void VariableSuite_Setup( VariableSuiteData* data ) {
Particle tmpParticle;
Name pNames[] = { "mass", "force", "info" };
SizeT pOffsets[] = { 0, 0, 0 }; /* Init later... */
Variable_DataType pDataTypes[] = {
Variable_DataType_Int,
Variable_DataType_Float,
Variable_DataType_Pointer,
};
Index pDtCounts[] = { 1, 3, 1 };
static SizeT pSize = sizeof(Particle);
data->aSize[0] = 16;
data->aSize[1] = 16;
data->aSize[2] = 16;
pOffsets[0] = (ArithPointer)&tmpParticle.mass - (ArithPointer)&tmpParticle;
pOffsets[1] = (ArithPointer)&tmpParticle.force - (ArithPointer)&tmpParticle;
pOffsets[2] = (ArithPointer)&tmpParticle.info - (ArithPointer)&tmpParticle;
/* Construction phase --------------------------------------------------------------------------------------------*/
data->vr = Variable_Register_New();
Variable_NewScalar( "temperature", NULL, Variable_DataType_Double, &data->aSize[0], NULL, (void**)&data->temperature, data->vr );
Variable_NewVector( "velocity", NULL, Variable_DataType_Double, 3, &data->aSize[1], NULL, (void**)&data->velocity, data->vr, "vx", "vy", "vz" );
Variable_New( "particle", NULL, 3, pOffsets, pDataTypes, pDtCounts, pNames, &pSize, &data->aSize[2], NULL, (void**)&data->particle, data->vr );
/* Build phase ---------------------------------------------------------------------------------------------------*/
data->temperature = Memory_Alloc_Array( double, data->aSize[0], "temperature" );
data->velocity = Memory_Alloc_Array( VectorD, data->aSize[1], "velocity" );
data->particle = Memory_Alloc_Array( Particle, data->aSize[2], "array" );
Variable_Register_BuildAll( data->vr );
}
Variable* Variable_NewFromOld( Variable* oldVariable, Name name, Bool copyValues ) {
Variable* self;
Index array_I;
SizeT dataOffsets[] = { 0 };
void* myPtr;
void* oldPtr;
Variable_Update( oldVariable );
self = Variable_New(
name,
self->context,
1,
dataOffsets,
oldVariable->dataTypes,
oldVariable->dataTypeCounts,
NULL,
0,
oldVariable->arraySizePtr,
oldVariable->arraySizeFunc,
NULL,
NULL );
self->allocateSelf = True;
self->arrayPtrPtr = &self->arrayPtr;
if ( oldVariable->isBuilt )
Stg_Component_Build( self, NULL, True );
if ( oldVariable->isInitialised )
Stg_Component_Initialise( self, NULL, True );
assert(self->offsetCount == 1);
if ( copyValues ) {
for ( array_I = 0 ; array_I < self->arraySize ; array_I++ ) {
myPtr = Variable_GetStructPtr( self, array_I );
oldPtr = Variable_GetStructPtr( oldVariable, array_I );
memcpy( myPtr, oldPtr, self->dataSizes[0] );
}
}
return self;
}
void _SnacViscoPlastic_ConstructExtensions( void* _context, void* data ) {
Snac_Context* context = (Snac_Context*)_context;
SnacViscoPlastic_Context* contextExt = ExtensionManager_Get(
context->extensionMgr,
context,
SnacViscoPlastic_ContextHandle );
Snac_Element tmpElement;
SnacViscoPlastic_Element* tmpElementExt = ExtensionManager_Get(
context->mesh->elementExtensionMgr,
&tmpElement,
SnacViscoPlastic_ElementHandle );
char tmpBuf[PATH_MAX];
/* Because plastic strain is not an array by itself, we must the "complex" constructor for Variable... the info needs to be
* wrapped this generic way... */
Index viscoplasticOffsetCount = 1;
SizeT viscoplasticOffsets[] = {
(SizeT)((char*)&tmpElementExt->aps - (char*)&tmpElement) };
Variable_DataType viscoplasticDataTypes[] = { Variable_DataType_Double };
Index viscoplasticDataTypeCounts[] = { 1 };
// #if DEBUG
if( context->rank == 0 ) printf( "In %s()\n", __func__ );
// #endif
/* Create the StGermain variable aps, which is stored on an element extension */
Variable_New(
"plStrain",
viscoplasticOffsetCount,
viscoplasticOffsets,
viscoplasticDataTypes,
viscoplasticDataTypeCounts,
0,
&ExtensionManager_GetFinalSize( context->mesh->elementExtensionMgr ),
&context->mesh->layout->decomp->elementDomainCount,
(void**)&context->mesh->element,
context->variable_Register );
int element_lI;
for( element_lI = 0; element_lI < context->mesh->elementLocalCount; element_lI++ ) {
Snac_Element* element = Snac_Element_At( context, element_lI );
SnacViscoPlastic_Element* viscoplasticElement = ExtensionManager_Get( context->mesh->elementExtensionMgr, element,
SnacViscoPlastic_ElementHandle );
viscoplasticElement->aps = 0.0f;
}//for
/* Prepare the dump file */
sprintf( tmpBuf, "%s/plStrain.%u", context->outputPath, context->rank );
if( (contextExt->plStrainOut = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->plStrainOut /* failed to open file for writing */ );
abort();
}
sprintf( tmpBuf, "%s/plStrainCP.%u", context->outputPath, context->rank );
if( (contextExt->plStrainCheckpoint = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->plStrainCheckpoint /* failed to open file for writing */ );
abort();
}
sprintf( tmpBuf, "%s/avgPlStrainCP.%u", context->outputPath, context->rank );
if( (contextExt->avgPlStrainCheckpoint = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->avgPlStrainCheckpoint /* failed to open file for writing */ );
abort();
}
sprintf( tmpBuf, "%s/viscosity.%u", context->outputPath, context->rank );
if( (contextExt->viscOut = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->viscOut /* failed to open file for writing */ );
abort();
}
sprintf( tmpBuf, "%s/viscosityCP.%u", context->outputPath, context->rank );
if( (contextExt->viscCheckpoint = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->viscCheckpoint /* failed to open file for writing */ );
abort();
}
}
void _SnacTemperature_ConstructExtensions( void* _context, void* data ) {
Snac_Context* context = (Snac_Context*)_context;
SnacTemperature_Context* contextExt = ExtensionManager_Get(
context->extensionMgr,
context,
SnacTemperature_ContextHandle );
Snac_Node tmpNode;
SnacTemperature_Node* tmpNodeExt = ExtensionManager_Get(
context->mesh->nodeExtensionMgr,
&tmpNode,
SnacTemperature_NodeHandle );
Dictionary* temperatureBCsDict;
char tmpBuf[PATH_MAX];
/* Because temperature is not an array by itself, we must the "complex" constructor for Variable... the info needs to be
* wrapped this generic way... */
Index temperatureOffsetCount = 1;
SizeT temperatureOffsets[] = { /*GetOffsetOfMember( *tmpNodeExt, temperature ) };*/
(SizeT)((char*)&tmpNodeExt->temperature - (char*)&tmpNode) };
Variable_DataType temperatureDataTypes[] = { Variable_DataType_Double };
Index temperatureDataTypeCounts[] = { 1 };
#if DEBUG
printf( "In %s()\n", __func__ );
#endif
/* Create the StGermain variable temperature, which is stored on a node extension */
Variable_New(
"temperature",
temperatureOffsetCount,
temperatureOffsets,
temperatureDataTypes,
temperatureDataTypeCounts,
0,
&ExtensionManager_GetFinalSize( context->mesh->nodeExtensionMgr ),
&context->mesh->layout->decomp->nodeDomainCount,
(void**)&context->mesh->node,
context->variable_Register );
/* Register these functions for use in VCs */
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacTemperature_Top2BottomSweep, "SnacTemperature_Top2BottomSweep" ) );
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacTemperature_Top2BottomSweep_Spherical, "SnacTemperature_Top2BottomSweep_Spherical" ) );
ConditionFunction_Register_Add(
context->condFunc_Register,
ConditionFunction_New( _SnacTemperature_Citcom_Compatible, "SnacTemperature_Citcom_Compatible" ) );
/* Temperature variables */
contextExt->topTemp = Dictionary_Entry_Value_AsDouble(
Dictionary_GetDefault( context->dictionary, "topTemp", Dictionary_Entry_Value_FromDouble( 0.0f ) ) );
contextExt->bottomTemp = Dictionary_Entry_Value_AsDouble(
Dictionary_GetDefault( context->dictionary, "bottomTemp", Dictionary_Entry_Value_FromDouble( 1300.0f ) ) );
/* Build the temperature IC and BC managers */
temperatureBCsDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( context->dictionary, "temperatureBCs" ) );
contextExt->temperatureBCs = CompositeVC_New("tempBC",
context->variable_Register,
context->condFunc_Register,
temperatureBCsDict,
context->mesh );
/* Prepare the dump and checkpoint file */
sprintf( tmpBuf, "%s/temperature.%u", context->outputPath, context->rank );
if( (contextExt->temperatureOut = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->temperatureOut /* failed to open file for writing */ );
abort();
}
sprintf( tmpBuf, "%s/temperatureCP.%u", context->outputPath, context->rank );
if( (contextExt->temperatureCheckpoint = fopen( tmpBuf, "w+" )) == NULL ) {
assert( contextExt->temperatureCheckpoint /* failed to open file for writing */ );
abort();
}
}
