void* _FieldVariable_Copy( void* fieldVariable, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
FieldVariable* self = (FieldVariable*)fieldVariable;
FieldVariable* newFieldVariable;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newFieldVariable = _Stg_Component_Copy( self, dest, deep, nameExt, map );
newFieldVariable->_interpolateValueAt = self->_interpolateValueAt;
newFieldVariable->_getMinAndMaxLocalCoords = self->_getMinAndMaxLocalCoords;
newFieldVariable->_getMinAndMaxGlobalCoords = self->_getMinAndMaxGlobalCoords;
newFieldVariable->fieldComponentCount = self->fieldComponentCount;
newFieldVariable->dim = self->dim;
newFieldVariable->isCheckpointedAndReloaded = self->isCheckpointedAndReloaded;
newFieldVariable->communicator = self->communicator;
newFieldVariable->fieldVariable_Register = self->fieldVariable_Register;
newFieldVariable->extensionMgr = Stg_Class_Copy( self->extensionMgr, NULL, deep, nameExt, map );
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newFieldVariable;
}
void* _MeshLayout_Copy( void* meshLayout, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
MeshLayout* self = (MeshLayout*)meshLayout;
MeshLayout* newMeshLayout;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newMeshLayout = (MeshLayout*)_Stg_Component_Copy( self, dest, deep, nameExt, map );
if( deep ) {
newMeshLayout->nodeLayout = (NodeLayout*)Stg_Class_Copy( self->nodeLayout, NULL, deep, nameExt, map );
newMeshLayout->elementLayout = (ElementLayout*)Stg_Class_Copy( self->elementLayout, NULL, deep, nameExt, map );
newMeshLayout->decomp = (MeshDecomp*)Stg_Class_Copy( self->decomp, NULL, deep, nameExt, map );
}
else {
newMeshLayout->nodeLayout = self->nodeLayout;
newMeshLayout->elementLayout = self->elementLayout;
newMeshLayout->decomp = self->decomp;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newMeshLayout;
}
void* _StiffnessMatrixTerm_Copy( void* stiffnessMatrixTerm, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
StiffnessMatrixTerm* self = (StiffnessMatrixTerm*)stiffnessMatrixTerm;
StiffnessMatrixTerm* newStiffnessMatrixTerm;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newStiffnessMatrixTerm = _Stg_Component_Copy( self, dest, deep, nameExt, map );
newStiffnessMatrixTerm->extraInfo = self->extraInfo;
if( deep ) {
newStiffnessMatrixTerm->integrationSwarm = (Swarm*)Stg_Class_Copy( self->integrationSwarm, NULL, deep, nameExt, map );
}
else {
newStiffnessMatrixTerm->integrationSwarm = self->integrationSwarm;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newStiffnessMatrixTerm;
}
void* _SolutionVector_Copy( void* solutionVector, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
SolutionVector* self = (SolutionVector*)solutionVector;
SolutionVector* newSolutionVector;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newSolutionVector = _Stg_Component_Copy( self, dest, deep, nameExt, map );
/* TODO: copy vector? */
newSolutionVector->vector = self->vector;
newSolutionVector->comm = self->comm;
if( deep ) {
newSolutionVector->debug = (Stream*)Stg_Class_Copy( self->debug, NULL, deep, nameExt, map );
newSolutionVector->feVariable = (FeVariable*)Stg_Class_Copy( self->feVariable, NULL, deep, nameExt, map );
}
else {
newSolutionVector->debug = self->debug;
newSolutionVector->feVariable = self->feVariable;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newSolutionVector;
}
void* _SwarmVariable_Copy( void* swarmVariable, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
SwarmVariable* self = (SwarmVariable*)swarmVariable;
SwarmVariable* newSwarmVariable;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newSwarmVariable = _Stg_Component_Copy( self, dest, deep, nameExt, map );
newSwarmVariable->_valueAt = self->_valueAt;
newSwarmVariable->_getMinGlobalMagnitude = self->_getMinGlobalMagnitude ;
newSwarmVariable->_getMaxGlobalMagnitude = self->_getMaxGlobalMagnitude;
newSwarmVariable->swarm = self->swarm;
newSwarmVariable->variable = self->variable;
newSwarmVariable->dofCount = self->dofCount;
newSwarmVariable->swarmVariable_Register = self->swarmVariable_Register;
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newSwarmVariable;
}
void* _SLE_Solver_Copy( void* sleSolver, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
SLE_Solver* self = (SLE_Solver*)sleSolver;
SLE_Solver* newSleSolver;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newSleSolver = _Stg_Component_Copy( self, dest, deep, nameExt, map );
/* virtual functions */
newSleSolver->_solverSetup = self->_solverSetup;
newSleSolver->_solve = self->_solve;
newSleSolver->maxIterations = self->maxIterations;
newSleSolver->inneritsinitialtime = self->inneritsinitialtime;
newSleSolver->outeritsinitialtime = self->outeritsinitialtime;
newSleSolver->nonlinearitsinitialtime = self->nonlinearitsinitialtime;
newSleSolver->inneritsendtime = self->inneritsendtime;
newSleSolver->outeritsendtime = self->outeritsendtime;
newSleSolver->nonlinearitsendtime = self->nonlinearitsendtime;
newSleSolver->totalinneritstime = self->totalinneritstime;
newSleSolver->totalouteritstime = self->totalouteritstime;
newSleSolver->totalnonlinearitstime = self->totalnonlinearitstime;
newSleSolver->totalnuminnerits = self->totalnuminnerits;
newSleSolver->totalnumouterits = self->totalnumouterits;
newSleSolver->totalnumnonlinearits = self->totalnumnonlinearits;
newSleSolver->avgnuminnerits = self->avgnuminnerits;
newSleSolver->avgnumouterits = self->avgnumouterits;
newSleSolver->avgtimeinnerits = self->avgtimeinnerits;
newSleSolver->avgtimeouterits = self->avgtimeouterits;
newSleSolver->avgtimenonlinearits = self->avgtimenonlinearits;
newSleSolver->currenttimestep = self->currenttimestep;
newSleSolver->previoustimestep = self->previoustimestep;
if( deep ) {
if( (newSleSolver->debug = PtrMap_Find( map, self->debug )) == NULL ) {
newSleSolver->debug = Stg_Class_Copy( self->debug, NULL, deep, nameExt, map );
PtrMap_Append( map, self->debug, newSleSolver->debug );
}
if( (newSleSolver->extensionManager = PtrMap_Find( map, self->extensionManager )) == NULL ) {
newSleSolver->extensionManager = Stg_Class_Copy( self->extensionManager, NULL, deep, nameExt, map );
PtrMap_Append( map, self->extensionManager, newSleSolver->extensionManager );
}
}
else {
newSleSolver->debug = self->debug;
newSleSolver->extensionManager = Stg_Class_Copy( self->extensionManager, NULL, deep, nameExt, map );
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newSleSolver;
}
void* _EscapedRoutine_Copy( void* escapedRoutine, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
EscapedRoutine* self = (EscapedRoutine*)escapedRoutine;
EscapedRoutine* newEscapedRoutine;
newEscapedRoutine = (EscapedRoutine*)_Stg_Component_Copy( self, dest, deep, nameExt, ptrMap );
return (void*)newEscapedRoutine;
}
void* _DofLayout_Copy( void* dofLayout, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
DofLayout* self = (DofLayout*)dofLayout;
DofLayout* newDofLayout;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newDofLayout = (DofLayout*)_Stg_Component_Copy( self, dest, deep, nameExt, map );
newDofLayout->_variableRegister = self->_variableRegister;
newDofLayout->_numItemsInLayout = self->_numItemsInLayout;
newDofLayout->_totalVarCount = self->_totalVarCount;
if( deep ) {
if( (newDofLayout->_variableEnabledSets = PtrMap_Find( map, self->_variableEnabledSets )) == NULL && self->_variableEnabledSets ) {
Index set_I;
newDofLayout->_variableEnabledSets = Memory_Alloc_Array( IndexSet*, newDofLayout->_totalVarCount, "DofLayout->_variableEnabledSets" );
for( set_I = 0; set_I < newDofLayout->_totalVarCount; set_I++ ) {
newDofLayout->_variableEnabledSets[set_I] = (IndexSet*)Stg_Class_Copy( self->_variableEnabledSets[set_I], NULL, deep, nameExt, map );
}
PtrMap_Append( map, self->_variableEnabledSets, newDofLayout->_variableEnabledSets );
}
if( (newDofLayout->_varIndicesMapping = PtrMap_Find( map, self->_varIndicesMapping )) == NULL && self->_varIndicesMapping ) {
newDofLayout->_varIndicesMapping = Memory_Alloc_Array( Variable_Index, newDofLayout->_totalVarCount, "DofLayout->_varIndicesMapping" );
memcpy( newDofLayout->_varIndicesMapping, self->_varIndicesMapping, sizeof(Variable_Index) * newDofLayout->_totalVarCount );
PtrMap_Append( map, self->_varIndicesMapping, newDofLayout->_varIndicesMapping );
}
if( (newDofLayout->dofCounts = PtrMap_Find( map, self->dofCounts )) == NULL && self->dofCounts ) {
newDofLayout->dofCounts = Memory_Alloc_Array( Index, newDofLayout->_numItemsInLayout, "DofLayout->dofCounts" );
memcpy( newDofLayout->dofCounts, self->dofCounts, sizeof(Index) * newDofLayout->_numItemsInLayout );
PtrMap_Append( map, self->dofCounts, newDofLayout->dofCounts );
}
if( (newDofLayout->varIndices = PtrMap_Find( map, self->varIndices )) == NULL && self->varIndices ) {
Index idx_I;
newDofLayout->varIndices = Memory_Alloc_2DComplex( Variable_Index, newDofLayout->_numItemsInLayout, self->dofCounts, "DofLayout->varIndices" );
for( idx_I = 0; idx_I < newDofLayout->_numItemsInLayout; idx_I++ ) {
memcpy( newDofLayout->varIndices[idx_I], self->varIndices[idx_I], sizeof(Variable_Index) * newDofLayout->dofCounts[idx_I] );
}
PtrMap_Append( map, self->varIndices, newDofLayout->varIndices );
}
}
void* _CellLayout_Copy( void* cellLayout, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
CellLayout* self = (CellLayout*)cellLayout;
CellLayout* newCellLayout;
newCellLayout = _Stg_Component_Copy( self, dest, deep, nameExt, ptrMap );
/* Virtual methods */
newCellLayout->_cellLocalCount = self->_cellLocalCount;
newCellLayout->_cellShadowCount = self->_cellShadowCount;
newCellLayout->_pointCount = self->_pointCount;
newCellLayout->_initialisePoints = self->_initialisePoints;
newCellLayout->_mapElementIdToCellId = self->_mapElementIdToCellId;
newCellLayout->_isInCell = self->_isInCell;
newCellLayout->_cellOf = self->_cellOf;
newCellLayout->_getShadowInfo = self->_getShadowInfo;
return (void*)newCellLayout;
}
void* _SwarmDump_Copy( void* swarmDump, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
SwarmDump* self = (SwarmDump*)swarmDump;
SwarmDump* newSwarmDump;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newSwarmDump = _Stg_Component_Copy( self, dest, deep, nameExt, map );
memcpy( newSwarmDump->swarmList, self->swarmList, self->swarmCount * sizeof(Swarm*) );
newSwarmDump->swarmCount = self->swarmCount;
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newSwarmDump;
}
void* _VariableCondition_Copy( void* variableCondition, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
VariableCondition* self = (VariableCondition*)variableCondition;
VariableCondition* newVariableCondition;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newVariableCondition = (VariableCondition*)_Stg_Component_Copy( self, dest, deep, nameExt, map );
/* Virtual methods */
newVariableCondition->_buildSelf = self->_buildSelf;
newVariableCondition->_printConcise = self->_printConcise;
newVariableCondition->_readDictionary = self->_readDictionary;
newVariableCondition->_getSet = self->_getSet;
newVariableCondition->_getVariableCount = self->_getVariableCount;
newVariableCondition->_getVariableIndex = self->_getVariableIndex;
newVariableCondition->_getValueIndex = self->_getValueIndex;
newVariableCondition->_getValueCount = self->_getValueCount;
newVariableCondition->_getValue = self->_getValue;
newVariableCondition->variable_Register = self->variable_Register;
newVariableCondition->conFunc_Register = self->conFunc_Register;
newVariableCondition->dictionary = self->dictionary;
newVariableCondition->indexCount = self->indexCount;
newVariableCondition->valueCount = self->valueCount;
if( deep ) {
newVariableCondition->_set = (IndexSet*)Stg_Class_Copy( self->_set, NULL, deep, nameExt, map );
if( (newVariableCondition->indexTbl = (Index*)PtrMap_Find( map, self->indexTbl )) == NULL && self->indexTbl ) {
newVariableCondition->indexTbl = (Index*)Memory_Alloc_Array( Index, newVariableCondition->indexCount, "VariableCondition->indexTbl" );
memcpy( newVariableCondition->indexTbl, self->indexTbl, sizeof(Index) * newVariableCondition->indexCount );
PtrMap_Append( map, newVariableCondition->indexTbl, self->indexTbl );
}
if( (newVariableCondition->vcVarCountTbl = (VariableCondition_VariableIndex*)PtrMap_Find( map, self->vcVarCountTbl )) == NULL && self->vcVarCountTbl ) {
newVariableCondition->vcVarCountTbl = Memory_Alloc_Array( VariableCondition_VariableIndex, newVariableCondition->indexCount, "VC->vcVarCountTbl" );
memcpy( newVariableCondition->vcVarCountTbl, self->vcVarCountTbl, sizeof(VariableCondition_VariableIndex) * newVariableCondition->indexCount );
PtrMap_Append( map, newVariableCondition->vcVarCountTbl, self->vcVarCountTbl );
}
if( (newVariableCondition->vcTbl = (VariableCondition_Tuple**)PtrMap_Find( map, self->vcTbl )) == NULL && self->vcTbl ) {
Index idx_I;
newVariableCondition->vcTbl = Memory_Alloc_2DComplex( VariableCondition_Tuple, newVariableCondition->indexCount, newVariableCondition->vcVarCountTbl, "VC->vcTbl" );
for( idx_I = 0; idx_I < newVariableCondition->indexCount; idx_I++ ) {
memcpy( newVariableCondition->vcTbl[idx_I], self->vcTbl[idx_I], sizeof(VariableCondition_Tuple) * newVariableCondition->vcVarCountTbl[idx_I] );
}
PtrMap_Append( map, newVariableCondition->vcTbl, self->vcTbl );
}
if( (newVariableCondition->valueTbl = (VariableCondition_Value*)PtrMap_Find( map, self->valueTbl )) == NULL && self->valueTbl ) {
newVariableCondition->valueTbl = Memory_Alloc_Array( VariableCondition_Value, newVariableCondition->valueCount, "VC->valueTbl" );
memcpy( newVariableCondition->valueTbl, self->valueTbl, sizeof(VariableCondition_Value) * newVariableCondition->indexCount );
PtrMap_Append( map, newVariableCondition->valueTbl, self->valueTbl );
}
}
else {
newVariableCondition->_set = self->_set;
newVariableCondition->indexTbl = self->indexTbl;
newVariableCondition->vcVarCountTbl = self->vcVarCountTbl;
newVariableCondition->vcTbl = self->vcTbl;
newVariableCondition->valueTbl = self->valueTbl;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newVariableCondition;
}
void* _Codelet_Copy( void* codelet, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
return _Stg_Component_Copy( codelet, dest, deep, nameExt, ptrMap );
}
void* _MeshDecomp_Copy( void* meshDecomp, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
MeshDecomp* self = (MeshDecomp*)meshDecomp;
MeshDecomp* newMeshDecomp;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newMeshDecomp = (MeshDecomp*)_Stg_Component_Copy( self, dest, deep, nameExt, map );
/* Virtual methods */
newMeshDecomp->nodeMapLocalToGlobal = self->nodeMapLocalToGlobal;
newMeshDecomp->nodeMapDomainToGlobal = self->nodeMapDomainToGlobal;
newMeshDecomp->nodeMapShadowToGlobal = self->nodeMapShadowToGlobal;
newMeshDecomp->nodeMapGlobalToLocal = self->nodeMapGlobalToLocal;
newMeshDecomp->nodeMapGlobalToDomain = self->nodeMapGlobalToDomain;
newMeshDecomp->nodeMapGlobalToShadow = self->nodeMapGlobalToShadow;
newMeshDecomp->elementMapLocalToGlobal = self->elementMapLocalToGlobal;
newMeshDecomp->elementMapDomainToGlobal = self->elementMapDomainToGlobal;
newMeshDecomp->elementMapShadowToGlobal = self->elementMapShadowToGlobal;
newMeshDecomp->elementMapGlobalToLocal = self->elementMapGlobalToLocal;
newMeshDecomp->elementMapGlobalToDomain = self->elementMapGlobalToDomain;
newMeshDecomp->elementMapGlobalToShadow = self->elementMapGlobalToShadow;
newMeshDecomp->shadowProcCount = self->shadowProcCount;
newMeshDecomp->shadowBuildProcs = self->shadowBuildProcs;
newMeshDecomp->shadowProcElementCount = self->shadowProcElementCount;
newMeshDecomp->procWithElement = self->procWithElement;
newMeshDecomp->dictionary = self->dictionary;
newMeshDecomp->communicator = self->communicator;
newMeshDecomp->rank = self->rank;
newMeshDecomp->nproc = self->nproc;
newMeshDecomp->procsInUse = self->procsInUse;
newMeshDecomp->allowUnusedCPUs = self->allowUnusedCPUs;
newMeshDecomp->allowPartitionOnNode = self->allowPartitionOnNode;
newMeshDecomp->allowPartitionOnElement = self->allowPartitionOnElement;
newMeshDecomp->allowUnbalancing = self->allowUnbalancing;
newMeshDecomp->storage = self->storage;
newMeshDecomp->shadowDepth = self->shadowDepth;
newMeshDecomp->nodeGlobalCount = self->nodeGlobalCount;
newMeshDecomp->nodeLocalCount = self->nodeLocalCount;
newMeshDecomp->nodeShadowCount = self->nodeShadowCount;
newMeshDecomp->nodeDomainCount = self->nodeDomainCount;
newMeshDecomp->elementGlobalCount = self->elementGlobalCount;
newMeshDecomp->elementLocalCount = self->elementLocalCount;
newMeshDecomp->elementShadowCount = self->elementShadowCount;
newMeshDecomp->elementDomainCount = self->elementDomainCount;
if( deep ) {
newMeshDecomp->procTopology = (Topology*)Stg_Class_Copy( self->procTopology, NULL, deep, nameExt, map );
newMeshDecomp->elementLayout = (ElementLayout*)Stg_Class_Copy( self->elementLayout, NULL, deep, nameExt, map );
newMeshDecomp->nodeLayout = (NodeLayout*)Stg_Class_Copy( self->nodeLayout, NULL, deep, nameExt, map );
if( (newMeshDecomp->localNodeSets = PtrMap_Find( map, self->localNodeSets )) == NULL && self->localNodeSets ) {
Partition_Index proc_I;
newMeshDecomp->localNodeSets = Memory_Alloc_Array( IndexSet*, newMeshDecomp->procsInUse, "MeshDecomp->localNodeSets" );
for( proc_I = 0; proc_I < newMeshDecomp->procsInUse; proc_I++ ) {
newMeshDecomp->localNodeSets[proc_I] = (IndexSet*)Stg_Class_Copy( self->localNodeSets[proc_I], NULL, deep, nameExt, map );
}
}
if( (newMeshDecomp->shadowNodeSets = PtrMap_Find( map, self->shadowNodeSets )) == NULL && self->shadowNodeSets ) {
Partition_Index proc_I;
newMeshDecomp->shadowNodeSets = Memory_Alloc_Array( IndexSet*, newMeshDecomp->procsInUse, "MeshDecomp->shadowNodeSets" );
for( proc_I = 0; proc_I < newMeshDecomp->procsInUse; proc_I++ ) {
newMeshDecomp->shadowNodeSets[proc_I] = (IndexSet*)Stg_Class_Copy( self->shadowNodeSets[proc_I], NULL, deep, nameExt, map );
}
}
