Index: /issm/trunk-jpl/src/c/Container/DataSet.cpp =================================================================== --- /issm/trunk-jpl/src/c/Container/DataSet.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/Container/DataSet.cpp (revision 11292) @@ -258,14 +258,14 @@ dataset->AddObject(datasetinputinput);} break; - case TriaVertexElementResultEnum:{ - TriaVertexElementResult* triavertexelementresult=NULL; - triavertexelementresult=new TriaVertexElementResult(); + case TriaP1ElementResultEnum:{ + TriaP1ElementResult* triavertexelementresult=NULL; + triavertexelementresult=new TriaP1ElementResult(); triavertexelementresult->Demarshall(&marshalled_dataset); dataset->AddObject(triavertexelementresult);} break; #ifdef _HAVE_THREED_ - case PentaVertexElementResultEnum:{ - PentaVertexElementResult* pentavertexelementresult=NULL; - pentavertexelementresult=new PentaVertexElementResult(); + case PentaP1ElementResultEnum:{ + PentaP1ElementResult* pentavertexelementresult=NULL; + pentavertexelementresult=new PentaP1ElementResult(); pentavertexelementresult->Demarshall(&marshalled_dataset); dataset->AddObject(pentavertexelementresult);} Index: /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 11291) +++ /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 11292) @@ -393,9 +393,9 @@ PatchNodesEnum, PatchVerticesEnum, - PentaVertexElementResultEnum, + PentaP1ElementResultEnum, PetscVecExternalResultEnum, StringExternalResultEnum, TimeEnum, - TriaVertexElementResultEnum, + TriaP1ElementResultEnum, WaterColumnOldEnum, /*}}}*/ Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 11291) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 11292) @@ -61,6 +61,6 @@ ./objects/ElementResults/DoubleElementResult.h\ ./objects/ElementResults/DoubleElementResult.cpp\ - ./objects/ElementResults/TriaVertexElementResult.h\ - ./objects/ElementResults/TriaVertexElementResult.cpp\ + ./objects/ElementResults/TriaP1ElementResult.h\ + ./objects/ElementResults/TriaP1ElementResult.cpp\ ./objects/ElementResults/BoolElementResult.h\ ./objects/ElementResults/BoolElementResult.cpp\ @@ -559,6 +559,6 @@ threed_sources = ./objects/Gauss/GaussPenta.h\ ./objects/Gauss/GaussPenta.cpp\ - ./objects/ElementResults/PentaVertexElementResult.h\ - ./objects/ElementResults/PentaVertexElementResult.cpp\ + ./objects/ElementResults/PentaP1ElementResult.h\ + ./objects/ElementResults/PentaP1ElementResult.cpp\ ./objects/Inputs/PentaP1Input.h\ ./objects/Inputs/PentaP1Input.cpp\ Index: /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 11292) @@ -379,9 +379,9 @@ case PatchNodesEnum : return "PatchNodes"; case PatchVerticesEnum : return "PatchVertices"; - case PentaVertexElementResultEnum : return "PentaVertexElementResult"; + case PentaP1ElementResultEnum : return "PentaP1ElementResult"; case PetscVecExternalResultEnum : return "PetscVecExternalResult"; case StringExternalResultEnum : return "StringExternalResult"; case TimeEnum : return "Time"; - case TriaVertexElementResultEnum : return "TriaVertexElementResult"; + case TriaP1ElementResultEnum : return "TriaP1ElementResult"; case WaterColumnOldEnum : return "WaterColumnOld"; case MinVelEnum : return "MinVel"; Index: /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 11292) @@ -377,9 +377,9 @@ else if (strcmp(name,"PatchNodes")==0) return PatchNodesEnum; else if (strcmp(name,"PatchVertices")==0) return PatchVerticesEnum; - else if (strcmp(name,"PentaVertexElementResult")==0) return PentaVertexElementResultEnum; + else if (strcmp(name,"PentaP1ElementResult")==0) return PentaP1ElementResultEnum; else if (strcmp(name,"PetscVecExternalResult")==0) return PetscVecExternalResultEnum; else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum; else if (strcmp(name,"Time")==0) return TimeEnum; - else if (strcmp(name,"TriaVertexElementResult")==0) return TriaVertexElementResultEnum; + else if (strcmp(name,"TriaP1ElementResult")==0) return TriaP1ElementResultEnum; else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum; else if (strcmp(name,"MinVel")==0) return MinVelEnum; Index: /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.cpp (revision 11292) +++ /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.cpp (revision 11292) @@ -0,0 +1,210 @@ +/*!\file PentaP1ElementResult.c + * \brief: implementation of the PentaP1ElementResult object + */ + +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include +#include +#include "./ElementResultLocal.h" +#include "../objects.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +/*PentaP1ElementResult constructors and destructor*/ +/*FUNCTION PentaP1ElementResult::PentaP1ElementResult(){{{1*/ +PentaP1ElementResult::PentaP1ElementResult(){ + return; +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::PentaP1ElementResult(int in_enum_type,double* in_values,int in_step, double in_time){{{1*/ +PentaP1ElementResult::PentaP1ElementResult(int in_enum_type,double* in_values,int in_step, double in_time){ + + int i; + + enum_type=in_enum_type; + for(i=0;i<6;i++)values[i]=in_values[i]; + step=in_step; + time=in_time; +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::~PentaP1ElementResult(){{{1*/ +PentaP1ElementResult::~PentaP1ElementResult(){ + return; +} +/*}}}*/ + +/*Object virtual functions definitions:*/ +/*FUNCTION PentaP1ElementResult::Echo {{{1*/ +void PentaP1ElementResult::Echo(void){ + this->DeepEcho(); +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::DeepEcho{{{1*/ +void PentaP1ElementResult::DeepEcho(void){ + + printf("PentaP1ElementResult:\n"); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); + printf(" values: [%g %g %g %g %g %g]\n",this->values[0],this->values[1],this->values[2],this->values[3],this->values[4],this->values[5]); + printf(" step: %i\n",this->step); + printf(" time: %g\n",this->time); + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::Id{{{1*/ +int PentaP1ElementResult::Id(void){ return -1; } +/*}}}*/ +/*FUNCTION PentaP1ElementResult::MyRank{{{1*/ +int PentaP1ElementResult::MyRank(void){ + extern int my_rank; + return my_rank; +} +/*}}}*/ +#ifdef _SERIAL_ +/*FUNCTION PentaP1ElementResult::Marshall{{{1*/ +void PentaP1ElementResult::Marshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int enum_value=0; + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*get enum value of PentaP1ElementResult: */ + enum_value=PentaP1ElementResultEnum; + + /*marshall enum: */ + memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); + + /*marshall PentaP1ElementResult data: */ + memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); + memcpy(marshalled_dataset,&time,sizeof(time));marshalled_dataset+=sizeof(time); + memcpy(marshalled_dataset,&step,sizeof(step));marshalled_dataset+=sizeof(step); + + *pmarshalled_dataset=marshalled_dataset; +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::MarshallSize{{{1*/ +int PentaP1ElementResult::MarshallSize(){ + + return sizeof(values)+ + +sizeof(enum_type) + +sizeof(time) + +sizeof(step) + +sizeof(int); //sizeof(int) for enum value +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::Demarshall{{{1*/ +void PentaP1ElementResult::Demarshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int i; + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*this time, no need to get enum type, the pointer directly points to the beginning of the + *object data (thanks to DataSet::Demarshall):*/ + memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values); + memcpy(&time,marshalled_dataset,sizeof(time));marshalled_dataset+=sizeof(time); + memcpy(&step,marshalled_dataset,sizeof(step));marshalled_dataset+=sizeof(step); + + /*return: */ + *pmarshalled_dataset=marshalled_dataset; + return; +} +/*}}}*/ +#endif +/*FUNCTION PentaP1ElementResult::ObjectEnum{{{1*/ +int PentaP1ElementResult::ObjectEnum(void){ + + return PentaP1ElementResultEnum; + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::copy{{{1*/ +Object* PentaP1ElementResult::copy() { + + return new PentaP1ElementResult(this->enum_type,this->values,this->step,this->time); + +} +/*}}}*/ + +/*ElementResult management*/ +/*FUNCTION PentaP1ElementResult::InstanceEnum{{{1*/ +int PentaP1ElementResult::InstanceEnum(void){ + + return this->enum_type; + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::SpawnTriaElementResult{{{1*/ +ElementResult* PentaP1ElementResult::SpawnTriaElementResult(int* indices){ + + /*output*/ + TriaP1ElementResult* outresult=NULL; + double newvalues[3]; + + /*Loop over the new indices*/ + for(int i=0;i<3;i++){ + + /*Check index value*/ + _assert_(indices[i]>=0 && indices[i]<6); + + /*Assign value to new result*/ + newvalues[i]=this->values[indices[i]]; + } + + /*Create new Tria result*/ + outresult=new TriaP1ElementResult(this->enum_type,&newvalues[0],this->step,this->time); + + /*Assign output*/ + return outresult; + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::ProcessUnits{{{1*/ +void PentaP1ElementResult::ProcessUnits(Parameters* parameters){ + + UnitConversion(this->values,6,IuToExtEnum,this->enum_type); + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::NumberOfNodalValues{{{1*/ +int PentaP1ElementResult::NumberOfNodalValues(void){ + return 6; +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::PatchFill{{{1*/ +void PentaP1ElementResult::PatchFill(int row, Patch* patch){ + + /*Here, we fill the result information into the patch object. First, let's remember what is in a row + * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values + * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */ + patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,6); + +} +/*}}}*/ +/*FUNCTION PentaP1ElementResult::GetVectorFromResults{{{1*/ +void PentaP1ElementResult::GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs){ + + double data[6]; + + if(numdofs!=6)_error_("Result %s is a PentaP1ElementResult and cannot write vector of %i dofs",numdofs); + for(int i=0;i<6;i++) data[i]=this->values[i]/(double)connectivitylist[i]; + VecSetValues(vector,numdofs,doflist,(const double*)&data,ADD_VALUES); + +} /*}}}*/ +/*FUNCTION PentaP1ElementResult::GetElementVectorFromResults{{{1*/ +void PentaP1ElementResult::GetElementVectorFromResults(Vec vector,int dof){ + + _error_("Result %s is a PentaP1ElementResult and should not write vector of size numberofelemenrs",EnumToStringx(enum_type)); +} /*}}}*/ Index: /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.h =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.h (revision 11292) +++ /issm/trunk-jpl/src/c/objects/ElementResults/PentaP1ElementResult.h (revision 11292) @@ -0,0 +1,59 @@ +/*! \file PentaP1ElementResult.h + * \brief: header file for PentaP1ElementResult object + * this object is just a PentaP1Input with additional time and step info. + */ + + +#ifndef _PENTAP1ELEMENTRESULT_H_ +#define _PENTAP1ELEMENTRESULT_H_ + +/*Headers:*/ +/*{{{1*/ +#include "../Inputs/Input.h" +#include "../../include/include.h" +/*}}}*/ + +class PentaP1ElementResult: public ElementResult{ + + private: + int enum_type; + double values[6]; + int step; + double time; + + public: + + /*PentaP1ElementResult constructors, destructors: {{{1*/ + PentaP1ElementResult(); + PentaP1ElementResult(int enum_type,double* values,int step, double time); + ~PentaP1ElementResult(); + /*}}}*/ + /*Object virtual functions definitions:{{{1 */ + void Echo(); + void DeepEcho(); + int Id(); + int MyRank(); + #ifdef _SERIAL_ + void Marshall(char** pmarshalled_dataset); + int MarshallSize(); + void Demarshall(char** pmarshalled_dataset); + #endif + int ObjectEnum(); + Object* copy(); + /*}}}*/ + /*ElementResult virtual functions definitions: {{{1*/ + ElementResult* SpawnTriaElementResult(int* indices); + double GetTime(void){return time;}; + int GetStep(void){return step;}; + void ProcessUnits(Parameters* parameters); + int NumberOfNodalValues(void); + void PatchFill(int row, Patch* patch); + /*}}}*/ + /*PentaP1ElementResult management: {{{1*/ + int InstanceEnum(); + void GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs); + void GetElementVectorFromResults(Vec vector,int dof); + /*}}}*/ + +}; +#endif /* _PENTAP1ELEMENTRESULT_H */ Index: sm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.cpp (revision 11291) +++ (revision ) @@ -1,210 +1,0 @@ -/*!\file PentaVertexElementResult.c - * \brief: implementation of the PentaVertexElementResult object - */ - -#ifdef HAVE_CONFIG_H - #include -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include -#include -#include "./ElementResultLocal.h" -#include "../objects.h" -#include "../../EnumDefinitions/EnumDefinitions.h" -#include "../../shared/shared.h" -#include "../../Container/Container.h" -#include "../../include/include.h" - -/*PentaVertexElementResult constructors and destructor*/ -/*FUNCTION PentaVertexElementResult::PentaVertexElementResult(){{{1*/ -PentaVertexElementResult::PentaVertexElementResult(){ - return; -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::PentaVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){{{1*/ -PentaVertexElementResult::PentaVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){ - - int i; - - enum_type=in_enum_type; - for(i=0;i<6;i++)values[i]=in_values[i]; - step=in_step; - time=in_time; -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::~PentaVertexElementResult(){{{1*/ -PentaVertexElementResult::~PentaVertexElementResult(){ - return; -} -/*}}}*/ - -/*Object virtual functions definitions:*/ -/*FUNCTION PentaVertexElementResult::Echo {{{1*/ -void PentaVertexElementResult::Echo(void){ - this->DeepEcho(); -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::DeepEcho{{{1*/ -void PentaVertexElementResult::DeepEcho(void){ - - printf("PentaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); - printf(" values: [%g %g %g %g %g %g]\n",this->values[0],this->values[1],this->values[2],this->values[3],this->values[4],this->values[5]); - printf(" step: %i\n",this->step); - printf(" time: %g\n",this->time); - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::Id{{{1*/ -int PentaVertexElementResult::Id(void){ return -1; } -/*}}}*/ -/*FUNCTION PentaVertexElementResult::MyRank{{{1*/ -int PentaVertexElementResult::MyRank(void){ - extern int my_rank; - return my_rank; -} -/*}}}*/ -#ifdef _SERIAL_ -/*FUNCTION PentaVertexElementResult::Marshall{{{1*/ -void PentaVertexElementResult::Marshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int enum_value=0; - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*get enum value of PentaVertexElementResult: */ - enum_value=PentaVertexElementResultEnum; - - /*marshall enum: */ - memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); - - /*marshall PentaVertexElementResult data: */ - memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); - memcpy(marshalled_dataset,&time,sizeof(time));marshalled_dataset+=sizeof(time); - memcpy(marshalled_dataset,&step,sizeof(step));marshalled_dataset+=sizeof(step); - - *pmarshalled_dataset=marshalled_dataset; -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::MarshallSize{{{1*/ -int PentaVertexElementResult::MarshallSize(){ - - return sizeof(values)+ - +sizeof(enum_type) - +sizeof(time) - +sizeof(step) - +sizeof(int); //sizeof(int) for enum value -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::Demarshall{{{1*/ -void PentaVertexElementResult::Demarshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int i; - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*this time, no need to get enum type, the pointer directly points to the beginning of the - *object data (thanks to DataSet::Demarshall):*/ - memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values); - memcpy(&time,marshalled_dataset,sizeof(time));marshalled_dataset+=sizeof(time); - memcpy(&step,marshalled_dataset,sizeof(step));marshalled_dataset+=sizeof(step); - - /*return: */ - *pmarshalled_dataset=marshalled_dataset; - return; -} -/*}}}*/ -#endif -/*FUNCTION PentaVertexElementResult::ObjectEnum{{{1*/ -int PentaVertexElementResult::ObjectEnum(void){ - - return PentaVertexElementResultEnum; - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::copy{{{1*/ -Object* PentaVertexElementResult::copy() { - - return new PentaVertexElementResult(this->enum_type,this->values,this->step,this->time); - -} -/*}}}*/ - -/*ElementResult management*/ -/*FUNCTION PentaVertexElementResult::InstanceEnum{{{1*/ -int PentaVertexElementResult::InstanceEnum(void){ - - return this->enum_type; - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::SpawnTriaElementResult{{{1*/ -ElementResult* PentaVertexElementResult::SpawnTriaElementResult(int* indices){ - - /*output*/ - TriaVertexElementResult* outresult=NULL; - double newvalues[3]; - - /*Loop over the new indices*/ - for(int i=0;i<3;i++){ - - /*Check index value*/ - _assert_(indices[i]>=0 && indices[i]<6); - - /*Assign value to new result*/ - newvalues[i]=this->values[indices[i]]; - } - - /*Create new Tria result*/ - outresult=new TriaVertexElementResult(this->enum_type,&newvalues[0],this->step,this->time); - - /*Assign output*/ - return outresult; - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::ProcessUnits{{{1*/ -void PentaVertexElementResult::ProcessUnits(Parameters* parameters){ - - UnitConversion(this->values,6,IuToExtEnum,this->enum_type); - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::NumberOfNodalValues{{{1*/ -int PentaVertexElementResult::NumberOfNodalValues(void){ - return 6; -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::PatchFill{{{1*/ -void PentaVertexElementResult::PatchFill(int row, Patch* patch){ - - /*Here, we fill the result information into the patch object. First, let's remember what is in a row - * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values - * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */ - patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,6); - -} -/*}}}*/ -/*FUNCTION PentaVertexElementResult::GetVectorFromResults{{{1*/ -void PentaVertexElementResult::GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs){ - - double data[6]; - - if(numdofs!=6)_error_("Result %s is a PentaVertexElementResult and cannot write vector of %i dofs",numdofs); - for(int i=0;i<6;i++) data[i]=this->values[i]/(double)connectivitylist[i]; - VecSetValues(vector,numdofs,doflist,(const double*)&data,ADD_VALUES); - -} /*}}}*/ -/*FUNCTION PentaVertexElementResult::GetElementVectorFromResults{{{1*/ -void PentaVertexElementResult::GetElementVectorFromResults(Vec vector,int dof){ - - _error_("Result %s is a PentaVertexElementResult and should not write vector of size numberofelemenrs",EnumToStringx(enum_type)); -} /*}}}*/ Index: sm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h (revision 11291) +++ (revision ) @@ -1,59 +1,0 @@ -/*! \file PentaVertexElementResult.h - * \brief: header file for penta vertex result object. - * this object is just a PentaP1Input with additional time and step info. - */ - - -#ifndef _PENTAVERTEXELEMENTRESULT_H_ -#define _PENTAVERTEXELEMENTRESULT_H_ - -/*Headers:*/ -/*{{{1*/ -#include "../Inputs/Input.h" -#include "../../include/include.h" -/*}}}*/ - -class PentaVertexElementResult: public ElementResult{ - - private: - int enum_type; - double values[6]; - int step; - double time; - - public: - - /*PentaVertexElementResult constructors, destructors: {{{1*/ - PentaVertexElementResult(); - PentaVertexElementResult(int enum_type,double* values,int step, double time); - ~PentaVertexElementResult(); - /*}}}*/ - /*Object virtual functions definitions:{{{1 */ - void Echo(); - void DeepEcho(); - int Id(); - int MyRank(); - #ifdef _SERIAL_ - void Marshall(char** pmarshalled_dataset); - int MarshallSize(); - void Demarshall(char** pmarshalled_dataset); - #endif - int ObjectEnum(); - Object* copy(); - /*}}}*/ - /*ElementResult virtual functions definitions: {{{1*/ - ElementResult* SpawnTriaElementResult(int* indices); - double GetTime(void){return time;}; - int GetStep(void){return step;}; - void ProcessUnits(Parameters* parameters); - int NumberOfNodalValues(void); - void PatchFill(int row, Patch* patch); - /*}}}*/ - /*PentaVertexElementResult management: {{{1*/ - int InstanceEnum(); - void GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs); - void GetElementVectorFromResults(Vec vector,int dof); - /*}}}*/ - -}; -#endif /* _PENTAVERTEXELEMENTRESULT_H */ Index: /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.cpp (revision 11292) +++ /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.cpp (revision 11292) @@ -0,0 +1,199 @@ +/*!\file TriaP1ElementResult.c + * \brief: implementation of the TriaP1ElementResult object + */ + +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include +#include +#include "./ElementResultLocal.h" +#include "../objects.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +/*TriaP1ElementResult constructors and destructor*/ +/*FUNCTION TriaP1ElementResult::TriaP1ElementResult(){{{1*/ +TriaP1ElementResult::TriaP1ElementResult(){ + return; +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::TriaP1ElementResult(int in_enum_type,double* in_values,int in_step, double in_time){{{1*/ +TriaP1ElementResult::TriaP1ElementResult(int in_enum_type,double* in_values,int in_step, double in_time){ + + enum_type=in_enum_type; + values[0]=in_values[0]; + values[1]=in_values[1]; + values[2]=in_values[2]; + step=in_step; + time=in_time; +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::~TriaP1ElementResult(){{{1*/ +TriaP1ElementResult::~TriaP1ElementResult(){ + return; +} +/*}}}*/ + +/*Object virtual functions definitions:*/ +/*FUNCTION TriaP1ElementResult::Echo {{{1*/ +void TriaP1ElementResult::Echo(void){ + this->DeepEcho(); +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::DeepEcho{{{1*/ +void TriaP1ElementResult::DeepEcho(void){ + + printf("TriaP1ElementResult:\n"); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); + printf(" values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]); + printf(" step: %i\n",this->step); + printf(" time: %g\n",this->time); +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::Id{{{1*/ +int TriaP1ElementResult::Id(void){ return -1; } +/*}}}*/ +/*FUNCTION TriaP1ElementResult::MyRank{{{1*/ +int TriaP1ElementResult::MyRank(void){ + extern int my_rank; + return my_rank; +} +/*}}}*/ +#ifdef _SERIAL_ +/*FUNCTION TriaP1ElementResult::Marshall{{{1*/ +void TriaP1ElementResult::Marshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int enum_value=0; + + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*get enum value of TriaP1ElementResult: */ + enum_value=TriaP1ElementResultEnum; + + /*marshall enum: */ + memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); + + /*marshall TriaP1ElementResult data: */ + memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); + memcpy(marshalled_dataset,&time,sizeof(time));marshalled_dataset+=sizeof(time); + memcpy(marshalled_dataset,&step,sizeof(step));marshalled_dataset+=sizeof(step); + + *pmarshalled_dataset=marshalled_dataset; +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::MarshallSize{{{1*/ +int TriaP1ElementResult::MarshallSize(){ + + return sizeof(values) + +sizeof(enum_type) + +sizeof(time) + +sizeof(step) + +sizeof(int); //sizeof(int) for enum value +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::Demarshall{{{1*/ +void TriaP1ElementResult::Demarshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int i; + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*this time, no need to get enum type, the pointer directly points to the beginning of the + *object data (thanks to DataSet::Demarshall):*/ + memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values); + memcpy(&time,marshalled_dataset,sizeof(time));marshalled_dataset+=sizeof(time); + memcpy(&step,marshalled_dataset,sizeof(step));marshalled_dataset+=sizeof(step); + + /*return: */ + *pmarshalled_dataset=marshalled_dataset; + return; +} +/*}}}*/ +#endif +/*FUNCTION TriaP1ElementResult::ObjectEnum{{{1*/ +int TriaP1ElementResult::ObjectEnum(void){ + + return TriaP1ElementResultEnum; + +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::copy{{{1*/ +Object* TriaP1ElementResult::copy() { + + return new TriaP1ElementResult(this->enum_type,this->values,this->step,this->time); + +} +/*}}}*/ + +/*ElementResult management*/ +/*FUNCTION TriaP1ElementResult::InstanceEnum{{{1*/ +int TriaP1ElementResult::InstanceEnum(void){ + + return this->enum_type; + +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::SpawnTriaElementResult{{{1*/ +ElementResult* TriaP1ElementResult::SpawnTriaElementResult(int* indices){ + + /*output*/ + TriaP1ElementResult* outresult=NULL; + + /*Create new Tria result (copy of current result)*/ + outresult=new TriaP1ElementResult(this->enum_type,&this->values[0],this->step,this->time); + + /*Assign output*/ + return outresult; + +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::ProcessUnits{{{1*/ +void TriaP1ElementResult::ProcessUnits(Parameters* parameters){ + + UnitConversion(this->values,3,IuToExtEnum,this->enum_type); + +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::NumberOfNodalValues{{{1*/ +int TriaP1ElementResult::NumberOfNodalValues(void){ + return 3; +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::PatchFill{{{1*/ +void TriaP1ElementResult::PatchFill(int row, Patch* patch){ + + /*Here, we fill the result information into the patch object. First, let's remember what is in a row + * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values + * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */ + patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,3); + +} +/*}}}*/ +/*FUNCTION TriaP1ElementResult::GetVectorFromResults{{{1*/ +void TriaP1ElementResult::GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs){ + + double data[3]; + + if(numdofs!=3)_error_("Result %s is a TriaP1ElementResult and cannot write vector of %i dofs",numdofs); + for(int i=0;i<3;i++) data[i]=this->values[i]/(double)connectivitylist[i]; + VecSetValues(vector,numdofs,doflist,(const double*)&data,ADD_VALUES); + +} /*}}}*/ +/*FUNCTION TriaP1ElementResult::GetElementVectorFromResults{{{1*/ +void TriaP1ElementResult::GetElementVectorFromResults(Vec vector,int dof){ + + _error_("Result %s is a TriaP1ElementResult and should not write vector of size numberofelemenrs",EnumToStringx(enum_type)); +} /*}}}*/ Index: /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.h =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.h (revision 11292) +++ /issm/trunk-jpl/src/c/objects/ElementResults/TriaP1ElementResult.h (revision 11292) @@ -0,0 +1,58 @@ +/*! \file TriaP1ElementResult.h + * \brief: header file for TriaP1ElementResult object + */ + + +#ifndef _TRIAP1ELEMENTRESULT_H_ +#define _TRIAP1ELEMENTRESULT_H_ + +/*Headers:*/ +/*{{{1*/ +#include "../Inputs/Input.h" +#include "../../include/include.h" +/*}}}*/ + +class TriaP1ElementResult: public ElementResult{ + + private: + int enum_type; + double values[3]; + int step; + double time; + + public: + + /*TriaP1ElementResult constructors, destructors: {{{1*/ + TriaP1ElementResult(); + TriaP1ElementResult(int enum_type,double* values,int step,double time); + ~TriaP1ElementResult(); + /*}}}*/ + /*Object virtual functions definitions:{{{1 */ + void Echo(); + void DeepEcho(); + int Id(); + int MyRank(); + #ifdef _SERIAL_ + void Marshall(char** pmarshalled_dataset); + int MarshallSize(); + void Demarshall(char** pmarshalled_dataset); + #endif + int ObjectEnum(); + Object* copy(); + /*}}}*/ + /*ElementResult virtual functions definitions: {{{1*/ + ElementResult* SpawnTriaElementResult(int* indices); + double GetTime(void){return time;}; + int GetStep(void){return step;}; + void ProcessUnits(Parameters* parameters); + int NumberOfNodalValues(void); + void PatchFill(int row, Patch* patch); + /*}}}*/ + /*TriaP1ElementResult management: {{{1*/ + int InstanceEnum(); + void GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs); + void GetElementVectorFromResults(Vec vector,int dof); + /*}}}*/ + +}; +#endif /* _TRIAP1ELEMENTRESULT_H */ Index: sm/trunk-jpl/src/c/objects/ElementResults/TriaVertexElementResult.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/TriaVertexElementResult.cpp (revision 11291) +++ (revision ) @@ -1,199 +1,0 @@ -/*!\file TriaVertexElementResult.c - * \brief: implementation of the TriaVertexElementResult object - */ - -#ifdef HAVE_CONFIG_H - #include -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include -#include -#include "./ElementResultLocal.h" -#include "../objects.h" -#include "../../EnumDefinitions/EnumDefinitions.h" -#include "../../shared/shared.h" -#include "../../Container/Container.h" -#include "../../include/include.h" - -/*TriaVertexElementResult constructors and destructor*/ -/*FUNCTION TriaVertexElementResult::TriaVertexElementResult(){{{1*/ -TriaVertexElementResult::TriaVertexElementResult(){ - return; -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::TriaVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){{{1*/ -TriaVertexElementResult::TriaVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){ - - enum_type=in_enum_type; - values[0]=in_values[0]; - values[1]=in_values[1]; - values[2]=in_values[2]; - step=in_step; - time=in_time; -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::~TriaVertexElementResult(){{{1*/ -TriaVertexElementResult::~TriaVertexElementResult(){ - return; -} -/*}}}*/ - -/*Object virtual functions definitions:*/ -/*FUNCTION TriaVertexElementResult::Echo {{{1*/ -void TriaVertexElementResult::Echo(void){ - this->DeepEcho(); -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::DeepEcho{{{1*/ -void TriaVertexElementResult::DeepEcho(void){ - - printf("TriaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); - printf(" values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]); - printf(" step: %i\n",this->step); - printf(" time: %g\n",this->time); -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::Id{{{1*/ -int TriaVertexElementResult::Id(void){ return -1; } -/*}}}*/ -/*FUNCTION TriaVertexElementResult::MyRank{{{1*/ -int TriaVertexElementResult::MyRank(void){ - extern int my_rank; - return my_rank; -} -/*}}}*/ -#ifdef _SERIAL_ -/*FUNCTION TriaVertexElementResult::Marshall{{{1*/ -void TriaVertexElementResult::Marshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int enum_value=0; - - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*get enum value of TriaVertexElementResult: */ - enum_value=TriaVertexElementResultEnum; - - /*marshall enum: */ - memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); - - /*marshall TriaVertexElementResult data: */ - memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); - memcpy(marshalled_dataset,&time,sizeof(time));marshalled_dataset+=sizeof(time); - memcpy(marshalled_dataset,&step,sizeof(step));marshalled_dataset+=sizeof(step); - - *pmarshalled_dataset=marshalled_dataset; -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::MarshallSize{{{1*/ -int TriaVertexElementResult::MarshallSize(){ - - return sizeof(values) - +sizeof(enum_type) - +sizeof(time) - +sizeof(step) - +sizeof(int); //sizeof(int) for enum value -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::Demarshall{{{1*/ -void TriaVertexElementResult::Demarshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int i; - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*this time, no need to get enum type, the pointer directly points to the beginning of the - *object data (thanks to DataSet::Demarshall):*/ - memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values); - memcpy(&time,marshalled_dataset,sizeof(time));marshalled_dataset+=sizeof(time); - memcpy(&step,marshalled_dataset,sizeof(step));marshalled_dataset+=sizeof(step); - - /*return: */ - *pmarshalled_dataset=marshalled_dataset; - return; -} -/*}}}*/ -#endif -/*FUNCTION TriaVertexElementResult::ObjectEnum{{{1*/ -int TriaVertexElementResult::ObjectEnum(void){ - - return TriaVertexElementResultEnum; - -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::copy{{{1*/ -Object* TriaVertexElementResult::copy() { - - return new TriaVertexElementResult(this->enum_type,this->values,this->step,this->time); - -} -/*}}}*/ - -/*ElementResult management*/ -/*FUNCTION TriaVertexElementResult::InstanceEnum{{{1*/ -int TriaVertexElementResult::InstanceEnum(void){ - - return this->enum_type; - -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::SpawnTriaElementResult{{{1*/ -ElementResult* TriaVertexElementResult::SpawnTriaElementResult(int* indices){ - - /*output*/ - TriaVertexElementResult* outresult=NULL; - - /*Create new Tria result (copy of current result)*/ - outresult=new TriaVertexElementResult(this->enum_type,&this->values[0],this->step,this->time); - - /*Assign output*/ - return outresult; - -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::ProcessUnits{{{1*/ -void TriaVertexElementResult::ProcessUnits(Parameters* parameters){ - - UnitConversion(this->values,3,IuToExtEnum,this->enum_type); - -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::NumberOfNodalValues{{{1*/ -int TriaVertexElementResult::NumberOfNodalValues(void){ - return 3; -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::PatchFill{{{1*/ -void TriaVertexElementResult::PatchFill(int row, Patch* patch){ - - /*Here, we fill the result information into the patch object. First, let's remember what is in a row - * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values - * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */ - patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,3); - -} -/*}}}*/ -/*FUNCTION TriaVertexElementResult::GetVectorFromResults{{{1*/ -void TriaVertexElementResult::GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs){ - - double data[3]; - - if(numdofs!=3)_error_("Result %s is a TriaVertexElementResult and cannot write vector of %i dofs",numdofs); - for(int i=0;i<3;i++) data[i]=this->values[i]/(double)connectivitylist[i]; - VecSetValues(vector,numdofs,doflist,(const double*)&data,ADD_VALUES); - -} /*}}}*/ -/*FUNCTION TriaVertexElementResult::GetElementVectorFromResults{{{1*/ -void TriaVertexElementResult::GetElementVectorFromResults(Vec vector,int dof){ - - _error_("Result %s is a TriaVertexElementResult and should not write vector of size numberofelemenrs",EnumToStringx(enum_type)); -} /*}}}*/ Index: sm/trunk-jpl/src/c/objects/ElementResults/TriaVertexElementResult.h =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/TriaVertexElementResult.h (revision 11291) +++ (revision ) @@ -1,58 +1,0 @@ -/*! \file TriaVertexElementResult.h - * \brief: header file for triavertexresult object - */ - - -#ifndef _TRIAVERTEXELEMENTRESULT_H_ -#define _TRIAVERTEXELEMENTRESULT_H_ - -/*Headers:*/ -/*{{{1*/ -#include "../Inputs/Input.h" -#include "../../include/include.h" -/*}}}*/ - -class TriaVertexElementResult: public ElementResult{ - - private: - int enum_type; - double values[3]; - int step; - double time; - - public: - - /*TriaVertexElementResult constructors, destructors: {{{1*/ - TriaVertexElementResult(); - TriaVertexElementResult(int enum_type,double* values,int step,double time); - ~TriaVertexElementResult(); - /*}}}*/ - /*Object virtual functions definitions:{{{1 */ - void Echo(); - void DeepEcho(); - int Id(); - int MyRank(); - #ifdef _SERIAL_ - void Marshall(char** pmarshalled_dataset); - int MarshallSize(); - void Demarshall(char** pmarshalled_dataset); - #endif - int ObjectEnum(); - Object* copy(); - /*}}}*/ - /*ElementResult virtual functions definitions: {{{1*/ - ElementResult* SpawnTriaElementResult(int* indices); - double GetTime(void){return time;}; - int GetStep(void){return step;}; - void ProcessUnits(Parameters* parameters); - int NumberOfNodalValues(void); - void PatchFill(int row, Patch* patch); - /*}}}*/ - /*TriaVertexElementResult management: {{{1*/ - int InstanceEnum(); - void GetVectorFromResults(Vec vector,int* doflist,int* connectivitylist,int numdofs); - void GetElementVectorFromResults(Vec vector,int dof); - /*}}}*/ - -}; -#endif /* _TRIAVERTEXELEMENTRESULT_H */ Index: /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp (revision 11292) @@ -2157,5 +2157,5 @@ resultstimes[i]=elementresult->GetTime(); resultssteps[i]=elementresult->GetStep(); - if(elementresult->ObjectEnum()==PentaVertexElementResultEnum){ + if(elementresult->ObjectEnum()==PentaP1ElementResultEnum){ resultssizes[i]=P1Enum; } Index: /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp (revision 11292) @@ -1985,5 +1985,5 @@ resultstimes[i]=elementresult->GetTime(); resultssteps[i]=elementresult->GetStep(); - if(elementresult->ObjectEnum()==TriaVertexElementResultEnum){ + if(elementresult->ObjectEnum()==TriaP1ElementResultEnum){ resultssizes[i]=P1Enum; } Index: /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp (revision 11292) @@ -172,5 +172,5 @@ ElementResult* PentaP1Input::SpawnResult(int step, double time){ - return new PentaVertexElementResult(this->enum_type,this->values,step,time); + return new PentaP1ElementResult(this->enum_type,this->values,step,time); } Index: /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h (revision 11292) @@ -1,9 +1,9 @@ /*! \file PentaP1Input.h - * \brief: header file for triavertexinput object + * \brief: header file for PentaP1Input object */ -#ifndef _PENTAVERTEXINPUT_H_ -#define _PENTAVERTEXINPUT_H_ +#ifndef _PENTAP1INPUT_H_ +#define _PENTAP1INPUT_H_ /*Headers:*/ @@ -87,3 +87,3 @@ }; -#endif /* _PENTAVERTEXINPUT_H */ +#endif /* _PENTAP1INPUT_H */ Index: /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp (revision 11292) @@ -161,5 +161,5 @@ ElementResult* TriaP1Input::SpawnResult(int step, double time){ - return new TriaVertexElementResult(this->enum_type,this->values,step,time); + return new TriaP1ElementResult(this->enum_type,this->values,step,time); } Index: /issm/trunk-jpl/src/c/objects/objects.h =================================================================== --- /issm/trunk-jpl/src/c/objects/objects.h (revision 11291) +++ /issm/trunk-jpl/src/c/objects/objects.h (revision 11292) @@ -97,6 +97,6 @@ #include "./ElementResults/ElementResult.h" #include "./ElementResults/DoubleElementResult.h" -#include "./ElementResults/TriaVertexElementResult.h" -#include "./ElementResults/PentaVertexElementResult.h" +#include "./ElementResults/TriaP1ElementResult.h" +#include "./ElementResults/PentaP1ElementResult.h" #include "./ElementResults/BoolElementResult.h"