Changeset 11291

Timestamp:

02/01/12 13:47:42 (13 years ago)

Author:

Mathieu Morlighem

Message:

moved TriaVertexInput to TriaP1Input and same for Penta

Location:

issm/trunk-jpl/src/c

Files:

• Container/DataSet.cpp (modified) (1 diff)
• EnumDefinitions/EnumDefinitions.h (modified) (2 diffs)
• Makefile.am (modified) (2 diffs)
• modules/EnumToStringx/EnumToStringx.cpp (modified) (2 diffs)
• modules/StringToEnumx/StringToEnumx.cpp (modified) (2 diffs)
• objects/ElementResults/PentaVertexElementResult.h (modified) (1 diff)
• objects/Elements/Penta.cpp (modified) (51 diffs)
• objects/Elements/Tria.cpp (modified) (25 diffs)
• objects/Inputs/ControlInput.cpp (modified) (6 diffs)
• objects/Inputs/DoubleInput.cpp (modified) (1 diff)
• objects/Inputs/PentaP1Input.cpp (moved) (moved from issm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.cpp ) (46 diffs)
• objects/Inputs/PentaP1Input.h (moved) (moved from issm/trunk-jpl/src/c/objects/Inputs/PentaVertexInput.h ) (4 diffs)
• objects/Inputs/TriaP1Input.cpp (moved) (moved from issm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.cpp ) (36 diffs)
• objects/Inputs/TriaP1Input.h (moved) (moved from issm/trunk-jpl/src/c/objects/Inputs/TriaVertexInput.h ) (5 diffs)
• objects/Materials/Matice.cpp (modified) (9 diffs)
• objects/objects.h (modified) (1 diff)

issm/trunk-jpl/src/c/Container/DataSet.cpp

@@ -224 +224 @@
                                 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);}

issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h

@@ -261 +261 @@
         PenpairEnum,
         PentaEnum,
-        PentaVertexInputEnum,
+        PentaP1InputEnum,
         PetscMatParamEnum,
         PetscVecParamEnum,
@@ -274 +274 @@
         StringParamEnum,
         TriaEnum,
-        TriaVertexInputEnum,
+        TriaP1InputEnum,
         VertexEnum,
         /*}}}*/

issm/trunk-jpl/src/c/Makefile.am

@@ -88 +88 @@
                                         ./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 +561 @@
                                      ./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\

issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp

@@ -257 +257 @@
                 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 +270 @@
                 case StringParamEnum : return "StringParam";
                 case TriaEnum : return "Tria";
-                case TriaVertexInputEnum : return "TriaVertexInput";
+                case TriaP1InputEnum : return "TriaP1Input";
                 case VertexEnum : return "Vertex";
                 case AirEnum : return "Air";

issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp

@@ -255 +255 @@
         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 +268 @@
         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;

issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h

@@ -1 +1 @@
 /*! \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.
  */
 

issm/trunk-jpl/src/c/objects/Elements/Penta.cpp

@@ -347 +347 @@
         if (!IsOnBed() || IsFloating()){
                 //empty friction: 
-                this->inputs->AddInput(new PentaVertexInput(BasalFrictionEnum,&basalfriction[0]));
+                this->inputs->AddInput(new PentaP1Input(BasalFrictionEnum,&basalfriction[0]));
                 return;
         }
@@ -375 +375 @@
         
         /*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 +523 @@
         
         /*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 +1347 @@
 
                         /*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 +1366 @@
 
                                 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 +1420 @@
 
         /*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 +1438 @@
                 /*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 +1454 @@
                         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 +1681 @@
                                                 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 +1689 @@
                                                 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 +1697 @@
                                                 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 +1705 @@
                                                 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 +1755 @@
                 for(i=0;i<num_cm_responses;i++){
                         for(j=0;j<6;j++)nodeinputs[j]=iomodel->Data(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 +1900 @@
         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 +1933 @@
 
         /*Add input to the element: */
-        this->inputs->AddInput(new PentaVertexInput(enum_type,values));
+        this->inputs->AddInput(new PentaP1Input(enum_type,values));
         
         /*Free ressources:*/
@@ -1966 +1966 @@
         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 +2000 @@
 
                         /*update input*/
-                        this->inputs->AddInput(new PentaVertexInput(name,values));
+                        this->inputs->AddInput(new PentaP1Input(name,values));
                         return;
 
@@ -2241 +2241 @@
         if(!this->IsFloating() && elementonshelf==true){
                 for(i=0;i<NUMVERTICES;i++)melting[i]=gl_melting_rate/yts;
-                this->inputs->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 +2768 @@
                         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 +2796 @@
                                 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 +2810 @@
                                 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 +2825 @@
                         /*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 +2833 @@
                         /*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 +2845 @@
                                                 +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 +2918 @@
 
         /*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 +4199 @@
         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 +4211 @@
                                 B_average=Paterson((values[0]+values[1]+values[2]+values[3]+values[4]+values[5])/6.0);
                                 for(i=0;i<numdof;i++) B[i]=B_average;
-                                this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
+                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
                                 break;
                         case ArrheniusEnum:
@@ -4219 +4219 @@
                                                         matice->GetN());
                                 for(i=0;i<numdof;i++) B[i]=B_average;
-                                this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
+                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
                                 break;
                         default:
@@ -4227 +4227 @@
         }
         else{
-                this->inputs->AddInput(new PentaVertexInput(TemperaturePicardEnum,values));
+                this->inputs->AddInput(new PentaP1Input(TemperaturePicardEnum,values));
         }
 
@@ -4272 +4272 @@
                 for(i=0;i<numdof;i++) matpar->EnthalpyToThermal(&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 +4286 @@
                                 B_average=Paterson((temperatures[0]+temperatures[1]+temperatures[2]+temperatures[3]+temperatures[4]+temperatures[5])/6.0);
                                 for(i=0;i<numdof;i++) B[i]=B_average;
-                                this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
+                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
                                 break;
                         case ArrheniusEnum:
@@ -4294 +4294 @@
                                                         matice->GetN());
                                 for(i=0;i<numdof;i++) B[i]=B_average;
-                                this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
+                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
                                 break;
                         default:
@@ -4302 +4302 @@
 //      }
 //      else{
-//              this->inputs->AddInput(new PentaVertexInput(EnthalpyPicardEnum,values));
+//              this->inputs->AddInput(new PentaP1Input(EnthalpyPicardEnum,values));
 //      }
 
@@ -4367 +4367 @@
         this->GetDofList1(&doflist1[0]);
         for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[doflist1[i]];
-        grad_input=new PentaVertexInput(GradientEnum,grad_list);
+        grad_input=new PentaP1Input(GradientEnum,grad_list);
         ((ControlInput*)input)->SetGradient(grad_input);
 
@@ -4823 +4823 @@
 
         /*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 +4860 @@
 
         /*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 +5125 @@
                 case VertexEnum:
 
-                        /*New PentaVertexInput*/
+                        /*New PentaP1Input*/
                         double values[6];
 
@@ -5198 +5198 @@
 
                                         /*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 +5258 @@
 
                                 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 +7569 @@
 
                 /*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 +7659 @@
 
         /*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 +7734 @@
         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 +7757 @@
 
         /*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 +7834 @@
 
         /*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 +7902 @@
         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 +7925 @@
 
         /*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 +7991 @@
 
         /*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 +8049 @@
                 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 +8061 @@
                 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 +8089 @@
         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 +8155 @@
 
         /*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:*/

issm/trunk-jpl/src/c/objects/Elements/Tria.cpp

@@ -938 +938 @@
         
         /*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 +1516 @@
                                                 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 +1524 @@
                                                 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 +1532 @@
                                                 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 +1540 @@
                                                 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 +1559 @@
                 for(i=0;i<num_cm_responses;i++){
                         for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(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 +1640 @@
 
         /*Add input to the element: */
-        this->inputs->AddInput(new TriaVertexInput(enum_type,values));
+        this->inputs->AddInput(new TriaP1Input(enum_type,values));
 
         /*Free ressources:*/
@@ -1705 +1705 @@
 
         /*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 +1723 @@
                 case VertexEnum:
 
-                        /*New TriaVertexInput*/
+                        /*New TriaP1Input*/
                         double values[3];
 
@@ -1733 +1733 @@
                         /*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 +1812 @@
 
                         /*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 +1831 @@
 
                                 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 +2067 @@
         if(!this->IsFloating() && elementonshelf==true){
                 for(i=0;i<NUMVERTICES;i++)melting[i]=gl_melting_rate/yts;
-                this->inputs->AddInput(new TriaVertexInput(BasalforcingsMeltingRateEnum,&melting[0]));
+                this->inputs->AddInput(new TriaP1Input(BasalforcingsMeltingRateEnum,&melting[0]));
         } 
 
@@ -2074 +2074 @@
 
         /*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 +2398 @@
                         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 +3158 @@
 
         /*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 +3218 @@
 
         /*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 +3319 @@
         this->GetDofList1(&doflist1[0]);
         for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[doflist1[i]];
-        grad_input=new TriaVertexInput(GradientEnum,grad_list);
+        grad_input=new TriaP1Input(GradientEnum,grad_list);
 
         ((ControlInput*)input)->SetGradient(grad_input);
@@ -4678 +4678 @@
 
         /*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 +4708 @@
 
         /*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 +4768 @@
 
         /*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 +4984 @@
 
         /*Add input to the element: */
-        this->inputs->AddInput(new TriaVertexInput(WatercolumnEnum,values));
+        this->inputs->AddInput(new TriaP1Input(WatercolumnEnum,values));
 
         /*Free ressources:*/
@@ -5005 +5005 @@
                 case VertexEnum:
 
-                        /*New TriaVertexInput*/
+                        /*New TriaP1Input*/
                         double values[3];
 
@@ -5078 +5078 @@
 
                                         /*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 +5137 @@
 
                                 if(t==0) transientinput=new TransientInput(name);
-                                transientinput->AddTimeInput(new TriaVertexInput(name,values),time);
+                                transientinput->AddTimeInput(new TriaP1Input(name,values),time);
                                 transientinput->Configure(parameters);
                         }

issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp

@@ -35 +35 @@
 
         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 +206 @@
         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 +224 @@
         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 +242 @@
         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 +260 @@
         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 +278 @@
         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);
                 }

issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp

@@ -340 +340 @@
         switch(thickness_input->ObjectEnum()){
 
-                case PentaVertexInputEnum:
+                case PentaP1InputEnum:
                         thickness_input->GetInputAverage(&thickness_value);
                         this->value=this->value*thickness_value;

issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp

@@ -1 @@
-/*!\file PentaVertexInput.c
- * \brief: implementation of the PentaVertexInput object
+/*!\file PentaP1Input.c
+ * \brief: implementation of the PentaP1Input object
  */
 
@@ -17 +17 @@
 #include "../../include/include.h"
 
-/*PentaVertexInput constructors and destructor*/
-/*FUNCTION PentaVertexInput::PentaVertexInput(){{{1*/
-PentaVertexInput::PentaVertexInput(){
+/*PentaP1Input constructors and destructor*/
+/*FUNCTION PentaP1Input::PentaP1Input(){{{1*/
+PentaP1Input::PentaP1Input(){
         return;
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::PentaVertexInput(int in_enum_type,double* values){{{1*/
-PentaVertexInput::PentaVertexInput(int in_enum_type,double* in_values)
+/*FUNCTION PentaP1Input::PentaP1Input(int in_enum_type,double* values){{{1*/
+PentaP1Input::PentaP1Input(int in_enum_type,double* in_values)
                 :PentaRef(1)
 {
@@ -41 +41 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::~PentaVertexInput(){{{1*/
-PentaVertexInput::~PentaVertexInput(){
+/*FUNCTION PentaP1Input::~PentaP1Input(){{{1*/
+PentaP1Input::~PentaP1Input(){
         return;
 }
@@ -48 +48 @@
 
 /*Object virtual functions definitions:*/
-/*FUNCTION PentaVertexInput::Echo {{{1*/
-void PentaVertexInput::Echo(void){
+/*FUNCTION PentaP1Input::Echo {{{1*/
+void PentaP1Input::Echo(void){
         this->DeepEcho();
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::DeepEcho{{{1*/
-void PentaVertexInput::DeepEcho(void){
-
-        printf("PentaVertexInput:\n");
+/*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 PentaVertexInput::Id{{{1*/
-int    PentaVertexInput::Id(void){ return -1; }
-/*}}}*/
-/*FUNCTION PentaVertexInput::MyRank{{{1*/
-int    PentaVertexInput::MyRank(void){ 
+/*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; 
@@ -71 +71 @@
 /*}}}*/
 #ifdef _SERIAL_
-/*FUNCTION PentaVertexInput::Marshall{{{1*/
-void  PentaVertexInput::Marshall(char** pmarshalled_dataset){
+/*FUNCTION PentaP1Input::Marshall{{{1*/
+void  PentaP1Input::Marshall(char** pmarshalled_dataset){
 
         char* marshalled_dataset=NULL;
@@ -80 +80 @@
         marshalled_dataset=*pmarshalled_dataset;
 
-        /*get enum value of PentaVertexInput: */
-        enum_value=PentaVertexInputEnum;
+        /*get enum value of PentaP1Input: */
+        enum_value=PentaP1InputEnum;
         
         /*marshall enum: */
         memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
         
-        /*marshall PentaVertexInput data: */
+        /*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);
@@ -93 +93 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::MarshallSize{{{1*/
-int   PentaVertexInput::MarshallSize(){
+/*FUNCTION PentaP1Input::MarshallSize{{{1*/
+int   PentaP1Input::MarshallSize(){
         
         return sizeof(values)+
@@ -101 +101 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Demarshall{{{1*/
-void  PentaVertexInput::Demarshall(char** pmarshalled_dataset){
+/*FUNCTION PentaP1Input::Demarshall{{{1*/
+void  PentaP1Input::Demarshall(char** pmarshalled_dataset){
 
         char* marshalled_dataset=NULL;
@@ -121 +121 @@
 /*}}}*/
 #endif
-/*FUNCTION PentaVertexInput::ObjectEnum{{{1*/
-int PentaVertexInput::ObjectEnum(void){
-
-        return PentaVertexInputEnum;
+/*FUNCTION PentaP1Input::ObjectEnum{{{1*/
+int PentaP1Input::ObjectEnum(void){
+
+        return PentaP1InputEnum;
 
 }
 /*}}}*/
         
-/*PentaVertexInput management*/
-/*FUNCTION PentaVertexInput::copy{{{1*/
-Object* PentaVertexInput::copy() {
+/*PentaP1Input management*/
+/*FUNCTION PentaP1Input::copy{{{1*/
+Object* PentaP1Input::copy() {
         
-        return new PentaVertexInput(this->enum_type,this->values);
-
-}
-/*}}}*/
-/*FUNCTION PentaVertexInput::InstanceEnum{{{1*/
-int PentaVertexInput::InstanceEnum(void){
+        return new PentaP1Input(this->enum_type,this->values);
+
+}
+/*}}}*/
+/*FUNCTION PentaP1Input::InstanceEnum{{{1*/
+int PentaP1Input::InstanceEnum(void){
 
         return this->enum_type;
@@ -144 +144 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::SpawnTriaInput{{{1*/
-Input* PentaVertexInput::SpawnTriaInput(int* indices){
+/*FUNCTION PentaP1Input::SpawnTriaInput{{{1*/
+Input* PentaP1Input::SpawnTriaInput(int* indices){
 
         /*output*/
-        TriaVertexInput* outinput=NULL;
+        TriaP1Input* outinput=NULL;
         double newvalues[3];
 
@@ -162 +162 @@
 
         /*Create new Tria input*/
-        outinput=new TriaVertexInput(this->enum_type,&newvalues[0]);
+        outinput=new TriaP1Input(this->enum_type,&newvalues[0]);
 
         /*Assign output*/
@@ -169 +169 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::SpawnResult{{{1*/
-ElementResult* PentaVertexInput::SpawnResult(int step, double time){
+/*FUNCTION PentaP1Input::SpawnResult{{{1*/
+ElementResult* PentaP1Input::SpawnResult(int step, double time){
 
         return new PentaVertexElementResult(this->enum_type,this->values,step,time);
@@ -178 +178 @@
 
 /*Object functions*/
-/*FUNCTION PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
-void PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
+void PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){
 
         /*Call PentaRef function*/
@@ -186 +186 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
-void PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* 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*/
@@ -193 +193 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVxStrainRate3d{{{1*/
-void PentaVertexInput::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetVxStrainRate3d{{{1*/
+void PentaP1Input::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
         int i,j;
 
@@ -238 +238 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVyStrainRate3d{{{1*/
-void PentaVertexInput::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetVyStrainRate3d{{{1*/
+void PentaP1Input::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
         int i,j;
 
@@ -283 +283 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVzStrainRate3d{{{1*/
-void PentaVertexInput::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetVzStrainRate3d{{{1*/
+void PentaP1Input::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){
         int i,j;
 
@@ -329 +329 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVxStrainRate3dPattyn{{{1*/
-void PentaVertexInput::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetVxStrainRate3dPattyn{{{1*/
+void PentaP1Input::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
 
         int i;
@@ -353 +353 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVyStrainRate3dPattyn{{{1*/
-void PentaVertexInput::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
+/*FUNCTION PentaP1Input::GetVyStrainRate3dPattyn{{{1*/
+void PentaP1Input::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
 
         int i;
@@ -377 +377 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::ChangeEnum{{{1*/
-void PentaVertexInput::ChangeEnum(int newenumtype){
+/*FUNCTION PentaP1Input::ChangeEnum{{{1*/
+void PentaP1Input::ChangeEnum(int newenumtype){
         this->enum_type=newenumtype;
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetInputAverage{{{1*/
-void PentaVertexInput::GetInputAverage(double* pvalue){
+/*FUNCTION PentaP1Input::GetInputAverage{{{1*/
+void PentaP1Input::GetInputAverage(double* pvalue){
         *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]);
 }
@@ -389 +389 @@
 
 /*Intermediary*/
-/*FUNCTION PentaVertexInput::SquareMin{{{1*/
-void PentaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
+/*FUNCTION PentaP1Input::SquareMin{{{1*/
+void PentaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
 
         int i;
@@ -412 +412 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::ConstrainMin{{{1*/
-void PentaVertexInput::ConstrainMin(double minimum){
+/*FUNCTION PentaP1Input::ConstrainMin{{{1*/
+void PentaP1Input::ConstrainMin(double minimum){
         
         int i;
@@ -421 +421 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::InfinityNorm{{{1*/
-double PentaVertexInput::InfinityNorm(void){
+/*FUNCTION PentaP1Input::InfinityNorm{{{1*/
+double PentaP1Input::InfinityNorm(void){
 
         /*Output*/
@@ -432 +432 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Max{{{1*/
-double PentaVertexInput::Max(void){
+/*FUNCTION PentaP1Input::Max{{{1*/
+double PentaP1Input::Max(void){
 
         const int numnodes=6;
@@ -444 +444 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::MaxAbs{{{1*/
-double PentaVertexInput::MaxAbs(void){
+/*FUNCTION PentaP1Input::MaxAbs{{{1*/
+double PentaP1Input::MaxAbs(void){
 
         const int numnodes=6;
@@ -456 +456 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Min{{{1*/
-double PentaVertexInput::Min(void){
+/*FUNCTION PentaP1Input::Min{{{1*/
+double PentaP1Input::Min(void){
 
         const int numnodes=6;
@@ -468 +468 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::MinAbs{{{1*/
-double PentaVertexInput::MinAbs(void){
+/*FUNCTION PentaP1Input::MinAbs{{{1*/
+double PentaP1Input::MinAbs(void){
 
         const int numnodes=6;
@@ -480 +480 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Scale{{{1*/
-void PentaVertexInput::Scale(double scale_factor){
+/*FUNCTION PentaP1Input::Scale{{{1*/
+void PentaP1Input::Scale(double scale_factor){
         
         int i;
@@ -489 +489 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::AXPY{{{1*/
-void PentaVertexInput::AXPY(Input* xinput,double scalar){
+/*FUNCTION PentaP1Input::AXPY{{{1*/
+void PentaP1Input::AXPY(Input* xinput,double scalar){
 
         int i;
@@ -500 +500 @@
         switch(xinput->ObjectEnum()){
 
-                case PentaVertexInputEnum:{
-                        PentaVertexInput* cast_input=(PentaVertexInput*)xinput;
+                case PentaP1InputEnum:{
+                        PentaP1Input* cast_input=(PentaP1Input*)xinput;
                         for(i=0;i<numnodes;i++)this->values[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;
+                        if(cont_input->values->ObjectEnum()!=PentaP1InputEnum) _error_("not supported yet");
+                        PentaP1Input* cast_input=(PentaP1Input*)cont_input->values;
                         for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
                         return;
@@ -516 +516 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Constrain{{{1*/
-void PentaVertexInput::Constrain(double cm_min, double cm_max){
+/*FUNCTION PentaP1Input::Constrain{{{1*/
+void PentaP1Input::Constrain(double cm_min, double cm_max){
 
         int i;
@@ -527 +527 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Extrude{{{1*/
-void PentaVertexInput::Extrude(void){
+/*FUNCTION PentaP1Input::Extrude{{{1*/
+void PentaP1Input::Extrude(void){
 
         int i;
@@ -536 +536 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::VerticallyIntegrate{{{1*/
-void PentaVertexInput::VerticallyIntegrate(Input* thickness_input){
+/*FUNCTION PentaP1Input::VerticallyIntegrate{{{1*/
+void PentaP1Input::VerticallyIntegrate(Input* thickness_input){
 
         /*Intermediaries*/
@@ -554 +554 @@
         switch(thickness_input->ObjectEnum()){
 
-                case PentaVertexInputEnum:
+                case PentaP1InputEnum:
                         for(i=0;i<3;i++){
                                 this->values[i]=0.5*(this->values[i]+this->values[i+3]) * thickness_values[i];
@@ -566 +566 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::PointwiseDivide{{{1*/
-Input* PentaVertexInput::PointwiseDivide(Input* inputB){
+/*FUNCTION PentaP1Input::PointwiseDivide{{{1*/
+Input* PentaP1Input::PointwiseDivide(Input* inputB){
 
         /*Ouput*/
-        PentaVertexInput* outinput=NULL;
+        PentaP1Input* outinput=NULL;
 
         /*Intermediaries*/
         int               i;
-        PentaVertexInput *xinputB     = NULL;
+        PentaP1Input *xinputB     = NULL;
         int               B_numvalues;
         const int         numnodes    = 6;
@@ -580 +580 @@
 
         /*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;
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
+        xinputB=(PentaP1Input*)inputB;
 
         /*Create point wise sum*/
@@ -590 +590 @@
 
         /*Create new Penta vertex input (copy of current input)*/
-        outinput=new PentaVertexInput(this->enum_type,&AdotBvalues[0]);
+        outinput=new PentaP1Input(this->enum_type,&AdotBvalues[0]);
 
         /*Return output pointer*/
@@ -597 +597 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::PointwiseMin{{{1*/
-Input* PentaVertexInput::PointwiseMin(Input* inputB){
+/*FUNCTION PentaP1Input::PointwiseMin{{{1*/
+Input* PentaP1Input::PointwiseMin(Input* inputB){
 
         /*Ouput*/
-        PentaVertexInput* outinput=NULL;
+        PentaP1Input* outinput=NULL;
 
         /*Intermediaries*/
         int               i;
-        PentaVertexInput *xinputB     = NULL;
+        PentaP1Input *xinputB     = NULL;
         int               B_numvalues;
         const int         numnodes    = 6;
@@ -611 +611 @@
 
         /*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;
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
+        xinputB=(PentaP1Input*)inputB;
 
         /*Create point wise min*/
@@ -621 +621 @@
 
         /*Create new Penta vertex input (copy of current input)*/
-        outinput=new PentaVertexInput(this->enum_type,&minvalues[0]);
+        outinput=new PentaP1Input(this->enum_type,&minvalues[0]);
 
         /*Return output pointer*/
@@ -628 +628 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::PointwiseMax{{{1*/
-Input* PentaVertexInput::PointwiseMax(Input* inputB){
+/*FUNCTION PentaP1Input::PointwiseMax{{{1*/
+Input* PentaP1Input::PointwiseMax(Input* inputB){
 
         /*Ouput*/
-        PentaVertexInput* outinput=NULL;
+        PentaP1Input* outinput=NULL;
 
         /*Intermediaries*/
         int               i;
-        PentaVertexInput *xinputB     = NULL;
+        PentaP1Input *xinputB     = NULL;
         int               B_numvalues;
         const int         numnodes    = 6;
@@ -642 +642 @@
 
         /*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;
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
+        xinputB=(PentaP1Input*)inputB;
 
         /*Create point wise max*/
@@ -652 +652 @@
 
         /*Create new Penta vertex input (copy of current input)*/
-        outinput=new PentaVertexInput(this->enum_type,&maxvalues[0]);
+        outinput=new PentaP1Input(this->enum_type,&maxvalues[0]);
 
         /*Return output pointer*/
@@ -659 +659 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::GetVectorFromInputs{{{1*/
-void PentaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
+/*FUNCTION PentaP1Input::GetVectorFromInputs{{{1*/
+void PentaP1Input::GetVectorFromInputs(Vec vector,int* doflist){
 
         const int numvertices=6;
@@ -666 +666 @@
 
 } /*}}}*/
-/*FUNCTION PentaVertexInput::GetValuesPtr{{{1*/
-void PentaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
+/*FUNCTION PentaP1Input::GetValuesPtr{{{1*/
+void PentaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){
 
         *pvalues=this->values;
@@ -674 +674 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::Configure{{{1*/
-void PentaVertexInput::Configure(Parameters* parameters){
+/*FUNCTION PentaP1Input::Configure{{{1*/
+void PentaP1Input::Configure(Parameters* parameters){
         /*do nothing: */
 }

issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h

@@ -1 @@
-/*! \file PentaVertexInput.h 
+/*! \file PentaP1Input.h 
  *  \brief: header file for triavertexinput object
  */
@@ -14 +14 @@
 /*}}}*/
 
-class PentaVertexInput: public Input, public PentaRef{
+class PentaP1Input: public Input, public PentaRef{
 
         public:
@@ -21 +21 @@
                 double values[6];
 
-                /*PentaVertexInput constructors, destructors: {{{1*/
-                PentaVertexInput();
-                PentaVertexInput(int enum_type,double* values);
-                ~PentaVertexInput();
+                /*PentaP1Input constructors, destructors: {{{1*/
+                PentaP1Input();
+                PentaP1Input(int enum_type,double* values);
+                ~PentaP1Input();
                 /*}}}*/
                 /*Object virtual functions definitions:{{{1 */
@@ -39 +39 @@
                 Object* copy();
                 /*}}}*/
-                /*PentaVertexInput management: {{{1*/
+                /*PentaP1Input management: {{{1*/
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int* indices);

issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp

@@ -1 @@
-/*!\file TriaVertexInput.c
- * \brief: implementation of the TriaVertexInput object
+/*!\file TriaP1Input.c
+ * \brief: implementation of the TriaP1Input object
  */
 
@@ -17 +17 @@
 #include "../../include/include.h"
 
-/*TriaVertexInput constructors and destructor*/
-/*FUNCTION TriaVertexInput::TriaVertexInput(){{{1*/
-TriaVertexInput::TriaVertexInput(){
+/*TriaP1Input constructors and destructor*/
+/*FUNCTION TriaP1Input::TriaP1Input(){{{1*/
+TriaP1Input::TriaP1Input(){
         return;
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::TriaVertexInput(int in_enum_type,double* values){{{1*/
-TriaVertexInput::TriaVertexInput(int in_enum_type,double* in_values)
+/*FUNCTION TriaP1Input::TriaP1Input(int in_enum_type,double* values){{{1*/
+TriaP1Input::TriaP1Input(int in_enum_type,double* in_values)
         :TriaRef(1)
 {
@@ -41 +41 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::~TriaVertexInput(){{{1*/
-TriaVertexInput::~TriaVertexInput(){
+/*FUNCTION TriaP1Input::~TriaP1Input(){{{1*/
+TriaP1Input::~TriaP1Input(){
         return;
 }
@@ -48 +48 @@
 
 /*Object virtual functions definitions:*/
-/*FUNCTION TriaVertexInput::Echo {{{1*/
-void TriaVertexInput::Echo(void){
+/*FUNCTION TriaP1Input::Echo {{{1*/
+void TriaP1Input::Echo(void){
         this->DeepEcho();
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::DeepEcho{{{1*/
-void TriaVertexInput::DeepEcho(void){
-
-        printf("TriaVertexInput:\n");
+/*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 TriaVertexInput::Id{{{1*/
-int    TriaVertexInput::Id(void){ return -1; }
-/*}}}*/
-/*FUNCTION TriaVertexInput::MyRank{{{1*/
-int    TriaVertexInput::MyRank(void){ 
+/*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; 
@@ -71 +71 @@
 /*}}}*/
 #ifdef _SERIAL_
-/*FUNCTION TriaVertexInput::Marshall{{{1*/
-void  TriaVertexInput::Marshall(char** pmarshalled_dataset){
+/*FUNCTION TriaP1Input::Marshall{{{1*/
+void  TriaP1Input::Marshall(char** pmarshalled_dataset){
 
         char* marshalled_dataset=NULL;
@@ -80 +80 @@
         marshalled_dataset=*pmarshalled_dataset;
 
-        /*get enum value of TriaVertexInput: */
-        enum_value=TriaVertexInputEnum;
+        /*get enum value of TriaP1Input: */
+        enum_value=TriaP1InputEnum;
         
         /*marshall enum: */
         memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
         
-        /*marshall TriaVertexInput data: */
+        /*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);
@@ -93 +93 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::MarshallSize{{{1*/
-int   TriaVertexInput::MarshallSize(){
+/*FUNCTION TriaP1Input::MarshallSize{{{1*/
+int   TriaP1Input::MarshallSize(){
         
         return sizeof(values)+
@@ -101 +101 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Demarshall{{{1*/
-void  TriaVertexInput::Demarshall(char** pmarshalled_dataset){
+/*FUNCTION TriaP1Input::Demarshall{{{1*/
+void  TriaP1Input::Demarshall(char** pmarshalled_dataset){
 
         char* marshalled_dataset=NULL;
@@ -121 +121 @@
 /*}}}*/
 #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){
+/*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;
@@ -144 +144 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::SpawnTriaInput{{{1*/
-Input* TriaVertexInput::SpawnTriaInput(int* indices){
+/*FUNCTION TriaP1Input::SpawnTriaInput{{{1*/
+Input* TriaP1Input::SpawnTriaInput(int* indices){
 
         /*output*/
-        TriaVertexInput* outinput=NULL;
+        TriaP1Input* outinput=NULL;
 
         /*Create new Tria input (copy of current input)*/
-        outinput=new TriaVertexInput(this->enum_type,&this->values[0]);
+        outinput=new TriaP1Input(this->enum_type,&this->values[0]);
 
         /*Assign output*/
@@ -158 +158 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::SpawnResult{{{1*/
-ElementResult* TriaVertexInput::SpawnResult(int step, double time){
+/*FUNCTION TriaP1Input::SpawnResult{{{1*/
+ElementResult* TriaP1Input::SpawnResult(int step, double time){
 
         return new TriaVertexElementResult(this->enum_type,this->values,step,time);
@@ -167 +167 @@
 
 /*Object functions*/
-/*FUNCTION TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
-void TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){
+/*FUNCTION TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
+void TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){
 
         /*Call TriaRef function*/
@@ -175 +175 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
-void TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* 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*/
@@ -182 +182 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::GetVxStrainRate2d{{{1*/
-void TriaVertexInput::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){
+/*FUNCTION TriaP1Input::GetVxStrainRate2d{{{1*/
+void TriaP1Input::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){
 
         /*Intermediary*/
@@ -205 +205 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::GetVyStrainRate2d{{{1*/
-void TriaVertexInput::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){
+/*FUNCTION TriaP1Input::GetVyStrainRate2d{{{1*/
+void TriaP1Input::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){
 
         /*Intermediary*/
@@ -228 +228 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::ChangeEnum{{{1*/
-void TriaVertexInput::ChangeEnum(int newenumtype){
+/*FUNCTION TriaP1Input::ChangeEnum{{{1*/
+void TriaP1Input::ChangeEnum(int newenumtype){
         this->enum_type=newenumtype;
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::GetInputAverage{{{1*/
-void TriaVertexInput::GetInputAverage(double* pvalue){
+/*FUNCTION TriaP1Input::GetInputAverage{{{1*/
+void TriaP1Input::GetInputAverage(double* pvalue){
         *pvalue=1./3.*(values[0]+values[1]+values[2]);
 }
@@ -240 +240 @@
 
 /*Intermediary*/
-/*FUNCTION TriaVertexInput::SquareMin{{{1*/
-void TriaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
+/*FUNCTION TriaP1Input::SquareMin{{{1*/
+void TriaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
 
         int i;
@@ -263 +263 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::ContrainMin{{{1*/
-void TriaVertexInput::ConstrainMin(double minimum){
+/*FUNCTION TriaP1Input::ContrainMin{{{1*/
+void TriaP1Input::ConstrainMin(double minimum){
         
         int i;
@@ -272 +272 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::InfinityNorm{{{1*/
-double TriaVertexInput::InfinityNorm(void){
+/*FUNCTION TriaP1Input::InfinityNorm{{{1*/
+double TriaP1Input::InfinityNorm(void){
 
         /*Output*/
@@ -283 +283 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Max{{{1*/
-double TriaVertexInput::Max(void){
+/*FUNCTION TriaP1Input::Max{{{1*/
+double TriaP1Input::Max(void){
 
         const int numnodes=3;
@@ -295 +295 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::MaxAbs{{{1*/
-double TriaVertexInput::MaxAbs(void){
+/*FUNCTION TriaP1Input::MaxAbs{{{1*/
+double TriaP1Input::MaxAbs(void){
 
         const int numnodes=3;
@@ -307 +307 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Min{{{1*/
-double TriaVertexInput::Min(void){
+/*FUNCTION TriaP1Input::Min{{{1*/
+double TriaP1Input::Min(void){
 
         const int numnodes=3;
@@ -319 +319 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::MinAbs{{{1*/
-double TriaVertexInput::MinAbs(void){
+/*FUNCTION TriaP1Input::MinAbs{{{1*/
+double TriaP1Input::MinAbs(void){
 
         const int numnodes=3;
@@ -331 +331 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Scale{{{1*/
-void TriaVertexInput::Scale(double scale_factor){
+/*FUNCTION TriaP1Input::Scale{{{1*/
+void TriaP1Input::Scale(double scale_factor){
         
         int i;
@@ -340 +340 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::ArtificialNoise{{{1*/
-void TriaVertexInput::ArtificialNoise(double min,double max){
+/*FUNCTION TriaP1Input::ArtificialNoise{{{1*/
+void TriaP1Input::ArtificialNoise(double min,double max){
 
         int i;
@@ -356 +356 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::AXPY{{{1*/
-void TriaVertexInput::AXPY(Input* xinput,double scalar){
-
-        int i;
-        const int numnodes=3;
-        TriaVertexInput*  xtriavertexinput=NULL;
+/*FUNCTION TriaP1Input::AXPY{{{1*/
+void TriaP1Input::AXPY(Input* xinput,double scalar){
+
+        int i;
+        const int numnodes=3;
+        TriaP1Input*  xtriavertexinput=NULL;
 
         /*xinput is of the same type, so cast it: */
-        xtriavertexinput=(TriaVertexInput*)xinput;
+        xtriavertexinput=(TriaP1Input*)xinput;
 
         /*Carry out the AXPY operation depending on type:*/
         switch(xinput->ObjectEnum()){
 
-                case TriaVertexInputEnum :
+                case TriaP1InputEnum :
                         for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*xtriavertexinput->values[i];
                         return;
@@ -379 +379 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Constrain{{{1*/
-void TriaVertexInput::Constrain(double cm_min, double cm_max){
+/*FUNCTION TriaP1Input::Constrain{{{1*/
+void TriaP1Input::Constrain(double cm_min, double cm_max){
 
         int i;
@@ -390 +390 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::GetVectorFromInputs{{{1*/
-void TriaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
+/*FUNCTION TriaP1Input::GetVectorFromInputs{{{1*/
+void TriaP1Input::GetVectorFromInputs(Vec vector,int* doflist){
 
         const int numvertices=3;
@@ -397 +397 @@
 
 } /*}}}*/
-/*FUNCTION TriaVertexInput::GetValuesPtr{{{1*/
-void TriaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
+/*FUNCTION TriaP1Input::GetValuesPtr{{{1*/
+void TriaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){
 
         *pvalues=this->values;
@@ -405 +405 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::PointwiseMin{{{1*/
-Input* TriaVertexInput::PointwiseMin(Input* inputB){
+/*FUNCTION TriaP1Input::PointwiseMin{{{1*/
+Input* TriaP1Input::PointwiseMin(Input* inputB){
 
         /*Ouput*/
-        TriaVertexInput* outinput=NULL;
+        TriaP1Input* outinput=NULL;
 
         /*Intermediaries*/
         int               i;
-        TriaVertexInput *xinputB     = NULL;
+        TriaP1Input *xinputB     = NULL;
         int               B_numvalues;
         const int         numnodes    = 3;
@@ -419 +419 @@
 
         /*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;
+        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
+        xinputB=(TriaP1Input*)inputB;
 
         /*Create point wise min*/
@@ -429 +429 @@
 
         /*Create new Tria vertex input (copy of current input)*/
-        outinput=new TriaVertexInput(this->enum_type,&minvalues[0]);
+        outinput=new TriaP1Input(this->enum_type,&minvalues[0]);
 
         /*Return output pointer*/
@@ -436 +436 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::PointwiseMax{{{1*/
-Input* TriaVertexInput::PointwiseMax(Input* inputB){
+/*FUNCTION TriaP1Input::PointwiseMax{{{1*/
+Input* TriaP1Input::PointwiseMax(Input* inputB){
 
         /*Ouput*/
-        TriaVertexInput* outinput=NULL;
+        TriaP1Input* outinput=NULL;
 
         /*Intermediaries*/
         int               i;
-        TriaVertexInput *xinputB     = NULL;
+        TriaP1Input *xinputB     = NULL;
         int               B_numvalues;
         const int         numnodes    = 3;
@@ -450 +450 @@
 
         /*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;
+        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
+        xinputB=(TriaP1Input*)inputB;
 
         /*Create point wise max*/
@@ -460 +460 @@
 
         /*Create new Tria vertex input (copy of current input)*/
-        outinput=new TriaVertexInput(this->enum_type,&maxvalues[0]);
+        outinput=new TriaP1Input(this->enum_type,&maxvalues[0]);
 
         /*Return output pointer*/
@@ -467 +467 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::Configure{{{1*/
-void TriaVertexInput::Configure(Parameters* parameters){
+/*FUNCTION TriaP1Input::Configure{{{1*/
+void TriaP1Input::Configure(Parameters* parameters){
         /*do nothing: */
 }

issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h

@@ -1 @@
-/*! \file TriaVertexInput.h 
- *  \brief: header file for triavertexinput object
+/*! \file TriaP1Input.h 
+ *  \brief: header file for TriaP1Input object
  */
 
 
-#ifndef _TRIAVERTEXINPUT_H_
-#define _TRIAVERTEXINPUT_H_
+#ifndef _TRIAP1INPUT_H_
+#define _TRIAP1INPUT_H_
 
 /*Headers:*/
@@ -14 +14 @@
 /*}}}*/
 
-class TriaVertexInput: public Input,public TriaRef{
+class TriaP1Input: public Input,public TriaRef{
 
         public:
@@ -21 +21 @@
                 double values[3];
 
-                /*TriaVertexInput constructors, destructors: {{{1*/
-                TriaVertexInput();
-                TriaVertexInput(int enum_type,double* values);
-                ~TriaVertexInput();
+                /*TriaP1Input constructors, destructors: {{{1*/
+                TriaP1Input();
+                TriaP1Input(int enum_type,double* values);
+                ~TriaP1Input();
                 /*}}}*/
                 /*Object virtual functions definitions:{{{1 */
@@ -39 +39 @@
                 Object* copy();
                 /*}}}*/
-                /*TriaVertexInput management: {{{1*/
+                /*TriaP1Input management: {{{1*/
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
@@ -87 +87 @@
 
 };
-#endif  /* _TRIAVERTEXINPUT_H */
+#endif  /* _TRIAP1INPUT_H */

issm/trunk-jpl/src/c/objects/Materials/Matice.cpp

@@ -552 +552 @@
                                         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 +594 @@
                                         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 +607 @@
                                                 if(dim==2){
                                                         /*Dupliacte rheology input: */
-                                                        this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,values));
+                                                        this->inputs->AddInput(new TriaP1Input(MaterialsRheologyBbarEnum,values));
                                                 }
                                         }
@@ -683 +683 @@
                 if (iomodel->Data(MaterialsRheologyBEnum)) {
                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(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 +689 @@
                 if (iomodel->Data(MaterialsRheologyNEnum)) {
                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
-                        this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyNEnum,nodeinputs));
+                        this->inputs->AddInput(new TriaP1Input(MaterialsRheologyNEnum,nodeinputs));
                 }
 
@@ -703 +703 @@
                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(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 +725 @@
                 if (iomodel->Data(MaterialsRheologyBEnum)) {
                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(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 +731 @@
                 if (iomodel->Data(MaterialsRheologyNEnum)) {
                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
-                        this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyNEnum,nodeinputs));
+                        this->inputs->AddInput(new PentaP1Input(MaterialsRheologyNEnum,nodeinputs));
                 }
 
@@ -745 +745 @@
                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(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;

issm/trunk-jpl/src/c/objects/objects.h

@@ -88 +88 @@
 #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"