Changeset 16542


Ignore:
Timestamp:
10/24/13 16:30:36 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: create all datasets once for all (nodes, elements, constraints, parameters), do not pass pointers anymore (much simpler)

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

Legend:

Unmodified
Added
Removed

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void AdjointBalancethicknessAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void AdjointBalancethicknessAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212        _error_("not implemented yet");
    1313}/*}}}*/
    … …  
    1515        _error_("not implemented yet");
    1616}/*}}}*/
    17 void AdjointBalancethicknessAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     17void AdjointBalancethicknessAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    1818        _error_("not implemented yet");
    1919}/*}}}*/
    20 void AdjointBalancethicknessAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     20void AdjointBalancethicknessAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    2121        _error_("not implemented yet");
    2222}/*}}}*/
    23 void AdjointBalancethicknessAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     23void AdjointBalancethicknessAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    2424        _error_("not implemented yet");
    2525}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        _error_("not implemented");
    1010}/*}}}*/
    11 void AdjointHorizAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void AdjointHorizAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212           _error_("not implemented yet");
    1313}/*}}}*/
    … …  
    1515           _error_("not implemented yet");
    1616}/*}}}*/
    17 void AdjointHorizAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     17void AdjointHorizAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    1818           _error_("not implemented yet");
    1919}/*}}}*/
    20 void AdjointHorizAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     20void AdjointHorizAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    2121           _error_("not implemented yet");
    2222}/*}}}*/
    23 void AdjointHorizAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     23void AdjointHorizAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    2424           _error_("not implemented yet");
    2525}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

  • issm/trunk-jpl/src/c/analyses/Analysis.h

    r16539 r16542  
    1919                virtual      ~Analysis(){};
    2020                virtual int  DofsPerNode(int** doflist,int meshtype,int approximation)=0;
    21                 virtual void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0;
     21                virtual void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0;
    2222                virtual void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type)=0;
    23                 virtual void CreateNodes(Nodes** pnodes,IoModel* iomodel)=0;
    24                 virtual void CreateConstraints(Constraints** pconstraints,IoModel* iomodel)=0;
    25                 virtual void CreateLoads(Loads** ploads, IoModel* iomodel)=0;
     23                virtual void CreateNodes(Nodes* nodes,IoModel* iomodel)=0;
     24                virtual void CreateConstraints(Constraints* constraints,IoModel* iomodel)=0;
     25                virtual void CreateLoads(Loads* loads, IoModel* iomodel)=0;
    2626};
    2727#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void BalancethicknessAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void BalancethicknessAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void BalancethicknessAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    4949        }
    5050}/*}}}*/
    51 void BalancethicknessAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     51void BalancethicknessAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    5252
    5353        int  stabilization;
    … …  
    6060        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    6161        if(stabilization!=3){
    62                 ::CreateNodes(pnodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
     62                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
    6363        }
    6464        else{
    65                 ::CreateNodes(pnodes,iomodel,BalancethicknessAnalysisEnum,P1DGEnum);
     65                ::CreateNodes(nodes,iomodel,BalancethicknessAnalysisEnum,P1DGEnum);
    6666        }
    6767        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    6868}/*}}}*/
    69 void BalancethicknessAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     69void BalancethicknessAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    7070
    7171        /*Fetch parameters: */
    7272        int    stabilization;   
    7373        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    74 
    75         /*Recover pointer: */
    76         Constraints* constraints=*pconstraints;
    7774
    7875        /*Do not add constraints in DG*/
    … …  
    8178        }
    8279
    83         /*Assign output pointer: */
    84         *pconstraints=constraints;
    8580}/*}}}*/
    86 void BalancethicknessAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     81void BalancethicknessAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    8782
    8883        /*Intermediary*/
    … …  
    9287        /*Fetch parameters: */
    9388        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    94 
    95         /*Recover pointer: */
    96         Loads* loads=*ploads;
    9789
    9890        /*Loads only in DG*/
    … …  
    119111                iomodel->DeleteData(1,ThicknessEnum);
    120112        }
    121 
    122         /*Assign output pointer: */
    123         *ploads=loads;
    124113}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        _error_("not implemented");
    1010}/*}}}*/
    11 void BalancethicknessSoftAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void BalancethicknessSoftAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212           _error_("not implemented yet");
    1313}/*}}}*/
    … …  
    1515           _error_("not implemented yet");
    1616}/*}}}*/
    17 void BalancethicknessSoftAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     17void BalancethicknessSoftAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    1818           _error_("not implemented yet");
    1919}/*}}}*/
    20 void BalancethicknessSoftAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     20void BalancethicknessSoftAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    2121           _error_("not implemented yet");
    2222}/*}}}*/
    23 void BalancethicknessSoftAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     23void BalancethicknessSoftAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    2424           _error_("not implemented yet");
    2525}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/BalancethicknessSoftAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void BalancevelocityAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void BalancevelocityAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void BalancevelocityAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    3838        }
    3939}/*}}}*/
    40 void BalancevelocityAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     40void BalancevelocityAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4141
    4242        /*Check in 3d*/
    … …  
    4545        /*First fetch data: */
    4646        iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    47         ::CreateNodes(pnodes,iomodel,BalancevelocityAnalysisEnum,P1Enum);
     47        ::CreateNodes(nodes,iomodel,BalancevelocityAnalysisEnum,P1Enum);
    4848        iomodel->DeleteData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    4949}/*}}}*/
    50 void BalancevelocityAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
    51 
    52         /*Recover pointer: */
    53         Constraints* constraints=*pconstraints;
     50void BalancevelocityAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    5451
    5552        /*No constraints for now*/
    5653        //IoModelToConstraintsx(constraints,iomodel,BalancethicknessSpcthicknessEnum,BalancevelocityAnalysisEnum,P1Enum);
    57 
    58         /*Assign output pointer: */
    59         *pconstraints=constraints;
    6054}/*}}}*/
    61 void BalancevelocityAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     55void BalancevelocityAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    6256
    6357        /*No loads*/

  • issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16541 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void DamageEvolutionAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    12         Parameters *parameters = NULL;
    13         char*       law        = NULL;
    14 
    15         /*Get parameters: */
    16         parameters=*pparameters;
     11void DamageEvolutionAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1712
    1813        /*retrieve some parameters: */
    … …  
    2722
    2823        /*Retrieve law dependent parameters: */
     24        char* law  = NULL;
    2925        iomodel->Constant(&law,DamageLawEnum);
    3026        if (strcmp(law,"pralong")==0){
    … …  
    3632                parameters->AddObject(iomodel->CopyConstantObject(DamageHealingEnum));
    3733        }
     34        xDelete<char>(law);
    3835
    39         /*Assign output pointer: */
    40         xDelete<char>(law);
    41         *pparameters=parameters;
    4236}/*}}}*/
    4337void DamageEvolutionAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    6761        }
    6862}/*}}}*/
    69 void DamageEvolutionAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     63void DamageEvolutionAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    7064
    7165        iomodel->FetchData(1,MeshVertexonbedEnum);
    72         ::CreateNodes(pnodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum);
     66        ::CreateNodes(nodes,iomodel,DamageEvolutionAnalysisEnum,P1Enum);
    7367        iomodel->DeleteData(1,MeshVertexonbedEnum);
    7468}/*}}}*/
    75 void DamageEvolutionAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     69void DamageEvolutionAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    7670
    77         /*Fetch parameters: */
    7871        int stabilization;
    7972        iomodel->Constant(&stabilization,DamageStabilizationEnum);
    8073
    81         /*Recover pointer: */
    82         Constraints* constraints=*pconstraints;
    83 
    8474        IoModelToConstraintsx(constraints,iomodel,DamageSpcdamageEnum,DamageEvolutionAnalysisEnum,P1Enum);
    8575
    86         /*Assign output pointer: */
    87         *pconstraints=constraints;
    8876}/*}}}*/
    89 void DamageEvolutionAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
    90 
    91         /*Recover pointer: */
    92         Loads* loads=*ploads;
     77void DamageEvolutionAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    9378
    9479        /*create penalties for nodes: no node can have a damage > 1*/
    … …  
    10792        iomodel->DeleteData(1,DamageSpcdamageEnum);
    10893
    109         /*Assign output pointer: */
    110         *ploads=loads;
    11194}/*}}}*/

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

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void EnthalpyAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void EnthalpyAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void EnthalpyAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    7575        iomodel->DeleteData(3,TemperatureEnum,WaterfractionEnum,PressureEnum);
    7676}/*}}}*/
    77 void EnthalpyAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     77void EnthalpyAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    7878
    7979        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    80         ::CreateNodes(pnodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
     80        ::CreateNodes(nodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
    8181        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    8282}/*}}}*/
    83 void EnthalpyAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     83void EnthalpyAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    8484
    8585        /*Intermediary*/
    … …  
    9898        iomodel->Constant(&heatcapacity,MaterialsHeatcapacityEnum);
    9999        iomodel->Constant(&referencetemperature,ConstantsReferencetemperatureEnum);
    100 
    101         /*Recover pointer: */
    102         Constraints* constraints=*pconstraints;
    103100
    104101        /*return if 2d mesh*/
    … …  
    168165        xDelete<IssmDouble>(times);
    169166        xDelete<IssmDouble>(values);
    170 
    171         /*Assign output pointer: */
    172         *pconstraints=constraints;
    173167}/*}}}*/
    174 void EnthalpyAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     168void EnthalpyAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    175169
    176170        /*No loads */

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

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

  • issm/trunk-jpl/src/c/analyses/EnumToAnalysis.h

    r16539 r16542  
    88#endif
    99                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    10                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     10                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1111                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    12                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    13                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    14                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     12                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     13                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     14                void CreateLoads(Loads* loads, IoModel* iomodel);

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void ExtrudeFromBaseAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void ExtrudeFromBaseAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void ExtrudeFromBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    2626        }
    2727}/*}}}*/
    28 void ExtrudeFromBaseAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     28void ExtrudeFromBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    2929
    30         ::CreateNodes(pnodes,iomodel,ExtrudeFromBaseAnalysisEnum,P1Enum);
     30        ::CreateNodes(nodes,iomodel,ExtrudeFromBaseAnalysisEnum,P1Enum);
    3131
    3232}/*}}}*/
    33 void ExtrudeFromBaseAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     33void ExtrudeFromBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    3434}/*}}}*/
    35 void ExtrudeFromBaseAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     35void ExtrudeFromBaseAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    3636}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void ExtrudeFromTopAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void ExtrudeFromTopAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void ExtrudeFromTopAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    2626        }
    2727}/*}}}*/
    28 void ExtrudeFromTopAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     28void ExtrudeFromTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    2929
    30         ::CreateNodes(pnodes,iomodel,ExtrudeFromBaseAnalysisEnum,P1Enum);
     30        ::CreateNodes(nodes,iomodel,ExtrudeFromBaseAnalysisEnum,P1Enum);
    3131
    3232}/*}}}*/
    33 void ExtrudeFromTopAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     33void ExtrudeFromTopAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    3434}/*}}}*/
    35 void ExtrudeFromTopAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     35void ExtrudeFromTopAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    3636}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void FreeSurfaceBaseAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void FreeSurfaceBaseAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void FreeSurfaceBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    4141        }
    4242}/*}}}*/
    43 void FreeSurfaceBaseAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     43void FreeSurfaceBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4444
    4545        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    46         ::CreateNodes(pnodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
     46        ::CreateNodes(nodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
    4747        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    4848}/*}}}*/
    49 void FreeSurfaceBaseAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     49void FreeSurfaceBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    5050}/*}}}*/
    51 void FreeSurfaceBaseAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     51void FreeSurfaceBaseAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    5252
    5353        /*Intermediaries*/
    … …  
    5555        int count=0;
    5656        int numvertex_pairing;
    57 
    58         /*Recover pointer: */
    59         Loads* loads=*ploads;
    6057
    6158        /*Create Penpair for vertex_pairing: */
    … …  
    9087        iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum);
    9188        iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    92 
    93         /*Assign output pointer: */
    94         *ploads=loads;
    9589}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void FreeSurfaceTopAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void FreeSurfaceTopAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void FreeSurfaceTopAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    3939        }
    4040}/*}}}*/
    41 void FreeSurfaceTopAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     41void FreeSurfaceTopAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4242
    4343        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    44         ::CreateNodes(pnodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum);
     44        ::CreateNodes(nodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum);
    4545        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    4646}/*}}}*/
    47 void FreeSurfaceTopAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     47void FreeSurfaceTopAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    4848}/*}}}*/
    49 void FreeSurfaceTopAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     49void FreeSurfaceTopAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    5050
    5151        /*Intermediaries*/
    … …  
    5353        int count=0;
    5454        int numvertex_pairing;
    55 
    56         /*Recover pointer: */
    57         Loads* loads=*ploads;
    5855
    5956        /*Create Penpair for vertex_pairing: */
    … …  
    8885        iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum);
    8986        iomodel->DeleteData(nodeonsurface,MeshVertexonsurfaceEnum);
    90 
    91         /*Assign output pointer: */
    92         *ploads=loads;
    9387}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceTopAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void GiaAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void GiaAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void GiaAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    2727        iomodel->FetchDataToInput(elements,GiaLithosphereThicknessEnum);
    2828}/*}}}*/
    29 void GiaAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
    30         ::CreateNodes(pnodes,iomodel,GiaAnalysisEnum,P1Enum);
     29void GiaAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
     30        ::CreateNodes(nodes,iomodel,GiaAnalysisEnum,P1Enum);
    3131}/*}}}*/
    32 void GiaAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     32void GiaAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    3333        /*No constraints*/
    3434}/*}}}*/
    35 void GiaAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     35void GiaAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    3636        /*No loads*/
    3737}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/GiaAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void HydrologyDCEfficientAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void HydrologyDCEfficientAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212
    13         Parameters *parameters = NULL;
    1413        int         hydrology_model;
    1514        bool        isefficientlayer;
    16 
    17         /*Get parameters: */
    18         parameters=*pparameters;
    1915
    2016        /*retrieve some parameters: */
    … …  
    2218
    2319        /*Now, do we really want DC?*/
    24         if(hydrology_model!=HydrologydcEnum){
    25                 *pparameters=parameters;
    26                 return;
    27         }
     20        if(hydrology_model!=HydrologydcEnum) return;
    2821
    2922        /*Do we want an efficient layer*/
    3023        iomodel->Constant(&isefficientlayer,HydrologydcIsefficientlayerEnum);
    31         if(!isefficientlayer){
    32                 *pparameters=parameters;
    33                 return;
    34         }
     24        if(!isefficientlayer) return;
    3525
    3626        /*Nothing for now*/
    37 
    38         /*Assign output pointer: */
    39         *pparameters=parameters;
    4027}/*}}}*/
    4128void HydrologyDCEfficientAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    7158        iomodel->FetchDataToInput(elements,EplHeadEnum);
    7259}/*}}}*/
    73 void HydrologyDCEfficientAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     60void HydrologyDCEfficientAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    7461
    7562        /*Now, do we really want DC?*/
    … …  
    8471
    8572        iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    86         ::CreateNodes(pnodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
     73        ::CreateNodes(nodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
    8774        iomodel->DeleteData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    8875}/*}}}*/
    89 void HydrologyDCEfficientAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
    90 
    91         /*Recover pointer: */
    92         Constraints* constraints=*pconstraints;
     76void HydrologyDCEfficientAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    9377
    9478        /*Do we really want DC?*/
    … …  
    10488        IoModelToConstraintsx(constraints,iomodel,HydrologydcSpceplHeadEnum,HydrologyDCEfficientAnalysisEnum,P1Enum);
    10589
    106         /*Assign output pointer: */
    107         *pconstraints=constraints;
    10890}/*}}}*/
    109 void HydrologyDCEfficientAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
    110 
    111         /*Recover pointer: */
    112         Loads* loads=*ploads;
     91void HydrologyDCEfficientAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    11392
    11493        /*Do we really want DC?*/
    … …  
    123102
    124103        /*Nothing for now*/
    125 
    126         /*Assign output pointer: */
    127         *ploads=loads;
    128104}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void HydrologyDCInefficientAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void HydrologyDCInefficientAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212
    13         Parameters *parameters = NULL;
    1413        int         hydrology_model;
    1514        int         sedimentlimit_flag;
    … …  
    2120        IssmDouble  rel_tol;
    2221
    23         /*Get parameters: */
    24         parameters=*pparameters;
    25 
    2622        /*retrieve some parameters: */
    2723        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    2824
    2925        /*Now, do we really want DC?*/
    30         if(hydrology_model!=HydrologydcEnum){
    31                 *pparameters=parameters;
    32                 return;
    33         }
     26        if(hydrology_model!=HydrologydcEnum) return;
    3427
    3528        iomodel->FetchData(&isefficientlayer,HydrologydcIsefficientlayerEnum);
    … …  
    5649        parameters->AddObject(new DoubleParam(HydrologydcRelTolEnum,rel_tol));
    5750
    58         /*Assign output pointer: */
    59         *pparameters=parameters;
    6051}/*}}}*/
    6152void HydrologyDCInefficientAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    9384        if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveEnum);
    9485}/*}}}*/
    95 void HydrologyDCInefficientAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     86void HydrologyDCInefficientAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    9687
    9788        /*Fetch parameters: */
    … …  
    10394
    10495        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    105         ::CreateNodes(pnodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
     96        ::CreateNodes(nodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
    10697        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    10798}/*}}}*/
    108 void HydrologyDCInefficientAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
    109 
    110         /*Recover pointer: */
    111         Constraints* constraints=*pconstraints;
     99void HydrologyDCInefficientAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    112100
    113101        /*retrieve some parameters: */
    … …  
    117105
    118106        IoModelToConstraintsx(constraints,iomodel,HydrologydcSpcsedimentHeadEnum,HydrologyDCInefficientAnalysisEnum,P1Enum);
    119 
    120         /*Assign output pointer: */
    121         *pconstraints=constraints;
    122107}/*}}}*/
    123 void HydrologyDCInefficientAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
    124 
    125         /*Recover pointer: */
    126         Loads* loads=*ploads;
     108void HydrologyDCInefficientAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    127109
    128110        /*Fetch parameters: */
    … …  
    148130                }
    149131        }
    150         /*Assign output pointer: */
    151         *ploads=loads;
    152132        iomodel->DeleteData(1,MeshVertexonbedEnum);
    153133}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void HydrologyShreveAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    12 
    13         Parameters *parameters = NULL;
    14         int         hydrology_model;
    15 
    16         /*Get parameters: */
    17         parameters=*pparameters;
     11void HydrologyShreveAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1812
    1913        /*retrieve some parameters: */
     14        int  hydrology_model;
    2015        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    2116
    2217        /*Now, do we really want Shreve?*/
    23         if(hydrology_model!=HydrologyshreveEnum){
    24                 *pparameters=parameters;
    25                 return;
    26         }
     18        if(hydrology_model!=HydrologyshreveEnum) return;
    2719
    2820        parameters->AddObject(new IntParam(HydrologyModelEnum,hydrology_model));
    2921        parameters->AddObject(iomodel->CopyConstantObject(HydrologyshreveStabilizationEnum));
    3022
    31         /*Assign output pointer: */
    32         *pparameters=parameters;
    3323}/*}}}*/
    3424void HydrologyShreveAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    6353        elements->InputDuplicate(WatercolumnEnum,WaterColumnOldEnum);
    6454}/*}}}*/
    65 void HydrologyShreveAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     55void HydrologyShreveAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    6656
    6757        /*Fetch parameters: */
    … …  
    7363
    7464        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    75         ::CreateNodes(pnodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
     65        ::CreateNodes(nodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    7666        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    7767}/*}}}*/
    78 void HydrologyShreveAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
    79 
    80         /*Recover pointer: */
    81         Constraints* constraints=*pconstraints;
     68void HydrologyShreveAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    8269
    8370        /*retrieve some parameters: */
    … …  
    8976        IoModelToConstraintsx(constraints,iomodel,HydrologyshreveSpcwatercolumnEnum,HydrologyShreveAnalysisEnum,P1Enum);
    9077
    91         /*Assign output pointer: */
    92         *pconstraints=constraints;
    9378}/*}}}*/
    94 void HydrologyShreveAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     79void HydrologyShreveAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    9580        /*No loads*/
    9681}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/HydrologyShreveAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void L2ProjectionBaseAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void L2ProjectionBaseAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void L2ProjectionBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    3434        }
    3535}/*}}}*/
    36 void L2ProjectionBaseAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     36void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737
    3838        if(iomodel->meshtype==Mesh3DEnum){
    … …  
    4242                iomodel->FetchData(1,MeshVertexonbedEnum);
    4343        }
    44         ::CreateNodes(pnodes,iomodel,L2ProjectionBaseAnalysisEnum,P1Enum);
     44        ::CreateNodes(nodes,iomodel,L2ProjectionBaseAnalysisEnum,P1Enum);
    4545        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    4646}/*}}}*/
    47 void L2ProjectionBaseAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     47void L2ProjectionBaseAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    4848
    4949        /*No constraints*/
    5050}/*}}}*/
    51 void L2ProjectionBaseAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     51void L2ProjectionBaseAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    5252
    5353        /*No loads*/

  • issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void MasstransportAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    12 
    13         /*Get parameters: */
    14         Parameters *parameters=*pparameters;
     11void MasstransportAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1512
    1613        parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsFSEnum));
    1714
    18         /*Assign output pointer: */
    19         *pparameters = parameters;
    2015}/*}}}*/
    2116void MasstransportAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    10196        }
    10297}/*}}}*/
    103 void MasstransportAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     98void MasstransportAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    10499
    105100        /*Fetch parameters: */
    … …  
    113108        if(iomodel->meshtype!=Mesh2DhorizontalEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    114109        if(stabilization!=3){
    115                 ::CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1Enum);
     110                ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1Enum);
    116111        }
    117112        else{
    118                 ::CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1DGEnum);
     113                ::CreateNodes(nodes,iomodel,MasstransportAnalysisEnum,P1DGEnum);
    119114        }
    120115        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    121116}/*}}}*/
    122 void MasstransportAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     117void MasstransportAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    123118
    124119        /*Fetch parameters: */
    … …  
    126121        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    127122
    128         /*Recover pointer: */
    129         Constraints* constraints=*pconstraints;
    130 
    131123        /*Do not add constraints in DG, they are weakly imposed*/
    132124        if(stabilization!=3){
    133125                IoModelToConstraintsx(constraints,iomodel,MasstransportSpcthicknessEnum,MasstransportAnalysisEnum,P1Enum);
    134126        }
    135 
    136         /*Assign output pointer: */
    137         *pconstraints=constraints;
    138127}/*}}}*/
    139 void MasstransportAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     128void MasstransportAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    140129
    141130        /*Intermediaries*/
    … …  
    148137        /*Fetch parameters: */
    149138        iomodel->Constant(&stabilization,MasstransportStabilizationEnum);
    150 
    151         /*Recover pointer: */
    152         Loads* loads=*ploads;
    153139
    154140        /*Loads only in DG*/
    … …  
    209195        iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    210196
    211         /*Assign output pointer: */
    212         *ploads=loads;
    213197}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void MeltingAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void MeltingAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void MeltingAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    4242        iomodel->FetchDataToInput(elements,PressureEnum);
    4343}/*}}}*/
    44 void MeltingAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     44void MeltingAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4545
    4646        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    47         ::CreateNodes(pnodes,iomodel,MeltingAnalysisEnum,P1Enum);
     47        ::CreateNodes(nodes,iomodel,MeltingAnalysisEnum,P1Enum);
    4848        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    4949}/*}}}*/
    50 void MeltingAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     50void MeltingAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    5151        /*No Constraints*/
    5252}/*}}}*/
    53 void MeltingAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     53void MeltingAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    5454
    5555        /*if 2d: Error*/
    5656        if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    57 
    58         /*Recover pointer: */
    59         Loads* loads=*ploads;
    6057
    6158        //create penalties for nodes: no node can have a temperature over the melting point
    … …  
    7269        iomodel->DeleteData(1,MeshVertexonbedEnum);
    7370
    74         /*Assign output pointer: */
    75         *ploads=loads;
    7671}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/MeltingAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        _error_("not implemented");
    1010}/*}}}*/
    11 void MeshdeformationAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void MeshdeformationAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212           _error_("not implemented yet");
    1313}/*}}}*/
    … …  
    1515           _error_("not implemented yet");
    1616}/*}}}*/
    17 void MeshdeformationAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     17void MeshdeformationAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    1818           _error_("not implemented yet");
    1919}/*}}}*/
    20 void MeshdeformationAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     20void MeshdeformationAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    2121           _error_("not implemented yet");
    2222}/*}}}*/
    23 void MeshdeformationAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     23void MeshdeformationAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    2424           _error_("not implemented yet");
    2525}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/MeshdeformationAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void SmoothedSurfaceSlopeXAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void SmoothedSurfaceSlopeXAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void SmoothedSurfaceSlopeXAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    3434        }
    3535}/*}}}*/
    36 void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     36void SmoothedSurfaceSlopeXAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737        iomodel->FetchData(1,MeshVertexonbedEnum);
    38         ::CreateNodes(pnodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum);
     38        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeXAnalysisEnum,P1Enum);
    3939        iomodel->DeleteData(1,MeshVertexonbedEnum);
    4040}/*}}}*/
    41 void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     41void SmoothedSurfaceSlopeXAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    4242}/*}}}*/
    43 void SmoothedSurfaceSlopeXAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     43void SmoothedSurfaceSlopeXAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    4444}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void SmoothedSurfaceSlopeYAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void SmoothedSurfaceSlopeYAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void SmoothedSurfaceSlopeYAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    3434        }
    3535}/*}}}*/
    36 void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     36void SmoothedSurfaceSlopeYAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    3737        iomodel->FetchData(1,MeshVertexonbedEnum);
    38         ::CreateNodes(pnodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum);
     38        ::CreateNodes(nodes,iomodel,SmoothedSurfaceSlopeYAnalysisEnum,P1Enum);
    3939        iomodel->DeleteData(1,MeshVertexonbedEnum);
    4040}/*}}}*/
    41 void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     41void SmoothedSurfaceSlopeYAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    4242}/*}}}*/
    43 void SmoothedSurfaceSlopeYAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     43void SmoothedSurfaceSlopeYAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    4444}/*}}}*/

  • issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    6666        return numdofs;
    6767}/*}}}*/
    68 void StressbalanceAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     68void StressbalanceAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    6969
    7070        /*Intermediaries*/
    7171        int         numoutputs;
    7272        char**      requestedoutputs = NULL;
    73 
    74         /*Get parameters: */
    75         Parameters *parameters=*pparameters;
    7673
    7774        parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsSIAEnum));
    … …  
    9895        iomodel->DeleteData(&requestedoutputs,numoutputs,StressbalanceRequestedOutputsEnum);
    9996
    100         /*Assign output pointer: */
    101         *pparameters = parameters;
    10297}/*}}}*/
    10398void StressbalanceAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    215210        xDelete<int>(finiteelement_list);
    216211}/*}}}*/
    217 void StressbalanceAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     212void StressbalanceAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    218213
    219214        /*Intermediary*/
    … …  
    258253                iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    259254                if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
    260                 ::CreateNodes(pnodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
     255                ::CreateNodes(nodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    261256                iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    262257                                        FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    … …  
    265260                /*Coupling: we are going to create P1 Elements only*/
    266261
    267                 /*Recover nodes*/
    268                 Nodes* nodes = *pnodes;
    269262                Node*  node  = NULL;
    270263                int    lid=0;
    … …  
    310303                iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    311304                                        FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    312 
    313                 /*Assign output pointer: */
    314                 *pnodes=nodes;
    315305        }
    316306}/*}}}*/
    317 void StressbalanceAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     307void StressbalanceAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    318308
    319309        /*Intermediary*/
    … …  
    344334   IssmDouble* values=NULL;
    345335
    346         /*Output*/
    347         Constraints *constraints      = NULL;
    348 
    349336        /*Fetch parameters: */
    350337        iomodel->Constant(&g,ConstantsGEnum);
    … …  
    357344        iomodel->Constant(&isFS,FlowequationIsFSEnum);
    358345
    359         /*Recover pointer: */
    360         constraints=*pconstraints;
    361 
    362346        /*Now, is the flag macayaealHO on? otherwise, do nothing: */
    363         if(!isSSA && !isHO && !isFS && !isL1L2){
    364                 *pconstraints=constraints;
    365                 return;
    366         }
     347        if(!isSSA && !isHO && !isFS && !isL1L2) return;
    367348
    368349        /*Do we have coupling*/
    … …  
    479460                }
    480461
    481                 *pconstraints=constraints;
    482462                return;
    483463        }
    … …  
    751731        xDelete<IssmDouble>(values);
    752732
    753         /*Assign output pointer: */
    754         *pconstraints=constraints;
    755733}/*}}}*/
    756 void StressbalanceAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     734void StressbalanceAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    757735
    758736        /*Intermediary*/
    … …  
    774752        iomodel->Constant(&numrifts,RiftsNumriftsEnum);
    775753
    776         /*Recover pointer: */
    777         Loads* loads=*ploads;
    778 
    779754        /*Now, is the flag macayaealHO on? otherwise, do nothing: */
    780755        if(!isSSA && !isHO && !isFS && !isL1L2) return;
    … …  
    821796        }
    822797#endif
    823 
    824         /*Assign output pointer: */
    825         *ploads=loads;
    826798}/*}}}*/

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

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 2;
    1010}/*}}}*/
    11 void StressbalanceSIAAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void StressbalanceSIAAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212
    1313        /*No specific parameters*/
    … …  
    4040        iomodel->DeleteData(1,FlowequationElementEquationEnum);
    4141}/*}}}*/
    42 void StressbalanceSIAAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     42void StressbalanceSIAAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4343
    4444        /*Intermediaries*/
    … …  
    5353
    5454        /*First create nodes*/
    55         Nodes* nodes=*pnodes;
    5655        int    lid=0;
    57         if(!nodes) nodes = new Nodes();
    58 
    5956        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    6057                                FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    … …  
    7976                                FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    8077
    81         /*Assign output pointer: */
    82         *pnodes=nodes;
    83 
    8478}/*}}}*/
    85 void StressbalanceSIAAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     79void StressbalanceSIAAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    8680
    8781        /*Intermediary*/
    … …  
    8983        IssmDouble yts;
    9084        bool       isSIA;
    91 
    92         /*Output*/
    93         Constraints* constraints = NULL;
    94 
    95         /*Recover pointer: */
    96         constraints=*pconstraints;
    9785
    9886        /*Fetch parameters: */
    … …  
    138126        iomodel->DeleteData(3,StressbalanceSpcvxEnum,StressbalanceSpcvyEnum,FlowequationVertexEquationEnum);
    139127
    140         /*Assign output pointer: */
    141         *pconstraints=constraints;
    142128}/*}}}*/
    143 void StressbalanceSIAAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     129void StressbalanceSIAAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    144130
    145131        /*No loads*/

  • issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void StressbalanceVerticalAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void StressbalanceVerticalAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212
    1313        /*No specific parameters*/
    … …  
    3939        iomodel->FetchDataToInput(elements,VyEnum,0.);
    4040}/*}}}*/
    41 void StressbalanceVerticalAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     41void StressbalanceVerticalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    4242
    4343        /*return if not 3d mesh*/
    … …  
    4545
    4646        iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    47         ::CreateNodes(pnodes,iomodel,StressbalanceVerticalAnalysisEnum,P1Enum);
     47        ::CreateNodes(nodes,iomodel,StressbalanceVerticalAnalysisEnum,P1Enum);
    4848        iomodel->DeleteData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);
    4949}/*}}}*/
    50 void StressbalanceVerticalAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
     50void StressbalanceVerticalAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    5151
    5252        /*Intermediary*/
    … …  
    5656        /*Fetch parameters: */
    5757        iomodel->Constant(&yts,ConstantsYtsEnum);
    58 
    59         /*Recover pointer: */
    60         Constraints* constraints=*pconstraints;
    6158
    6259        /*return if not 3d mesh*/
    … …  
    9188        iomodel->DeleteData(2,StressbalanceSpcvzEnum,FlowequationBorderFSEnum);
    9289
    93         /*Assign output pointer: */
    94         *pconstraints=constraints;
    9590}/*}}}*/
    96 void StressbalanceVerticalAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
     91void StressbalanceVerticalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    9792
    9893        /*No loads*/

  • issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.h

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16539 r16542  
    99        return 1;
    1010}/*}}}*/
    11 void ThermalAnalysis::UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
     11void ThermalAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1212}/*}}}*/
    1313void ThermalAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    … …  
    5959        }
    6060}/*}}}*/
    61 void ThermalAnalysis::CreateNodes(Nodes** pnodes,IoModel* iomodel){/*{{{*/
     61void ThermalAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
    6262
    6363        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    64         ::CreateNodes(pnodes,iomodel,ThermalAnalysisEnum,P1Enum);
     64        ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum);
    6565        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    6666}/*}}}*/
    67 void ThermalAnalysis::CreateConstraints(Constraints** pconstraints,IoModel* iomodel){/*{{{*/
    68 
    69         /*Recover pointer: */
    70         Constraints* constraints=*pconstraints;
     67void ThermalAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    7168
    7269        /*Only 3d mesh supported*/
    … …  
    7572        }
    7673
    77         /*Assign output pointer: */
    78         *pconstraints=constraints;
    7974}/*}}}*/
    80 void ThermalAnalysis::CreateLoads(Loads** ploads, IoModel* iomodel){/*{{{*/
    81 
    82         /*Recover pointer: */
    83         Loads* loads=*ploads;
     75void ThermalAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    8476
    8577        if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    … …  
    10092        iomodel->DeleteData(1,ThermalSpctemperatureEnum);
    10193
    102         /*Assign output pointer: */
    103         *ploads=loads;
    10494}/*}}}*/

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

    r16539 r16542  
    1313        public:
    1414                int  DofsPerNode(int** doflist,int meshtype,int approximation);
    15                 void UpdateParameters(Parameters** pparameters,IoModel* iomodel,int solution_enum,int analysis_enum);
     15                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    1616                void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    17                 void CreateNodes(Nodes** pnodes,IoModel* iomodel);
    18                 void CreateConstraints(Constraints** pconstraints,IoModel* iomodel);
    19                 void CreateLoads(Loads** ploads, IoModel* iomodel);
     17                void CreateNodes(Nodes* nodes,IoModel* iomodel);
     18                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
     19                void CreateLoads(Loads* loads, IoModel* iomodel);
    2020};
    2121#endif

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

    r16467 r16542  
    88#include "../ModelProcessorx.h"
    99
    10 void CreateParametersAutodiff(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type){
     10void CreateParametersAutodiff(Parameters** pparameters,IoModel* iomodel){
    1111
    1212        int         i;

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

    r16313 r16542  
    88#include "../ModelProcessorx.h"
    99
    10 void CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type){
     10void CreateParametersControl(Parameters* parameters,IoModel* iomodel,int solution_type){
    1111
    12         Parameters *parameters       = NULL;
    1312        bool        control_analysis,tao_analysis;
    1413        int         nsteps;
    … …  
    2019        IssmDouble *optscal          = NULL;
    2120        IssmDouble *maxiter          = NULL;
    22 
    23         /*Get parameters: */
    24         parameters=*pparameters;
    2521
    2622        /*retrieve some parameters: */
    … …  
    4036
    4137                /*What solution type?*/
    42                 if (solution_type==SteadystateSolutionEnum){
     38                if(solution_type==SteadystateSolutionEnum){
    4339                        parameters->AddObject(new BoolParam(ControlSteadyEnum,true));
    4440                }
    … …  
    7470                iomodel->DeleteData(maxiter,InversionMaxiterPerStepEnum);
    7571        }
    76 
    77         /*Assign output pointer: */
    78         *pparameters=parameters;
    7972}

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

    r16539 r16542  
    1414#include "./ModelProcessorx.h"
    1515
    16 void CreateDataSets(Elements** pelements,Nodes** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,FILE* toolkitfile,char* rootpath,const int solution_enum,const int analysis_enum,const int nummodels,int analysis_counter){
    17 
    18         Elements   *elements   = NULL;
    19         Materials  *materials  = NULL;
    20         Parameters *parameters = NULL;
    21 
    22         /*Process Finite Element Mesh*/
    23 
    24         /*Partition Elements and Nodes*/
    25         ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
    26 
    27         /*Create elements, vertices and materials, independent of analysis_enum: */
    28         CreateElementsVerticesAndMaterials(pelements, pvertices, pmaterials, iomodel,nummodels);
    29 
    30         /*Create Parameters*/
    31         CreateParameters(pparameters,iomodel,rootpath,toolkitfile,solution_enum,analysis_enum,analysis_counter);
    32 
    33         /*Recover elements and materials, for future update: */
    34         elements  = *pelements;
    35         materials = *pmaterials;
     16void CreateDataSets(Elements* elements,Nodes* nodes, Vertices* vertices, Materials* materials,Constraints* constraints, Loads* loads,Parameters* parameters,IoModel* iomodel,FILE* toolkitfile,char* rootpath,const int solution_enum,const int analysis_enum,const int nummodels,int analysis_counter){
    3617
    3718        /*Creates Nodes and constraints datasets if empty*/
    38         if(!*pnodes)       *pnodes       = new Nodes();
    39         if(!*pconstraints) *pconstraints = new Constraints();
    40         if(!*ploads)       *ploads       = new Loads();
    4119
    4220        /*Now, branch onto analysis dependent model generation: */
    4321        Analysis* analysis = EnumToAnalysis(analysis_enum);
    44         analysis->UpdateParameters(pparameters,iomodel,solution_enum,analysis_enum);
    45         analysis->CreateNodes(pnodes,iomodel);
    46         analysis->CreateConstraints(pconstraints,iomodel);
    47         analysis->CreateLoads(ploads,iomodel);
     22        analysis->UpdateParameters(parameters,iomodel,solution_enum,analysis_enum);
     23        analysis->CreateNodes(nodes,iomodel);
     24        analysis->CreateConstraints(constraints,iomodel);
     25        analysis->CreateLoads(loads,iomodel);
    4826        analysis->UpdateElements(elements,iomodel,analysis_counter,analysis_enum);
    4927        delete analysis;
    … …  
    5937        #endif
    6038
    61 
    6239        /*Update Elements in case we are running a transient solution: */
    6340        #ifdef _HAVE_TRANSIENT_
    64         parameters=*pparameters;
    6541        if(analysis_counter==(nummodels-1)&& solution_enum==TransientSolutionEnum){
    6642                UpdateElementsTransient(elements,parameters,iomodel,analysis_counter,analysis_enum);
    … …  
    6945
    7046        /*Sort datasets: */
    71         SortDataSets(pelements,pnodes,pvertices, ploads, pmaterials, pconstraints, pparameters);
     47        SortDataSets(elements,nodes,vertices,loads,materials,constraints,parameters);
    7248
    7349        /* Update counters, because we have created more nodes, loads and
    7450         * constraints, and ids for objects created in next call to CreateDataSets
    7551         * will need to start at the end of the updated counters: */
    76         UpdateCounters(iomodel,pnodes,ploads,pconstraints);
     52        UpdateCounters(iomodel,nodes,loads,constraints);
    7753}

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

    r16336 r16542  
    88#include "./ModelProcessorx.h"
    99
    10 void    CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels){
     10void CreateElementsVerticesAndMaterials(Elements* elements,Vertices* vertices,Materials* materials,IoModel* iomodel,const int nummodels){
    1111
    1212        /*Intermediary*/
    … …  
    1616        bool dakota_analysis;
    1717
    18         /*DataSets: */
    19         Elements  *elements  = NULL;
    20         Vertices  *vertices  = NULL;
    21         Materials *materials = NULL;
    22 
    2318        /*Fetch parameters: */
    2419        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    … …  
    2722
    2823        /*Did we already create the elements? : */
    29         if(*pelements)return;
    30 
    31         /*First create the elements, vertices, nodes and material properties, if they don't already exist */
    32         elements  = new Elements();
    33         vertices  = new Vertices();
    34         materials = new Materials();
     24        _assert_(elements->Size()==0);
    3525
    3626        /*Create elements*/
    … …  
    10494        /*Free data: */
    10595        iomodel->DeleteData(6,MeshXEnum,MeshYEnum,MeshZEnum,BedEnum,ThicknessEnum,MaskIceLevelsetEnum);
    106 
    107         /*Assign output pointer: */
    108         *pelements=elements;
    109         *pvertices=vertices;
    110         *pmaterials=materials;
    11196}

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

    r16024 r16542  
    99#include "./ModelProcessorx.h"
    1010
    11 void CreateNodes(Nodes** pnodes, IoModel* iomodel,int analysis,int finite_element,int approximation){
     11void CreateNodes(Nodes* nodes, IoModel* iomodel,int analysis,int finite_element,int approximation){
    1212
    1313        /*Intermediaries*/
    … …  
    1616        bool *my_nodes = NULL;
    1717        Node *node     = NULL;
    18 
    19         /*Recover pointer: */
    20         Nodes* nodes=*pnodes;
    21 
    22         /*First create nodes*/
    23         if(!nodes) nodes = new Nodes();
    2418
    2519        switch(finite_element){
    … …  
    228222        xDelete<bool>(my_edges);
    229223        xDelete<bool>(my_nodes);
    230 
    231         /*Assign output pointer: */
    232         *pnodes=nodes;
    233224}

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

    r16474 r16542  
    88#include "./ModelProcessorx.h"
    99
    10 void CreateOutputDefinitions(Parameters** pparameters,IoModel* iomodel){
     10void CreateOutputDefinitions(Parameters* parameters,IoModel* iomodel){
    1111
    1212        int i,j;
    1313       
    14         Parameters  *parameters              = NULL;
    1514        DataSet     *output_definitions      = NULL;
    1615        int         *output_definition_enums = NULL;
    … …  
    2019        IssmDouble **gatesegments            = NULL;
    2120        int         *gatesegments_M          = NULL;
    22 
    23         /*Get parameters: */
    24         parameters=*pparameters;
    2521
    2622        /*Create output_definitions dataset: */
    … …  
    5955        delete output_definitions;
    6056        xDelete<int>(output_definition_enums);
    61 
    62         /*Assign output pointer: */
    63         *pparameters=parameters;
    6457}

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

    r16539 r16542  
    1616#include "./ModelProcessorx.h"
    1717
    18 void CreateParameters(Parameters** pparameters,IoModel* iomodel,char* rootpath,FILE* toolkitsoptionsfid,const int solution_type,int analysis_type,int analysis_counter){
     18void CreateParameters(Parameters* parameters,IoModel* iomodel,char* rootpath,FILE* toolkitsoptionsfid,const int solution_type){
    1919
    2020        int         i,j,m,k;
    2121        int         numoutputs,meshtype;
    22         Parameters *parameters       = NULL;
    2322        char**      requestedoutputs = NULL;
    2423        IssmDouble  time;
    … …  
    3837        int          count;
    3938
    40         if(*pparameters)return; //do not create parameters twice!
    41 
    42         /*Initialize dataset: */
    43         parameters = new Parameters();
     39        /*Make sure current dataset is empty*/
     40        _assert_(parameters->Size()==0);
    4441
    4542        /*Copy some constants from iomodel */
    … …  
    130127        /*some parameters that did not come with the iomodel: */
    131128        parameters->AddObject(new IntParam(SolutionTypeEnum,solution_type));
    132         parameters->AddObject(new IntParam(AnalysisTypeEnum,analysis_type));
    133         parameters->AddObject(new IntParam(AnalysisCounterEnum,analysis_counter));
    134129
    135130        iomodel->Constant(&time,TimesteppingStartTimeEnum);
    … …  
    224219
    225220        /*Output definitions dataset: */
    226         CreateOutputDefinitions(&parameters,iomodel);
     221        CreateOutputDefinitions(parameters,iomodel);
    227222
    228223        /*Before returning, create parameters in case we are running Qmu or control types runs: */
    229224        #ifdef _HAVE_CONTROL_
    230         CreateParametersControl(&parameters,iomodel,solution_type,analysis_type);
     225        CreateParametersControl(parameters,iomodel,solution_type);
    231226        #endif
    232227
    233228        #ifdef _HAVE_DAKOTA_
    234         CreateParametersDakota(&parameters,iomodel,rootpath,solution_type,analysis_type);
     229        CreateParametersDakota(parameters,iomodel,rootpath);
    235230        #endif
    236231
    … …  
    239234
    240235        #ifdef _HAVE_ADOLC_
    241         CreateParametersAutodiff(&parameters,iomodel,solution_type,analysis_type);
     236        CreateParametersAutodiff(parameters,iomodel);
    242237        #endif
    243 
    244         /*Assign output pointer: */
    245         *pparameters=parameters;
    246238}

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

    r16240 r16542  
    99#include "../ModelProcessorx.h"
    1010
    11 void CreateParametersDakota(Parameters** pparameters,IoModel* iomodel,char* rootpath,int solution_type,int analysis_type){
     11void CreateParametersDakota(Parameters** pparameters,IoModel* iomodel,char* rootpath){
    1212
    1313        /*variable declarations*/

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

    r16291 r16542  
    1313#include "./ModelProcessorx.h"
    1414
    15 void ModelProcessorx(Elements** pelements, Nodes** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads, Parameters** pparameters, FILE* IOMODEL,FILE* toolkitfile, char* rootpath,const int solution_type,const int nummodels,const int* analysis_type_list){
     15void ModelProcessorx(Elements** pelements, Nodes** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads, Parameters** pparameters, FILE* IOMODEL,FILE* toolkitfile, char* rootpath,const int solution_enum,const int nummodels,const int* analysis_type_list){
    1616
    1717        int   i,analysis_type,verbose;
    1818        bool  isthermal,ismasstransport,isstressbalance,isgroundingline,isenthalpy;
    1919
    20         /*output: */
    21         Elements    *elements    = NULL;
    22         Nodes       *nodes       = NULL;
    23         Vertices    *vertices    = NULL;
    24         Materials   *materials   = NULL;
    25         Constraints *constraints = NULL;
    26         Loads       *loads       = NULL;
    27         Parameters  *parameters  = NULL;
     20        /*Initialize datasets*/
     21        Elements    *elements    = new Elements();
     22        Nodes       *nodes       = new Nodes();
     23        Vertices    *vertices    = new Vertices();
     24        Materials   *materials   = new Materials();
     25        Constraints *constraints = new Constraints();
     26        Loads       *loads       = new Loads();
     27        Parameters  *parameters  = new Parameters();
    2828
    2929        /*Initialize IoModel from input file*/
    … …  
    4242        if(VerboseMProcessor()) _printf0_("   starting model processor \n");
    4343
     44        /*Partition Elements and Nodes*/
     45        ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
     46
     47        /*Create elements, vertices and materials, independent of analysis_enum: */
     48        CreateElementsVerticesAndMaterials(elements,vertices,materials,iomodel,nummodels);
     49
     50        /*Create Parameters*/
     51        CreateParameters(parameters,iomodel,rootpath,toolkitfile,solution_enum);
     52
    4453        for(i=0;i<nummodels;i++){
    4554
    4655                analysis_type=analysis_type_list[i];
     56                parameters->AddObject(new IntParam(AnalysisCounterEnum,i));
    4757
    4858                /*Hack for trasient runs (FIXME: to be improved)*/
    49                 if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    50                 if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    51                 if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    52                 if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum && isthermal==false) continue;
    53                 if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isthermal==false) continue;
    54                 if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isthermal==false) continue;
    55                 if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue;
    56                 if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;
    57                 if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
    58                 if(solution_type==TransientSolutionEnum && analysis_type==MasstransportAnalysisEnum && ismasstransport==false && isgroundingline==false) continue;
    59                 if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceAnalysisEnum && isstressbalance==false) continue;
    60                 if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceVerticalAnalysisEnum && isstressbalance==false) continue;
    61                 if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceSIAAnalysisEnum && isstressbalance==false) continue;
    62                 if(solution_type==SteadystateSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue;
    63                 if(solution_type==SteadystateSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;
    64                 if(solution_type==SteadystateSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
     59                if(solution_enum==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     60                if(solution_enum==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     61                if(solution_enum==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     62                if(solution_enum==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum && isthermal==false) continue;
     63                if(solution_enum==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isthermal==false) continue;
     64                if(solution_enum==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isthermal==false) continue;
     65                if(solution_enum==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue;
     66                if(solution_enum==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;
     67                if(solution_enum==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
     68                if(solution_enum==TransientSolutionEnum && analysis_type==MasstransportAnalysisEnum && ismasstransport==false && isgroundingline==false) continue;
     69                if(solution_enum==TransientSolutionEnum && analysis_type==StressbalanceAnalysisEnum && isstressbalance==false) continue;
     70                if(solution_enum==TransientSolutionEnum && analysis_type==StressbalanceVerticalAnalysisEnum && isstressbalance==false) continue;
     71                if(solution_enum==TransientSolutionEnum && analysis_type==StressbalanceSIAAnalysisEnum && isstressbalance==false) continue;
     72                if(solution_enum==SteadystateSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue;
     73                if(solution_enum==SteadystateSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;
     74                if(solution_enum==SteadystateSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
    6575
    6676                if(VerboseMProcessor()) _printf0_("   creating datasets for analysis " << EnumToStringx(analysis_type) << "\n");
    67                 CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,&parameters,iomodel,toolkitfile,rootpath,solution_type,analysis_type,nummodels,i);
     77                CreateDataSets(elements,nodes,vertices,materials,constraints,loads,parameters,iomodel,toolkitfile,rootpath,solution_enum,analysis_type,nummodels,i);
    6878        }
    6979        if(VerboseMProcessor()) _printf0_("   done with model processor \n");
    … …  
    7383
    7484        /*Assign output pointers:*/
    75         *pelements=elements;
    76         *pnodes=nodes;
    77         *pvertices=vertices;
    78         *pmaterials=materials;
    79         *pconstraints=constraints;
    80         *ploads=loads;
    81         *pparameters=parameters;
    82 
     85        *pelements    = elements;
     86        *pnodes       = nodes;
     87        *pvertices    = vertices;
     88        *pmaterials   = materials;
     89        *pconstraints = constraints;
     90        *ploads       = loads;
     91        *pparameters  = parameters;
    8392}

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

    r16539 r16542  
    1212
    1313/*Creation of fem datasets: general drivers*/
    14 void CreateDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,FILE* toolkitfile,char* rootpath,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
    15 void CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels);
    16 void CreateParameters(Parameters** pparameters,IoModel* iomodel,char* rootpath,FILE* toolkitfile,const int solution_type,int analysis_type,int analysis_counter);
    17 void CreateParametersAutodiff(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    18 void CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    19 void CreateParametersDakota(Parameters** pparameters,IoModel* iomodel,char* rootpath,int solution_type,int analysis_type);
    20 void CreateOutputDefinitions(Parameters** pparameters,IoModel* iomodel);
     14void CreateDataSets(Elements* elements,Nodes* nodes,Vertices* vertices, Materials* materials, Constraints* constraints, Loads* loads,Parameters* parameters,IoModel* iomodel,FILE* toolkitfile,char* rootpath,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
     15void CreateElementsVerticesAndMaterials(Elements* elements,Vertices* vertices,Materials* materials, IoModel* iomodel,const int nummodels);
     16void CreateParameters(Parameters*parameters,IoModel* iomodel,char* rootpath,FILE* toolkitfile,const int solution_type);
     17void CreateParametersAutodiff(Parameters* parameters,IoModel* iomodel);
     18void CreateParametersControl(Parameters* parameters,IoModel* iomodel,int solution_type);
     19void CreateParametersDakota(Parameters* parameters,IoModel* iomodel,char* rootpath);
     20void CreateOutputDefinitions(Parameters* parameters,IoModel* iomodel);
    2121void UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel);
    2222void UpdateElementsAndMaterialsDakota(Elements* elements,Materials* materials, IoModel* iomodel);
    2323void UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel,int analysis_counter,int analysis_type);
    24 void CreateNodes(Nodes** pnodes, IoModel* iomodel,int analysis,int finite_element,int approximation=NoneApproximationEnum);
     24void CreateNodes(Nodes*nodes, IoModel* iomodel,int analysis,int finite_element,int approximation=NoneApproximationEnum);
    2525
    2626/*partitioning: */
    … …  
    3939
    4040/*Diverse: */
    41 void SortDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Loads** ploads, Materials** pmaterials, Constraints** pconstraints, Parameters** pparameters);
    42 void UpdateCounters(IoModel* iomodel,Nodes** pnodes,Loads** ploads, Constraints** pconstraints);
     41void SortDataSets(Elements*elements,Nodes*nodes,Vertices*vertices, Loads*loads, Materials*materials, Constraints*constraints, Parameters*parameters);
     42void UpdateCounters(IoModel* iomodel,Nodes*nodes,Loads*loads, Constraints*constraints);
    4343
    4444#endif

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

    r15464 r16542  
    1313#include "./ModelProcessorx.h"
    1414
    15 void SortDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Loads** ploads, Materials** pmaterials, Constraints** pconstraints, Parameters** pparameters){
    16 
    17         Elements    *elements    = NULL;
    18         Nodes       *nodes       = NULL;
    19         Vertices    *vertices    = NULL;
    20         Loads       *loads       = NULL;
    21         Materials   *materials   = NULL;
    22         Constraints *constraints = NULL;
    23         Parameters  *parameters  = NULL;
    24 
    25         /*Recover pointers: */
    26         elements    = *pelements;
    27         nodes       = *pnodes;
    28         vertices    = *pvertices;
    29         loads       = *ploads;
    30         materials   = *pmaterials;
    31         constraints = *pconstraints;
    32         parameters  = *pparameters;
     15void SortDataSets(Elements*elements,Nodes*nodes,Vertices*vertices, Loads*loads, Materials*materials, Constraints*constraints, Parameters*parameters){
    3316
    3417        /*All our datasets are already ordered by ids. Set presort flag so that
    3518         * later on, when sorting is requested on these datasets, it will not be
    3619         * redone: */
    37         if(elements)    elements->Presort();
    38         if(nodes)       nodes->Presort();
    39         if(vertices)    vertices->Presort();
    40         if(loads)       loads->Presort();
    41         if(materials)   materials->Presort();
    42         if(constraints) constraints->Presort();
    43         if(parameters)  parameters->Presort();
    44 
     20        elements->Presort();
     21        nodes->Presort();
     22        vertices->Presort();
     23        loads->Presort();
     24        materials->Presort();
     25        constraints->Presort();
     26        parameters->Presort();
    4527}

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

    r16182 r16542  
    1313#include "./ModelProcessorx.h"
    1414
    15 void    UpdateCounters(IoModel* iomodel,Nodes** pnodes,Loads** ploads, Constraints** pconstraints){
     15void    UpdateCounters(IoModel* iomodel,Nodes* nodes,Loads* loads, Constraints* constraints){
    1616
    17         Nodes* nodes=NULL;
    18         Loads* loads=NULL;
    19         Constraints* constraints=NULL;
    20 
    21         /*recover pointers: */
    22         nodes=*pnodes;
    23         loads=*ploads;
    24         constraints=*pconstraints;
    25 
    26         if(nodes) iomodel->nodecounter=nodes->MaximumId();
    27         else iomodel->nodecounter=0;
    28 
    29         if(loads)iomodel->loadcounter=loads->NumberOfLoads();
    30         else iomodel->loadcounter=0;
    31 
    32         if(constraints)iomodel->constraintcounter=constraints->NumberOfConstraints();
    33         else iomodel->constraintcounter=0;
     17        iomodel->nodecounter       = nodes->MaximumId();
     18        iomodel->loadcounter       = loads->NumberOfLoads();
     19        iomodel->constraintcounter = constraints->NumberOfConstraints();
    3420
    3521}
Note: See TracChangeset for help on using the changeset viewer.