Changeset 15849


Ignore:
Timestamp:
08/20/13 14:50:44 (12 years ago)
Author:
seroussi
Message:

CHG: moved some modules back to src/modules and simplified some prototypes

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

Legend:

Unmodified
Added
Removed

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

    r15838 r15849  
    6666
    6767        /*Modify core inputs in objects contained in femmodel, to reflect the dakota variables inputs: */
    68         InputUpdateFromDakotax(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,d_variables,d_variables_descriptors,d_numvariables);
     68        InputUpdateFromDakotax(femmodel,d_variables,d_variables_descriptors,d_numvariables);
    6969
    7070        /*Determine solution sequence: */

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

    r15104 r15849  
    2222
    2323        /*retrieve boundary conditions from element inputs :*/
    24         GetSolutionFromInputsx( &yg, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,  femmodel->parameters);
     24        GetSolutionFromInputsx(&yg,femmodel);
    2525
    2626        /*update spcs using this new vector of constraints: */

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

    r15104 r15849  
    2424
    2525        /*Call SurfaceAreax, because some it might be needed by PVector*/
    26         SurfaceAreax(NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     26        SurfaceAreax(NULL,femmodel);
    2727
    2828        /*compute adjoint*/
    … …  
    3434        if(save_results){
    3535                if(VerboseSolution()) _printf0_("   saving results\n");
    36                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointEnum);
     36                InputToResultx(femmodel,AdjointEnum);
    3737        }
    3838}

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

    r15771 r15849  
    2727
    2828        /*Call SurfaceAreax, because some it might be needed by PVector*/
    29         SurfaceAreax(NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     29        SurfaceAreax(NULL,femmodel);
    3030
    3131        /*Compute adjoint*/
    … …  
    3737        if(save_results){
    3838                if(VerboseSolution()) _printf0_("   saving results\n");
    39                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum);
    40                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum);
     39                InputToResultx(femmodel,AdjointxEnum);
     40                InputToResultx(femmodel,AdjointyEnum);
    4141                if (isFS){
    42                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointzEnum);
    43                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointpEnum);
     42                        InputToResultx(femmodel,AdjointzEnum);
     43                        InputToResultx(femmodel,AdjointpEnum);
    4444                }
    4545        }

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

    r15104 r15849  
    2626        if(save_results){
    2727                if(VerboseSolution()) _printf0_("   saving results\n");
    28                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
     28                InputToResultx(femmodel,ThicknessEnum);
    2929        }
    3030

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

    r15104 r15849  
    2828        if(save_results){
    2929                if(VerboseSolution()) _printf0_("   saving results\n");
    30                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeXEnum);
    31                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeYEnum);
     30                InputToResultx(femmodel,BedSlopeXEnum);
     31                InputToResultx(femmodel,BedSlopeYEnum);
    3232        }
    3333

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

    r15771 r15849  
    9494                /*Return gradient if asked: */
    9595                if (cm_gradient){
    96                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,GradientEnum);
     96                        InputToResultx(femmodel,GradientEnum);
    9797                        goto cleanup_and_return;
    9898                }
    … …  
    114114        /*some results not computed by steadystate_core or stressbalance_core: */
    115115        if(!dakota_analysis){ //do not save this if we are running the control core from a qmu run!
    116                 for(i=0;i<num_controls;i++) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]);
     116                for(i=0;i<num_controls;i++) InputToResultx(femmodel,control_type[i]);
    117117
    118118                #ifdef _HAVE_ADOLC_

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

    r15205 r15849  
    8585        SetControlInputsFromVectorx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,X);
    8686        for(int i=0;i<num_controls;i++){
    87                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_list[i]);
     87                InputToResultx(femmodel,control_list[i]);
    8888        }
    8989        femmodel->results->AddObject(new GenericExternalResult<double*>(femmodel->results->Size()+1,JEnum,user.J,maxiter+3,1,1,0));

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

    r15104 r15849  
    2727        if(save_results){
    2828                if(VerboseSolution()) _printf0_("   saving results\n");
    29                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum);
    30                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EnthalpyEnum);
    31                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WaterfractionEnum);
     29                InputToResultx(femmodel,TemperatureEnum);
     30                InputToResultx(femmodel,EnthalpyEnum);
     31                InputToResultx(femmodel,WaterfractionEnum);
    3232        }
    3333}

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

    r15104 r15849  
    4646        dwdtg->Assemble();
    4747
    48         InputUpdateFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,wg,GiaWEnum,VertexSIdEnum);
    49         InputUpdateFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,dwdtg,GiadWdtEnum,VertexSIdEnum);
     48        InputUpdateFromVectorx(femmodel,wg,GiaWEnum,VertexSIdEnum);
     49        InputUpdateFromVectorx(femmodel,dwdtg,GiadWdtEnum,VertexSIdEnum);
    5050
    5151        if(save_results){
    5252                if(VerboseSolution()) _printf0_("   saving results\n");
    53                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,GiaWEnum);
    54                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,GiadWdtEnum);
     53                InputToResultx(femmodel,GiaWEnum);
     54                InputToResultx(femmodel,GiadWdtEnum);
    5555        }
    5656

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

    r15191 r15849  
    6868                        if(save_results && ((i+1)%output_frequency==0 || (i+1)==nsteps)){
    6969                                if(VerboseSolution()) _printf0_("   saving results \n");
    70                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WatercolumnEnum);
    71                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVxEnum);
    72                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVyEnum);
     70                                InputToResultx(femmodel,WatercolumnEnum);
     71                                InputToResultx(femmodel,HydrologyWaterVxEnum);
     72                                InputToResultx(femmodel,HydrologyWaterVyEnum);
    7373
    7474                                /*unload results*/
    … …  
    8989                        if(save_results && ((i+1)%output_frequency==0 || (i+1)==nsteps)){
    9090                                if(VerboseSolution()) _printf0_("   saving results \n");
    91                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SedimentHeadEnum);
    92                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SedimentHeadResidualEnum);
     91                                InputToResultx(femmodel,SedimentHeadEnum);
     92                                InputToResultx(femmodel,SedimentHeadResidualEnum);
    9393                                if(isefficientlayer){
    94                                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EplHeadEnum);
    95                                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologydcMaskEplactiveEnum);
     94                                        InputToResultx(femmodel,EplHeadEnum);
     95                                        InputToResultx(femmodel,HydrologydcMaskEplactiveEnum);
    9696                                }
    9797                                /*unload results*/

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

    r15767 r15849  
    4848        if(save_results){
    4949                if(VerboseSolution()) _printf0_("   saving results\n");
    50                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
     50                InputToResultx(femmodel,ThicknessEnum);
    5151                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    5252        }

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

    r15771 r15849  
    5353                        thermal_core(femmodel);
    5454                        femmodel->SetCurrentConfiguration(ThermalAnalysisEnum);
    55                         GetSolutionFromInputsx(&tg,femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     55                        GetSolutionFromInputsx(&tg,femmodel);
    5656                }
    5757                else{
    5858                        enthalpy_core(femmodel);
    59                         GetSolutionFromInputsx(&tg,femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     59                        GetSolutionFromInputsx(&tg,femmodel);
    6060                }
    6161                #else
    … …  
    6565                if(VerboseSolution()) _printf0_("   computing new velocity\n");
    6666                stressbalance_core(femmodel);
    67                 GetSolutionFromInputsx(&ug,femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     67                GetSolutionFromInputsx(&ug,femmodel);
    6868
    6969                if(step>1){
    … …  
    8484        if(save_results){
    8585                if(VerboseSolution()) _printf0_("   saving results\n");
    86                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    87                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);
    88                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum);
    89                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum);
    90                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum);
    91                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum);
    92                 if(isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WaterfractionEnum);
    93                 if(isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EnthalpyEnum);
    94                 if(!isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalforcingsMeltingRateEnum);
     86                InputToResultx(femmodel,VxEnum);
     87                InputToResultx(femmodel,VyEnum);
     88                InputToResultx(femmodel,VzEnum);
     89                InputToResultx(femmodel,VelEnum);
     90                InputToResultx(femmodel,PressureEnum);
     91                InputToResultx(femmodel,TemperatureEnum);
     92                if(isenthalpy)  InputToResultx(femmodel,WaterfractionEnum);
     93                if(isenthalpy)  InputToResultx(femmodel,EnthalpyEnum);
     94                if(!isenthalpy) InputToResultx(femmodel,BasalforcingsMeltingRateEnum);
    9595                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    9696        }

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

    r15771 r15849  
    8686        if(save_results){
    8787                if(VerboseSolution()) _printf0_("   saving results\n");
    88                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    89                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);
    90                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum);
    91                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum);
    92                 if(dim==3) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum);
     88                InputToResultx(femmodel,VxEnum);
     89                InputToResultx(femmodel,VyEnum);
     90                InputToResultx(femmodel,VelEnum);
     91                InputToResultx(femmodel,PressureEnum);
     92                if(dim==3) InputToResultx(femmodel,VzEnum);
    9393                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    9494        }

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

    r15104 r15849  
    2828        if(save_results){
    2929                if(VerboseSolution()) _printf0_("saving results:\n");
    30                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeXEnum);
    31                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeYEnum);
     30                InputToResultx(femmodel,SurfaceSlopeXEnum);
     31                InputToResultx(femmodel,SurfaceSlopeYEnum);
    3232        }
    3333

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

    r15375 r15849  
    2424        if(dakota_analysis && solution_type!=TransientSolutionEnum){
    2525                femmodel->SetCurrentConfiguration(ThermalAnalysisEnum);
    26                 ResetConstraintsx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     26                ResetConstraintsx(femmodel);
    2727        }
    2828
    … …  
    3737        if(save_results){
    3838                if(VerboseSolution()) _printf0_("   saving results\n");
    39                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum);
    40                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalforcingsMeltingRateEnum);
     39                InputToResultx(femmodel,TemperatureEnum);
     40                InputToResultx(femmodel,BasalforcingsMeltingRateEnum);
    4141        }
    4242}

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

    r15771 r15849  
    7979                        //Reset Thermal Constraints
    8080                        femmodel->SetCurrentConfiguration(ThermalAnalysisEnum);
    81                         ResetConstraintsx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     81                        ResetConstraintsx(femmodel);
    8282                }
    8383        }
    … …  
    154154                if(save_results){
    155155                        if(VerboseSolution()) _printf0_("   saving transient results\n");
    156                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceEnum);
    157                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedEnum);
    158                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsMassBalanceEnum);
    159                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MaskElementonfloatingiceEnum);
     156                        InputToResultx(femmodel,SurfaceEnum);
     157                        InputToResultx(femmodel,BedEnum);
     158                        InputToResultx(femmodel,SurfaceforcingsMassBalanceEnum);
     159                        InputToResultx(femmodel,MaskElementonfloatingiceEnum);
    160160                        femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    161161
    162162                        if(isdelta18o){
    163                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsMonthlytemperaturesEnum);
    164                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsPrecipitationEnum);
    165                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalFrictionEnum);
     163                                InputToResultx(femmodel,SurfaceforcingsMonthlytemperaturesEnum);
     164                                InputToResultx(femmodel,SurfaceforcingsPrecipitationEnum);
     165                                InputToResultx(femmodel,BasalFrictionEnum);
    166166                        }
    167167                        if(isgroundingline && (groundingline_migration==SubelementMigrationEnum || groundingline_migration==SubelementMigration2Enum)){
    168                                 InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,GLlevelsetEnum);
     168                                InputToResultx(femmodel,GLlevelsetEnum);
    169169                        }
    170170

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

    r15839 r15849  
    649649
    650650        /*get vertex vectors for bed and thickness: */
    651         GetVectorFromInputsx(&thickness,elements,nodes, vertices, loads, materials, parameters, ThicknessEnum,VertexEnum);
    652         GetVectorFromInputsx(&bed      ,elements,nodes, vertices, loads, materials, parameters, BedEnum,      VertexEnum);
     651        GetVectorFromInputsx(&thickness,this, ThicknessEnum,VertexEnum);
     652        GetVectorFromInputsx(&bed      ,this, BedEnum,      VertexEnum);
    653653
    654654        /*Allocate vector*/
    … …  
    665665
    666666        /*Update element inputs*/
    667         InputUpdateFromVectorx(elements,nodes,vertices,loads,materials,parameters,vz,VzMeshEnum,VertexPIdEnum);
     667        InputUpdateFromVectorx(this,vz,VzMeshEnum,VertexPIdEnum);
    668668
    669669        /*Free ressources:*/
    … …  
    731731                case SurfaceLogVelMisfitEnum:    SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
    732732                case SurfaceLogVxVyMisfitEnum:   SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
    733                 case SurfaceAverageVelMisfitEnum:SurfaceAverageVelMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     733                case SurfaceAverageVelMisfitEnum:SurfaceAverageVelMisfitx(responses,this,weight_index); break;
    734734                case ThicknessAbsMisfitEnum:     ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
    735735                case ThicknessAbsGradientEnum:   this->ThicknessAbsGradientx(responses,weight_index); break;
    … …  
    14731473
    14741474                        /*this response was scaled. pick up the response from the inputs: */
    1475                         GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnumx(root),VertexEnum);
     1475                        GetVectorFromInputsx(&vertex_response,this, StringToEnumx(root),VertexEnum);
    14761476
    14771477                        /*Now, average it onto the partition nodes: */
    … …  
    15791579
    15801580        /*Update Mask*/
    1581         InputUpdateFromVectorx(elements,nodes,vertices,loads,materials,parameters,serial_mask,HydrologydcMaskEplactiveEnum,NodeSIdEnum);
     1581        InputUpdateFromVectorx(this,serial_mask,HydrologydcMaskEplactiveEnum,NodeSIdEnum);
    15821582        xDelete<IssmDouble>(serial_mask);
    15831583
    … …  
    16351635
    16361636        /*Update Inputs*/
    1637         InputUpdateFromVectorx(elements,nodes,vertices,loads,materials,parameters,transferg,WaterTransferEnum,NodesEnum);
     1637        InputUpdateFromVectorx(this,transferg,WaterTransferEnum,NodesEnum);
    16381638        delete transferg;
    16391639}

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

    r15771 r15849  
    88#include "../../toolkits/toolkits.h"
    99
    10 void ConstraintsStatex(int* pconverged, int* pnum_unstable_constraints, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads,Materials* materials,  Parameters* parameters){
     10void ConstraintsStatex(int* pconverged, int* pnum_unstable_constraints,FemModel* femmodel){
    1111
    1212        /*output: */
    13         int converged=0;
    14         int num_unstable_constraints=0;
    15         int min_mechanical_constraints=0;
     13        int converged                  = 0;
     14        int num_unstable_constraints   = 0;
     15        int min_mechanical_constraints = 0;
    1616        int analysis_type;
    1717
    … …  
    2020
    2121        /*recover parameters: */
    22         parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
    23         parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     22        femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
     23        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2424
    2525        /*Do we have penalties linked to rifts? In this case, run our special rifts penalty
    … …  
    3131
    3232        #ifdef _HAVE_RIFTS_
    33         if (RiftIsPresent(loads,analysis_type)){
    34                 RiftConstraintsState(&converged,&num_unstable_constraints,loads,min_mechanical_constraints,analysis_type);
     33        if(RiftIsPresent(femmodel->loads,analysis_type)){
     34                RiftConstraintsState(&converged,&num_unstable_constraints,femmodel->loads,min_mechanical_constraints,analysis_type);
    3535        }
    3636        #endif
    3737        #ifdef _HAVE_THERMAL_
    38         if(ThermalIsPresent(loads,analysis_type)){
    39                 ThermalConstraintsState(loads,&converged,&num_unstable_constraints,analysis_type);
     38        if(ThermalIsPresent(femmodel->loads,analysis_type)){
     39                ThermalConstraintsState(femmodel->loads,&converged,&num_unstable_constraints,analysis_type);
    4040        }
    4141        #endif

  • issm/trunk-jpl/src/c/modules/ConstraintsStatex/ConstraintsStatex.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 int   ThermalIsPresent(Loads* loads,int analysis_type);
    12 int    RiftIsPresent(Loads* loads,int analysis_type);
    13 void ConstraintsStatex(int* pconverged, int* pnum_unstable_constraints, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads,Materials* materials,  Parameters* parameters);
     11int  ThermalIsPresent(Loads* loads,int analysis_type);
     12int  RiftIsPresent(Loads* loads,int analysis_type);
     13void ConstraintsStatex(int* pconverged, int* pnum_unstable_constraints,FemModel* femmodel);
    1414
    1515#endif  /* _CONSTRAINTSSTATEX_H */

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

    r15104 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void    GetSolutionFromInputsx( Vector<IssmDouble>** psolution, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters){
     9void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel){
    1010
    1111        /*intermediary: */
    12         int gsize;
    13         int i;
    14         Element* element=NULL;
     12        int      gsize;
     13        Element* element = NULL;
    1514
    1615        int configuration_type;
    … …  
    2221
    2322        /*retrive parameters: */
    24         parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
     23        femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2524
    2625        /*Get size of vector: */
    27         gsize=nodes->NumberOfDofs(configuration_type,GsetEnum);
    28         if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: " << EnumToStringx(configuration_type));
     26        gsize=femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     27        if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: " << EnumToStringx(configuration_type));
    2928
    3029        /*Initialize solution: */
    … …  
    3231
    3332        /*Go through elements and plug solution: */
    34         for (i=0;i<elements->Size();i++){
    35                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     33        for(int i=0;i<femmodel->elements->Size();i++){
     34                element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3635                element->GetSolutionFromInputs(solution);
    3736        }
    … …  
    4241        /*Assign output pointers:*/
    4342        *psolution=solution;
    44 
    4543}

  • issm/trunk-jpl/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void GetSolutionFromInputsx( Vector<IssmDouble>** psolution, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters);
     11void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel);
    1212
    1313#endif  /* _GETSOLUTIONFROMINPUTSXX_H */

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

    r14999 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void GetVectorFromInputsx( Vector<IssmDouble>** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, int name, int type){
     9void GetVectorFromInputsx( Vector<IssmDouble>** pvector,FemModel* femmodel,int name,int type){
    1010
    1111        int i;
    … …  
    1515
    1616                /*Allocate vector*/
    17                 vector=new Vector<IssmDouble>(vertices->NumberOfVertices());
     17                vector=new Vector<IssmDouble>(femmodel->vertices->NumberOfVertices());
    1818
    1919                /*Look up in elements*/
    20                 for(i=0;i<elements->Size();i++){
    21                         Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     20                for(i=0;i<femmodel->elements->Size();i++){
     21                        Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2222                        element->GetVectorFromInputs(vector,name);
    2323                }
    2424
    2525                /*Look up in materials*/
    26                 for(i=0;i<materials->Size();i++){
    27                         Material* material=(Material*)materials->GetObjectByOffset(i);
     26                for(i=0;i<femmodel->materials->Size();i++){
     27                        Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    2828                        material->GetVectorFromInputs(vector,name);
    2929                }
    … …  
    3939}
    4040
    41 void GetVectorFromInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, int name, int type){
     41void GetVectorFromInputsx(IssmDouble** pvector,FemModel* femmodel,int name, int type){
    4242
    4343        /*output: */
    … …  
    4747        Vector<IssmDouble>* vec_vector=NULL;
    4848
    49         GetVectorFromInputsx( &vec_vector, elements,nodes, vertices, loads, materials, parameters, name, type);
     49        GetVectorFromInputsx(&vec_vector,femmodel,name,type);
    5050        vector=vec_vector->ToMPISerial();
    5151

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

    r15000 r15849  
    88
    99/* local prototypes: */
    10 void    GetVectorFromInputsx( Vector<IssmDouble>** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,int name,int type);
    11 void    GetVectorFromInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,int name,int type);
     10void    GetVectorFromInputsx( Vector<IssmDouble>** pvector,FemModel* femmodel,int name,int type);
     11void    GetVectorFromInputsx( IssmDouble** pvector,FemModel* femmodel,int name,int type);
    1212
    1313#endif  /* _GETVECTORFROMINPUTSXX_H */

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

    r14999 r15849  
    88#include "../../toolkits/toolkits.h"
    99
    10 void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type){
     10void InputToResultx(FemModel* femmodel,int enum_type){
    1111
    1212        /*intermediary:*/
    13         int      step;
    14         IssmDouble   time;
    15         Element *element = NULL;
     13        int        step;
     14        IssmDouble time;
     15        Element   *element = NULL;
    1616
    1717        /*Get time and step*/
    18         parameters->FindParam(&step,StepEnum);
    19         parameters->FindParam(&time,TimeEnum);
     18        femmodel->parameters->FindParam(&step,StepEnum);
     19        femmodel->parameters->FindParam(&time,TimeEnum);
    2020
    2121        /*Go through elemnets, and ask each element to transfer the enum_type input into the results dataset, with step and time information: */
    22         for(int i=0;i<elements->Size();i++){
    23 
    24                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     22        for(int i=0;i<femmodel->elements->Size();i++){
     23                element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2524                element->InputToResult(enum_type,step,time);
    2625        }

  • issm/trunk-jpl/src/c/modules/InputToResultx/InputToResultx.h

    r14996 r15849  
    99
    1010/* local prototypes: */
    11 void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type);
     11void InputToResultx(FemModel* femmodel,int enum_type);
    1212
    1313#endif  /* _INPUTTORESULTX_H */

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

    r15104 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool  constant, int name){
     9void InputUpdateFromConstantx(FemModel* femmodel,bool constant, int name){
    1010
    1111        int i;
    … …  
    1313
    1414        /*Elements and loads drive the update: */
    15         for(i=0;i<elements->Size();i++){
    16                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     15        for(i=0;i<femmodel->elements->Size();i++){
     16                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1717                element->InputUpdateFromConstant(constant,name);
    1818        }
    1919
    20         for(i=0;i<loads->Size();i++){
    21                 Load* load=(Load*)loads->GetObjectByOffset(i);
     20        for(i=0;i<femmodel->loads->Size();i++){
     21                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    2222                load->InputUpdateFromConstant(constant,name);
    2323        }
    2424
    25         for(i=0;i<materials->Size();i++){
    26                 Material* material=(Material*)materials->GetObjectByOffset(i);
     25        for(i=0;i<femmodel->materials->Size();i++){
     26                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    2727                material->InputUpdateFromConstant(constant,name);
    2828        }
    2929}
    30 void InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int    constant, int name){
     30void InputUpdateFromConstantx(FemModel* femmodel,int constant, int name){
    3131
    3232        int i;
    … …  
    3434
    3535        /*Elements and loads drive the update: */
    36         for(i=0;i<elements->Size();i++){
    37                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     36        for(i=0;i<femmodel->elements->Size();i++){
     37                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3838                element->InputUpdateFromConstant(constant,name);
    3939        }
    4040
    41         for(i=0;i<loads->Size();i++){
    42                 Load* load=(Load*)loads->GetObjectByOffset(i);
     41        for(i=0;i<femmodel->loads->Size();i++){
     42                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    4343                load->InputUpdateFromConstant(constant,name);
    4444        }
    4545
    46         for(i=0;i<materials->Size();i++){
    47                 Material* material=(Material*)materials->GetObjectByOffset(i);
     46        for(i=0;i<femmodel->materials->Size();i++){
     47                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    4848                material->InputUpdateFromConstant(constant,name);
    4949        }
    5050}
    51 void InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble constant, int name){
     51void InputUpdateFromConstantx(FemModel* femmodel,IssmDouble constant, int name){
    5252
    5353        int i;
    … …  
    5555
    5656        /*Elements and loads drive the update: */
    57         for(i=0;i<elements->Size();i++){
    58                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     57        for(i=0;i<femmodel->elements->Size();i++){
     58                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    5959                element->InputUpdateFromConstant(constant,name);
    6060        }
    6161
    62         for(i=0;i<loads->Size();i++){
    63                 Load* load=(Load*)loads->GetObjectByOffset(i);
     62        for(i=0;i<femmodel->loads->Size();i++){
     63                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    6464                load->InputUpdateFromConstant(constant,name);
    6565        }
    6666
    67         for(i=0;i<materials->Size();i++){
    68                 Material* material=(Material*)materials->GetObjectByOffset(i);
     67        for(i=0;i<femmodel->materials->Size();i++){
     68                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    6969                material->InputUpdateFromConstant(constant,name);
    7070        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromConstantx/InputUpdateFromConstantx.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void            InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters, bool   constant, int name);
    12 void            InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters, int    constant, int name);
    13 void            InputUpdateFromConstantx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters, IssmDouble constant, int name);
     11void InputUpdateFromConstantx(FemModel* femmode,bool   constant    ,int name);
     12void InputUpdateFromConstantx(FemModel* femmode,int    constant    ,int name);
     13void InputUpdateFromConstantx(FemModel* femmode,IssmDouble constant,int name);
    1414
    1515#endif  /* _UPDATEINPUTSFROMCONSTANTXX_H */

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

    r14999 r15849  
    1010#include "../InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h"
    1111
    12 void  InputUpdateFromDakotax(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials*  materials,Parameters* parameters,double* variables,char* *variables_descriptors,int numvariables){
     12void InputUpdateFromDakotax(FemModel* femmodel,double* variables,char* *variables_descriptors,int numvariables){
    1313
    1414        int     i,j,k,l;
    … …  
    2727
    2828        /*retrieve parameters: */
    29         parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
    30         parameters->FindParam(&qmu_part,&dummy,QmuPartitionEnum);
    31         numberofvertices=vertices->NumberOfVertices();
     29        femmodel->parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
     30        femmodel->parameters->FindParam(&qmu_part,&dummy,QmuPartitionEnum);
     31        numberofvertices=femmodel->vertices->NumberOfVertices();
    3232
    3333        /*Go through all dakota descriptors, ex: "rho_ice","thermal_conductivity","thickness1","thickness2", etc ..., and
    … …  
    5454
    5555                        /*Now, pick up the parameter corresponding to root: */
    56                         parameters->FindParam(&parameter,&nrows,&ncols,StringToEnumx(root));
     56                        femmodel->parameters->FindParam(&parameter,&nrows,&ncols,StringToEnumx(root));
    5757
    5858                        /*We've got the parameter, we need to update it using qmu_part (a partitioning vector),
    … …  
    8383
    8484                        /*Update inputs using the parameter matrix: */
    85                         InputUpdateFromMatrixDakotax( elements,nodes, vertices,loads, materials,  parameters, parameter, nrows,ncols,StringToEnumx(root), VertexEnum);
     85                        InputUpdateFromMatrixDakotax(femmodel, parameter, nrows,ncols,StringToEnumx(root), VertexEnum);
    8686
    8787                        /*increment i to skip the distributed values just collected: */
    … …  
    100100                else{
    101101                        /*Ok, standard variable, just update inputs using the variable: */
    102                         InputUpdateFromConstantx( elements,nodes, vertices,loads, materials,  parameters, variables[i],StringToEnumx(descriptor));
     102                        InputUpdateFromConstantx(femmodel,variables[i],StringToEnumx(descriptor));
    103103                }
    104104        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h

    r15000 r15849  
    88#include "../../classes/classes.h"
    99
    10 void  InputUpdateFromDakotax(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials*  materials,Parameters* parameters,double* variables,char* *variables_descriptors,int numvariables);
     10void  InputUpdateFromDakotax(FemModel* femmodel,double* variables,char* *variables_descriptors,int numvariables);
    1111
    1212#endif  /* _INPUTUPDATEFROMDAKOTAXX_H */

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

    r14999 r15849  
    88#include "../InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h"
    99
    10 void InputUpdateFromMatrixDakotax( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* matrix,int nrows,int ncols, int name, int type){
     10void InputUpdateFromMatrixDakotax(FemModel* femmodel,double* matrix,int nrows,int ncols, int name, int type){
    1111
    1212        int i;
    1313        int numberofvertices;
    1414
    15         numberofvertices=vertices->NumberOfVertices();
     15        numberofvertices=femmodel->vertices->NumberOfVertices();
    1616
    17         if((ncols==1) && (nrows==numberofvertices)) InputUpdateFromVectorDakotax( elements,nodes, vertices,loads, materials,  parameters,matrix, name,type);
     17        if((ncols==1) && (nrows==numberofvertices)) InputUpdateFromVectorDakotax(femmodel,matrix,name,type);
    1818        else{
    1919
    2020                /*Update elements, nodes, loads and materials from inputs: */
    21                 for(i=0;i<elements->Size();i++){
    22                         Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     21                for(i=0;i<femmodel->elements->Size();i++){
     22                        Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2323                        element->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    2424                }
    25                 for(i=0;i<nodes->Size();i++){
    26                         Node* node=(Node*)nodes->GetObjectByOffset(i);
     25                for(i=0;i<femmodel->nodes->Size();i++){
     26                        Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    2727                        node->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    2828                }
    29                 for(i=0;i<loads->Size();i++){
    30                         Load* load=(Load*)loads->GetObjectByOffset(i);
     29                for(i=0;i<femmodel->loads->Size();i++){
     30                        Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    3131                        load->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    3232                }
    33                 for(i=0;i<materials->Size();i++){
    34                         Material* material=(Material*)materials->GetObjectByOffset(i);
     33                for(i=0;i<femmodel->materials->Size();i++){
     34                        Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    3535                        material->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    3636                }
    3737        }
    38 
    3938}

  • issm/trunk-jpl/src/c/modules/InputUpdateFromMatrixDakotax/InputUpdateFromMatrixDakotax.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void InputUpdateFromMatrixDakotax( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* matrix,int nrows,int ncols, int name, int type);
     11void InputUpdateFromMatrixDakotax(FemModel* femmodel,double* matrix,int nrows,int ncols, int name, int type);
    1212
    1313#endif  /* _UPDATEINPUTSFROMMATRIXDAKOTAXX_H */

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

    r14999 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Vector<IssmDouble>* solution){
    10 
    11         IssmDouble* serial_solution=NULL;
     9void InputUpdateFromSolutionx(FemModel* femmodel,Vector<IssmDouble>* solution){
    1210
    1311        /*Serialize solution, so that elements can index into it on every CPU: */
    14         serial_solution=solution->ToMPISerial();
     12        IssmDouble* serial_solution=solution->ToMPISerial();
    1513
    1614        /*Call overloaded form of InputUpdateFromSolutionx: */
    17         InputUpdateFromSolutionx( elements, nodes,  vertices,  loads,  materials,  parameters,serial_solution);
     15        InputUpdateFromSolutionx(femmodel,serial_solution);
    1816
    19         /*Free ressources:*/
     17        /*cleanup and return*/
    2018        xDelete<IssmDouble>(serial_solution);
    2119}
    2220
    23 void InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* solution){
     21void InputUpdateFromSolutionx(FemModel* femmodel,IssmDouble* solution){
    2422
    25         /*Intermediary*/
    26         int i;
    27         Element* element=NULL;
    28 
    29         /*Elements drive the update: */
    30         for (i=0;i<elements->Size();i++){
    31                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     23        for(int i=0;i<femmodel->elements->Size();i++){
     24                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3225                element->InputUpdateFromSolution(solution);
    3326        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void            InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,Vector<IssmDouble>* solution);
    12 void        InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* solution);
    13 
    14 //with timestep
    15 void            InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,Vector<IssmDouble>* solution,int timestep);
    16 void        InputUpdateFromSolutionx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* solution, int timestep);
     11void    InputUpdateFromSolutionx(FemModel* femmodel,Vector<IssmDouble>* solution);
     12void  InputUpdateFromSolutionx(FemModel* femmodel,IssmDouble* solution);
    1713
    1814#endif  /* _UPDATEINPUTSFROMSOLUTIONXX_H */

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

    r14999 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Vector<IssmDouble>* vector, int name, int type){
     9void InputUpdateFromVectorDakotax(FemModel* femmodel,Vector<IssmDouble>* vector, int name, int type){
    1010
    11         double* serial_vector=NULL;
    12 
    13         serial_vector=vector->ToMPISerial();
    14 
    15         InputUpdateFromVectorDakotax( elements,nodes, vertices, loads, materials, parameters,serial_vector,name, type);
     11        IssmDouble* serial_vector=vector->ToMPISerial();
     12        InputUpdateFromVectorDakotax(femmodel,serial_vector,name, type);
    1613
    1714        /*Free ressources:*/
    … …  
    1916}
    2017
    21 void InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* vector, int name, int type){
     18void InputUpdateFromVectorDakotax(FemModel* femmodel,IssmDouble* vector, int name, int type){
    2219
    2320        int i;
    2421
    2522        /*Update elements, nodes, loads and materials from inputs: */
    26         for(i=0;i<elements->Size();i++){
    27                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     23        for(i=0;i<femmodel->elements->Size();i++){
     24                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2825                element->InputUpdateFromVectorDakota(vector,name,type);
    2926        }
    30         for(i=0;i<nodes->Size();i++){
    31                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     27        for(i=0;i<femmodel->nodes->Size();i++){
     28                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    3229                node->InputUpdateFromVectorDakota(vector,name,type);
    3330        }
    34         for(i=0;i<loads->Size();i++){
    35                 Load* load=(Load*)loads->GetObjectByOffset(i);
     31        for(i=0;i<femmodel->loads->Size();i++){
     32                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    3633                load->InputUpdateFromVectorDakota(vector,name,type);
    3734        }
    38         for(i=0;i<materials->Size();i++){
    39                 Material* material=(Material*)materials->GetObjectByOffset(i);
     35        for(i=0;i<femmodel->materials->Size();i++){
     36                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    4037                material->InputUpdateFromVectorDakota(vector,name,type);
    4138        }
    4239}
    4340
    44 void InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int* vector, int name, int type){
     41void InputUpdateFromVectorDakotax(FemModel* femmodel,int* vector, int name, int type){
    4542
    4643        int i;
    4744
    4845        /*Update elements, nodes, loads and materials from inputs: */
    49         for(i=0;i<elements->Size();i++){
    50                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     46        for(i=0;i<femmodel->elements->Size();i++){
     47                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    5148                element->InputUpdateFromVectorDakota(vector,name,type);
    5249        }
    53         for(i=0;i<nodes->Size();i++){
    54                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     50        for(i=0;i<femmodel->nodes->Size();i++){
     51                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    5552                node->InputUpdateFromVectorDakota(vector,name,type);
    5653        }
    57         for(i=0;i<loads->Size();i++){
    58                 Load* load=(Load*)loads->GetObjectByOffset(i);
     54        for(i=0;i<femmodel->loads->Size();i++){
     55                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    5956                load->InputUpdateFromVectorDakota(vector,name,type);
    6057        }
    61         for(i=0;i<materials->Size();i++){
    62                 Material* material=(Material*)materials->GetObjectByOffset(i);
     58        for(i=0;i<femmodel->materials->Size();i++){
     59                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    6360                material->InputUpdateFromVectorDakota(vector,name,type);
    6461        }
    … …  
    7067
    7168        /*Update elements, nodes, loads and materials from inputs: */
    72         for(i=0;i<elements->Size();i++){
    73                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     69        for(i=0;i<femmodel->elements->Size();i++){
     70                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    7471                element->InputUpdateFromVectorDakota(vector,name,type);
    7572        }
    76         for(i=0;i<nodes->Size();i++){
    77                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     73        for(i=0;i<femmodel->nodes->Size();i++){
     74                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    7875                node->InputUpdateFromVectorDakota(vector,name,type);
    7976        }
    80         for(i=0;i<loads->Size();i++){
    81                 Load* load=(Load*)loads->GetObjectByOffset(i);
     77        for(i=0;i<femmodel->loads->Size();i++){
     78                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    8279                load->InputUpdateFromVectorDakota(vector,name,type);
    8380        }
    84         for(i=0;i<materials->Size();i++){
    85                 Material* material=(Material*)materials->GetObjectByOffset(i);
     81        for(i=0;i<femmodel->materials->Size();i++){
     82                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    8683                material->InputUpdateFromVectorDakota(vector,name,type);
    8784        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void    InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,Vector<IssmDouble>* vector, int name,int type);
    12 void    InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,double* vector, int name,int type);
    13 void    InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,int* vector, int name,int type);
    14 void    InputUpdateFromVectorDakotax( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,bool* vector, int name,int type);
     11void    InputUpdateFromVectorDakotax(FemModel* femmodel,Vector<IssmDouble>* vector, int name,int type);
     12void    InputUpdateFromVectorDakotax(FemModel* femmodel,IssmDouble* vector, int name,int type);
     13void    InputUpdateFromVectorDakotax(FemModel* femmodel,int* vector, int name,int type);
     14void    InputUpdateFromVectorDakotax(FemModel* femmodel,bool* vector, int name,int type);
    1515
    1616#endif  /* _UPDATEINPUTSFROMVECTORDAKOTAXX_H */

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

    r14999 r15849  
    77#include "../../toolkits/toolkits.h"
    88
    9 void InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Vector<IssmDouble>* vector, int name, int type){
     9void InputUpdateFromVectorx(FemModel* femmodel,Vector<IssmDouble>* vector, int name, int type){
    1010
    11         IssmDouble* serial_vector=NULL;
    12 
    13         serial_vector=vector->ToMPISerial();
    14 
    15         InputUpdateFromVectorx( elements,nodes, vertices, loads, materials, parameters,serial_vector,name, type);
    16 
    17         /*Free ressources:*/
     11        IssmDouble* serial_vector=vector->ToMPISerial();
     12        InputUpdateFromVectorx(femmodel,serial_vector,name,type);
    1813        xDelete<IssmDouble>(serial_vector);
    1914}
    2015
    21 void InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* vector, int name, int type){
     16void InputUpdateFromVectorx(FemModel* femmodel,IssmDouble* vector, int name, int type){
    2217
    2318        int i;
    2419
    2520        /*Update elements, nodes, loads and materials from inputs: */
    26         for(i=0;i<elements->Size();i++){
    27                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     21        for(i=0;i<femmodel->elements->Size();i++){
     22                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2823                element->InputUpdateFromVector(vector,name,type);
    2924        }
    30         for(i=0;i<nodes->Size();i++){
    31                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     25        for(i=0;i<femmodel->nodes->Size();i++){
     26                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    3227                node->InputUpdateFromVector(vector,name,type);
    3328        }
    34         for(i=0;i<loads->Size();i++){
    35                 Load* load=(Load*)loads->GetObjectByOffset(i);
     29        for(i=0;i<femmodel->loads->Size();i++){
     30                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    3631                load->InputUpdateFromVector(vector,name,type);
    3732        }
    38         for(i=0;i<materials->Size();i++){
    39                 Material* material=(Material*)materials->GetObjectByOffset(i);
     33        for(i=0;i<femmodel->materials->Size();i++){
     34                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    4035                material->InputUpdateFromVector(vector,name,type);
    4136        }
    4237}
    4338
    44 void InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int* vector, int name, int type){
     39void InputUpdateFromVectorx(FemModel* femmodel,int* vector, int name, int type){
    4540
    4641        int i;
    4742
    4843        /*Update elements, nodes, loads and materials from inputs: */
    49         for(i=0;i<elements->Size();i++){
    50                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     44        for(i=0;i<femmodel->elements->Size();i++){
     45                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    5146                element->InputUpdateFromVector(vector,name,type);
    5247        }
    53         for(i=0;i<nodes->Size();i++){
    54                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     48        for(i=0;i<femmodel->nodes->Size();i++){
     49                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    5550                node->InputUpdateFromVector(vector,name,type);
    5651        }
    57         for(i=0;i<loads->Size();i++){
    58                 Load* load=(Load*)loads->GetObjectByOffset(i);
     52        for(i=0;i<femmodel->loads->Size();i++){
     53                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    5954                load->InputUpdateFromVector(vector,name,type);
    6055        }
    61         for(i=0;i<materials->Size();i++){
    62                 Material* material=(Material*)materials->GetObjectByOffset(i);
     56        for(i=0;i<femmodel->materials->Size();i++){
     57                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    6358                material->InputUpdateFromVector(vector,name,type);
    6459        }
    6560}
    6661
    67 void InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool* vector, int name, int type){
     62void InputUpdateFromVectorx(FemModel* femmodel,bool* vector, int name, int type){
    6863
    6964        int i;
    7065
    7166        /*Update elements, nodes, loads and materials from inputs: */
    72         for(i=0;i<elements->Size();i++){
    73                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     67        for(i=0;i<femmodel->elements->Size();i++){
     68                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    7469                element->InputUpdateFromVector(vector,name,type);
    7570        }
    76         for(i=0;i<nodes->Size();i++){
    77                 Node* node=(Node*)nodes->GetObjectByOffset(i);
     71        for(i=0;i<femmodel->nodes->Size();i++){
     72                Node* node=(Node*)femmodel->nodes->GetObjectByOffset(i);
    7873                node->InputUpdateFromVector(vector,name,type);
    7974        }
    80         for(i=0;i<loads->Size();i++){
    81                 Load* load=(Load*)loads->GetObjectByOffset(i);
     75        for(i=0;i<femmodel->loads->Size();i++){
     76                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    8277                load->InputUpdateFromVector(vector,name,type);
    8378        }
    84         for(i=0;i<materials->Size();i++){
    85                 Material* material=(Material*)materials->GetObjectByOffset(i);
     79        for(i=0;i<femmodel->materials->Size();i++){
     80                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    8681                material->InputUpdateFromVector(vector,name,type);
    8782        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromVectorx/InputUpdateFromVectorx.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void    InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,Vector<IssmDouble>* vector, int name,int type);
    12 void    InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,IssmDouble* vector, int name,int type);
    13 void    InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,int* vector, int name,int type);
    14 void    InputUpdateFromVectorx( Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,bool* vector, int name,int type);
     11void    InputUpdateFromVectorx(FemModel* femmodel,Vector<IssmDouble>* vector, int name,int type);
     12void    InputUpdateFromVectorx(FemModel* femmodel,IssmDouble* vector, int name,int type);
     13void    InputUpdateFromVectorx(FemModel* femmodel,int* vector, int name,int type);
     14void    InputUpdateFromVectorx(FemModel* femmodel,bool* vector, int name,int type);
    1515
    1616#endif  /* _UPDATEINPUTSFROMVECTORXX_H */

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

    r15384 r15849  
    1414#include "../ConstraintsStatex/ConstraintsStatex.h"
    1515
    16 void ResetConstraintsx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads,Materials* materials,  Parameters* parameters){
     16void ResetConstraintsx(FemModel* femmodel){
    1717
    18         /*output: */
    19         int analysis_type;
    2018
    2119        /*Display message*/
    … …  
    2321
    2422        /*recover parameters: */
    25         parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     23        int analysis_type;
     24        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2625
    2726        /*Do we have penalties linked to rifts? In this case, run our special rifts penalty
    2827         * management routine, otherwise, skip : */
    2928        #ifdef _HAVE_RIFTS_
    30         if (RiftIsPresent(loads,analysis_type)){
     29        if(RiftIsPresent(femmodel->loads,analysis_type)){
    3130                _error_("rift constraints reset not supported yet!");
    3231        }
    3332        #endif
    3433        #ifdef _HAVE_THERMAL_
    35         if(ThermalIsPresent(loads,analysis_type)){
    36                 ThermalConstraintsReset(loads,analysis_type);
     34        if(ThermalIsPresent(femmodel->loads,analysis_type)){
     35                ThermalConstraintsReset(femmodel->loads,analysis_type);
    3736        }
    3837        #endif
    39 
    4038}

  • issm/trunk-jpl/src/c/modules/ResetConstraintsx/ResetConstraintsx.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void  ThermalConstraintsReset(Loads* loads, int configuration_type);
    12 void ResetConstraintsx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads,Materials* materials,  Parameters* parameters);
     11void ThermalConstraintsReset(Loads* loads, int configuration_type);
     12void ResetConstraintsx(FemModel* femmodel);
    1313
    1414#endif  /* _RESETCONSTRAINTSX_H */

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

    r15838 r15849  
    99#include "../InputUpdateFromConstantx/InputUpdateFromConstantx.h"
    1010
    11 void SurfaceAreax( IssmDouble* pS, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     11void SurfaceAreax(IssmDouble* pS,FemModel* femmodel){
    1212
    1313        /*Intermediary*/
    1414        Element* element=NULL;
    15         int i;
    1615
    1716        /*output: */
    18         IssmDouble S=0;
     17        IssmDouble S = 0.;
    1918        IssmDouble S_sum;
    2019
    2120        /*Compute gradients: */
    22         for (i=0;i<elements->Size();i++){
    23                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     21        for(int i=0;i<femmodel->elements->Size();i++){
     22                element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2423                S+=element->SurfaceArea();
    2524        }
    … …  
    3130
    3231        /*add surface area to element inputs:*/
    33         InputUpdateFromConstantx(elements,nodes,vertices,loads,materials,parameters,S,SurfaceAreaEnum);
     32        InputUpdateFromConstantx(femmodel,S,SurfaceAreaEnum);
    3433
    3534        /*Assign output pointers: */

  • issm/trunk-jpl/src/c/modules/SurfaceAreax/SurfaceAreax.h

    r15000 r15849  
    99
    1010/* local prototypes: */
    11 void SurfaceAreax( IssmDouble* pS, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     11void SurfaceAreax(IssmDouble* pS,FemModel* femmodel);
    1212
    1313#endif  /* _SURFACEAREAX_H */

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

    r15838 r15849  
    99#include "../SurfaceAreax/SurfaceAreax.h"
    1010
    11 void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
     11void SurfaceAverageVelMisfitx(IssmDouble* pJ,FemModel* femmodel,int weight_index){
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        Element* element=NULL;
    1615
    1716        /*output: */
    18         IssmDouble J=0;
     17        IssmDouble J = 0.;
    1918        IssmDouble J_sum;
    2019
    2120        /*Compute surface area and add to elements inputs */
    22         SurfaceAreax(NULL,elements,nodes,vertices, loads,materials,parameters);
     21        SurfaceAreax(NULL,femmodel);
    2322
    2423        /*Compute Misfit: */
    25         for (i=0;i<elements->Size();i++){
    26                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     24        for(int i=0;i<femmodel->elements->Size();i++){
     25                element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2726                J+=element->SurfaceAverageVelMisfit(weight_index);
    2827        }

  • issm/trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.h

    r15130 r15849  
    99
    1010/* local prototypes: */
    11 void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
     11void SurfaceAverageVelMisfitx(IssmDouble* pJ,FemModel* femmodel,int weight_index);
    1212
    1313#endif

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_adjoint_linear.cpp

    r15002 r15849  
    3131        Solverx(&uf, Kff, pf, NULL, df, femmodel->parameters); delete Kff; delete pf; delete df;
    3232        Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters,true); delete ys; //true means spc0
    33         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
     33        InputUpdateFromSolutionx(femmodel,ug);
    3434        delete ug; delete uf;
    3535}

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_hydro_nonlinear.cpp

    r15643 r15849  
    5050        /*Retrieve inputs as the initial state for the non linear iteration*/
    5151        //femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
    52         GetSolutionFromInputsx(&ug_sed, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     52        GetSolutionFromInputsx(&ug_sed,femmodel);
    5353
    5454        if(isefficientlayer) {
    5555                femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    56                 GetSolutionFromInputsx(&ug_epl, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     56                GetSolutionFromInputsx(&ug_epl,femmodel);
    5757        }
    5858
    … …  
    7070
    7171                femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
    72                 InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
    73                 InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
     72                InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     73                InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
    7474                femmodel->UpdateConstraintsx();
    7575                femmodel->parameters->SetParam(HydrologySedimentEnum,HydrologyLayerEnum);
    … …  
    9090                        delete ug_sed;
    9191                        Mergesolutionfromftogx(&ug_sed,uf_sed,ys,femmodel->nodes,femmodel->parameters); delete ys;
    92                         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_sed);
    93                         ConstraintsStatex(&constraints_converged,&num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     92                        InputUpdateFromSolutionx(femmodel,ug_sed);
     93                        ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
    9494
    9595                        if (!sedconverged){
    … …  
    104104                        if(sedconverged){
    105105                                femmodel->parameters->SetParam(sediment_kmax,HydrologySedimentKmaxEnum);
    106                                 InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sedconverged,ConvergedEnum);
    107                                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_sed);
    108                                 InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sediment_kmax,HydrologySedimentKmaxEnum);
     106                                InputUpdateFromConstantx(femmodel,sedconverged,ConvergedEnum);
     107                                InputUpdateFromSolutionx(femmodel,ug_sed);
     108                                InputUpdateFromConstantx(femmodel,sediment_kmax,HydrologySedimentKmaxEnum);
    109109                                break;
    110110                        }
    … …  
    114114                if(isefficientlayer){
    115115                        femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    116                         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
    117                         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
     116                        InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     117                        InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
    118118                        femmodel->HydrologyEPLupdateDomainx();
    119119                        femmodel->parameters->SetParam(HydrologyEfficientEnum,HydrologyLayerEnum);
    … …  
    134134                                delete ug_epl;
    135135                                Mergesolutionfromftogx(&ug_epl,uf_epl,ys,femmodel->nodes,femmodel->parameters); delete ys;
    136                                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_epl);
    137                                 ConstraintsStatex(&constraints_converged,&num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     136                                InputUpdateFromSolutionx(femmodel,ug_epl);
     137                                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
    138138                                femmodel->HydrologyEPLupdateDomainx();                 
    139139
    … …  
    148148
    149149                                if(eplconverged){
    150                                         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,eplconverged,ConvergedEnum);
    151                                         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sediment_kmax,MeltingOffsetEnum);
    152                                         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_epl);
     150                                        InputUpdateFromConstantx(femmodel,eplconverged,ConvergedEnum);
     151                                        InputUpdateFromConstantx(femmodel,sediment_kmax,MeltingOffsetEnum);
     152                                        InputUpdateFromSolutionx(femmodel,ug_epl);
    153153                                        break;
    154154                                }
    … …  
    207207        }
    208208
    209         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_sed);
    210         if(isefficientlayer)InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_epl);
     209        InputUpdateFromSolutionx(femmodel,ug_sed);
     210        if(isefficientlayer)InputUpdateFromSolutionx(femmodel,ug_epl);
    211211
    212212        /*Free ressources: */

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_linear.cpp

    r15002 r15849  
    3535//#endif
    3636        Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters);delete uf; delete ys;
    37         InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
     37        InputUpdateFromSolutionx(femmodel,ug);
    3838        delete ug; 
    3939}

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp

    r15771 r15849  
    4242
    4343        /*Start non-linear iteration using input velocity: */
    44         GetSolutionFromInputsx(&ug,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     44        GetSolutionFromInputsx(&ug,femmodel);
    4545        Reducevectorgtofx(&uf,ug,femmodel->nodes,femmodel->parameters);
    4646
    4747        //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    48         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,converged,ConvergedEnum);
    49         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
     48        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
     49        InputUpdateFromSolutionx(femmodel,ug);
    5050
    5151        for(;;){
    … …  
    6161                        Solverx(&uf,Kff,pf,old_uf,df,femmodel->parameters);delete df; delete Kff; delete pf;
    6262                        Mergesolutionfromftogx(&ug,uf,ys,femmodel->nodes,femmodel->parameters);delete ys;
    63                         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
     63                        InputUpdateFromSolutionx(femmodel,ug);
    6464                        delete old_ug;old_ug=ug;
    6565                        delete old_uf;old_uf=uf;
    … …  
    8080                uf->AXPY(duf, 1.0); delete duf;
    8181                Mergesolutionfromftogx(&ug,uf,ys,femmodel->nodes,femmodel->parameters);delete ys;
    82                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
     82                InputUpdateFromSolutionx(femmodel,ug);
    8383
    8484                /*Check convergence*/

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp

    r15771 r15849  
    4747
    4848        /*Start non-linear iteration using input velocity: */
    49         GetSolutionFromInputsx(&ug, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     49        GetSolutionFromInputsx(&ug,femmodel);
    5050        Reducevectorgtofx(&uf, ug, femmodel->nodes,femmodel->parameters);
    5151
    5252        //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    53         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
    54         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
     53        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
     54        InputUpdateFromSolutionx(femmodel,ug);
    5555
    5656        for(;;){
    … …  
    6767
    6868                convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters); delete Kff; delete pf; delete df;
    69                 InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
    70                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
     69                InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
     70                InputUpdateFromSolutionx(femmodel,ug);
    7171
    72                 ConstraintsStatex(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     72                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
    7373                if(VerboseConvergence()) _printf0_("   number of unstable constraints: " << num_unstable_constraints << "\n");
    7474
    … …  
    9393                        _printf0_("   maximum number of nonlinear iterations (" << max_nonlinear_iterations << ") exceeded\n");
    9494                        converged=true;
    95                         InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
    96                         InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);               
     95                        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
     96                        InputUpdateFromSolutionx(femmodel,ug);         
    9797                        bool max_iteration_state=true;
    9898                        int tempStep=1;

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp

    r15771 r15849  
    4444        /*First get ug_horiz:*/
    4545        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    46         GetSolutionFromInputsx(&ug_horiz, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters);
     46        GetSolutionFromInputsx(&ug_horiz,femmodel);
    4747        Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodes,femmodel->parameters);
    4848
    … …  
    5454
    5555                //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    56                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
     56                InputUpdateFromSolutionx(femmodel,ug_horiz);
    5757                delete ug_horiz;
    5858
    … …  
    6666                Solverx(&uf_horiz, Kff_horiz, pf_horiz, old_uf_horiz, df_horiz,femmodel->parameters);
    6767                Mergesolutionfromftogx(&ug_horiz, uf_horiz,ys,femmodel->nodes,femmodel->parameters); delete ys;
    68                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
     68                InputUpdateFromSolutionx(femmodel,ug_horiz);
    6969
    7070                convergence(&converged,Kff_horiz,pf_horiz,uf_horiz,old_uf_horiz,femmodel->parameters); delete Kff_horiz; delete pf_horiz; delete df_horiz;
    … …  
    8282                delete uf_vert;
    8383                delete ys;
    84                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_vert);
     84                InputUpdateFromSolutionx(femmodel,ug_vert);
    8585                delete ug_vert;
    8686

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_thermal_nonlinear.cpp

    r15457 r15849  
    4141        converged=false;
    4242
    43         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
    44         InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
     43        InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     44        InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
    4545        femmodel->UpdateConstraintsx();
    4646
    … …  
    5454                delete Kff;delete pf;delete tg; delete df;
    5555                Mergesolutionfromftogx(&tg, tf,ys,femmodel->nodes,femmodel->parameters); delete ys;
    56                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,tg);
     56                InputUpdateFromSolutionx(femmodel,tg);
    5757
    58                 ConstraintsStatex(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     58                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
    5959
    6060                if (!converged){
    … …  
    6868                count++;
    6969
    70                 InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
     70                InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
    7171
    7272                if(converged)break;
    7373        }
    7474
    75         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);
    76         InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,melting_offset,MeltingOffsetEnum);
     75        InputUpdateFromSolutionx(femmodel,tg);
     76        InputUpdateFromConstantx(femmodel,melting_offset,MeltingOffsetEnum);
    7777
    7878        /*Free ressources: */
Note: See TracChangeset for help on using the changeset viewer.