Ignore:
Timestamp:
04/01/20 21:54:40 (5 years ago)
Author:
Mathieu Morlighem
Message:

merged trunk-jpl and trunk for revision 24684

Location:
issm/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk

  • issm/trunk/src

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

    r24313 r24686  
    4040        return 1;
    4141}/*}}}*/
    42 void DamageEvolutionAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     42void DamageEvolutionAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    4343
    4444        int finiteelement;
    … …  
    5454                if(iomodel->my_elements[i]){
    5555                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    56                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     56                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
     57
     58                        /*Need to know the type of approximation for this element*/
     59                        if(iomodel->Data("md.flowequation.element_equation")){
     60                                inputs2->SetInput(ApproximationEnum,counter,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i])));
     61                        }
    5762                        counter++;
    5863                }
    … …  
    6368        for(int i=0;i<elements->Size();i++){
    6469                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    65                 int numvertices = element->GetNumberOfVertices();
    66                 IssmDouble* values = xNewZeroInit<IssmDouble>(numvertices);
    67                 element->AddInput(DamageFEnum,values,P1Enum);
    68                 xDelete<IssmDouble>(values);
     70                element->SetElementInput(inputs2,DamageFEnum,0.);
    6971        }
    7072
    7173
    7274        /*What input do I need to run my damage evolution model?*/
    73         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    74         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    75         if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
    76         iomodel->FetchDataToInput(elements,"md.damage.D",DamageDEnum);
    77         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    78         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
     75        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     76        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     77        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
     78        iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
     79        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     80        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
    7981
    8082}/*}}}*/
    … …  
    137139
    138140        /*Add input*/
    139         element->AddInput(DamageFEnum,f,element->GetElementType());
     141        element->AddInput2(DamageFEnum,f,element->GetElementType());
    140142
    141143        /*Clean up and return*/
    … …  
    172174        element->ComputeDeviatoricStressTensor();
    173175
    174         Input* principalDevStress1_input = element->GetInput(DeviatoricStress1Enum);     _assert_(principalDevStress1_input);
    175         Input* principalDevStress2_input = element->GetInput(DeviatoricStress2Enum);     _assert_(principalDevStress2_input);
    176 
    177         Input* damage_input = NULL;
     176        Input2* principalDevStress1_input = element->GetInput2(DeviatoricStress1Enum);     _assert_(principalDevStress1_input);
     177        Input2* principalDevStress2_input = element->GetInput2(DeviatoricStress2Enum);     _assert_(principalDevStress2_input);
     178
     179        Input2* damage_input = NULL;
    178180        if(domaintype==Domain2DhorizontalEnum){
    179                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
     181                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
    180182        }
    181183        else{
    182                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
     184                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
    183185        }
    184186
    … …  
    220222
    221223        /*Add input*/
    222         element->AddInput(DamageFEnum,f,element->GetElementType());
     224        element->AddInput2(DamageFEnum,f,element->GetElementType());
    223225
    224226        /*Clean up and return*/
    … …  
    248250
    249251        /*retrieve what we need: */
    250         Input* eps_xx_input  = element->GetInput(StrainRatexxEnum);     _assert_(eps_xx_input);
    251         Input* eps_xy_input  = element->GetInput(StrainRatexyEnum);     _assert_(eps_xy_input);
    252         Input* eps_yy_input  = element->GetInput(StrainRateyyEnum);     _assert_(eps_yy_input);
    253         Input*  n_input=element->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    254         Input* damage_input = NULL;
    255         Input* B_input = NULL;
     252        Input2* eps_xx_input  = element->GetInput2(StrainRatexxEnum);     _assert_(eps_xx_input);
     253        Input2* eps_xy_input  = element->GetInput2(StrainRatexyEnum);     _assert_(eps_xy_input);
     254        Input2* eps_yy_input  = element->GetInput2(StrainRateyyEnum);     _assert_(eps_yy_input);
     255        Input2*  n_input=element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     256        Input2* damage_input = NULL;
     257        Input2* B_input = NULL;
    256258        if(domaintype==Domain2DhorizontalEnum){
    257                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
    258                 B_input=element->GetInput(MaterialsRheologyBbarEnum); _assert_(B_input);
     259                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
     260                B_input=element->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
    259261        }
    260262        else{
    261                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
    262                 B_input=element->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
     263                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
     264                B_input=element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
    263265        }
    264266
    … …  
    295297
    296298        /*Add input*/
    297         element->AddInput(DamageFEnum,f,element->GetElementType());
     299        element->AddInput2(DamageFEnum,f,P1DGEnum);
    298300
    299301        /*Clean up and return*/
    … …  
    335337        }
    336338        /*retrieve what we need: */
    337         Input* tau_xx_input  = element->GetInput(DeviatoricStressxxEnum);     _assert_(tau_xx_input);
    338         Input* tau_xy_input  = element->GetInput(DeviatoricStressxyEnum);     _assert_(tau_xy_input);
    339         Input* tau_yy_input  = element->GetInput(DeviatoricStressyyEnum);     _assert_(tau_yy_input);
    340         Input* tau_xz_input  = NULL;
    341         Input* tau_yz_input  = NULL;
    342         Input* tau_zz_input  = NULL;
    343         Input* stressMaxPrincipal_input = NULL;
     339        Input2* tau_xx_input  = element->GetInput2(DeviatoricStressxxEnum);     _assert_(tau_xx_input);
     340        Input2* tau_xy_input  = element->GetInput2(DeviatoricStressxyEnum);     _assert_(tau_xy_input);
     341        Input2* tau_yy_input  = element->GetInput2(DeviatoricStressyyEnum);     _assert_(tau_yy_input);
     342        Input2* tau_xz_input  = NULL;
     343        Input2* tau_yz_input  = NULL;
     344        Input2* tau_zz_input  = NULL;
     345        Input2* stressMaxPrincipal_input = NULL;
    344346        if(dim==3){
    345                 tau_xz_input  = element->GetInput(DeviatoricStressxzEnum);     _assert_(tau_xz_input);
    346                 tau_yz_input  = element->GetInput(DeviatoricStressyzEnum);     _assert_(tau_yz_input);
    347                 tau_zz_input  = element->GetInput(DeviatoricStresszzEnum);     _assert_(tau_zz_input);
    348                 stressMaxPrincipal_input = element->GetInput(StressMaxPrincipalEnum); _assert_(stressMaxPrincipal_input);
    349         }
    350         Input* damage_input = NULL;
     347                tau_xz_input  = element->GetInput2(DeviatoricStressxzEnum);     _assert_(tau_xz_input);
     348                tau_yz_input  = element->GetInput2(DeviatoricStressyzEnum);     _assert_(tau_yz_input);
     349                tau_zz_input  = element->GetInput2(DeviatoricStresszzEnum);     _assert_(tau_zz_input);
     350                stressMaxPrincipal_input = element->GetInput2(StressMaxPrincipalEnum); _assert_(stressMaxPrincipal_input);
     351        }
     352        Input2* damage_input = NULL;
    351353        if(domaintype==Domain2DhorizontalEnum){
    352                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
     354                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
    353355        }
    354356        else{
    355                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
     357                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
    356358        }
    357359
    … …  
    414416        }
    415417        /*Add input*/
    416         element->AddInput(DamageFEnum,f,element->GetElementType());
     418        element->AddInput2(DamageFEnum,f,P1DGEnum);
    417419
    418420        /*Clean up and return*/
    … …  
    461463        //printf("dt %f\n", dt);
    462464        element->FindParam(&stabilization,DamageStabilizationEnum);
    463         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    464         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
    465         Input* vz_input = NULL;
     465        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     466        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
     467        Input2* vz_input = NULL;
    466468        if(dim==3){
    467                 vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     469                vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
    468470        }
    469471
    … …  
    634636        }
    635637
    636         Input* damaged_input = NULL;
    637         Input* damagef_input = element->GetInput(DamageFEnum); _assert_(damagef_input);
     638        Input2* damaged_input = NULL;
     639        Input2* damagef_input = element->GetInput2(DamageFEnum); _assert_(damagef_input);
    638640        if(domaintype==Domain2DhorizontalEnum){
    639                 damaged_input = element->GetInput(DamageDbarEnum); _assert_(damaged_input);
     641                damaged_input = element->GetInput2(DamageDbarEnum); _assert_(damaged_input);
    640642        }
    641643        else{
    642                 damaged_input = element->GetInput(DamageDEnum); _assert_(damaged_input);
     644                damaged_input = element->GetInput2(DamageDEnum); _assert_(damaged_input);
    643645        }
    644646
    … …  
    755757        element->FindParam(&domaintype,DomainTypeEnum);
    756758        if(domaintype==Domain2DhorizontalEnum){
    757                 element->AddInput(DamageDbarEnum,newdamage,element->GetElementType());
     759                element->AddInput2(DamageDbarEnum,newdamage,element->GetElementType());
    758760        }
    759761        else{
    760                 element->AddInput(DamageDEnum,newdamage,element->GetElementType());
     762                element->AddInput2(DamageDEnum,newdamage,element->GetElementType());
    761763        }
    762764
    … …  
    792794        /*Retrieve all inputs and parameters*/
    793795        element->GetVerticesCoordinates(&xyz_list);
    794         Input* vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    795         Input* vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
     796        Input2* vxaverage_input=element->GetInput2(VxEnum); _assert_(vxaverage_input);
     797        Input2* vyaverage_input=element->GetInput2(VyEnum); _assert_(vyaverage_input);
    796798
    797799        /* Start  looping on the number of gaussian points: */
Note: See TracChangeset for help on using the changeset viewer.