Changeset 17275


Ignore:
Timestamp:
02/13/14 14:46:49 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removing materials inputs, that are now in element

Location:
issm/trunk-jpl/src/c
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp

    r17212 r17275  
    270270        element->FindParam(&dt,TimesteppingTimeStepEnum);
    271271        this->CreateDamageFInput(element);
    272         Input* damaged_input = element->GetMaterialInput(DamageDbarEnum); _assert_(damaged_input);
    273         Input* damagef_input = element->GetMaterialInput(DamageFEnum);    _assert_(damagef_input);
     272        Input* damaged_input = element->GetInput(DamageDbarEnum); _assert_(damaged_input);
     273        Input* damagef_input = element->GetInput(DamageFEnum);    _assert_(damagef_input);
    274274
    275275        /* Start  looping on the number of gaussian points: */
    … …  
    378378
    379379        /*Get all inputs and parameters*/
    380         element->AddMaterialInput(DamageDbarEnum,values,P1Enum);
     380        element->AddInput(DamageDbarEnum,values,P1Enum);
    381381
    382382        /*Free ressources:*/
    … …  
    416416        Input* sigma_xy_input  = element->GetInput(StressTensorxyEnum);     _assert_(sigma_xy_input);
    417417        Input* sigma_yy_input  = element->GetInput(StressTensoryyEnum);     _assert_(sigma_yy_input);
    418         Input* damage_input    = element->GetMaterialInput(DamageDbarEnum); _assert_(damage_input);
     418        Input* damage_input    = element->GetInput(DamageDbarEnum); _assert_(damage_input);
    419419
    420420        /*Damage evolution z mapping: */
    … …  
    442442
    443443        /*Add input*/
    444         element->AddMaterialInput(DamageFEnum,f,P1Enum);
     444        element->AddInput(DamageFEnum,f,P1Enum);
    445445       
    446446        /*Clean up and return*/

  • issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp

    r17212 r17275  
    790790                        case PatersonEnum:
    791791                                for(i=0;i<numnodes;i++) B[i]=Paterson(temperature[i]);
    792                                 element->AddMaterialInput(MaterialsRheologyBEnum,&B[0],P1Enum);
     792                                element->AddInput(MaterialsRheologyBEnum,&B[0],P1Enum);
    793793                                break;
    794794                        case ArrheniusEnum:
    795795                                element->GetVerticesCoordinates(&xyz_list);
    796796                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(temperature[i],surface[i]-xyz_list[i*3+2],element->GetMaterialParameter(MaterialsRheologyNEnum));
    797                                 element->AddMaterialInput(MaterialsRheologyBEnum,&B[0],P1Enum);
     797                                element->AddInput(MaterialsRheologyBEnum,&B[0],P1Enum);
    798798                                break;
    799799                        case LliboutryDuvalEnum:
    800800                                for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],element->GetMaterialParameter(MaterialsRheologyNEnum),element->GetMaterialParameter(MaterialsBetaEnum),element->GetMaterialParameter(ConstantsReferencetemperatureEnum),element->GetMaterialParameter(MaterialsHeatcapacityEnum),element->GetMaterialParameter(MaterialsLatentheatEnum));
    801                                 element->AddMaterialInput(MaterialsRheologyBEnum,&B[0],P1Enum);
     801                                element->AddInput(MaterialsRheologyBEnum,&B[0],P1Enum);
    802802                                break;
    803803                        default: _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

    r17261 r17275  
    10441044void StressbalanceAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    10451045        /*Default, do nothing*/
    1046         _printf0_("   Updating active and non-active nodes for StressbalanceAnalysis \n");
     1046        //_printf0_("   Updating active and non-active nodes for StressbalanceAnalysis \n");
    10471047//      SetActiveNodesLSMx(femmodel->elements);
    10481048        return;

  • issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp

    r17212 r17275  
    659659                        case PatersonEnum:
    660660                                for(i=0;i<numnodes;i++) B[i]=Paterson(values[i]);
    661                                 element->AddMaterialInput(MaterialsRheologyBEnum,&B[0],P1Enum);
     661                                element->AddInput(MaterialsRheologyBEnum,&B[0],P1Enum);
    662662                                break;
    663663                        case ArrheniusEnum:{
    664664                                element->GetVerticesCoordinates(&xyz_list);
    665665                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(values[i],surface[i]-xyz_list[i*3+2],element->GetMaterialParameter(MaterialsRheologyNEnum));
    666                                 element->AddMaterialInput(MaterialsRheologyBEnum,&B[0],P1Enum);
     666                                element->AddInput(MaterialsRheologyBEnum,&B[0],P1Enum);
    667667                                break;
    668668                                }

  • issm/trunk-jpl/src/c/classes/Elements/Element.cpp

    r17258 r17275  
    155155                        return this->matpar->GetMaterialParameter(enum_in);
    156156        }
    157 }
    158 /*}}}*/
     157}/*}}}*/
    159158void Element::GetPhi(IssmDouble* phi, IssmDouble*  epsilon, IssmDouble viscosity){/*{{{*/
    160159        /*Compute deformational heating from epsilon and viscosity */
    … …  
    227226        return shelf;
    228227}/*}}}*/
     228bool Element::IsInput(int name){/*{{{*/
     229        if (
     230                                name==ThicknessEnum ||
     231                                name==SurfaceEnum ||
     232                                name==BedEnum ||
     233                                name==BathymetryEnum ||
     234                                name==SurfaceSlopeXEnum ||
     235                                name==SurfaceSlopeYEnum ||
     236                                name==SurfaceforcingsMassBalanceEnum ||
     237                                name==BasalforcingsMeltingRateEnum ||
     238                                name==BasalforcingsGeothermalfluxEnum ||
     239                                name==SurfaceAreaEnum||
     240                                name==DamageDEnum ||
     241                                name==DamageDbarEnum ||
     242                                name==PressureEnum ||
     243                                name==VxEnum ||
     244                                name==VyEnum ||
     245                                name==VzEnum ||
     246                                name==VxMeshEnum ||
     247                                name==VyMeshEnum ||
     248                                name==VzMeshEnum ||
     249                                name==InversionVxObsEnum ||
     250                                name==InversionVyObsEnum ||
     251                                name==InversionVzObsEnum ||
     252                                name==TemperatureEnum ||
     253                                name==EnthalpyEnum ||
     254                                name==EnthalpyPicardEnum ||
     255                                name==WaterfractionEnum||
     256                                name==WatercolumnEnum ||
     257                                name==FrictionCoefficientEnum ||
     258                                name==MaskGroundediceLevelsetEnum ||
     259                                name==MaskIceLevelsetEnum ||
     260                                name==IceMaskNodeActivationEnum ||
     261                                name==LevelsetfunctionSlopeXEnum ||
     262                                name==LevelsetfunctionSlopeYEnum ||
     263                                name==GradientEnum ||
     264                                name==OldGradientEnum  ||
     265                                name==ConvergedEnum ||
     266                                name==QmuVxEnum ||
     267                                name==QmuVyEnum ||
     268                                name==QmuVzEnum ||
     269                                name==QmuVxMeshEnum ||
     270                                name==QmuVyMeshEnum ||
     271                                name==QmuVzMeshEnum ||
     272                                name==QmuPressureEnum ||
     273                                name==QmuBedEnum ||
     274                                name==QmuThicknessEnum ||
     275                                name==QmuSurfaceEnum ||
     276                                name==QmuTemperatureEnum ||
     277                                name==QmuMeltingEnum ||
     278                                name==QmuMaskGroundediceLevelsetEnum ||
     279                                name==QmuMaskIceLevelsetEnum ||
     280                                name==QmuMaterialsRheologyBEnum ||
     281                                name==MaterialsRheologyBEnum ||
     282                                name==MaterialsRheologyBbarEnum ||
     283                                name==MaterialsRheologyNEnum ||
     284                                name==GiaWEnum ||
     285                                name==GiadWdtEnum ||
     286                                name==SedimentHeadEnum ||
     287                                name==EplHeadEnum ||
     288                                name==SedimentHeadOldEnum ||
     289                                name==EplHeadOldEnum ||
     290                                name==HydrologydcEplThicknessOldEnum ||
     291                                name==HydrologydcEplInitialThicknessEnum ||
     292                                name==HydrologydcEplThicknessEnum ||
     293                                name==HydrologydcMaskEplactiveNodeEnum ||
     294                                name==MeshVertexonbedEnum ||
     295                                name==WaterTransferEnum
     296
     297                                ) {
     298                                        return true;
     299                                }
     300        else return false;
     301}
     302/*}}}*/
    229303void Element::ResultInterpolation(int* pinterpolation,int* pnodesperelement,int output_enum){/*{{{*/
    230304

  • issm/trunk-jpl/src/c/classes/Elements/Element.h

    r17257 r17275  
    6565                void       GetVerticesSidList(int* sidlist);
    6666                void       GetVerticesConnectivityList(int* connectivitylist);
     67                bool         IsInput(int name);
    6768                bool       IsFloating();
    6869                void       ResultInterpolation(int* pinterpolation,int*nodesperelement,int output_enum);
    … …  
    106107                virtual void       AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    107108                virtual void       AddInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    108                 virtual void       AddMaterialInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    109109                virtual IssmDouble CharacteristicLength(void)=0;
    110110                virtual void       Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters)=0;
    … …  
    164164                virtual void   GetInputListOnVertices(IssmDouble* pvalue,int enumtype)=0;
    165165                virtual void   GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue)=0;
    166                 virtual Input* GetMaterialInput(int inputenum)=0;
    167166                virtual void   GetInputValue(IssmDouble* pvalue,Node* node,int enumtype)=0;
    168167                virtual void   GetInputValue(bool* pvalue,int enum_type)=0;
    … …  
    177176                virtual IssmDouble GetYcoord(Gauss* gauss)=0;
    178177                virtual IssmDouble GetZcoord(Gauss* gauss)=0;
    179                 virtual void   GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype)=0;
    180178                virtual int    GetElementType(void)=0;
    181179
    182180                virtual IssmDouble SurfaceArea(void)=0;
    183                 virtual void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum)=0;
     181                virtual void   InputDepthAverageAtBase(int enum_type,int average_enum_type)=0;
    184182                virtual void   InputChangeName(int enum_type,int enum_type_old)=0;
    185183                virtual void   ComputeBasalStress(Vector<IssmDouble>* sigma_b)=0;

  • issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r17274 r17275  
    139139                else _error_("not implemented yet");
    140140        }
    141 }
    142 /*}}}*/
    143 /*FUNCTION Penta::AddMaterialInput{{{*/
    144 void  Penta::AddMaterialInput(int input_enum,IssmDouble* values, int interpolation_enum){
    145 
    146         _assert_(this->material);
    147         this->material->inputs->AddInput(new PentaInput(input_enum,values,interpolation_enum));
    148141}
    149142/*}}}*/
    … …  
    465458        this->inputs->AddInput(NewPrecipitationInput);
    466459
    467         this->InputExtrude(SurfaceforcingsMonthlytemperaturesEnum,ElementEnum);
    468         this->InputExtrude(SurfaceforcingsPrecipitationEnum,ElementEnum);
     460        this->InputExtrude(SurfaceforcingsMonthlytemperaturesEnum);
     461        this->InputExtrude(SurfaceforcingsPrecipitationEnum);
    469462
    470463        /*clean-up*/
    … …  
    974967}
    975968/*}}}*/
    976 /*FUNCTION Penta::GetMaterialInput(int inputenum) {{{*/
    977 Input* Penta::GetMaterialInput(int inputenum){
    978         return this->material->inputs->GetInput(inputenum);
    979 }
    980 /*}}}*/
    981969/*FUNCTION Penta::GetInputListOnVertices(IssmDouble* pvalue,int enumtype) {{{*/
    982970void Penta::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){
    … …  
    11381126
    11391127}/*}}}*/
    1140 /*FUNCTION Penta::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype) {{{*/
    1141 void Penta::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){
    1142 
    1143         Input* input=this->material->inputs->GetInput(enumtype);
    1144         if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    1145 
    1146         GaussPenta* gauss=new GaussPenta();
    1147         gauss->GaussVertex(this->GetNodeIndex(node));
    1148 
    1149         input->GetInputValue(pvalue,gauss);
    1150         delete gauss;
    1151 }
    1152 /*}}}*/
    11531128/*FUNCTION Penta::NormalSection{{{*/
    11541129void Penta::NormalSection(IssmDouble* normal,IssmDouble* xyz_list){
    … …  
    15001475/*}}}*/
    15011476/*FUNCTION Penta::InputDepthAverageAtBase{{{*/
    1502 void  Penta::InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum){
     1477void  Penta::InputDepthAverageAtBase(int enum_type,int average_enum_type){
    15031478
    15041479        int  step,i;
    … …  
    15281503
    15291504                /*Step1: Get original input (to be depth avegaged): */
    1530                 if (object_enum==MeshElementsEnum)
    1531                  original_input=(Input*)penta->inputs->GetInput(enum_type);
    1532                 else if (object_enum==MaterialsEnum)
    1533                  original_input=(Input*)penta->material->inputs->GetInput(enum_type);
    1534                 else
    1535                  _error_("object " << EnumToStringx(object_enum) << " not supported yet");
     1505                original_input=(Input*)penta->inputs->GetInput(enum_type);
    15361506                if(!original_input) _error_("could not find input with enum " << EnumToStringx(enum_type));
    15371507
    … …  
    15891559
    15901560        /*Finally, add to inputs*/
    1591         if (object_enum==MeshElementsEnum)
    1592          this->inputs->AddInput((Input*)depth_averaged_input);
    1593         else if (object_enum==MaterialsEnum)
    1594          this->material->inputs->AddInput((Input*)depth_averaged_input);
    1595         else
    1596          _error_("object " << EnumToStringx(object_enum) << " not supported yet");
     1561        this->inputs->AddInput((Input*)depth_averaged_input);
    15971562}
    15981563/*}}}*/
    … …  
    16061571/*}}}*/
    16071572/*FUNCTION Penta::InputExtrude {{{*/
    1608 void  Penta::InputExtrude(int enum_type,int object_type){
     1573void  Penta::InputExtrude(int enum_type){
    16091574
    16101575        int     i,num_inputs;
    … …  
    16171582
    16181583        /*Step1: Get and Extrude original input: */
    1619         if(object_type==ElementEnum){
    1620                 num_inputs=1;
    1621                 base_inputs=xNew<Input*>(num_inputs);
    1622                 base_inputs[0]=(Input*)this->inputs->GetInput(enum_type);
    1623         }
    1624         else if(object_type==MaterialsEnum){
    1625                 num_inputs=1;
    1626                 base_inputs=xNew<Input*>(num_inputs);
    1627                 base_inputs[0]=(Input*)material->inputs->GetInput(enum_type);
    1628         }
    1629         else{
    1630                 _error_("object of type " << EnumToStringx(object_type) << " not supported yet");
    1631         }
     1584        num_inputs=1;
     1585        base_inputs=xNew<Input*>(num_inputs);
     1586        base_inputs[0]=(Input*)this->inputs->GetInput(enum_type);
    16321587        for(i=0;i<num_inputs;i++){
    1633                 if(!base_inputs[i]) _error_("could not find input with enum " << EnumToStringx(enum_type) << " in object " << EnumToStringx(object_type));
     1588                if(!base_inputs[i]) _error_("could not find input with enum " << EnumToStringx(enum_type));
    16341589                base_inputs[i]->Extrude();
    16351590        }
    … …  
    16481603                for(i=0;i<num_inputs;i++){
    16491604                        copy=(Input*)base_inputs[i]->copy();
    1650                         if (object_type==ElementEnum){
    1651                                 penta->inputs->AddInput((Input*)copy);
    1652                         }
    1653                         else if(object_type==MaterialsEnum){
    1654                                 penta->material->inputs->AddInput((Input*)copy);
    1655                         }
    1656                         else{
    1657                                 _error_("object of type " << EnumToStringx(object_type) << " not supported yet");
    1658                         }
     1605                        penta->inputs->AddInput((Input*)copy);
    16591606                }
    16601607
    … …  
    17741721                                        }
    17751722                                        break;
    1776                                 /*Material will take care of it*/
    1777                                 case MaterialsRheologyBbarEnum: break;
    1778                                 case DamageDbarEnum:break;
     1723                                case MaterialsRheologyBbarEnum:
     1724                                        if(iomodel->Data(MaterialsRheologyBEnum)){
     1725                                                for(j=0;j<6;j++) nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[penta_vertex_ids[j]-1];
     1726                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
     1727                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
     1728                                                this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1729                                        }
     1730                                        break;
     1731                                case DamageDbarEnum:
     1732                                        if(iomodel->Data(DamageDEnum)){
     1733                                                for(j=0;j<6;j++) nodeinputs[j]=iomodel->Data(DamageDEnum)[penta_vertex_ids[j]-1];
     1734                                                for(j=0;j<6;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
     1735                                                for(j=0;j<6;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(penta_vertex_ids[j]-1)*num_control_type+i];
     1736                                                this->inputs->AddInput(new ControlInput(DamageDEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1737                                        }
     1738                                        break;
    17791739                                default:
    17801740                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
    … …  
    19441904        inputs->GetInputValue(&onsurface,MeshElementonsurfaceEnum);
    19451905        return onsurface;
    1946 }
    1947 /*}}}*/
    1948 /*FUNCTION Penta::IsInput{{{*/
    1949 bool Penta::IsInput(int name){
    1950         if (
    1951                                 name==ThicknessEnum ||
    1952                                 name==SurfaceEnum ||
    1953                                 name==BedEnum ||
    1954                                 name==BathymetryEnum ||
    1955                                 name==SurfaceSlopeXEnum ||
    1956                                 name==SurfaceSlopeYEnum ||
    1957                                 name==SurfaceforcingsMassBalanceEnum ||
    1958                                 name==BasalforcingsMeltingRateEnum ||
    1959                                 name==BasalforcingsGeothermalfluxEnum ||
    1960                                 name==SurfaceAreaEnum||
    1961                                 name==PressureEnum ||
    1962                                 name==VxEnum ||
    1963                                 name==VyEnum ||
    1964                                 name==VzEnum ||
    1965                                 name==VxMeshEnum ||
    1966                                 name==VyMeshEnum ||
    1967                                 name==VzMeshEnum ||
    1968                                 name==InversionVxObsEnum ||
    1969                                 name==InversionVyObsEnum ||
    1970                                 name==InversionVzObsEnum ||
    1971                                 name==TemperatureEnum ||
    1972                                 name==EnthalpyEnum ||
    1973                                 name==EnthalpyPicardEnum ||
    1974                                 name==WaterfractionEnum||
    1975                                 name==FrictionCoefficientEnum ||
    1976                                 name==MaskGroundediceLevelsetEnum ||
    1977                                 name==MaskIceLevelsetEnum ||
    1978                                 name==IceMaskNodeActivationEnum ||
    1979                                 name==LevelsetfunctionSlopeXEnum ||
    1980                                 name==LevelsetfunctionSlopeYEnum ||
    1981                                 name==GradientEnum ||
    1982                                 name==OldGradientEnum  ||
    1983                                 name==ConvergedEnum ||
    1984                                 name==QmuVxEnum ||
    1985                                 name==QmuVyEnum ||
    1986                                 name==QmuVzEnum ||
    1987                                 name==QmuVxMeshEnum ||
    1988                                 name==QmuVyMeshEnum ||
    1989                                 name==QmuVzMeshEnum ||
    1990                                 name==QmuPressureEnum ||
    1991                                 name==QmuBedEnum ||
    1992                                 name==QmuThicknessEnum ||
    1993                                 name==QmuSurfaceEnum ||
    1994                                 name==QmuTemperatureEnum ||
    1995                                 name==QmuMeltingEnum ||
    1996                                 name==QmuMaskGroundediceLevelsetEnum ||
    1997                                 name==QmuMaskIceLevelsetEnum ||
    1998                                 name==GiaWEnum ||
    1999                                 name==GiadWdtEnum ||
    2000                                 name==SedimentHeadEnum ||
    2001                                 name==EplHeadEnum ||
    2002                                 name==SedimentHeadOldEnum ||
    2003                                 name==EplHeadOldEnum ||
    2004                                 name==HydrologydcEplThicknessOldEnum ||
    2005                                 name==HydrologydcEplInitialThicknessEnum ||
    2006                                 name==HydrologydcEplThicknessEnum ||
    2007                                 name==HydrologydcMaskEplactiveNodeEnum ||
    2008                                 name==WaterTransferEnum
    2009 
    2010                                 ) {
    2011                 return true;
    2012         }
    2013         else return false;
    20141906}
    20151907/*}}}*/
    … …  
    23542246   this->inputs->AddInput(new PentaInput(SurfaceforcingsMassBalanceEnum,&agd[0],P1Enum));
    23552247   //this->inputs->AddInput(new PentaVertexInput(ThermalSpcTemperatureEnum,&Tsurf[0]));
    2356    this->InputExtrude(SurfaceforcingsMassBalanceEnum,ElementEnum);
     2248   this->InputExtrude(SurfaceforcingsMassBalanceEnum);
    23572249
    23582250        /*clean-up*/
    … …  
    25792471
    25802472        /*Spawn material*/
    2581         tria->material=(Material*)this->material->copy();
    2582         delete tria->material->inputs;
    2583         tria->material->inputs=(Inputs*)this->material->inputs->SpawnTriaInputs(location);
     2473        tria->material=(Material*)this->material->copy(tria);
    25842474
    25852475        /*recover nodes, material and matpar: */
    … …  
    25972487        _assert_(this->IsOnBed());
    25982488
    2599         this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum,MaterialsEnum);
    2600         this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum,MaterialsEnum);
     2489        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     2490        this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    26012491        if(this->inputs->GetInput(VxEnum)) this->InputDepthAverageAtBase(VxEnum,VxAverageEnum);
    26022492        if(this->inputs->GetInput(VyEnum)) this->InputDepthAverageAtBase(VyEnum,VyAverageEnum);
    26032493        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    2604         this->material->inputs->DeleteInput(MaterialsRheologyBbarEnum);
    2605         this->material->inputs->DeleteInput(DamageDbarEnum);
     2494        this->inputs->DeleteInput(MaterialsRheologyBbarEnum);
     2495        this->inputs->DeleteInput(DamageDbarEnum);
    26062496        this->inputs->DeleteInput(VxAverageEnum);
    26072497        this->inputs->DeleteInput(VyAverageEnum);
    … …  
    34913381        if(enum_type==MaterialsRheologyBbarEnum){
    34923382                if(!IsOnBed()) return;
    3493                 input=(Input*)material->inputs->GetInput(MaterialsRheologyBEnum);
     3383                input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    34943384        }
    34953385        else if(enum_type==DamageDbarEnum){
    34963386                if(!IsOnBed()) return;
    3497                 input=(Input*)material->inputs->GetInput(DamageDEnum);
     3387                input=(Input*)inputs->GetInput(DamageDEnum);
    34983388        }
    34993389        else{
    … …  
    35133403
    35143404        if(enum_type==MaterialsRheologyBbarEnum){
    3515                 input=(Input*)material->inputs->GetInput(MaterialsRheologyBEnum);
     3405                input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    35163406        }
    35173407        else if(enum_type==DamageDbarEnum){
    3518                 input=(Input*)material->inputs->GetInput(DamageDEnum);
     3408                input=(Input*)inputs->GetInput(DamageDEnum);
    35193409        }
    35203410        else{
    … …  
    35353425
    35363426        if(enum_type==MaterialsRheologyBbarEnum){
    3537                 input=(Input*)material->inputs->GetInput(MaterialsRheologyBEnum);
     3427                input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    35383428        }
    35393429        else if(enum_type==DamageDbarEnum){
    3540                 input=(Input*)material->inputs->GetInput(DamageDEnum);
     3430                input=(Input*)inputs->GetInput(DamageDEnum);
    35413431        }
    35423432        else{
    … …  
    35583448
    35593449        if(control_enum==MaterialsRheologyBbarEnum){
    3560                 input=(Input*)material->inputs->GetInput(MaterialsRheologyBEnum);
     3450                input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    35613451        }
    35623452        else if(control_enum==DamageDbarEnum){
    3563                 input=(Input*)material->inputs->GetInput(DamageDEnum);
     3453                input=(Input*)inputs->GetInput(DamageDEnum);
    35643454        }
    35653455        else{
    … …  
    38833773
    38843774        /*Depth Average B*/
    3885         this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum,MaterialsEnum);
    3886         this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum,MaterialsEnum);
     3775        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     3776        this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    38873777
    38883778        /*Collapse element to the base*/
    … …  
    38923782
    38933783        /*delete Average B*/
    3894         this->material->inputs->DeleteInput(MaterialsRheologyBbarEnum);
    3895         this->material->inputs->DeleteInput(DamageDbarEnum);
     3784        this->inputs->DeleteInput(MaterialsRheologyBbarEnum);
     3785        this->inputs->DeleteInput(DamageDbarEnum);
    38963786
    38973787} /*}}}*/
    … …  
    39033793
    39043794        /*Depth Average B and D*/
    3905         this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum,MaterialsEnum);
    3906         this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum,MaterialsEnum);
     3795        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     3796        this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    39073797
    39083798        /*Collapse element to the base*/
    … …  
    39123802
    39133803        /*delete Average B*/
    3914         this->material->inputs->DeleteInput(MaterialsRheologyBbarEnum);
    3915         this->material->inputs->DeleteInput(DamageDbarEnum);
     3804        this->inputs->DeleteInput(MaterialsRheologyBbarEnum);
     3805        this->inputs->DeleteInput(DamageDbarEnum);
    39163806} /*}}}*/
    39173807/*FUNCTION Penta::GradjBbarFS {{{*/
    … …  
    39223812
    39233813        /*Depth Average B and D*/
    3924         this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum,MaterialsEnum);
    3925         this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum,MaterialsEnum);
     3814        this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     3815        this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    39263816
    39273817        /*Collapse element to the base*/
    … …  
    39313821
    39323822        /*delete Average B*/
    3933         this->material->inputs->DeleteInput(MaterialsRheologyBbarEnum);
    3934         this->material->inputs->DeleteInput(DamageDbarEnum);
     3823        this->inputs->DeleteInput(MaterialsRheologyBbarEnum);
     3824        this->inputs->DeleteInput(DamageDbarEnum);
    39353825} /*}}}*/
    39363826/*FUNCTION Penta::InputControlUpdate{{{*/
    … …  
    39503840                if(control_type[i]==MaterialsRheologyBbarEnum){
    39513841                        if (!IsOnBed()) goto cleanup_and_return;
    3952                         input=(Input*)material->inputs->GetInput(MaterialsRheologyBEnum); _assert_(input);
     3842                        input=(Input*)this->inputs->GetInput(MaterialsRheologyBEnum); _assert_(input);
    39533843                }
    39543844                else if(control_type[i]==DamageDbarEnum){
    39553845                        if (!IsOnBed()) goto cleanup_and_return;
    3956                         input=(Input*)material->inputs->GetInput(DamageDEnum); _assert_(input);
     3846                        input=(Input*)this->inputs->GetInput(DamageDEnum); _assert_(input);
    39573847                }
    39583848                else{
    39593849                        input=(Input*)this->inputs->GetInput(control_type[i]); _assert_(input);
    39603850                }
    3961 
    3962                 if (input->ObjectEnum()!=ControlInputEnum) _error_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
     3851                if(input->ObjectEnum()!=ControlInputEnum) _error_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
    39633852
    39643853                ((ControlInput*)input)->UpdateValue(scalar);
    … …  
    39673856
    39683857                if(control_type[i]==MaterialsRheologyBbarEnum){
    3969                         this->InputExtrude(MaterialsRheologyBEnum,MaterialsEnum);
     3858                        this->InputExtrude(MaterialsRheologyBEnum);
    39703859                }
    39713860                else if(control_type[i]==DamageDbarEnum){
    3972                         this->InputExtrude(DamageDEnum,MaterialsEnum);
     3861                        this->InputExtrude(DamageDEnum);
    39733862                }
    39743863        }
    … …  
    42644153        }
    42654154        new_input = new PentaInput(control_enum,values,P1Enum);
    4266 
    4267         if(control_enum==MaterialsRheologyBbarEnum){
    4268                 input=(Input*)material->inputs->GetInput(control_enum); _assert_(input);
    4269         }
    4270         else{
    4271                 input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    4272         }
     4155        input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    42734156
    42744157        if (input->ObjectEnum()!=ControlInputEnum){
    … …  
    43694252                                        this->inputs->AddInput(new PentaInput(BedEnum,bed,P1Enum));
    43704253                                        this->inputs->AddInput(new PentaInput(SurfaceEnum,surface,P1Enum));
    4371 
    43724254                                        break;
     4255
    43734256                                default:
    43744257                                        this->inputs->AddInput(new PentaInput(name,values,P1Enum));
    … …  
    46564539        }
    46574540        this->inputs->AddInput(new PentaInput(MaskGroundediceLevelsetEnum,&phi[0],P1Enum));
    4658         this->InputExtrude(MaskGroundediceLevelsetEnum,ElementEnum);
     4541        this->InputExtrude(MaskGroundediceLevelsetEnum);
    46594542
    46604543        /*SubelementMigrationEnum: if one grounded, all grounded*/
    … …  
    46884571
    46894572        /*Extrude inputs*/
    4690         this->InputExtrude(SurfaceEnum,ElementEnum);
    4691         this->InputExtrude(BedEnum,ElementEnum);
     4573        this->InputExtrude(SurfaceEnum);
     4574        this->InputExtrude(BedEnum);
    46924575}
    46934576/*}}}*/

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r17267 r17275  
    105105                int    Sid();
    106106                void   InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    107                 void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
     107                void   InputDepthAverageAtBase(int enum_type,int average_enum_type);
    108108                void   InputDuplicate(int original_enum,int new_enum);
    109109                void   InputScale(int enum_type,IssmDouble scale_factor);
    … …  
    195195                void           AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum);
    196196                void           AddInput(int input_enum, IssmDouble* values, int interpolation_enum);
    197                 void           AddMaterialInput(int input_enum, IssmDouble* values, int interpolation_enum);
    198197                void             NormalBase(IssmDouble* bed_normal, IssmDouble* xyz_list);
    199198                void           NormalSection(IssmDouble* normal,IssmDouble* xyz_list);
    … …  
    206205                void             GetVertexPidList(int* doflist);
    207206                int            GetElementType(void);
    208                 Input*         GetMaterialInput(int inputenum);
    209207                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    210208                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    … …  
    216214                void           GetInputValue(IssmDouble* pvalue,int enum_type);
    217215                void           GetInputValue(IssmDouble* pvalue,Gauss* gauss,int enum_type);
    218                 void           GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    219216                Node*          GetNode(int node_number);
    220217                void           InputChangeName(int input_enum, int enum_type_old);
    221                 void             InputExtrude(int enum_type,int object_type);
     218                void             InputExtrude(int enum_type);
    222219                void           InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type);
    223220                void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);
    224                 bool             IsInput(int name);
    225221                bool             IsOnSurface(void);
    226222                bool             IsOnBed(void);

  • issm/trunk-jpl/src/c/classes/Elements/Seg.h

    r17257 r17275  
    6161                void        AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum){_error_("not implemented yet");};
    6262                void        AddInput(int input_enum, IssmDouble* values, int interpolation_enum){_error_("not implemented yet");};
    63                 void        AddMaterialInput(int input_enum, IssmDouble* values, int interpolation_enum){_error_("not implemented yet");};
    6463                IssmDouble  CharacteristicLength(void);
    6564                void        ComputeBasalStress(Vector<IssmDouble>* sigma_b){_error_("not implemented yet");};
    … …  
    130129                void        GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating){_error_("not implemented yet");};
    131130                IssmDouble  GetGroundedPortion(IssmDouble* xyz_list){_error_("not implemented yet");};
    132                 Input*      GetMaterialInput(int inputenum){_error_("not implemented yet");};
    133131                void        GetInputListOnVertices(IssmDouble* pvalue,int enumtype){_error_("not implemented yet");};
    134132                void        GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){_error_("not implemented yet");};
    … …  
    138136                void        GetInputValue(IssmDouble* pvalue,int enum_type){_error_("not implemented yet");};
    139137                void        GetInputValue(IssmDouble* pvalue,Gauss* gauss,int enum_type){_error_("not implemented yet");};
    140                 void        GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
    141138                Node*       GetNode(int node_number){_error_("Not implemented");};
    142139                IssmDouble  GetXcoord(Gauss* gauss){_error_("Not implemented");};
    … …  
    173170                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum){_error_("not implemented yet");};
    174171                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){_error_("not implemented yet");};
    175                 void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum){_error_("not implemented yet");};
     172                void        InputDepthAverageAtBase(int enum_type,int average_enum_type){_error_("not implemented yet");};
    176173                void        InputDuplicate(int original_enum,int new_enum){_error_("not implemented yet");};
    177174                void        InputScale(int enum_type,IssmDouble scale_factor){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r17274 r17275  
    178178}
    179179/*}}}*/
    180 /*FUNCTION Tria::AddMaterialInput{{{*/
    181 void  Tria::AddMaterialInput(int input_enum,IssmDouble* values, int interpolation_enum){
    182 
    183         _assert_(this->material);
    184         this->material->inputs->AddInput(new TriaInput(input_enum,values,interpolation_enum));
    185 }
    186 /*}}}*/
    187180/*FUNCTION Tria::CharacteristicLength{{{*/
    188181IssmDouble Tria::CharacteristicLength(void){
    … …  
    10181011}
    10191012/*}}}*/
    1020 /*FUNCTION Tria::GetMaterialInput(int inputenum) {{{*/
    1021 Input* Tria::GetMaterialInput(int inputenum){
    1022         return this->material->inputs->GetInput(inputenum);
    1023 }
    1024 /*}}}*/
    10251013/*FUNCTION Tria::GetInputListOnVertices(IssmDouble* pvalue,int enumtype) {{{*/
    10261014void Tria::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){
    … …  
    11731161
    11741162}/*}}}*/
    1175 /*FUNCTION Tria::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype) {{{*/
    1176 void Tria::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){
    1177 
    1178         Input* input=this->material->inputs->GetInput(enumtype);
    1179         if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    1180 
    1181         GaussTria* gauss=new GaussTria();
    1182         gauss->GaussVertex(this->GetNodeIndex(node));
    1183 
    1184         input->GetInputValue(pvalue,gauss);
    1185         delete gauss;
    1186 }
    1187 /*}}}*/
    11881163Node* Tria::GetNode(int node_number){/*{{{*/
    11891164        _assert_(node_number>=0);
    … …  
    12471222/*}}}*/
    12481223/*FUNCTION Tria::InputDepthAverageAtBase {{{*/
    1249 void  Tria::InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum){
     1224void  Tria::InputDepthAverageAtBase(int enum_type,int average_enum_type){
    12501225
    12511226        /*New input*/
    … …  
    12541229
    12551230        /*copy input of enum_type*/
    1256         if (object_enum==MeshElementsEnum)
    1257          oldinput=(Input*)this->inputs->GetInput(enum_type);
    1258         else if (object_enum==MaterialsEnum)
    1259          oldinput=(Input*)this->material->inputs->GetInput(enum_type);
    1260         else
    1261          _error_("object " << EnumToStringx(object_enum) << " not supported yet");
     1231        oldinput=(Input*)this->inputs->GetInput(enum_type);
    12621232        if(!oldinput)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
    12631233        newinput=(Input*)oldinput->copy();
    … …  
    12671237
    12681238        /*Add new input to current element*/
    1269         if (object_enum==MeshElementsEnum)
    1270          this->inputs->AddInput((Input*)newinput);
    1271         else if (object_enum==MaterialsEnum)
    1272          this->material->inputs->AddInput((Input*)newinput);
    1273         else
    1274          _error_("object " << EnumToStringx(object_enum) << " not supported yet");
     1239        this->inputs->AddInput((Input*)newinput);
    12751240}
    12761241/*}}}*/
    … …  
    14081373                                        }
    14091374                                        break;
    1410                                 /*Material will take care of it*/
    1411                                 case MaterialsRheologyBbarEnum:break;
    1412                                 case DamageDbarEnum: break;
     1375                                case MaterialsRheologyBbarEnum:
     1376                                        if(iomodel->Data(MaterialsRheologyBEnum)){
     1377                                                for(j=0;j<3;j++) nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[tria_vertex_ids[j]-1];
     1378                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
     1379                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
     1380                                                this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1381                                        }
     1382                                        break;
     1383                                case DamageDbarEnum:
     1384                                        if(iomodel->Data(DamageDEnum)){
     1385                                                for(j=0;j<3;j++) nodeinputs[j]=iomodel->Data(DamageDEnum)[tria_vertex_ids[j]-1];
     1386                                                for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
     1387                                                for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i];
     1388                                                this->inputs->AddInput(new ControlInput(DamageDbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
     1389                                        }
     1390                                        break;
    14131391                                default:
    14141392                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
    … …  
    14761454                }
    14771455                /*update input*/
    1478                 if (name==MaterialsRheologyBbarEnum || name==MaterialsRheologyBEnum || name==DamageDEnum || name==DamageDbarEnum){
    1479                         material->inputs->AddInput(new TriaInput(name,values,P1Enum));
    1480                 }
    1481                 else{
    1482                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    1483                 }
     1456                this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    14841457                break;
    14851458
    … …  
    14901463                }
    14911464                /*update input*/
    1492                 if(name==MaterialsRheologyBbarEnum || name==MaterialsRheologyBEnum || name==DamageDEnum || name==DamageDbarEnum){
    1493                         material->inputs->AddInput(new TriaInput(name,values,P1Enum));
    1494                 }
    1495                 else{
    1496                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    1497                 }
     1465                this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    14981466                break;
    14991467
    … …  
    16031571        }
    16041572
    1605 }
    1606 /*}}}*/
    1607 /*FUNCTION Tria::IsInput{{{*/
    1608 bool Tria::IsInput(int name){
    1609         if (
    1610                                 name==ThicknessEnum ||
    1611                                 name==SurfaceEnum ||
    1612                                 name==BathymetryEnum ||
    1613                                 name==BedEnum ||
    1614                                 name==MaskGroundediceLevelsetEnum ||
    1615                                 name==MaskIceLevelsetEnum ||
    1616                                 name==IceMaskNodeActivationEnum ||
    1617                                 name==LevelsetfunctionSlopeXEnum ||
    1618                                 name==LevelsetfunctionSlopeYEnum ||
    1619                                 name==SurfaceSlopeXEnum ||
    1620                                 name==SurfaceSlopeYEnum ||
    1621                                 name==BasalforcingsMeltingRateEnum ||
    1622                                 name==WatercolumnEnum ||
    1623                                 name==SurfaceforcingsMassBalanceEnum ||
    1624                                 name==SurfaceAreaEnum||
    1625                                 name==VxEnum ||
    1626                                 name==VyEnum ||
    1627                                 name==PressureEnum ||
    1628                                 name==InversionVxObsEnum ||
    1629                                 name==InversionVyObsEnum ||
    1630                                 name==FrictionCoefficientEnum ||
    1631                                 name==MaterialsRheologyBbarEnum ||
    1632                                 name==DamageDbarEnum ||
    1633                                 name==GradientEnum ||
    1634                                 name==OldGradientEnum ||
    1635                                 name==ConvergedEnum ||
    1636                                 name==SedimentHeadOldEnum ||
    1637                                 name==SedimentHeadEnum ||
    1638                                 name==EplHeadEnum ||
    1639                                 name==EplHeadOldEnum ||
    1640                                 name==HydrologydcEplThicknessOldEnum ||
    1641                                 name==HydrologydcEplInitialThicknessEnum ||
    1642                                 name==HydrologydcEplThicknessEnum ||
    1643                                 name==HydrologydcMaskEplactiveNodeEnum ||
    1644                                 name==MeshVertexonbedEnum ||
    1645                                 name==WaterTransferEnum ||
    1646                                 name==QmuVxEnum ||
    1647                                 name==QmuVyEnum ||
    1648                                 name==QmuPressureEnum ||
    1649                                 name==QmuBedEnum ||
    1650                                 name==QmuThicknessEnum ||
    1651                                 name==QmuSurfaceEnum ||
    1652                                 name==QmuTemperatureEnum ||
    1653                                 name==QmuMeltingEnum ||
    1654                                 name==QmuMaskGroundediceLevelsetEnum ||
    1655                                 name==QmuMaskIceLevelsetEnum ||
    1656                                 name==GiaWEnum ||
    1657                                 name==GiadWdtEnum
    1658                 ){
    1659                 return true;
    1660         }
    1661         else return false;
    16621573}
    16631574/*}}}*/
    … …  
    22992210
    23002211        /*Spawn material*/
    2301         seg->material=(Material*)this->material->copy();
    2302         delete seg->material->inputs;
    2303         seg->material->inputs=(Inputs*)this->material->inputs->SpawnSegInputs(index1,index2);
     2212        seg->material=(Material*)this->material->copy(seg);
    23042213
    23052214        /*recover nodes, material and matpar: */
    … …  
    32973206
    32983207        for(int i=0;i<num_controls;i++){
    3299 
    3300                 if(control_type[i]==MaterialsRheologyBbarEnum || control_type[i]==DamageDbarEnum){
    3301                         input=(Input*)material->inputs->GetInput(control_type[i]); _assert_(input);
    3302                 }
    3303                 else{
    3304                         input=(Input*)this->inputs->GetInput(control_type[i]);   _assert_(input);
    3305                 }
    3306 
     3208                input=(Input*)this->inputs->GetInput(control_type[i]);   _assert_(input);
    33073209                if (input->ObjectEnum()!=ControlInputEnum){
    33083210                        _error_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
    … …  
    33233225
    33243226        int vertexpidlist[NUMVERTICES];
    3325         Input* input=NULL;
    3326 
    3327         if(enum_type==MaterialsRheologyBbarEnum || enum_type==DamageDbarEnum){
    3328                 input=(Input*)material->inputs->GetInput(enum_type);
    3329         }
    3330         else{
    3331                 input=inputs->GetInput(enum_type);
    3332         }
     3227
     3228        Input* input=inputs->GetInput(enum_type);
    33333229        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    33343230        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    … …  
    33413237void Tria::ControlInputScaleGradient(int enum_type,IssmDouble scale){
    33423238
    3343         Input* input=NULL;
    3344 
    3345         if(enum_type==MaterialsRheologyBbarEnum || enum_type==DamageDbarEnum){
    3346                 input=(Input*)material->inputs->GetInput(enum_type);
    3347         }
    3348         else{
    3349                 input=inputs->GetInput(enum_type);
    3350         }
     3239        Input* input=inputs->GetInput(enum_type);
    33513240        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    33523241        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    … …  
    33603249        IssmDouble grad_list[NUMVERTICES];
    33613250        Input* grad_input=NULL;
    3362         Input* input=NULL;
    3363 
    3364         if(enum_type==MaterialsRheologyBbarEnum || enum_type==DamageDbarEnum){
    3365                 input=(Input*)material->inputs->GetInput(enum_type);
    3366         }
    3367         else{
    3368                 input=inputs->GetInput(enum_type);
    3369         }
     3251
     3252        Input* input=inputs->GetInput(enum_type);
    33703253        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    33713254        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    … …  
    33813264void Tria::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){
    33823265
    3383         Input* input=NULL;
    3384         if(control_enum==MaterialsRheologyBbarEnum || control_enum==DamageDbarEnum){
    3385                 input=(Input*)material->inputs->GetInput(control_enum);
    3386         }
    3387         else{
    3388                 input=inputs->GetInput(control_enum);
    3389         }
     3266        Input* input=inputs->GetInput(control_enum);
    33903267        if (!input) _error_("Input " << EnumToStringx(control_enum) << " not found");
    33913268        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(control_enum) << " is not a ControlInput");
    … …  
    34993376        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    35003377        GradientIndexing(&vertexpidlist[0],control_index);
    3501         Input* rheologyb_input=material->inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
     3378        Input* rheologyb_input=inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
    35023379        Input* weights_input=inputs->GetInput(InversionCostFunctionsCoefficientsEnum);                _assert_(weights_input);
    35033380
    … …  
    35483425        Input* adjointx_input=inputs->GetInput(AdjointxEnum);                       _assert_(adjointx_input);
    35493426        Input* adjointy_input=inputs->GetInput(AdjointyEnum);                       _assert_(adjointy_input);
    3550         Input* rheologyb_input=material->inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
     3427        Input* rheologyb_input=inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
    35513428
    35523429        /* Start  looping on the number of gaussian points: */
    … …  
    36053482        Input* adjointx_input=inputs->GetInput(AdjointxEnum);                       _assert_(adjointx_input);
    36063483        Input* adjointy_input=inputs->GetInput(AdjointyEnum);                       _assert_(adjointy_input);
    3607         Input* rheologyd_input=material->inputs->GetInput(DamageDbarEnum); _assert_(rheologyd_input);
     3484        Input* rheologyd_input=inputs->GetInput(DamageDbarEnum); _assert_(rheologyd_input);
    36083485
    36093486        /* Start  looping on the number of gaussian points: */
    … …  
    40113888        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    40123889        Input* weights_input  =inputs->GetInput(InversionCostFunctionsCoefficientsEnum);              _assert_(weights_input);
    4013         Input* rheologyb_input=material->inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
     3890        Input* rheologyb_input=inputs->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
    40143891
    40153892        /* Start looping on the number of gaussian points: */
    … …  
    45734450
    45744451        /*Get input (either in element or material)*/
    4575         if(control_enum==MaterialsRheologyBbarEnum || control_enum==DamageDbarEnum){
    4576                 input=(Input*)this->material->inputs->GetInput(control_enum); _assert_(input);
    4577         }
    4578         else{
    4579                 input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    4580         }
     4452        input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    45814453
    45824454        /*Check that it is a ControlInput*/
    … …  
    46084480        new_input = new TriaInput(control_enum,values,P1Enum);
    46094481
    4610         if(control_enum==MaterialsRheologyBbarEnum || control_enum==DamageDbarEnum){
    4611                 input=(Input*)material->inputs->GetInput(control_enum); _assert_(input);
    4612         }
    4613         else{
    4614                 input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    4615         }
    4616 
     4482        input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    46174483        if (input->ObjectEnum()!=ControlInputEnum){
    46184484                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    … …  
    51505016
    51515017                                        break;
     5018                                case MaterialsRheologyBEnum:
     5019                                        this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,values,P1Enum));
     5020                                        break;
    51525021                                default:
    51535022                                        this->inputs->AddInput(new TriaInput(name,values,P1Enum));

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r17257 r17275  
    109109                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
    110110                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    111                 void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
     111                void        InputDepthAverageAtBase(int enum_type,int average_enum_type);
    112112                void        InputDuplicate(int original_enum,int new_enum);
    113113                void        InputScale(int enum_type,IssmDouble scale_factor);
    … …  
    202202                void           AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum);
    203203                void           AddInput(int input_enum, IssmDouble* values, int interpolation_enum);
    204                 void           AddMaterialInput(int input_enum, IssmDouble* values, int interpolation_enum);
    205204                IssmDouble     EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){_error_("not implemented");};
    206205                IssmDouble     EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){_error_("not implemented");};
    … …  
    216215                void           NormalTop(IssmDouble* normal,IssmDouble* xyz_list);
    217216                void           NormalBase(IssmDouble* normal,IssmDouble* xyz_list);
    218                 Input*         GetMaterialInput(int inputenum);
    219217                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    220218                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    … …  
    232230                void             InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type);
    233231                void             InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int enum_type){_error_("not implemented yet");};
    234                 bool             IsInput(int name);
    235232                void           JacobianDeterminant(IssmDouble*  pJdet, IssmDouble* xyz_list,Gauss* gauss);
    236233                void           JacobianDeterminantLine(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp

    r17268 r17275  
    706706
    707707        //First recover damage  using the element: */
    708         element->GetMaterialInputValue(&damage,node,DamageDbarEnum);
     708        element->GetInputValue(&damage,node,DamageDbarEnum);
    709709
    710710        //Recover our data:

  • issm/trunk-jpl/src/c/classes/Materials/Material.h

    r17266 r17275  
    1212#include "../../datastructures/datastructures.h"
    1313#include "../Update.h"
     14class Element;
    1415class Elements;
    1516/*}}}*/
    … …  
    1819
    1920        public:
    20                 Inputs*  inputs;
    2121                virtual ~Material(){};
    2222                /*WARNING: input should not be public but it is an easy way to update B from T (using UpdateFromSolution) from Pentas*/
    2323
    2424                /*Numerics*/
    25                 virtual void       InputDuplicate(int original_enum,int new_enum)=0;
     25                virtual Material*  copy(Element* element)=0;
    2626                virtual void       Configure(Elements* elements)=0;
    27                 virtual void       GetVectorFromInputs(Vector<IssmDouble>* vector,int input_enum)=0;
    2827                virtual void       GetViscosity(IssmDouble* pviscosity,IssmDouble epseff)=0;
    2928                virtual void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble epseff)=0;

  • issm/trunk-jpl/src/c/classes/Materials/Materials.cpp

    r15375 r17275  
    4747}
    4848/*}}}*/
    49 /*FUNCTION Materials::InputDuplicate{{{*/
    50 void Materials::InputDuplicate(int input_enum,int output_enum){
    51 
    52         for(int i=0;i<this->Size();i++){
    53                 Material* material=(Material*)this->GetObjectByOffset(i);
    54                 material->InputDuplicate(input_enum,output_enum);
    55         }
    56 }

  • issm/trunk-jpl/src/c/classes/Materials/Materials.h

    r15375 r17275  
    2424                /*numerics*/
    2525                void  Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    26                 void  InputDuplicate(int input_enum,int output_enum);
    2726
    2827};

  • issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

    r17248 r17275  
    2929/*FUNCTION Matice::Matice(){{{*/
    3030Matice::Matice(){
    31         this->inputs=NULL;
    3231        this->helement=NULL;
     32        this->element=NULL;
    3333        return;
    3434}
    … …  
    4242        /*Initialize id*/
    4343        this->mid=matice_mid;
    44 
    45         /*Initialize inputs*/
    46         this->inputs=new Inputs();
    47 
    48         /*Initialize inputs from IoModel*/
    49         this->InputUpdateFromIoModel(index,iomodel);
    5044
    5145        /*Hooks: */
    5246        matice_eid=index+1;
    5347        this->helement=new Hook(&matice_eid,1);
     48        this->element=NULL;
    5449
    5550        return;
    … …  
    6055Matice::~Matice(){
    6156        delete helement;
    62         delete inputs;
    6357        return;
    6458}
    … …  
    7165        _printf_("Matice:\n");
    7266        _printf_("   mid: " << mid << "\n");
    73         _printf_("   inputs:\n");
    74         inputs->Echo();
    7567        _printf_("   element:\n");
    7668        helement->Echo();
    … …  
    8274        _printf_("Matice:\n");
    8375        _printf_("   mid: " << mid << "\n");
    84         _printf_("   inputs:\n");
    85         inputs->DeepEcho();
    8676        _printf_("   element:\n");
    8777        helement->Echo();
    … …  
    9888}
    9989/*}}}*/
    100 /*FUNCTION Matice::copy {{{*/
     90/*FUNCTION Matice::copy() {{{*/
    10191Object* Matice::copy() {
    10292
    … …  
    110100        matice->mid=this->mid;
    111101        matice->helement=(Hook*)this->helement->copy();
    112         if(this->inputs) matice->inputs=(Inputs*)this->inputs->Copy();
    113         else  matice->inputs=new Inputs();
     102        matice->element =(Element*)this->helement->delivers();
     103
     104        return matice;
     105}
     106/*}}}*/
     107/*FUNCTION Matice::copy(Element* element) {{{*/
     108Material* Matice::copy(Element* element_in) {
     109
     110        /*Output*/
     111        Matice* matice=NULL;
     112
     113        /*Initialize output*/
     114        matice=new Matice();
     115
     116        /*copy fields: */
     117        matice->mid=this->mid;
     118        matice->helement=(Hook*)this->helement->copy();
     119        matice->element =element_in;
    114120
    115121        return matice;
    … …  
    124130         * datasets, using internal ids and offsets hidden in hooks: */
    125131        helement->configure((DataSet*)elementsin);
     132        this->element  = (Element*)helement->delivers();
    126133}
    127134/*}}}*/
    … …  
    139146        IssmDouble B,n;
    140147
    141         inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
     148        element->inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
    142149        n=this->GetN();
    143150
    … …  
    153160        IssmDouble B,n;
    154161
    155         inputs->GetInputAverage(&B,MaterialsRheologyBbarEnum);
     162        element->inputs->GetInputAverage(&B,MaterialsRheologyBbarEnum);
    156163        n=this->GetN();
    157164
    … …  
    165172        IssmDouble B;
    166173
    167         inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
     174        element->inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
    168175        return B;
    169176}
    … …  
    175182        IssmDouble Bbar;
    176183
    177         inputs->GetInputAverage(&Bbar,MaterialsRheologyBbarEnum);
     184        element->inputs->GetInputAverage(&Bbar,MaterialsRheologyBbarEnum);
    178185        return Bbar;
    179186}
    … …  
    185192        IssmDouble n;
    186193
    187         inputs->GetInputAverage(&n,MaterialsRheologyNEnum);
     194        element->inputs->GetInputAverage(&n,MaterialsRheologyNEnum);
    188195        return n;
    189196}
    … …  
    195202        IssmDouble D;
    196203
    197         inputs->GetInputAverage(&D,DamageDEnum);
     204        element->inputs->GetInputAverage(&D,DamageDEnum);
    198205        return D;
    199206}
    … …  
    204211        /*Output*/
    205212        IssmDouble Dbar;
    206         inputs->GetInputAverage(&Dbar,DamageDbarEnum);
     213        element->inputs->GetInputAverage(&Dbar,DamageDbarEnum);
    207214        return Dbar;
    208 }
    209 /*}}}*/
    210 /*FUNCTION Matice::GetVectorFromInputs{{{*/
    211 void  Matice::GetVectorFromInputs(Vector<IssmDouble>* vector,int input_enum){
    212 
    213         /*Intermediaries*/
    214         Element *element= NULL;
    215 
    216         /*Recover element*/
    217         element=(Element*)helement->delivers();
    218 
    219         /*Check that input_enum is a material input*/
    220         if (!IsInput(input_enum)) return;
    221 
    222         switch(element->ObjectEnum()){
    223 
    224                 case TriaEnum:{
    225 
    226                                                           /*Prepare index list*/
    227                                                           int vertexpidlist[3];
    228                                                           ((Tria*)element)->GetVertexPidList(&vertexpidlist[0]);
    229 
    230                                                                  /*Get input (either in element or material)*/
    231                                                                  Input* input=inputs->GetInput(input_enum);
    232                                                           if(!input) _error_("Input " << EnumToStringx(input_enum) << " not found in material");
    233 
    234                                                           /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
    235                                                           input->GetVectorFromInputs(vector,&vertexpidlist[0]);}
    236                                                 break;
    237 
    238                 default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
    239         }
    240215}
    241216/*}}}*/
    … …  
    546521}
    547522/*}}}*/
    548 /*FUNCTION Matice::InputDuplicate{{{*/
    549 void  Matice::InputDuplicate(int original_enum,int new_enum){
    550 
    551         /*Call inputs method*/
    552         if (IsInput(original_enum)) inputs->DuplicateInput(original_enum,new_enum);
    553 
    554 }
    555 /*}}}*/
    556523/*FUNCTION Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type) {{{*/
    557524void  Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type){
    558525
    559         /*Intermediaries*/
    560         Element *element      = NULL;
    561 
    562         /*Recover element*/
    563         element=(Element*)helement->delivers();
    564 
    565         /*Check that name is an element input*/
    566         if (!IsInput(name)) return;
    567 
    568         switch(type){
    569 
    570                 case VertexEnum:
    571 
    572                         switch(element->ObjectEnum()){
    573 
    574                                 case TriaEnum: {
    575                                         IssmDouble values[3];
    576                                         for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->vertices[i]->Pid()];
    577                                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    578                                         return;
    579                                 }
    580                                 case PentaEnum: {
    581                                         IssmDouble valuesp[6];
    582                                         for (int i=0;i<6;i++) valuesp[i]=vector[((Penta*)element)->vertices[i]->Sid()]; //use sid list, to index into serial oriented vector
    583                                         this->inputs->AddInput(new PentaInput(name,valuesp,P1Enum));
    584                                         return;
    585                                 }
    586                                 default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
    587                         }
    588                 default: _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
    589         }
    590526}
    591527/*}}}*/
    592528/*FUNCTION Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type) {{{*/
    593529void  Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){
    594 
    595         /*Intermediaries*/
    596         Element    *element    = NULL;
    597         Parameters *parameters = NULL;
    598         int         meshtype;
    599 
    600         /*Recover element*/
    601         element=(Element*)helement->delivers();
    602 
    603         /*Check that name is an element input*/
    604         if (!IsInput(name)) return;
    605 
    606         switch(type){
    607 
    608                 case VertexEnum:
    609 
    610                         switch(element->ObjectEnum()){
    611 
    612                                 case TriaEnum: {
    613                                         IssmDouble values[3];
    614                                         for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->vertices[i]->Sid()]; //index into serial oriented vector
    615                                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    616                                         /*Special case for rheology B in 2D: Pourave land for this solution{{{*/
    617                                         if(name==MaterialsRheologyBEnum){
    618                                                 /*Are we in 2D?:*/
    619                                                 if(element->ObjectEnum()==TriaEnum){
    620                                                         parameters=((Tria*)(element))->parameters;
    621                                                 }
    622                                                 else{
    623                                                         parameters=((Penta*)(element))->parameters;
    624                                                 }
    625                                                 parameters->FindParam(&meshtype,MeshTypeEnum);
    626                                                 if(meshtype==Mesh2DhorizontalEnum){
    627                                                         /*Duplicate rheology input: */
    628                                                         this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,values,P1Enum));
    629                                                 }
    630                                         }
    631                                         /*}}}*/
    632                                         return;
    633                                 }
    634                                 case PentaEnum:{
    635                                         IssmDouble valuesp[6];
    636                                         for (int i=0;i<6;i++) valuesp[i]=vector[((Penta*)element)->vertices[i]->Sid()]; //use sid list, to index into serial oriented vector
    637                                         this->inputs->AddInput(new PentaInput(name,valuesp,P1Enum));
    638                                         return;
    639                                 }
    640                                 default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
    641                         }
    642                 default: _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
    643         }
    644530
    645531}
    … …  
    665551}
    666552/*}}}*/
    667 /*FUNCTION Matice::InputUpdateFromIoModel{{{*/
    668 void Matice::InputUpdateFromIoModel(int index, IoModel* iomodel){
    669 
    670         int i,j;
    671         bool   control_analysis;
    672         int    num_control_type;
    673 
    674         /*Fetch parameters: */
    675         iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    676         if(control_analysis) iomodel->Constant(&num_control_type,InversionNumControlParametersEnum);
    677 
    678         if(iomodel->meshtype==Mesh2DhorizontalEnum){
    679 
    680                 /*Intermediaries*/
    681                 const int  num_vertices = 3; //Tria has 3 vertices
    682                 IssmDouble nodeinputs[num_vertices];
    683                 IssmDouble cmmininputs[num_vertices];
    684                 IssmDouble cmmaxinputs[num_vertices];
    685 
    686                 /*Get B*/
    687                 if (iomodel->Data(MaterialsRheologyBEnum)) {
    688                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    689                         this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,nodeinputs,P1Enum));
    690                 }
    691 
    692                 /*Get n*/
    693                 if (iomodel->Data(MaterialsRheologyNEnum)) {
    694                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
    695                         this->inputs->AddInput(new TriaInput(MaterialsRheologyNEnum,nodeinputs,P1Enum));
    696                 }
    697 
    698                 /*Get D:*/
    699                 if (iomodel->Data(DamageDEnum)) {
    700                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(DamageDEnum)[iomodel->elements[num_vertices*index+i]-1];
    701                         this->inputs->AddInput(new TriaInput(DamageDbarEnum,nodeinputs,P1Enum));
    702                 }
    703 
    704                 /*Control Inputs*/
    705                 if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    706                         for(i=0;i<num_control_type;i++){
    707                                 switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
    708                                         case MaterialsRheologyBbarEnum:
    709                                                 if (iomodel->Data(MaterialsRheologyBEnum)){
    710                                                         _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    711                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
    712                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    713                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    714                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    715                                                 }
    716                                                 break;
    717                                         case DamageDbarEnum:
    718                                                 if (iomodel->Data(DamageDEnum)){
    719                                                         _assert_(iomodel->Data(DamageDEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    720                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(DamageDEnum)[iomodel->elements[num_vertices*index+j]-1];
    721                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    722                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    723                                                         this->inputs->AddInput(new ControlInput(DamageDbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    724                                                 }
    725                                                 break;
    726                                 }
    727                         }
    728                 }
    729         }
    730         else if(iomodel->meshtype==Mesh2DverticalEnum){
    731 
    732                 /*Intermediaries*/
    733                 const int num_vertices = 3; //Tria has 3 vertices
    734                 IssmDouble    nodeinputs[num_vertices];
    735                 IssmDouble    cmmininputs[num_vertices];
    736                 IssmDouble    cmmaxinputs[num_vertices];
    737 
    738                 /*Get B*/
    739                 if (iomodel->Data(MaterialsRheologyBEnum)) {
    740                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    741                         this->inputs->AddInput(new TriaInput(MaterialsRheologyBEnum,nodeinputs,P1Enum));
    742                 }
    743 
    744                 /*Get n*/
    745                 if (iomodel->Data(MaterialsRheologyNEnum)) {
    746                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
    747                         this->inputs->AddInput(new TriaInput(MaterialsRheologyNEnum,nodeinputs,P1Enum));
    748                 }
    749 
    750                 /*Get D:*/
    751                 if (iomodel->Data(DamageDEnum)) {
    752                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(DamageDEnum)[iomodel->elements[num_vertices*index+i]-1];
    753                         this->inputs->AddInput(new TriaInput(DamageDEnum,nodeinputs,P1Enum));
    754                 }
    755         }
    756         else if(iomodel->meshtype==Mesh3DEnum){
    757 
    758                 /*Intermediaries*/
    759                 const int  num_vertices = 6; //Penta has 6 vertices
    760                 IssmDouble nodeinputs[num_vertices];
    761                 IssmDouble cmmininputs[num_vertices];
    762                 IssmDouble cmmaxinputs[num_vertices];
    763 
    764                 /*Get B*/
    765                 if (iomodel->Data(MaterialsRheologyBEnum)) {
    766                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    767                         this->inputs->AddInput(new PentaInput(MaterialsRheologyBEnum,nodeinputs,P1Enum));
    768                 }
    769 
    770                 /*Get n*/
    771                 if (iomodel->Data(MaterialsRheologyNEnum)) {
    772                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyNEnum)[index];
    773                         this->inputs->AddInput(new PentaInput(MaterialsRheologyNEnum,nodeinputs,P1Enum));
    774                 }
    775                
    776                 /*Get D*/
    777                 if (iomodel->Data(DamageDEnum)) {
    778                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(DamageDEnum)[iomodel->elements[num_vertices*index+i]-1];
    779                         this->inputs->AddInput(new PentaInput(DamageDEnum,nodeinputs,P1Enum));
    780                 }
    781                
    782                 /*Control Inputs*/
    783                 if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    784                         for(i=0;i<num_control_type;i++){
    785                                 switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
    786                                         case MaterialsRheologyBbarEnum:
    787                                                 if (iomodel->Data(MaterialsRheologyBEnum)){
    788                                                         _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    789                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
    790                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    791                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    792                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    793                                                 }
    794                                                 break;
    795                                         case DamageDbarEnum:
    796                                                 if (iomodel->Data(DamageDEnum)){
    797                                                         _assert_(iomodel->Data(DamageDEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    798                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(DamageDEnum)[iomodel->elements[num_vertices*index+j]-1];
    799                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    800                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    801                                                         this->inputs->AddInput(new ControlInput(DamageDEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    802                                                 }
    803                                                 break;
    804 
    805                                 }
    806                         }
    807                 }
    808         }
    809         else{
    810                 _error_("Mesh type not supported yet!");
    811         }
    812 
    813         return;
    814 }
    815 /*}}}*/
    816 /*FUNCTION Matice::IsInput{{{*/
    817 bool Matice::IsInput(int name){
    818         if (
    819                                 name==MaterialsRheologyBEnum ||
    820                                 name==MaterialsRheologyBbarEnum ||
    821                                 name==MaterialsRheologyNEnum ||
    822                                 name==QmuMaterialsRheologyBEnum ||
    823                                 name==DamageDEnum ||
    824                                 name==DamageDbarEnum
    825 
    826                 ){
    827                 return true;
    828         }
    829         else return false;
    830 }
    831 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Materials/Matice.h

    r17248 r17275  
    1212class IoModel;
    1313class Elements;
     14class Element;
    1415class Loads;
    1516class Nodes;
    … …  
    2223
    2324        private:
    24                 int   mid;
    25                 Hook *helement;
     25                int      mid;
     26                Hook    *helement;
     27                Element *element;
    2628
    2729        public:
    … …  
    4547                void  InputUpdateFromConstant(int constant, int name);
    4648                void  InputUpdateFromConstant(bool constant, int name);
    47                 void  InputUpdateFromIoModel(int index, IoModel* iomodel);
     49                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    4850                /*}}}*/
    4951                /*Material virtual functions resolution: {{{*/
    50                 void   InputDuplicate(int original_enum,int new_enum);
    5152                void   Configure(Elements* elements);
    52                 void   GetVectorFromInputs(Vector<IssmDouble>* vector,int input_enum);
     53                Material*  copy(Element* element);
    5354                void       SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
    5455                void       GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff);
    … …  
    6667                IssmDouble GetDbar();
    6768                IssmDouble GetN();
    68                 bool       IsInput(int name);
    6969                /*}}}*/
    7070};

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp

    r17266 r17275  
    9191        iomodel->Constant(&this->mantle_shear_modulus,MaterialsMantleShearModulusEnum);
    9292        iomodel->Constant(&this->mantle_density,MaterialsMantleDensityEnum);
    93 
    94         this->inputs=NULL; /*not used here*/
    9593}
    9694/*}}}*/
    … …  
    234232
    235233/*Matpar management: */
    236 /*FUNCTION Matpar::InputDuplicate{{{*/
    237 void  Matpar::InputDuplicate(int original_enum,int new_enum){
    238 
    239            /*Call inputs method*/
    240            if (IsInput(original_enum)) inputs->DuplicateInput(original_enum,new_enum);
    241 
    242 }
    243 /*}}}*/
    244234/*FUNCTION Matpar::Configure {{{*/
    245235void  Matpar::Configure(Elements* elementsin){
    … …  
    520510}
    521511/*}}}*/
    522 
    523512/*FUNCTION Matpar::GetLithosphereShearModulus {{{*/                     
    524513IssmDouble Matpar::GetLithosphereShearModulus(){                 
    … …  
    541530}               
    542531/*}}}*/
    543 /*FUNCTION Matpar::IsInput{{{*/
    544 bool Matpar::IsInput(int name){
    545         return false;
    546 }
    547 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.h

    r17248 r17275  
    7676                void   InputUpdateFromConstant(int constant, int name);
    7777                void   InputUpdateFromConstant(bool constant, int name);
    78                 void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
     78                void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    7979                /*}}}*/
    8080                /*Material virtual functions resolution: {{{*/
    81                 void       InputDuplicate(int original_enum,int new_enum);
     81                Material*  copy(Element* element){_error_("not implemented");};
    8282                void       Configure(Elements* elements);
    83                 void       GetVectorFromInputs(Vector<IssmDouble>* vector,int input_enum){return;}
    8483                void       GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
    8584                void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
    … …  
    135134                IssmDouble GetS0p();
    136135                IssmDouble GetMaterialParameter(int in_enum);
    137                 bool       IsInput(int name);
    138136                /*}}}*/
    139137

  • issm/trunk-jpl/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp

    r15849 r17275  
    2121                        Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2222                        element->GetVectorFromInputs(vector,name);
    23                 }
    24 
    25                 /*Look up in materials*/
    26                 for(i=0;i<femmodel->materials->Size();i++){
    27                         Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    28                         material->GetVectorFromInputs(vector,name);
    2923                }
    3024        }

  • issm/trunk-jpl/src/c/modules/InputDuplicatex/InputDuplicatex.cpp

    r16638 r17275  
    1414                element->InputDuplicate(original_enum,new_enum);
    1515        }
    16         for(int i=0;i<femmodel->materials->Size();i++){
    17                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    18                 material->InputDuplicate(original_enum,new_enum);
    19         }
    20 
    2116}

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

    r16313 r17275  
    4545        }
    4646
    47         /*Update elements and materials: */
     47        /*Update elements: */
    4848        counter=0;
    4949        for (i=0;i<iomodel->numberofelements;i++){
    … …  
    5151                        element=(Element*)elements->GetObjectByOffset(counter);
    5252                        element->InputUpdateFromIoModel(i,iomodel); //we need i to index into elements.
    53 
    54                         material=(Material*)materials->GetObjectByOffset(counter);
    55                         material->InputUpdateFromIoModel(i,iomodel); //we need i to index into elements.
    5653                        counter++;
    5754                }

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp

    r17236 r17275  
    2828        switch(iomodel->meshtype){
    2929                case Mesh2DhorizontalEnum:
    30                         materials->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
    3130                        for(i=0;i<iomodel->numberofelements;i++){
    3231                                if(iomodel->my_elements[i]) elements->AddObject(new Tria(i+1,i,i,iomodel,nummodels));
    … …  
    5150        switch(materials_type){
    5251                case MaticeEnum:
    53                         iomodel->FetchData(3,MaterialsRheologyBEnum,MaterialsRheologyNEnum,DamageDEnum);
     52                        iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum);
     53                        iomodel->FetchDataToInput(elements,MaterialsRheologyNEnum);
     54                        iomodel->FetchDataToInput(elements,DamageDEnum);
    5455                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    55                         if(dakota_analysis){
    56                                 switch(iomodel->meshtype){
    57                                         case Mesh2DhorizontalEnum:
    58                                                 materials->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
    59                                                 break;
    60                                         case Mesh3DEnum:
    61                                                 materials->InputDuplicate(MaterialsRheologyBEnum,QmuMaterialsRheologyBEnum);
    62                                                 break;
    63                                         default:
    64                                                 _error_("Mesh not supported yet");
    65                                 }
     56                        switch(iomodel->meshtype){
     57                                case Mesh2DhorizontalEnum:
     58                                        elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     59                                        elements->InputDuplicate(DamageDEnum,DamageDbarEnum);
     60                                        if(dakota_analysis) elements->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
     61                                        break;
     62                                case Mesh3DEnum:
     63                                        if(dakota_analysis) elements->InputDuplicate(MaterialsRheologyBEnum,QmuMaterialsRheologyBEnum);
     64                                        break;
     65                                default:
     66                                        _error_("Mesh not supported yet");
    6667                        }
    6768                        break;
Note: See TracChangeset for help on using the changeset viewer.