Changeset 9340


Ignore:
Timestamp:
08/12/11 18:07:26 (14 years ago)
Author:
Eric.Larour
Message:

Propping up IoModel class, to contain the iomodel handlle. This simplifies IoModelFetchDAta,
which then becomes the FetchData method of the IoModel class.

Location:
issm/trunk/src/c
Files:
1 deleted
63 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Makefile.am

    r9293 r9340  
    409409                                        ./io/io.h\
    410410                                        ./io/Disk/diskio.h\
    411                                         ./io/Disk/IoModelFetchData.cpp\
    412411                                        ./io/Disk/pfopen.cpp\
    413412                                        ./io/Disk/pfclose.cpp\
    … …  
    11011100                                        ./io/io.h\
    11021101                                        ./io/Disk/diskio.h\
    1103                                         ./io/Disk/IoModelFetchData.cpp\
    11041102                                        ./io/Disk/pfopen.cpp\
    11051103                                        ./io/Disk/pfclose.cpp\

  • issm/trunk/src/c/io/Disk/diskio.h

    r8967 r9340  
    1616void  pfclose(FILE* fid,char* filename);
    1717
    18 void  IoModelFetchData(bool*     pboolean,FILE* model_handle,int data_enum);
    19 void  IoModelFetchData(int*      pinteger,FILE* model_handle,int data_enum);
    20 void  IoModelFetchData(double*   pscalar,FILE* model_handle,int data_enum);
    21 void  IoModelFetchData(char**    pstring,FILE* model_handle,int data_enum);
    22 void  IoModelFetchData(double**  pscalarmatrix,int* pM,int* pN,FILE* model_handle,int data_enum);
    23 void  IoModelFetchData(char***   pstringarray,int* pnumstrings,FILE* model_handle,int data_enum);
    24 void  IoModelFetchData(double*** pmatrixarray,int** pmdims,int** pndims, int* pnumrecords,FILE* model_handle,int data_enum);
    25 
    26 FILE* SetFilePointerToData(int* pcode,int* pvector_type, FILE* model_handle,int data_enum);
    27 
    2818#endif  /* _IO_H_ */

  • issm/trunk/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp

    r9285 r9340  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void IoModelToConstraintsx(Constraints* constraints,IoModel* iomodel,FILE* iomodel_handle,int vector_enum,int analysis_type){
     12void IoModelToConstraintsx(Constraints* constraints,IoModel* iomodel,int vector_enum,int analysis_type){
    1313       
    1414
    … …  
    3333
    3434        /*First of, find the record for the enum, and get code  of data type: */
    35         fid=SetFilePointerToData(&code, &vector_layout,iomodel_handle,vector_enum);
     35        fid=iomodel->SetFilePointerToData(&code, &vector_layout,vector_enum);
    3636
    3737        if(code!=7)_error_("%s%s"," expecting a double vector for constraints with enum ",EnumToStringx(vector_enum));
    … …  
    3939
    4040        /*Fetch vector:*/
    41         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,vector_enum);
     41        iomodel->FetchData(&doublevector,&M,&N,vector_enum);
    4242
    4343        /*Transient or static?:*/

  • issm/trunk/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.h

    r9002 r9340  
    99
    1010/* local prototypes: */
    11 void IoModelToConstraintsx(Constraints* constraints,IoModel* iomodel,FILE* iomodel_handle,int vector_enum,int analysis_type);
     11void IoModelToConstraintsx(Constraints* constraints,IoModel* iomodel,int vector_enum,int analysis_type);
    1212
    1313#endif  /* _IOMODELTOELEMENTINPUTX_H */

  • issm/trunk/src/c/modules/IoModelToInputsx/IoModelToInputsx.cpp

    r8976 r9340  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void IoModelToInputsx(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int vector_enum,int default_vector_enum,double default_value){
     12void IoModelToInputsx(Elements* elements,IoModel* iomodel,int vector_enum,int default_vector_enum,double default_value){
    1313       
    1414
    … …  
    3535
    3636        /*First of, find the record for the enum, and get code  of data type: */
    37         fid=SetFilePointerToData(&code, &vector_layout,iomodel_handle,vector_enum);
     37        fid=iomodel->SetFilePointerToData(&code, &vector_layout,vector_enum);
    3838
    3939        switch(code){
    4040                case 1: //boolean constant.  {{{1
    41                         IoModelFetchData(&boolean,iomodel_handle,vector_enum);
     41                        iomodel->FetchData(&boolean,vector_enum);
    4242
    4343                        /*Add boolean constant input to all elements: */
    … …  
    5252                        break; /*}}}*/
    5353                case 2: //integer constant.  {{{1
    54                         IoModelFetchData(&integer,iomodel_handle,vector_enum);
     54                        iomodel->FetchData(&integer,vector_enum);
    5555
    5656                        /*Add integer constant input to all elements: */
    … …  
    6565                        break; /*}}}*/
    6666                case 3: //double constant.  {{{1
    67                         IoModelFetchData(&scalar,iomodel_handle,vector_enum);
     67                        iomodel->FetchData(&scalar,vector_enum);
    6868
    6969                        /*Add double constant input to all elements: */
    … …  
    8080
    8181                        /*Fetch vector:*/
    82                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,vector_enum); //we still have a doublevector, because it might include times in transient mode
     82                        iomodel->FetchData(&doublevector,&M,&N,vector_enum); //we still have a doublevector, because it might include times in transient mode
    8383                        /*Check we got something, otherwise fetch default: */
    8484                        if(doublevector){
    … …  
    8989                                if(default_vector_enum!=NoneEnum){
    9090                                        /*yes. fetch it: */
    91                                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,default_vector_enum);
     91                                        iomodel->FetchData(&doublevector,&M,&N,default_vector_enum);
    9292                                        if(doublevector){
    9393                                                defaulting=false;  //we are not defaulting, because  we do have a vector
    … …  
    118118
    119119                        /*Fetch vector:*/
    120                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,vector_enum); //we still have a doublevector, because it might include times in transient mode
     120                        iomodel->FetchData(&doublevector,&M,&N,vector_enum); //we still have a doublevector, because it might include times in transient mode
    121121                        /*Check we got something, otherwise fetch default: */
    122122                        if(doublevector){
    … …  
    127127                                if(default_vector_enum!=NoneEnum){
    128128                                        /*yes. fetch it: */
    129                                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,default_vector_enum);
     129                                        iomodel->FetchData(&doublevector,&M,&N,default_vector_enum);
    130130                                        if(doublevector){
    131131                                                defaulting=false;  //we are not defaulting, because  we do have a vector
    … …  
    156156
    157157                        /*Fetch vector:*/
    158                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,vector_enum);
     158                        iomodel->FetchData(&doublevector,&M,&N,vector_enum);
    159159                        /*Check we got something, otherwise fetch default: */
    160160                        if(doublevector){
    … …  
    165165                                if(default_vector_enum!=NoneEnum){
    166166                                        /*yes. fetch it: */
    167                                         IoModelFetchData(&doublevector,&M,&N,iomodel_handle,default_vector_enum);
     167                                        iomodel->FetchData(&doublevector,&M,&N,default_vector_enum);
    168168                                        if(doublevector){
    169169                                                defaulting=false;  //we are not defaulting, because  we do have a vector

  • issm/trunk/src/c/modules/IoModelToInputsx/IoModelToInputsx.h

    r8967 r9340  
    99
    1010/* local prototypes: */
    11 void IoModelToInputsx(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int vector_enum,int default_vector_enum=NoneEnum,double default_value=0);
     11void IoModelToInputsx(Elements* elements,IoModel* iomodel,int vector_enum,int default_vector_enum=NoneEnum,double default_value=0);
    1212
    1313#endif  /* _IOMODELTOELEMENTINPUTX_H */

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/CreateConstraintsBalancethickness.cpp

    r9081 r9340  
    88#include "../ModelProcessorx.h"
    99
    10 void    CreateConstraintsBalancethickness(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     10void    CreateConstraintsBalancethickness(Constraints** pconstraints, IoModel* iomodel){
    1111
    1212        /*Output*/
    … …  
    2121        /*Do not add constraints in DG*/
    2222        if(!iomodel->prognostic_DG){
    23                 IoModelToConstraintsx(constraints,iomodel,iomodel_handle,SpcthicknessEnum,BalancethicknessAnalysisEnum);
     23                IoModelToConstraintsx(constraints,iomodel,SpcthicknessEnum,BalancethicknessAnalysisEnum);
    2424        }
    2525

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/CreateLoadsBalancethickness.cpp

    r8926 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3030
    3131                /*Get edges and elements*/
    32                 IoModelFetchData(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel_handle,EdgesEnum);
    33                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    34                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
     32                iomodel->FetchData(&iomodel->edges,&iomodel->numberofedges,NULL,EdgesEnum);
     33                iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     34                iomodel->FetchData(&iomodel->thickness,NULL,NULL,ThicknessEnum);
    3535
    3636                /*First load data:*/

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/CreateNodesBalancethickness.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesBalancethickness(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesBalancethickness(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    3333        /*Continuous Galerkin partition of nodes: */
    3434        if(iomodel->prognostic_DG) continuous_galerkin=false;
    35         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     35        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3636
    3737        /*Check in 3d*/
    … …  
    3939
    4040        /*First fetch data: */
    41         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    42         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    43         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    44         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    45         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    46         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    47         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     41        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     42        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     43        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     44        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     45        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     46        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     47        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4848
    4949        if(continuous_galerkin){

  • issm/trunk/src/c/modules/ModelProcessorx/Balancethickness/UpdateElementsBalancethickness.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsBalancethickness(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsBalancethickness(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Fetch data needed: */
    19         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     19        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2020
    2121        /*Update elements: */
    … …  
    2929        }
    3030
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    33         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,DhdtEnum);
     31        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     32        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     33        IoModelToInputsx(elements,iomodel,BedEnum);
     34        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     35        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     36        IoModelToInputsx(elements,iomodel,VxEnum);
     37        IoModelToInputsx(elements,iomodel,VyEnum);
     38        IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     39        IoModelToInputsx(elements,iomodel,SurfaceAccumulationRateEnum);
     40        IoModelToInputsx(elements,iomodel,SurfaceAblationRateEnum);
     41        IoModelToInputsx(elements,iomodel,SurfaceMassBalanceEnum);
     42        IoModelToInputsx(elements,iomodel,DhdtEnum);
    4343
    4444        if (iomodel->dim==3){
    45                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    46                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     45                IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     46                IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
    4747        }
    4848        /*Free data: */

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/CreateConstraintsBedSlope.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsBedSlope(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsBedSlope(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Output*/

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/CreateLoadsBedSlope.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsBedSlope(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsBedSlope(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSet*/

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/CreateNodesBedSlope.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesBedSlope(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesBedSlope(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929       
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232       
    3333        /*First fetch data: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/BedSlope/UpdateElementsBedSlope.cpp

    r8986 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsBedSlope(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsBedSlope(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Fetch data needed: */
    19         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     19        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2020
    2121        /*Update elements: */
    … …  
    2929        }
    3030
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    33         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     31        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     32        IoModelToInputsx(elements,iomodel,BedEnum);
     33        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
    3434
    3535        if (iomodel->dim==3){
    36                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    37                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     36                IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     37                IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
    3838        }
    3939       

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

    r8926 r9340  
    1212#include "../ModelProcessorx.h"
    1313
    14 void CreateParametersControl(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,int solution_type,int analysis_type){
     14void CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type){
    1515       
    1616        int i;
    … …  
    2828
    2929                /*What control type?*/
    30                 IoModelFetchData(&iomodel->control_type,NULL,NULL,iomodel_handle,ControlTypeEnum);
     30                iomodel->FetchData(&iomodel->control_type,NULL,NULL,ControlTypeEnum);
    3131                parameters->AddObject(new IntVecParam(ControlTypeEnum,iomodel->control_type,iomodel->num_control_type));
    3232                xfree((void**)&iomodel->control_type);
    … …  
    4747
    4848                /*Now, recover fit, optscal and maxiter as vectors: */
    49                 IoModelFetchData(&iomodel->cm_responses,NULL,NULL,iomodel_handle,CmResponsesEnum);
    50                 IoModelFetchData(&iomodel->cm_jump,NULL,NULL,iomodel_handle,CmJumpEnum);
    51                 IoModelFetchData(&iomodel->optscal,NULL,NULL,iomodel_handle,OptscalEnum);
    52                 IoModelFetchData(&iomodel->maxiter,NULL,NULL,iomodel_handle,MaxiterEnum);
     49                iomodel->FetchData(&iomodel->cm_responses,NULL,NULL,CmResponsesEnum);
     50                iomodel->FetchData(&iomodel->cm_jump,NULL,NULL,CmJumpEnum);
     51                iomodel->FetchData(&iomodel->optscal,NULL,NULL,OptscalEnum);
     52                iomodel->FetchData(&iomodel->maxiter,NULL,NULL,MaxiterEnum);
    5353
    5454                parameters->AddObject(new DoubleMatParam(OptscalEnum,iomodel->optscal,iomodel->nsteps,iomodel->num_control_type));

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

    r8967 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel,FILE* iomodel_handle){
     16void    UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel){
    1717
    1818        /*Intermediary*/
    … …  
    2626
    2727        /*Fetch data needed: */
    28         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     28        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2929
    30         IoModelToInputsx(elements,iomodel,iomodel_handle,VxObsEnum);
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,VyObsEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessObsEnum);
     30        IoModelToInputsx(elements,iomodel,VxObsEnum);
     31        IoModelToInputsx(elements,iomodel,VyObsEnum);
     32        IoModelToInputsx(elements,iomodel,ThicknessObsEnum);
    3333
    34         IoModelFetchData(&iomodel->control_type,NULL,NULL,iomodel_handle,ControlTypeEnum);
    35         IoModelFetchData(&iomodel->weights,NULL,NULL,iomodel_handle,WeightsEnum);
    36         IoModelFetchData(&iomodel->cm_min,NULL,NULL,iomodel_handle,CmMinEnum);
    37         IoModelFetchData(&iomodel->cm_max,NULL,NULL,iomodel_handle,CmMaxEnum);
     34        iomodel->FetchData(&iomodel->control_type,NULL,NULL,ControlTypeEnum);
     35        iomodel->FetchData(&iomodel->weights,NULL,NULL,WeightsEnum);
     36        iomodel->FetchData(&iomodel->cm_min,NULL,NULL,CmMinEnum);
     37        iomodel->FetchData(&iomodel->cm_max,NULL,NULL,CmMaxEnum);
    3838        for(i=0;i<iomodel->num_control_type;i++){
    3939                switch((int)iomodel->control_type[i]){
    4040                        case DhdtEnum:
    41                                 IoModelFetchData(&iomodel->dhdt,NULL,NULL,iomodel_handle,DhdtEnum);
     41                                iomodel->FetchData(&iomodel->dhdt,NULL,NULL,DhdtEnum);
    4242                                break;
    4343                        case VxEnum:
    44                                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
     44                                iomodel->FetchData(&iomodel->vx,NULL,NULL,VxEnum);
    4545                                break;
    4646                        case VyEnum:
    47                                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
     47                                iomodel->FetchData(&iomodel->vy,NULL,NULL,VyEnum);
    4848                                break;
    4949                        case DragCoefficientEnum:
    50                                 IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
     50                                iomodel->FetchData(&iomodel->drag_coefficient,NULL,NULL,DragCoefficientEnum);
    5151                                break;
    5252                        case RheologyBbarEnum:
    53                                 IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
     53                                iomodel->FetchData(&iomodel->rheology_B,NULL,NULL,RheologyBEnum);
    5454                                break;
    5555                        default:

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

    r9320 r9340  
    1616
    1717
    18 void CreateDataSets(Elements** pelements,Nodes** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,const int solution_type,const int analysis_type,const int nummodels,int analysis_counter){
     18void CreateDataSets(Elements** pelements,Nodes** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,const int solution_type,const int analysis_type,const int nummodels,int analysis_counter){
    1919
    2020        bool        continuous = true;
    … …  
    2424                       
    2525        /*Create elements, vertices and materials, independent of analysis_type: */
    26         CreateElementsVerticesAndMaterials(pelements, pvertices, pmaterials, iomodel,iomodel_handle,nummodels);
     26        CreateElementsVerticesAndMaterials(pelements, pvertices, pmaterials, iomodel,nummodels);
    2727
    2828        /*Recover elements and materials, for future update: */
    … …  
    3333        switch(analysis_type){
    3434                case DiagnosticHorizAnalysisEnum:
    35                         CreateNodesDiagnosticHoriz(pnodes, iomodel,iomodel_handle);
    36                         CreateConstraintsDiagnosticHoriz(pconstraints,iomodel,iomodel_handle);
    37                         CreateLoadsDiagnosticHoriz(ploads,iomodel,iomodel_handle);
    38                         UpdateElementsDiagnosticHoriz(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     35                        CreateNodesDiagnosticHoriz(pnodes, iomodel);
     36                        CreateConstraintsDiagnosticHoriz(pconstraints,iomodel);
     37                        CreateLoadsDiagnosticHoriz(ploads,iomodel);
     38                        UpdateElementsDiagnosticHoriz(elements,iomodel,analysis_counter,analysis_type);
    3939                        break;
    4040               
    4141                case DiagnosticVertAnalysisEnum:
    42                         CreateNodesDiagnosticVert(pnodes, iomodel,iomodel_handle);
    43                         CreateConstraintsDiagnosticVert(pconstraints,iomodel,iomodel_handle);
    44                         CreateLoadsDiagnosticVert(ploads,iomodel,iomodel_handle);
    45                         UpdateElementsDiagnosticVert(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     42                        CreateNodesDiagnosticVert(pnodes, iomodel);
     43                        CreateConstraintsDiagnosticVert(pconstraints,iomodel);
     44                        CreateLoadsDiagnosticVert(ploads,iomodel);
     45                        UpdateElementsDiagnosticVert(elements,iomodel,analysis_counter,analysis_type);
    4646                        break;
    4747       
    4848                case DiagnosticHutterAnalysisEnum:
    49                         CreateNodesDiagnosticHutter(pnodes, iomodel,iomodel_handle);
    50                         CreateConstraintsDiagnosticHutter(pconstraints,iomodel,iomodel_handle);
    51                         CreateLoadsDiagnosticHutter(ploads,iomodel,iomodel_handle);
    52                         UpdateElementsDiagnosticHutter(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     49                        CreateNodesDiagnosticHutter(pnodes, iomodel);
     50                        CreateConstraintsDiagnosticHutter(pconstraints,iomodel);
     51                        CreateLoadsDiagnosticHutter(ploads,iomodel);
     52                        UpdateElementsDiagnosticHutter(elements,iomodel,analysis_counter,analysis_type);
    5353                        break;
    5454
    5555                case BedSlopeAnalysisEnum:
    56                         CreateNodesBedSlope(pnodes, iomodel,iomodel_handle);
    57                         CreateConstraintsBedSlope(pconstraints,iomodel,iomodel_handle);
    58                         CreateLoadsBedSlope(ploads,iomodel,iomodel_handle);
    59                         UpdateElementsBedSlope(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     56                        CreateNodesBedSlope(pnodes, iomodel);
     57                        CreateConstraintsBedSlope(pconstraints,iomodel);
     58                        CreateLoadsBedSlope(ploads,iomodel);
     59                        UpdateElementsBedSlope(elements,iomodel,analysis_counter,analysis_type);
    6060                        break;
    6161
    6262                case SurfaceSlopeAnalysisEnum:
    63                         CreateNodesSurfaceSlope(pnodes, iomodel,iomodel_handle);
    64                         CreateConstraintsSurfaceSlope(pconstraints,iomodel,iomodel_handle);
    65                         CreateLoadsSurfaceSlope(ploads,iomodel,iomodel_handle);
    66                         UpdateElementsSurfaceSlope(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     63                        CreateNodesSurfaceSlope(pnodes, iomodel);
     64                        CreateConstraintsSurfaceSlope(pconstraints,iomodel);
     65                        CreateLoadsSurfaceSlope(ploads,iomodel);
     66                        UpdateElementsSurfaceSlope(elements,iomodel,analysis_counter,analysis_type);
    6767                        break;
    6868
    6969                case ThermalAnalysisEnum:
    70                         CreateNodesThermal(pnodes, iomodel,iomodel_handle);
    71                         CreateConstraintsThermal(pconstraints,iomodel,iomodel_handle);
    72                         CreateLoadsThermal(ploads,iomodel,iomodel_handle);
    73                         UpdateElementsThermal(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     70                        CreateNodesThermal(pnodes, iomodel);
     71                        CreateConstraintsThermal(pconstraints,iomodel);
     72                        CreateLoadsThermal(ploads,iomodel);
     73                        UpdateElementsThermal(elements,iomodel,analysis_counter,analysis_type);
    7474                        break;
    7575               
    7676                case EnthalpyAnalysisEnum:
    77                         CreateNodesEnthalpy(pnodes, iomodel,iomodel_handle);
    78                         CreateConstraintsEnthalpy(pconstraints,iomodel,iomodel_handle);
    79                         CreateLoadsEnthalpy(ploads,iomodel,iomodel_handle);
    80                         UpdateElementsEnthalpy(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     77                        CreateNodesEnthalpy(pnodes, iomodel);
     78                        CreateConstraintsEnthalpy(pconstraints,iomodel);
     79                        CreateLoadsEnthalpy(ploads,iomodel);
     80                        UpdateElementsEnthalpy(elements,iomodel,analysis_counter,analysis_type);
    8181                        break;
    8282               
    8383                case HydrologyAnalysisEnum:
    84                         CreateNodesHydrology(pnodes, iomodel,iomodel_handle);
    85                         CreateConstraintsHydrology(pconstraints,iomodel,iomodel_handle);
    86                         CreateLoadsHydrology(ploads,iomodel,iomodel_handle);
    87                         UpdateElementsHydrology(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     84                        CreateNodesHydrology(pnodes, iomodel);
     85                        CreateConstraintsHydrology(pconstraints,iomodel);
     86                        CreateLoadsHydrology(ploads,iomodel);
     87                        UpdateElementsHydrology(elements,iomodel,analysis_counter,analysis_type);
    8888                        break;
    8989
    9090                case MeltingAnalysisEnum:
    91                         CreateNodesMelting(pnodes, iomodel,iomodel_handle);
    92                         CreateConstraintsMelting(pconstraints,iomodel,iomodel_handle);
    93                         CreateLoadsMelting(ploads,iomodel,iomodel_handle);
    94                         UpdateElementsMelting(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     91                        CreateNodesMelting(pnodes, iomodel);
     92                        CreateConstraintsMelting(pconstraints,iomodel);
     93                        CreateLoadsMelting(ploads,iomodel);
     94                        UpdateElementsMelting(elements,iomodel,analysis_counter,analysis_type);
    9595                        break;
    9696
    9797                case PrognosticAnalysisEnum:
    98                         CreateNodesPrognostic(pnodes, iomodel,iomodel_handle);
    99                         CreateConstraintsPrognostic(pconstraints,iomodel,iomodel_handle);
    100                         CreateLoadsPrognostic(ploads,iomodel,iomodel_handle);
    101                         UpdateElementsPrognostic(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     98                        CreateNodesPrognostic(pnodes, iomodel);
     99                        CreateConstraintsPrognostic(pconstraints,iomodel);
     100                        CreateLoadsPrognostic(ploads,iomodel);
     101                        UpdateElementsPrognostic(elements,iomodel,analysis_counter,analysis_type);
    102102                        break;
    103103
    104104                case BalancethicknessAnalysisEnum:
    105                         CreateNodesBalancethickness(pnodes, iomodel,iomodel_handle);
    106                         CreateConstraintsBalancethickness(pconstraints,iomodel,iomodel_handle);
    107                         CreateLoadsBalancethickness(ploads,iomodel,iomodel_handle);
    108                         UpdateElementsBalancethickness(elements,iomodel,iomodel_handle,analysis_counter,analysis_type);
     105                        CreateNodesBalancethickness(pnodes, iomodel);
     106                        CreateConstraintsBalancethickness(pconstraints,iomodel);
     107                        CreateLoadsBalancethickness(ploads,iomodel);
     108                        UpdateElementsBalancethickness(elements,iomodel,analysis_counter,analysis_type);
    109109                        break;
    110110
    … …  
    114114
    115115        /*Update Elements and Materials For Control methods*/
    116         UpdateElementsAndMaterialsControl(elements,materials,iomodel,iomodel_handle);
     116        UpdateElementsAndMaterialsControl(elements,materials,iomodel);
    117117
    118118        /*Generate objects that are not dependent on any analysis_type: */
    119         CreateParameters(pparameters,iomodel,iomodel_handle,solution_type,analysis_type,analysis_counter);
     119        CreateParameters(pparameters,iomodel,solution_type,analysis_type,analysis_counter);
    120120
    121121        /*Update Elements in case we are running a transient solution: */
    122122        parameters=*pparameters;
    123123        if(analysis_counter==(nummodels-1)&& solution_type==TransientSolutionEnum){
    124                 UpdateElementsTransient(elements,parameters,iomodel,iomodel_handle,analysis_counter,analysis_type);
     124                UpdateElementsTransient(elements,parameters,iomodel,analysis_counter,analysis_type);
    125125        }
    126126

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

    r8983 r9340  
    1313#include "./ModelProcessorx.h"
    1414
    15 void    CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,FILE* iomodel_handle,const int nummodels){
     15void    CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels){
    1616
    1717        /*Intermediary*/
    … …  
    3232       
    3333        /*First, partition elements and vertices. Nodes will partitioned on a per analysis_type basis. If partitining already done, ignore: */
    34         ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel,iomodel_handle);
     34        ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
    3535       
    3636        /*Fetch data needed: */
    37         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    38         IoModelFetchData(&iomodel->elementconnectivity,NULL,NULL,iomodel_handle,ElementconnectivityEnum);
    39         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,UpperelementsEnum);
    40         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,LowerelementsEnum);
    41         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    42         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    43         IoModelFetchData(&iomodel->control_type,NULL,NULL,iomodel_handle,ControlTypeEnum);
    44         IoModelFetchData(&iomodel->cm_min,NULL,NULL,iomodel_handle,CmMinEnum);
    45         IoModelFetchData(&iomodel->cm_max,NULL,NULL,iomodel_handle,CmMaxEnum);
     37        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     38        iomodel->FetchData(&iomodel->elementconnectivity,NULL,NULL,ElementconnectivityEnum);
     39        iomodel->FetchData(&iomodel->upperelements,NULL,NULL,UpperelementsEnum);
     40        iomodel->FetchData(&iomodel->lowerelements,NULL,NULL,LowerelementsEnum);
     41        iomodel->FetchData(&iomodel->rheology_B,NULL,NULL,RheologyBEnum);
     42        iomodel->FetchData(&iomodel->rheology_n,NULL,NULL,RheologyNEnum);
     43        iomodel->FetchData(&iomodel->control_type,NULL,NULL,ControlTypeEnum);
     44        iomodel->FetchData(&iomodel->cm_min,NULL,NULL,CmMinEnum);
     45        iomodel->FetchData(&iomodel->cm_max,NULL,NULL,CmMaxEnum);
    4646       
    4747        /*Create elements and materials: */
    … …  
    7676       
    7777        /*Create vertices: */
    78         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,XEnum);
    79         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,YEnum);
    80         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,ZEnum);
    81         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    82         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
     78        iomodel->FetchData(&iomodel->x,NULL,NULL,XEnum);
     79        iomodel->FetchData(&iomodel->y,NULL,NULL,YEnum);
     80        iomodel->FetchData(&iomodel->z,NULL,NULL,ZEnum);
     81        iomodel->FetchData(&iomodel->bed,NULL,NULL,BedEnum);
     82        iomodel->FetchData(&iomodel->thickness,NULL,NULL,ThicknessEnum);
    8383       
    8484        for (i=0;i<iomodel->numberofvertices;i++){

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

    r9113 r9340  
    1212#include "./ModelProcessorx.h"
    1313
    14 void CreateParameters(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,const int solution_type,int analysis_type,int analysis_counter){
     14void CreateParameters(Parameters** pparameters,IoModel* iomodel,const int solution_type,int analysis_type,int analysis_counter){
    1515       
    1616        int i;
    … …  
    7777
    7878        /*Deal with more complex parameters*/
    79         IoModelFetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,iomodel_handle,RiftinfoEnum);
     79        iomodel->FetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,RiftinfoEnum);
    8080        parameters->AddObject(new IntParam(NumRiftsEnum,iomodel->numrifts));
    8181        xfree((void**)&iomodel->riftinfo);
    … …  
    8383
    8484        /*Requested output?*/
    85         IoModelFetchData(&requestedoutputs,&numoutputs,NULL,iomodel_handle,RequestedOutputsEnum);
     85        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,RequestedOutputsEnum);
    8686        parameters->AddObject(new IntParam(NumRequestedOutputsEnum,numoutputs));
    8787        if(numoutputs)parameters->AddObject(new IntVecParam(RequestedOutputsEnum,requestedoutputs,numoutputs));
    … …  
    8989       
    9090        /*Before returning, create parameters in case we are running Qmu or control types runs: */
    91         CreateParametersControl(&parameters,iomodel,iomodel_handle,solution_type,analysis_type);
    92         CreateParametersQmu(&parameters,iomodel,iomodel_handle,solution_type,analysis_type);
     91        CreateParametersControl(&parameters,iomodel,solution_type,analysis_type);
     92        CreateParametersQmu(&parameters,iomodel,solution_type,analysis_type);
    9393
    9494        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp

    r9298 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3232       
    3333        /*Constraints: fetch data: */
    34         IoModelFetchData(&iomodel->spcvx,NULL,NULL,iomodel_handle,SpcvxEnum);
    35         IoModelFetchData(&iomodel->spcvy,NULL,NULL,iomodel_handle,SpcvyEnum);
    36         IoModelFetchData(&iomodel->spcvz,NULL,NULL,iomodel_handle,SpcvzEnum);
    37         IoModelFetchData(&iomodel->nodeonhutter,NULL,NULL,iomodel_handle,NodeOnHutterEnum);
    38         IoModelFetchData(&iomodel->nodeonmacayeal,NULL,NULL,iomodel_handle,NodeOnMacayealEnum);
    39         if(iomodel->dim==3)IoModelFetchData(&iomodel->nodeonpattyn,NULL,NULL,iomodel_handle,NodeOnPattynEnum);
    40         if(iomodel->dim==3)IoModelFetchData(&iomodel->nodeonstokes,NULL,NULL,iomodel_handle,NodeOnStokesEnum);
    41         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    42         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    43         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,ZEnum);
     34        iomodel->FetchData(&iomodel->spcvx,NULL,NULL,SpcvxEnum);
     35        iomodel->FetchData(&iomodel->spcvy,NULL,NULL,SpcvyEnum);
     36        iomodel->FetchData(&iomodel->spcvz,NULL,NULL,SpcvzEnum);
     37        iomodel->FetchData(&iomodel->nodeonhutter,NULL,NULL,NodeOnHutterEnum);
     38        iomodel->FetchData(&iomodel->nodeonmacayeal,NULL,NULL,NodeOnMacayealEnum);
     39        if(iomodel->dim==3)iomodel->FetchData(&iomodel->nodeonpattyn,NULL,NULL,NodeOnPattynEnum);
     40        if(iomodel->dim==3)iomodel->FetchData(&iomodel->nodeonstokes,NULL,NULL,NodeOnStokesEnum);
     41        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     42        iomodel->FetchData(&iomodel->surface,NULL,NULL,SurfaceEnum);
     43        iomodel->FetchData(&iomodel->z,NULL,NULL,ZEnum);
    4444
    4545        /*Initialize counter: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

    r8926 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSets*/
    … …  
    3737        /*Create pressure loads as boundary conditions. Pay attention to the partitioning if we are running in parallel (the nodes
    3838         * referenced by a certain load must belong to the cluster node): */
    39         IoModelFetchData(&iomodel->pressureload,&iomodel->numberofpressureloads,NULL,iomodel_handle,PressureloadEnum);
    40         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    41         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    42         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
     39        iomodel->FetchData(&iomodel->pressureload,&iomodel->numberofpressureloads,NULL,PressureloadEnum);
     40        iomodel->FetchData(&iomodel->elements_type,NULL,NULL,ElementsTypeEnum);
     41        iomodel->FetchData(&iomodel->thickness,NULL,NULL,ThicknessEnum);
     42        iomodel->FetchData(&iomodel->bed,NULL,NULL,BedEnum);
    4343
    4444        /*Initialize counter: */
    … …  
    103103
    104104        /*create penalties for nodes on the base of icesheet. We must have wb=ub*db/dx+vb*db/dy */
    105         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    106         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    107         IoModelFetchData(&iomodel->nodeonstokes,NULL,NULL,iomodel_handle,NodeOnStokesEnum);
    108         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    109         IoModelFetchData(&iomodel->spcvx,NULL,NULL,iomodel_handle,SpcvxEnum);
    110         IoModelFetchData(&iomodel->spcvy,NULL,NULL,iomodel_handle,SpcvyEnum);
    111         IoModelFetchData(&iomodel->spcvz,NULL,NULL,iomodel_handle,SpcvzEnum);
    112         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
     105        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     106        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     107        iomodel->FetchData(&iomodel->nodeonstokes,NULL,NULL,NodeOnStokesEnum);
     108        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     109        iomodel->FetchData(&iomodel->spcvx,NULL,NULL,SpcvxEnum);
     110        iomodel->FetchData(&iomodel->spcvy,NULL,NULL,SpcvyEnum);
     111        iomodel->FetchData(&iomodel->spcvz,NULL,NULL,SpcvzEnum);
     112        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
    113113        CreateSingleNodeToElementConnectivity(iomodel);
    114114       
    … …  
    137137
    138138        /*Create Penpair for penalties: */
    139         IoModelFetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,iomodel_handle,PenaltiesEnum);
     139        iomodel->FetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,PenaltiesEnum);
    140140       
    141141        for(i=0;i<iomodel->numpenalties;i++){
    … …  
    160160
    161161        /*Create Riffront loads for rifts: */
    162         IoModelFetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,iomodel_handle,RiftinfoEnum);
    163         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    164         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    165         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    166         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
     162        iomodel->FetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,RiftinfoEnum);
     163        iomodel->FetchData(&iomodel->thickness,NULL,NULL,ThicknessEnum);
     164        iomodel->FetchData(&iomodel->bed,NULL,NULL,BedEnum);
     165        iomodel->FetchData(&iomodel->surface,NULL,NULL,SurfaceEnum);
     166        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
    167167
    168168       

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesDiagnosticHoriz(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesDiagnosticHoriz(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    3232
    3333        /*Continuous Galerkin partition of nodes: */
    34         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     34        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3535
    3636        /*Create nodes: */
    37         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    38         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    39         IoModelFetchData(&iomodel->nodeonhutter,NULL,NULL,iomodel_handle,NodeOnHutterEnum);
    40         IoModelFetchData(&iomodel->nodeonmacayeal,NULL,NULL,iomodel_handle,NodeOnMacayealEnum);
    41         IoModelFetchData(&iomodel->nodeonstokes,NULL,NULL,iomodel_handle,NodeOnStokesEnum);
    42         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    43         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    44         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
    45         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    46         IoModelFetchData(&iomodel->diagnostic_ref,NULL,NULL,iomodel_handle,DiagnosticRefEnum);
     37        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     38        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     39        iomodel->FetchData(&iomodel->nodeonhutter,NULL,NULL,NodeOnHutterEnum);
     40        iomodel->FetchData(&iomodel->nodeonmacayeal,NULL,NULL,NodeOnMacayealEnum);
     41        iomodel->FetchData(&iomodel->nodeonstokes,NULL,NULL,NodeOnStokesEnum);
     42        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     43        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     44        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
     45        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     46        iomodel->FetchData(&iomodel->diagnostic_ref,NULL,NULL,DiagnosticRefEnum);
    4747       
    4848        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/UpdateElementsDiagnosticHoriz.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsDiagnosticHoriz(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsDiagnosticHoriz(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    23         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     23        iomodel->FetchData(&iomodel->elements_type,NULL,NULL,ElementsTypeEnum);
    2424
    2525        /*Update elements: */
    … …  
    3434
    3535        /*Create inputs: */
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,DragTypeEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
    48         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum,VxObsEnum,0);
    49         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum,VyObsEnum,0);
    50         IoModelToInputsx(elements,iomodel,iomodel_handle,BathymetryEnum);
     36        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     37        IoModelToInputsx(elements,iomodel,ThicknessCoeffEnum);
     38        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     39        IoModelToInputsx(elements,iomodel,BedEnum);
     40        IoModelToInputsx(elements,iomodel,DragCoefficientEnum);
     41        IoModelToInputsx(elements,iomodel,DragPEnum);
     42        IoModelToInputsx(elements,iomodel,DragQEnum);
     43        IoModelToInputsx(elements,iomodel,DragTypeEnum);
     44        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     45        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     46        IoModelToInputsx(elements,iomodel,RheologyBEnum);
     47        IoModelToInputsx(elements,iomodel,RheologyNEnum);
     48        IoModelToInputsx(elements,iomodel,VxEnum,VxObsEnum,0);
     49        IoModelToInputsx(elements,iomodel,VyEnum,VyObsEnum,0);
     50        IoModelToInputsx(elements,iomodel,BathymetryEnum);
    5151
    5252        if (iomodel->dim==3){
    53                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    54                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    55                 IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
    56                 IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
    57                 IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
    58                 IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    59                 IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    60                 IoModelToInputsx(elements,iomodel,iomodel_handle,NodeOnStokesEnum);
     53                IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     54                IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     55                IoModelToInputsx(elements,iomodel,VzEnum);
     56                IoModelToInputsx(elements,iomodel,SurfaceAccumulationRateEnum);
     57                IoModelToInputsx(elements,iomodel,SurfaceAblationRateEnum);
     58                IoModelToInputsx(elements,iomodel,SurfaceMassBalanceEnum);
     59                IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     60                IoModelToInputsx(elements,iomodel,NodeOnStokesEnum);
    6161        }
    6262
    6363        if(iomodel->control_analysis){
    64                 IoModelToInputsx(elements,iomodel,iomodel_handle,VxObsEnum);
    65                 IoModelToInputsx(elements,iomodel,iomodel_handle,VyObsEnum);
     64                IoModelToInputsx(elements,iomodel,VxObsEnum);
     65                IoModelToInputsx(elements,iomodel,VyObsEnum);
    6666        }
    6767

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp

    r9285 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsDiagnosticHutter(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsDiagnosticHutter(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3131
    3232        /*Fetch data: */
    33         IoModelFetchData(&iomodel->spcvx,NULL,NULL,iomodel_handle,SpcvxEnum);
    34         IoModelFetchData(&iomodel->spcvy,NULL,NULL,iomodel_handle,SpcvyEnum);
    35         IoModelFetchData(&iomodel->nodeonhutter,NULL,NULL,iomodel_handle,NodeOnHutterEnum);
     33        iomodel->FetchData(&iomodel->spcvx,NULL,NULL,SpcvxEnum);
     34        iomodel->FetchData(&iomodel->spcvy,NULL,NULL,SpcvyEnum);
     35        iomodel->FetchData(&iomodel->nodeonhutter,NULL,NULL,NodeOnHutterEnum);
    3636
    3737        /*Initialize conunter*/

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateLoadsDiagnosticHutter.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsDiagnosticHutter(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsDiagnosticHutter(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSet*/

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateNodesDiagnosticHutter.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesDiagnosticHutter(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesDiagnosticHutter(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    3232
    3333        /*Continuous Galerkin partition of nodes: */
    34         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     34        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3535
    3636        /*First fetch data: */
    37         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    38         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    39         IoModelFetchData(&iomodel->nodeonhutter,NULL,NULL,iomodel_handle,NodeOnHutterEnum);
    40         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    41         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    42         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    43         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    44         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     37        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     38        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     39        iomodel->FetchData(&iomodel->nodeonhutter,NULL,NULL,NodeOnHutterEnum);
     40        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     41        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     42        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     43        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     44        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4545
    4646        CreateNumberNodeToElementConnectivity(iomodel);

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/UpdateElementsDiagnosticHutter.cpp

    r8986 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsDiagnosticHutter(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsDiagnosticHutter(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the flag hutter on? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    23         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     23        iomodel->FetchData(&iomodel->elements_type,NULL,NULL,ElementsTypeEnum);
    2424
    2525        /*Update elements: */
    … …  
    3333        }
    3434       
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,NodeOnHutterEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
     35        IoModelToInputsx(elements,iomodel,NodeOnHutterEnum);
     36        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     37        IoModelToInputsx(elements,iomodel,ThicknessCoeffEnum);
    3838       
    3939        /*Free data: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateConstraintsDiagnosticVert.cpp

    r9285 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsDiagnosticVert(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsDiagnosticVert(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3030
    3131        /*Fetch data: */
    32         IoModelFetchData(&iomodel->spcvz,NULL,NULL,iomodel_handle,SpcvzEnum);
    33         IoModelFetchData(&iomodel->nodeonstokes,NULL,NULL,iomodel_handle,NodeOnStokesEnum);
     32        iomodel->FetchData(&iomodel->spcvz,NULL,NULL,SpcvzEnum);
     33        iomodel->FetchData(&iomodel->nodeonstokes,NULL,NULL,NodeOnStokesEnum);
    3434
    3535        /*Initialize counter*/

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateLoadsDiagnosticVert.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSet*/

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateNodesDiagnosticVert.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesDiagnosticVert(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesDiagnosticVert(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    3232
    3333        /*Continuous Galerkin partition of nodes: */
    34         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     34        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3535       
    3636        /*First fetch data: */
    37         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    38         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    39         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    40         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    41         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    42         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     37        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     38        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     39        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     40        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     41        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     42        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4343
    4444        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/UpdateElementsDiagnosticVert.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsDiagnosticVert(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsDiagnosticVert(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2323
    2424        /*Update elements: */
    … …  
    3232        }
    3333
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     34        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     35        IoModelToInputsx(elements,iomodel,ThicknessCoeffEnum);
     36        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     37        IoModelToInputsx(elements,iomodel,BedEnum);
     38        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     39        IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     40        IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     41        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     42        IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     43        IoModelToInputsx(elements,iomodel,SurfaceAccumulationRateEnum);
     44        IoModelToInputsx(elements,iomodel,SurfaceAblationRateEnum);
     45        IoModelToInputsx(elements,iomodel,SurfaceMassBalanceEnum);
     46        IoModelToInputsx(elements,iomodel,VxEnum);
     47        IoModelToInputsx(elements,iomodel,VyEnum);
    4848
    4949        /*Free data: */

  • issm/trunk/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp

    r9320 r9340  
    1818#include "../ModelProcessorx/ModelProcessorx.h"
    1919
    20 void  ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel, FILE* iomodel_handle){
     20void  ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel){
    2121
    2222        int i;
    … …  
    4646        if(iomodel->dim==2){
    4747                /*load elements: */
    48                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     48                iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    4949        }
    5050        else{
    5151                /*load elements2d: */
    52                 IoModelFetchData(&iomodel->elements2d,NULL,NULL,iomodel_handle,Elements2DEnum);
     52                iomodel->FetchData(&iomodel->elements2d,NULL,NULL,Elements2DEnum);
    5353        }
    5454
    … …  
    6565
    6666        /*Deal with rifts, they have to be included into one partition only, not several: */
    67         IoModelFetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,iomodel_handle,RiftinfoEnum);
     67        iomodel->FetchData(&iomodel->riftinfo,&iomodel->numrifts,NULL,RiftinfoEnum);
    6868
    6969        for(i=0;i<iomodel->numrifts;i++){
    … …  
    8181
    8282        /*Start figuring out, out of the partition, which elements belong to this cpu: */
    83         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     83        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    8484        for (i=0;i<iomodel->numberofelements;i++){
    8585
    … …  
    110110         * penpair has 2 nodes that are poointing toward 2 vertices.
    111111         * The 2 vertices must be in the same cpu as the penpair*/
    112         IoModelFetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,iomodel_handle,PenaltiesEnum);
     112        iomodel->FetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,PenaltiesEnum);
    113113        for(i=0;i<iomodel->numpenalties;i++){
    114114                if(my_vertices[(int)iomodel->penalties[2*i+0]-1] && !my_vertices[(int)iomodel->penalties[2*i+1]-1]){

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/CreateConstraintsEnthalpy.cpp

    r9285 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsEnthalpy(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsEnthalpy(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3131
    3232        /*Fetch data: */
    33         IoModelFetchData(&iomodel->spctemperature,NULL,NULL,iomodel_handle,SpctemperatureEnum);
     33        iomodel->FetchData(&iomodel->spctemperature,NULL,NULL,SpctemperatureEnum);
    3434
    3535        /*Initialize counter*/

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/CreateLoadsEnthalpy.cpp

    r8483 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSet*/

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/CreateNodesEnthalpy.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesEnthalpy(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesEnthalpy(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232
    3333        /*Create nodes and vertices: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Enthalpy/UpdateElementsEnthalpy.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsEnthalpy(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsEnthalpy(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2323
    2424        /*Update elements: */
    … …  
    3232        }
    3333
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
    48         IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
    49         IoModelToInputsx(elements,iomodel,iomodel_handle,WaterfractionEnum);
    50         IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
    51         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    52         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
    53         IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     34        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     35        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     36        IoModelToInputsx(elements,iomodel,BedEnum);
     37        IoModelToInputsx(elements,iomodel,DragCoefficientEnum);
     38        IoModelToInputsx(elements,iomodel,DragPEnum);
     39        IoModelToInputsx(elements,iomodel,DragQEnum);
     40        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     41        IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     42        IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     43        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     44        IoModelToInputsx(elements,iomodel,ElementsTypeEnum);
     45        IoModelToInputsx(elements,iomodel,RheologyBEnum);
     46        IoModelToInputsx(elements,iomodel,RheologyNEnum);
     47        IoModelToInputsx(elements,iomodel,PressureEnum);
     48        IoModelToInputsx(elements,iomodel,TemperatureEnum);
     49        IoModelToInputsx(elements,iomodel,WaterfractionEnum);
     50        IoModelToInputsx(elements,iomodel,GeothermalfluxEnum);
     51        IoModelToInputsx(elements,iomodel,VxEnum);
     52        IoModelToInputsx(elements,iomodel,VyEnum);
     53        IoModelToInputsx(elements,iomodel,VzEnum);
    5454       
    5555        /*Free data: */

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/CreateConstraintsHydrology.cpp

    r9271 r9340  
    1212#include "../ModelProcessorx.h"
    1313
    14 void    CreateConstraintsHydrology(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     14void    CreateConstraintsHydrology(Constraints** pconstraints, IoModel* iomodel){
    1515
    1616        /*Output*/
    … …  
    2222        /*Create constraints if they do not exist yet*/
    2323        if(!constraints) constraints = new Constraints(ConstraintsEnum);
    24         IoModelToConstraintsx(constraints,iomodel,iomodel_handle,SpcwatercolumnEnum,HydrologyAnalysisEnum);
     24        IoModelToConstraintsx(constraints,iomodel,SpcwatercolumnEnum,HydrologyAnalysisEnum);
    2525       
    2626        /*Assign output pointer: */

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/CreateLoadsHydrology.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsHydrology(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsHydrology(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*Intermediary*/

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/CreateNodesHydrology.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesHydrology(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesHydrology(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232
    3333        /*Create nodes and vertices: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Hydrology/UpdateElementsHydrology.cpp

    r9291 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsHydrology(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsHydrology(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Fetch data needed: */
    19         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     19        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2020
    2121        /*Update elements: */
    … …  
    2929        }
    3030
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    33         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,WatercolumnEnum);
    48         IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
    49         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    50         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
    51         IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     31        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     32        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     33        IoModelToInputsx(elements,iomodel,BedEnum);
     34        IoModelToInputsx(elements,iomodel,DragCoefficientEnum);
     35        IoModelToInputsx(elements,iomodel,DragPEnum);
     36        IoModelToInputsx(elements,iomodel,DragQEnum);
     37        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     38        IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     39        IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     40        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     41        IoModelToInputsx(elements,iomodel,ElementsTypeEnum);
     42        IoModelToInputsx(elements,iomodel,RheologyBEnum);
     43        IoModelToInputsx(elements,iomodel,RheologyNEnum);
     44        IoModelToInputsx(elements,iomodel,PressureEnum);
     45        IoModelToInputsx(elements,iomodel,TemperatureEnum);
     46        IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     47        IoModelToInputsx(elements,iomodel,WatercolumnEnum);
     48        IoModelToInputsx(elements,iomodel,GeothermalfluxEnum);
     49        IoModelToInputsx(elements,iomodel,VxEnum);
     50        IoModelToInputsx(elements,iomodel,VyEnum);
     51        IoModelToInputsx(elements,iomodel,VzEnum);
    5252
    5353        elements->InputDuplicate(WatercolumnEnum,WaterColumnOldEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateConstraintsMelting.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsMelting(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsMelting(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Intermediary*/

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateLoadsMelting.cpp

    r8926 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsMelting(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsMelting(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    2929
    3030        //create penalties for nodes: no node can have a temperature over the melting point
    31         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    32         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     31        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     32        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    3333        CreateSingleNodeToElementConnectivity(iomodel);
    3434

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateNodesMelting.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesMelting(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesMelting(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232
    3333        /*First fetch data: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/UpdateElementsMelting.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsMelting(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsMelting(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2323
    2424        /*Update elements: */
    … …  
    3333
    3434        /*Create inputs: */
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
    48         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
    49         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
    50         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    51         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    52         IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     35        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     36        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     37        IoModelToInputsx(elements,iomodel,BedEnum);
     38        IoModelToInputsx(elements,iomodel,DragCoefficientEnum);
     39        IoModelToInputsx(elements,iomodel,DragPEnum);
     40        IoModelToInputsx(elements,iomodel,DragQEnum);
     41        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     42        IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     43        IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     44        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     45        IoModelToInputsx(elements,iomodel,ElementsTypeEnum);
     46        IoModelToInputsx(elements,iomodel,RheologyBEnum);
     47        IoModelToInputsx(elements,iomodel,RheologyNEnum);
     48        IoModelToInputsx(elements,iomodel,SurfaceAccumulationRateEnum);
     49        IoModelToInputsx(elements,iomodel,SurfaceAblationRateEnum);
     50        IoModelToInputsx(elements,iomodel,SurfaceMassBalanceEnum);
     51        IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     52        IoModelToInputsx(elements,iomodel,PressureEnum);
    5353       
    5454        /*Free data: */

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

    r9320 r9340  
    4343       
    4444                _printf_(VerboseMProcessor(),"   create datasets for analysis %s\n",EnumToStringx(analysis_type));
    45                 CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,&parameters,iomodel,IOMODEL,solution_type,analysis_type,nummodels,i);
     45                CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,&parameters,iomodel,solution_type,analysis_type,nummodels,i);
    4646        }
    4747

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

    r9218 r9340  
    1616
    1717/*Creation of fem datasets: general drivers*/
    18 void  CreateDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
    19 void  CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,FILE* iomodel_handle,const int nummodels);
    20 void  CreateParameters(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,const int solution_type,int analysis_type,int analysis_counter);
    21 void  CreateParametersControl(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,int solution_type,int analysis_type);
    22 void  CreateParametersQmu(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,int solution_type,int analysis_type);
    23 void  UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel,FILE* iomodel_handle);
     18void  CreateDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
     19void  CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels);
     20void  CreateParameters(Parameters** pparameters,IoModel* iomodel,const int solution_type,int analysis_type,int analysis_counter);
     21void  CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     22void  CreateParametersQmu(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     23void  UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel);
    2424
    2525/*Creation of fem datasets: specialised drivers: */
    2626
    2727/*diagnostic horizontal*/
    28 void    CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    29 void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    30 void  CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    31 void    UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     28void    CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel);
     29void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel);
     30void  CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel);
     31void    UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    3232
    3333/*diagnostic vertical*/
    34 void    CreateNodesDiagnosticVert(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    35 void    CreateConstraintsDiagnosticVert(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    36 void  CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    37 void    UpdateElementsDiagnosticVert(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     34void    CreateNodesDiagnosticVert(Nodes** pnodes,IoModel* iomodel);
     35void    CreateConstraintsDiagnosticVert(Constraints** pconstraints,IoModel* iomodel);
     36void  CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel);
     37void    UpdateElementsDiagnosticVert(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    3838
    3939/*diagnostic hutter*/
    40 void    CreateNodesDiagnosticHutter(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    41 void    CreateConstraintsDiagnosticHutter(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    42 void  CreateLoadsDiagnosticHutter(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    43 void    UpdateElementsDiagnosticHutter(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     40void    CreateNodesDiagnosticHutter(Nodes** pnodes,IoModel* iomodel);
     41void    CreateConstraintsDiagnosticHutter(Constraints** pconstraints,IoModel* iomodel);
     42void  CreateLoadsDiagnosticHutter(Loads** ploads, IoModel* iomodel);
     43void    UpdateElementsDiagnosticHutter(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    4444
    4545/*bed slope*/
    46 void    CreateNodesBedSlope(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    47 void    CreateConstraintsBedSlope(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    48 void  CreateLoadsBedSlope(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    49 void    UpdateElementsBedSlope(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     46void    CreateNodesBedSlope(Nodes** pnodes,IoModel* iomodel);
     47void    CreateConstraintsBedSlope(Constraints** pconstraints,IoModel* iomodel);
     48void  CreateLoadsBedSlope(Loads** ploads, IoModel* iomodel);
     49void    UpdateElementsBedSlope(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    5050
    5151/*surface slope*/
    52 void    CreateNodesSurfaceSlope(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    53 void    CreateConstraintsSurfaceSlope(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    54 void  CreateLoadsSurfaceSlope(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    55 void    UpdateElementsSurfaceSlope(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     52void    CreateNodesSurfaceSlope(Nodes** pnodes,IoModel* iomodel);
     53void    CreateConstraintsSurfaceSlope(Constraints** pconstraints,IoModel* iomodel);
     54void  CreateLoadsSurfaceSlope(Loads** ploads, IoModel* iomodel);
     55void    UpdateElementsSurfaceSlope(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    5656
    5757/*thermal:*/
    58 void    CreateNodesThermal(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    59 void    CreateConstraintsThermal(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    60 void  CreateLoadsThermal(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    61 void    UpdateElementsThermal(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     58void    CreateNodesThermal(Nodes** pnodes,IoModel* iomodel);
     59void    CreateConstraintsThermal(Constraints** pconstraints,IoModel* iomodel);
     60void  CreateLoadsThermal(Loads** ploads, IoModel* iomodel);
     61void    UpdateElementsThermal(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    6262
    6363/*enthalpy:*/
    64 void    CreateNodesEnthalpy(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    65 void    CreateConstraintsEnthalpy(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    66 void  CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    67 void    UpdateElementsEnthalpy(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     64void    CreateNodesEnthalpy(Nodes** pnodes,IoModel* iomodel);
     65void    CreateConstraintsEnthalpy(Constraints** pconstraints,IoModel* iomodel);
     66void  CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel);
     67void    UpdateElementsEnthalpy(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    6868
    6969/*hydrology:*/
    70 void    CreateNodesHydrology(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    71 void    CreateConstraintsHydrology(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    72 void  CreateLoadsHydrology(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    73 void    UpdateElementsHydrology(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     70void    CreateNodesHydrology(Nodes** pnodes,IoModel* iomodel);
     71void    CreateConstraintsHydrology(Constraints** pconstraints,IoModel* iomodel);
     72void  CreateLoadsHydrology(Loads** ploads, IoModel* iomodel);
     73void    UpdateElementsHydrology(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    7474
    7575/*melting:*/
    76 void    CreateNodesMelting(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    77 void    CreateConstraintsMelting(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    78 void  CreateLoadsMelting(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    79 void    UpdateElementsMelting(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     76void    CreateNodesMelting(Nodes** pnodes,IoModel* iomodel);
     77void    CreateConstraintsMelting(Constraints** pconstraints,IoModel* iomodel);
     78void  CreateLoadsMelting(Loads** ploads, IoModel* iomodel);
     79void    UpdateElementsMelting(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    8080
    8181/*prognostic:*/
    82 void    CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    83 void    CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    84 void  CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    85 void    UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     82void    CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel);
     83void    CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel);
     84void  CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel);
     85void    UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    8686
    8787/*balancedthickness:*/
    88 void    CreateNodesBalancethickness(Nodes** pnodes,IoModel* iomodel,FILE* iomodel_handle);
    89 void    CreateConstraintsBalancethickness(Constraints** pconstraints,IoModel* iomodel,FILE* iomodel_handle);
    90 void  CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel, FILE* iomodel_handle);
    91 void    UpdateElementsBalancethickness(Elements* elements,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     88void    CreateNodesBalancethickness(Nodes** pnodes,IoModel* iomodel);
     89void    CreateConstraintsBalancethickness(Constraints** pconstraints,IoModel* iomodel);
     90void  CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel);
     91void    UpdateElementsBalancethickness(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    9292
    9393/*transient: */
    94 void    UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type);
     94void    UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel,int analysis_counter,int analysis_type);
    9595
    9696/*partitioning: */
    97 void  ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel, FILE* iomodel_handle);
    98 void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices,  IoModel* iomodel, FILE* iomodel_handle,bool continuous);
     97void  ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel);
     98void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices,  IoModel* iomodel, bool continuous);
    9999
    100100/*Connectivity*/

  • issm/trunk/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

    r9320 r9340  
    1818#include "../ModelProcessorx/ModelProcessorx.h"
    1919
    20 void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, FILE* iomodel_handle);
    21 void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, FILE* iomodel_handle);
     20void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel);
     21void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel);
    2222
    23 void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, FILE* iomodel_handle,bool continuous){
     23void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, bool continuous){
    2424       
    2525        /*First thing, this is a new partition for a new analysis_type, therefore, to avoid a leak, erase the nodes partition that might come through pmy_nodes: */
    … …  
    2828        /*Now, depending on whether we are running galerkin discontinous or continuous elements, carry out a different partition of the nodes: */
    2929        if(continuous==true)
    30                 ContinuousGalerkinNodesPartitioning(pmy_nodes,my_elements, my_vertices, iomodel, iomodel_handle);
     30                ContinuousGalerkinNodesPartitioning(pmy_nodes,my_elements, my_vertices, iomodel);
    3131        else
    32                 DiscontinuousGalerkinNodesPartitioning(pmy_nodes,my_elements, my_vertices, iomodel, iomodel_handle);
     32                DiscontinuousGalerkinNodesPartitioning(pmy_nodes,my_elements, my_vertices, iomodel);
    3333}
    3434
    35 void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, FILE* iomodel_handle){
     35void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
    3636
    3737        /*as many nodes as there are vertices */
    … …  
    4848
    4949
    50 void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, FILE* iomodel_handle){
     50void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
    5151
    5252        /*each element has it own nodes (as many as vertices) + additional nodes from neighbouring elements for each edge. This yields to a very different partition for
    … …  
    9393
    9494        /*Get edges and elements*/
    95         IoModelFetchData(&iomodel->edges,&iomodel->numberofedges,&cols,iomodel_handle,EdgesEnum);
    96         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     95        iomodel->FetchData(&iomodel->edges,&iomodel->numberofedges,&cols,EdgesEnum);
     96        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    9797        if (cols!=4) _error_("field edges should have 4 columns");
    9898

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateConstraintsPrognostic.cpp

    r9081 r9340  
    88#include "../ModelProcessorx.h"
    99
    10 void    CreateConstraintsPrognostic(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     10void    CreateConstraintsPrognostic(Constraints** pconstraints, IoModel* iomodel){
    1111
    1212        /*Output*/
    … …  
    2121        /*Do not add constraints in DG, they are weakly imposed*/
    2222        if(!iomodel->prognostic_DG){
    23                 IoModelToConstraintsx(constraints,iomodel,iomodel_handle,SpcthicknessEnum,PrognosticAnalysisEnum);
     23                IoModelToConstraintsx(constraints,iomodel,SpcthicknessEnum,PrognosticAnalysisEnum);
    2424        }
    2525

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp

    r8926 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*Intermediaries*/
    … …  
    3232
    3333                /*Get edges and elements*/
    34                 IoModelFetchData(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel_handle,EdgesEnum);
    35                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    36                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
     34                iomodel->FetchData(&iomodel->edges,&iomodel->numberofedges,NULL,EdgesEnum);
     35                iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     36                iomodel->FetchData(&iomodel->thickness,NULL,NULL,ThicknessEnum);
    3737
    3838                /*First load data:*/
    … …  
    5757
    5858        /*Create Penpair for penalties: */
    59         IoModelFetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,iomodel_handle,PenaltiesEnum);
    60         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
     59        iomodel->FetchData(&iomodel->penalties,&iomodel->numpenalties,NULL,PenaltiesEnum);
     60        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
    6161
    6262        for(i=0;i<iomodel->numpenalties;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesPrognostic(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesPrognostic(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    3333        /*Create partition of nodes: */
    3434        if(iomodel->prognostic_DG) continuous_galerkin=false;
    35         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     35        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3636
    3737        /*Check in 3d*/
    … …  
    3939
    4040        /*First fetch data: */
    41         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    42         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    43         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    44         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    45         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    46         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    47         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     41        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
     42        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     43        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     44        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     45        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     46        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     47        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4848
    4949        if(continuous_galerkin){

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/UpdateElementsPrognostic.cpp

    r9232 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsPrognostic(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsPrognostic(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Fetch data needed: */
    19         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     19        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2020
    2121        /*Update elements: */
    … …  
    2929        }
    3030
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    33         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateCorrectionEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     31        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     32        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     33        IoModelToInputsx(elements,iomodel,BedEnum);
     34        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     35        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     36        IoModelToInputsx(elements,iomodel,SurfaceAccumulationRateEnum);
     37        IoModelToInputsx(elements,iomodel,SurfaceAblationRateEnum);
     38        IoModelToInputsx(elements,iomodel,SurfaceMassBalanceEnum);
     39        IoModelToInputsx(elements,iomodel,BasalMeltingRateEnum);
     40        IoModelToInputsx(elements,iomodel,BasalMeltingRateCorrectionEnum);
     41        IoModelToInputsx(elements,iomodel,VxEnum);
     42        IoModelToInputsx(elements,iomodel,VyEnum);
    4343
    4444        if(iomodel->prognostic_DG){
    45                 IoModelToInputsx(elements,iomodel,iomodel_handle,SpcthicknessEnum); //for DG, we need the spc in the element
     45                IoModelToInputsx(elements,iomodel,SpcthicknessEnum); //for DG, we need the spc in the element
    4646        }
    4747       
    4848        if (iomodel->dim==3){
    49                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    50                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    51                 IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
    52                 IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
     49                IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     50                IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     51                IoModelToInputsx(elements,iomodel,PressureEnum);
     52                IoModelToInputsx(elements,iomodel,TemperatureEnum);
    5353        }
    5454       

  • issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r8967 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void CreateParametersQmu(Parameters** pparameters,IoModel* iomodel,FILE* iomodel_handle,int solution_type,int analysis_type){
     15void CreateParametersQmu(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type){
    1616
    1717        /*variable declarations: {{{1*/
    … …  
    7575                /*}}}*/
    7676                /*Fetch variable descriptors: {{{1*/
    77                 IoModelFetchData(&variabledescriptors,&numvariabledescriptors,iomodel_handle,VariabledescriptorsEnum);
     77                iomodel->FetchData(&variabledescriptors,&numvariabledescriptors,VariabledescriptorsEnum);
    7878
    7979                /*Ok, we have all the variable descriptors. Build a parameter with it: */
    … …  
    8282                /*}}}*/
    8383                /*Fetch response descriptors: {{{1*/
    84                 IoModelFetchData(&responsedescriptors,&numresponsedescriptors,iomodel_handle,ResponsedescriptorsEnum);
     84                iomodel->FetchData(&responsedescriptors,&numresponsedescriptors,ResponsedescriptorsEnum);
    8585
    8686                /*Ok, we have all the response descriptors. Build a parameter with it: */
    … …  
    9292                parameters->AddObject(new    IntParam(QmuNPartEnum,iomodel->qmu_npart));
    9393               
    94                 IoModelFetchData(&dpart,NULL,NULL,iomodel_handle,PartEnum);
     94                iomodel->FetchData(&dpart,NULL,NULL,PartEnum);
    9595
    9696                if(!dpart){
    9797
    9898                        /*Partition elements and vertices and nodes: */
    99                         ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel,iomodel_handle);
     99                        ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
    100100
    101101                        dpart=(double*)xmalloc(iomodel->numberofvertices*sizeof(double));
    … …  
    113113                               
    114114                                /*Recover data: */
    115                                 IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,StringToEnumx(tag));
     115                                iomodel->FetchData(&dakota_parameter,NULL,NULL,StringToEnumx(tag));
    116116
    117117                                /*Convert units: */
    … …  
    138138                       
    139139                        /*Fetch the mass flux segments necessary to compute the mass fluxes.  Build a DoubleMatArrayParam object out of them: */
    140                         IoModelFetchData(&array,&mdims_array,&ndims_array,&qmu_mass_flux_num_profiles,iomodel_handle,QmuMassFluxSegmentsEnum);
     140                        iomodel->FetchData(&array,&mdims_array,&ndims_array,&qmu_mass_flux_num_profiles,QmuMassFluxSegmentsEnum);
    141141                        if(qmu_mass_flux_num_profiles==0)_error_(" qmu_mass_flux_num_profiles is 0, when MassFlux computations were requested!");
    142142

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/CreateConstraintsSurfaceSlope.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateConstraintsSurfaceSlope(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateConstraintsSurfaceSlope(Constraints** pconstraints, IoModel* iomodel){
    1414
    1515        /*Output*/

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/CreateLoadsSurfaceSlope.cpp

    r8330 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsSurfaceSlope(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsSurfaceSlope(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*DataSet*/

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/CreateNodesSurfaceSlope.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesSurfaceSlope(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesSurfaceSlope(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929       
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232       
    3333        /*First fetch data: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/SurfaceSlope/UpdateElementsSurfaceSlope.cpp

    r8985 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsSurfaceSlope(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsSurfaceSlope(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Fetch data needed: */
    19         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     19        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2020
    2121        /*Update elements: */
    … …  
    2929        }
    3030
    31         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    32         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    33         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     31        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     32        IoModelToInputsx(elements,iomodel,BedEnum);
     33        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
    3434       
    3535        if (iomodel->dim==3){
    36                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    37                 IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     36                IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     37                IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
    3838        }
    3939       

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateConstraintsThermal.cpp

    r9081 r9340  
    1212#include "../ModelProcessorx.h"
    1313
    14 void    CreateConstraintsThermal(Constraints** pconstraints, IoModel* iomodel,FILE* iomodel_handle){
     14void    CreateConstraintsThermal(Constraints** pconstraints, IoModel* iomodel){
    1515
    1616        /*Intermediary*/
    … …  
    2929        /*Only 3d mesh supported*/
    3030        if (iomodel->dim==3){
    31                 IoModelToConstraintsx(constraints,iomodel,iomodel_handle,SpctemperatureEnum,ThermalAnalysisEnum);
     31                IoModelToConstraintsx(constraints,iomodel,SpctemperatureEnum,ThermalAnalysisEnum);
    3232        }
    3333

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateLoadsThermal.cpp

    r9002 r9340  
    1111#include "../ModelProcessorx.h"
    1212
    13 void    CreateLoadsThermal(Loads** ploads, IoModel* iomodel,FILE* iomodel_handle){
     13void    CreateLoadsThermal(Loads** ploads, IoModel* iomodel){
    1414
    1515        /*Intermediary*/
    … …  
    3030
    3131        //create penalties for nodes: no node can have a temperature over the melting point
    32         IoModelFetchData(&iomodel->spctemperature,NULL,NULL,iomodel_handle,SpctemperatureEnum);
    33         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     32        iomodel->FetchData(&iomodel->spctemperature,NULL,NULL,SpctemperatureEnum);
     33        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    3434        CreateSingleNodeToElementConnectivity(iomodel);
    3535

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateNodesThermal.cpp

    r8926 r9340  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateNodesThermal(Nodes** pnodes, IoModel* iomodel,FILE* iomodel_handle){
     15void    CreateNodesThermal(Nodes** pnodes, IoModel* iomodel){
    1616
    1717        /*Intermediary*/
    … …  
    2929
    3030        /*Continuous Galerkin partition of nodes: */
    31         NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,iomodel_handle,continuous_galerkin);
     31        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements,iomodel->my_vertices,iomodel,continuous_galerkin);
    3232
    3333        /*Create nodes and vertices: */
    34         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    35         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->nodeonicesheet,NULL,NULL,iomodel_handle,NodeOnIceSheetEnum);
    37         IoModelFetchData(&iomodel->nodeoniceshelf,NULL,NULL,iomodel_handle,NodeOnIceShelfEnum);
    38         IoModelFetchData(&iomodel->vertices_type,NULL,NULL,iomodel_handle,VerticesTypeEnum);
    39         IoModelFetchData(&iomodel->nodeonwater,NULL,NULL,iomodel_handle,NodeOnWaterEnum);
     34        iomodel->FetchData(&iomodel->nodeonbed,NULL,NULL,NodeOnBedEnum);
     35        iomodel->FetchData(&iomodel->nodeonsurface,NULL,NULL,NodeOnSurfaceEnum);
     36        iomodel->FetchData(&iomodel->nodeonicesheet,NULL,NULL,NodeOnIceSheetEnum);
     37        iomodel->FetchData(&iomodel->nodeoniceshelf,NULL,NULL,NodeOnIceShelfEnum);
     38        iomodel->FetchData(&iomodel->vertices_type,NULL,NULL,VerticesTypeEnum);
     39        iomodel->FetchData(&iomodel->nodeonwater,NULL,NULL,NodeOnWaterEnum);
    4040
    4141        for (i=0;i<iomodel->numberofvertices;i++){

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/UpdateElementsThermal.cpp

    r9126 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsThermal(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsThermal(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    2020
    2121        /*Fetch data needed: */
    22         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     22        iomodel->FetchData(&iomodel->elements,NULL,NULL,ElementsEnum);
    2323
    2424        /*Update elements: */
    … …  
    3232        }
    3333
    34         IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
    35         IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
    36         IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
    37         IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
    38         IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
    39         IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
    40         IoModelToInputsx(elements,iomodel,iomodel_handle,DragTypeEnum);
    41         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
    42         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
    43         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    44         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
    45         IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
    46         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
    47         IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
    48         IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
    49         IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
    50         IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
    51         IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
    52         IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
    53         IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     34        IoModelToInputsx(elements,iomodel,ThicknessEnum);
     35        IoModelToInputsx(elements,iomodel,SurfaceEnum);
     36        IoModelToInputsx(elements,iomodel,BedEnum);
     37        IoModelToInputsx(elements,iomodel,DragCoefficientEnum);
     38        IoModelToInputsx(elements,iomodel,DragPEnum);
     39        IoModelToInputsx(elements,iomodel,DragQEnum);
     40        IoModelToInputsx(elements,iomodel,DragTypeEnum);
     41        IoModelToInputsx(elements,iomodel,ElementOnIceShelfEnum);
     42        IoModelToInputsx(elements,iomodel,ElementOnBedEnum);
     43        IoModelToInputsx(elements,iomodel,ElementOnSurfaceEnum);
     44        IoModelToInputsx(elements,iomodel,ElementOnWaterEnum);
     45        IoModelToInputsx(elements,iomodel,ElementsTypeEnum);
     46        IoModelToInputsx(elements,iomodel,RheologyBEnum);
     47        IoModelToInputsx(elements,iomodel,RheologyNEnum);
     48        IoModelToInputsx(elements,iomodel,PressureEnum);
     49        IoModelToInputsx(elements,iomodel,TemperatureEnum);
     50        IoModelToInputsx(elements,iomodel,GeothermalfluxEnum);
     51        IoModelToInputsx(elements,iomodel,VxEnum);
     52        IoModelToInputsx(elements,iomodel,VyEnum);
     53        IoModelToInputsx(elements,iomodel,VzEnum);
    5454       
    5555        if(iomodel->qmu_analysis)elements->InputDuplicate(TemperatureEnum,QmuTemperatureEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Transient/UpdateElementsTransient.cpp

    r8967 r9340  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsTransient(Elements* elements, Parameters* parameters,IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
     16void    UpdateElementsTransient(Elements* elements, Parameters* parameters,IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        /*nothing for now: */

  • issm/trunk/src/c/objects/IoModel.cpp

    r9320 r9340  
    124124}
    125125/*}}}*/
    126 /*FUNCTION IoModel::IoModel(ConstDataHandle iomodel_handle){{{1*/
     126/*FUNCTION IoModel::IoModel(FILE* iomodel_handle){{{1*/
    127127IoModel::IoModel(FILE* iomodel_handle){
     128
     129        /*First, keep track of the fil handle: */
     130        this->fid=iomodel_handle;
    128131       
    129132        int i,j;
    … …  
    134137        /*Get all the data that consists of scalars, integers and strings: */
    135138
    136         IoModelFetchData(&this->name,iomodel_handle,NameEnum);
    137         IoModelFetchData(&this->inputfilename,iomodel_handle,InputfilenameEnum);
    138         IoModelFetchData(&this->outputfilename,iomodel_handle,OutputfilenameEnum);
    139         IoModelFetchData(&this->qmu_analysis,iomodel_handle,QmuAnalysisEnum);
    140         IoModelFetchData(&this->control_analysis,iomodel_handle,ControlAnalysisEnum);
    141         IoModelFetchData(&this->dim,iomodel_handle,DimEnum);
     139        this->FetchData(&this->name,NameEnum);
     140        this->FetchData(&this->inputfilename,InputfilenameEnum);
     141        this->FetchData(&this->outputfilename,OutputfilenameEnum);
     142        this->FetchData(&this->qmu_analysis,QmuAnalysisEnum);
     143        this->FetchData(&this->control_analysis,ControlAnalysisEnum);
     144        this->FetchData(&this->dim,DimEnum);
    142145        /*!Get numberofelements and numberofvertices: */
    143         IoModelFetchData(&this->numberofvertices,iomodel_handle,NumberOfNodesEnum);
    144         IoModelFetchData(&this->numberofelements,iomodel_handle,NumberOfElementsEnum);
     146        this->FetchData(&this->numberofvertices,NumberOfNodesEnum);
     147        this->FetchData(&this->numberofelements,NumberOfElementsEnum);
    145148        /*!In case we are running 3d, we are going to need the collapsed and non-collapsed 2d meshes, from which the 3d mesh was extruded: */
    146149        if (this->dim==3){
    147150       
    148151                /*!Deal with 2d mesh: */
    149                 IoModelFetchData(&this->numberofelements2d,iomodel_handle,NumberOfElements2DEnum);
    150                 IoModelFetchData(&this->numberofvertices2d,iomodel_handle,NumberOfNodes2DEnum);
    151                 IoModelFetchData(&this->numlayers,iomodel_handle,NumlayersEnum);
     152                this->FetchData(&this->numberofelements2d,NumberOfElements2DEnum);
     153                this->FetchData(&this->numberofvertices2d,NumberOfNodes2DEnum);
     154                this->FetchData(&this->numlayers,NumlayersEnum);
    152155        }
    153156
    154157
    155158        /*elements type: */
    156         IoModelFetchData(&this->ishutter,iomodel_handle,IshutterEnum);
    157         IoModelFetchData(&this->ismacayealpattyn,iomodel_handle,IsmacayealpattynEnum);
    158         IoModelFetchData(&this->isstokes,iomodel_handle,IsstokesEnum);
     159        this->FetchData(&this->ishutter,IshutterEnum);
     160        this->FetchData(&this->ismacayealpattyn,IsmacayealpattynEnum);
     161        this->FetchData(&this->isstokes,IsstokesEnum);
    159162
    160163        /*!Get drag_type, drag and p,q: */
    161         IoModelFetchData(&this->drag_type,iomodel_handle,DragTypeEnum);
     164        this->FetchData(&this->drag_type,DragTypeEnum);
    162165
    163166        /*!Get materials: */
    164         IoModelFetchData(&this->rho_water,iomodel_handle,RhoWaterEnum);
    165         IoModelFetchData(&this->rho_ice,iomodel_handle,RhoIceEnum);
    166         IoModelFetchData(&this->g,iomodel_handle,GEnum);
     167        this->FetchData(&this->rho_water,RhoWaterEnum);
     168        this->FetchData(&this->rho_ice,RhoIceEnum);
     169        this->FetchData(&this->g,GEnum);
    167170
    168171        /*Get control parameters: */
    169         IoModelFetchData(&this->num_control_type,iomodel_handle,NumControlTypeEnum);
    170         IoModelFetchData(&this->num_cm_responses,iomodel_handle,NumCmResponsesEnum);
     172        this->FetchData(&this->num_control_type,NumControlTypeEnum);
     173        this->FetchData(&this->num_cm_responses,NumCmResponsesEnum);
    171174
    172175        /*!Get solution parameters: */
    173         IoModelFetchData(&this->yts,iomodel_handle,YtsEnum);
    174         IoModelFetchData(&this->meanvel,iomodel_handle,MeanvelEnum);
    175         IoModelFetchData(&this->epsvel,iomodel_handle,EpsvelEnum);
    176         IoModelFetchData(&this->verbose,iomodel_handle,VerboseBinaryEnum);
    177         IoModelFetchData(&this->output_frequency,iomodel_handle,OutputFrequencyEnum);
    178         IoModelFetchData(&this->prognostic_DG,iomodel_handle,PrognosticDGEnum);
    179         IoModelFetchData(&this->nsteps,iomodel_handle,NstepsEnum);
    180         IoModelFetchData(&this->eps_cm,iomodel_handle,EpsCmEnum);
    181         IoModelFetchData(&this->tolx,iomodel_handle,TolxEnum);
    182         IoModelFetchData(&this->cm_gradient,iomodel_handle,CmGradientEnum);
    183         IoModelFetchData(&this->eps_res,iomodel_handle,EpsResEnum);
    184         IoModelFetchData(&this->eps_rel,iomodel_handle,EpsRelEnum);
    185         IoModelFetchData(&this->eps_abs,iomodel_handle,EpsAbsEnum);
    186         IoModelFetchData(&this->max_nonlinear_iterations,iomodel_handle,MaxNonlinearIterationsEnum);
    187         IoModelFetchData(&this->max_steadystate_iterations,iomodel_handle,MaxSteadystateIterationsEnum);
    188         IoModelFetchData(&this->dt,iomodel_handle,DtEnum);
    189         IoModelFetchData(&this->ndt,iomodel_handle,NdtEnum);
    190         IoModelFetchData(&this->time_adapt,iomodel_handle,TimeAdaptEnum);
    191         IoModelFetchData(&this->cfl_coefficient,iomodel_handle,CflCoefficientEnum);
    192         IoModelFetchData(&this->hydrostatic_adjustment,iomodel_handle,HydrostaticAdjustmentEnum);
    193         IoModelFetchData(&this->penalty_offset,iomodel_handle,PenaltyOffsetEnum);
    194         IoModelFetchData(&this->penalty_melting,iomodel_handle,PenaltyMeltingEnum);
    195         IoModelFetchData(&this->penalty_lock,iomodel_handle,PenaltyLockEnum);
    196         IoModelFetchData(&this->sparsity,iomodel_handle,SparsityEnum);
    197         IoModelFetchData(&this->connectivity,iomodel_handle,ConnectivityEnum);
    198         IoModelFetchData(&this->lowmem,iomodel_handle,LowmemEnum);
    199         IoModelFetchData(&this->viscosity_overshoot,iomodel_handle,ViscosityOvershootEnum);
    200         IoModelFetchData(&this->artdiff,iomodel_handle,ArtificialDiffusivityEnum);
    201         IoModelFetchData(&this->prognostic_DG,iomodel_handle,PrognosticDGEnum);
    202         IoModelFetchData(&this->stokesreconditioning,iomodel_handle,StokesreconditioningEnum);
    203         IoModelFetchData(&this->shelf_dampening,iomodel_handle,ShelfDampeningEnum);
    204         IoModelFetchData(&this->waitonlock,iomodel_handle,WaitonlockEnum);
    205         IoModelFetchData(&this->gl_migration,iomodel_handle,GlMigrationEnum);
    206         IoModelFetchData(&this->isdiagnostic,iomodel_handle,IsdiagnosticEnum);
    207         IoModelFetchData(&this->isprognostic,iomodel_handle,IsprognosticEnum);
    208         IoModelFetchData(&this->isthermal,iomodel_handle,IsthermalEnum);
     176        this->FetchData(&this->yts,YtsEnum);
     177        this->FetchData(&this->meanvel,MeanvelEnum);
     178        this->FetchData(&this->epsvel,EpsvelEnum);
     179        this->FetchData(&this->verbose,VerboseBinaryEnum);
     180        this->FetchData(&this->output_frequency,OutputFrequencyEnum);
     181        this->FetchData(&this->prognostic_DG,PrognosticDGEnum);
     182        this->FetchData(&this->nsteps,NstepsEnum);
     183        this->FetchData(&this->eps_cm,EpsCmEnum);
     184        this->FetchData(&this->tolx,TolxEnum);
     185        this->FetchData(&this->cm_gradient,CmGradientEnum);
     186        this->FetchData(&this->eps_res,EpsResEnum);
     187        this->FetchData(&this->eps_rel,EpsRelEnum);
     188        this->FetchData(&this->eps_abs,EpsAbsEnum);
     189        this->FetchData(&this->max_nonlinear_iterations,MaxNonlinearIterationsEnum);
     190        this->FetchData(&this->max_steadystate_iterations,MaxSteadystateIterationsEnum);
     191        this->FetchData(&this->dt,DtEnum);
     192        this->FetchData(&this->ndt,NdtEnum);
     193        this->FetchData(&this->time_adapt,TimeAdaptEnum);
     194        this->FetchData(&this->cfl_coefficient,CflCoefficientEnum);
     195        this->FetchData(&this->hydrostatic_adjustment,HydrostaticAdjustmentEnum);
     196        this->FetchData(&this->penalty_offset,PenaltyOffsetEnum);
     197        this->FetchData(&this->penalty_melting,PenaltyMeltingEnum);
     198        this->FetchData(&this->penalty_lock,PenaltyLockEnum);
     199        this->FetchData(&this->sparsity,SparsityEnum);
     200        this->FetchData(&this->connectivity,ConnectivityEnum);
     201        this->FetchData(&this->lowmem,LowmemEnum);
     202        this->FetchData(&this->viscosity_overshoot,ViscosityOvershootEnum);
     203        this->FetchData(&this->artdiff,ArtificialDiffusivityEnum);
     204        this->FetchData(&this->prognostic_DG,PrognosticDGEnum);
     205        this->FetchData(&this->stokesreconditioning,StokesreconditioningEnum);
     206        this->FetchData(&this->shelf_dampening,ShelfDampeningEnum);
     207        this->FetchData(&this->waitonlock,WaitonlockEnum);
     208        this->FetchData(&this->gl_migration,GlMigrationEnum);
     209        this->FetchData(&this->isdiagnostic,IsdiagnosticEnum);
     210        this->FetchData(&this->isprognostic,IsprognosticEnum);
     211        this->FetchData(&this->isthermal,IsthermalEnum);
    209212
    210213        /*!Get thermal parameters: */
    211         IoModelFetchData(&this->beta,iomodel_handle,BetaEnum);
    212         IoModelFetchData(&this->meltingpoint,iomodel_handle,MeltingpointEnum);
    213         IoModelFetchData(&this->referencetemperature,iomodel_handle,ReferencetemperatureEnum);
    214         IoModelFetchData(&this->latentheat,iomodel_handle,LatentheatEnum);
    215         IoModelFetchData(&this->heatcapacity,iomodel_handle,HeatcapacityEnum);
    216         IoModelFetchData(&this->thermalconductivity,iomodel_handle,ThermalconductivityEnum);
    217         IoModelFetchData(&this->min_thermal_constraints,iomodel_handle,MinThermalConstraintsEnum);
    218         IoModelFetchData(&this->min_mechanical_constraints,iomodel_handle,MinMechanicalConstraintsEnum);
    219         IoModelFetchData(&this->stabilize_constraints,iomodel_handle,StabilizeConstraintsEnum);
    220         IoModelFetchData(&this->mixed_layer_capacity,iomodel_handle,MixedLayerCapacityEnum);
    221         IoModelFetchData(&this->thermal_exchange_velocity,iomodel_handle,ThermalExchangeVelocityEnum);
    222         IoModelFetchData(&this->basal_melting_rate_correction_apply,iomodel_handle,BasalMeltingRateCorrectionApplyEnum);
    223         IoModelFetchData(&this->gl_melting_rate,iomodel_handle,GlMeltingRateEnum);
    224         IoModelFetchData(&this->rheology_law,iomodel_handle,RheologyLawEnum);
     214        this->FetchData(&this->beta,BetaEnum);
     215        this->FetchData(&this->meltingpoint,MeltingpointEnum);
     216        this->FetchData(&this->referencetemperature,ReferencetemperatureEnum);
     217        this->FetchData(&this->latentheat,LatentheatEnum);
     218        this->FetchData(&this->heatcapacity,HeatcapacityEnum);
     219        this->FetchData(&this->thermalconductivity,ThermalconductivityEnum);
     220        this->FetchData(&this->min_thermal_constraints,MinThermalConstraintsEnum);
     221        this->FetchData(&this->min_mechanical_constraints,MinMechanicalConstraintsEnum);
     222        this->FetchData(&this->stabilize_constraints,StabilizeConstraintsEnum);
     223        this->FetchData(&this->mixed_layer_capacity,MixedLayerCapacityEnum);
     224        this->FetchData(&this->thermal_exchange_velocity,ThermalExchangeVelocityEnum);
     225        this->FetchData(&this->basal_melting_rate_correction_apply,BasalMeltingRateCorrectionApplyEnum);
     226        this->FetchData(&this->gl_melting_rate,GlMeltingRateEnum);
     227        this->FetchData(&this->rheology_law,RheologyLawEnum);
    225228
    226229        /*!Get hydrology parameters: */         
    227         IoModelFetchData(&this->hydro_kn,iomodel_handle,HydroKnEnum);                   
    228         IoModelFetchData(&this->hydro_p,iomodel_handle,HydroPEnum);             
    229         IoModelFetchData(&this->hydro_q,iomodel_handle,HydroQEnum);             
    230         IoModelFetchData(&this->hydro_CR,iomodel_handle,HydroCREnum);           
    231         IoModelFetchData(&this->hydro_n,iomodel_handle,HydroNEnum);
     230        this->FetchData(&this->hydro_kn,HydroKnEnum);                   
     231        this->FetchData(&this->hydro_p,HydroPEnum);             
     232        this->FetchData(&this->hydro_q,HydroQEnum);             
     233        this->FetchData(&this->hydro_CR,HydroCREnum);           
     234        this->FetchData(&this->hydro_n,HydroNEnum);
    232235
    233236        /*qmu: */
    234237        if(this->qmu_analysis){
    235                 IoModelFetchData(&this->numberofvariables,iomodel_handle,NumberOfVariablesEnum);
    236                 IoModelFetchData(&this->numberofresponses,iomodel_handle,NumberOfResponsesEnum);
    237                 IoModelFetchData(&this->qmu_npart,iomodel_handle,NpartEnum);
    238                 IoModelFetchData(&this->qmu_save_femmodel,iomodel_handle,QmuSaveFemmodelEnum);
     238                this->FetchData(&this->numberofvariables,NumberOfVariablesEnum);
     239                this->FetchData(&this->numberofresponses,NumberOfResponsesEnum);
     240                this->FetchData(&this->qmu_npart,NpartEnum);
     241                this->FetchData(&this->qmu_save_femmodel,QmuSaveFemmodelEnum);
    239242        }
    240243
    241244        /*i/o: */
    242         IoModelFetchData(&this->io_gather,iomodel_handle,IoGatherEnum);
     245        this->FetchData(&this->io_gather,IoGatherEnum);
    243246}
    244247/*}}}*/
    … …  
    424427}
    425428/*}}}*/
     429/*FUNCTION IoModel::FetchData(bool*     pbool,int data_enum){{{1*/
     430void  IoModel::FetchData(bool* pboolean,int data_enum){
     431
     432        extern int my_rank;
     433        extern int num_procs;
     434       
     435
     436        /*output: */
     437        bool  boolean;
     438        int   code;
     439       
     440        /*Set file pointer to beginning of the data: */
     441        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     442       
     443        if(code!=1)_error_("%s%s","IoModel::FetchData expecting a boolean for enum ",EnumToStringx(data_enum));
     444       
     445        /*We have to read a boolean from disk. */
     446        if(my_rank==0){ 
     447                if(fread(&boolean,sizeof(bool),1,fid)!=1) _error_(" could not read boolean ");
     448        }
     449
     450        MPI_Bcast(&boolean,1,MPI_BYTE,0,MPI_COMM_WORLD);
     451
     452        /*Assign output pointers: */
     453        *pboolean=boolean;
     454
     455}
     456/*}}}*/
     457/*FUNCTION IoModel::FetchData(int*      pinteger,int data_enum){{{1*/
     458void  IoModel::FetchData(int* pinteger,int data_enum){
     459
     460        extern int my_rank;
     461        extern int num_procs;
     462       
     463
     464        /*output: */
     465        int   integer;
     466        int   code;
     467       
     468        /*Set file pointer to beginning of the data: */
     469        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     470       
     471        if(code!=2)_error_("%s%s","IoModel::FetchData expecting an integer for enum ",EnumToStringx(data_enum));
     472       
     473        /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
     474        if(my_rank==0){ 
     475                if(fread(&integer,sizeof(int),1,fid)!=1) _error_(" could not read integer ");
     476        }
     477
     478        MPI_Bcast(&integer,1,MPI_INT,0,MPI_COMM_WORLD);
     479
     480        /*Assign output pointers: */
     481        *pinteger=integer;
     482
     483}
     484/*}}}*/
     485/*FUNCTION IoModel::FetchData(double*   pscalar,int data_enum){{{1*/
     486void  IoModel::FetchData(double* pscalar,int data_enum){
     487
     488
     489        extern int my_rank;
     490        extern int num_procs;
     491       
     492
     493        /*output: */
     494        double   scalar;
     495        int      code;
     496       
     497        /*Set file pointer to beginning of the data: */
     498        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     499       
     500        if(code!=3)_error_("%s%s","IoModel::FetchData expecting a double for enum ",EnumToStringx(data_enum));
     501       
     502        /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
     503        if(my_rank==0){
     504                if(fread(&scalar,sizeof(double),1,fid)!=1)_error_(" could not read scalar ");
     505        }
     506        MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
     507
     508        /*Assign output pointers: */
     509        *pscalar=scalar;
     510                 
     511}
     512/*}}}*/
     513/*FUNCTION IoModel::FetchData(char**    pstring,int data_enum){{{1*/
     514void  IoModel::FetchData(char** pstring,int data_enum){
     515
     516        extern int my_rank;
     517        extern int num_procs;
     518       
     519
     520        /*output: */
     521        char* string=NULL;
     522        int   string_size;
     523        int code=0;
     524       
     525        /*Set file pointer to beginning of the data: */
     526        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     527       
     528        if(code!=4)_error_("%s%s","IoModel::FetchData expecting a string for enum ",EnumToStringx(data_enum));
     529       
     530        /*Now fetch: */
     531       
     532        /*We have to read a string from disk. First read the dimensions of the string, then the string: */
     533        if(my_rank==0){ 
     534                if(fread(&string_size,sizeof(int),1,fid)!=1) _error_(" could not read length of string ");
     535        }
     536
     537        MPI_Bcast(&string_size,1,MPI_INT,0,MPI_COMM_WORLD);
     538
     539        /*Now allocate string: */
     540        if(string_size){
     541                string=(char*)xmalloc((string_size+1)*sizeof(char));
     542                string[string_size]='\0';
     543
     544                /*Read string on node 0, then broadcast: */
     545                if(my_rank==0){ 
     546                        if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_("  could not read string ");
     547                }
     548                MPI_Bcast(string,string_size,MPI_CHAR,0,MPI_COMM_WORLD);
     549        }
     550        else{
     551                string=(char*)xmalloc(sizeof(char));
     552                string[0]='\0';
     553        }
     554
     555
     556        /*Assign output pointers: */
     557        *pstring=string;
     558}
     559/*}}}*/
     560/*FUNCTION IoModel::FetchData(double**  pdoublematrix,int* pM,int* pN,int data_enum){{{1*/
     561void  IoModel::FetchData(double** pmatrix,int* pM,int* pN,int data_enum){
     562
     563        extern int my_rank;
     564        extern int num_procs;
     565
     566        /*output: */
     567        int M,N;
     568        double* matrix=NULL;
     569        int code=0;
     570        int vector_type=0;
     571       
     572       
     573       
     574        /*Set file pointer to beginning of the data: */
     575        fid=this->SetFilePointerToData(&code,&vector_type,data_enum);
     576
     577        if((code!=5) && (code!=6) && (code!=7))_error_("%s%s","IoModel::FetchData expecting a double, integer or boolean matrix for enum ",EnumToStringx(data_enum));
     578       
     579        /*Now fetch: */
     580
     581        /*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
     582        /*numberofelements: */
     583        if(my_rank==0){ 
     584                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
     585        }
     586
     587        MPI_Bcast(&M,1,MPI_INT,0,MPI_COMM_WORLD);
     588
     589        if(my_rank==0){ 
     590                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
     591        }
     592        MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD);
     593
     594        /*Now allocate matrix: */
     595        if(M*N){
     596                matrix=(double*)xmalloc(M*N*sizeof(double));
     597
     598                /*Read matrix on node 0, then broadcast: */
     599                if(my_rank==0){ 
     600                        if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix ");
     601                }
     602               
     603                MPI_Bcast(matrix,M*N,MPI_DOUBLE,0,MPI_COMM_WORLD);
     604        }
     605
     606        /*Assign output pointers: */
     607        *pmatrix=matrix;
     608        if (pM)*pM=M;
     609        if (pN)*pN=N;
     610
     611}
     612/*}}}*/
     613/*FUNCTION IoModel::FetchData(char***   pstrings,int* pnumstrings,int data_enum){{{1*/
     614void  IoModel::FetchData(char*** pstrings,int* pnumstrings,int data_enum){
     615
     616        extern int my_rank;
     617        extern int num_procs;
     618       
     619        int i;
     620
     621        /*output: */
     622        int   numstrings=0;
     623        char** strings=NULL;
     624       
     625        /*intermediary: */
     626        char* string=NULL;
     627        int   string_size;
     628        int   code;
     629       
     630        /*Set file pointer to beginning of the data: */
     631        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     632       
     633        if(code!=9)_error_("%s%s","IoModel::FetchData expecting a string array for enum ",EnumToStringx(data_enum));
     634       
     635        /*We have to read a bunch of strings from disk. First read the number of strings, and allocate: */
     636        if(my_rank==0){ 
     637                if(fread(&numstrings,sizeof(int),1,fid)!=1) _error_(" could not read length of string array");
     638        }
     639        MPI_Bcast(&numstrings,1,MPI_INT,0,MPI_COMM_WORLD);
     640
     641        /*Now allocate string array: */
     642        if(numstrings){
     643                strings=(char**)xmalloc(numstrings*sizeof(char*));
     644                for(i=0;i<numstrings;i++)strings[i]=NULL;
     645
     646                /*Go through strings, and read: */
     647                for(i=0;i<numstrings;i++){
     648                       
     649                        if(my_rank==0){ 
     650                                if(fread(&string_size,sizeof(int),1,fid)!=1) _error_(" could not read length of string ");
     651                        }
     652                        MPI_Bcast(&string_size,1,MPI_INT,0,MPI_COMM_WORLD);
     653                        if(string_size){
     654                                string=(char*)xmalloc((string_size+1)*sizeof(char));
     655                                string[string_size]='\0';
     656
     657                                /*Read string on node 0, then broadcast: */
     658                                if(my_rank==0){ 
     659                                        if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_("  could not read string ");
     660                                }
     661                                MPI_Bcast(string,string_size,MPI_CHAR,0,MPI_COMM_WORLD);
     662                        }
     663                        else{
     664                                string=(char*)xmalloc(sizeof(char));
     665                                string[0]='\0';
     666                        }
     667
     668                        strings[i]=string;
     669                }
     670        }
     671
     672        /*Assign output pointers: */
     673        *pstrings=strings;
     674        *pnumstrings=numstrings;
     675}
     676/*}}}*/
     677/*FUNCTION IoModel::FetchData(double*** pmatrices,int** pmdims,int** pndims, int* pM,int data_enum){{{1*/
     678void  IoModel::FetchData(double*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){
     679
     680        int i;
     681
     682        extern int my_rank;
     683        extern int num_procs;
     684
     685        /*output: */
     686        double** matrices=NULL;
     687        int*     mdims=NULL;
     688        int*     ndims=NULL;
     689        int      numrecords=0;
     690
     691        /*intermediary: */
     692        int M,N;
     693        double* matrix=NULL;
     694       
     695       
     696        int   code;
     697       
     698        /*Set file pointer to beginning of the data: */
     699        fid=this->SetFilePointerToData(&code,NULL,data_enum);
     700       
     701        if(code!=8)_error_("%s%s","IoModel::FetchData expecting a double mat  array for enum ",EnumToStringx(data_enum));
     702       
     703        /*Now fetch: */
     704        if(my_rank==0){ 
     705                if(fread(&numrecords,sizeof(int),1,fid)!=1) _error_("could not read number of records in matrix array ");
     706        }
     707        MPI_Bcast(&numrecords,1,MPI_INT,0,MPI_COMM_WORLD);
     708
     709        if(numrecords){
     710
     711                /*Allocate matrices :*/
     712                matrices=(double**)xmalloc(numrecords*sizeof(double*));
     713                mdims=(int*)xmalloc(numrecords*sizeof(int));
     714                ndims=(int*)xmalloc(numrecords*sizeof(int));
     715
     716                for(i=0;i<numrecords;i++){
     717                        matrices[i]=NULL;
     718                        mdims[i]=0;
     719                        ndims[i]=0;
     720                }
     721
     722                /*Loop through records and fetch matrix: */
     723                for(i=0;i<numrecords;i++){
     724
     725                        if(my_rank==0){ 
     726                                if(fread(&M,sizeof(int),1,fid)!=1) _error_("%s%i%s","could not read number of rows in ",i,"th matrix of matrix array");
     727                        }
     728                        MPI_Bcast(&M,1,MPI_INT,0,MPI_COMM_WORLD);
     729
     730                        if(my_rank==0){ 
     731                                if(fread(&N,sizeof(int),1,fid)!=1) _error_("%s%i%s","could not read number of columns in ",i,"th matrix of matrix array");
     732                        }
     733                        MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD);
     734
     735                        /*Now allocate matrix: */
     736                        if(M*N){
     737                                matrix=(double*)xmalloc(M*N*sizeof(double));
     738
     739                                /*Read matrix on node 0, then broadcast: */
     740                                if(my_rank==0){ 
     741                                        if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix ");
     742                                }
     743
     744                                MPI_Bcast(matrix,M*N,MPI_DOUBLE,0,MPI_COMM_WORLD);
     745                        }
     746
     747                        /*Assign: */
     748                        matrices[i]=matrix;
     749                        mdims[i]=M;
     750                        ndims[i]=N;
     751                }
     752        }
     753
     754        /*Assign output pointers: */
     755        *pmatrices=matrices;
     756        *pmdims=mdims;
     757        *pndims=ndims;
     758        *pnumrecords=numrecords;
     759}
     760/*}}}*/
     761/*FUNCTION IoModel::SetFilePointerToData(int* pcode,int* pvector_type, int data_enum){{{1*/
     762FILE* IoModel::SetFilePointerToData(int* pcode,int* pvector_type, int data_enum){
     763
     764        extern int my_rank;
     765        extern int num_procs;
     766       
     767       
     768        int found=0;
     769        int record_enum;
     770        int record_length;
     771        int record_code; //1 to 7 number
     772        int vector_type; //nodal or elementary
     773 
     774        /*Go find in the binary file, the position of the data we want to fetch: */
     775        if(my_rank==0){
     776       
     777                /*First set FILE* position to the beginning of the file: */
     778                fseek(fid,0,SEEK_SET);
     779
     780                /*Now march through file looking for the correct data identifier: */
     781                for(;;){
     782                        /*Read enum for this size of first string name: */
     783                        if(fread(&record_enum,sizeof(int),1,fid)==0){
     784                                /*Ok, we have reached the end of the file. break: */
     785                                found=0;
     786                                break;
     787                        }
     788                       
     789                        /*Is this the record sought for? : */
     790                        if (data_enum==record_enum){
     791                                /*Ok, we have found the correct string. Pass the record length, and read data type code: */
     792                                fseek(fid,sizeof(int),SEEK_CUR);
     793                                fread(&record_code,sizeof(int),1,fid);
     794
     795                                /*if record_code points to a vector, get its type (nodal or elementary): */
     796                                if(5<=record_code && record_code<=7)fread(&vector_type,sizeof(int),1,fid);
     797                                found=1;
     798                                break;
     799                        }
     800                        else{
     801                                /*This is not the correct string, read the record length, and use it to skip this record: */
     802                                fread(&record_length,sizeof(int),1,fid);
     803                                /*skip: */
     804                                fseek(fid,record_length,SEEK_CUR);
     805                        }
     806                }
     807        }
     808        MPI_Bcast(&found,1,MPI_INT,0,MPI_COMM_WORLD);
     809        if(!found)_error_("%s %s ","could not find data with name",EnumToStringx(data_enum));
     810
     811        /*Broadcast code and vector type: */
     812        MPI_Bcast(&record_code,1,MPI_INT,0,MPI_COMM_WORLD);
     813        MPI_Bcast(&vector_type,1,MPI_INT,0,MPI_COMM_WORLD);
     814        if(record_code==5) MPI_Bcast(&vector_type,1,MPI_INT,0,MPI_COMM_WORLD);
     815
     816        /*Assign output pointers:*/
     817        *pcode=record_code;
     818        if(pvector_type)*pvector_type=vector_type;
     819
     820        return fid;
     821}
     822/*}}}*/
    426823/*FUNCTION IoModel::Echo{{{1*/
    427824void IoModel::Echo(int which_part,int rank) {

  • issm/trunk/src/c/objects/IoModel.h

    r9338 r9340  
    1111
    1212class IoModel {
     13
     14        private:
     15                FILE* fid; //pointer to input file
    1316
    1417        public:
    … …  
    229232                void Echo(int which_part,int rank);
    230233                /*}}}*/
     234                /*Input/Output:{{{1*/
     235                void  FetchData(bool*     pboolean,int data_enum);
     236                void  FetchData(int*      pinteger,int data_enum);
     237                void  FetchData(double*   pscalar,int data_enum);
     238                void  FetchData(char**    pstring,int data_enum);
     239                void  FetchData(double**  pscalarmatrix,int* pM,int* pN,int data_enum);
     240                void  FetchData(char***   pstringarray,int* pnumstrings,int data_enum);
     241                void  FetchData(double*** pmatrixarray,int** pmdims,int** pndims, int* pnumrecords,int data_enum);
     242                FILE* SetFilePointerToData(int* pcode,int* pvector_type, int data_enum);
     243                /*}}}*/
    231244
    232245};
Note: See TracChangeset for help on using the changeset viewer.