void _lucViewport_Print( void* viewport, Stream* stream )
{
lucViewport* self = viewport;
Journal_Printf( stream, "lucViewport: %s\n", self->name );
Stream_Indent( stream );
/* Print Parent */
_Stg_Component_Print( self, stream );
lucDrawingObject_Register_PrintAllObjects( self->drawingObject_Register, stream );
Stg_Class_Print( self->camera, stream );
Journal_PrintValue( stream, self->margin );
Journal_PrintValue( stream, self->nearClipPlane );
Journal_PrintValue( stream, self->farClipPlane );
Journal_PrintString( stream, self->title );
Journal_PrintBool( stream, self->timestep );
Journal_PrintBool( stream, self->disabled );
Stream_UnIndent( stream );
}
void _EntryPoint_Register_Print( void* entryPoint_Register, Stream* stream ) {
EntryPoint_Register* self = (EntryPoint_Register*)entryPoint_Register;
#ifdef DEBUG
EntryPoint_Index entryPoint_I;
#endif
/* General info */
Journal_Printf( (void*) stream, "EntryPoint_Register (ptr): %p\n", self );
/* Print parent */
_Stg_Class_Print( self, stream );
/* Virtual info */
/* EntryPoint_Register info */
Journal_Printf( (void*) stream, "\tcount: %u\n", self->count );
Journal_Printf( (void*) stream, "\t_size: %lu\n", self->_size );
Journal_Printf( (void*) stream, "\t_delta: %lu\n", self->_delta );
Journal_Printf( (void*) stream, "\tentryPoint (ptr): %p\n", self->entryPoint );
Journal_Printf( (void*) stream, "\tentryPoint[0-%u]:\n", self->count );
#ifdef DEBUG
for( entryPoint_I = 0; entryPoint_I < self->count; entryPoint_I++ ) {
Journal_Printf( (void*) stream, "entryPoint[%u]: ", entryPoint_I );
Stg_Class_Print( self->entryPoint[entryPoint_I], stream);
}
#else
Journal_Printf( (void*) stream, "...\n" );
#endif
Journal_Printf( (void*) stream, "\t]\n" );
}
void _Variable_Register_Print(void* variable_Register, Stream* stream)
{
Variable_Register* self = (Variable_Register*)variable_Register;
/* Set the Journal for printing informations */
Stream* variable_RegisterStream = Journal_Register( InfoStream_Type, "Variable_RegisterStream");
/* General info */
Journal_Printf( variable_RegisterStream, "Variable_Register (ptr): %p\n", self);
/* Virtual info */
/* Stg_Class info */
Journal_Printf( variable_RegisterStream, "\tcount: %u\n", self->count);
Journal_Printf( variable_RegisterStream, "\t_size: %lu\n", self->_size);
Journal_Printf( variable_RegisterStream, "\t_delta: %lu\n", self->_delta);
Journal_Printf( variable_RegisterStream, "\t_variable (ptr): %p\n", self->_variable);
if (self->_variable)
{
Variable_Index var_I;
for (var_I = 0; var_I < self->count; var_I++)
Stg_Class_Print(self->_variable[var_I], stream);
}
/* Print parent */
_Stg_Class_Print(self, variable_RegisterStream);
}
void _EntryPoint_Print( void* entryPoint, Stream* stream ) {
EntryPoint* self = (EntryPoint*)entryPoint;
#if DEBUG
assert( self );
assert( stream );
#endif
/* General info */
Journal_Printf( (void*) stream, "EntryPoint (ptr) (%p):\n", self );
/* Virtual info */
Journal_Printf( (void*) stream, "\t_getRun (ptr): %p\n", self->_getRun );
/* EntryPoint info */
Journal_Printf( (void*) stream, "\tname: %s\n", self->name );
Journal_Printf( (void*) stream, "\tcastType: %u\n", self->castType );
Journal_Printf( (void*) stream, "\trun (ptr): %p\n", self->run );
Journal_Printf( (void*) stream, "\thooks: \n" );
Stg_Class_Print( self->hooks, stream );
Journal_Printf( (void*) stream, "\n" );
/* Print parent */
_Stg_Class_Print( self, stream );
}
void _Stokes_SLE_Print( void* sle, Stream* stream ) {
Stokes_SLE* self = (Stokes_SLE*)sle;
/* Set the Journal for printing informations */
/* General info */
Journal_Printf( stream, "Stokes_SLE (ptr): %p\n", self );
_SystemLinearEquations_Print( self, stream );
Journal_Printf( stream, "Name of discrete stress tensor (K) matrix = \"%s\" \n",self->kStiffMat->name );
Journal_Printf( stream, "Name of discrete gradient (G) matrix = \"%s\" \n",self->gStiffMat->name );
if (self->dStiffMat) {
Journal_Printf( stream, "Name of discrete divergence (D) matrix = \"%s\" \n",self->dStiffMat->name );
}
else {
Journal_Printf( stream, "No discrete divergence (D) matrix set up (Symmetric geometry).\n" );
}
if (self->cStiffMat) {
Journal_Printf( stream, "Name of compressibility (C) matrix = \"%s\" \n",self->cStiffMat->name );
}
else {
Journal_Printf( stream, "No compressibility (C) matrix set up (incompressible fluids)\n" );
}
Journal_Printf( stream, "Name of velocity (u) vector = \"%s\" \n",self->uSolnVec->name );
Journal_Printf( stream, "Name of pressure (p) vector = \"%s\" \n",self->pSolnVec->name );
Stg_Class_Print( self->solver, stream );
}
void _Stg_ObjectAdaptor_Print( void* objectAdaptor, struct Stream* stream ) {
Stg_ObjectAdaptor* self = (Stg_ObjectAdaptor*)objectAdaptor;
/* General info */
Journal_Printf( stream, "Stg_ObjectAdaptor (ptr): %p\n", self );
Stream_Indent( stream );
_Stg_Object_Print( self, stream );
Journal_Printf( stream, "iOwn: %s\n", self->iOwn ? "Yes" : "No" );
Journal_Printf( stream, "isGlobal: %s\n", self->isGlobal ? "Yes" : "No" );
Journal_Printf( stream, "isStgClass: %s\n", self->isStgClass ? "Yes" : "No" );
if( self->isStgClass ) {
Stg_Class_Print( self->dataPtr, stream );
}
else {
if( self->ptrPrint ) {
self->ptrPrint( self->dataPtr, stream );
}
else {
Journal_Printf( stream, "Don't know how to print the pointer (it is not to a StGermain class)\n" );
}
}
Stream_UnIndent( stream );
}
void _OneToOneMapper_Print( void* mapper, Stream* stream ) {
OneToOneMapper* self = (OneToOneMapper*)mapper;
_IntegrationPointMapper_Print( self, stream );
Stream_Indent( stream );
Stg_Class_Print( self->materialSwarm, stream );
Stream_UnIndent( stream );
}
void Stg_ObjectList_PrintAllObjects( void* objectList, void* _stream ) {
Stg_ObjectList* self = (Stg_ObjectList*) objectList;
Stream* stream = (Stream*)_stream;
Index objectIndex = 0;
for ( objectIndex = 0; objectIndex < self->count; objectIndex++ ) {
Stg_Class_Print( self->data[ objectIndex ], stream );
}
}
void _DomainContext_Print( void* context, Stream* stream ) {
DomainContext* self = (DomainContext*)context;
/* General info */
Journal_Printf( (void*) stream, "DomainContext (ptr): %p\n", self );
/* Print parent */
_AbstractContext_Print( self, stream );
Journal_Printf( (void*) stream, "\tfieldVariables (ptr): %p\n", self->fieldVariable_Register );
Stg_Class_Print( self->fieldVariable_Register, stream );
}
void _Energy_SLE_Print( void* sle, Stream* stream ) {
Energy_SLE* self = (Energy_SLE*)sle;
/* General info */
Journal_Printf( stream, "Energy_SLE (ptr): %p\n", self );
_SystemLinearEquations_Print( self, stream );
Journal_PrintString( stream, self->stiffMat->name );
Journal_PrintString( stream, self->solutionVec->name );
Journal_PrintString( stream, self->fVector->name );
Stg_Class_Print( self->solver, stream );
}
void _LiveComponentRegister_Print( void* liveComponentRegister, Stream* stream ) {
LiveComponentRegister *self = (LiveComponentRegister *) liveComponentRegister;
assert( self );
/* General info */
Journal_Printf( (void*)stream, "LiveComponentRegister (ptr): %p\n", self );
/* Print parent class */
_Stg_Class_Print( self, stream );
Journal_Printf( (void*)stream, "componentList (ptr): %p\n", self->componentList );
Stg_Class_Print( self->componentList, stream );
}
void _Stg_ComponentFactory_Print( void* cf, Stream* stream )
{
Stg_ComponentFactory *self = (Stg_ComponentFactory*) cf;
assert( self );
/* General info */
Journal_Printf( (void*) stream, "Stg_ComponentFactory (ptr): %p\n", self );
/* Print parent class */
_Stg_Class_Print( self, stream );
Journal_Printf( (void*) stream, "LiveComponentRegister (ptr): %p\n", self->LCRegister );
Stg_Class_Print( self->LCRegister, stream );
}
void _NamedObject_Register_Print( void* namedObjectRegister, struct Stream* stream ) {
NamedObject_Register* self = (NamedObject_Register*)namedObjectRegister;
/* General info */
Journal_Printf( stream, "NamedObject_Register (ptr): %p\n", self);
Stream_Indent( stream );
/* Use parent print */
_Stg_Class_Print( self, stream );
/* Print the list of registered objects */
Stg_Class_Print( self->objects, stream );
Stream_UnIndent( stream );
}
PyObject* Context_Python_Print( PyObject* self, PyObject* args ) {
PyObject* pyContext;
Context* context;
Stream* stream = Journal_Register (Info_Type, "myString");
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "O:", &pyContext ) ) {
return NULL;
}
context = (Context*)( PyCObject_AsVoidPtr( pyContext ) );
/* Run function */
Stg_Class_Print( context, stream );
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
void _TimeIntegrator_Print( void* timeIntegrator, Stream* stream ) {
TimeIntegrator* self = (TimeIntegrator*)timeIntegrator;
/* General info */
Journal_DPrintf( self->debug, "TimeIntegrator - '%s'\n", self->name );
Journal_PrintPointer( stream, self );
Stream_Indent( stream );
/* Print parent */
_Stg_Component_Print( self, stream );
/* Virtual info */
/* Regular Info */
Stg_Class_Print( self->integrandRegister, stream );
Stream_UnIndent( stream );
}
PyObject* Dictionary_Python_Print( PyObject* self, PyObject* args) {
PyObject* pyDictionary;
Dictionary* dictionary;
Stream* stream = Journal_Register (Info_Type, "myStream");
/* Obtain arguements */
if( !PyArg_ParseTuple( args, "O:", &pyDictionary ) ) {
return NULL;
}
dictionary = (Dictionary*)( PyCObject_AsVoidPtr( pyDictionary ) );
/* Run function */
Stg_Class_Print( dictionary, stream );
/* Return */
Py_INCREF( Py_None );
return Py_None;
}
void _SolutionVector_Print( void* solutionVector, Stream* stream ) {
SolutionVector* self = (SolutionVector*)solutionVector;
/* Set the Journal for printing informations */
Stream* solutionVectorStream = stream;
/* General info */
Journal_Printf( solutionVectorStream, "SolutionVector (ptr): %p\n", self );
/* Print parent */
_Stg_Component_Print( self, solutionVectorStream );
/* Virtual info */
/* SolutionVector info */
Stg_Class_Print( self->feVariable, solutionVectorStream );
Journal_Printf( solutionVectorStream, "\tComm: %u\n", self->comm );
}
int main( int argc, char *argv[] ) {
int rank;
int procCount;
int procToWatch;
Stream* stream;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &procCount );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
BaseFoundation_Init( &argc, &argv );
RegressionTest_Init( "Base/Automation/Stg_Component" );
BaseIO_Init( &argc, &argv );
BaseContainer_Init( &argc, &argv );
BaseAutomation_Init( &argc, &argv );
stream = Journal_Register( Info_Type, __FILE__ );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) {
Stg_ComponentMeta* metaTest;
XML_IO_Handler* io;
Dictionary* allDict;
Dictionary* compDict;
CompositeVC* vc;
Journal_Printf( stream, "%s\n", Stg_Component_GetMetadata() );
metaTest = Stg_Component_CreateMeta( "blah", Variable_Type );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
allDict = Dictionary_New();
io = XML_IO_Handler_New();
IO_Handler_ReadAllFromFile( io, "data/metatest.xml", allDict );
compDict = Dictionary_GetDictionary( allDict, "components" );
vc = CompositeVC_DefaultNew( "vc" );
metaTest = Stg_Component_Validate( vc, CompositeVC_Type, compDict );
Stg_Class_Print( metaTest, stream );
Stg_Class_Delete( metaTest );
Stg_Class_Delete( io );
Stg_Class_Delete( compDict );
}
BaseAutomation_Finalise();
BaseContainer_Finalise();
BaseIO_Finalise();
RegressionTest_Finalise();
BaseFoundation_Finalise();
/* Close off MPI */
MPI_Finalize();
return 0; /* success */
}
int main( int argc, char* argv[] ) {
MPI_Comm CommWorld;
int rank;
int numProcessors;
int procToWatch;
int **keys;
MaxHeap *heap;
int i = 0;
Stream *myStream = NULL;
/* Initialise MPI, get world info */
MPI_Init( &argc, &argv );
MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
MPI_Comm_size( CommWorld, &numProcessors );
MPI_Comm_rank( CommWorld, &rank );
BaseFoundation_Init( &argc, &argv );
BaseIO_Init( &argc, &argv );
BaseContainer_Init( &argc, &argv );
if( argc >= 2 ) {
procToWatch = atoi( argv[1] );
}
else {
procToWatch = 0;
}
if( rank == procToWatch ) {
myStream = Journal_Register( InfoStream_Type, "LinkedListStream" );
data = Memory_Alloc_Array_Unnamed( int, NUM_DATA );
keys = Memory_Alloc_Array_Unnamed( int*, NUM_INITIAL_DATA );
Journal_Printf( myStream, "\nCreating the Heap\n" );
for(i=0; i<NUM_INITIAL_DATA; i++){
data[i] = i;
keys[i] = &(data[i]);
}
heap = MaxHeap_New(
(void**)(keys), sizeof(int),
NUM_INITIAL_DATA,
keySwap,
compareFunction,
extendArray );
Journal_Printf( myStream, "\nPrinting the Heap\n" );
Stg_Class_Print( heap, myStream );
Journal_Printf( myStream, "\nInserting more entries into the Heap\n" );
for( i=50; i<NUM_DATA; i++ ){
data[i] = i;
MaxHeap_Insert( heap, &(data[i]) );
}
Journal_Printf( myStream, "\nPrinting the Heap\n" );
Stg_Class_Print( heap, myStream );
Journal_Printf( myStream, "\nExtracting all the entries in the Heap\n" );
for( i=0; i<NUM_DATA; i++ ){
printf( "Heap Max %d\n", *(int*)MaxHeap_Extract( (_Heap*)heap ) );
}
Journal_Printf( myStream, "\nPrinting the Heap\n" );
Stg_Class_Print( heap, myStream );
Journal_Printf( myStream, "\nDeleting the Heap\n" );
Stg_Class_Delete( (void*)heap );
Memory_Free( data );
}
