void _SLE_Solver_Init( SLE_Solver* self, Bool useStatSolve, int statReps ) {
	self->isConstructed = True;
	self->extensionManager = ExtensionManager_New_OfExistingObject( self->name, self );
	
	self->debug         = Stream_RegisterChild( StgFEM_SLE_SystemSetup_Debug, self->type );
	self->info          = Journal_MyStream( Info_Type, self );
	self->maxIterations = 0;
	self->hasSolved = False;

	self->previoustimestep = 0;
	self->currenttimestep = 0;
	self->nonlinearitsinitialtime = 0; 
	self->nonlinearitsendtime = 0; 
	self->totalnonlinearitstime = 0; 
	self->totalnumnonlinearits = 0; 
	self->avgtimenonlinearits = 0; 	
	self->inneritsinitialtime = 0; 
	self->outeritsinitialtime = 0; 
	self->inneritsendtime = 0; 
	self->outeritsendtime = 0; 
	self->totalinneritstime = 0; 
	self->totalouteritstime = 0; 
	self->totalnuminnerits = 0; 
	self->totalnumouterits = 0; 
	self->avgnuminnerits = 0; 
	self->avgnumouterits = 0; 
	self->avgtimeinnerits = 0; 
	self->avgtimeouterits = 0;
	
	self->useStatSolve = useStatSolve;
	self->nStatReps     = statReps;
}
예제 #2
0
void _ShapedMaterial_Init( 
	void*						shapedMaterial,
	PICelleratorContext*	context,
	FieldVariable*			materialIndexField,
	Dictionary*				materialDictionary,
	Materials_Register*	shapedMaterialRegister )
{
	ShapedMaterial* self = (ShapedMaterial*)shapedMaterial;
	char* name;
	Coord centre = {0,0,0};
	
	/* Set Values */
	self->context = context;

	self->dictionary = materialDictionary;

	/* Register shapedMaterial */
	if (shapedMaterialRegister != NULL)	
		self->index = Materials_Register_Add( shapedMaterialRegister, self );	
	else 
		self->index = 0;

	Stg_asprintf( &name, "%s_Shape", self->name );

	/** create a field value shape using the current material's index to define limits for the fieldvalueshape */
	self->shape = FieldValueShape_New( name, 3,centre,0,0,0,materialIndexField,self->index-0.5,self->index+ 0.5 );
	
	Memory_Free( name );

	self->extensionMgr = ExtensionManager_New_OfExistingObject( self->name, self );

}
예제 #3
0
Mesh* _Mesh_New(  MESH_DEFARGS  ) {
	Mesh* self;
	
	/* Allocate memory */
	assert( _sizeOfSelf >= sizeof(Mesh) );
	self = (Mesh*)_Stg_Component_New(  STG_COMPONENT_PASSARGS  );

	self->topo = (MeshTopology*)IGraph_New( "" );
	self->vertices = NULL;
    self->verticesVariable = NULL;
    self->vGlobalIdsVar = NULL;
    self->verticesgid = NULL;
    self->e_n = NULL;
    self->enMapVar = NULL;
    self->elgid = NULL;
    self->eGlobalIdsVar = NULL;

	self->vars = List_New();
	List_SetItemSize( self->vars, sizeof(MeshVariable*) );

	self->minSep = 0.0;
	self->minAxialSep = NULL;
	self->minLocalCrd = NULL;
	self->maxLocalCrd = NULL;
	self->minDomainCrd = NULL;
	self->maxDomainCrd = NULL;
	self->minGlobalCrd = NULL;
	self->maxGlobalCrd = NULL;

	self->algorithms = Mesh_Algorithms_New( "", NULL );
	Mesh_Algorithms_SetMesh( self->algorithms, self );
	self->nElTypes = 0;
	self->elTypes = NULL;
	self->elTypeMap = NULL;

	self->topoDataSizes = UIntMap_New();
	self->topoDataInfos = NULL;
	self->topoDatas = NULL;
	self->info = ExtensionManager_New_OfExistingObject( "mesh_info", self );
	self->vertGridId = (unsigned)-1;
	self->elGridId = (unsigned)-1;
	self->periodicId = (unsigned)-1;
	self->localOriginId = (unsigned)-1;
	self->localRangeId = (unsigned)-1;

	self->generator = NULL;
	self->emReg = NULL;

	self->isDeforming     = False;

	self->isRegular = False;
    self->parentMesh = NULL;

	return self;
}
void _FieldVariable_Init( 
   FieldVariable*          self, 
   DomainContext*          context,
   Index                   fieldComponentCount, 
   Dimension_Index         dim,
   Bool                    isCheckpointedAndReloaded,
   char*                   o_units,
   MPI_Comm                communicator, 
   FieldVariable_Register* fV_Register,
   Bool                    useCacheMaxMin ) {
   /* Add ourselves to the register for later retrieval by clients */
   
   self->context                   = context;
   self->fieldComponentCount       = fieldComponentCount;
   self->dim                       = dim;
   self->communicator              = communicator;
   self->fieldVariable_Register    = fV_Register;
   self->isCheckpointedAndReloaded = isCheckpointedAndReloaded;
   self->useCacheMaxMin            = useCacheMaxMin;

   if( o_units ) { 
      /* test if units string is valid */
      Scaling_Parse( o_units );
      /* copy units string */
      self->o_units = StG_Strdup( o_units );
   }

   if( self != NULL && fV_Register != NULL ) {   
      /* Prevent the same field from being added more than once */
      if( NamedObject_Register_GetIndex( fV_Register, self->name ) == -1 )
         FieldVariable_Register_Add( fV_Register, self );
   }   

   self->extensionMgr = ExtensionManager_New_OfExistingObject( self->name, self );
   self->cachedTimestep = -1;
}