Changeset 11291


Ignore:
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:
12 edited
4 moved

Legend:

Unmodified
Added
Removed
  • issm/trunk-jpl/src/c/Container/DataSet.cpp

    r10440 r11291  
    224224                                dataset->AddObject(tria);}
    225225                                break;
    226                         case TriaVertexInputEnum:{
    227                                 TriaVertexInput* triavertexinput=NULL;
    228                                 triavertexinput=new TriaVertexInput();
     226                        case TriaP1InputEnum:{
     227                                TriaP1Input* triavertexinput=NULL;
     228                                triavertexinput=new TriaP1Input();
    229229                                triavertexinput->Demarshall(&marshalled_dataset);
    230230                                dataset->AddObject(triavertexinput);}
    231231                                break;
    232232                        #ifdef _HAVE_THREED_
    233                         case PentaVertexInputEnum:{
    234                                 PentaVertexInput* pentavertexinput=NULL;
    235                                 pentavertexinput=new PentaVertexInput();
     233                        case PentaP1InputEnum:{
     234                                PentaP1Input* pentavertexinput=NULL;
     235                                pentavertexinput=new PentaP1Input();
    236236                                pentavertexinput->Demarshall(&marshalled_dataset);
    237237                                dataset->AddObject(pentavertexinput);}
  • issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h

    r11275 r11291  
    261261        PenpairEnum,
    262262        PentaEnum,
    263         PentaVertexInputEnum,
     263        PentaP1InputEnum,
    264264        PetscMatParamEnum,
    265265        PetscVecParamEnum,
     
    274274        StringParamEnum,
    275275        TriaEnum,
    276         TriaVertexInputEnum,
     276        TriaP1InputEnum,
    277277        VertexEnum,
    278278        /*}}}*/
  • issm/trunk-jpl/src/c/Makefile.am

    r11287 r11291  
    8888                                        ./objects/Inputs/Input.h\
    8989                                        ./objects/Inputs/InputLocal.h\
    90                                         ./objects/Inputs/TriaVertexInput.h\
    91                                         ./objects/Inputs/TriaVertexInput.cpp\
     90                                        ./objects/Inputs/TriaP1Input.h\
     91                                        ./objects/Inputs/TriaP1Input.cpp\
    9292                                        ./objects/Inputs/BoolInput.h\
    9393                                        ./objects/Inputs/BoolInput.cpp\
     
    561561                                     ./objects/ElementResults/PentaVertexElementResult.h\
    562562                                     ./objects/ElementResults/PentaVertexElementResult.cpp\
    563                                      ./objects/Inputs/PentaVertexInput.h\
    564                                      ./objects/Inputs/PentaVertexInput.cpp\
     563                                     ./objects/Inputs/PentaP1Input.h\
     564                                     ./objects/Inputs/PentaP1Input.cpp\
    565565                                     ./objects/Elements/Penta.h\
    566566                                     ./objects/Elements/Penta.cpp\
  • issm/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp

    r11275 r11291  
    257257                case PenpairEnum : return "Penpair";
    258258                case PentaEnum : return "Penta";
    259                 case PentaVertexInputEnum : return "PentaVertexInput";
     259                case PentaP1InputEnum : return "PentaP1Input";
    260260                case PetscMatParamEnum : return "PetscMatParam";
    261261                case PetscVecParamEnum : return "PetscVecParam";
     
    270270                case StringParamEnum : return "StringParam";
    271271                case TriaEnum : return "Tria";
    272                 case TriaVertexInputEnum : return "TriaVertexInput";
     272                case TriaP1InputEnum : return "TriaP1Input";
    273273                case VertexEnum : return "Vertex";
    274274                case AirEnum : return "Air";
  • issm/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp

    r11275 r11291  
    255255        else if (strcmp(name,"Penpair")==0) return PenpairEnum;
    256256        else if (strcmp(name,"Penta")==0) return PentaEnum;
    257         else if (strcmp(name,"PentaVertexInput")==0) return PentaVertexInputEnum;
     257        else if (strcmp(name,"PentaP1Input")==0) return PentaP1InputEnum;
    258258        else if (strcmp(name,"PetscMatParam")==0) return PetscMatParamEnum;
    259259        else if (strcmp(name,"PetscVecParam")==0) return PetscVecParamEnum;
     
    268268        else if (strcmp(name,"StringParam")==0) return StringParamEnum;
    269269        else if (strcmp(name,"Tria")==0) return TriaEnum;
    270         else if (strcmp(name,"TriaVertexInput")==0) return TriaVertexInputEnum;
     270        else if (strcmp(name,"TriaP1Input")==0) return TriaP1InputEnum;
    271271        else if (strcmp(name,"Vertex")==0) return VertexEnum;
    272272        else if (strcmp(name,"Air")==0) return AirEnum;
  • issm/trunk-jpl/src/c/objects/ElementResults/PentaVertexElementResult.h

    r11001 r11291  
    11/*! \file PentaVertexElementResult.h
    22 *  \brief: header file for penta vertex result  object.
    3  *  this object is just a PentaVertexInput with additional time and step info.
     3 *  this object is just a PentaP1Input with additional time and step info.
    44 */
    55
  • issm/trunk-jpl/src/c/objects/Elements/Penta.cpp

    r11273 r11291  
    347347        if (!IsOnBed() || IsFloating()){
    348348                //empty friction:
    349                 this->inputs->AddInput(new PentaVertexInput(BasalFrictionEnum,&basalfriction[0]));
     349                this->inputs->AddInput(new PentaP1Input(BasalFrictionEnum,&basalfriction[0]));
    350350                return;
    351351        }
     
    375375       
    376376        /*Create PentaVertex input, which will hold the basal friction:*/
    377         this->inputs->AddInput(new PentaVertexInput(BasalFrictionEnum,&basalfriction[0]));
     377        this->inputs->AddInput(new PentaP1Input(BasalFrictionEnum,&basalfriction[0]));
    378378
    379379        /*Clean up and return*/
     
    523523       
    524524        /*Add Stress tensor components into inputs*/
    525         this->inputs->AddInput(new PentaVertexInput(StressTensorxxEnum,&sigma_xx[0]));
    526         this->inputs->AddInput(new PentaVertexInput(StressTensorxyEnum,&sigma_xy[0]));
    527         this->inputs->AddInput(new PentaVertexInput(StressTensorxzEnum,&sigma_xz[0]));
    528         this->inputs->AddInput(new PentaVertexInput(StressTensoryyEnum,&sigma_yy[0]));
    529         this->inputs->AddInput(new PentaVertexInput(StressTensoryzEnum,&sigma_yz[0]));
    530         this->inputs->AddInput(new PentaVertexInput(StressTensorzzEnum,&sigma_zz[0]));
     525        this->inputs->AddInput(new PentaP1Input(StressTensorxxEnum,&sigma_xx[0]));
     526        this->inputs->AddInput(new PentaP1Input(StressTensorxyEnum,&sigma_xy[0]));
     527        this->inputs->AddInput(new PentaP1Input(StressTensorxzEnum,&sigma_xz[0]));
     528        this->inputs->AddInput(new PentaP1Input(StressTensoryyEnum,&sigma_yy[0]));
     529        this->inputs->AddInput(new PentaP1Input(StressTensoryzEnum,&sigma_yz[0]));
     530        this->inputs->AddInput(new PentaP1Input(StressTensorzzEnum,&sigma_zz[0]));
    531531
    532532        /*Clean up and return*/
     
    13471347
    13481348                        /*create static input: */
    1349                         this->inputs->AddInput(new PentaVertexInput(vector_enum,nodeinputs));
     1349                        this->inputs->AddInput(new PentaP1Input(vector_enum,nodeinputs));
    13501350                }
    13511351                else if(M==numberofvertices+1){
     
    13661366
    13671367                                if(t==0)transientinput=new TransientInput(vector_enum);
    1368                                 transientinput->AddTimeInput(new PentaVertexInput(vector_enum,nodeinputs),time);
     1368                                transientinput->AddTimeInput(new PentaP1Input(vector_enum,nodeinputs),time);
    13691369                        }
    13701370                        this->inputs->AddInput(transientinput);
     
    14201420
    14211421        /*OK, we are on bed. Initialize global inputs as 0*/
    1422         total_thickness_input =new PentaVertexInput(ThicknessEnum,zeros_list);
     1422        total_thickness_input =new PentaP1Input(ThicknessEnum,zeros_list);
    14231423
    14241424        /*Now follow all the upper element from the base to the surface to integrate the input*/
     
    14381438                /*If first time, initialize total_integrated_input*/
    14391439                if (step==0){
    1440                         if (original_input->ObjectEnum()==PentaVertexInputEnum)
    1441                          total_integrated_input=new PentaVertexInput(average_enum_type,zeros_list);
     1440                        if (original_input->ObjectEnum()==PentaP1InputEnum)
     1441                         total_integrated_input=new PentaP1Input(average_enum_type,zeros_list);
    14421442                        else if (original_input->ObjectEnum()==ControlInputEnum)
    1443                          total_integrated_input=new PentaVertexInput(average_enum_type,zeros_list);
     1443                         total_integrated_input=new PentaP1Input(average_enum_type,zeros_list);
    14441444                        else if (original_input->ObjectEnum()==DoubleInputEnum)
    14451445                         total_integrated_input=new DoubleInput(average_enum_type,0.0);
     
    14541454                        Helem_list[i+3]=Helem_list[i];
    14551455                }
    1456                 element_thickness_input=new PentaVertexInput(ThicknessEnum,Helem_list);
     1456                element_thickness_input=new PentaP1Input(ThicknessEnum,Helem_list);
    14571457
    14581458                /*Step3: Vertically integrate A COPY of the original*/
     
    16811681                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    16821682                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    1683                                                 this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1683                                                this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    16841684                                        }
    16851685                                        break;
     
    16891689                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    16901690                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    1691                                                 this->inputs->AddInput(new ControlInput(VxEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1691                                                this->inputs->AddInput(new ControlInput(VxEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    16921692                                        }
    16931693                                        break;
     
    16971697                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    16981698                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    1699                                                 this->inputs->AddInput(new ControlInput(VyEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1699                                                this->inputs->AddInput(new ControlInput(VyEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    17001700                                        }
    17011701                                        break;
     
    17051705                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
    17061706                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
    1707                                                 this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1707                                                this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    17081708                                        }
    17091709                                        break;
     
    17551755                for(i=0;i<num_cm_responses;i++){
    17561756                        for(j=0;j<6;j++)nodeinputs[j]=iomodel->Data(InversionCostFunctionsCoefficientsEnum)[(penta_vertex_ids[j]-1)*num_cm_responses+i];
    1757                         datasetinput->inputs->AddObject(new PentaVertexInput(InversionCostFunctionsCoefficientsEnum,nodeinputs));
     1757                        datasetinput->inputs->AddObject(new PentaP1Input(InversionCostFunctionsCoefficientsEnum,nodeinputs));
    17581758                }
    17591759
     
    19001900        for(;;){
    19011901                /*Add input to the element: */
    1902                 penta->inputs->AddInput(new PentaVertexInput(ThicknessEnum,newthickness));
    1903                 penta->inputs->AddInput(new PentaVertexInput(SurfaceEnum,newsurface));
    1904                 penta->inputs->AddInput(new PentaVertexInput(BedEnum,newbed));
     1902                penta->inputs->AddInput(new PentaP1Input(ThicknessEnum,newthickness));
     1903                penta->inputs->AddInput(new PentaP1Input(SurfaceEnum,newsurface));
     1904                penta->inputs->AddInput(new PentaP1Input(BedEnum,newbed));
    19051905
    19061906                /*Stop if we have reached the surface*/
     
    19331933
    19341934        /*Add input to the element: */
    1935         this->inputs->AddInput(new PentaVertexInput(enum_type,values));
     1935        this->inputs->AddInput(new PentaP1Input(enum_type,values));
    19361936       
    19371937        /*Free ressources:*/
     
    19661966        for(;;){
    19671967                /*Add input to the element: */
    1968                 penta->inputs->AddInput(new PentaVertexInput(enum_type,values));
     1968                penta->inputs->AddInput(new PentaP1Input(enum_type,values));
    19691969
    19701970                /*Stop if we have reached the surface*/
     
    20002000
    20012001                        /*update input*/
    2002                         this->inputs->AddInput(new PentaVertexInput(name,values));
     2002                        this->inputs->AddInput(new PentaP1Input(name,values));
    20032003                        return;
    20042004
     
    22412241        if(!this->IsFloating() && elementonshelf==true){
    22422242                for(i=0;i<NUMVERTICES;i++)melting[i]=gl_melting_rate/yts;
    2243                 this->inputs->AddInput(new PentaVertexInput(BasalforcingsMeltingRateEnum,&melting[0]));
     2243                this->inputs->AddInput(new PentaP1Input(BasalforcingsMeltingRateEnum,&melting[0]));
    22442244        }
    22452245
    22462246        /*Update inputs*/
    2247         this->inputs->AddInput(new PentaVertexInput(SurfaceEnum,&s[0]));
    2248         this->inputs->AddInput(new PentaVertexInput(BedEnum,&b[0]));
     2247        this->inputs->AddInput(new PentaP1Input(SurfaceEnum,&s[0]));
     2248        this->inputs->AddInput(new PentaP1Input(BedEnum,&b[0]));
    22492249   this->inputs->AddInput(new BoolInput(MaskElementonfloatingiceEnum,elementonshelf));
    22502250
     
    27682768                        if(!iomodel->Data(VxEnum)){
    27692769                                for(i=0;i<6;i++)nodeinputs[i]=0;
    2770                                 this->inputs->AddInput(new PentaVertexInput(VxEnum,nodeinputs));
    2771                                 if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVxEnum,nodeinputs));
     2770                                this->inputs->AddInput(new PentaP1Input(VxEnum,nodeinputs));
     2771                                if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVxEnum,nodeinputs));
    27722772                        }
    27732773                        if(!iomodel->Data(VyEnum)){
    27742774                                for(i=0;i<6;i++)nodeinputs[i]=0;
    2775                                 this->inputs->AddInput(new PentaVertexInput(VyEnum,nodeinputs));
    2776                                 if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVyEnum,nodeinputs));
     2775                                this->inputs->AddInput(new PentaP1Input(VyEnum,nodeinputs));
     2776                                if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVyEnum,nodeinputs));
    27772777                        }
    27782778                        if(!iomodel->Data(VzEnum)){
    27792779                                for(i=0;i<6;i++)nodeinputs[i]=0;
    2780                                 this->inputs->AddInput(new PentaVertexInput(VzEnum,nodeinputs));
    2781                                 if(dakota_analysis) this->inputs->AddInput(new PentaVertexInput(QmuVzEnum,nodeinputs));
     2780                                this->inputs->AddInput(new PentaP1Input(VzEnum,nodeinputs));
     2781                                if(dakota_analysis) this->inputs->AddInput(new PentaP1Input(QmuVzEnum,nodeinputs));
    27822782                        }
    27832783                        if(!iomodel->Data(PressureEnum)){
    27842784                                for(i=0;i<6;i++)nodeinputs[i]=0;
    27852785                                if(dakota_analysis){
    2786                                         this->inputs->AddInput(new PentaVertexInput(PressureEnum,nodeinputs));
    2787                                         this->inputs->AddInput(new PentaVertexInput(QmuPressureEnum,nodeinputs));
     2786                                        this->inputs->AddInput(new PentaP1Input(PressureEnum,nodeinputs));
     2787                                        this->inputs->AddInput(new PentaP1Input(QmuPressureEnum,nodeinputs));
    27882788                                }
    27892789                                if(isstokes){
    2790                                         this->inputs->AddInput(new PentaVertexInput(PressureEnum,nodeinputs));
    2791                                         this->inputs->AddInput(new PentaVertexInput(PressurePicardEnum,nodeinputs));
     2790                                        this->inputs->AddInput(new PentaP1Input(PressureEnum,nodeinputs));
     2791                                        this->inputs->AddInput(new PentaP1Input(PressurePicardEnum,nodeinputs));
    27922792                                }
    27932793                        }
     
    27962796                                if(iomodel->Data(VzEnum) && iomodel->Data(FlowequationBorderstokesEnum)){
    27972797                                        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];
    2798                                         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs));
     2798                                        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs));
    27992799                                        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]);
    2800                                         this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,nodeinputs));
     2800                                        this->inputs->AddInput(new PentaP1Input(VzPattynEnum,nodeinputs));
    28012801                                }
    28022802                                else{
    28032803                                        for(i=0;i<6;i++)nodeinputs[i]=0;
    2804                                         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs));
    2805                                         this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,nodeinputs));
     2804                                        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs));
     2805                                        this->inputs->AddInput(new PentaP1Input(VzPattynEnum,nodeinputs));
    28062806                                }
    28072807                        }
     
    28102810                                if(iomodel->Data(VzEnum) && iomodel->Data(FlowequationBorderstokesEnum)){
    28112811                                        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];
    2812                                         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs));
     2812                                        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs));
    28132813                                        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]);
    2814                                         this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,nodeinputs));
     2814                                        this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,nodeinputs));
    28152815                                }
    28162816                                else{
    28172817                                        for(i=0;i<6;i++)nodeinputs[i]=0;
    2818                                         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,nodeinputs));
    2819                                         this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,nodeinputs));
     2818                                        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,nodeinputs));
     2819                                        this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,nodeinputs));
    28202820                                }
    28212821                        }
     
    28252825                        /*Initialize mesh velocity*/
    28262826                        for(i=0;i<6;i++)nodeinputs[i]=0;
    2827                         this->inputs->AddInput(new PentaVertexInput(VxMeshEnum,nodeinputs));
    2828                         this->inputs->AddInput(new PentaVertexInput(VyMeshEnum,nodeinputs));
    2829                         this->inputs->AddInput(new PentaVertexInput(VzMeshEnum,nodeinputs));
     2827                        this->inputs->AddInput(new PentaP1Input(VxMeshEnum,nodeinputs));
     2828                        this->inputs->AddInput(new PentaP1Input(VyMeshEnum,nodeinputs));
     2829                        this->inputs->AddInput(new PentaP1Input(VzMeshEnum,nodeinputs));
    28302830                        break;
    28312831
     
    28332833                        /*Initialize mesh velocity*/
    28342834                        for(i=0;i<6;i++)nodeinputs[i]=0;
    2835                         this->inputs->AddInput(new PentaVertexInput(VxMeshEnum,nodeinputs));
    2836                         this->inputs->AddInput(new PentaVertexInput(VyMeshEnum,nodeinputs));
    2837                         this->inputs->AddInput(new PentaVertexInput(VzMeshEnum,nodeinputs));
     2835                        this->inputs->AddInput(new PentaP1Input(VxMeshEnum,nodeinputs));
     2836                        this->inputs->AddInput(new PentaP1Input(VyMeshEnum,nodeinputs));
     2837                        this->inputs->AddInput(new PentaP1Input(VzMeshEnum,nodeinputs));
    28382838                        if (iomodel->Data(TemperatureEnum) && iomodel->Data(WaterfractionEnum) && iomodel->Data(PressureEnum)) {
    28392839                                for(i=0;i<6;i++){
     
    28452845                                                +latentheat*iomodel->Data(WaterfractionEnum)[penta_vertex_ids[i]-1];
    28462846                                }
    2847                                 this->inputs->AddInput(new PentaVertexInput(EnthalpyEnum,nodeinputs));
     2847                                this->inputs->AddInput(new PentaP1Input(EnthalpyEnum,nodeinputs));
    28482848                        }
    28492849                        else _error_("temperature and waterfraction required for the enthalpy solution");
     
    29182918
    29192919        /*Create PentaVertex input, which will hold the basal friction:*/
    2920         this->inputs->AddInput(new PentaVertexInput(ViscousHeatingEnum,&viscousheating[0]));
     2920        this->inputs->AddInput(new PentaP1Input(ViscousHeatingEnum,&viscousheating[0]));
    29212921
    29222922        /*Clean up and return*/
     
    41994199        this->inputs->GetInputValue(&converged,ConvergedEnum);
    42004200        if(converged){
    4201                 this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,values));
     4201                this->inputs->AddInput(new PentaP1Input(TemperatureEnum,values));
    42024202
    42034203                /*Update Rheology only if converged (we must make sure that the temperature is below melting point
     
    42114211                                B_average=Paterson((values[0]+values[1]+values[2]+values[3]+values[4]+values[5])/6.0);
    42124212                                for(i=0;i<numdof;i++) B[i]=B_average;
    4213                                 this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
     4213                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
    42144214                                break;
    42154215                        case ArrheniusEnum:
     
    42194219                                                        matice->GetN());
    42204220                                for(i=0;i<numdof;i++) B[i]=B_average;
    4221                                 this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
     4221                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
    42224222                                break;
    42234223                        default:
     
    42274227        }
    42284228        else{
    4229                 this->inputs->AddInput(new PentaVertexInput(TemperaturePicardEnum,values));
     4229                this->inputs->AddInput(new PentaP1Input(TemperaturePicardEnum,values));
    42304230        }
    42314231
     
    42724272                for(i=0;i<numdof;i++) matpar->EnthalpyToThermal(&temperatures[i],&waterfraction[i],values[i],pressure[i]);
    42734273                       
    4274                 this->inputs->AddInput(new PentaVertexInput(EnthalpyEnum,values));
    4275                 this->inputs->AddInput(new PentaVertexInput(WaterfractionEnum,waterfraction));
    4276                 this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,temperatures));
     4274                this->inputs->AddInput(new PentaP1Input(EnthalpyEnum,values));
     4275                this->inputs->AddInput(new PentaP1Input(WaterfractionEnum,waterfraction));
     4276                this->inputs->AddInput(new PentaP1Input(TemperatureEnum,temperatures));
    42774277
    42784278                /*Update Rheology only if converged (we must make sure that the temperature is below melting point
     
    42864286                                B_average=Paterson((temperatures[0]+temperatures[1]+temperatures[2]+temperatures[3]+temperatures[4]+temperatures[5])/6.0);
    42874287                                for(i=0;i<numdof;i++) B[i]=B_average;
    4288                                 this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
     4288                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
    42894289                                break;
    42904290                        case ArrheniusEnum:
     
    42944294                                                        matice->GetN());
    42954295                                for(i=0;i<numdof;i++) B[i]=B_average;
    4296                                 this->matice->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,B));
     4296                                this->matice->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,B));
    42974297                                break;
    42984298                        default:
     
    43024302//      }
    43034303//      else{
    4304 //              this->inputs->AddInput(new PentaVertexInput(EnthalpyPicardEnum,values));
     4304//              this->inputs->AddInput(new PentaP1Input(EnthalpyPicardEnum,values));
    43054305//      }
    43064306
     
    43674367        this->GetDofList1(&doflist1[0]);
    43684368        for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[doflist1[i]];
    4369         grad_input=new PentaVertexInput(GradientEnum,grad_list);
     4369        grad_input=new PentaP1Input(GradientEnum,grad_list);
    43704370        ((ControlInput*)input)->SetGradient(grad_input);
    43714371
     
    48234823
    48244824        /*Add vx and vy as inputs to the tria element: */
    4825         this->inputs->AddInput(new PentaVertexInput(AdjointxEnum,lambdax));
    4826         this->inputs->AddInput(new PentaVertexInput(AdjointyEnum,lambday));
    4827         this->inputs->AddInput(new PentaVertexInput(AdjointzEnum,lambdaz));
    4828         this->inputs->AddInput(new PentaVertexInput(AdjointpEnum,lambdap));
     4825        this->inputs->AddInput(new PentaP1Input(AdjointxEnum,lambdax));
     4826        this->inputs->AddInput(new PentaP1Input(AdjointyEnum,lambday));
     4827        this->inputs->AddInput(new PentaP1Input(AdjointzEnum,lambdaz));
     4828        this->inputs->AddInput(new PentaP1Input(AdjointpEnum,lambdap));
    48294829
    48304830        /*Free ressources:*/
     
    48604860
    48614861        /*Add vx and vy as inputs to the tria element: */
    4862         this->inputs->AddInput(new PentaVertexInput(AdjointxEnum,lambdax));
    4863         this->inputs->AddInput(new PentaVertexInput(AdjointyEnum,lambday));
     4862        this->inputs->AddInput(new PentaP1Input(AdjointxEnum,lambdax));
     4863        this->inputs->AddInput(new PentaP1Input(AdjointyEnum,lambday));
    48644864
    48654865        /*Free ressources:*/
     
    51255125                case VertexEnum:
    51265126
    5127                         /*New PentaVertexInput*/
     5127                        /*New PentaP1Input*/
    51285128                        double values[6];
    51295129
     
    51985198
    51995199                                        /*Add new inputs: */
    5200                                         this->inputs->AddInput(new PentaVertexInput(ThicknessEnum,thickness));
    5201                                         this->inputs->AddInput(new PentaVertexInput(BedEnum,bed));
    5202                                         this->inputs->AddInput(new PentaVertexInput(SurfaceEnum,surface));
     5200                                        this->inputs->AddInput(new PentaP1Input(ThicknessEnum,thickness));
     5201                                        this->inputs->AddInput(new PentaP1Input(BedEnum,bed));
     5202                                        this->inputs->AddInput(new PentaP1Input(SurfaceEnum,surface));
    52035203
    52045204                                        /*}}}*/
    52055205                                        break;
    52065206                                default:
    5207                                         this->inputs->AddInput(new PentaVertexInput(name,values));
     5207                                        this->inputs->AddInput(new PentaP1Input(name,values));
    52085208                        }
    52095209                        break;
     
    52585258
    52595259                                if(t==0) transientinput=new TransientInput(name);
    5260                                 transientinput->AddTimeInput(new PentaVertexInput(name,values),time);
     5260                                transientinput->AddTimeInput(new PentaP1Input(name,values),time);
    52615261                                transientinput->Configure(parameters);
    52625262                        }
     
    75697569
    75707570                /*Add vx and vy as inputs to the tria element: */
    7571                 penta->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7572                 penta->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7573                 penta->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7574                 penta->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7571                penta->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7572                penta->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7573                penta->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7574                penta->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    75757575
    75767576                /*Stop if we have reached the surface*/
     
    76597659
    76607660        /*Add vx and vy as inputs to the tria element: */
    7661         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7662         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7663         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7664         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7661        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7662        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7663        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7664        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    76657665
    76667666        /*Free ressources:*/
     
    77347734        Input* vzmacayeal_input=inputs->GetInput(VzMacAyealEnum);
    77357735        if (vzmacayeal_input){
    7736                 if (vzmacayeal_input->ObjectEnum()!=PentaVertexInputEnum){
     7736                if (vzmacayeal_input->ObjectEnum()!=PentaP1InputEnum){
    77377737                        _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToStringx(vzmacayeal_input->ObjectEnum()));
    77387738                }
     
    77577757
    77587758        /*Add vx and vy as inputs to the tria element: */
    7759         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7760         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7761         this->inputs->AddInput(new PentaVertexInput(VzEnum,vz));
    7762         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,vzstokes));
    7763         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7764         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7759        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7760        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7761        this->inputs->AddInput(new PentaP1Input(VzEnum,vz));
     7762        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,vzstokes));
     7763        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7764        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    77657765
    77667766        /*Free ressources:*/
     
    78347834
    78357835        /*Add vx and vy as inputs to the tria element: */
    7836         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7837         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7838         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7839         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7836        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7837        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7838        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7839        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    78407840
    78417841        /*Free ressources:*/
     
    79027902        Input* vzpattyn_input=inputs->GetInput(VzPattynEnum);
    79037903        if (vzpattyn_input){
    7904                 if (vzpattyn_input->ObjectEnum()!=PentaVertexInputEnum){
     7904                if (vzpattyn_input->ObjectEnum()!=PentaP1InputEnum){
    79057905                        _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToStringx(vzpattyn_input->ObjectEnum()));
    79067906                }
     
    79257925
    79267926        /*Add vx and vy as inputs to the tria element: */
    7927         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7928         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7929         this->inputs->AddInput(new PentaVertexInput(VzEnum,vz));
    7930         this->inputs->AddInput(new PentaVertexInput(VzStokesEnum,vzstokes));
    7931         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7932         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7927        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7928        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7929        this->inputs->AddInput(new PentaP1Input(VzEnum,vz));
     7930        this->inputs->AddInput(new PentaP1Input(VzStokesEnum,vzstokes));
     7931        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7932        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    79337933
    79347934        /*Free ressources:*/
     
    79917991
    79927992        /*Add vx and vy as inputs to the tria element: */
    7993         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    7994         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    7995         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    7996         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     7993        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     7994        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     7995        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     7996        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    79977997
    79987998        /*Free ressources:*/
     
    80498049                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    80508050                if (vzstokes_input){
    8051                         if (vzstokes_input->ObjectEnum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum()));
     8051                        if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum()));
    80528052                        GetInputListOnVertices(&vzstokes[0],VzStokesEnum);
    80538053                }
     
    80618061                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    80628062                if (vzstokes_input){
    8063                         if (vzstokes_input->ObjectEnum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum()));
     8063                        if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vzstokes_input->ObjectEnum()));
    80648064                        GetInputListOnVertices(&vzstokes[0],VzStokesEnum);
    80658065                }
     
    80898089        if(approximation!=PattynStokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum){
    80908090                this->inputs->ChangeEnum(PressureEnum,PressurePicardEnum);
    8091                 this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     8091                this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    80928092        }
    80938093        else if(approximation==PattynStokesApproximationEnum){
    8094                 this->inputs->AddInput(new PentaVertexInput(VzPattynEnum,vzpattyn));
     8094                this->inputs->AddInput(new PentaP1Input(VzPattynEnum,vzpattyn));
    80958095        }
    80968096        else if(approximation==MacAyealStokesApproximationEnum){
    8097                 this->inputs->AddInput(new PentaVertexInput(VzMacAyealEnum,vzmacayeal));
    8098         }
    8099         this->inputs->AddInput(new PentaVertexInput(VzEnum,vz));
    8100         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
     8097                this->inputs->AddInput(new PentaP1Input(VzMacAyealEnum,vzmacayeal));
     8098        }
     8099        this->inputs->AddInput(new PentaP1Input(VzEnum,vz));
     8100        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
    81018101
    81028102        /*Free ressources:*/
     
    81558155
    81568156        /*Add vx and vy as inputs to the tria element: */
    8157         this->inputs->AddInput(new PentaVertexInput(VxEnum,vx));
    8158         this->inputs->AddInput(new PentaVertexInput(VyEnum,vy));
    8159         this->inputs->AddInput(new PentaVertexInput(VzEnum,vz));
    8160         this->inputs->AddInput(new PentaVertexInput(VelEnum,vel));
    8161         this->inputs->AddInput(new PentaVertexInput(PressureEnum,pressure));
     8157        this->inputs->AddInput(new PentaP1Input(VxEnum,vx));
     8158        this->inputs->AddInput(new PentaP1Input(VyEnum,vy));
     8159        this->inputs->AddInput(new PentaP1Input(VzEnum,vz));
     8160        this->inputs->AddInput(new PentaP1Input(VelEnum,vel));
     8161        this->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
    81628162
    81638163        /*Free ressources:*/
  • issm/trunk-jpl/src/c/objects/Elements/Tria.cpp

    r11260 r11291  
    938938       
    939939        /*Add Stress tensor components into inputs*/
    940         this->inputs->AddInput(new TriaVertexInput(StressTensorxxEnum,&sigma_xx[0]));
    941         this->inputs->AddInput(new TriaVertexInput(StressTensorxyEnum,&sigma_xy[0]));
    942         this->inputs->AddInput(new TriaVertexInput(StressTensorxzEnum,&sigma_xz[0]));
    943         this->inputs->AddInput(new TriaVertexInput(StressTensoryyEnum,&sigma_yy[0]));
    944         this->inputs->AddInput(new TriaVertexInput(StressTensoryzEnum,&sigma_yz[0]));
    945         this->inputs->AddInput(new TriaVertexInput(StressTensorzzEnum,&sigma_zz[0]));
     940        this->inputs->AddInput(new TriaP1Input(StressTensorxxEnum,&sigma_xx[0]));
     941        this->inputs->AddInput(new TriaP1Input(StressTensorxyEnum,&sigma_xy[0]));
     942        this->inputs->AddInput(new TriaP1Input(StressTensorxzEnum,&sigma_xz[0]));
     943        this->inputs->AddInput(new TriaP1Input(StressTensoryyEnum,&sigma_yy[0]));
     944        this->inputs->AddInput(new TriaP1Input(StressTensoryzEnum,&sigma_yz[0]));
     945        this->inputs->AddInput(new TriaP1Input(StressTensorzzEnum,&sigma_zz[0]));
    946946
    947947        /*Clean up and return*/
     
    15161516                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    15171517                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    1518                                                 this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1518                                                this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    15191519                                        }
    15201520                                        break;
     
    15241524                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    15251525                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    1526                                                 this->inputs->AddInput(new ControlInput(VxEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1526                                                this->inputs->AddInput(new ControlInput(VxEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    15271527                                        }
    15281528                                        break;
     
    15321532                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    15331533                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    1534                                                 this->inputs->AddInput(new ControlInput(VyEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1534                                                this->inputs->AddInput(new ControlInput(VyEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    15351535                                        }
    15361536                                        break;
     
    15401540                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
    15411541                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
    1542                                                 this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1542                                                this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    15431543                                        }
    15441544                                        break;
     
    15591559                for(i=0;i<num_cm_responses;i++){
    15601560                        for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(InversionCostFunctionsCoefficientsEnum)[(tria_vertex_ids[j]-1)*num_cm_responses+i];
    1561                         datasetinput->inputs->AddObject(new TriaVertexInput(InversionCostFunctionsCoefficientsEnum,nodeinputs));
     1561                        datasetinput->inputs->AddObject(new TriaP1Input(InversionCostFunctionsCoefficientsEnum,nodeinputs));
    15621562                }
    15631563
     
    16401640
    16411641        /*Add input to the element: */
    1642         this->inputs->AddInput(new TriaVertexInput(enum_type,values));
     1642        this->inputs->AddInput(new TriaP1Input(enum_type,values));
    16431643
    16441644        /*Free ressources:*/
     
    17051705
    17061706        /*Add input to the element: */
    1707         this->inputs->AddInput(new TriaVertexInput(ThicknessEnum,newthickness));
    1708         this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,newsurface));
    1709         this->inputs->AddInput(new TriaVertexInput(BedEnum,newbed));
     1707        this->inputs->AddInput(new TriaP1Input(ThicknessEnum,newthickness));
     1708        this->inputs->AddInput(new TriaP1Input(SurfaceEnum,newsurface));
     1709        this->inputs->AddInput(new TriaP1Input(BedEnum,newbed));
    17101710
    17111711        /*Free ressources:*/
     
    17231723                case VertexEnum:
    17241724
    1725                         /*New TriaVertexInput*/
     1725                        /*New TriaP1Input*/
    17261726                        double values[3];
    17271727
     
    17331733                        /*update input*/
    17341734                        if (name==MaterialsRheologyBbarEnum || name==MaterialsRheologyBEnum){
    1735                                 matice->inputs->AddInput(new TriaVertexInput(name,values));
     1735                                matice->inputs->AddInput(new TriaP1Input(name,values));
    17361736                        }
    17371737                        else{
    1738                                 this->inputs->AddInput(new TriaVertexInput(name,values));
     1738                                this->inputs->AddInput(new TriaP1Input(name,values));
    17391739                        }
    17401740                        return;
     
    18121812
    18131813                        /*create static input: */
    1814                         this->inputs->AddInput(new TriaVertexInput(vector_enum,nodeinputs));
     1814                        this->inputs->AddInput(new TriaP1Input(vector_enum,nodeinputs));
    18151815                }
    18161816                else if(M==numberofvertices+1){
     
    18311831
    18321832                                if(t==0) transientinput=new TransientInput(vector_enum);
    1833                                 transientinput->AddTimeInput(new TriaVertexInput(vector_enum,nodeinputs),time);
     1833                                transientinput->AddTimeInput(new TriaP1Input(vector_enum,nodeinputs),time);
    18341834                        }
    18351835                        this->inputs->AddInput(transientinput);
     
    20672067        if(!this->IsFloating() && elementonshelf==true){
    20682068                for(i=0;i<NUMVERTICES;i++)melting[i]=gl_melting_rate/yts;
    2069                 this->inputs->AddInput(new TriaVertexInput(BasalforcingsMeltingRateEnum,&melting[0]));
     2069                this->inputs->AddInput(new TriaP1Input(BasalforcingsMeltingRateEnum,&melting[0]));
    20702070        }
    20712071
     
    20742074
    20752075        /*Update inputs*/   
    2076         this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,&s[0]));
    2077         this->inputs->AddInput(new TriaVertexInput(BedEnum,&b[0]));
     2076        this->inputs->AddInput(new TriaP1Input(SurfaceEnum,&s[0]));
     2077        this->inputs->AddInput(new TriaP1Input(BedEnum,&b[0]));
    20782078}
    20792079/*}}}*/
     
    23982398                        if(!iomodel->Data(VxEnum)){
    23992399                                for(i=0;i<3;i++)nodeinputs[i]=0;
    2400                                 this->inputs->AddInput(new TriaVertexInput(VxEnum,nodeinputs));
    2401                                 if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVxEnum,nodeinputs));
     2400                                this->inputs->AddInput(new TriaP1Input(VxEnum,nodeinputs));
     2401                                if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVxEnum,nodeinputs));
    24022402                        }
    24032403                        if(!iomodel->Data(VyEnum)){
    24042404                                for(i=0;i<3;i++)nodeinputs[i]=0;
    2405                                 this->inputs->AddInput(new TriaVertexInput(VyEnum,nodeinputs));
    2406                                 if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVyEnum,nodeinputs));
     2405                                this->inputs->AddInput(new TriaP1Input(VyEnum,nodeinputs));
     2406                                if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVyEnum,nodeinputs));
    24072407                        }
    24082408                        if(!iomodel->Data(VzEnum)){
    24092409                                for(i=0;i<3;i++)nodeinputs[i]=0;
    2410                                 this->inputs->AddInput(new TriaVertexInput(VzEnum,nodeinputs));
    2411                                 if(dakota_analysis) this->inputs->AddInput(new TriaVertexInput(QmuVzEnum,nodeinputs));
     2410                                this->inputs->AddInput(new TriaP1Input(VzEnum,nodeinputs));
     2411                                if(dakota_analysis) this->inputs->AddInput(new TriaP1Input(QmuVzEnum,nodeinputs));
    24122412                        }
    24132413                        if(!iomodel->Data(PressureEnum)){
    24142414                                for(i=0;i<3;i++)nodeinputs[i]=0;
    24152415                                if(dakota_analysis){
    2416                                         this->inputs->AddInput(new TriaVertexInput(PressureEnum,nodeinputs));
    2417                                         this->inputs->AddInput(new TriaVertexInput(QmuPressureEnum,nodeinputs));
     2416                                        this->inputs->AddInput(new TriaP1Input(PressureEnum,nodeinputs));
     2417                                        this->inputs->AddInput(new TriaP1Input(QmuPressureEnum,nodeinputs));
    24182418                                }
    24192419                        }
     
    31583158
    31593159        /*Add vx and vy as inputs to the tria element: */
    3160         this->inputs->AddInput(new TriaVertexInput(VxEnum,vx));
    3161         this->inputs->AddInput(new TriaVertexInput(VyEnum,vy));
    3162         this->inputs->AddInput(new TriaVertexInput(VelEnum,vel));
    3163         this->inputs->AddInput(new TriaVertexInput(PressureEnum,pressure));
     3160        this->inputs->AddInput(new TriaP1Input(VxEnum,vx));
     3161        this->inputs->AddInput(new TriaP1Input(VyEnum,vy));
     3162        this->inputs->AddInput(new TriaP1Input(VelEnum,vel));
     3163        this->inputs->AddInput(new TriaP1Input(PressureEnum,pressure));
    31643164
    31653165        /*Free ressources:*/
     
    32183218
    32193219        /*Add vx and vy as inputs to the tria element: */
    3220         this->inputs->AddInput(new TriaVertexInput(VxEnum,vx));
    3221         this->inputs->AddInput(new TriaVertexInput(VyEnum,vy));
    3222         this->inputs->AddInput(new TriaVertexInput(VelEnum,vel));
    3223         this->inputs->AddInput(new TriaVertexInput(PressureEnum,pressure));
     3220        this->inputs->AddInput(new TriaP1Input(VxEnum,vx));
     3221        this->inputs->AddInput(new TriaP1Input(VyEnum,vy));
     3222        this->inputs->AddInput(new TriaP1Input(VelEnum,vel));
     3223        this->inputs->AddInput(new TriaP1Input(PressureEnum,pressure));
    32243224
    32253225        /*Free ressources:*/
     
    33193319        this->GetDofList1(&doflist1[0]);
    33203320        for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[doflist1[i]];
    3321         grad_input=new TriaVertexInput(GradientEnum,grad_list);
     3321        grad_input=new TriaP1Input(GradientEnum,grad_list);
    33223322
    33233323        ((ControlInput*)input)->SetGradient(grad_input);
     
    46784678
    46794679        /*Add vx and vy as inputs to the tria element: */
    4680         this->inputs->AddInput(new TriaVertexInput(AdjointxEnum,lambdax));
    4681         this->inputs->AddInput(new TriaVertexInput(AdjointyEnum,lambday));
     4680        this->inputs->AddInput(new TriaP1Input(AdjointxEnum,lambdax));
     4681        this->inputs->AddInput(new TriaP1Input(AdjointyEnum,lambday));
    46824682
    46834683        /*Free ressources:*/
     
    47084708
    47094709        /*Add vx and vy as inputs to the tria element: */
    4710         this->inputs->AddInput(new TriaVertexInput(AdjointEnum,lambda));
     4710        this->inputs->AddInput(new TriaP1Input(AdjointEnum,lambda));
    47114711
    47124712        /*Free ressources:*/
     
    47684768
    47694769        /*Add to inputs*/
    4770         this->inputs->AddInput(new TriaVertexInput(HydrologyWaterVxEnum,vx));
    4771         this->inputs->AddInput(new TriaVertexInput(HydrologyWaterVyEnum,vy));
     4770        this->inputs->AddInput(new TriaP1Input(HydrologyWaterVxEnum,vx));
     4771        this->inputs->AddInput(new TriaP1Input(HydrologyWaterVyEnum,vy));
    47724772}
    47734773/*}}}*/
     
    49844984
    49854985        /*Add input to the element: */
    4986         this->inputs->AddInput(new TriaVertexInput(WatercolumnEnum,values));
     4986        this->inputs->AddInput(new TriaP1Input(WatercolumnEnum,values));
    49874987
    49884988        /*Free ressources:*/
     
    50055005                case VertexEnum:
    50065006
    5007                         /*New TriaVertexInput*/
     5007                        /*New TriaP1Input*/
    50085008                        double values[3];
    50095009
     
    50785078
    50795079                                        /*Add new inputs: */
    5080                                         this->inputs->AddInput(new TriaVertexInput(ThicknessEnum,thickness));
    5081                                         this->inputs->AddInput(new TriaVertexInput(BedEnum,bed));
    5082                                         this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,surface));
     5080                                        this->inputs->AddInput(new TriaP1Input(ThicknessEnum,thickness));
     5081                                        this->inputs->AddInput(new TriaP1Input(BedEnum,bed));
     5082                                        this->inputs->AddInput(new TriaP1Input(SurfaceEnum,surface));
    50835083
    50845084                                        /*}}}*/
    50855085                                        break;
    50865086                                default:
    5087                                         this->inputs->AddInput(new TriaVertexInput(name,values));
     5087                                        this->inputs->AddInput(new TriaP1Input(name,values));
    50885088                        }
    50895089                        break;
     
    51375137
    51385138                                if(t==0) transientinput=new TransientInput(name);
    5139                                 transientinput->AddTimeInput(new TriaVertexInput(name,values),time);
     5139                                transientinput->AddTimeInput(new TriaP1Input(name,values),time);
    51405140                                transientinput->Configure(parameters);
    51415141                        }
  • issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp

    r10135 r11291  
    3535
    3636        switch(enum_input){
    37                 case TriaVertexInputEnum:
    38                         values     =new TriaVertexInput(enum_type,pvalues);
    39                         savedvalues=new TriaVertexInput(enum_type,pvalues);
    40                         minvalues  =new TriaVertexInput(enum_type,pmin);
    41                         maxvalues  =new TriaVertexInput(enum_type,pmax);
     37                case TriaP1InputEnum:
     38                        values     =new TriaP1Input(enum_type,pvalues);
     39                        savedvalues=new TriaP1Input(enum_type,pvalues);
     40                        minvalues  =new TriaP1Input(enum_type,pmin);
     41                        maxvalues  =new TriaP1Input(enum_type,pmax);
    4242                        break;
    43                 case PentaVertexInputEnum:
    44                         values     =new PentaVertexInput(enum_type,pvalues);
    45                         savedvalues=new PentaVertexInput(enum_type,pvalues);
    46                         minvalues  =new PentaVertexInput(enum_type,pmin);
    47                         maxvalues  =new PentaVertexInput(enum_type,pmax);
     43                case PentaP1InputEnum:
     44                        values     =new PentaP1Input(enum_type,pvalues);
     45                        savedvalues=new PentaP1Input(enum_type,pvalues);
     46                        minvalues  =new PentaP1Input(enum_type,pmin);
     47                        maxvalues  =new PentaP1Input(enum_type,pmax);
    4848                        break;
    4949                default:
     
    206206        if(flag){
    207207                memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
    208                 if(input_enum_type==PentaVertexInputEnum){
    209                         values=new PentaVertexInput();
     208                if(input_enum_type==PentaP1InputEnum){
     209                        values=new PentaP1Input();
    210210                        values->Demarshall(&marshalled_dataset);
    211211                }
    212                 else if(input_enum_type==TriaVertexInputEnum){
    213                         values=new TriaVertexInput();
     212                else if(input_enum_type==TriaP1InputEnum){
     213                        values=new TriaP1Input();
    214214                        values->Demarshall(&marshalled_dataset);
    215215                }
     
    224224        if(flag){
    225225                memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
    226                 if(input_enum_type==PentaVertexInputEnum){
    227                         savedvalues=new PentaVertexInput();
     226                if(input_enum_type==PentaP1InputEnum){
     227                        savedvalues=new PentaP1Input();
    228228                        savedvalues->Demarshall(&marshalled_dataset);
    229229                }
    230                 else if(input_enum_type==TriaVertexInputEnum){
    231                         savedvalues=new TriaVertexInput();
     230                else if(input_enum_type==TriaP1InputEnum){
     231                        savedvalues=new TriaP1Input();
    232232                        savedvalues->Demarshall(&marshalled_dataset);
    233233                }
     
    242242        if(flag){
    243243                memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
    244                 if(input_enum_type==PentaVertexInputEnum){
    245                         minvalues=new PentaVertexInput();
     244                if(input_enum_type==PentaP1InputEnum){
     245                        minvalues=new PentaP1Input();
    246246                        minvalues->Demarshall(&marshalled_dataset);
    247247                }
    248                 else if(input_enum_type==TriaVertexInputEnum){
    249                         minvalues=new TriaVertexInput();
     248                else if(input_enum_type==TriaP1InputEnum){
     249                        minvalues=new TriaP1Input();
    250250                        minvalues->Demarshall(&marshalled_dataset);
    251251                }
     
    260260        if(flag){
    261261                memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
    262                 if(input_enum_type==PentaVertexInputEnum){
    263                         maxvalues=new PentaVertexInput();
     262                if(input_enum_type==PentaP1InputEnum){
     263                        maxvalues=new PentaP1Input();
    264264                        maxvalues->Demarshall(&marshalled_dataset);
    265265                }
    266                 else if(input_enum_type==TriaVertexInputEnum){
    267                         maxvalues=new TriaVertexInput();
     266                else if(input_enum_type==TriaP1InputEnum){
     267                        maxvalues=new TriaP1Input();
    268268                        maxvalues->Demarshall(&marshalled_dataset);
    269269                }
     
    278278        if(flag){
    279279                memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
    280                 if(input_enum_type==PentaVertexInputEnum){
    281                         gradient=new PentaVertexInput();
     280                if(input_enum_type==PentaP1InputEnum){
     281                        gradient=new PentaP1Input();
    282282                        gradient->Demarshall(&marshalled_dataset);
    283283                }
    284                 else if(input_enum_type==TriaVertexInputEnum){
    285                         gradient=new TriaVertexInput();
     284                else if(input_enum_type==TriaP1InputEnum){
     285                        gradient=new TriaP1Input();
    286286                        gradient->Demarshall(&marshalled_dataset);
    287287                }
  • issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp

    r10135 r11291  
    340340        switch(thickness_input->ObjectEnum()){
    341341
    342                 case PentaVertexInputEnum:
     342                case PentaP1InputEnum:
    343343                        thickness_input->GetInputAverage(&thickness_value);
    344344                        this->value=this->value*thickness_value;
  • issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp

    r11288 r11291  
    1 /*!\file PentaVertexInput.c
    2  * \brief: implementation of the PentaVertexInput object
     1/*!\file PentaP1Input.c
     2 * \brief: implementation of the PentaP1Input object
    33 */
    44
     
    1717#include "../../include/include.h"
    1818
    19 /*PentaVertexInput constructors and destructor*/
    20 /*FUNCTION PentaVertexInput::PentaVertexInput(){{{1*/
    21 PentaVertexInput::PentaVertexInput(){
     19/*PentaP1Input constructors and destructor*/
     20/*FUNCTION PentaP1Input::PentaP1Input(){{{1*/
     21PentaP1Input::PentaP1Input(){
    2222        return;
    2323}
    2424/*}}}*/
    25 /*FUNCTION PentaVertexInput::PentaVertexInput(int in_enum_type,double* values){{{1*/
    26 PentaVertexInput::PentaVertexInput(int in_enum_type,double* in_values)
     25/*FUNCTION PentaP1Input::PentaP1Input(int in_enum_type,double* values){{{1*/
     26PentaP1Input::PentaP1Input(int in_enum_type,double* in_values)
    2727                :PentaRef(1)
    2828{
     
    4141}
    4242/*}}}*/
    43 /*FUNCTION PentaVertexInput::~PentaVertexInput(){{{1*/
    44 PentaVertexInput::~PentaVertexInput(){
     43/*FUNCTION PentaP1Input::~PentaP1Input(){{{1*/
     44PentaP1Input::~PentaP1Input(){
    4545        return;
    4646}
     
    4848
    4949/*Object virtual functions definitions:*/
    50 /*FUNCTION PentaVertexInput::Echo {{{1*/
    51 void PentaVertexInput::Echo(void){
     50/*FUNCTION PentaP1Input::Echo {{{1*/
     51void PentaP1Input::Echo(void){
    5252        this->DeepEcho();
    5353}
    5454/*}}}*/
    55 /*FUNCTION PentaVertexInput::DeepEcho{{{1*/
    56 void PentaVertexInput::DeepEcho(void){
    57 
    58         printf("PentaVertexInput:\n");
     55/*FUNCTION PentaP1Input::DeepEcho{{{1*/
     56void PentaP1Input::DeepEcho(void){
     57
     58        printf("PentaP1Input:\n");
    5959        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6060        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]);
    6161}
    6262/*}}}*/
    63 /*FUNCTION PentaVertexInput::Id{{{1*/
    64 int    PentaVertexInput::Id(void){ return -1; }
    65 /*}}}*/
    66 /*FUNCTION PentaVertexInput::MyRank{{{1*/
    67 int    PentaVertexInput::MyRank(void){
     63/*FUNCTION PentaP1Input::Id{{{1*/
     64int    PentaP1Input::Id(void){ return -1; }
     65/*}}}*/
     66/*FUNCTION PentaP1Input::MyRank{{{1*/
     67int    PentaP1Input::MyRank(void){
    6868        extern int my_rank;
    6969        return my_rank;
     
    7171/*}}}*/
    7272#ifdef _SERIAL_
    73 /*FUNCTION PentaVertexInput::Marshall{{{1*/
    74 void  PentaVertexInput::Marshall(char** pmarshalled_dataset){
     73/*FUNCTION PentaP1Input::Marshall{{{1*/
     74void  PentaP1Input::Marshall(char** pmarshalled_dataset){
    7575
    7676        char* marshalled_dataset=NULL;
     
    8080        marshalled_dataset=*pmarshalled_dataset;
    8181
    82         /*get enum value of PentaVertexInput: */
    83         enum_value=PentaVertexInputEnum;
     82        /*get enum value of PentaP1Input: */
     83        enum_value=PentaP1InputEnum;
    8484       
    8585        /*marshall enum: */
    8686        memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
    8787       
    88         /*marshall PentaVertexInput data: */
     88        /*marshall PentaP1Input data: */
    8989        memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
    9090        memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values);
     
    9393}
    9494/*}}}*/
    95 /*FUNCTION PentaVertexInput::MarshallSize{{{1*/
    96 int   PentaVertexInput::MarshallSize(){
     95/*FUNCTION PentaP1Input::MarshallSize{{{1*/
     96int   PentaP1Input::MarshallSize(){
    9797       
    9898        return sizeof(values)+
     
    101101}
    102102/*}}}*/
    103 /*FUNCTION PentaVertexInput::Demarshall{{{1*/
    104 void  PentaVertexInput::Demarshall(char** pmarshalled_dataset){
     103/*FUNCTION PentaP1Input::Demarshall{{{1*/
     104void  PentaP1Input::Demarshall(char** pmarshalled_dataset){
    105105
    106106        char* marshalled_dataset=NULL;
     
    121121/*}}}*/
    122122#endif
    123 /*FUNCTION PentaVertexInput::ObjectEnum{{{1*/
    124 int PentaVertexInput::ObjectEnum(void){
    125 
    126         return PentaVertexInputEnum;
     123/*FUNCTION PentaP1Input::ObjectEnum{{{1*/
     124int PentaP1Input::ObjectEnum(void){
     125
     126        return PentaP1InputEnum;
    127127
    128128}
    129129/*}}}*/
    130130       
    131 /*PentaVertexInput management*/
    132 /*FUNCTION PentaVertexInput::copy{{{1*/
    133 Object* PentaVertexInput::copy() {
     131/*PentaP1Input management*/
     132/*FUNCTION PentaP1Input::copy{{{1*/
     133Object* PentaP1Input::copy() {
    134134       
    135         return new PentaVertexInput(this->enum_type,this->values);
    136 
    137 }
    138 /*}}}*/
    139 /*FUNCTION PentaVertexInput::InstanceEnum{{{1*/
    140 int PentaVertexInput::InstanceEnum(void){
     135        return new PentaP1Input(this->enum_type,this->values);
     136
     137}
     138/*}}}*/
     139/*FUNCTION PentaP1Input::InstanceEnum{{{1*/
     140int PentaP1Input::InstanceEnum(void){
    141141
    142142        return this->enum_type;
     
    144144}
    145145/*}}}*/
    146 /*FUNCTION PentaVertexInput::SpawnTriaInput{{{1*/
    147 Input* PentaVertexInput::SpawnTriaInput(int* indices){
     146/*FUNCTION PentaP1Input::SpawnTriaInput{{{1*/
     147Input* PentaP1Input::SpawnTriaInput(int* indices){
    148148
    149149        /*output*/
    150         TriaVertexInput* outinput=NULL;
     150        TriaP1Input* outinput=NULL;
    151151        double newvalues[3];
    152152
     
    162162
    163163        /*Create new Tria input*/
    164         outinput=new TriaVertexInput(this->enum_type,&newvalues[0]);
     164        outinput=new TriaP1Input(this->enum_type,&newvalues[0]);
    165165
    166166        /*Assign output*/
     
    169169}
    170170/*}}}*/
    171 /*FUNCTION PentaVertexInput::SpawnResult{{{1*/
    172 ElementResult* PentaVertexInput::SpawnResult(int step, double time){
     171/*FUNCTION PentaP1Input::SpawnResult{{{1*/
     172ElementResult* PentaP1Input::SpawnResult(int step, double time){
    173173
    174174        return new PentaVertexElementResult(this->enum_type,this->values,step,time);
     
    178178
    179179/*Object functions*/
    180 /*FUNCTION PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
    181 void PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){
     180/*FUNCTION PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
     181void PentaP1Input::GetInputValue(double* pvalue,GaussPenta* gauss){
    182182
    183183        /*Call PentaRef function*/
     
    186186}
    187187/*}}}*/
    188 /*FUNCTION PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
    189 void PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){
     188/*FUNCTION PentaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
     189void PentaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){
    190190
    191191        /*Call PentaRef function*/
     
    193193}
    194194/*}}}*/
    195 /*FUNCTION PentaVertexInput::GetVxStrainRate3d{{{1*/
    196 void PentaVertexInput::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
     195/*FUNCTION PentaP1Input::GetVxStrainRate3d{{{1*/
     196void PentaP1Input::GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
    197197        int i,j;
    198198
     
    238238}
    239239/*}}}*/
    240 /*FUNCTION PentaVertexInput::GetVyStrainRate3d{{{1*/
    241 void PentaVertexInput::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
     240/*FUNCTION PentaP1Input::GetVyStrainRate3d{{{1*/
     241void PentaP1Input::GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
    242242        int i,j;
    243243
     
    283283}
    284284/*}}}*/
    285 /*FUNCTION PentaVertexInput::GetVzStrainRate3d{{{1*/
    286 void PentaVertexInput::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){
     285/*FUNCTION PentaP1Input::GetVzStrainRate3d{{{1*/
     286void PentaP1Input::GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){
    287287        int i,j;
    288288
     
    329329}
    330330/*}}}*/
    331 /*FUNCTION PentaVertexInput::GetVxStrainRate3dPattyn{{{1*/
    332 void PentaVertexInput::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
     331/*FUNCTION PentaP1Input::GetVxStrainRate3dPattyn{{{1*/
     332void PentaP1Input::GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){
    333333
    334334        int i;
     
    353353}
    354354/*}}}*/
    355 /*FUNCTION PentaVertexInput::GetVyStrainRate3dPattyn{{{1*/
    356 void PentaVertexInput::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
     355/*FUNCTION PentaP1Input::GetVyStrainRate3dPattyn{{{1*/
     356void PentaP1Input::GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){
    357357
    358358        int i;
     
    377377}
    378378/*}}}*/
    379 /*FUNCTION PentaVertexInput::ChangeEnum{{{1*/
    380 void PentaVertexInput::ChangeEnum(int newenumtype){
     379/*FUNCTION PentaP1Input::ChangeEnum{{{1*/
     380void PentaP1Input::ChangeEnum(int newenumtype){
    381381        this->enum_type=newenumtype;
    382382}
    383383/*}}}*/
    384 /*FUNCTION PentaVertexInput::GetInputAverage{{{1*/
    385 void PentaVertexInput::GetInputAverage(double* pvalue){
     384/*FUNCTION PentaP1Input::GetInputAverage{{{1*/
     385void PentaP1Input::GetInputAverage(double* pvalue){
    386386        *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]);
    387387}
     
    389389
    390390/*Intermediary*/
    391 /*FUNCTION PentaVertexInput::SquareMin{{{1*/
    392 void PentaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
     391/*FUNCTION PentaP1Input::SquareMin{{{1*/
     392void PentaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
    393393
    394394        int i;
     
    412412}
    413413/*}}}*/
    414 /*FUNCTION PentaVertexInput::ConstrainMin{{{1*/
    415 void PentaVertexInput::ConstrainMin(double minimum){
     414/*FUNCTION PentaP1Input::ConstrainMin{{{1*/
     415void PentaP1Input::ConstrainMin(double minimum){
    416416       
    417417        int i;
     
    421421}
    422422/*}}}*/
    423 /*FUNCTION PentaVertexInput::InfinityNorm{{{1*/
    424 double PentaVertexInput::InfinityNorm(void){
     423/*FUNCTION PentaP1Input::InfinityNorm{{{1*/
     424double PentaP1Input::InfinityNorm(void){
    425425
    426426        /*Output*/
     
    432432}
    433433/*}}}*/
    434 /*FUNCTION PentaVertexInput::Max{{{1*/
    435 double PentaVertexInput::Max(void){
     434/*FUNCTION PentaP1Input::Max{{{1*/
     435double PentaP1Input::Max(void){
    436436
    437437        const int numnodes=6;
     
    444444}
    445445/*}}}*/
    446 /*FUNCTION PentaVertexInput::MaxAbs{{{1*/
    447 double PentaVertexInput::MaxAbs(void){
     446/*FUNCTION PentaP1Input::MaxAbs{{{1*/
     447double PentaP1Input::MaxAbs(void){
    448448
    449449        const int numnodes=6;
     
    456456}
    457457/*}}}*/
    458 /*FUNCTION PentaVertexInput::Min{{{1*/
    459 double PentaVertexInput::Min(void){
     458/*FUNCTION PentaP1Input::Min{{{1*/
     459double PentaP1Input::Min(void){
    460460
    461461        const int numnodes=6;
     
    468468}
    469469/*}}}*/
    470 /*FUNCTION PentaVertexInput::MinAbs{{{1*/
    471 double PentaVertexInput::MinAbs(void){
     470/*FUNCTION PentaP1Input::MinAbs{{{1*/
     471double PentaP1Input::MinAbs(void){
    472472
    473473        const int numnodes=6;
     
    480480}
    481481/*}}}*/
    482 /*FUNCTION PentaVertexInput::Scale{{{1*/
    483 void PentaVertexInput::Scale(double scale_factor){
     482/*FUNCTION PentaP1Input::Scale{{{1*/
     483void PentaP1Input::Scale(double scale_factor){
    484484       
    485485        int i;
     
    489489}
    490490/*}}}*/
    491 /*FUNCTION PentaVertexInput::AXPY{{{1*/
    492 void PentaVertexInput::AXPY(Input* xinput,double scalar){
     491/*FUNCTION PentaP1Input::AXPY{{{1*/
     492void PentaP1Input::AXPY(Input* xinput,double scalar){
    493493
    494494        int i;
     
    500500        switch(xinput->ObjectEnum()){
    501501
    502                 case PentaVertexInputEnum:{
    503                         PentaVertexInput* cast_input=(PentaVertexInput*)xinput;
     502                case PentaP1InputEnum:{
     503                        PentaP1Input* cast_input=(PentaP1Input*)xinput;
    504504                        for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
    505505                        return;
    506506                case ControlInputEnum:{
    507507                        ControlInput* cont_input=(ControlInput*)xinput;
    508                         if(cont_input->values->ObjectEnum()!=PentaVertexInputEnum) _error_("not supported yet");
    509                         PentaVertexInput* cast_input=(PentaVertexInput*)cont_input->values;
     508                        if(cont_input->values->ObjectEnum()!=PentaP1InputEnum) _error_("not supported yet");
     509                        PentaP1Input* cast_input=(PentaP1Input*)cont_input->values;
    510510                        for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
    511511                        return;
     
    516516}
    517517/*}}}*/
    518 /*FUNCTION PentaVertexInput::Constrain{{{1*/
    519 void PentaVertexInput::Constrain(double cm_min, double cm_max){
     518/*FUNCTION PentaP1Input::Constrain{{{1*/
     519void PentaP1Input::Constrain(double cm_min, double cm_max){
    520520
    521521        int i;
     
    527527}
    528528/*}}}*/
    529 /*FUNCTION PentaVertexInput::Extrude{{{1*/
    530 void PentaVertexInput::Extrude(void){
     529/*FUNCTION PentaP1Input::Extrude{{{1*/
     530void PentaP1Input::Extrude(void){
    531531
    532532        int i;
     
    536536}
    537537/*}}}*/
    538 /*FUNCTION PentaVertexInput::VerticallyIntegrate{{{1*/
    539 void PentaVertexInput::VerticallyIntegrate(Input* thickness_input){
     538/*FUNCTION PentaP1Input::VerticallyIntegrate{{{1*/
     539void PentaP1Input::VerticallyIntegrate(Input* thickness_input){
    540540
    541541        /*Intermediaries*/
     
    554554        switch(thickness_input->ObjectEnum()){
    555555
    556                 case PentaVertexInputEnum:
     556                case PentaP1InputEnum:
    557557                        for(i=0;i<3;i++){
    558558                                this->values[i]=0.5*(this->values[i]+this->values[i+3]) * thickness_values[i];
     
    566566}
    567567/*}}}*/
    568 /*FUNCTION PentaVertexInput::PointwiseDivide{{{1*/
    569 Input* PentaVertexInput::PointwiseDivide(Input* inputB){
     568/*FUNCTION PentaP1Input::PointwiseDivide{{{1*/
     569Input* PentaP1Input::PointwiseDivide(Input* inputB){
    570570
    571571        /*Ouput*/
    572         PentaVertexInput* outinput=NULL;
     572        PentaP1Input* outinput=NULL;
    573573
    574574        /*Intermediaries*/
    575575        int               i;
    576         PentaVertexInput *xinputB     = NULL;
     576        PentaP1Input *xinputB     = NULL;
    577577        int               B_numvalues;
    578578        const int         numnodes    = 6;
     
    580580
    581581        /*Check that inputB is of the same type*/
    582         if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
    583         xinputB=(PentaVertexInput*)inputB;
     582        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
     583        xinputB=(PentaP1Input*)inputB;
    584584
    585585        /*Create point wise sum*/
     
    590590
    591591        /*Create new Penta vertex input (copy of current input)*/
    592         outinput=new PentaVertexInput(this->enum_type,&AdotBvalues[0]);
     592        outinput=new PentaP1Input(this->enum_type,&AdotBvalues[0]);
    593593
    594594        /*Return output pointer*/
     
    597597}
    598598/*}}}*/
    599 /*FUNCTION PentaVertexInput::PointwiseMin{{{1*/
    600 Input* PentaVertexInput::PointwiseMin(Input* inputB){
     599/*FUNCTION PentaP1Input::PointwiseMin{{{1*/
     600Input* PentaP1Input::PointwiseMin(Input* inputB){
    601601
    602602        /*Ouput*/
    603         PentaVertexInput* outinput=NULL;
     603        PentaP1Input* outinput=NULL;
    604604
    605605        /*Intermediaries*/
    606606        int               i;
    607         PentaVertexInput *xinputB     = NULL;
     607        PentaP1Input *xinputB     = NULL;
    608608        int               B_numvalues;
    609609        const int         numnodes    = 6;
     
    611611
    612612        /*Check that inputB is of the same type*/
    613         if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
    614         xinputB=(PentaVertexInput*)inputB;
     613        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
     614        xinputB=(PentaP1Input*)inputB;
    615615
    616616        /*Create point wise min*/
     
    621621
    622622        /*Create new Penta vertex input (copy of current input)*/
    623         outinput=new PentaVertexInput(this->enum_type,&minvalues[0]);
     623        outinput=new PentaP1Input(this->enum_type,&minvalues[0]);
    624624
    625625        /*Return output pointer*/
     
    628628}
    629629/*}}}*/
    630 /*FUNCTION PentaVertexInput::PointwiseMax{{{1*/
    631 Input* PentaVertexInput::PointwiseMax(Input* inputB){
     630/*FUNCTION PentaP1Input::PointwiseMax{{{1*/
     631Input* PentaP1Input::PointwiseMax(Input* inputB){
    632632
    633633        /*Ouput*/
    634         PentaVertexInput* outinput=NULL;
     634        PentaP1Input* outinput=NULL;
    635635
    636636        /*Intermediaries*/
    637637        int               i;
    638         PentaVertexInput *xinputB     = NULL;
     638        PentaP1Input *xinputB     = NULL;
    639639        int               B_numvalues;
    640640        const int         numnodes    = 6;
     
    642642
    643643        /*Check that inputB is of the same type*/
    644         if (inputB->ObjectEnum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
    645         xinputB=(PentaVertexInput*)inputB;
     644        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
     645        xinputB=(PentaP1Input*)inputB;
    646646
    647647        /*Create point wise max*/
     
    652652
    653653        /*Create new Penta vertex input (copy of current input)*/
    654         outinput=new PentaVertexInput(this->enum_type,&maxvalues[0]);
     654        outinput=new PentaP1Input(this->enum_type,&maxvalues[0]);
    655655
    656656        /*Return output pointer*/
     
    659659}
    660660/*}}}*/
    661 /*FUNCTION PentaVertexInput::GetVectorFromInputs{{{1*/
    662 void PentaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
     661/*FUNCTION PentaP1Input::GetVectorFromInputs{{{1*/
     662void PentaP1Input::GetVectorFromInputs(Vec vector,int* doflist){
    663663
    664664        const int numvertices=6;
     
    666666
    667667} /*}}}*/
    668 /*FUNCTION PentaVertexInput::GetValuesPtr{{{1*/
    669 void PentaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
     668/*FUNCTION PentaP1Input::GetValuesPtr{{{1*/
     669void PentaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){
    670670
    671671        *pvalues=this->values;
     
    674674}
    675675/*}}}*/
    676 /*FUNCTION PentaVertexInput::Configure{{{1*/
    677 void PentaVertexInput::Configure(Parameters* parameters){
     676/*FUNCTION PentaP1Input::Configure{{{1*/
     677void PentaP1Input::Configure(Parameters* parameters){
    678678        /*do nothing: */
    679679}
  • issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h

    r11288 r11291  
    1 /*! \file PentaVertexInput.h
     1/*! \file PentaP1Input.h
    22 *  \brief: header file for triavertexinput object
    33 */
     
    1414/*}}}*/
    1515
    16 class PentaVertexInput: public Input, public PentaRef{
     16class PentaP1Input: public Input, public PentaRef{
    1717
    1818        public:
     
    2121                double values[6];
    2222
    23                 /*PentaVertexInput constructors, destructors: {{{1*/
    24                 PentaVertexInput();
    25                 PentaVertexInput(int enum_type,double* values);
    26                 ~PentaVertexInput();
     23                /*PentaP1Input constructors, destructors: {{{1*/
     24                PentaP1Input();
     25                PentaP1Input(int enum_type,double* values);
     26                ~PentaP1Input();
    2727                /*}}}*/
    2828                /*Object virtual functions definitions:{{{1 */
     
    3939                Object* copy();
    4040                /*}}}*/
    41                 /*PentaVertexInput management: {{{1*/
     41                /*PentaP1Input management: {{{1*/
    4242                int   InstanceEnum();
    4343                Input* SpawnTriaInput(int* indices);
  • issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp

    r11288 r11291  
    1 /*!\file TriaVertexInput.c
    2  * \brief: implementation of the TriaVertexInput object
     1/*!\file TriaP1Input.c
     2 * \brief: implementation of the TriaP1Input object
    33 */
    44
     
    1717#include "../../include/include.h"
    1818
    19 /*TriaVertexInput constructors and destructor*/
    20 /*FUNCTION TriaVertexInput::TriaVertexInput(){{{1*/
    21 TriaVertexInput::TriaVertexInput(){
     19/*TriaP1Input constructors and destructor*/
     20/*FUNCTION TriaP1Input::TriaP1Input(){{{1*/
     21TriaP1Input::TriaP1Input(){
    2222        return;
    2323}
    2424/*}}}*/
    25 /*FUNCTION TriaVertexInput::TriaVertexInput(int in_enum_type,double* values){{{1*/
    26 TriaVertexInput::TriaVertexInput(int in_enum_type,double* in_values)
     25/*FUNCTION TriaP1Input::TriaP1Input(int in_enum_type,double* values){{{1*/
     26TriaP1Input::TriaP1Input(int in_enum_type,double* in_values)
    2727        :TriaRef(1)
    2828{
     
    4141}
    4242/*}}}*/
    43 /*FUNCTION TriaVertexInput::~TriaVertexInput(){{{1*/
    44 TriaVertexInput::~TriaVertexInput(){
     43/*FUNCTION TriaP1Input::~TriaP1Input(){{{1*/
     44TriaP1Input::~TriaP1Input(){
    4545        return;
    4646}
     
    4848
    4949/*Object virtual functions definitions:*/
    50 /*FUNCTION TriaVertexInput::Echo {{{1*/
    51 void TriaVertexInput::Echo(void){
     50/*FUNCTION TriaP1Input::Echo {{{1*/
     51void TriaP1Input::Echo(void){
    5252        this->DeepEcho();
    5353}
    5454/*}}}*/
    55 /*FUNCTION TriaVertexInput::DeepEcho{{{1*/
    56 void TriaVertexInput::DeepEcho(void){
    57 
    58         printf("TriaVertexInput:\n");
     55/*FUNCTION TriaP1Input::DeepEcho{{{1*/
     56void TriaP1Input::DeepEcho(void){
     57
     58        printf("TriaP1Input:\n");
    5959        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6060        printf("   values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]);
    6161}
    6262/*}}}*/
    63 /*FUNCTION TriaVertexInput::Id{{{1*/
    64 int    TriaVertexInput::Id(void){ return -1; }
    65 /*}}}*/
    66 /*FUNCTION TriaVertexInput::MyRank{{{1*/
    67 int    TriaVertexInput::MyRank(void){
     63/*FUNCTION TriaP1Input::Id{{{1*/
     64int    TriaP1Input::Id(void){ return -1; }
     65/*}}}*/
     66/*FUNCTION TriaP1Input::MyRank{{{1*/
     67int    TriaP1Input::MyRank(void){
    6868        extern int my_rank;
    6969        return my_rank;
     
    7171/*}}}*/
    7272#ifdef _SERIAL_
    73 /*FUNCTION TriaVertexInput::Marshall{{{1*/
    74 void  TriaVertexInput::Marshall(char** pmarshalled_dataset){
     73/*FUNCTION TriaP1Input::Marshall{{{1*/
     74void  TriaP1Input::Marshall(char** pmarshalled_dataset){
    7575
    7676        char* marshalled_dataset=NULL;
     
    8080        marshalled_dataset=*pmarshalled_dataset;
    8181
    82         /*get enum value of TriaVertexInput: */
    83         enum_value=TriaVertexInputEnum;
     82        /*get enum value of TriaP1Input: */
     83        enum_value=TriaP1InputEnum;
    8484       
    8585        /*marshall enum: */
    8686        memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
    8787       
    88         /*marshall TriaVertexInput data: */
     88        /*marshall TriaP1Input data: */
    8989        memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
    9090        memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values);
     
    9393}
    9494/*}}}*/
    95 /*FUNCTION TriaVertexInput::MarshallSize{{{1*/
    96 int   TriaVertexInput::MarshallSize(){
     95/*FUNCTION TriaP1Input::MarshallSize{{{1*/
     96int   TriaP1Input::MarshallSize(){
    9797       
    9898        return sizeof(values)+
     
    101101}
    102102/*}}}*/
    103 /*FUNCTION TriaVertexInput::Demarshall{{{1*/
    104 void  TriaVertexInput::Demarshall(char** pmarshalled_dataset){
     103/*FUNCTION TriaP1Input::Demarshall{{{1*/
     104void  TriaP1Input::Demarshall(char** pmarshalled_dataset){
    105105
    106106        char* marshalled_dataset=NULL;
     
    121121/*}}}*/
    122122#endif
    123 /*FUNCTION TriaVertexInput::ObjectEnum{{{1*/
    124 int TriaVertexInput::ObjectEnum(void){
    125 
    126         return TriaVertexInputEnum;
    127 
    128 }
    129 /*}}}*/
    130 /*FUNCTION TriaVertexInput::copy{{{1*/
    131 Object* TriaVertexInput::copy() {
    132        
    133         return new TriaVertexInput(this->enum_type,this->values);
    134 
    135 }
    136 /*}}}*/
    137        
    138 /*TriaVertexInput management*/
    139 /*FUNCTION TriaVertexInput::InstanceEnum{{{1*/
    140 int TriaVertexInput::InstanceEnum(void){
     123/*FUNCTION TriaP1Input::ObjectEnum{{{1*/
     124int TriaP1Input::ObjectEnum(void){
     125
     126        return TriaP1InputEnum;
     127
     128}
     129/*}}}*/
     130/*FUNCTION TriaP1Input::copy{{{1*/
     131Object* TriaP1Input::copy() {
     132       
     133        return new TriaP1Input(this->enum_type,this->values);
     134
     135}
     136/*}}}*/
     137       
     138/*TriaP1Input management*/
     139/*FUNCTION TriaP1Input::InstanceEnum{{{1*/
     140int TriaP1Input::InstanceEnum(void){
    141141
    142142        return this->enum_type;
     
    144144}
    145145/*}}}*/
    146 /*FUNCTION TriaVertexInput::SpawnTriaInput{{{1*/
    147 Input* TriaVertexInput::SpawnTriaInput(int* indices){
     146/*FUNCTION TriaP1Input::SpawnTriaInput{{{1*/
     147Input* TriaP1Input::SpawnTriaInput(int* indices){
    148148
    149149        /*output*/
    150         TriaVertexInput* outinput=NULL;
     150        TriaP1Input* outinput=NULL;
    151151
    152152        /*Create new Tria input (copy of current input)*/
    153         outinput=new TriaVertexInput(this->enum_type,&this->values[0]);
     153        outinput=new TriaP1Input(this->enum_type,&this->values[0]);
    154154
    155155        /*Assign output*/
     
    158158}
    159159/*}}}*/
    160 /*FUNCTION TriaVertexInput::SpawnResult{{{1*/
    161 ElementResult* TriaVertexInput::SpawnResult(int step, double time){
     160/*FUNCTION TriaP1Input::SpawnResult{{{1*/
     161ElementResult* TriaP1Input::SpawnResult(int step, double time){
    162162
    163163        return new TriaVertexElementResult(this->enum_type,this->values,step,time);
     
    167167
    168168/*Object functions*/
    169 /*FUNCTION TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
    170 void TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){
     169/*FUNCTION TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     170void TriaP1Input::GetInputValue(double* pvalue,GaussTria* gauss){
    171171
    172172        /*Call TriaRef function*/
     
    175175}
    176176/*}}}*/
    177 /*FUNCTION TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
    178 void TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
     177/*FUNCTION TriaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
     178void TriaP1Input::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
    179179
    180180        /*Call TriaRef function*/
     
    182182}
    183183/*}}}*/
    184 /*FUNCTION TriaVertexInput::GetVxStrainRate2d{{{1*/
    185 void TriaVertexInput::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){
     184/*FUNCTION TriaP1Input::GetVxStrainRate2d{{{1*/
     185void TriaP1Input::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){
    186186
    187187        /*Intermediary*/
     
    205205}
    206206/*}}}*/
    207 /*FUNCTION TriaVertexInput::GetVyStrainRate2d{{{1*/
    208 void TriaVertexInput::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){
     207/*FUNCTION TriaP1Input::GetVyStrainRate2d{{{1*/
     208void TriaP1Input::GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){
    209209
    210210        /*Intermediary*/
     
    228228}
    229229/*}}}*/
    230 /*FUNCTION TriaVertexInput::ChangeEnum{{{1*/
    231 void TriaVertexInput::ChangeEnum(int newenumtype){
     230/*FUNCTION TriaP1Input::ChangeEnum{{{1*/
     231void TriaP1Input::ChangeEnum(int newenumtype){
    232232        this->enum_type=newenumtype;
    233233}
    234234/*}}}*/
    235 /*FUNCTION TriaVertexInput::GetInputAverage{{{1*/
    236 void TriaVertexInput::GetInputAverage(double* pvalue){
     235/*FUNCTION TriaP1Input::GetInputAverage{{{1*/
     236void TriaP1Input::GetInputAverage(double* pvalue){
    237237        *pvalue=1./3.*(values[0]+values[1]+values[2]);
    238238}
     
    240240
    241241/*Intermediary*/
    242 /*FUNCTION TriaVertexInput::SquareMin{{{1*/
    243 void TriaVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
     242/*FUNCTION TriaP1Input::SquareMin{{{1*/
     243void TriaP1Input::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
    244244
    245245        int i;
     
    263263}
    264264/*}}}*/
    265 /*FUNCTION TriaVertexInput::ContrainMin{{{1*/
    266 void TriaVertexInput::ConstrainMin(double minimum){
     265/*FUNCTION TriaP1Input::ContrainMin{{{1*/
     266void TriaP1Input::ConstrainMin(double minimum){
    267267       
    268268        int i;
     
    272272}
    273273/*}}}*/
    274 /*FUNCTION TriaVertexInput::InfinityNorm{{{1*/
    275 double TriaVertexInput::InfinityNorm(void){
     274/*FUNCTION TriaP1Input::InfinityNorm{{{1*/
     275double TriaP1Input::InfinityNorm(void){
    276276
    277277        /*Output*/
     
    283283}
    284284/*}}}*/
    285 /*FUNCTION TriaVertexInput::Max{{{1*/
    286 double TriaVertexInput::Max(void){
     285/*FUNCTION TriaP1Input::Max{{{1*/
     286double TriaP1Input::Max(void){
    287287
    288288        const int numnodes=3;
     
    295295}
    296296/*}}}*/
    297 /*FUNCTION TriaVertexInput::MaxAbs{{{1*/
    298 double TriaVertexInput::MaxAbs(void){
     297/*FUNCTION TriaP1Input::MaxAbs{{{1*/
     298double TriaP1Input::MaxAbs(void){
    299299
    300300        const int numnodes=3;
     
    307307}
    308308/*}}}*/
    309 /*FUNCTION TriaVertexInput::Min{{{1*/
    310 double TriaVertexInput::Min(void){
     309/*FUNCTION TriaP1Input::Min{{{1*/
     310double TriaP1Input::Min(void){
    311311
    312312        const int numnodes=3;
     
    319319}
    320320/*}}}*/
    321 /*FUNCTION TriaVertexInput::MinAbs{{{1*/
    322 double TriaVertexInput::MinAbs(void){
     321/*FUNCTION TriaP1Input::MinAbs{{{1*/
     322double TriaP1Input::MinAbs(void){
    323323
    324324        const int numnodes=3;
     
    331331}
    332332/*}}}*/
    333 /*FUNCTION TriaVertexInput::Scale{{{1*/
    334 void TriaVertexInput::Scale(double scale_factor){
     333/*FUNCTION TriaP1Input::Scale{{{1*/
     334void TriaP1Input::Scale(double scale_factor){
    335335       
    336336        int i;
     
    340340}
    341341/*}}}*/
    342 /*FUNCTION TriaVertexInput::ArtificialNoise{{{1*/
    343 void TriaVertexInput::ArtificialNoise(double min,double max){
     342/*FUNCTION TriaP1Input::ArtificialNoise{{{1*/
     343void TriaP1Input::ArtificialNoise(double min,double max){
    344344
    345345        int i;
     
    356356}
    357357/*}}}*/
    358 /*FUNCTION TriaVertexInput::AXPY{{{1*/
    359 void TriaVertexInput::AXPY(Input* xinput,double scalar){
    360 
    361         int i;
    362         const int numnodes=3;
    363         TriaVertexInput*  xtriavertexinput=NULL;
     358/*FUNCTION TriaP1Input::AXPY{{{1*/
     359void TriaP1Input::AXPY(Input* xinput,double scalar){
     360
     361        int i;
     362        const int numnodes=3;
     363        TriaP1Input*  xtriavertexinput=NULL;
    364364
    365365        /*xinput is of the same type, so cast it: */
    366         xtriavertexinput=(TriaVertexInput*)xinput;
     366        xtriavertexinput=(TriaP1Input*)xinput;
    367367
    368368        /*Carry out the AXPY operation depending on type:*/
    369369        switch(xinput->ObjectEnum()){
    370370
    371                 case TriaVertexInputEnum :
     371                case TriaP1InputEnum :
    372372                        for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*xtriavertexinput->values[i];
    373373                        return;
     
    379379}
    380380/*}}}*/
    381 /*FUNCTION TriaVertexInput::Constrain{{{1*/
    382 void TriaVertexInput::Constrain(double cm_min, double cm_max){
     381/*FUNCTION TriaP1Input::Constrain{{{1*/
     382void TriaP1Input::Constrain(double cm_min, double cm_max){
    383383
    384384        int i;
     
    390390}
    391391/*}}}*/
    392 /*FUNCTION TriaVertexInput::GetVectorFromInputs{{{1*/
    393 void TriaVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
     392/*FUNCTION TriaP1Input::GetVectorFromInputs{{{1*/
     393void TriaP1Input::GetVectorFromInputs(Vec vector,int* doflist){
    394394
    395395        const int numvertices=3;
     
    397397
    398398} /*}}}*/
    399 /*FUNCTION TriaVertexInput::GetValuesPtr{{{1*/
    400 void TriaVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
     399/*FUNCTION TriaP1Input::GetValuesPtr{{{1*/
     400void TriaP1Input::GetValuesPtr(double** pvalues,int* pnum_values){
    401401
    402402        *pvalues=this->values;
     
    405405}
    406406/*}}}*/
    407 /*FUNCTION TriaVertexInput::PointwiseMin{{{1*/
    408 Input* TriaVertexInput::PointwiseMin(Input* inputB){
     407/*FUNCTION TriaP1Input::PointwiseMin{{{1*/
     408Input* TriaP1Input::PointwiseMin(Input* inputB){
    409409
    410410        /*Ouput*/
    411         TriaVertexInput* outinput=NULL;
     411        TriaP1Input* outinput=NULL;
    412412
    413413        /*Intermediaries*/
    414414        int               i;
    415         TriaVertexInput *xinputB     = NULL;
     415        TriaP1Input *xinputB     = NULL;
    416416        int               B_numvalues;
    417417        const int         numnodes    = 3;
     
    419419
    420420        /*Check that inputB is of the same type*/
    421         if (inputB->ObjectEnum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
    422         xinputB=(TriaVertexInput*)inputB;
     421        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
     422        xinputB=(TriaP1Input*)inputB;
    423423
    424424        /*Create point wise min*/
     
    429429
    430430        /*Create new Tria vertex input (copy of current input)*/
    431         outinput=new TriaVertexInput(this->enum_type,&minvalues[0]);
     431        outinput=new TriaP1Input(this->enum_type,&minvalues[0]);
    432432
    433433        /*Return output pointer*/
     
    436436}
    437437/*}}}*/
    438 /*FUNCTION TriaVertexInput::PointwiseMax{{{1*/
    439 Input* TriaVertexInput::PointwiseMax(Input* inputB){
     438/*FUNCTION TriaP1Input::PointwiseMax{{{1*/
     439Input* TriaP1Input::PointwiseMax(Input* inputB){
    440440
    441441        /*Ouput*/
    442         TriaVertexInput* outinput=NULL;
     442        TriaP1Input* outinput=NULL;
    443443
    444444        /*Intermediaries*/
    445445        int               i;
    446         TriaVertexInput *xinputB     = NULL;
     446        TriaP1Input *xinputB     = NULL;
    447447        int               B_numvalues;
    448448        const int         numnodes    = 3;
     
    450450
    451451        /*Check that inputB is of the same type*/
    452         if (inputB->ObjectEnum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
    453         xinputB=(TriaVertexInput*)inputB;
     452        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->ObjectEnum()));
     453        xinputB=(TriaP1Input*)inputB;
    454454
    455455        /*Create point wise max*/
     
    460460
    461461        /*Create new Tria vertex input (copy of current input)*/
    462         outinput=new TriaVertexInput(this->enum_type,&maxvalues[0]);
     462        outinput=new TriaP1Input(this->enum_type,&maxvalues[0]);
    463463
    464464        /*Return output pointer*/
     
    467467}
    468468/*}}}*/
    469 /*FUNCTION TriaVertexInput::Configure{{{1*/
    470 void TriaVertexInput::Configure(Parameters* parameters){
     469/*FUNCTION TriaP1Input::Configure{{{1*/
     470void TriaP1Input::Configure(Parameters* parameters){
    471471        /*do nothing: */
    472472}
  • issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h

    r11288 r11291  
    1 /*! \file TriaVertexInput.h
    2  *  \brief: header file for triavertexinput object
     1/*! \file TriaP1Input.h
     2 *  \brief: header file for TriaP1Input object
    33 */
    44
    55
    6 #ifndef _TRIAVERTEXINPUT_H_
    7 #define _TRIAVERTEXINPUT_H_
     6#ifndef _TRIAP1INPUT_H_
     7#define _TRIAP1INPUT_H_
    88
    99/*Headers:*/
     
    1414/*}}}*/
    1515
    16 class TriaVertexInput: public Input,public TriaRef{
     16class TriaP1Input: public Input,public TriaRef{
    1717
    1818        public:
     
    2121                double values[3];
    2222
    23                 /*TriaVertexInput constructors, destructors: {{{1*/
    24                 TriaVertexInput();
    25                 TriaVertexInput(int enum_type,double* values);
    26                 ~TriaVertexInput();
     23                /*TriaP1Input constructors, destructors: {{{1*/
     24                TriaP1Input();
     25                TriaP1Input(int enum_type,double* values);
     26                ~TriaP1Input();
    2727                /*}}}*/
    2828                /*Object virtual functions definitions:{{{1 */
     
    3939                Object* copy();
    4040                /*}}}*/
    41                 /*TriaVertexInput management: {{{1*/
     41                /*TriaP1Input management: {{{1*/
    4242                int   InstanceEnum();
    4343                Input* SpawnTriaInput(int* indices);
     
    8787
    8888};
    89 #endif  /* _TRIAVERTEXINPUT_H */
     89#endif  /* _TRIAP1INPUT_H */
  • issm/trunk-jpl/src/c/objects/Materials/Matice.cpp

    r10970 r11291  
    552552                                        double values[3];
    553553                                        for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->nodes[i]->GetVertexDof()];
    554                                         this->inputs->AddInput(new TriaVertexInput(name,values));
     554                                        this->inputs->AddInput(new TriaP1Input(name,values));
    555555                                        return;
    556556
     
    594594                                        double values[3];
    595595                                        for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->nodes[i]->GetSidList()]; //use sid list, to index into serial oriented vector
    596                                         this->inputs->AddInput(new TriaVertexInput(name,values));
     596                                        this->inputs->AddInput(new TriaP1Input(name,values));
    597597                                        /*Special case for rheology B in 2D: Pourave land for this solution{{{2*/
    598598                                        if(name==MaterialsRheologyBEnum){
     
    607607                                                if(dim==2){
    608608                                                        /*Dupliacte rheology input: */
    609                                                         this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,values));
     609                                                        this->inputs->AddInput(new TriaP1Input(MaterialsRheologyBbarEnum,values));
    610610                                                }
    611611                                        }
     
    683683                if (iomodel->Data(MaterialsRheologyBEnum)) {
    684684                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
    685                         this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyBbarEnum,nodeinputs));
     685                        this->inputs->AddInput(new TriaP1Input(MaterialsRheologyBbarEnum,nodeinputs));
    686686                }
    687687
     
    689689                if (iomodel->Data(MaterialsRheologyNEnum)) {
    690690                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
    691                         this->inputs->AddInput(new TriaVertexInput(MaterialsRheologyNEnum,nodeinputs));
     691                        this->inputs->AddInput(new TriaP1Input(MaterialsRheologyNEnum,nodeinputs));
    692692                }
    693693
     
    703703                                                        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];
    704704                                                        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];
    705                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     705                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    706706                                                }
    707707                                                break;
     
    725725                if (iomodel->Data(MaterialsRheologyBEnum)) {
    726726                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
    727                         this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyBEnum,nodeinputs));
     727                        this->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,nodeinputs));
    728728                }
    729729
     
    731731                if (iomodel->Data(MaterialsRheologyNEnum)) {
    732732                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
    733                         this->inputs->AddInput(new PentaVertexInput(MaterialsRheologyNEnum,nodeinputs));
     733                        this->inputs->AddInput(new PentaP1Input(MaterialsRheologyNEnum,nodeinputs));
    734734                }
    735735
     
    745745                                                        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];
    746746                                                        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];
    747                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaVertexInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     747                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    748748                                                }
    749749                                                break;
  • issm/trunk-jpl/src/c/objects/objects.h

    r10840 r11291  
    8888#include "./Inputs/DoubleInput.h"
    8989#include "./Inputs/IntInput.h"
    90 #include "./Inputs/PentaVertexInput.h"
    91 #include "./Inputs/TriaVertexInput.h"
     90#include "./Inputs/PentaP1Input.h"
     91#include "./Inputs/TriaP1Input.h"
    9292#include "./Inputs/ControlInput.h"
    9393#include "./Inputs/DatasetInput.h"
Note: See TracChangeset for help on using the changeset viewer.