void LinearStability :: terminateLinStatic(TimeStep *stepN) { Domain *domain = this->giveDomain(1); FILE *File; int j; File = this->giveOutputStream(); stepN->setTime(0.); fprintf(File, "\nOutput for time % .3e \n\n", stepN->giveTargetTime() ); fprintf(File, "Linear static:\n\n"); int nnodes = domain->giveNumberOfDofManagers(); if ( requiresUnknownsDictionaryUpdate() ) { for ( j = 1; j <= nnodes; j++ ) { this->updateDofUnknownsDictionary(domain->giveDofManager(j), stepN); } } for ( j = 1; j <= nnodes; j++ ) { domain->giveDofManager(j)->updateYourself(stepN); domain->giveDofManager(j)->printOutputAt(File, stepN); } # ifdef VERBOSE VERBOSE_PRINT0("Updated nodes & sides ", nnodes) # endif Element *elem; int nelem = domain->giveNumberOfElements(); for ( j = 1; j <= nelem; j++ ) { elem = domain->giveElement(j); elem->updateInternalState(stepN); elem->updateYourself(stepN); elem->printOutputAt(File, stepN); } # ifdef VERBOSE VERBOSE_PRINT0("Updated Elements ", nelem) # endif fprintf(File, "\n"); /* * // save context if required * // default - save only if ALWAYS is set ( see cltypes.h ) * * if ((domain->giveContextOutputMode() == COM_Always ) || * (domain->giveContextOutputMode() == COM_Required )) { * this->saveContext(NULL); * } * else if (domain->giveContextOutputMode() == COM_UserDefined ) { * if (stepN->giveNumber()%domain->giveContextOutputStep() == 0) * this->saveContext(NULL); * } */ this->printReactionForces(stepN, 1); }
void StructuralEngngModel :: printReactionForces(TimeStep *tStep, int di) // // computes and prints reaction forces in all supported or restrained dofs // { // // Sum all equivalent forces for all connected elements // int i, numRestrDofs = 0; IntArray ielemDofMask; FloatArray reactions; IntArray dofManMap, dofMap, eqnMap; Domain *domain = this->giveDomain(di); // test if solution step output is active if ( !domain->giveOutputManager()->testTimeStepOutput(tStep) ) { return; } FILE *outputStream = this->giveOutputStream(); // map contains corresponding dofmanager and dofs numbers corresponding to prescribed equations // sorted according to dofmanger number and as a minor crit. according to dof number // this is necessary for extractor, since the sorted output is expected this->buildReactionTable(dofManMap, dofMap, eqnMap, tStep, di); // // print header // fprintf(outputStream, "\n\n\tR E A C T I O N S O U T P U T:\n\t_______________________________\n\n\n"); numRestrDofs = this->giveNumberOfPrescribedDomainEquations(di, EID_MomentumBalance); reactions.resize(numRestrDofs); // compute reaction forces this->computeReaction(reactions, tStep, di); // // loop over reactions and print them // for ( i = 1; i <= numRestrDofs; i++ ) { if ( domain->giveOutputManager()->testDofManOutput(dofManMap.at(i), tStep) ) { //fprintf(outputStream,"\tNode %8d iDof %2d reaction % .4e\n",dofManMap.at(i), dofMap.at(i),reactions.at(eqnMap.at(i))); #if defined ( __PARALLEL_MODE ) || defined ( __ENABLE_COMPONENT_LABELS ) fprintf( outputStream, "\tNode %8d iDof %2d reaction % .4e [bc-id: %d]\n", domain->giveDofManager( dofManMap.at(i) )->giveLabel(), dofMap.at(i), reactions.at( eqnMap.at(i) ), domain->giveDofManager( dofManMap.at(i) )->giveDof( dofMap.at(i) )->giveBcId() ); #else fprintf( outputStream, "\tNode %8d iDof %2d reaction % .4e [bc-id: %d]\n", dofManMap.at(i), dofMap.at(i), reactions.at( eqnMap.at(i) ), domain->giveDofManager( dofManMap.at(i) )->giveDof( dofMap.at(i) )->giveBcId() ); #endif } } }
void EigenValueDynamic :: terminate(TimeStep *tStep) { Domain *domain = this->giveDomain(1); FILE *outputStream = this->giveOutputStream(); int i, j; // print loadcase header fprintf(outputStream, "\nOutput for time % .3e \n\n", 1.0); // print eigen values on output fprintf(outputStream, "\n\nEigen Values (Omega^2) are:\n-----------------\n"); for ( i = 1; i <= numberOfRequiredEigenValues; i++ ) { fprintf( outputStream, "%15.8e ", eigVal.at(i) ); if ( ( i % 5 ) == 0 ) { fprintf(outputStream, "\n"); } } fprintf(outputStream, "\n\n"); int nnodes = domain->giveNumberOfDofManagers(); for ( i = 1; i <= numberOfRequiredEigenValues; i++ ) { fprintf(outputStream, "\nOutput for eigen value no. % .3e \n", ( double ) i); fprintf( outputStream, "Printing eigen vector no. %d, corresponding eigen value is %15.8e\n\n", i, eigVal.at(i) ); tStep->setTime( ( double ) i ); // we use time as intrinsic eigen value index if ( this->requiresUnknownsDictionaryUpdate() ) { for ( j = 1; j <= nnodes; j++ ) { this->updateDofUnknownsDictionary(domain->giveDofManager(j), tStep); } } for ( j = 1; j <= nnodes; j++ ) { domain->giveDofManager(j)->updateYourself(tStep); domain->giveDofManager(j)->printOutputAt(outputStream, tStep); } } # ifdef VERBOSE VERBOSE_PRINT0("Updated nodes & sides ", nnodes) # endif for ( i = 1; i <= numberOfRequiredEigenValues; i++ ) { // export using export manager tStep->setTime( ( double ) i ); // we use time as intrinsic eigen value index tStep->setNumber(i); exportModuleManager->doOutput(tStep); } fflush( this->giveOutputStream() ); this->saveStepContext(tStep); }
void LinearStability :: terminate(TimeStep *stepN) { Domain *domain = this->giveDomain(1); FILE *outputStream = this->giveOutputStream(); //FloatArray *eigv; // Element *elem; int i, j; // print eigen values on output fprintf(outputStream, "\nLinear Stability:"); fprintf(outputStream, "\nEigen Values are:\n-----------------\n"); for ( i = 1; i <= numberOfRequiredEigenValues; i++ ) { fprintf( outputStream, "%15.8e ", eigVal.at(i) ); if ( ( i % 5 ) == 0 ) { fprintf(outputStream, "\n"); } } fprintf(outputStream, "\n\n"); int nnodes = domain->giveNumberOfDofManagers(); for ( i = 1; i <= numberOfRequiredEigenValues; i++ ) { fprintf(outputStream, "\nOutput for eigen value no. % .3e \n", ( double ) i); fprintf( outputStream, "Printing eigen vector no. %d, corresponding eigen value is %15.8e\n\n", i, eigVal.at(i) ); stepN->setTime( ( double ) i ); if ( this->requiresUnknownsDictionaryUpdate() ) { for ( j = 1; j <= nnodes; j++ ) { this->updateDofUnknownsDictionary(domain->giveDofManager(j), stepN); } } for ( j = 1; j <= nnodes; j++ ) { domain->giveDofManager(j)->updateYourself(stepN); domain->giveDofManager(j)->printOutputAt(outputStream, stepN); } stepN->setNumber( i ); exportModuleManager->doOutput(stepN); } # ifdef VERBOSE VERBOSE_PRINT0("Updated nodes & sides ", nnodes) # endif fflush(this->giveOutputStream()); // save context if required this->saveStepContext(stepN); }
// project solutionVector to DoF unknowns dictionary void DofDistributedPrimaryField :: update(ValueModeType mode, TimeStep *tStep, FloatArray &vectorToStore) { Domain *domain = emodel->giveDomain(domainIndx); int nnodes = domain->giveNumberOfDofManagers(); for ( int j = 1; j <= nnodes; j++ ) { DofManager *inode = domain->giveDofManager(j); for ( Dof *iDof: *inode ) { int eqNum = iDof->__giveEquationNumber(); double val; if ( mode == VM_Total ) { if ( iDof->hasBc(tStep) ) { // boundary condition val = iDof->giveBcValue(VM_Total, tStep); } else { //vect = this->UnknownsField->giveSolutionVector(tStep); val = vectorToStore.at(eqNum); } } else { //all other modes, e.g. VM_RhsTotal if ( !eqNum ) { val = 0.; //assume that 0's are present in the beginning of node initiation } else { val = vectorToStore.at(eqNum); } } iDof->updateUnknownsDictionary(tStep, mode, val); } } }
int NonLinearDynamic :: estimateMaxPackSize(IntArray &commMap, DataStream &buff, int packUnpackType) { int count = 0, pcount = 0; Domain *domain = this->giveDomain(1); if ( packUnpackType == 0 ) { ///@todo Fix this old ProblemCommMode__NODE_CUT value for ( int map: commMap ) { DofManager *dman = domain->giveDofManager( map ); for ( Dof *dof: *dman ) { if ( dof->isPrimaryDof() && ( dof->__giveEquationNumber() ) ) { count++; } else { pcount++; } } } return ( buff.givePackSizeOfDouble(1) * max(count, pcount) ); } else if ( packUnpackType == 1 ) { for ( int map: commMap ) { count += domain->giveElement( map )->estimatePackSize(buff); } return count; } return 0; }
int StructuralEngngModel :: packDofManagers(FloatArray *src, ProcessCommunicator &processComm, bool prescribedEquations) { int result = 1; int i, size; int j, ndofs, eqNum; Domain *domain = this->giveDomain(1); IntArray const *toSendMap = processComm.giveToSendMap(); ProcessCommunicatorBuff *pcbuff = processComm.giveProcessCommunicatorBuff(); DofManager *dman; Dof *jdof; size = toSendMap->giveSize(); for ( i = 1; i <= size; i++ ) { dman = domain->giveDofManager( toSendMap->at(i) ); ndofs = dman->giveNumberOfDofs(); for ( j = 1; j <= ndofs; j++ ) { jdof = dman->giveDof(j); if ( prescribedEquations ) { eqNum = jdof->__givePrescribedEquationNumber(); } else { eqNum = jdof->__giveEquationNumber(); } if ( jdof->isPrimaryDof() && eqNum ) { result &= pcbuff->packDouble( src->at(eqNum) ); } } } return result; }
void StructuralEngngModel :: updateInternalState(TimeStep *stepN) { int j, nnodes; Domain *domain; for ( int idomain = 1; idomain <= this->giveNumberOfDomains(); idomain++ ) { domain = this->giveDomain(idomain); nnodes = domain->giveNumberOfDofManagers(); if ( requiresUnknownsDictionaryUpdate() ) { for ( j = 1; j <= nnodes; j++ ) { this->updateDofUnknownsDictionary(domain->giveDofManager(j), stepN); } } if ( internalVarUpdateStamp != stepN->giveSolutionStateCounter() ) { int nelem = domain->giveNumberOfElements(); for ( j = 1; j <= nelem; j++ ) { domain->giveElement(j)->updateInternalState(stepN); } internalVarUpdateStamp = stepN->giveSolutionStateCounter(); } } }
int FreeWarping :: estimateMaxPackSize(IntArray &commMap, DataStream &buff, int packUnpackType) { int count = 0, pcount = 0; Domain *domain = this->giveDomain(1); if ( packUnpackType == 0 ) { ///@todo Fix this old ProblemCommMode__NODE_CUT value for ( int map: commMap ) { for ( Dof *jdof: *domain->giveDofManager( map ) ) { if ( jdof->isPrimaryDof() && ( jdof->__giveEquationNumber() ) ) { count++; } else { pcount++; } } } // -------------------------------------------------------------------------------- // only pcount is relevant here, since only prescribed components are exchanged !!!! // -------------------------------------------------------------------------------- return ( buff.givePackSizeOfDouble(1) * pcount ); } else if ( packUnpackType == 1 ) { for ( int map: commMap ) { count += domain->giveElement( map )->estimatePackSize(buff); } return count; } return 0; }
void XFEMStatic :: buildDofMap() { printf("Building dof map.\n"); mDofEqnNumMap.clear(); for ( int domainIndex = 1; domainIndex <= this->giveNumberOfDomains(); domainIndex++ ) { Domain *domain = this->giveDomain(domainIndex); for ( int dManIndex = 1; dManIndex <= domain->giveNumberOfDofManagers(); dManIndex++ ) { DofManager *dMan = domain->giveDofManager(dManIndex); for ( Dof *dof: *dMan ) { int eqNum = dof->giveEqn(); if ( eqNum > 0 ) { std :: vector< int > key(3); key [ 0 ] = domainIndex; key [ 1 ] = dManIndex; key [ 2 ] = dof->giveDofID(); mDofEqnNumMap [ key ] = eqNum; } } } } }
void NonLinearStatic :: unpackMigratingData(TimeStep *tStep) { Domain *domain = this->giveDomain(1); int ndofman = domain->giveNumberOfDofManagers(); //int myrank = this->giveRank(); // resize target arrays int neq = this->giveNumberOfDomainEquations( 1, EModelDefaultEquationNumbering() ); totalDisplacement.resize(neq); incrementOfDisplacement.resize(neq); incrementalLoadVector.resize(neq); initialLoadVector.resize(neq); initialLoadVectorOfPrescribed.resize( giveNumberOfDomainEquations( 1, EModelDefaultPrescribedEquationNumbering() ) ); incrementalLoadVectorOfPrescribed.resize( giveNumberOfDomainEquations( 1, EModelDefaultPrescribedEquationNumbering() ) ); for ( int idofman = 1; idofman <= ndofman; idofman++ ) { DofManager *_dm = domain->giveDofManager(idofman); for ( Dof *_dof: *_dm ) { if ( _dof->isPrimaryDof() ) { int _eq; if ( ( _eq = _dof->__giveEquationNumber() ) ) { // pack values in solution vectors totalDisplacement.at(_eq) = _dof->giveUnknownsDictionaryValue( tStep, VM_Total ); initialLoadVector.at(_eq) = _dof->giveUnknownsDictionaryValue( tStep, VM_RhsInitial ); incrementalLoadVector.at(_eq) = _dof->giveUnknownsDictionaryValue( tStep, VM_RhsIncremental ); #if 0 // debug print if ( _dm->giveParallelMode() == DofManager_shared ) { fprintf(stderr, "[%d] Shared: %d(%d) -> %d\n", myrank, idofman, idof, _eq); } else { fprintf(stderr, "[%d] Local : %d(%d) -> %d\n", myrank, idofman, idof, _eq); } #endif } else if ( ( _eq = _dof->__givePrescribedEquationNumber() ) ) { // pack values in prescribed solution vectors initialLoadVectorOfPrescribed.at(_eq) = _dof->giveUnknownsDictionaryValue( tStep, VM_RhsInitial ); incrementalLoadVectorOfPrescribed.at(_eq) = _dof->giveUnknownsDictionaryValue( tStep, VM_RhsIncremental ); #if 0 // debug print fprintf(stderr, "[%d] %d(%d) -> %d\n", myrank, idofman, idof, -_eq); #endif } } // end primary dof } // end dof loop } // end dofman loop this->initializeCommMaps(true); nMethod->reinitialize(); // reinitialize error estimator (if any) if ( this->giveDomainErrorEstimator(1) ) { this->giveDomainErrorEstimator(1)->reinitialize(); } initFlag = true; }
void MatlabExportModule :: doOutputData(TimeStep *tStep, FILE *FID) { Domain *domain = emodel->giveDomain(1); std :: vector< int >DofIDList; std :: vector< int > :: iterator it; std :: vector< std :: vector< double > * >valuesList; std :: vector< double > *values; for ( int i = 1; i <= domain->giveNumberOfDofManagers(); i++ ) { for ( int j = 1; j <= domain->giveDofManager(i)->giveNumberOfDofs(); j++ ) { Dof *thisDof; thisDof = domain->giveDofManager(i)->giveDof(j); it = std :: find( DofIDList.begin(), DofIDList.end(), thisDof->giveDofID() ); if ( it == DofIDList.end() ) { DofIDList.push_back( thisDof->giveDofID() ); values = new( std :: vector< double > ); valuesList.push_back(values); } else { int pos = it - DofIDList.begin(); values = valuesList.at(pos); } double value = thisDof->giveUnknown(EID_MomentumBalance, VM_Total, tStep); values->push_back(value); } } fprintf(FID, "\tdata.DofIDs=["); for ( size_t i = 0; i < DofIDList.size(); i++ ) { fprintf( FID, "%u, ", DofIDList.at(i) ); } fprintf(FID, "];\n"); for ( size_t i = 0; i < valuesList.size(); i++ ) { fprintf(FID, "\tdata.a{%lu}=[", static_cast<long unsigned int>(i) + 1); for ( size_t j = 0; j < valuesList.at(i)->size(); j++ ) { fprintf( FID, "%f,", valuesList.at(i)->at(j) ); } fprintf(FID, "];\n"); } }
void StructuralEngngModel :: printReactionForces(TimeStep *tStep, int di) // // computes and prints reaction forces in all supported or restrained dofs // { IntArray ielemDofMask; FloatArray reactions; IntArray dofManMap, dofidMap, eqnMap; Domain *domain = this->giveDomain(di); // test if solution step output is active if ( !domain->giveOutputManager()->testTimeStepOutput(tStep) ) { return; } FILE *outputStream = this->giveOutputStream(); // map contains corresponding dofmanager and dofs numbers corresponding to prescribed equations // sorted according to dofmanger number and as a minor crit. according to dof number // this is necessary for extractor, since the sorted output is expected this->buildReactionTable(dofManMap, dofidMap, eqnMap, tStep, di); // // print header // fprintf(outputStream, "\n\n\tR E A C T I O N S O U T P U T:\n\t_______________________________\n\n\n"); // compute reaction forces this->computeReaction(reactions, tStep, di); // // loop over reactions and print them // for ( int i = 1; i <= dofManMap.giveSize(); i++ ) { if ( domain->giveOutputManager()->testDofManOutput(dofManMap.at(i), tStep) ) { fprintf( outputStream, "\tNode %8d iDof %2d reaction % .4e [bc-id: %d]\n", domain->giveDofManager( dofManMap.at(i) )->giveLabel(), dofidMap.at(i), reactions.at( eqnMap.at(i) ), domain->giveDofManager( dofManMap.at(i) )->giveDofWithID( dofidMap.at(i) )->giveBcId() ); } } }
int NonLinearDynamic :: estimateMaxPackSize(IntArray &commMap, CommunicationBuffer &buff, int packUnpackType) { int mapSize = commMap.giveSize(); int i, j, ndofs, count = 0, pcount = 0; IntArray locationArray; Domain *domain = this->giveDomain(1); DofManager *dman; Dof *jdof; if ( packUnpackType == ProblemCommMode__ELEMENT_CUT ) { for ( i = 1; i <= mapSize; i++ ) { count += domain->giveDofManager( commMap.at(i) )->giveNumberOfDofs(); } return ( buff.givePackSize(MPI_DOUBLE, 1) * count ); } else if ( packUnpackType == ProblemCommMode__NODE_CUT ) { for ( i = 1; i <= mapSize; i++ ) { ndofs = ( dman = domain->giveDofManager( commMap.at(i) ) )->giveNumberOfDofs(); for ( j = 1; j <= ndofs; j++ ) { jdof = dman->giveDof(j); if ( jdof->isPrimaryDof() && ( jdof->__giveEquationNumber() ) ) { count++; } else { pcount++; } } } //printf ("\nestimated count is %d\n",count); return ( buff.givePackSize(MPI_DOUBLE, 1) * max(count, pcount) ); } else if ( packUnpackType == ProblemCommMode__REMOTE_ELEMENT_MODE ) { for ( i = 1; i <= mapSize; i++ ) { count += domain->giveElement( commMap.at(i) )->estimatePackSize(buff); } return count; } return 0; }
int FreeWarping :: estimateMaxPackSize(IntArray &commMap, CommunicationBuffer &buff, int packUnpackType) { int count = 0, pcount = 0; IntArray locationArray; Domain *domain = this->giveDomain(1); if ( packUnpackType == ProblemCommMode__ELEMENT_CUT ) { for ( int map: commMap ) { count += domain->giveDofManager( map )->giveNumberOfDofs(); } return ( buff.givePackSize(MPI_DOUBLE, 1) * count ); } else if ( packUnpackType == ProblemCommMode__NODE_CUT ) { for ( int map: commMap ) { for ( Dof *jdof: *domain->giveDofManager( map ) ) { if ( jdof->isPrimaryDof() && ( jdof->__giveEquationNumber() ) ) { count++; } else { pcount++; } } } // -------------------------------------------------------------------------------- // only pcount is relevant here, since only prescribed components are exchanged !!!! // -------------------------------------------------------------------------------- return ( buff.givePackSize(MPI_DOUBLE, 1) * pcount ); } else if ( packUnpackType == ProblemCommMode__REMOTE_ELEMENT_MODE ) { for ( int map: commMap ) { count += domain->giveElement( map )->estimatePackSize(buff); } return count; } return 0; }
void MatlabExportModule :: computeArea() { Domain *domain = emodel->giveDomain(1); xmax = domain->giveDofManager(1)->giveCoordinate(1); xmin = xmax; ymax = domain->giveDofManager(1)->giveCoordinate(2); ymin = ymax; for ( int i = 1; i <= domain->giveNumberOfDofManagers(); i++ ) { double x = domain->giveDofManager(i)->giveCoordinate(1); double y = domain->giveDofManager(i)->giveCoordinate(2); xmax = max(xmax, x); xmin = min(xmin, x); ymax = max(ymax, y); ymin = min(ymin, y); } for ( int i = 1; i <= domain->giveNumberOfElements(); i++ ) { Area = Area + domain->giveElement(i)->computeArea(); } }
int NonLinearDynamic :: estimateMaxPackSize(IntArray &commMap, CommunicationBuffer &buff, int packUnpackType) { int count = 0, pcount = 0; IntArray locationArray; Domain *domain = this->giveDomain(1); if ( packUnpackType == ProblemCommMode__ELEMENT_CUT ) { for ( int map: commMap ) { count += domain->giveDofManager( map )->giveNumberOfDofs(); } return ( buff.givePackSize(MPI_DOUBLE, 1) * count ); } else if ( packUnpackType == ProblemCommMode__NODE_CUT ) { for ( int map: commMap ) { DofManager *dman = domain->giveDofManager( map ); for ( Dof *dof: *dman ) { if ( dof->isPrimaryDof() && ( dof->__giveEquationNumber() ) ) { count++; } else { pcount++; } } } //printf ("\nestimated count is %d\n",count); return ( buff.givePackSize(MPI_DOUBLE, 1) * max(count, pcount) ); } else if ( packUnpackType == ProblemCommMode__REMOTE_ELEMENT_MODE ) { for ( int map: commMap ) { count += domain->giveElement( map )->estimatePackSize(buff); } return count; } return 0; }
void MatlabExportModule :: doOutputMesh(TimeStep *tStep, FILE *FID) { Domain *domain = emodel->giveDomain(1); fprintf(FID, "\tmesh.p=["); for ( int i = 1; i <= domain->giveNumberOfDofManagers(); i++ ) { double x = domain->giveDofManager(i)->giveCoordinate(1), y = domain->giveDofManager(i)->giveCoordinate(2); fprintf(FID, "%f,%f;", x, y); } fprintf(FID, "]';\n"); fprintf(FID, "\tmesh.t=["); for ( int i = 1; i <= domain->giveNumberOfElements(); i++ ) { for ( int j = 1; j <= domain->giveElement(i)->giveNumberOfDofManagers(); j++ ) { fprintf( FID, "%u,", domain->giveElement(i)->giveDofManagerNumber(j) ); } fprintf(FID, ";"); } fprintf(FID, "]';\n"); }
void PetscNatural2LocalOrdering :: init(EngngModel *emodel, EquationID ut, int di, EquationType et) { Domain *d = emodel->giveDomain(di); int i, j, n_eq = 0, ndofs, ndofman = d->giveNumberOfDofManagers(), loc_eq = 1; bool lFlag; DofManager *dman; EModelDefaultEquationNumbering dn; EModelDefaultPrescribedEquationNumbering dpn; // determine number of local eqs + number of those shared DOFs which are numbered by receiver // shared dofman is numbered on partition with lovest rank number if ( et == et_standard ) { n2l.resize( emodel->giveNumberOfEquations(ut) ); } else { n2l.resize( emodel->giveNumberOfPrescribedEquations(ut) ); } for ( i = 1; i <= ndofman; i++ ) { dman = d->giveDofManager(i); lFlag = isLocal(dman); ndofs = dman->giveNumberOfDofs(); for ( j = 1; j <= ndofs; j++ ) { if ( dman->giveDof(j)->isPrimaryDof() ) { if ( et == et_standard ) { n_eq = dman->giveDof(j)->giveEquationNumber(dn); } else { n_eq = dman->giveDof(j)->giveEquationNumber(dpn); } if ( n_eq == 0 ) { continue; } if ( lFlag ) { n2l.at(n_eq) = loc_eq++; } else { n2l.at(n_eq) = 0; } } } } }
void NonLinearDynamic :: packMigratingData(TimeStep *tStep) { Domain *domain = this->giveDomain(1); int ndofman = domain->giveNumberOfDofManagers(), _eq; for ( int idofman = 1; idofman <= ndofman; idofman++ ) { DofManager *_dm = domain->giveDofManager(idofman); for ( Dof *_dof: *_dm ) { if ( _dof->isPrimaryDof() ) { if ( ( _eq = _dof->__giveEquationNumber() ) ) { // pack values in solution vectors _dof->updateUnknownsDictionary( tStep, VM_Total, totalDisplacement.at(_eq) ); } } } } }
void NonLinearStatic :: packMigratingData(TimeStep *atTime) { Domain *domain = this->giveDomain(1); int ndofman = domain->giveNumberOfDofManagers(), ndofs, idofman, idof, _eq; DofManager *_dm; Dof *_dof; bool initialLoadVectorEmpty = initialLoadVector.isEmpty(); bool initialLoadVectorOfPrescribedEmpty = initialLoadVectorOfPrescribed.isEmpty(); for ( idofman = 1; idofman <= ndofman; idofman++ ) { _dm = domain->giveDofManager(idofman); ndofs = _dm->giveNumberOfDofs(); for ( idof = 1; idof <= ndofs; idof++ ) { _dof = _dm->giveDof(idof); if ( _dof->isPrimaryDof() ) { if ( ( _eq = _dof->__giveEquationNumber() ) ) { // pack values in solution vectors _dof->updateUnknownsDictionary( atTime, EID_MomentumBalance, VM_Total, totalDisplacement.at(_eq) ); if ( initialLoadVectorEmpty ) { _dof->updateUnknownsDictionary(atTime, EID_MomentumBalance, VM_RhsInitial, 0.0); } else { _dof->updateUnknownsDictionary( atTime, EID_MomentumBalance, VM_RhsInitial, initialLoadVector.at(_eq) ); } _dof->updateUnknownsDictionary( atTime, EID_MomentumBalance, VM_RhsIncremental, incrementalLoadVector.at(_eq) ); } else if ( ( _eq = _dof->__givePrescribedEquationNumber() ) ) { // pack values in prescribed solution vectors if ( initialLoadVectorOfPrescribedEmpty ) { _dof->updateUnknownsDictionary(atTime, EID_MomentumBalance, VM_RhsInitial, 0.0); } else { _dof->updateUnknownsDictionary( atTime, EID_MomentumBalance, VM_RhsInitial, initialLoadVectorOfPrescribed.at(_eq) ); } _dof->updateUnknownsDictionary( atTime, EID_MomentumBalance, VM_RhsIncremental, incrementalLoadVectorOfPrescribed.at(_eq) ); } } // end primary dof } // end dof loop } // end dofman loop }
void XFEMStatic :: setValsFromDofMap(FloatArray &oArray, const FloatArray &iArray) { int neq = 0; for ( int domainIndex = 1; domainIndex <= this->giveNumberOfDomains(); domainIndex++ ) { neq += this->giveNumberOfDomainEquations( domainIndex, EModelDefaultEquationNumbering() ); } int numEqOld = iArray.giveSize(); printf("Setting values from dof map. neq: %d numEqOld: %d\n", neq, numEqOld); oArray.resize(neq); oArray.zero(); for ( int domainIndex = 1; domainIndex <= this->giveNumberOfDomains(); domainIndex++ ) { Domain *domain = this->giveDomain(domainIndex); for ( int dManIndex = 1; dManIndex <= domain->giveNumberOfDofManagers(); dManIndex++ ) { DofManager *dMan = domain->giveDofManager(dManIndex); for ( Dof *dof: *dMan ) { int eqNumNew = dof->giveEqn(); if ( eqNumNew > 0 ) { std :: vector< int > key(3); key [ 0 ] = domainIndex; key [ 1 ] = dManIndex; key [ 2 ] = dof->giveDofID(); if ( mDofEqnNumMap.find(key) != mDofEqnNumMap.end() ) { int eqNumOld = mDofEqnNumMap [ key ]; // printf("eqNumNew: %d eqNumOld: %d\n", eqNumNew, eqNumOld); if ( eqNumOld > 0 && eqNumOld <= numEqOld ) { oArray.at(eqNumNew) = iArray.at(eqNumOld); } } } } } } }
int StructuralEngngModel :: unpackDofManagers(FloatArray *dest, ProcessCommunicator &processComm, bool prescribedEquations) { int result = 1; int i, size; int j, ndofs, eqNum; Domain *domain = this->giveDomain(1); dofManagerParallelMode dofmanmode; IntArray const *toRecvMap = processComm.giveToRecvMap(); ProcessCommunicatorBuff *pcbuff = processComm.giveProcessCommunicatorBuff(); DofManager *dman; Dof *jdof; double value; size = toRecvMap->giveSize(); for ( i = 1; i <= size; i++ ) { dman = domain->giveDofManager( toRecvMap->at(i) ); ndofs = dman->giveNumberOfDofs(); dofmanmode = dman->giveParallelMode(); for ( j = 1; j <= ndofs; j++ ) { jdof = dman->giveDof(j); if ( prescribedEquations ) { eqNum = jdof->__givePrescribedEquationNumber(); } else { eqNum = jdof->__giveEquationNumber(); } if ( jdof->isPrimaryDof() && eqNum ) { result &= pcbuff->unpackDouble(value); if ( dofmanmode == DofManager_shared ) { dest->at(eqNum) += value; } else if ( dofmanmode == DofManager_remote ) { dest->at(eqNum) = value; } else { _error("unpackReactions: unknown dof namager parallel mode"); } } } } return result; }
void StructuralEngngModel :: updateInternalState(TimeStep *tStep) { int nnodes; Domain *domain; for ( int idomain = 1; idomain <= this->giveNumberOfDomains(); idomain++ ) { domain = this->giveDomain(idomain); nnodes = domain->giveNumberOfDofManagers(); if ( requiresUnknownsDictionaryUpdate() ) { for ( int j = 1; j <= nnodes; j++ ) { this->updateDofUnknownsDictionary(domain->giveDofManager(j), tStep); } } int nbc = domain->giveNumberOfBoundaryConditions(); for ( int i = 1; i <= nbc; ++i ) { GeneralBoundaryCondition *bc = domain->giveBc(i); ActiveBoundaryCondition *abc; if ( ( abc = dynamic_cast< ActiveBoundaryCondition * >(bc) ) ) { int ndman = abc->giveNumberOfInternalDofManagers(); for ( int j = 1; j <= ndman; j++ ) { this->updateDofUnknownsDictionary(abc->giveInternalDofManager(j), tStep); } } } if ( internalVarUpdateStamp != tStep->giveSolutionStateCounter() ) { int nelem = domain->giveNumberOfElements(); for ( int j = 1; j <= nelem; j++ ) { domain->giveElement(j)->updateInternalState(tStep); } internalVarUpdateStamp = tStep->giveSolutionStateCounter(); } } }
void DofDistributedPrimaryField :: initialize(ValueModeType mode, TimeStep *tStep, FloatArray &answer, const UnknownNumberingScheme &s) { Domain *domain = emodel->giveDomain(domainIndx); int neq = emodel->giveNumberOfDomainEquations(domainIndx, s); int nnodes = domain->giveNumberOfDofManagers(); answer.resize(neq); answer.zero(); for ( int j = 1; j <= nnodes; j++ ) { DofManager *inode = domain->giveDofManager(j); for ( Dof *iDof: *inode ) { int eqNum = iDof->__giveEquationNumber(); double val; if ( eqNum ) { iDof->giveUnknownsDictionaryValue(tStep, mode, val); answer.at(eqNum) = val; //answer.at(eqNum) = iDof->giveUnknown( mode, tStep); } } } }
void StructuralEngngModel :: buildReactionTable(IntArray &restrDofMans, IntArray &restrDofs, IntArray &eqn, TimeStep *tStep, int di) { // determine number of restrained dofs Domain *domain = this->giveDomain(di); int numRestrDofs = this->giveNumberOfPrescribedDomainEquations(di, EID_MomentumBalance); int ndofMan = domain->giveNumberOfDofManagers(); int i, j, indofs, rindex, count = 0; DofManager *inode; Dof *jdof; // initialize corresponding dofManagers and dofs for each restrained dof restrDofMans.resize(numRestrDofs); restrDofs.resize(numRestrDofs); eqn.resize(numRestrDofs); for ( i = 1; i <= ndofMan; i++ ) { inode = domain->giveDofManager(i); indofs = inode->giveNumberOfDofs(); for ( j = 1; j <= indofs; j++ ) { jdof = inode->giveDof(j); if ( ( jdof->giveClassID() != SimpleSlaveDofClass ) && ( jdof->hasBc(tStep) ) ) { // skip slave dofs rindex = jdof->__givePrescribedEquationNumber(); if ( rindex ) { count++; restrDofMans.at(count) = i; restrDofs.at(count) = j; eqn.at(count) = rindex; } else { // NullDof has no equation number and no prescribed equation number //_error ("No prescribed equation number assigned to supported DOF"); } } } } }
void StructuralEngngModel :: buildReactionTable(IntArray &restrDofMans, IntArray &restrDofs, IntArray &eqn, TimeStep *tStep, int di) { // determine number of restrained dofs Domain *domain = this->giveDomain(di); int numRestrDofs = this->giveNumberOfDomainEquations( di, EModelDefaultPrescribedEquationNumbering() ); int ndofMan = domain->giveNumberOfDofManagers(); int rindex, count = 0; // initialize corresponding dofManagers and dofs for each restrained dof restrDofMans.resize(numRestrDofs); restrDofs.resize(numRestrDofs); eqn.resize(numRestrDofs); for ( int i = 1; i <= ndofMan; i++ ) { DofManager *inode = domain->giveDofManager(i); for ( Dof *jdof: *inode ) { if ( jdof->isPrimaryDof() && ( jdof->hasBc(tStep) ) ) { // skip slave dofs rindex = jdof->__givePrescribedEquationNumber(); if ( rindex ) { count++; restrDofMans.at(count) = i; restrDofs.at(count) = jdof->giveDofID(); eqn.at(count) = rindex; } else { // NullDof has no equation number and no prescribed equation number //_error("No prescribed equation number assigned to supported DOF"); } } } } // Trim to size. restrDofMans.resizeWithValues(count); restrDofs.resizeWithValues(count); eqn.resizeWithValues(count); }
void NonStationaryTransportProblem :: applyIC(TimeStep *stepWhenIcApply) { Domain *domain = this->giveDomain(1); int neq = this->giveNumberOfEquations(EID_ConservationEquation); FloatArray *solutionVector; double val; #ifdef VERBOSE OOFEM_LOG_INFO("Applying initial conditions\n"); #endif int nDofs, j, k, jj; int nman = domain->giveNumberOfDofManagers(); DofManager *node; Dof *iDof; UnknownsField->advanceSolution(stepWhenIcApply); solutionVector = UnknownsField->giveSolutionVector(stepWhenIcApply); solutionVector->resize(neq); solutionVector->zero(); for ( j = 1; j <= nman; j++ ) { node = domain->giveDofManager(j); nDofs = node->giveNumberOfDofs(); for ( k = 1; k <= nDofs; k++ ) { // ask for initial values obtained from // bc (boundary conditions) and ic (initial conditions) iDof = node->giveDof(k); if ( !iDof->isPrimaryDof() ) { continue; } jj = iDof->__giveEquationNumber(); if ( jj ) { val = iDof->giveUnknown(EID_ConservationEquation, VM_Total, stepWhenIcApply); solutionVector->at(jj) = val; //update in dictionary, if the problem is growing/decreasing if ( this->changingProblemSize ) { iDof->updateUnknownsDictionary(stepWhenIcApply, EID_MomentumBalance, VM_Total, val); } } } } int nelem = domain->giveNumberOfElements(); //project initial temperature to integration points // for ( j = 1; j <= nelem; j++ ) { // domain->giveElement(j)->updateInternalState(stepWhenIcApply); // } #ifdef __CEMHYD_MODULE // Not relevant in linear case, but needed for CemhydMat for temperature averaging before solving balance equations // Update element state according to given ic TransportElement *element; CemhydMat *cem; for ( j = 1; j <= nelem; j++ ) { element = ( TransportElement * ) domain->giveElement(j); //assign status to each integration point on each element if ( element->giveMaterial()->giveClassID() == CemhydMatClass ) { element->giveMaterial()->initMaterial(element); //create microstructures and statuses on specific GPs element->updateInternalState(stepWhenIcApply); //store temporary unequilibrated temperature element->updateYourself(stepWhenIcApply); //store equilibrated temperature cem = ( CemhydMat * ) element->giveMaterial(); cem->clearWeightTemperatureProductVolume(element); cem->storeWeightTemperatureProductVolume(element, stepWhenIcApply); } } //perform averaging on each material instance of CemhydMatClass int nmat = domain->giveNumberOfMaterialModels(); for ( j = 1; j <= nmat; j++ ) { if ( domain->giveMaterial(j)->giveClassID() == CemhydMatClass ) { cem = ( CemhydMat * ) domain->giveMaterial(j); cem->averageTemperature(); } } #endif //__CEMHYD_MODULE }
void DEIDynamic :: solveYourselfAt(TimeStep *tStep) { // // creates system of governing eq's and solves them at given time step // // this is an explicit problem: we assemble governing equating at time t // and solution is obtained for time t+dt // // first assemble problem at current time step to obtain results in following // time step. // and then print results for this step also. // for first time step we need special start code Domain *domain = this->giveDomain(1); int nelem = domain->giveNumberOfElements(); int nman = domain->giveNumberOfDofManagers(); IntArray loc; Element *element; DofManager *node; Dof *iDof; int nDofs, neq; int i, k, n, j, jj, kk, init = 0; double coeff, maxDt, maxOmi, maxOm = 0., maxOmEl, c1, c2, c3; FloatMatrix charMtrx, charMtrx2; FloatArray previousDisplacementVector; neq = this->giveNumberOfEquations(EID_MomentumBalance); if ( tStep->giveNumber() == giveNumberOfFirstStep() ) { init = 1; #ifdef VERBOSE OOFEM_LOG_INFO("Assembling mass matrix\n"); #endif // // first step assemble mass Matrix // massMatrix.resize(neq); massMatrix.zero(); EModelDefaultEquationNumbering dn; for ( i = 1; i <= nelem; i++ ) { element = domain->giveElement(i); element->giveLocationArray(loc, EID_MomentumBalance, dn); element->giveCharacteristicMatrix(charMtrx, LumpedMassMatrix, tStep); // charMtrx.beLumpedOf(fullCharMtrx); element->giveCharacteristicMatrix(charMtrx2, StiffnessMatrix, tStep); // // assemble it manually // #ifdef DEBUG if ( ( n = loc.giveSize() ) != charMtrx.giveNumberOfRows() ) { _error("solveYourselfAt : dimension mismatch"); } #endif n = loc.giveSize(); maxOmEl = 0.; for ( j = 1; j <= n; j++ ) { if ( charMtrx.at(j, j) > ZERO_MASS ) { maxOmi = charMtrx2.at(j, j) / charMtrx.at(j, j); if ( init ) { maxOmEl = ( maxOmEl > maxOmi ) ? ( maxOmEl ) : ( maxOmi ); } } } maxOm = ( maxOm > maxOmEl ) ? ( maxOm ) : ( maxOmEl ); for ( j = 1; j <= n; j++ ) { jj = loc.at(j); if ( ( jj ) && ( charMtrx.at(j, j) <= ZERO_MASS ) ) { charMtrx.at(j, j) = charMtrx2.at(j, j) / maxOmEl; } } for ( j = 1; j <= n; j++ ) { jj = loc.at(j); if ( jj ) { massMatrix.at(jj) += charMtrx.at(j, j); } } } // if init - try to determine the best deltaT if ( init ) { maxDt = 2 / sqrt(maxOm); if ( deltaT > maxDt ) { OOFEM_LOG_RELEVANT("DEIDynamic: deltaT reduced to %e\n", maxDt); deltaT = maxDt; tStep->setTimeIncrement(deltaT); } } // // special init step - compute displacements at tstep 0 // displacementVector.resize(neq); displacementVector.zero(); nextDisplacementVector.resize(neq); nextDisplacementVector.zero(); velocityVector.resize(neq); velocityVector.zero(); accelerationVector.resize(neq); accelerationVector.zero(); for ( j = 1; j <= nman; j++ ) { node = domain->giveDofManager(j); nDofs = node->giveNumberOfDofs(); for ( k = 1; k <= nDofs; k++ ) { // ask for initial values obtained from // bc (boundary conditions) and ic (initial conditions) // now we are setting initial cond. for step -1. iDof = node->giveDof(k); if ( !iDof->isPrimaryDof() ) { continue; } jj = iDof->__giveEquationNumber(); if ( jj ) { nextDisplacementVector.at(jj) = iDof->giveUnknown(EID_MomentumBalance, VM_Total, tStep); // become displacementVector after init velocityVector.at(jj) = iDof->giveUnknown(EID_MomentumBalance, VM_Velocity, tStep); // accelerationVector = iDof->giveUnknown(AccelerartionVector,tStep) ; } } } for ( j = 1; j <= neq; j++ ) { nextDisplacementVector.at(j) -= velocityVector.at(j) * ( deltaT ); } return; } // end of init step #ifdef VERBOSE OOFEM_LOG_INFO("Assembling right hand side\n"); #endif c1 = ( 1. / ( deltaT * deltaT ) ); c2 = ( 1. / ( 2. * deltaT ) ); c3 = ( 2. / ( deltaT * deltaT ) ); previousDisplacementVector = displacementVector; displacementVector = nextDisplacementVector; // // assembling the element part of load vector // loadVector.resize( this->giveNumberOfEquations(EID_MomentumBalance) ); loadVector.zero(); this->assembleVector(loadVector, tStep, EID_MomentumBalance, ExternalForcesVector, VM_Total, EModelDefaultEquationNumbering(), domain); // // assembling additional parts of right hand side // EModelDefaultEquationNumbering dn; for ( i = 1; i <= nelem; i++ ) { element = domain->giveElement(i); element->giveLocationArray(loc, EID_MomentumBalance, dn); element->giveCharacteristicMatrix(charMtrx, StiffnessMatrix, tStep); n = loc.giveSize(); for ( j = 1; j <= n; j++ ) { jj = loc.at(j); if ( jj ) { for ( k = 1; k <= n; k++ ) { kk = loc.at(k); if ( kk ) { loadVector.at(jj) -= charMtrx.at(j, k) * displacementVector.at(kk); } } // // if init step - find minimum period of vibration in order to // determine maximal admissible time step // //maxOmi = charMtrx.at(j,j)/massMatrix.at(jj) ; //if (init) maxOm = (maxOm > maxOmi) ? (maxOm) : (maxOmi) ; } } } for ( j = 1; j <= neq; j++ ) { coeff = massMatrix.at(j); loadVector.at(j) += coeff * c3 * displacementVector.at(j) - coeff * ( c1 - dumpingCoef * c2 ) * previousDisplacementVector.at(j); } // // set-up numerical model // /* it is not necessary to call numerical method * approach used here is not good, but effective enough * inverse of diagonal mass matrix is done here */ // // call numerical model to solve arose problem - done locally here // #ifdef VERBOSE OOFEM_LOG_RELEVANT( "Solving [step number %8d, time %15e]\n", tStep->giveNumber(), tStep->giveTargetTime() ); #endif double prevD; for ( i = 1; i <= neq; i++ ) { prevD = previousDisplacementVector.at(i); nextDisplacementVector.at(i) = loadVector.at(i) / ( massMatrix.at(i) * ( c1 + dumpingCoef * c2 ) ); velocityVector.at(i) = nextDisplacementVector.at(i) - prevD; accelerationVector.at(i) = nextDisplacementVector.at(i) - 2. * displacementVector.at(i) + prevD; } accelerationVector.times(c1); velocityVector.times(c2); }
void MatlabExportModule :: doOutputReactionForces(TimeStep *tStep, FILE *FID) { int domainIndex = 1; Domain *domain = emodel->giveDomain( domainIndex ); FloatArray reactions; IntArray dofManMap, dofidMap, eqnMap; #ifdef __SM_MODULE StructuralEngngModel *strEngMod = dynamic_cast< StructuralEngngModel * >(emodel); if ( strEngMod ) { strEngMod->buildReactionTable(dofManMap, dofidMap, eqnMap, tStep, domainIndex); strEngMod->computeReaction(reactions, tStep, 1); } else #endif { OOFEM_ERROR("Cannot export reaction forces - only implemented for structural problems."); } // Set the nodes and elements to export based on sets if ( this->reactionForcesNodeSet > 0 ) { Set *set = domain->giveSet( this->reactionForcesNodeSet ); reactionForcesDofManList = set->giveNodeList(); } int numDofManToExport = this->reactionForcesDofManList.giveSize(); if ( numDofManToExport == 0 ) { // No dofMan's given - export every dMan with reaction forces for (int i = 1; i <= domain->giveNumberOfDofManagers(); i++) { if ( dofManMap.contains(i) ) { this->reactionForcesDofManList.followedBy(i); } } numDofManToExport = this->reactionForcesDofManList.giveSize(); } // Output header fprintf( FID, "\n %%%% Export of reaction forces \n\n" ); // Output the dofMan numbers that are exported fprintf( FID, "\tReactionForces.DofManNumbers = [" ); for ( int i = 1; i <= numDofManToExport; i++ ) { fprintf( FID, "%i ", this->reactionForcesDofManList.at(i) ); } fprintf( FID, "];\n" ); // Define the reaction forces as a cell object fprintf( FID, "\tReactionForces.ReactionForces = cell(%i,1); \n", numDofManToExport ); fprintf( FID, "\tReactionForces.DofIDs = cell(%i,1); \n", numDofManToExport ); // Output the reaction forces for each dofMan. If a certain dof is not prescribed zero is exported. IntArray dofIDs; for ( int i = 1; i <= numDofManToExport; i++ ) { int dManNum = this->reactionForcesDofManList.at(i); fprintf(FID, "\tReactionForces.ReactionForces{%i} = [", i); if ( dofManMap.contains( dManNum ) ) { DofManager *dofMan = domain->giveDofManager( dManNum ); dofIDs.clear(); for ( Dof *dof: *dofMan ) { int num = dof->giveEquationNumber( EModelDefaultPrescribedEquationNumbering() ); int pos = eqnMap.findFirstIndexOf( num ); dofIDs.followedBy(dof->giveDofID()); if ( pos > 0 ) { fprintf(FID, "%e ", reactions.at(pos)); } else { fprintf( FID, "%e ", 0.0 ); // if not prescibed output zero } } } fprintf(FID, "];\n"); // Output dof ID's fprintf( FID, "\tReactionForces.DofIDs{%i} = [", i); if ( dofManMap.contains( dManNum ) ) { for ( int id: dofIDs ) { fprintf( FID, "%i ", id ); } } fprintf(FID, "];\n"); } }