Index: /issm/trunk-jpl/src/c/Container/DataSet.cpp =================================================================== --- /issm/trunk-jpl/src/c/Container/DataSet.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/Container/DataSet.cpp (revision 11291) @@ -224,14 +224,14 @@ dataset->AddObject(tria);} break; - case TriaVertexInputEnum:{ - TriaVertexInput* triavertexinput=NULL; - triavertexinput=new TriaVertexInput(); + case TriaP1InputEnum:{ + TriaP1Input* triavertexinput=NULL; + triavertexinput=new TriaP1Input(); triavertexinput->Demarshall(&marshalled_dataset); dataset->AddObject(triavertexinput);} break; #ifdef _HAVE_THREED_ - case PentaVertexInputEnum:{ - PentaVertexInput* pentavertexinput=NULL; - pentavertexinput=new PentaVertexInput(); + case PentaP1InputEnum:{ + PentaP1Input* pentavertexinput=NULL; + pentavertexinput=new PentaP1Input(); pentavertexinput->Demarshall(&marshalled_dataset); dataset->AddObject(pentavertexinput);} Index: /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 11290) +++ /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 11291) @@ -261,5 +261,5 @@ PenpairEnum, PentaEnum, - PentaVertexInputEnum, + PentaP1InputEnum, PetscMatParamEnum, PetscVecParamEnum, @@ -274,5 +274,5 @@ StringParamEnum, TriaEnum, - TriaVertexInputEnum, + TriaP1InputEnum, VertexEnum, /*}}}*/ Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 11290) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 11291) @@ -88,6 +88,6 @@ ./objects/Inputs/Input.h\ ./objects/Inputs/InputLocal.h\ - ./objects/Inputs/TriaVertexInput.h\ - ./objects/Inputs/TriaVertexInput.cpp\ + ./objects/Inputs/TriaP1Input.h\ + ./objects/Inputs/TriaP1Input.cpp\ ./objects/Inputs/BoolInput.h\ ./objects/Inputs/BoolInput.cpp\ @@ -561,6 +561,6 @@ ./objects/ElementResults/PentaVertexElementResult.h\ ./objects/ElementResults/PentaVertexElementResult.cpp\ - ./objects/Inputs/PentaVertexInput.h\ - ./objects/Inputs/PentaVertexInput.cpp\ + ./objects/Inputs/PentaP1Input.h\ + ./objects/Inputs/PentaP1Input.cpp\ ./objects/Elements/Penta.h\ ./objects/Elements/Penta.cpp\ Index: /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 11291) @@ -257,5 +257,5 @@ case PenpairEnum : return "Penpair"; case PentaEnum : return "Penta"; - case PentaVertexInputEnum : return "PentaVertexInput"; + case PentaP1InputEnum : return "PentaP1Input"; case PetscMatParamEnum : return "PetscMatParam"; case PetscVecParamEnum : return "PetscVecParam"; @@ -270,5 +270,5 @@ case StringParamEnum : return "StringParam"; case TriaEnum : return "Tria"; - case TriaVertexInputEnum : return "TriaVertexInput"; + case TriaP1InputEnum : return "TriaP1Input"; case VertexEnum : return "Vertex"; case AirEnum : return "Air"; Index: /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 11291) @@ -255,5 +255,5 @@ else if (strcmp(name,"Penpair")==0) return PenpairEnum; else if (strcmp(name,"Penta")==0) return PentaEnum; - else if (strcmp(name,"PentaVertexInput")==0) return PentaVertexInputEnum; + else if (strcmp(name,"PentaP1Input")==0) return PentaP1InputEnum; else if (strcmp(name,"PetscMatParam")==0) return PetscMatParamEnum; else if (strcmp(name,"PetscVecParam")==0) return PetscVecParamEnum; @@ -268,5 +268,5 @@ else if (strcmp(name,"StringParam")==0) return StringParamEnum; else if (strcmp(name,"Tria")==0) return TriaEnum; - else if (strcmp(name,"TriaVertexInput")==0) return TriaVertexInputEnum; + else if (strcmp(name,"TriaP1Input")==0) return TriaP1InputEnum; else if (strcmp(name,"Vertex")==0) return VertexEnum; else if (strcmp(name,"Air")==0) return AirEnum; Index: /issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h =================================================================== --- /issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h (revision 11290) +++ /issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h (revision 11291) @@ -1,5 +1,5 @@ /*! \file PentaVertexElementResult.h * \brief: header file for penta vertex result object. - * this object is just a PentaVertexInput with additional time and step info. + * this object is just a PentaP1Input with additional time and step info. */ Index: /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/objects/Elements/Penta.cpp (revision 11291) @@ -347,5 +347,5 @@ if (!IsOnBed() || IsFloating()){ //empty friction: - this->inputs->AddInput(new PentaVertexInput(BasalFrictionEnum,&basalfriction[0])); + this->inputs->AddInput(new PentaP1Input(BasalFrictionEnum,&basalfriction[0])); return; } @@ -375,5 +375,5 @@ /*Create PentaVertex input, which will hold the basal friction:*/ - this->inputs->AddInput(new PentaVertexInput(BasalFrictionEnum,&basalfriction[0])); + this->inputs->AddInput(new PentaP1Input(BasalFrictionEnum,&basalfriction[0])); /*Clean up and return*/ @@ -523,10 +523,10 @@ /*Add Stress tensor components into inputs*/ - this->inputs->AddInput(new PentaVertexInput(StressTensorxxEnum,&sigma_xx[0])); - this->inputs->AddInput(new PentaVertexInput(StressTensorxyEnum,&sigma_xy[0])); - this->inputs->AddInput(new PentaVertexInput(StressTensorxzEnum,&sigma_xz[0])); - this->inputs->AddInput(new PentaVertexInput(StressTensoryyEnum,&sigma_yy[0])); - this->inputs->AddInput(new PentaVertexInput(StressTensoryzEnum,&sigma_yz[0])); - this->inputs->AddInput(new PentaVertexInput(StressTensorzzEnum,&sigma_zz[0])); + this->inputs->AddInput(new PentaP1Input(StressTensorxxEnum,&sigma_xx[0])); + this->inputs->AddInput(new PentaP1Input(StressTensorxyEnum,&sigma_xy[0])); + this->inputs->AddInput(new PentaP1Input(StressTensorxzEnum,&sigma_xz[0])); + this->inputs->AddInput(new PentaP1Input(StressTensoryyEnum,&sigma_yy[0])); + this->inputs->AddInput(new PentaP1Input(StressTensoryzEnum,&sigma_yz[0])); + this->inputs->AddInput(new PentaP1Input(StressTensorzzEnum,&sigma_zz[0])); /*Clean up and return*/ @@ -1347,5 +1347,5 @@ /*create static input: */ - this->inputs->AddInput(new PentaVertexInput(vector_enum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(vector_enum,nodeinputs)); } else if(M==numberofvertices+1){ @@ -1366,5 +1366,5 @@ if(t==0)transientinput=new TransientInput(vector_enum); - transientinput->AddTimeInput(new PentaVertexInput(vector_enum,nodeinputs),time); + transientinput->AddTimeInput(new PentaP1Input(vector_enum,nodeinputs),time); } this->inputs->AddInput(transientinput); @@ -1420,5 +1420,5 @@ /*OK, we are on bed. Initialize global inputs as 0*/ - total_thickness_input =new PentaVertexInput(ThicknessEnum,zeros_list); + total_thickness_input =new PentaP1Input(ThicknessEnum,zeros_list); /*Now follow all the upper element from the base to the surface to integrate the input*/ @@ -1438,8 +1438,8 @@ /*If first time, initialize total_integrated_input*/ if (step==0){ - if (original_input->ObjectEnum()==PentaVertexInputEnum) - total_integrated_input=new PentaVertexInput(average_enum_type,zeros_list); + if (original_input->ObjectEnum()==PentaP1InputEnum) + total_integrated_input=new PentaP1Input(average_enum_type,zeros_list); else if (original_input->ObjectEnum()==ControlInputEnum) - total_integrated_input=new PentaVertexInput(average_enum_type,zeros_list); + total_integrated_input=new PentaP1Input(average_enum_type,zeros_list); else if (original_input->ObjectEnum()==DoubleInputEnum) total_integrated_input=new DoubleInput(average_enum_type,0.0); @@ -1454,5 +1454,5 @@ Helem_list[i+3]=Helem_list[i]; } - element_thickness_input=new PentaVertexInput(ThicknessEnum,Helem_list); + element_thickness_input=new PentaP1Input(ThicknessEnum,Helem_list); /*Step3: Vertically integrate A COPY of the original*/ @@ -1681,5 +1681,5 @@ for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1689,5 +1689,5 @@ for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VxEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(VxEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1697,5 +1697,5 @@ for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VyEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(VyEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1705,5 +1705,5 @@ for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]; for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1755,5 +1755,5 @@ for(i=0;iData(InversionCostFunctionsCoefficientsEnum)[(penta_vertex_ids[j]-1)*num_cm_responses+i]; - datasetinput->inputs->AddObject(new PentaVertexInput(InversionCostFunctionsCoefficientsEnum,nodeinputs)); + datasetinput->inputs->AddObject(new PentaP1Input(InversionCostFunctionsCoefficientsEnum,nodeinputs)); } @@ -1900,7 +1900,7 @@ for(;;){ /*Add input to the element: */ - penta->inputs->AddInput(new PentaVertexInput(ThicknessEnum,newthickness)); - penta->inputs->AddInput(new PentaVertexInput(SurfaceEnum,newsurface)); - penta->inputs->AddInput(new PentaVertexInput(BedEnum,newbed)); + penta->inputs->AddInput(new PentaP1Input(ThicknessEnum,newthickness)); + penta->inputs->AddInput(new PentaP1Input(SurfaceEnum,newsurface)); + penta->inputs->AddInput(new PentaP1Input(BedEnum,newbed)); /*Stop if we have reached the surface*/ @@ -1933,5 +1933,5 @@ /*Add input to the element: */ - this->inputs->AddInput(new PentaVertexInput(enum_type,values)); + this->inputs->AddInput(new PentaP1Input(enum_type,values)); /*Free ressources:*/ @@ -1966,5 +1966,5 @@ for(;;){ /*Add input to the element: */ - penta->inputs->AddInput(new PentaVertexInput(enum_type,values)); + penta->inputs->AddInput(new PentaP1Input(enum_type,values)); /*Stop if we have reached the surface*/ @@ -2000,5 +2000,5 @@ /*update input*/ - this->inputs->AddInput(new PentaVertexInput(name,values)); + this->inputs->AddInput(new PentaP1Input(name,values)); return; @@ -2241,10 +2241,10 @@ if(!this->IsFloating() && elementonshelf==true){ for(i=0;iinputs->AddInput(new PentaVertexInput(BasalforcingsMeltingRateEnum,&melting[0])); + this->inputs->AddInput(new PentaP1Input(BasalforcingsMeltingRateEnum,&melting[0])); } /*Update inputs*/ - this->inputs->AddInput(new PentaVertexInput(SurfaceEnum,&s[0])); - this->inputs->AddInput(new PentaVertexInput(BedEnum,&b[0])); + this->inputs->AddInput(new PentaP1Input(SurfaceEnum,&s[0])); + this->inputs->AddInput(new PentaP1Input(BedEnum,&b[0])); this->inputs->AddInput(new BoolInput(MaskElementonfloatingiceEnum,elementonshelf)); @@ -2768,26 +2768,26 @@ if(!iomodel->Data(VxEnum)){ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VxEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVxEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VxEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVxEnum,nodeinputs)); } if(!iomodel->Data(VyEnum)){ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VyEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVyEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VyEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVyEnum,nodeinputs)); } if(!iomodel->Data(VzEnum)){ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VzEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVzEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVzEnum,nodeinputs)); } if(!iomodel->Data(PressureEnum)){ for(i=0;i<6;i++)nodeinputs[i]=0; if(dakota_analysis){ - this->inputs->AddInput(new PentaVertexInput(PressureEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(QmuPressureEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(QmuPressureEnum,nodeinputs)); } if(isstokes){ - this->inputs->AddInput(new PentaVertexInput(PressureEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(PressurePicardEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(PressurePicardEnum,nodeinputs)); } } @@ -2796,12 +2796,12 @@ if(iomodel->Data(VzEnum) && iomodel->Data(FlowequationBorderstokesEnum)){ for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data(VzEnum)[penta_vertex_ids[i]-1]/yts*iomodel->Data(FlowequationBorderstokesEnum)[penta_vertex_ids[i]-1]; - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs)); for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data(VzEnum)[penta_vertex_ids[i]-1]/yts*(1-iomodel->Data(FlowequationBorderstokesEnum)[penta_vertex_ids[i]-1]); - this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzPattynEnum,nodeinputs)); } else{ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzPattynEnum,nodeinputs)); } } @@ -2810,12 +2810,12 @@ if(iomodel->Data(VzEnum) && iomodel->Data(FlowequationBorderstokesEnum)){ for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data(VzEnum)[penta_vertex_ids[i]-1]/yts*iomodel->Data(FlowequationBorderstokesEnum)[penta_vertex_ids[i]-1]; - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs)); for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data(VzEnum)[penta_vertex_ids[i]-1]/yts*(1-iomodel->Data(FlowequationBorderstokesEnum)[penta_vertex_ids[i]-1]); - this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,nodeinputs)); } else{ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,nodeinputs)); } } @@ -2825,7 +2825,7 @@ /*Initialize mesh velocity*/ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VxMeshEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VyMeshEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VzMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VxMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VyMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzMeshEnum,nodeinputs)); break; @@ -2833,7 +2833,7 @@ /*Initialize mesh velocity*/ for(i=0;i<6;i++)nodeinputs[i]=0; - this->inputs->AddInput(new PentaVertexInput(VxMeshEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VyMeshEnum,nodeinputs)); - this->inputs->AddInput(new PentaVertexInput(VzMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VxMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VyMeshEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(VzMeshEnum,nodeinputs)); if (iomodel->Data(TemperatureEnum) && iomodel->Data(WaterfractionEnum) && iomodel->Data(PressureEnum)) { for(i=0;i<6;i++){ @@ -2845,5 +2845,5 @@ +latentheat*iomodel->Data(WaterfractionEnum)[penta_vertex_ids[i]-1]; } - this->inputs->AddInput(new PentaVertexInput(EnthalpyEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(EnthalpyEnum,nodeinputs)); } else _error_("temperature and waterfraction required for the enthalpy solution"); @@ -2918,5 +2918,5 @@ /*Create PentaVertex input, which will hold the basal friction:*/ - this->inputs->AddInput(new PentaVertexInput(ViscousHeatingEnum,&viscousheating[0])); + this->inputs->AddInput(new PentaP1Input(ViscousHeatingEnum,&viscousheating[0])); /*Clean up and return*/ @@ -4199,5 +4199,5 @@ this->inputs->GetInputValue(&converged,ConvergedEnum); if(converged){ - this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,values)); + this->inputs->AddInput(new PentaP1Input(TemperatureEnum,values)); /*Update Rheology only if converged (we must make sure that the temperature is below melting point @@ -4211,5 +4211,5 @@ B_average=Paterson((values[0]+values[1]+values[2]+values[3]+values[4]+values[5])/6.0); for(i=0;imatice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B)); + this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B)); break; case ArrheniusEnum: @@ -4219,5 +4219,5 @@ matice->GetN()); for(i=0;imatice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B)); + this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B)); break; default: @@ -4227,5 +4227,5 @@ } else{ - this->inputs->AddInput(new PentaVertexInput(TemperaturePicardEnum,values)); + this->inputs->AddInput(new PentaP1Input(TemperaturePicardEnum,values)); } @@ -4272,7 +4272,7 @@ for(i=0;iEnthalpyToThermal(&temperatures[i],&waterfraction[i],values[i],pressure[i]); - this->inputs->AddInput(new PentaVertexInput(EnthalpyEnum,values)); - this->inputs->AddInput(new PentaVertexInput(WaterfractionEnum,waterfraction)); - this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,temperatures)); + this->inputs->AddInput(new PentaP1Input(EnthalpyEnum,values)); + this->inputs->AddInput(new PentaP1Input(WaterfractionEnum,waterfraction)); + this->inputs->AddInput(new PentaP1Input(TemperatureEnum,temperatures)); /*Update Rheology only if converged (we must make sure that the temperature is below melting point @@ -4286,5 +4286,5 @@ B_average=Paterson((temperatures[0]+temperatures[1]+temperatures[2]+temperatures[3]+temperatures[4]+temperatures[5])/6.0); for(i=0;imatice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B)); + this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B)); break; case ArrheniusEnum: @@ -4294,5 +4294,5 @@ matice->GetN()); for(i=0;imatice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B)); + this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B)); break; default: @@ -4302,5 +4302,5 @@ // } // else{ -// this->inputs->AddInput(new PentaVertexInput(EnthalpyPicardEnum,values)); +// this->inputs->AddInput(new PentaP1Input(EnthalpyPicardEnum,values)); // } @@ -4367,5 +4367,5 @@ this->GetDofList1(&doflist1[0]); for(int i=0;iSetGradient(grad_input); @@ -4823,8 +4823,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(AdjointxEnum,lambdax)); - this->inputs->AddInput(new PentaVertexInput(AdjointyEnum,lambday)); - this->inputs->AddInput(new PentaVertexInput(AdjointzEnum,lambdaz)); - this->inputs->AddInput(new PentaVertexInput(AdjointpEnum,lambdap)); + this->inputs->AddInput(new PentaP1Input(AdjointxEnum,lambdax)); + this->inputs->AddInput(new PentaP1Input(AdjointyEnum,lambday)); + this->inputs->AddInput(new PentaP1Input(AdjointzEnum,lambdaz)); + this->inputs->AddInput(new PentaP1Input(AdjointpEnum,lambdap)); /*Free ressources:*/ @@ -4860,6 +4860,6 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(AdjointxEnum,lambdax)); - this->inputs->AddInput(new PentaVertexInput(AdjointyEnum,lambday)); + this->inputs->AddInput(new PentaP1Input(AdjointxEnum,lambdax)); + this->inputs->AddInput(new PentaP1Input(AdjointyEnum,lambday)); /*Free ressources:*/ @@ -5125,5 +5125,5 @@ case VertexEnum: - /*New PentaVertexInput*/ + /*New PentaP1Input*/ double values[6]; @@ -5198,12 +5198,12 @@ /*Add new inputs: */ - this->inputs->AddInput(new PentaVertexInput(ThicknessEnum,thickness)); - this->inputs->AddInput(new PentaVertexInput(BedEnum,bed)); - this->inputs->AddInput(new PentaVertexInput(SurfaceEnum,surface)); + this->inputs->AddInput(new PentaP1Input(ThicknessEnum,thickness)); + this->inputs->AddInput(new PentaP1Input(BedEnum,bed)); + this->inputs->AddInput(new PentaP1Input(SurfaceEnum,surface)); /*}}}*/ break; default: - this->inputs->AddInput(new PentaVertexInput(name,values)); + this->inputs->AddInput(new PentaP1Input(name,values)); } break; @@ -5258,5 +5258,5 @@ if(t==0) transientinput=new TransientInput(name); - transientinput->AddTimeInput(new PentaVertexInput(name,values),time); + transientinput->AddTimeInput(new PentaP1Input(name,values),time); transientinput->Configure(parameters); } @@ -7569,8 +7569,8 @@ /*Add vx and vy as inputs to the tria element: */ - penta->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - penta->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - penta->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - penta->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + penta->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + penta->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + penta->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + penta->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Stop if we have reached the surface*/ @@ -7659,8 +7659,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -7734,5 +7734,5 @@ Input* vzmacayeal_input=inputs->GetInput(VzMacAyealEnum); if (vzmacayeal_input){ - if (vzmacayeal_input->ObjectEnum()!=PentaVertexInputEnum){ + if (vzmacayeal_input->ObjectEnum()!=PentaP1InputEnum){ _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToStringx(vzmacayeal_input->ObjectEnum())); } @@ -7757,10 +7757,10 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VzEnum,vz)); - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,vzstokes)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VzEnum,vz)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,vzstokes)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -7834,8 +7834,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -7902,5 +7902,5 @@ Input* vzpattyn_input=inputs->GetInput(VzPattynEnum); if (vzpattyn_input){ - if (vzpattyn_input->ObjectEnum()!=PentaVertexInputEnum){ + if (vzpattyn_input->ObjectEnum()!=PentaP1InputEnum){ _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToStringx(vzpattyn_input->ObjectEnum())); } @@ -7925,10 +7925,10 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VzEnum,vz)); - this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,vzstokes)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VzEnum,vz)); + this->inputs->AddInput(new PentaP1Input(VzStokesEnum,vzstokes)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -7991,8 +7991,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -8049,5 +8049,5 @@ Input* vzstokes_input=inputs->GetInput(VzStokesEnum); if (vzstokes_input){ - if (vzstokes_input->ObjectEnum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum())); + if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum())); GetInputListOnVertices(&vzstokes[0],VzStokesEnum); } @@ -8061,5 +8061,5 @@ Input* vzstokes_input=inputs->GetInput(VzStokesEnum); if (vzstokes_input){ - if (vzstokes_input->ObjectEnum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum())); + if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum())); GetInputListOnVertices(&vzstokes[0],VzStokesEnum); } @@ -8089,14 +8089,14 @@ if(approximation!=PattynStokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum){ this->inputs->ChangeEnum(PressureEnum,PressurePicardEnum); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); } else if(approximation==PattynStokesApproximationEnum){ - this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,vzpattyn)); + this->inputs->AddInput(new PentaP1Input(VzPattynEnum,vzpattyn)); } else if(approximation==MacAyealStokesApproximationEnum){ - this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,vzmacayeal)); - } - this->inputs->AddInput(new PentaVertexInput(VzEnum,vz)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,vzmacayeal)); + } + this->inputs->AddInput(new PentaP1Input(VzEnum,vz)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); /*Free ressources:*/ @@ -8155,9 +8155,9 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new PentaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new PentaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new PentaVertexInput(VzEnum,vz)); - this->inputs->AddInput(new PentaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new PentaP1Input(VxEnum,vx)); + this->inputs->AddInput(new PentaP1Input(VyEnum,vy)); + this->inputs->AddInput(new PentaP1Input(VzEnum,vz)); + this->inputs->AddInput(new PentaP1Input(VelEnum,vel)); + this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure)); /*Free ressources:*/ Index: /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/objects/Elements/Tria.cpp (revision 11291) @@ -938,10 +938,10 @@ /*Add Stress tensor components into inputs*/ - this->inputs->AddInput(new TriaVertexInput(StressTensorxxEnum,&sigma_xx[0])); - this->inputs->AddInput(new TriaVertexInput(StressTensorxyEnum,&sigma_xy[0])); - this->inputs->AddInput(new TriaVertexInput(StressTensorxzEnum,&sigma_xz[0])); - this->inputs->AddInput(new TriaVertexInput(StressTensoryyEnum,&sigma_yy[0])); - this->inputs->AddInput(new TriaVertexInput(StressTensoryzEnum,&sigma_yz[0])); - this->inputs->AddInput(new TriaVertexInput(StressTensorzzEnum,&sigma_zz[0])); + this->inputs->AddInput(new TriaP1Input(StressTensorxxEnum,&sigma_xx[0])); + this->inputs->AddInput(new TriaP1Input(StressTensorxyEnum,&sigma_xy[0])); + this->inputs->AddInput(new TriaP1Input(StressTensorxzEnum,&sigma_xz[0])); + this->inputs->AddInput(new TriaP1Input(StressTensoryyEnum,&sigma_yy[0])); + this->inputs->AddInput(new TriaP1Input(StressTensoryzEnum,&sigma_yz[0])); + this->inputs->AddInput(new TriaP1Input(StressTensorzzEnum,&sigma_zz[0])); /*Clean up and return*/ @@ -1516,5 +1516,5 @@ for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1524,5 +1524,5 @@ for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VxEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(VxEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1532,5 +1532,5 @@ for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VyEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(VyEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1540,5 +1540,5 @@ for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -1559,5 +1559,5 @@ for(i=0;iData(InversionCostFunctionsCoefficientsEnum)[(tria_vertex_ids[j]-1)*num_cm_responses+i]; - datasetinput->inputs->AddObject(new TriaVertexInput(InversionCostFunctionsCoefficientsEnum,nodeinputs)); + datasetinput->inputs->AddObject(new TriaP1Input(InversionCostFunctionsCoefficientsEnum,nodeinputs)); } @@ -1640,5 +1640,5 @@ /*Add input to the element: */ - this->inputs->AddInput(new TriaVertexInput(enum_type,values)); + this->inputs->AddInput(new TriaP1Input(enum_type,values)); /*Free ressources:*/ @@ -1705,7 +1705,7 @@ /*Add input to the element: */ - this->inputs->AddInput(new TriaVertexInput(ThicknessEnum,newthickness)); - this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,newsurface)); - this->inputs->AddInput(new TriaVertexInput(BedEnum,newbed)); + this->inputs->AddInput(new TriaP1Input(ThicknessEnum,newthickness)); + this->inputs->AddInput(new TriaP1Input(SurfaceEnum,newsurface)); + this->inputs->AddInput(new TriaP1Input(BedEnum,newbed)); /*Free ressources:*/ @@ -1723,5 +1723,5 @@ case VertexEnum: - /*New TriaVertexInput*/ + /*New TriaP1Input*/ double values[3]; @@ -1733,8 +1733,8 @@ /*update input*/ if (name==MaterialsRheologyBbarEnum || name==MaterialsRheologyBEnum){ - matice->inputs->AddInput(new TriaVertexInput(name,values)); + matice->inputs->AddInput(new TriaP1Input(name,values)); } else{ - this->inputs->AddInput(new TriaVertexInput(name,values)); + this->inputs->AddInput(new TriaP1Input(name,values)); } return; @@ -1812,5 +1812,5 @@ /*create static input: */ - this->inputs->AddInput(new TriaVertexInput(vector_enum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(vector_enum,nodeinputs)); } else if(M==numberofvertices+1){ @@ -1831,5 +1831,5 @@ if(t==0) transientinput=new TransientInput(vector_enum); - transientinput->AddTimeInput(new TriaVertexInput(vector_enum,nodeinputs),time); + transientinput->AddTimeInput(new TriaP1Input(vector_enum,nodeinputs),time); } this->inputs->AddInput(transientinput); @@ -2067,5 +2067,5 @@ if(!this->IsFloating() && elementonshelf==true){ for(i=0;iinputs->AddInput(new TriaVertexInput(BasalforcingsMeltingRateEnum,&melting[0])); + this->inputs->AddInput(new TriaP1Input(BasalforcingsMeltingRateEnum,&melting[0])); } @@ -2074,6 +2074,6 @@ /*Update inputs*/ - this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,&s[0])); - this->inputs->AddInput(new TriaVertexInput(BedEnum,&b[0])); + this->inputs->AddInput(new TriaP1Input(SurfaceEnum,&s[0])); + this->inputs->AddInput(new TriaP1Input(BedEnum,&b[0])); } /*}}}*/ @@ -2398,22 +2398,22 @@ if(!iomodel->Data(VxEnum)){ for(i=0;i<3;i++)nodeinputs[i]=0; - this->inputs->AddInput(new TriaVertexInput(VxEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVxEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(VxEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVxEnum,nodeinputs)); } if(!iomodel->Data(VyEnum)){ for(i=0;i<3;i++)nodeinputs[i]=0; - this->inputs->AddInput(new TriaVertexInput(VyEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVyEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(VyEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVyEnum,nodeinputs)); } if(!iomodel->Data(VzEnum)){ for(i=0;i<3;i++)nodeinputs[i]=0; - this->inputs->AddInput(new TriaVertexInput(VzEnum,nodeinputs)); - if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVzEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(VzEnum,nodeinputs)); + if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVzEnum,nodeinputs)); } if(!iomodel->Data(PressureEnum)){ for(i=0;i<3;i++)nodeinputs[i]=0; if(dakota_analysis){ - this->inputs->AddInput(new TriaVertexInput(PressureEnum,nodeinputs)); - this->inputs->AddInput(new TriaVertexInput(QmuPressureEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(PressureEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(QmuPressureEnum,nodeinputs)); } } @@ -3158,8 +3158,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new TriaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new TriaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new TriaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new TriaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new TriaP1Input(VxEnum,vx)); + this->inputs->AddInput(new TriaP1Input(VyEnum,vy)); + this->inputs->AddInput(new TriaP1Input(VelEnum,vel)); + this->inputs->AddInput(new TriaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -3218,8 +3218,8 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new TriaVertexInput(VxEnum,vx)); - this->inputs->AddInput(new TriaVertexInput(VyEnum,vy)); - this->inputs->AddInput(new TriaVertexInput(VelEnum,vel)); - this->inputs->AddInput(new TriaVertexInput(PressureEnum,pressure)); + this->inputs->AddInput(new TriaP1Input(VxEnum,vx)); + this->inputs->AddInput(new TriaP1Input(VyEnum,vy)); + this->inputs->AddInput(new TriaP1Input(VelEnum,vel)); + this->inputs->AddInput(new TriaP1Input(PressureEnum,pressure)); /*Free ressources:*/ @@ -3319,5 +3319,5 @@ this->GetDofList1(&doflist1[0]); for(int i=0;iSetGradient(grad_input); @@ -4678,6 +4678,6 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new TriaVertexInput(AdjointxEnum,lambdax)); - this->inputs->AddInput(new TriaVertexInput(AdjointyEnum,lambday)); + this->inputs->AddInput(new TriaP1Input(AdjointxEnum,lambdax)); + this->inputs->AddInput(new TriaP1Input(AdjointyEnum,lambday)); /*Free ressources:*/ @@ -4708,5 +4708,5 @@ /*Add vx and vy as inputs to the tria element: */ - this->inputs->AddInput(new TriaVertexInput(AdjointEnum,lambda)); + this->inputs->AddInput(new TriaP1Input(AdjointEnum,lambda)); /*Free ressources:*/ @@ -4768,6 +4768,6 @@ /*Add to inputs*/ - this->inputs->AddInput(new TriaVertexInput(HydrologyWaterVxEnum,vx)); - this->inputs->AddInput(new TriaVertexInput(HydrologyWaterVyEnum,vy)); + this->inputs->AddInput(new TriaP1Input(HydrologyWaterVxEnum,vx)); + this->inputs->AddInput(new TriaP1Input(HydrologyWaterVyEnum,vy)); } /*}}}*/ @@ -4984,5 +4984,5 @@ /*Add input to the element: */ - this->inputs->AddInput(new TriaVertexInput(WatercolumnEnum,values)); + this->inputs->AddInput(new TriaP1Input(WatercolumnEnum,values)); /*Free ressources:*/ @@ -5005,5 +5005,5 @@ case VertexEnum: - /*New TriaVertexInput*/ + /*New TriaP1Input*/ double values[3]; @@ -5078,12 +5078,12 @@ /*Add new inputs: */ - this->inputs->AddInput(new TriaVertexInput(ThicknessEnum,thickness)); - this->inputs->AddInput(new TriaVertexInput(BedEnum,bed)); - this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,surface)); + this->inputs->AddInput(new TriaP1Input(ThicknessEnum,thickness)); + this->inputs->AddInput(new TriaP1Input(BedEnum,bed)); + this->inputs->AddInput(new TriaP1Input(SurfaceEnum,surface)); /*}}}*/ break; default: - this->inputs->AddInput(new TriaVertexInput(name,values)); + this->inputs->AddInput(new TriaP1Input(name,values)); } break; @@ -5137,5 +5137,5 @@ if(t==0) transientinput=new TransientInput(name); - transientinput->AddTimeInput(new TriaVertexInput(name,values),time); + transientinput->AddTimeInput(new TriaP1Input(name,values),time); transientinput->Configure(parameters); } Index: /issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp (revision 11291) @@ -35,15 +35,15 @@ switch(enum_input){ - case TriaVertexInputEnum: - values =new TriaVertexInput(enum_type,pvalues); - savedvalues=new TriaVertexInput(enum_type,pvalues); - minvalues =new TriaVertexInput(enum_type,pmin); - maxvalues =new TriaVertexInput(enum_type,pmax); + case TriaP1InputEnum: + values =new TriaP1Input(enum_type,pvalues); + savedvalues=new TriaP1Input(enum_type,pvalues); + minvalues =new TriaP1Input(enum_type,pmin); + maxvalues =new TriaP1Input(enum_type,pmax); break; - case PentaVertexInputEnum: - values =new PentaVertexInput(enum_type,pvalues); - savedvalues=new PentaVertexInput(enum_type,pvalues); - minvalues =new PentaVertexInput(enum_type,pmin); - maxvalues =new PentaVertexInput(enum_type,pmax); + case PentaP1InputEnum: + values =new PentaP1Input(enum_type,pvalues); + savedvalues=new PentaP1Input(enum_type,pvalues); + minvalues =new PentaP1Input(enum_type,pmin); + maxvalues =new PentaP1Input(enum_type,pmax); break; default: @@ -206,10 +206,10 @@ if(flag){ memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int); - if(input_enum_type==PentaVertexInputEnum){ - values=new PentaVertexInput(); + if(input_enum_type==PentaP1InputEnum){ + values=new PentaP1Input(); values->Demarshall(&marshalled_dataset); } - else if(input_enum_type==TriaVertexInputEnum){ - values=new TriaVertexInput(); + else if(input_enum_type==TriaP1InputEnum){ + values=new TriaP1Input(); values->Demarshall(&marshalled_dataset); } @@ -224,10 +224,10 @@ if(flag){ memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int); - if(input_enum_type==PentaVertexInputEnum){ - savedvalues=new PentaVertexInput(); + if(input_enum_type==PentaP1InputEnum){ + savedvalues=new PentaP1Input(); savedvalues->Demarshall(&marshalled_dataset); } - else if(input_enum_type==TriaVertexInputEnum){ - savedvalues=new TriaVertexInput(); + else if(input_enum_type==TriaP1InputEnum){ + savedvalues=new TriaP1Input(); savedvalues->Demarshall(&marshalled_dataset); } @@ -242,10 +242,10 @@ if(flag){ memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int); - if(input_enum_type==PentaVertexInputEnum){ - minvalues=new PentaVertexInput(); + if(input_enum_type==PentaP1InputEnum){ + minvalues=new PentaP1Input(); minvalues->Demarshall(&marshalled_dataset); } - else if(input_enum_type==TriaVertexInputEnum){ - minvalues=new TriaVertexInput(); + else if(input_enum_type==TriaP1InputEnum){ + minvalues=new TriaP1Input(); minvalues->Demarshall(&marshalled_dataset); } @@ -260,10 +260,10 @@ if(flag){ memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int); - if(input_enum_type==PentaVertexInputEnum){ - maxvalues=new PentaVertexInput(); + if(input_enum_type==PentaP1InputEnum){ + maxvalues=new PentaP1Input(); maxvalues->Demarshall(&marshalled_dataset); } - else if(input_enum_type==TriaVertexInputEnum){ - maxvalues=new TriaVertexInput(); + else if(input_enum_type==TriaP1InputEnum){ + maxvalues=new TriaP1Input(); maxvalues->Demarshall(&marshalled_dataset); } @@ -278,10 +278,10 @@ if(flag){ memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int); - if(input_enum_type==PentaVertexInputEnum){ - gradient=new PentaVertexInput(); + if(input_enum_type==PentaP1InputEnum){ + gradient=new PentaP1Input(); gradient->Demarshall(&marshalled_dataset); } - else if(input_enum_type==TriaVertexInputEnum){ - gradient=new TriaVertexInput(); + else if(input_enum_type==TriaP1InputEnum){ + gradient=new TriaP1Input(); gradient->Demarshall(&marshalled_dataset); } Index: /issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp (revision 11291) @@ -340,5 +340,5 @@ switch(thickness_input->ObjectEnum()){ - case PentaVertexInputEnum: + case PentaP1InputEnum: thickness_input->GetInputAverage(&thickness_value); this->value=this->value*thickness_value; 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 11291) @@ -0,0 +1,680 @@ +/*!\file PentaP1Input.c + * \brief: implementation of the PentaP1Input object + */ + +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include +#include +#include "../objects.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +/*PentaP1Input constructors and destructor*/ +/*FUNCTION PentaP1Input::PentaP1Input(){{{1*/ +PentaP1Input::PentaP1Input(){ + return; +} +/*}}}*/ +/*FUNCTION PentaP1Input::PentaP1Input(int in_enum_type,double* values){{{1*/ +PentaP1Input::PentaP1Input(int in_enum_type,double* in_values) + :PentaRef(1) +{ + + /*Set PentaRef*/ + this->SetElementType(P1Enum,0); + this->element_type=P1Enum; + + enum_type=in_enum_type; + values[0]=in_values[0]; + values[1]=in_values[1]; + values[2]=in_values[2]; + values[3]=in_values[3]; + values[4]=in_values[4]; + values[5]=in_values[5]; +} +/*}}}*/ +/*FUNCTION PentaP1Input::~PentaP1Input(){{{1*/ +PentaP1Input::~PentaP1Input(){ + return; +} +/*}}}*/ + +/*Object virtual functions definitions:*/ +/*FUNCTION PentaP1Input::Echo {{{1*/ +void PentaP1Input::Echo(void){ + this->DeepEcho(); +} +/*}}}*/ +/*FUNCTION PentaP1Input::DeepEcho{{{1*/ +void PentaP1Input::DeepEcho(void){ + + printf("PentaP1Input:\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]); +} +/*}}}*/ +/*FUNCTION PentaP1Input::Id{{{1*/ +int PentaP1Input::Id(void){ return -1; } +/*}}}*/ +/*FUNCTION PentaP1Input::MyRank{{{1*/ +int PentaP1Input::MyRank(void){ + extern int my_rank; + return my_rank; +} +/*}}}*/ +#ifdef _SERIAL_ +/*FUNCTION PentaP1Input::Marshall{{{1*/ +void PentaP1Input::Marshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int enum_value=0; + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*get enum value of PentaP1Input: */ + enum_value=PentaP1InputEnum; + + /*marshall enum: */ + memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); + + /*marshall PentaP1Input data: */ + memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); + + *pmarshalled_dataset=marshalled_dataset; +} +/*}}}*/ +/*FUNCTION PentaP1Input::MarshallSize{{{1*/ +int PentaP1Input::MarshallSize(){ + + return sizeof(values)+ + +sizeof(enum_type)+ + +sizeof(int); //sizeof(int) for enum value +} +/*}}}*/ +/*FUNCTION PentaP1Input::Demarshall{{{1*/ +void PentaP1Input::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); + + /*return: */ + *pmarshalled_dataset=marshalled_dataset; + return; +} +/*}}}*/ +#endif +/*FUNCTION PentaP1Input::ObjectEnum{{{1*/ +int PentaP1Input::ObjectEnum(void){ + + return PentaP1InputEnum; + +} +/*}}}*/ + +/*PentaP1Input management*/ +/*FUNCTION PentaP1Input::copy{{{1*/ +Object* PentaP1Input::copy() { + + return new PentaP1Input(this->enum_type,this->values); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::InstanceEnum{{{1*/ +int PentaP1Input::InstanceEnum(void){ + + return this->enum_type; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::SpawnTriaInput{{{1*/ +Input* PentaP1Input::SpawnTriaInput(int* indices){ + + /*output*/ + TriaP1Input* outinput=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 input*/ + newvalues[i]=this->values[indices[i]]; + } + + /*Create new Tria input*/ + outinput=new TriaP1Input(this->enum_type,&newvalues[0]); + + /*Assign output*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::SpawnResult{{{1*/ +ElementResult* PentaP1Input::SpawnResult(int step, double time){ + + return new PentaVertexElementResult(this->enum_type,this->values,step,time); + +} +/*}}}*/ + +/*Object functions*/ +/*FUNCTION PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ +void PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){ + + /*Call PentaRef function*/ + PentaRef::GetInputValue(pvalue,&values[0],gauss); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/ +void PentaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){ + + /*Call PentaRef function*/ + PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVxStrainRate3d{{{1*/ +void PentaP1Input::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ + int i,j; + + const int numnodes=6; + const int DOFVELOCITY=3; + double B[8][27]; + double B_reduced[6][DOFVELOCITY*numnodes]; + double velocity[numnodes][DOFVELOCITY]; + + /*Get B matrix: */ + GetBStokes(&B[0][0], xyz_list, gauss); + /*Create a reduced matrix of B to get rid of pressure */ + for (i=0;i<6;i++){ + for (j=0;j<3;j++){ + B_reduced[i][j]=B[i][j]; + } + for (j=4;j<7;j++){ + B_reduced[i][j-1]=B[i][j]; + } + for (j=8;j<11;j++){ + B_reduced[i][j-2]=B[i][j]; + } + for (j=12;j<15;j++){ + B_reduced[i][j-3]=B[i][j]; + } + for (j=16;j<19;j++){ + B_reduced[i][j-4]=B[i][j]; + } + for (j=20;j<23;j++){ + B_reduced[i][j-5]=B[i][j]; + } + } + + /*Here, we are computing the strain rate of (vx,0,0)*/ + for(i=0;ivalues[i]; + velocity[i][1]=0.0; + velocity[i][2]=0.0; + } + /*Multiply B by velocity, to get strain rate: */ + MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvx,0); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVyStrainRate3d{{{1*/ +void PentaP1Input::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ + int i,j; + + const int numnodes=6; + const int DOFVELOCITY=3; + double B[8][27]; + double B_reduced[6][DOFVELOCITY*numnodes]; + double velocity[numnodes][DOFVELOCITY]; + + /*Get B matrix: */ + GetBStokes(&B[0][0], xyz_list, gauss); + /*Create a reduced matrix of B to get rid of pressure */ + for (i=0;i<6;i++){ + for (j=0;j<3;j++){ + B_reduced[i][j]=B[i][j]; + } + for (j=4;j<7;j++){ + B_reduced[i][j-1]=B[i][j]; + } + for (j=8;j<11;j++){ + B_reduced[i][j-2]=B[i][j]; + } + for (j=12;j<15;j++){ + B_reduced[i][j-3]=B[i][j]; + } + for (j=16;j<19;j++){ + B_reduced[i][j-4]=B[i][j]; + } + for (j=20;j<23;j++){ + B_reduced[i][j-5]=B[i][j]; + } + } + + /*Here, we are computing the strain rate of (0,vy,0)*/ + for(i=0;ivalues[i]; + velocity[i][2]=0.0; + } + /*Multiply B by velocity, to get strain rate: */ + MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvy,0); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVzStrainRate3d{{{1*/ +void PentaP1Input::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ + int i,j; + + const int numnodes=6; + const int DOFVELOCITY=3; + double B[8][27]; + double B_reduced[6][DOFVELOCITY*numnodes]; + double velocity[numnodes][DOFVELOCITY]; + + /*Get B matrix: */ + GetBStokes(&B[0][0], xyz_list, gauss); + /*Create a reduced matrix of B to get rid of pressure */ + for (i=0;i<6;i++){ + for (j=0;j<3;j++){ + B_reduced[i][j]=B[i][j]; + } + for (j=4;j<7;j++){ + B_reduced[i][j-1]=B[i][j]; + } + for (j=8;j<11;j++){ + B_reduced[i][j-2]=B[i][j]; + } + for (j=12;j<15;j++){ + B_reduced[i][j-3]=B[i][j]; + } + for (j=16;j<19;j++){ + B_reduced[i][j-4]=B[i][j]; + } + for (j=20;j<23;j++){ + B_reduced[i][j-5]=B[i][j]; + } + } + + /*Here, we are computing the strain rate of (0,0,vz)*/ + for(i=0;ivalues[i]; + } + + /*Multiply B by velocity, to get strain rate: */ + MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvz,0); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVxStrainRate3dPattyn{{{1*/ +void PentaP1Input::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ + + int i; + const int numnodes=6; + double B[5][NDOF2*numnodes]; + double velocity[numnodes][NDOF2]; + + /*Get B matrix: */ + GetBPattyn(&B[0][0], xyz_list, gauss); + + /*Here, we are computing the strain rate of (vx,0)*/ + for(i=0;ivalues[i]; + velocity[i][1]=0.0; + } + + /*Multiply B by velocity, to get strain rate: */ + MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0, + &velocity[0][0],NDOF2*numnodes,1,0, + epsilonvx,0); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVyStrainRate3dPattyn{{{1*/ +void PentaP1Input::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ + + int i; + const int numnodes=6; + double B[5][NDOF2*numnodes]; + double velocity[numnodes][NDOF2]; + + /*Get B matrix: */ + GetBPattyn(&B[0][0], xyz_list, gauss); + + /*Here, we are computing the strain rate of (0,vy)*/ + for(i=0;ivalues[i]; + } + + /*Multiply B by velocity, to get strain rate: */ + MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0, + &velocity[0][0],NDOF2*numnodes,1,0, + epsilonvy,0); + +} +/*}}}*/ +/*FUNCTION PentaP1Input::ChangeEnum{{{1*/ +void PentaP1Input::ChangeEnum(int newenumtype){ + this->enum_type=newenumtype; +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetInputAverage{{{1*/ +void PentaP1Input::GetInputAverage(double* pvalue){ + *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]); +} +/*}}}*/ + +/*Intermediary*/ +/*FUNCTION PentaP1Input::SquareMin{{{1*/ +void PentaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){ + + int i; + const int numnodes=6; + double valuescopy[numnodes]; + double squaremin; + + /*First, copy values, to process units if requested: */ + for(i=0;ivalues[i]; + + /*Process units if requested: */ + if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type); + + /*Now, figure out minimum of valuescopy: */ + squaremin=pow(valuescopy[0],2); + for(i=1;inorm) norm=fabs(values[i]); + return norm; +} +/*}}}*/ +/*FUNCTION PentaP1Input::Max{{{1*/ +double PentaP1Input::Max(void){ + + const int numnodes=6; + double max=values[0]; + + for(int i=1;imax) max=values[i]; + } + return max; +} +/*}}}*/ +/*FUNCTION PentaP1Input::MaxAbs{{{1*/ +double PentaP1Input::MaxAbs(void){ + + const int numnodes=6; + double max=fabs(values[0]); + + for(int i=1;imax) max=fabs(values[i]); + } + return max; +} +/*}}}*/ +/*FUNCTION PentaP1Input::Min{{{1*/ +double PentaP1Input::Min(void){ + + const int numnodes=6; + double min=values[0]; + + for(int i=1;iObjectEnum()){ + + case PentaP1InputEnum:{ + PentaP1Input* cast_input=(PentaP1Input*)xinput; + for(i=0;ivalues[i]=this->values[i]+scalar*(cast_input->values[i]);} + return; + case ControlInputEnum:{ + ControlInput* cont_input=(ControlInput*)xinput; + if(cont_input->values->ObjectEnum()!=PentaP1InputEnum) _error_("not supported yet"); + PentaP1Input* cast_input=(PentaP1Input*)cont_input->values; + for(i=0;ivalues[i]=this->values[i]+scalar*(cast_input->values[i]);} + return; + default: + _error_("not implemented yet"); + } + +} +/*}}}*/ +/*FUNCTION PentaP1Input::Constrain{{{1*/ +void PentaP1Input::Constrain(double cm_min, double cm_max){ + + int i; + const int numnodes=6; + + if(!isnan(cm_min)) for(i=0;ivalues[i]values[i]=cm_min; + if(!isnan(cm_max)) for(i=0;ivalues[i]>cm_max)this->values[i]=cm_max; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::Extrude{{{1*/ +void PentaP1Input::Extrude(void){ + + int i; + + /*First 3 values copied on 3 last values*/ + for(i=0;i<3;i++) this->values[3+i]=this->values[i]; +} +/*}}}*/ +/*FUNCTION PentaP1Input::VerticallyIntegrate{{{1*/ +void PentaP1Input::VerticallyIntegrate(Input* thickness_input){ + + /*Intermediaries*/ + int i; + const int numnodes = 6; + int num_thickness_values; + double *thickness_values = NULL; + + /*Check that input provided is a thickness*/ + if (thickness_input->InstanceEnum()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->InstanceEnum())); + + /*Get Thickness value pointer*/ + thickness_input->GetValuesPtr(&thickness_values,&num_thickness_values); + + /*vertically integrate depending on type:*/ + switch(thickness_input->ObjectEnum()){ + + case PentaP1InputEnum: + for(i=0;i<3;i++){ + this->values[i]=0.5*(this->values[i]+this->values[i+3]) * thickness_values[i]; + this->values[i+3]=this->values[i]; + } + return; + + default: + _error_("not implemented yet"); + } +} +/*}}}*/ +/*FUNCTION PentaP1Input::PointwiseDivide{{{1*/ +Input* PentaP1Input::PointwiseDivide(Input* inputB){ + + /*Ouput*/ + PentaP1Input* outinput=NULL; + + /*Intermediaries*/ + int i; + PentaP1Input *xinputB = NULL; + int B_numvalues; + const int numnodes = 6; + double AdotBvalues[numnodes]; + + /*Check that inputB is of the same type*/ + if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); + xinputB=(PentaP1Input*)inputB; + + /*Create point wise sum*/ + for(i=0;ivalues[i]!=0); + AdotBvalues[i]=this->values[i]/xinputB->values[i]; + } + + /*Create new Penta vertex input (copy of current input)*/ + outinput=new PentaP1Input(this->enum_type,&AdotBvalues[0]); + + /*Return output pointer*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::PointwiseMin{{{1*/ +Input* PentaP1Input::PointwiseMin(Input* inputB){ + + /*Ouput*/ + PentaP1Input* outinput=NULL; + + /*Intermediaries*/ + int i; + PentaP1Input *xinputB = NULL; + int B_numvalues; + const int numnodes = 6; + double minvalues[numnodes]; + + /*Check that inputB is of the same type*/ + if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); + xinputB=(PentaP1Input*)inputB; + + /*Create point wise min*/ + for(i=0;ivalues[i] > xinputB->values[i]) minvalues[i]=xinputB->values[i]; + else minvalues[i]=this->values[i]; + } + + /*Create new Penta vertex input (copy of current input)*/ + outinput=new PentaP1Input(this->enum_type,&minvalues[0]); + + /*Return output pointer*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::PointwiseMax{{{1*/ +Input* PentaP1Input::PointwiseMax(Input* inputB){ + + /*Ouput*/ + PentaP1Input* outinput=NULL; + + /*Intermediaries*/ + int i; + PentaP1Input *xinputB = NULL; + int B_numvalues; + const int numnodes = 6; + double maxvalues[numnodes]; + + /*Check that inputB is of the same type*/ + if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); + xinputB=(PentaP1Input*)inputB; + + /*Create point wise max*/ + for(i=0;ivalues[i] < xinputB->values[i]) maxvalues[i]=xinputB->values[i]; + else maxvalues[i]=this->values[i]; + } + + /*Create new Penta vertex input (copy of current input)*/ + outinput=new PentaP1Input(this->enum_type,&maxvalues[0]); + + /*Return output pointer*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::GetVectorFromInputs{{{1*/ +void PentaP1Input::GetVectorFromInputs(Vec vector,int* doflist){ + + const int numvertices=6; + VecSetValues(vector,numvertices,doflist,(const double*)this->values,INSERT_VALUES); + +} /*}}}*/ +/*FUNCTION PentaP1Input::GetValuesPtr{{{1*/ +void PentaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){ + + *pvalues=this->values; + *pnum_values=6; + +} +/*}}}*/ +/*FUNCTION PentaP1Input::Configure{{{1*/ +void PentaP1Input::Configure(Parameters* parameters){ + /*do nothing: */ +} +/*}}}*/ 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 11291) @@ -0,0 +1,89 @@ +/*! \file PentaP1Input.h + * \brief: header file for triavertexinput object + */ + + +#ifndef _PENTAVERTEXINPUT_H_ +#define _PENTAVERTEXINPUT_H_ + +/*Headers:*/ +/*{{{1*/ +#include "./Input.h" +#include "../Elements/PentaRef.h" +class GaussTria; +/*}}}*/ + +class PentaP1Input: public Input, public PentaRef{ + + public: + /*just hold 6 values for 6 vertices: */ + int enum_type; + double values[6]; + + /*PentaP1Input constructors, destructors: {{{1*/ + PentaP1Input(); + PentaP1Input(int enum_type,double* values); + ~PentaP1Input(); + /*}}}*/ + /*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(); + /*}}}*/ + /*PentaP1Input management: {{{1*/ + int InstanceEnum(); + Input* SpawnTriaInput(int* indices); + Input* PointwiseDivide(Input* inputB); + Input* PointwiseMin(Input* inputB); + Input* PointwiseMax(Input* inputB); + ElementResult* SpawnResult(int step, double time); + void AddTimeValues(double* values,int step,double time){_error_("not supported yet");}; + void Configure(Parameters* parameters); + /*}}}*/ + /*numerics: {{{1*/ + void GetInputValue(bool* pvalue){_error_("not implemented yet");}; + void GetInputValue(int* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue); + void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; + void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; + void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss); + void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss); + void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss); + void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss); + void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss); + void ChangeEnum(int newenumtype); + + void SquareMin(double* psquaremin, bool process_units,Parameters* parameters); + void ConstrainMin(double minimum); + void Scale(double scale_factor); + void ArtificialNoise(double min,double max){_error_("not implemented yet");}; + void AXPY(Input* xinput,double scalar); + void Constrain(double cm_min, double cm_max); + double InfinityNorm(void); + double Max(void); + double MaxAbs(void); + double Min(void); + double MinAbs(void); + void Extrude(void); + void VerticallyIntegrate(Input* thickness_input); + void GetVectorFromInputs(Vec vector,int* doflist); + void GetValuesPtr(double** pvalues,int* pnum_values); + /*}}}*/ + +}; +#endif /* _PENTAVERTEXINPUT_H */ Index: sm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.cpp (revision 11290) +++ (revision ) @@ -1,680 +1,0 @@ -/*!\file PentaVertexInput.c - * \brief: implementation of the PentaVertexInput object - */ - -#ifdef HAVE_CONFIG_H - #include -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include -#include -#include "../objects.h" -#include "../../EnumDefinitions/EnumDefinitions.h" -#include "../../shared/shared.h" -#include "../../Container/Container.h" -#include "../../include/include.h" - -/*PentaVertexInput constructors and destructor*/ -/*FUNCTION PentaVertexInput::PentaVertexInput(){{{1*/ -PentaVertexInput::PentaVertexInput(){ - return; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::PentaVertexInput(int in_enum_type,double* values){{{1*/ -PentaVertexInput::PentaVertexInput(int in_enum_type,double* in_values) - :PentaRef(1) -{ - - /*Set PentaRef*/ - this->SetElementType(P1Enum,0); - this->element_type=P1Enum; - - enum_type=in_enum_type; - values[0]=in_values[0]; - values[1]=in_values[1]; - values[2]=in_values[2]; - values[3]=in_values[3]; - values[4]=in_values[4]; - values[5]=in_values[5]; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::~PentaVertexInput(){{{1*/ -PentaVertexInput::~PentaVertexInput(){ - return; -} -/*}}}*/ - -/*Object virtual functions definitions:*/ -/*FUNCTION PentaVertexInput::Echo {{{1*/ -void PentaVertexInput::Echo(void){ - this->DeepEcho(); -} -/*}}}*/ -/*FUNCTION PentaVertexInput::DeepEcho{{{1*/ -void PentaVertexInput::DeepEcho(void){ - - printf("PentaVertexInput:\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]); -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Id{{{1*/ -int PentaVertexInput::Id(void){ return -1; } -/*}}}*/ -/*FUNCTION PentaVertexInput::MyRank{{{1*/ -int PentaVertexInput::MyRank(void){ - extern int my_rank; - return my_rank; -} -/*}}}*/ -#ifdef _SERIAL_ -/*FUNCTION PentaVertexInput::Marshall{{{1*/ -void PentaVertexInput::Marshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int enum_value=0; - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*get enum value of PentaVertexInput: */ - enum_value=PentaVertexInputEnum; - - /*marshall enum: */ - memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); - - /*marshall PentaVertexInput data: */ - memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); - - *pmarshalled_dataset=marshalled_dataset; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::MarshallSize{{{1*/ -int PentaVertexInput::MarshallSize(){ - - return sizeof(values)+ - +sizeof(enum_type)+ - +sizeof(int); //sizeof(int) for enum value -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Demarshall{{{1*/ -void PentaVertexInput::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); - - /*return: */ - *pmarshalled_dataset=marshalled_dataset; - return; -} -/*}}}*/ -#endif -/*FUNCTION PentaVertexInput::ObjectEnum{{{1*/ -int PentaVertexInput::ObjectEnum(void){ - - return PentaVertexInputEnum; - -} -/*}}}*/ - -/*PentaVertexInput management*/ -/*FUNCTION PentaVertexInput::copy{{{1*/ -Object* PentaVertexInput::copy() { - - return new PentaVertexInput(this->enum_type,this->values); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::InstanceEnum{{{1*/ -int PentaVertexInput::InstanceEnum(void){ - - return this->enum_type; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::SpawnTriaInput{{{1*/ -Input* PentaVertexInput::SpawnTriaInput(int* indices){ - - /*output*/ - TriaVertexInput* outinput=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 input*/ - newvalues[i]=this->values[indices[i]]; - } - - /*Create new Tria input*/ - outinput=new TriaVertexInput(this->enum_type,&newvalues[0]); - - /*Assign output*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::SpawnResult{{{1*/ -ElementResult* PentaVertexInput::SpawnResult(int step, double time){ - - return new PentaVertexElementResult(this->enum_type,this->values,step,time); - -} -/*}}}*/ - -/*Object functions*/ -/*FUNCTION PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ -void PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){ - - /*Call PentaRef function*/ - PentaRef::GetInputValue(pvalue,&values[0],gauss); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/ -void PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){ - - /*Call PentaRef function*/ - PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVxStrainRate3d{{{1*/ -void PentaVertexInput::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ - int i,j; - - const int numnodes=6; - const int DOFVELOCITY=3; - double B[8][27]; - double B_reduced[6][DOFVELOCITY*numnodes]; - double velocity[numnodes][DOFVELOCITY]; - - /*Get B matrix: */ - GetBStokes(&B[0][0], xyz_list, gauss); - /*Create a reduced matrix of B to get rid of pressure */ - for (i=0;i<6;i++){ - for (j=0;j<3;j++){ - B_reduced[i][j]=B[i][j]; - } - for (j=4;j<7;j++){ - B_reduced[i][j-1]=B[i][j]; - } - for (j=8;j<11;j++){ - B_reduced[i][j-2]=B[i][j]; - } - for (j=12;j<15;j++){ - B_reduced[i][j-3]=B[i][j]; - } - for (j=16;j<19;j++){ - B_reduced[i][j-4]=B[i][j]; - } - for (j=20;j<23;j++){ - B_reduced[i][j-5]=B[i][j]; - } - } - - /*Here, we are computing the strain rate of (vx,0,0)*/ - for(i=0;ivalues[i]; - velocity[i][1]=0.0; - velocity[i][2]=0.0; - } - /*Multiply B by velocity, to get strain rate: */ - MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvx,0); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVyStrainRate3d{{{1*/ -void PentaVertexInput::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ - int i,j; - - const int numnodes=6; - const int DOFVELOCITY=3; - double B[8][27]; - double B_reduced[6][DOFVELOCITY*numnodes]; - double velocity[numnodes][DOFVELOCITY]; - - /*Get B matrix: */ - GetBStokes(&B[0][0], xyz_list, gauss); - /*Create a reduced matrix of B to get rid of pressure */ - for (i=0;i<6;i++){ - for (j=0;j<3;j++){ - B_reduced[i][j]=B[i][j]; - } - for (j=4;j<7;j++){ - B_reduced[i][j-1]=B[i][j]; - } - for (j=8;j<11;j++){ - B_reduced[i][j-2]=B[i][j]; - } - for (j=12;j<15;j++){ - B_reduced[i][j-3]=B[i][j]; - } - for (j=16;j<19;j++){ - B_reduced[i][j-4]=B[i][j]; - } - for (j=20;j<23;j++){ - B_reduced[i][j-5]=B[i][j]; - } - } - - /*Here, we are computing the strain rate of (0,vy,0)*/ - for(i=0;ivalues[i]; - velocity[i][2]=0.0; - } - /*Multiply B by velocity, to get strain rate: */ - MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvy,0); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVzStrainRate3d{{{1*/ -void PentaVertexInput::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ - int i,j; - - const int numnodes=6; - const int DOFVELOCITY=3; - double B[8][27]; - double B_reduced[6][DOFVELOCITY*numnodes]; - double velocity[numnodes][DOFVELOCITY]; - - /*Get B matrix: */ - GetBStokes(&B[0][0], xyz_list, gauss); - /*Create a reduced matrix of B to get rid of pressure */ - for (i=0;i<6;i++){ - for (j=0;j<3;j++){ - B_reduced[i][j]=B[i][j]; - } - for (j=4;j<7;j++){ - B_reduced[i][j-1]=B[i][j]; - } - for (j=8;j<11;j++){ - B_reduced[i][j-2]=B[i][j]; - } - for (j=12;j<15;j++){ - B_reduced[i][j-3]=B[i][j]; - } - for (j=16;j<19;j++){ - B_reduced[i][j-4]=B[i][j]; - } - for (j=20;j<23;j++){ - B_reduced[i][j-5]=B[i][j]; - } - } - - /*Here, we are computing the strain rate of (0,0,vz)*/ - for(i=0;ivalues[i]; - } - - /*Multiply B by velocity, to get strain rate: */ - MatrixMultiply(&B_reduced[0][0],6,DOFVELOCITY*numnodes,0,&velocity[0][0],DOFVELOCITY*numnodes,1,0,epsilonvz,0); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVxStrainRate3dPattyn{{{1*/ -void PentaVertexInput::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ - - int i; - const int numnodes=6; - double B[5][NDOF2*numnodes]; - double velocity[numnodes][NDOF2]; - - /*Get B matrix: */ - GetBPattyn(&B[0][0], xyz_list, gauss); - - /*Here, we are computing the strain rate of (vx,0)*/ - for(i=0;ivalues[i]; - velocity[i][1]=0.0; - } - - /*Multiply B by velocity, to get strain rate: */ - MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0, - &velocity[0][0],NDOF2*numnodes,1,0, - epsilonvx,0); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVyStrainRate3dPattyn{{{1*/ -void PentaVertexInput::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ - - int i; - const int numnodes=6; - double B[5][NDOF2*numnodes]; - double velocity[numnodes][NDOF2]; - - /*Get B matrix: */ - GetBPattyn(&B[0][0], xyz_list, gauss); - - /*Here, we are computing the strain rate of (0,vy)*/ - for(i=0;ivalues[i]; - } - - /*Multiply B by velocity, to get strain rate: */ - MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0, - &velocity[0][0],NDOF2*numnodes,1,0, - epsilonvy,0); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::ChangeEnum{{{1*/ -void PentaVertexInput::ChangeEnum(int newenumtype){ - this->enum_type=newenumtype; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetInputAverage{{{1*/ -void PentaVertexInput::GetInputAverage(double* pvalue){ - *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]); -} -/*}}}*/ - -/*Intermediary*/ -/*FUNCTION PentaVertexInput::SquareMin{{{1*/ -void PentaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){ - - int i; - const int numnodes=6; - double valuescopy[numnodes]; - double squaremin; - - /*First, copy values, to process units if requested: */ - for(i=0;ivalues[i]; - - /*Process units if requested: */ - if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type); - - /*Now, figure out minimum of valuescopy: */ - squaremin=pow(valuescopy[0],2); - for(i=1;inorm) norm=fabs(values[i]); - return norm; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Max{{{1*/ -double PentaVertexInput::Max(void){ - - const int numnodes=6; - double max=values[0]; - - for(int i=1;imax) max=values[i]; - } - return max; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::MaxAbs{{{1*/ -double PentaVertexInput::MaxAbs(void){ - - const int numnodes=6; - double max=fabs(values[0]); - - for(int i=1;imax) max=fabs(values[i]); - } - return max; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Min{{{1*/ -double PentaVertexInput::Min(void){ - - const int numnodes=6; - double min=values[0]; - - for(int i=1;iObjectEnum()){ - - case PentaVertexInputEnum:{ - PentaVertexInput* cast_input=(PentaVertexInput*)xinput; - for(i=0;ivalues[i]=this->values[i]+scalar*(cast_input->values[i]);} - return; - case ControlInputEnum:{ - ControlInput* cont_input=(ControlInput*)xinput; - if(cont_input->values->ObjectEnum()!=PentaVertexInputEnum) _error_("not supported yet"); - PentaVertexInput* cast_input=(PentaVertexInput*)cont_input->values; - for(i=0;ivalues[i]=this->values[i]+scalar*(cast_input->values[i]);} - return; - default: - _error_("not implemented yet"); - } - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Constrain{{{1*/ -void PentaVertexInput::Constrain(double cm_min, double cm_max){ - - int i; - const int numnodes=6; - - if(!isnan(cm_min)) for(i=0;ivalues[i]values[i]=cm_min; - if(!isnan(cm_max)) for(i=0;ivalues[i]>cm_max)this->values[i]=cm_max; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Extrude{{{1*/ -void PentaVertexInput::Extrude(void){ - - int i; - - /*First 3 values copied on 3 last values*/ - for(i=0;i<3;i++) this->values[3+i]=this->values[i]; -} -/*}}}*/ -/*FUNCTION PentaVertexInput::VerticallyIntegrate{{{1*/ -void PentaVertexInput::VerticallyIntegrate(Input* thickness_input){ - - /*Intermediaries*/ - int i; - const int numnodes = 6; - int num_thickness_values; - double *thickness_values = NULL; - - /*Check that input provided is a thickness*/ - if (thickness_input->InstanceEnum()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->InstanceEnum())); - - /*Get Thickness value pointer*/ - thickness_input->GetValuesPtr(&thickness_values,&num_thickness_values); - - /*vertically integrate depending on type:*/ - switch(thickness_input->ObjectEnum()){ - - case PentaVertexInputEnum: - for(i=0;i<3;i++){ - this->values[i]=0.5*(this->values[i]+this->values[i+3]) * thickness_values[i]; - this->values[i+3]=this->values[i]; - } - return; - - default: - _error_("not implemented yet"); - } -} -/*}}}*/ -/*FUNCTION PentaVertexInput::PointwiseDivide{{{1*/ -Input* PentaVertexInput::PointwiseDivide(Input* inputB){ - - /*Ouput*/ - PentaVertexInput* outinput=NULL; - - /*Intermediaries*/ - int i; - PentaVertexInput *xinputB = NULL; - int B_numvalues; - const int numnodes = 6; - double AdotBvalues[numnodes]; - - /*Check that inputB is of the same type*/ - if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); - xinputB=(PentaVertexInput*)inputB; - - /*Create point wise sum*/ - for(i=0;ivalues[i]!=0); - AdotBvalues[i]=this->values[i]/xinputB->values[i]; - } - - /*Create new Penta vertex input (copy of current input)*/ - outinput=new PentaVertexInput(this->enum_type,&AdotBvalues[0]); - - /*Return output pointer*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::PointwiseMin{{{1*/ -Input* PentaVertexInput::PointwiseMin(Input* inputB){ - - /*Ouput*/ - PentaVertexInput* outinput=NULL; - - /*Intermediaries*/ - int i; - PentaVertexInput *xinputB = NULL; - int B_numvalues; - const int numnodes = 6; - double minvalues[numnodes]; - - /*Check that inputB is of the same type*/ - if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); - xinputB=(PentaVertexInput*)inputB; - - /*Create point wise min*/ - for(i=0;ivalues[i] > xinputB->values[i]) minvalues[i]=xinputB->values[i]; - else minvalues[i]=this->values[i]; - } - - /*Create new Penta vertex input (copy of current input)*/ - outinput=new PentaVertexInput(this->enum_type,&minvalues[0]); - - /*Return output pointer*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::PointwiseMax{{{1*/ -Input* PentaVertexInput::PointwiseMax(Input* inputB){ - - /*Ouput*/ - PentaVertexInput* outinput=NULL; - - /*Intermediaries*/ - int i; - PentaVertexInput *xinputB = NULL; - int B_numvalues; - const int numnodes = 6; - double maxvalues[numnodes]; - - /*Check that inputB is of the same type*/ - if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); - xinputB=(PentaVertexInput*)inputB; - - /*Create point wise max*/ - for(i=0;ivalues[i] < xinputB->values[i]) maxvalues[i]=xinputB->values[i]; - else maxvalues[i]=this->values[i]; - } - - /*Create new Penta vertex input (copy of current input)*/ - outinput=new PentaVertexInput(this->enum_type,&maxvalues[0]); - - /*Return output pointer*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetVectorFromInputs{{{1*/ -void PentaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){ - - const int numvertices=6; - VecSetValues(vector,numvertices,doflist,(const double*)this->values,INSERT_VALUES); - -} /*}}}*/ -/*FUNCTION PentaVertexInput::GetValuesPtr{{{1*/ -void PentaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){ - - *pvalues=this->values; - *pnum_values=6; - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::Configure{{{1*/ -void PentaVertexInput::Configure(Parameters* parameters){ - /*do nothing: */ -} -/*}}}*/ Index: sm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.h =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.h (revision 11290) +++ (revision ) @@ -1,89 +1,0 @@ -/*! \file PentaVertexInput.h - * \brief: header file for triavertexinput object - */ - - -#ifndef _PENTAVERTEXINPUT_H_ -#define _PENTAVERTEXINPUT_H_ - -/*Headers:*/ -/*{{{1*/ -#include "./Input.h" -#include "../Elements/PentaRef.h" -class GaussTria; -/*}}}*/ - -class PentaVertexInput: public Input, public PentaRef{ - - public: - /*just hold 6 values for 6 vertices: */ - int enum_type; - double values[6]; - - /*PentaVertexInput constructors, destructors: {{{1*/ - PentaVertexInput(); - PentaVertexInput(int enum_type,double* values); - ~PentaVertexInput(); - /*}}}*/ - /*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(); - /*}}}*/ - /*PentaVertexInput management: {{{1*/ - int InstanceEnum(); - Input* SpawnTriaInput(int* indices); - Input* PointwiseDivide(Input* inputB); - Input* PointwiseMin(Input* inputB); - Input* PointwiseMax(Input* inputB); - ElementResult* SpawnResult(int step, double time); - void AddTimeValues(double* values,int step,double time){_error_("not supported yet");}; - void Configure(Parameters* parameters); - /*}}}*/ - /*numerics: {{{1*/ - void GetInputValue(bool* pvalue){_error_("not implemented yet");}; - void GetInputValue(int* pvalue){_error_("not implemented yet");}; - void GetInputValue(double* pvalue){_error_("not implemented yet");}; - void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; - void GetInputValue(double* pvalue,GaussPenta* gauss); - void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; - void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetInputAverage(double* pvalue); - void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; - void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; - void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss); - void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss); - void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss); - void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss); - void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss); - void ChangeEnum(int newenumtype); - - void SquareMin(double* psquaremin, bool process_units,Parameters* parameters); - void ConstrainMin(double minimum); - void Scale(double scale_factor); - void ArtificialNoise(double min,double max){_error_("not implemented yet");}; - void AXPY(Input* xinput,double scalar); - void Constrain(double cm_min, double cm_max); - double InfinityNorm(void); - double Max(void); - double MaxAbs(void); - double Min(void); - double MinAbs(void); - void Extrude(void); - void VerticallyIntegrate(Input* thickness_input); - void GetVectorFromInputs(Vec vector,int* doflist); - void GetValuesPtr(double** pvalues,int* pnum_values); - /*}}}*/ - -}; -#endif /* _PENTAVERTEXINPUT_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 11291) @@ -0,0 +1,473 @@ +/*!\file TriaP1Input.c + * \brief: implementation of the TriaP1Input object + */ + +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include +#include +#include "../objects.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +/*TriaP1Input constructors and destructor*/ +/*FUNCTION TriaP1Input::TriaP1Input(){{{1*/ +TriaP1Input::TriaP1Input(){ + return; +} +/*}}}*/ +/*FUNCTION TriaP1Input::TriaP1Input(int in_enum_type,double* values){{{1*/ +TriaP1Input::TriaP1Input(int in_enum_type,double* in_values) + :TriaRef(1) +{ + + /*Set TriaRef*/ + this->SetElementType(P1Enum,0); + this->element_type=P1Enum; + + /*Set Enum*/ + enum_type=in_enum_type; + + /*Set values*/ + values[0]=in_values[0]; + values[1]=in_values[1]; + values[2]=in_values[2]; +} +/*}}}*/ +/*FUNCTION TriaP1Input::~TriaP1Input(){{{1*/ +TriaP1Input::~TriaP1Input(){ + return; +} +/*}}}*/ + +/*Object virtual functions definitions:*/ +/*FUNCTION TriaP1Input::Echo {{{1*/ +void TriaP1Input::Echo(void){ + this->DeepEcho(); +} +/*}}}*/ +/*FUNCTION TriaP1Input::DeepEcho{{{1*/ +void TriaP1Input::DeepEcho(void){ + + printf("TriaP1Input:\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]); +} +/*}}}*/ +/*FUNCTION TriaP1Input::Id{{{1*/ +int TriaP1Input::Id(void){ return -1; } +/*}}}*/ +/*FUNCTION TriaP1Input::MyRank{{{1*/ +int TriaP1Input::MyRank(void){ + extern int my_rank; + return my_rank; +} +/*}}}*/ +#ifdef _SERIAL_ +/*FUNCTION TriaP1Input::Marshall{{{1*/ +void TriaP1Input::Marshall(char** pmarshalled_dataset){ + + char* marshalled_dataset=NULL; + int enum_value=0; + + /*recover marshalled_dataset: */ + marshalled_dataset=*pmarshalled_dataset; + + /*get enum value of TriaP1Input: */ + enum_value=TriaP1InputEnum; + + /*marshall enum: */ + memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); + + /*marshall TriaP1Input data: */ + memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); + memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); + + *pmarshalled_dataset=marshalled_dataset; +} +/*}}}*/ +/*FUNCTION TriaP1Input::MarshallSize{{{1*/ +int TriaP1Input::MarshallSize(){ + + return sizeof(values)+ + +sizeof(enum_type)+ + +sizeof(int); //sizeof(int) for enum value +} +/*}}}*/ +/*FUNCTION TriaP1Input::Demarshall{{{1*/ +void TriaP1Input::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); + + /*return: */ + *pmarshalled_dataset=marshalled_dataset; + return; +} +/*}}}*/ +#endif +/*FUNCTION TriaP1Input::ObjectEnum{{{1*/ +int TriaP1Input::ObjectEnum(void){ + + return TriaP1InputEnum; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::copy{{{1*/ +Object* TriaP1Input::copy() { + + return new TriaP1Input(this->enum_type,this->values); + +} +/*}}}*/ + +/*TriaP1Input management*/ +/*FUNCTION TriaP1Input::InstanceEnum{{{1*/ +int TriaP1Input::InstanceEnum(void){ + + return this->enum_type; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::SpawnTriaInput{{{1*/ +Input* TriaP1Input::SpawnTriaInput(int* indices){ + + /*output*/ + TriaP1Input* outinput=NULL; + + /*Create new Tria input (copy of current input)*/ + outinput=new TriaP1Input(this->enum_type,&this->values[0]); + + /*Assign output*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::SpawnResult{{{1*/ +ElementResult* TriaP1Input::SpawnResult(int step, double time){ + + return new TriaVertexElementResult(this->enum_type,this->values,step,time); + +} +/*}}}*/ + +/*Object functions*/ +/*FUNCTION TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){ + + /*Call TriaRef function*/ + TriaRef::GetInputValue(pvalue,&values[0],gauss); + +} +/*}}}*/ +/*FUNCTION TriaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ +void TriaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ + + /*Call TriaRef function*/ + TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); +} +/*}}}*/ +/*FUNCTION TriaP1Input::GetVxStrainRate2d{{{1*/ +void TriaP1Input::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ + + /*Intermediary*/ + int i; + const int numnodes=3; + double B[3][NDOF2*numnodes]; + double velocity[3][NDOF2]; + + /*Get B matrix: */ + GetBMacAyeal(&B[0][0], xyz_list, gauss); + + /*Here, we are computing the strain rate of (vx,0)*/ + for(i=0;i<3;i++){ + velocity[i][0]=this->values[i]; + velocity[i][1]=0.0; + } + /*Get epsilon(vx) = B*velocity*/ + MatrixMultiply( &B[0][0],3,NDOF2*numnodes,0, + &velocity[0][0],NDOF2*numnodes,1,0, + epsilonvx,0); +} +/*}}}*/ +/*FUNCTION TriaP1Input::GetVyStrainRate2d{{{1*/ +void TriaP1Input::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ + + /*Intermediary*/ + int i; + const int numnodes=3; + double B[3][NDOF2*numnodes]; + double velocity[3][NDOF2]; + + /*Get B matrix: */ + GetBMacAyeal(&B[0][0], xyz_list, gauss); + + /*Here, we are computing the strain rate of (0,vy)*/ + for(i=0;i<3;i++){ + velocity[i][0]=0.0; + velocity[i][1]=this->values[i]; + } + /*Get epsilon(vy) = B*velocity*/ + MatrixMultiply( &B[0][0],3,NDOF2*numnodes,0, + &velocity[0][0],NDOF2*numnodes,1,0, + epsilonvy,0); +} +/*}}}*/ +/*FUNCTION TriaP1Input::ChangeEnum{{{1*/ +void TriaP1Input::ChangeEnum(int newenumtype){ + this->enum_type=newenumtype; +} +/*}}}*/ +/*FUNCTION TriaP1Input::GetInputAverage{{{1*/ +void TriaP1Input::GetInputAverage(double* pvalue){ + *pvalue=1./3.*(values[0]+values[1]+values[2]); +} +/*}}}*/ + +/*Intermediary*/ +/*FUNCTION TriaP1Input::SquareMin{{{1*/ +void TriaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){ + + int i; + const int numnodes=3; + double valuescopy[numnodes]; + double squaremin; + + /*First, copy values, to process units if requested: */ + for(i=0;ivalues[i]; + + /*Process units if requested: */ + if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type); + + /*Now, figure out minimum of valuescopy: */ + squaremin=pow(valuescopy[0],2); + for(i=1;inorm) norm=fabs(values[i]); + return norm; +} +/*}}}*/ +/*FUNCTION TriaP1Input::Max{{{1*/ +double TriaP1Input::Max(void){ + + const int numnodes=3; + double max=values[0]; + + for(int i=1;imax) max=values[i]; + } + return max; +} +/*}}}*/ +/*FUNCTION TriaP1Input::MaxAbs{{{1*/ +double TriaP1Input::MaxAbs(void){ + + const int numnodes=3; + double max=fabs(values[0]); + + for(int i=1;imax) max=fabs(values[i]); + } + return max; +} +/*}}}*/ +/*FUNCTION TriaP1Input::Min{{{1*/ +double TriaP1Input::Min(void){ + + const int numnodes=3; + double min=values[0]; + + for(int i=1;iObjectEnum()){ + + case TriaP1InputEnum : + for(i=0;ivalues[i]=this->values[i]+scalar*xtriavertexinput->values[i]; + return; + + default : + _error_("not implemented yet"); + } + +} +/*}}}*/ +/*FUNCTION TriaP1Input::Constrain{{{1*/ +void TriaP1Input::Constrain(double cm_min, double cm_max){ + + int i; + const int numnodes=3; + + if(!isnan(cm_min)) for(i=0;ivalues[i]values[i]=cm_min; + if(!isnan(cm_max)) for(i=0;ivalues[i]>cm_max)this->values[i]=cm_max; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::GetVectorFromInputs{{{1*/ +void TriaP1Input::GetVectorFromInputs(Vec vector,int* doflist){ + + const int numvertices=3; + VecSetValues(vector,numvertices,doflist,(const double*)this->values,INSERT_VALUES); + +} /*}}}*/ +/*FUNCTION TriaP1Input::GetValuesPtr{{{1*/ +void TriaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){ + + *pvalues=this->values; + if(pnum_values)*pnum_values=3; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::PointwiseMin{{{1*/ +Input* TriaP1Input::PointwiseMin(Input* inputB){ + + /*Ouput*/ + TriaP1Input* outinput=NULL; + + /*Intermediaries*/ + int i; + TriaP1Input *xinputB = NULL; + int B_numvalues; + const int numnodes = 3; + double minvalues[numnodes]; + + /*Check that inputB is of the same type*/ + if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); + xinputB=(TriaP1Input*)inputB; + + /*Create point wise min*/ + for(i=0;ivalues[i] > xinputB->values[i]) minvalues[i]=xinputB->values[i]; + else minvalues[i]=this->values[i]; + } + + /*Create new Tria vertex input (copy of current input)*/ + outinput=new TriaP1Input(this->enum_type,&minvalues[0]); + + /*Return output pointer*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::PointwiseMax{{{1*/ +Input* TriaP1Input::PointwiseMax(Input* inputB){ + + /*Ouput*/ + TriaP1Input* outinput=NULL; + + /*Intermediaries*/ + int i; + TriaP1Input *xinputB = NULL; + int B_numvalues; + const int numnodes = 3; + double maxvalues[numnodes]; + + /*Check that inputB is of the same type*/ + if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); + xinputB=(TriaP1Input*)inputB; + + /*Create point wise max*/ + for(i=0;ivalues[i] < xinputB->values[i]) maxvalues[i]=xinputB->values[i]; + else maxvalues[i]=this->values[i]; + } + + /*Create new Tria vertex input (copy of current input)*/ + outinput=new TriaP1Input(this->enum_type,&maxvalues[0]); + + /*Return output pointer*/ + return outinput; + +} +/*}}}*/ +/*FUNCTION TriaP1Input::Configure{{{1*/ +void TriaP1Input::Configure(Parameters* parameters){ + /*do nothing: */ +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h (revision 11291) +++ /issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h (revision 11291) @@ -0,0 +1,89 @@ +/*! \file TriaP1Input.h + * \brief: header file for TriaP1Input object + */ + + +#ifndef _TRIAP1INPUT_H_ +#define _TRIAP1INPUT_H_ + +/*Headers:*/ +/*{{{1*/ +#include "./Input.h" +#include "../Elements/TriaRef.h" +class GaussTria; +/*}}}*/ + +class TriaP1Input: public Input,public TriaRef{ + + public: + /*just hold 3 values for 3 vertices: */ + int enum_type; + double values[3]; + + /*TriaP1Input constructors, destructors: {{{1*/ + TriaP1Input(); + TriaP1Input(int enum_type,double* values); + ~TriaP1Input(); + /*}}}*/ + /*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(); + /*}}}*/ + /*TriaP1Input management: {{{1*/ + int InstanceEnum(); + Input* SpawnTriaInput(int* indices); + Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");}; + Input* PointwiseMin(Input* inputB); + Input* PointwiseMax(Input* inputB); + ElementResult* SpawnResult(int step, double time); + void AddTimeValues(double* values,int step,double time){_error_("not supported yet");}; + void Configure(Parameters* parameters); + /*}}}*/ + /*numerics: {{{1*/ + void GetInputValue(bool* pvalue){_error_("not implemented yet");} + void GetInputValue(int* pvalue){_error_("not implemented yet");} + void GetInputValue(double* pvalue){_error_("not implemented yet");} + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputAverage(double* pvalue); + void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss); + void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss); + void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void ChangeEnum(int newenumtype); + + void SquareMin(double* psquaremin, bool process_units,Parameters* parameters); + void ConstrainMin(double minimum); + void Scale(double scale_factor); + void ArtificialNoise(double min,double max); + void AXPY(Input* xinput,double scalar); + void Constrain(double cm_min, double cm_max); + double InfinityNorm(void); + double Max(void); + double MaxAbs(void); + double Min(void); + double MinAbs(void); + void Extrude(void){_error_("not supported yet");}; + void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");}; + void GetVectorFromInputs(Vec vector,int* doflist); + void GetValuesPtr(double** pvalues,int* pnum_values); + /*}}}*/ + +}; +#endif /* _TRIAP1INPUT_H */ Index: sm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.cpp (revision 11290) +++ (revision ) @@ -1,473 +1,0 @@ -/*!\file TriaVertexInput.c - * \brief: implementation of the TriaVertexInput object - */ - -#ifdef HAVE_CONFIG_H - #include -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include -#include -#include "../objects.h" -#include "../../EnumDefinitions/EnumDefinitions.h" -#include "../../shared/shared.h" -#include "../../Container/Container.h" -#include "../../include/include.h" - -/*TriaVertexInput constructors and destructor*/ -/*FUNCTION TriaVertexInput::TriaVertexInput(){{{1*/ -TriaVertexInput::TriaVertexInput(){ - return; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::TriaVertexInput(int in_enum_type,double* values){{{1*/ -TriaVertexInput::TriaVertexInput(int in_enum_type,double* in_values) - :TriaRef(1) -{ - - /*Set TriaRef*/ - this->SetElementType(P1Enum,0); - this->element_type=P1Enum; - - /*Set Enum*/ - enum_type=in_enum_type; - - /*Set values*/ - values[0]=in_values[0]; - values[1]=in_values[1]; - values[2]=in_values[2]; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::~TriaVertexInput(){{{1*/ -TriaVertexInput::~TriaVertexInput(){ - return; -} -/*}}}*/ - -/*Object virtual functions definitions:*/ -/*FUNCTION TriaVertexInput::Echo {{{1*/ -void TriaVertexInput::Echo(void){ - this->DeepEcho(); -} -/*}}}*/ -/*FUNCTION TriaVertexInput::DeepEcho{{{1*/ -void TriaVertexInput::DeepEcho(void){ - - printf("TriaVertexInput:\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]); -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Id{{{1*/ -int TriaVertexInput::Id(void){ return -1; } -/*}}}*/ -/*FUNCTION TriaVertexInput::MyRank{{{1*/ -int TriaVertexInput::MyRank(void){ - extern int my_rank; - return my_rank; -} -/*}}}*/ -#ifdef _SERIAL_ -/*FUNCTION TriaVertexInput::Marshall{{{1*/ -void TriaVertexInput::Marshall(char** pmarshalled_dataset){ - - char* marshalled_dataset=NULL; - int enum_value=0; - - /*recover marshalled_dataset: */ - marshalled_dataset=*pmarshalled_dataset; - - /*get enum value of TriaVertexInput: */ - enum_value=TriaVertexInputEnum; - - /*marshall enum: */ - memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value); - - /*marshall TriaVertexInput data: */ - memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type); - memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values); - - *pmarshalled_dataset=marshalled_dataset; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::MarshallSize{{{1*/ -int TriaVertexInput::MarshallSize(){ - - return sizeof(values)+ - +sizeof(enum_type)+ - +sizeof(int); //sizeof(int) for enum value -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Demarshall{{{1*/ -void TriaVertexInput::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); - - /*return: */ - *pmarshalled_dataset=marshalled_dataset; - return; -} -/*}}}*/ -#endif -/*FUNCTION TriaVertexInput::ObjectEnum{{{1*/ -int TriaVertexInput::ObjectEnum(void){ - - return TriaVertexInputEnum; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::copy{{{1*/ -Object* TriaVertexInput::copy() { - - return new TriaVertexInput(this->enum_type,this->values); - -} -/*}}}*/ - -/*TriaVertexInput management*/ -/*FUNCTION TriaVertexInput::InstanceEnum{{{1*/ -int TriaVertexInput::InstanceEnum(void){ - - return this->enum_type; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::SpawnTriaInput{{{1*/ -Input* TriaVertexInput::SpawnTriaInput(int* indices){ - - /*output*/ - TriaVertexInput* outinput=NULL; - - /*Create new Tria input (copy of current input)*/ - outinput=new TriaVertexInput(this->enum_type,&this->values[0]); - - /*Assign output*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::SpawnResult{{{1*/ -ElementResult* TriaVertexInput::SpawnResult(int step, double time){ - - return new TriaVertexElementResult(this->enum_type,this->values,step,time); - -} -/*}}}*/ - -/*Object functions*/ -/*FUNCTION TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ -void TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){ - - /*Call TriaRef function*/ - TriaRef::GetInputValue(pvalue,&values[0],gauss); - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ -void TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ - - /*Call TriaRef function*/ - TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetVxStrainRate2d{{{1*/ -void TriaVertexInput::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ - - /*Intermediary*/ - int i; - const int numnodes=3; - double B[3][NDOF2*numnodes]; - double velocity[3][NDOF2]; - - /*Get B matrix: */ - GetBMacAyeal(&B[0][0], xyz_list, gauss); - - /*Here, we are computing the strain rate of (vx,0)*/ - for(i=0;i<3;i++){ - velocity[i][0]=this->values[i]; - velocity[i][1]=0.0; - } - /*Get epsilon(vx) = B*velocity*/ - MatrixMultiply( &B[0][0],3,NDOF2*numnodes,0, - &velocity[0][0],NDOF2*numnodes,1,0, - epsilonvx,0); -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetVyStrainRate2d{{{1*/ -void TriaVertexInput::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ - - /*Intermediary*/ - int i; - const int numnodes=3; - double B[3][NDOF2*numnodes]; - double velocity[3][NDOF2]; - - /*Get B matrix: */ - GetBMacAyeal(&B[0][0], xyz_list, gauss); - - /*Here, we are computing the strain rate of (0,vy)*/ - for(i=0;i<3;i++){ - velocity[i][0]=0.0; - velocity[i][1]=this->values[i]; - } - /*Get epsilon(vy) = B*velocity*/ - MatrixMultiply( &B[0][0],3,NDOF2*numnodes,0, - &velocity[0][0],NDOF2*numnodes,1,0, - epsilonvy,0); -} -/*}}}*/ -/*FUNCTION TriaVertexInput::ChangeEnum{{{1*/ -void TriaVertexInput::ChangeEnum(int newenumtype){ - this->enum_type=newenumtype; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetInputAverage{{{1*/ -void TriaVertexInput::GetInputAverage(double* pvalue){ - *pvalue=1./3.*(values[0]+values[1]+values[2]); -} -/*}}}*/ - -/*Intermediary*/ -/*FUNCTION TriaVertexInput::SquareMin{{{1*/ -void TriaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){ - - int i; - const int numnodes=3; - double valuescopy[numnodes]; - double squaremin; - - /*First, copy values, to process units if requested: */ - for(i=0;ivalues[i]; - - /*Process units if requested: */ - if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type); - - /*Now, figure out minimum of valuescopy: */ - squaremin=pow(valuescopy[0],2); - for(i=1;inorm) norm=fabs(values[i]); - return norm; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Max{{{1*/ -double TriaVertexInput::Max(void){ - - const int numnodes=3; - double max=values[0]; - - for(int i=1;imax) max=values[i]; - } - return max; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::MaxAbs{{{1*/ -double TriaVertexInput::MaxAbs(void){ - - const int numnodes=3; - double max=fabs(values[0]); - - for(int i=1;imax) max=fabs(values[i]); - } - return max; -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Min{{{1*/ -double TriaVertexInput::Min(void){ - - const int numnodes=3; - double min=values[0]; - - for(int i=1;iObjectEnum()){ - - case TriaVertexInputEnum : - for(i=0;ivalues[i]=this->values[i]+scalar*xtriavertexinput->values[i]; - return; - - default : - _error_("not implemented yet"); - } - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Constrain{{{1*/ -void TriaVertexInput::Constrain(double cm_min, double cm_max){ - - int i; - const int numnodes=3; - - if(!isnan(cm_min)) for(i=0;ivalues[i]values[i]=cm_min; - if(!isnan(cm_max)) for(i=0;ivalues[i]>cm_max)this->values[i]=cm_max; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetVectorFromInputs{{{1*/ -void TriaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){ - - const int numvertices=3; - VecSetValues(vector,numvertices,doflist,(const double*)this->values,INSERT_VALUES); - -} /*}}}*/ -/*FUNCTION TriaVertexInput::GetValuesPtr{{{1*/ -void TriaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){ - - *pvalues=this->values; - if(pnum_values)*pnum_values=3; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::PointwiseMin{{{1*/ -Input* TriaVertexInput::PointwiseMin(Input* inputB){ - - /*Ouput*/ - TriaVertexInput* outinput=NULL; - - /*Intermediaries*/ - int i; - TriaVertexInput *xinputB = NULL; - int B_numvalues; - const int numnodes = 3; - double minvalues[numnodes]; - - /*Check that inputB is of the same type*/ - if (inputB->ObjectEnum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); - xinputB=(TriaVertexInput*)inputB; - - /*Create point wise min*/ - for(i=0;ivalues[i] > xinputB->values[i]) minvalues[i]=xinputB->values[i]; - else minvalues[i]=this->values[i]; - } - - /*Create new Tria vertex input (copy of current input)*/ - outinput=new TriaVertexInput(this->enum_type,&minvalues[0]); - - /*Return output pointer*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::PointwiseMax{{{1*/ -Input* TriaVertexInput::PointwiseMax(Input* inputB){ - - /*Ouput*/ - TriaVertexInput* outinput=NULL; - - /*Intermediaries*/ - int i; - TriaVertexInput *xinputB = NULL; - int B_numvalues; - const int numnodes = 3; - double maxvalues[numnodes]; - - /*Check that inputB is of the same type*/ - if (inputB->ObjectEnum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum())); - xinputB=(TriaVertexInput*)inputB; - - /*Create point wise max*/ - for(i=0;ivalues[i] < xinputB->values[i]) maxvalues[i]=xinputB->values[i]; - else maxvalues[i]=this->values[i]; - } - - /*Create new Tria vertex input (copy of current input)*/ - outinput=new TriaVertexInput(this->enum_type,&maxvalues[0]); - - /*Return output pointer*/ - return outinput; - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::Configure{{{1*/ -void TriaVertexInput::Configure(Parameters* parameters){ - /*do nothing: */ -} -/*}}}*/ Index: sm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.h =================================================================== --- /issm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.h (revision 11290) +++ (revision ) @@ -1,89 +1,0 @@ -/*! \file TriaVertexInput.h - * \brief: header file for triavertexinput object - */ - - -#ifndef _TRIAVERTEXINPUT_H_ -#define _TRIAVERTEXINPUT_H_ - -/*Headers:*/ -/*{{{1*/ -#include "./Input.h" -#include "../Elements/TriaRef.h" -class GaussTria; -/*}}}*/ - -class TriaVertexInput: public Input,public TriaRef{ - - public: - /*just hold 3 values for 3 vertices: */ - int enum_type; - double values[3]; - - /*TriaVertexInput constructors, destructors: {{{1*/ - TriaVertexInput(); - TriaVertexInput(int enum_type,double* values); - ~TriaVertexInput(); - /*}}}*/ - /*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(); - /*}}}*/ - /*TriaVertexInput management: {{{1*/ - int InstanceEnum(); - Input* SpawnTriaInput(int* indices); - Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");}; - Input* PointwiseMin(Input* inputB); - Input* PointwiseMax(Input* inputB); - ElementResult* SpawnResult(int step, double time); - void AddTimeValues(double* values,int step,double time){_error_("not supported yet");}; - void Configure(Parameters* parameters); - /*}}}*/ - /*numerics: {{{1*/ - void GetInputValue(bool* pvalue){_error_("not implemented yet");} - void GetInputValue(int* pvalue){_error_("not implemented yet");} - void GetInputValue(double* pvalue){_error_("not implemented yet");} - void GetInputValue(double* pvalue,GaussTria* gauss); - void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; - void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetInputValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");}; - void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetInputAverage(double* pvalue); - void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss); - void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss); - void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void ChangeEnum(int newenumtype); - - void SquareMin(double* psquaremin, bool process_units,Parameters* parameters); - void ConstrainMin(double minimum); - void Scale(double scale_factor); - void ArtificialNoise(double min,double max); - void AXPY(Input* xinput,double scalar); - void Constrain(double cm_min, double cm_max); - double InfinityNorm(void); - double Max(void); - double MaxAbs(void); - double Min(void); - double MinAbs(void); - void Extrude(void){_error_("not supported yet");}; - void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");}; - void GetVectorFromInputs(Vec vector,int* doflist); - void GetValuesPtr(double** pvalues,int* pnum_values); - /*}}}*/ - -}; -#endif /* _TRIAVERTEXINPUT_H */ Index: /issm/trunk-jpl/src/c/objects/Materials/Matice.cpp =================================================================== --- /issm/trunk-jpl/src/c/objects/Materials/Matice.cpp (revision 11290) +++ /issm/trunk-jpl/src/c/objects/Materials/Matice.cpp (revision 11291) @@ -552,5 +552,5 @@ double values[3]; for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->nodes[i]->GetVertexDof()]; - this->inputs->AddInput(new TriaVertexInput(name,values)); + this->inputs->AddInput(new TriaP1Input(name,values)); return; @@ -594,5 +594,5 @@ double values[3]; for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->nodes[i]->GetSidList()]; //use sid list, to index into serial oriented vector - this->inputs->AddInput(new TriaVertexInput(name,values)); + this->inputs->AddInput(new TriaP1Input(name,values)); /*Special case for rheology B in 2D: Pourave land for this solution{{{2*/ if(name==MaterialsRheologyBEnum){ @@ -607,5 +607,5 @@ if(dim==2){ /*Dupliacte rheology input: */ - this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,values)); + this->inputs->AddInput(new TriaP1Input(MaterialsRheologyBbarEnum,values)); } } @@ -683,5 +683,5 @@ if (iomodel->Data(MaterialsRheologyBEnum)) { for(i=0;iData(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)]; - this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(MaterialsRheologyBbarEnum,nodeinputs)); } @@ -689,5 +689,5 @@ if (iomodel->Data(MaterialsRheologyNEnum)) { for(i=0;iData(MaterialsRheologyNEnum)[index]; - this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyNEnum,nodeinputs)); + this->inputs->AddInput(new TriaP1Input(MaterialsRheologyNEnum,nodeinputs)); } @@ -703,5 +703,5 @@ for(j=0;jData(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i]; for(j=0;jData(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; @@ -725,5 +725,5 @@ if (iomodel->Data(MaterialsRheologyBEnum)) { for(i=0;iData(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)]; - this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,nodeinputs)); } @@ -731,5 +731,5 @@ if (iomodel->Data(MaterialsRheologyNEnum)) { for(i=0;iData(MaterialsRheologyNEnum)[index]; - this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyNEnum,nodeinputs)); + this->inputs->AddInput(new PentaP1Input(MaterialsRheologyNEnum,nodeinputs)); } @@ -745,5 +745,5 @@ for(j=0;jData(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i]; for(j=0;jData(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; Index: /issm/trunk-jpl/src/c/objects/objects.h =================================================================== --- /issm/trunk-jpl/src/c/objects/objects.h (revision 11290) +++ /issm/trunk-jpl/src/c/objects/objects.h (revision 11291) @@ -88,6 +88,6 @@ #include "./Inputs/DoubleInput.h" #include "./Inputs/IntInput.h" -#include "./Inputs/PentaVertexInput.h" -#include "./Inputs/TriaVertexInput.h" +#include "./Inputs/PentaP1Input.h" +#include "./Inputs/TriaP1Input.h" #include "./Inputs/ControlInput.h" #include "./Inputs/DatasetInput.h"