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");
}
}
