Changeset 8967


Ignore:
Timestamp:
07/14/11 06:59:37 (14 years ago)
Author:
Eric.Larour
Message:

New IoModelToInputsx module, that creates inputs directly out of fetched data.
Greatly simplifies ModelProcessorx. Also takes care of transient forcings.

Location:
issm/trunk/src
Files:
3 added
41 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Container/Elements.cpp

    r7089 r8967  
    220220}
    221221/*}}}*/
     222/*FUNCTION Elements::InputCopy{{{1*/
     223void Elements::InputDuplicate(int input_enum,int output_enum){
     224       
     225        int i;
     226
     227        for(i=0;i<this->Size();i++){
     228                Element* element=(Element*)this->GetObjectByOffset(i);
     229                element->InputDuplicate(input_enum,output_enum);
     230        }
     231}
     232/*}}}*/

  • issm/trunk/src/c/Container/Elements.h

    r7089 r8967  
    3434                Patch* ResultsToPatch(void);
    3535                int   NumberOfElements(void);
     36                void InputDuplicate(int input_enum,int output_enum);
    3637                /*}}}*/
    3738

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

    r8913 r8967  
    564564                                        ./modules/Gradjx/Gradjx.h\
    565565                                        ./modules/Gradjx/Gradjx.cpp\
     566                                        ./modules/IoModelToInputsx/IoModelToInputsx.h\
     567                                        ./modules/IoModelToInputsx/IoModelToInputsx.cpp\
    566568                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.h\
    567569                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.cpp\
    … …  
    12341236                                        ./modules/Gradjx/Gradjx.h\
    12351237                                        ./modules/Gradjx/Gradjx.cpp\
     1238                                        ./modules/IoModelToInputsx/IoModelToInputsx.h\
     1239                                        ./modules/IoModelToInputsx/IoModelToInputsx.cpp\
    12361240                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.h\
    12371241                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.cpp\

  • issm/trunk/src/c/io/Disk/IoModelFetchData.cpp

    r8936 r8967  
    1313#include "./diskio.h"
    1414
    15 /*FUNCTION IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,int data_enum){{{1*/
    16 void  IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,int data_enum){
    17 
    18         extern int my_rank;
    19         extern int num_procs;
    20 
    21         /*output: */
    22         int M,N;
    23         double* matrix=NULL;
    24        
    25         FILE* fid=NULL;
    26        
    27         /*Set file pointer to beginning of the data: */
    28         fid=SetFilePointerToData(model_handle,data_enum);
    29        
    30         /*Now fetch: */
    31 
    32         /*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
    33         /*numberofelements: */
    34         if(my_rank==0){ 
    35                 if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
    36         }
    37 
    38         MPI_Bcast(&M,1,MPI_INT,0,MPI_COMM_WORLD);
    39 
    40         if(my_rank==0){ 
    41                 if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
    42         }
    43         MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD);
    44 
    45         /*Now allocate matrix: */
    46         if(M*N){
    47                 matrix=(double*)xmalloc(M*N*sizeof(double));
    48 
    49                 /*Read matrix on node 0, then broadcast: */
    50                 if(my_rank==0){ 
    51                         if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix ");
    52                 }
    53                
    54                 MPI_Bcast(matrix,M*N,MPI_DOUBLE,0,MPI_COMM_WORLD);
    55         }
    56 
    57         /*Assign output pointers: */
    58         *pmatrix=matrix;
    59         if (pM)*pM=M;
    60         if (pN)*pN=N;
    61 
    62 }
    63 /*}}}*/
    64 /*FUNCTION IoModelFetchData(char** pstring,FILE* model_handle,int data_enum){{{1*/
     15/*FUNCTION IoModelFetchData(bool*     pbool,FILE* model_handle,int data_enum){{{1*/
     16void  IoModelFetchData(bool* pboolean,FILE* model_handle,int data_enum){
     17
     18        extern int my_rank;
     19        extern int num_procs;
     20        FILE* fid=NULL;
     21
     22        /*output: */
     23        bool  boolean;
     24        int   code;
     25       
     26        /*Set file pointer to beginning of the data: */
     27        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     28       
     29        if(code!=1)_error_("%s%s","IoModelFetchData expecting a boolean for enum ",EnumToStringx(data_enum));
     30       
     31        /*We have to read a boolean from disk. */
     32        if(my_rank==0){ 
     33                if(fread(&boolean,sizeof(bool),1,fid)!=1) _error_(" could not read boolean ");
     34        }
     35
     36        MPI_Bcast(&boolean,1,MPI_BYTE,0,MPI_COMM_WORLD);
     37
     38        /*Assign output pointers: */
     39        *pboolean=boolean;
     40
     41}
     42/*}}}*/
     43/*FUNCTION IoModelFetchData(int*      pinteger,FILE* model_handle,int data_enum){{{1*/
     44void  IoModelFetchData(int* pinteger,FILE* model_handle,int data_enum){
     45
     46        extern int my_rank;
     47        extern int num_procs;
     48        FILE* fid=NULL;
     49
     50        /*output: */
     51        int   integer;
     52        int   code;
     53       
     54        /*Set file pointer to beginning of the data: */
     55        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     56       
     57        if(code!=2)_error_("%s%s","IoModelFetchData expecting an integer for enum ",EnumToStringx(data_enum));
     58       
     59        /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
     60        if(my_rank==0){ 
     61                if(fread(&integer,sizeof(int),1,fid)!=1) _error_(" could not read integer ");
     62        }
     63
     64        MPI_Bcast(&integer,1,MPI_INT,0,MPI_COMM_WORLD);
     65
     66        /*Assign output pointers: */
     67        *pinteger=integer;
     68
     69}
     70/*}}}*/
     71/*FUNCTION IoModelFetchData(double*   pscalar,FILE* model_handle,int data_enum){{{1*/
     72void  IoModelFetchData(double* pscalar,FILE* model_handle,int data_enum){
     73
     74
     75        extern int my_rank;
     76        extern int num_procs;
     77        FILE* fid=NULL;
     78
     79        /*output: */
     80        double   scalar;
     81        int      code;
     82       
     83        /*Set file pointer to beginning of the data: */
     84        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     85       
     86        if(code!=3)_error_("%s%s","IoModelFetchData expecting a double for enum ",EnumToStringx(data_enum));
     87       
     88        /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
     89        if(my_rank==0){
     90                if(fread(&scalar,sizeof(double),1,fid)!=1)_error_(" could not read scalar ");
     91        }
     92        MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
     93
     94        /*Assign output pointers: */
     95        *pscalar=scalar;
     96                 
     97}
     98/*}}}*/
     99/*FUNCTION IoModelFetchData(char**    pstring,FILE* model_handle,int data_enum){{{1*/
    65100void  IoModelFetchData(char** pstring,FILE* model_handle,int data_enum){
    66101
    … …  
    72107        char* string=NULL;
    73108        int   string_size;
    74        
    75         /*Set file pointer to beginning of the data: */
    76         fid=SetFilePointerToData(model_handle,data_enum);
     109        int code=0;
     110       
     111        /*Set file pointer to beginning of the data: */
     112        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     113       
     114        if(code!=4)_error_("%s%s","IoModelFetchData expecting a string for enum ",EnumToStringx(data_enum));
    77115       
    78116        /*Now fetch: */
    … …  
    106144}
    107145/*}}}*/
    108 /*FUNCTION IoModelFetchData(char*** pstrings,int* pnumstrings,FILE* model_handle,int data_enum){{{1*/
     146/*FUNCTION IoModelFetchData(double**  pdoublematrix,int* pM,int* pN,FILE* model_handle,int data_enum){{{1*/
     147void  IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,int data_enum){
     148
     149        extern int my_rank;
     150        extern int num_procs;
     151
     152        /*output: */
     153        int M,N;
     154        double* matrix=NULL;
     155        int code=0;
     156        int vector_type=0;
     157       
     158        FILE* fid=NULL;
     159       
     160        /*Set file pointer to beginning of the data: */
     161        fid=SetFilePointerToData(&code,&vector_type,model_handle,data_enum);
     162
     163        if((code!=5) && (code!=6) && (code!=7))_error_("%s%s","IoModelFetchData expecting a double, integer or boolean matrix for enum ",EnumToStringx(data_enum));
     164       
     165        /*Now fetch: */
     166
     167        /*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
     168        /*numberofelements: */
     169        if(my_rank==0){ 
     170                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
     171        }
     172
     173        MPI_Bcast(&M,1,MPI_INT,0,MPI_COMM_WORLD);
     174
     175        if(my_rank==0){ 
     176                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
     177        }
     178        MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD);
     179
     180        /*Now allocate matrix: */
     181        if(M*N){
     182                matrix=(double*)xmalloc(M*N*sizeof(double));
     183
     184                /*Read matrix on node 0, then broadcast: */
     185                if(my_rank==0){ 
     186                        if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix ");
     187                }
     188               
     189                MPI_Bcast(matrix,M*N,MPI_DOUBLE,0,MPI_COMM_WORLD);
     190        }
     191
     192        /*Assign output pointers: */
     193        *pmatrix=matrix;
     194        if (pM)*pM=M;
     195        if (pN)*pN=N;
     196
     197}
     198/*}}}*/
     199/*FUNCTION IoModelFetchData(char***   pstrings,int* pnumstrings,FILE* model_handle,int data_enum){{{1*/
    109200void  IoModelFetchData(char*** pstrings,int* pnumstrings,FILE* model_handle,int data_enum){
    110201
    … …  
    121212        char* string=NULL;
    122213        int   string_size;
    123        
    124         /*Set file pointer to beginning of the data: */
    125         fid=SetFilePointerToData(model_handle,data_enum);
     214        int   code;
     215       
     216        /*Set file pointer to beginning of the data: */
     217        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     218       
     219        if(code!=9)_error_("%s%s","IoModelFetchData expecting a string array for enum ",EnumToStringx(data_enum));
    126220       
    127221        /*We have to read a bunch of strings from disk. First read the number of strings, and allocate: */
    … …  
    167261}
    168262/*}}}*/
    169 /*FUNCTION IoModelFetchData(double* pscalar,FILE* model_handle,int data_enum){{{1*/
    170 void  IoModelFetchData(double* pscalar,FILE* model_handle,int data_enum){
    171 
    172 
    173         extern int my_rank;
    174         extern int num_procs;
    175         FILE* fid=NULL;
    176 
    177         /*output: */
    178         double   scalar;
    179        
    180         /*Set file pointer to beginning of the data: */
    181         fid=SetFilePointerToData(model_handle,data_enum);
    182        
    183         /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
    184         if(my_rank==0){
    185                 if(fread(&scalar,sizeof(double),1,fid)!=1)_error_(" could not read scalar ");
    186         }
    187         MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
    188 
    189         /*Assign output pointers: */
    190         *pscalar=scalar;
    191                  
    192 }
    193 /*}}}*/
    194 /*FUNCTION IoModelFetchData(int* pinteger,FILE* model_handle,int data_enum){{{1*/
    195 void  IoModelFetchData(int* pinteger,FILE* model_handle,int data_enum){
    196 
    197         extern int my_rank;
    198         extern int num_procs;
    199         FILE* fid=NULL;
    200 
    201         /*output: */
    202         int   integer;
    203        
    204         /*Set file pointer to beginning of the data: */
    205         fid=SetFilePointerToData(model_handle,data_enum);
    206        
    207         /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
    208         if(my_rank==0){ 
    209                 if(fread(&integer,sizeof(int),1,fid)!=1) _error_(" could not read integer ");
    210         }
    211 
    212         MPI_Bcast(&integer,1,MPI_INT,0,MPI_COMM_WORLD);
    213 
    214         /*Assign output pointers: */
    215         *pinteger=integer;
    216 
    217 }
    218 /*}}}*/
    219263/*FUNCTION IoModelFetchData(double*** pmatrices,int** pmdims,int** pndims, int* pM,FILE* model_handle,int data_enum){{{1*/
    220264void  IoModelFetchData(double*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,FILE* model_handle,int data_enum){
    … …  
    236280       
    237281        FILE* fid=NULL;
    238        
    239         /*Set file pointer to beginning of the data: */
    240         fid=SetFilePointerToData(model_handle,data_enum);
     282        int   code;
     283       
     284        /*Set file pointer to beginning of the data: */
     285        fid=SetFilePointerToData(&code,NULL,model_handle,data_enum);
     286       
     287        if(code!=8)_error_("%s%s","IoModelFetchData expecting a double mat  array for enum ",EnumToStringx(data_enum));
    241288       
    242289        /*Now fetch: */
    … …  
    298345}
    299346/*}}}*/
    300 /*FUNCTION SetFilePointerToData(FILE* model_handle,int data_enum){{{1*/
    301 FILE* SetFilePointerToData(FILE* model_handle,int data_enum){
    302 
    303         extern int my_rank;
    304         extern int num_procs;
    305        
    306         int record_length;
     347
     348/*FUNCTION SetFilePointerToData(int* pcode,int* pvector_type, FILE* model_handle,int data_enum){{{1*/
     349FILE* SetFilePointerToData(int* pcode,int* pvector_type, FILE* model_handle,int data_enum){
     350
     351        extern int my_rank;
     352        extern int num_procs;
     353       
    307354        FILE* fid=NULL;
    308355        int found=0;
    309356        int record_enum;
    310 
     357        int record_length;
     358        int record_code; //1 to 7 number
     359        int vector_type; //nodal or elementary
     360 
    311361        /*Go find in the binary file, the position of the data we want to fetch: */
    312362        if(my_rank==0){
    … …  
    327377                        /*Is this the record sought for? : */
    328378                        if (data_enum==record_enum){
    329                                 /*Ok, we have found the correct string. Pass the record length, and break: */
     379                                /*Ok, we have found the correct string. Pass the record length, and read data type code: */
    330380                                fseek(fid,sizeof(int),SEEK_CUR);
     381                                fread(&record_code,sizeof(int),1,fid);
     382
     383                                /*if record_code points to a vector, get its type (nodal or elementary): */
     384                                if(5<=record_code && record_code<=7)fread(&vector_type,sizeof(int),1,fid);
    331385                                found=1;
    332386                                break;
    333387                        }
    334388                        else{
    335                                 /*This is not the correct string, read the record length, and skip it: */
     389                                /*This is not the correct string, read the record length, and use it to skip this record: */
    336390                                fread(&record_length,sizeof(int),1,fid);
    337391                                /*skip: */
    … …  
    341395        }
    342396        MPI_Bcast(&found,1,MPI_INT,0,MPI_COMM_WORLD);
    343 
    344397        if(!found)_error_("%s %s ","could not find data with name",EnumToStringx(data_enum));
    345398
     399        /*Broadcast code and vector type: */
     400        MPI_Bcast(&record_code,1,MPI_INT,0,MPI_COMM_WORLD);
     401        if(record_code==5) MPI_Bcast(&vector_type,1,MPI_INT,0,MPI_COMM_WORLD);
     402
     403        /*Assign output pointers:*/
     404        *pcode=record_code;
     405        if(pvector_type)*pvector_type=vector_type;
     406
    346407        return fid;
    347408}

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

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

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    1516void    UpdateElementsBalancethickness(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    25         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    26         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    27         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    28         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    29         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    30         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    31         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    32    IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    33         IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    34         IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
    35         IoModelFetchData(&iomodel->dhdt,NULL,NULL,iomodel_handle,DhdtEnum);
     20
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,DhdtEnum);
     33
    3634        if (iomodel->dim==3){
    37                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    38                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
     35                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     36                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    3937        }
    40 
    41         /*Update elements: */
    42         counter=0;
    43         for (i=0;i<iomodel->numberofelements;i++){
    44                 if(iomodel->my_elements[i]){
    45                         element=(Element*)elements->GetObjectByOffset(counter);
    46                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    47                         counter++;
    48                 }
    49         }
    50 
    5138        /*Free data: */
    5239        xfree((void**)&iomodel->elements);
    53         xfree((void**)&iomodel->thickness);
    54         xfree((void**)&iomodel->surface);
    55         xfree((void**)&iomodel->bed);
    56         xfree((void**)&iomodel->elementoniceshelf);
    57         xfree((void**)&iomodel->elementonbed);
    58         xfree((void**)&iomodel->elementonsurface);
    59         xfree((void**)&iomodel->elementonwater);
    60         xfree((void**)&iomodel->vx);
    61         xfree((void**)&iomodel->vy);
    62         xfree((void**)&iomodel->basal_melting_rate);
    63    xfree((void**)&iomodel->surface_accumulation_rate);
    64         xfree((void**)&iomodel->surface_ablation_rate);
    65         xfree((void**)&iomodel->surface_mass_balance);
     40
     41
    6642}

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    1516void    UpdateElementsBalancevelocities(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    25         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    26         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    27         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    28         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    29         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    30         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    31         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    32         IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    33         IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    34         IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
     20
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
    3532
    3633        if (iomodel->dim==3){
    37                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    38                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
     34                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     35                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    3936        }
    40 
    41         /*Update elements: */
    42         counter=0;
    43         for (i=0;i<iomodel->numberofelements;i++){
    44                 if(iomodel->my_elements[i]){
    45                         element=(Element*)elements->GetObjectByOffset(counter);
    46                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    47                         counter++;
    48                 }
    49         }
    50 
    5137        /*Free data: */
    5238        xfree((void**)&iomodel->elements);
    53         xfree((void**)&iomodel->thickness);
    54         xfree((void**)&iomodel->surface);
    55         xfree((void**)&iomodel->bed);
    56         xfree((void**)&iomodel->elementoniceshelf);
    57         xfree((void**)&iomodel->elementonwater);
    58         xfree((void**)&iomodel->elementonbed);
    59         xfree((void**)&iomodel->elementonsurface);
    60         xfree((void**)&iomodel->vx);
    61         xfree((void**)&iomodel->vy);
    62         xfree((void**)&iomodel->vz);
    63         xfree((void**)&iomodel->basal_melting_rate);
    64         xfree((void**)&iomodel->surface_accumulation_rate);
    65         xfree((void**)&iomodel->surface_ablation_rate);
    66         xfree((void**)&iomodel->surface_mass_balance);
     39
    6740}

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

    r8926 r8967  
    44
    55#include "../../../Container/Container.h"
     6#include "../../../modules/modules.h"
    67#include "../../../toolkits/toolkits.h"
    78#include "../../../io/io.h"
    … …  
    1516void    UpdateElementsBedSlope(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    25         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    26         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    2720
    28         if (iomodel->dim==3){
    29                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    30                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    31         }
    32 
    33         /*Update elements: */
    34         counter=0;
    35         for (i=0;i<iomodel->numberofelements;i++){
    36                 if(iomodel->my_elements[i]){
    37                         element=(Element*)elements->GetObjectByOffset(counter);
    38                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    39                         counter++;
    40                 }
    41         }
    42 
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     24       
    4325        /*Free data: */
    4426        xfree((void**)&iomodel->elements);
    45         xfree((void**)&iomodel->surface);
    46         xfree((void**)&iomodel->bed);
    47         xfree((void**)&iomodel->elementonwater);
    48         xfree((void**)&iomodel->elementonbed);
    49         xfree((void**)&iomodel->elementonsurface);
     27
    5028}

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    2627        /*Fetch data needed: */
    2728        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     29
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,VxObsEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,VyObsEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessObsEnum);
     33
    2834        IoModelFetchData(&iomodel->control_type,NULL,NULL,iomodel_handle,ControlTypeEnum);
    2935        IoModelFetchData(&iomodel->weights,NULL,NULL,iomodel_handle,WeightsEnum);
    3036        IoModelFetchData(&iomodel->cm_min,NULL,NULL,iomodel_handle,CmMinEnum);
    3137        IoModelFetchData(&iomodel->cm_max,NULL,NULL,iomodel_handle,CmMaxEnum);
    32         IoModelFetchData(&iomodel->vx_obs,NULL,NULL,iomodel_handle,VxObsEnum);
    33         IoModelFetchData(&iomodel->vy_obs,NULL,NULL,iomodel_handle,VyObsEnum);
    34         IoModelFetchData(&iomodel->thickness_obs,NULL,NULL,iomodel_handle,ThicknessObsEnum);
    3538        for(i=0;i<iomodel->num_control_type;i++){
    3639                switch((int)iomodel->control_type[i]){
    … …  
    5558        }
    5659
    57         /*Update elements: */
     60        /*Update elements and materials: */
    5861        counter=0;
    5962        for (i=0;i<iomodel->numberofelements;i++){
    … …  
    6770                }
    6871        }
    69 
     72       
    7073        /*Free data: */
    7174        xfree((void**)&iomodel->elements);
    … …  
    7477        xfree((void**)&iomodel->cm_max);
    7578        xfree((void**)&iomodel->control_type);
    76         xfree((void**)&iomodel->vx_obs);
    77         xfree((void**)&iomodel->vy_obs);
    78         xfree((void**)&iomodel->thickness_obs);
    7979        xfree((void**)&iomodel->dhdt);
    8080        xfree((void**)&iomodel->vx);

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

    r8926 r8967  
    44
    55#include "../../../Container/Container.h"
     6#include "../../../modules/modules.h"
    67#include "../../../toolkits/toolkits.h"
    78#include "../../../io/io.h"
    … …  
    2627        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    2728        IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    28         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    29         IoModelFetchData(&iomodel->thickness_coeff,NULL,NULL,iomodel_handle,ThicknessCoeffEnum);
    30         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    31         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    32         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    33         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,DragPEnum);
    34         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,DragQEnum);
    35         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    36         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    37         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    38         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    39         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    40         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    41         if(iomodel->gl_migration!=NoneEnum) IoModelFetchData(&iomodel->bathymetry,NULL,NULL,iomodel_handle,BathymetryEnum);
    42 
    43         if (iomodel->dim==3){
    44                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    45                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    46                 IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,VzEnum);
    47                 IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    48                 IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    49                 IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
    50                 IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    51                 IoModelFetchData(&iomodel->nodeonstokes,NULL,NULL,iomodel_handle,NodeOnStokesEnum);
    52         }
    53         if(iomodel->control_analysis){
    54                 IoModelFetchData(&iomodel->vx_obs,NULL,NULL,iomodel_handle,VxObsEnum);
    55                 IoModelFetchData(&iomodel->vy_obs,NULL,NULL,iomodel_handle,VyObsEnum);
    56         }
    5729
    5830        /*Update elements: */
    … …  
    6537                }
    6638        }
    67 cleanup_and_return:
    6839
     40        /*Create inputs: */
     41        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     42        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
     43        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     44        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     45        IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
     46        IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
     47        IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
     48        IoModelToInputsx(elements,iomodel,iomodel_handle,DragTypeEnum);
     49        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     50        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     51        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
     52        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
     53        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum,VxObsEnum,0);
     54        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum,VyObsEnum,0);
     55        IoModelToInputsx(elements,iomodel,iomodel_handle,BathymetryEnum);
     56
     57        if (iomodel->dim==3){
     58                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     59                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     60                IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     61                IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     62                IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     63                IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
     64                IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     65                IoModelToInputsx(elements,iomodel,iomodel_handle,NodeOnStokesEnum);
     66        }
     67
     68        if(iomodel->control_analysis){
     69                IoModelToInputsx(elements,iomodel,iomodel_handle,VxObsEnum);
     70                IoModelToInputsx(elements,iomodel,iomodel_handle,VyObsEnum);
     71        }
     72
     73        /*Post-process: */
     74
     75        elements->InputDuplicate(VxEnum,VxPicardEnum);
     76        elements->InputDuplicate(VxEnum,VxObsEnum);
     77        if(iomodel->qmu_analysis)elements->InputDuplicate(VxEnum,QmuVxEnum);
     78       
     79        elements->InputDuplicate(VyEnum,VyPicardEnum);
     80        elements->InputDuplicate(VyEnum,VyObsEnum);
     81        if(iomodel->qmu_analysis)elements->InputDuplicate(VyEnum,QmuVyEnum);
     82       
     83        if(iomodel->dim==3){
     84                elements->InputDuplicate(VzEnum,VzPicardEnum);
     85                elements->InputDuplicate(VzEnum,VzObsEnum);
     86                if(iomodel->qmu_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum);
     87        }
     88
     89       
     90        cleanup_and_return:
    6991        /*Free data: */
    7092        xfree((void**)&iomodel->elements);
    7193        xfree((void**)&iomodel->elements_type);
    72         xfree((void**)&iomodel->thickness);
    73         xfree((void**)&iomodel->thickness_coeff);
    74         xfree((void**)&iomodel->surface);
    75         xfree((void**)&iomodel->bed);
    76         xfree((void**)&iomodel->drag_coefficient);
    77         xfree((void**)&iomodel->drag_p);
    78         xfree((void**)&iomodel->drag_q);
    79         xfree((void**)&iomodel->rheology_n);
    80         xfree((void**)&iomodel->rheology_B);
    81         xfree((void**)&iomodel->elementoniceshelf);
    82         xfree((void**)&iomodel->elementonbed);
    83         xfree((void**)&iomodel->elementonsurface);
    84         xfree((void**)&iomodel->elementonwater);
    85    xfree((void**)&iomodel->surface_accumulation_rate);
    86         xfree((void**)&iomodel->surface_ablation_rate);
    87         xfree((void**)&iomodel->surface_mass_balance);
    88         xfree((void**)&iomodel->basal_melting_rate);
    89         xfree((void**)&iomodel->nodeonstokes);
    90         xfree((void**)&iomodel->vx);
    91         xfree((void**)&iomodel->vy);
    92         xfree((void**)&iomodel->vz);
    93         xfree((void**)&iomodel->vx_obs);
    94         xfree((void**)&iomodel->vy_obs);
    9594}

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

    r8926 r8967  
    66#include "../../../toolkits/toolkits.h"
    77#include "../../../io/io.h"
     8#include "../../../modules/modules.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    910#include "../../../objects/objects.h"
    … …  
    1516void    UpdateElementsDiagnosticHutter(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Now, is the flag hutter on? otherwise, do nothing: */
    23         if (!iomodel->ishutter)goto cleanup_and_return;
     19        if (!iomodel->ishutter)return;
    2420
    2521        /*Fetch data needed: */
    26         IoModelFetchData(&iomodel->nodeonhutter,NULL,NULL,iomodel_handle,NodeOnHutterEnum);
    27         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    28         IoModelFetchData(&iomodel->thickness_coeff,NULL,NULL,iomodel_handle,ThicknessCoeffEnum);
    29         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    30         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    31         IoModelFetchData(&iomodel->nodeonsurface,NULL,NULL,iomodel_handle,NodeOnSurfaceEnum);
    32         IoModelFetchData(&iomodel->nodeonbed,NULL,NULL,iomodel_handle,NodeOnBedEnum);
    33         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    34         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    35         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    36         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    37         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    38         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    39         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    4022        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
     23       
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,NodeOnHutterEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
     27       
     28        /*Free data: */
     29        xfree((void**)&iomodel->elements);
    4130
    42         /*Update elements: */
    43         counter=0;
    44         for (i=0;i<iomodel->numberofelements;i++){
    45                 if(iomodel->my_elements[i]){
    46                         element=(Element*)elements->GetObjectByOffset(counter);
    47                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    48                         counter++;
    49                 }
    50         }
    51         cleanup_and_return:
    52 
    53         /*Free data: */
    54         xfree((void**)&iomodel->nodeonhutter);
    55         xfree((void**)&iomodel->thickness);
    56         xfree((void**)&iomodel->thickness_coeff);
    57         xfree((void**)&iomodel->surface);
    58         xfree((void**)&iomodel->bed);
    59         xfree((void**)&iomodel->nodeonsurface);
    60         xfree((void**)&iomodel->nodeonbed);
    61         xfree((void**)&iomodel->drag_coefficient);
    62         xfree((void**)&iomodel->rheology_B);
    63         xfree((void**)&iomodel->rheology_n);
    64         xfree((void**)&iomodel->elements_type);
    65         xfree((void**)&iomodel->elementonbed);
    66         xfree((void**)&iomodel->elementonsurface);
    67         xfree((void**)&iomodel->elementonwater);
    68         xfree((void**)&iomodel->elements);
    6931}

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

    r8926 r8967  
    66#include "../../../toolkits/toolkits.h"
    77#include "../../../io/io.h"
     8#include "../../../modules/modules.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    910#include "../../../objects/objects.h"
    … …  
    1516void    UpdateElementsDiagnosticVert(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Now, is the model 3d? otherwise, do nothing: */
    23         if (iomodel->dim==2)goto cleanup_and_return;
     19        if (iomodel->dim==2)return;
    2420
    2521        /*Fetch data needed: */
    2622        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    27         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    28         IoModelFetchData(&iomodel->thickness_coeff,NULL,NULL,iomodel_handle,ThicknessCoeffEnum);
    29         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    30         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    31         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    32         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    33         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    34         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    35         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    36         IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    37         IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    38         IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
    39         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    40         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    4123
    42         /*Update elements: */
    43         counter=0;
    44         for (i=0;i<iomodel->numberofelements;i++){
    45                 if(iomodel->my_elements[i]){
    46                         element=(Element*)elements->GetObjectByOffset(counter);
    47                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    48                         counter++;
    49                 }
    50         }
    51         cleanup_and_return:
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessCoeffEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     33        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     34        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     35        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
     36        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     37        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
    5238
    5339        /*Free data: */
    5440        xfree((void**)&iomodel->elements);
    55         xfree((void**)&iomodel->thickness);
    56         xfree((void**)&iomodel->thickness_coeff);
    57         xfree((void**)&iomodel->surface);
    58         xfree((void**)&iomodel->bed);
    59         xfree((void**)&iomodel->elementoniceshelf);
    60         xfree((void**)&iomodel->elementonbed);
    61         xfree((void**)&iomodel->elementonsurface);
    62         xfree((void**)&iomodel->elementonwater);
    63         xfree((void**)&iomodel->basal_melting_rate);
    64         xfree((void**)&iomodel->surface_accumulation_rate);
    65         xfree((void**)&iomodel->surface_ablation_rate);
    66         xfree((void**)&iomodel->surface_mass_balance);
    67         xfree((void**)&iomodel->vx);
    68         xfree((void**)&iomodel->vy);
     41       
    6942}

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

    r8926 r8967  
    77#include "../../../io/io.h"
    88#include "../../../EnumDefinitions/EnumDefinitions.h"
     9#include "../../../modules/modules.h"
    910#include "../../../objects/objects.h"
    1011#include "../../../shared/shared.h"
    … …  
    1516void    UpdateElementsEnthalpy(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Now, is the model 3d? otherwise, do nothing: */
    23         if (iomodel->dim==2)goto cleanup_and_return;
     19        if (iomodel->dim==2)return;
    2420
    2521        /*Fetch data needed: */
    2622        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    27         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    28         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    29         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    30         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    31         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,DragPEnum);
    32         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,DragQEnum);
    33         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    34         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    35         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    37         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    38         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    39         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    40         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,PressureEnum);
    41         IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,TemperatureEnum);
    42         IoModelFetchData(&iomodel->waterfraction,NULL,NULL,iomodel_handle,WaterfractionEnum);
    43         IoModelFetchData(&iomodel->geothermalflux,NULL,NULL,iomodel_handle,GeothermalfluxEnum);
    44         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    45         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    46         IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,VzEnum);
    4723
    48         /*Update elements: */
    49         counter=0;
    50         for (i=0;i<iomodel->numberofelements;i++){
    51                 if(iomodel->my_elements[i]){
    52                         element=(Element*)elements->GetObjectByOffset(counter);
    53                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    54                         counter++;
    55                 }
    56         }
    57 
    58         cleanup_and_return:
    59 
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     33        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     34        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
     35        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
     36        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
     37        IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     38        IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
     39        IoModelToInputsx(elements,iomodel,iomodel_handle,WaterfractionEnum);
     40        IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
     41        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     42        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     43        IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     44       
    6045        /*Free data: */
    6146        xfree((void**)&iomodel->elements);
    62         xfree((void**)&iomodel->thickness);
    63         xfree((void**)&iomodel->surface);
    64         xfree((void**)&iomodel->bed);
    65         xfree((void**)&iomodel->drag_coefficient);
    66         xfree((void**)&iomodel->drag_p);
    67         xfree((void**)&iomodel->drag_q);
    68         xfree((void**)&iomodel->elementoniceshelf);
    69         xfree((void**)&iomodel->elementonbed);
    70         xfree((void**)&iomodel->elementonsurface);
    71         xfree((void**)&iomodel->elementonwater);
    72         xfree((void**)&iomodel->elements_type);
    73         xfree((void**)&iomodel->rheology_B);
    74         xfree((void**)&iomodel->rheology_n);
    75         xfree((void**)&iomodel->pressure);
    76         xfree((void**)&iomodel->temperature);
    77         xfree((void**)&iomodel->waterfraction);
    78         xfree((void**)&iomodel->geothermalflux);
    79         xfree((void**)&iomodel->vx);
    80         xfree((void**)&iomodel->vy);
    81         xfree((void**)&iomodel->vz);
     47
    8248}

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

    r8926 r8967  
    66#include "../../../toolkits/toolkits.h"
    77#include "../../../io/io.h"
     8#include "../../../modules/modules.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    910#include "../../../objects/objects.h"
    … …  
    1516void    UpdateElementsHydrology(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    25         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    26         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    27         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    28         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,DragPEnum);
    29         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,DragQEnum);
    30         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    31         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    32         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    33         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    34         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    35         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    36         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    37         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,PressureEnum);
    38         IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,TemperatureEnum);
    39         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    40         IoModelFetchData(&iomodel->watercolumn,NULL,NULL,iomodel_handle,WatercolumnEnum);
    41         IoModelFetchData(&iomodel->geothermalflux,NULL,NULL,iomodel_handle,GeothermalfluxEnum);
    42         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    43         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    44         IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,VzEnum);
    4520
    46         /*Update elements: */
    47         counter=0;
    48         for (i=0;i<iomodel->numberofelements;i++){
    49                 if(iomodel->my_elements[i]){
    50                         element=(Element*)elements->GetObjectByOffset(counter);
    51                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    52                         counter++;
    53                 }
    54         }
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
     33        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
     34        IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     35        IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
     36        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     37        IoModelToInputsx(elements,iomodel,iomodel_handle,WatercolumnEnum);
     38        IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
     39        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     40        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     41        IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
    5542
    56         cleanup_and_return:
    57 
     43        elements->InputDuplicate(WatercolumnEnum,WaterColumnOldEnum);
     44        elements->InputDuplicate(WatercolumnEnum,WaterColumnPicardEnum);
     45       
    5846        /*Free data: */
    5947        xfree((void**)&iomodel->elements);
    60         xfree((void**)&iomodel->thickness);
    61         xfree((void**)&iomodel->surface);
    62         xfree((void**)&iomodel->bed);
    63         xfree((void**)&iomodel->drag_coefficient);
    64         xfree((void**)&iomodel->drag_p);
    65         xfree((void**)&iomodel->drag_q);
    66         xfree((void**)&iomodel->elementoniceshelf);
    67         xfree((void**)&iomodel->elementonbed);
    68         xfree((void**)&iomodel->elementonsurface);
    69         xfree((void**)&iomodel->elementonwater);
    70         xfree((void**)&iomodel->elements_type);
    71         xfree((void**)&iomodel->rheology_B);
    72         xfree((void**)&iomodel->rheology_n);
    73         xfree((void**)&iomodel->pressure);
    74         xfree((void**)&iomodel->temperature);
    75         xfree((void**)&iomodel->basal_melting_rate);
    76         xfree((void**)&iomodel->watercolumn);
    77         xfree((void**)&iomodel->geothermalflux);
    78         xfree((void**)&iomodel->vx);
    79         xfree((void**)&iomodel->vy);
    80         xfree((void**)&iomodel->vz);
     48
     49       
    8150}

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    1516void    UpdateElementsMelting(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Now, is the model 3d? otherwise, do nothing: */
    23         if (iomodel->dim==2)goto cleanup_and_return;
     19        if (iomodel->dim==2)return;
    2420
    2521        /*Fetch data needed: */
    2622        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    27         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    28         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    29         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    30         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    31         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,DragPEnum);
    32         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,DragQEnum);
    33         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    34         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    35         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    37         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    38         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    39         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    40    IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    41         IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    42         IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
    43         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    44         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,PressureEnum);
    4523
    46         /*Update elements: */
    47         counter=0;
    48         for (i=0;i<iomodel->numberofelements;i++){
    49                 if(iomodel->my_elements[i]){
    50                         element=(Element*)elements->GetObjectByOffset(counter);
    51                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    52                         counter++;
    53                 }
    54         }
    55 
    56         cleanup_and_return:
     24        /*Create inputs: */
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     33        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     34        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     35        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
     36        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
     37        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
     38        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     39        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     40        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
     41        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     42        IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     43       
    5744        /*Free data: */
    5845        xfree((void**)&iomodel->elements);
    59         xfree((void**)&iomodel->thickness);
    60         xfree((void**)&iomodel->surface);
    61         xfree((void**)&iomodel->bed);
    62         xfree((void**)&iomodel->drag_coefficient);
    63         xfree((void**)&iomodel->drag_p);
    64         xfree((void**)&iomodel->drag_q);
    65         xfree((void**)&iomodel->elementoniceshelf);
    66         xfree((void**)&iomodel->elementonbed);
    67         xfree((void**)&iomodel->elementonsurface);
    68         xfree((void**)&iomodel->elementonwater);
    69         xfree((void**)&iomodel->elements_type);
    70         xfree((void**)&iomodel->rheology_B);
    71         xfree((void**)&iomodel->rheology_n);
    72         xfree((void**)&iomodel->basal_melting_rate);
    73    xfree((void**)&iomodel->surface_accumulation_rate);
    74         xfree((void**)&iomodel->surface_ablation_rate);
    75         xfree((void**)&iomodel->surface_mass_balance);
    76         xfree((void**)&iomodel->pressure);
     46
    7747}

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    1516void    UpdateElementsPrognostic(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    25         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    26         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    27         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    28         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    29         IoModelFetchData(&iomodel->surface_accumulation_rate,NULL,NULL,iomodel_handle,SurfaceAccumulationRateEnum);
    30         IoModelFetchData(&iomodel->surface_ablation_rate,NULL,NULL,iomodel_handle,SurfaceAblationRateEnum);
    31         IoModelFetchData(&iomodel->surface_mass_balance,NULL,NULL,iomodel_handle,SurfaceMassBalanceEnum);
    32         IoModelFetchData(&iomodel->basal_melting_rate,NULL,NULL,iomodel_handle,BasalMeltingRateEnum);
    33         if(iomodel->basal_melting_rate_correction_apply)IoModelFetchData(&iomodel->basal_melting_rate_correction,NULL,NULL,iomodel_handle,BasalMeltingRateCorrectionEnum);
    34         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    35         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    3620
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAccumulationRateEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceAblationRateEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceMassBalanceEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,BasalMeltingRateCorrectionEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     33       
    3734        if (iomodel->dim==3){
    38                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    39                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    40                 IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,PressureEnum);
    41                 IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,TemperatureEnum);
     35                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     36                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     37                IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     38                IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
    4239        }
    43 
    44         /*Update elements: */
    45         counter=0;
    46         for (i=0;i<iomodel->numberofelements;i++){
    47                 if(iomodel->my_elements[i]){
    48                         element=(Element*)elements->GetObjectByOffset(counter);
    49                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    50                         counter++;
    51                 }
    52         }
    53 
     40       
    5441        /*Free data: */
    5542        xfree((void**)&iomodel->elements);
    56         xfree((void**)&iomodel->thickness);
    57         xfree((void**)&iomodel->surface);
    58         xfree((void**)&iomodel->bed);
    59         xfree((void**)&iomodel->elementoniceshelf);
    60         xfree((void**)&iomodel->elementonbed);
    61         xfree((void**)&iomodel->elementonsurface);
    62         xfree((void**)&iomodel->elementonwater);
    63    xfree((void**)&iomodel->surface_accumulation_rate);
    64         xfree((void**)&iomodel->surface_ablation_rate);
    65         xfree((void**)&iomodel->surface_mass_balance);
    66         xfree((void**)&iomodel->basal_melting_rate);
    67         xfree((void**)&iomodel->basal_melting_rate_correction);
    68         xfree((void**)&iomodel->vx);
    69         xfree((void**)&iomodel->vy);
    70         xfree((void**)&iomodel->pressure);
    71         xfree((void**)&iomodel->temperature);
     43
     44
    7245}

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

    r8943 r8967  
    116116
    117117                                /*Convert units: */
    118                                 UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnumx(tag),parameters);
     118                                UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnumx(tag));
    119119
    120120                                /*Add to parameters: */

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

    r8926 r8967  
    55#include "../../../Container/Container.h"
    66#include "../../../toolkits/toolkits.h"
     7#include "../../../modules/modules.h"
    78#include "../../../io/io.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    … …  
    1516void    UpdateElementsSurfaceSlope(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Fetch data needed: */
    2319        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    24         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    25         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    26         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    2720
     21        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     22        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     23        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     24       
    2825        if (iomodel->dim==3){
    29                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    30                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
     26                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     27                IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
    3128        }
    32 
    33         /*Update elements: */
    34         counter=0;
    35         for (i=0;i<iomodel->numberofelements;i++){
    36                 if(iomodel->my_elements[i]){
    37                         element=(Element*)elements->GetObjectByOffset(counter);
    38                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    39                         counter++;
    40                 }
    41         }
    42 
     29       
    4330        /*Free data: */
    4431        xfree((void**)&iomodel->elements);
    45         xfree((void**)&iomodel->surface);
    46         xfree((void**)&iomodel->bed);
    47         xfree((void**)&iomodel->elementonwater);
    48         xfree((void**)&iomodel->elementonbed);
    49         xfree((void**)&iomodel->elementonsurface);
     32
    5033}

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

    r8926 r8967  
    44
    55#include "../../../Container/Container.h"
     6#include "../../../modules/modules.h"
    67#include "../../../toolkits/toolkits.h"
    78#include "../../../io/io.h"
    … …  
    1516void    UpdateElementsThermal(Elements* elements, IoModel* iomodel,FILE* iomodel_handle,int analysis_counter,int analysis_type){
    1617
    17         /*Intermediary*/
    18         int i;
    19         int counter;
    20         Element* element=NULL;
    21 
    2218        /*Now, is the model 3d? otherwise, do nothing: */
    23         if (iomodel->dim==2)goto cleanup_and_return;
     19        if (iomodel->dim==2)return;
    2420
    2521        /*Fetch data needed: */
    2622        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,ElementsEnum);
    27         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,ThicknessEnum);
    28         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,SurfaceEnum);
    29         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,BedEnum);
    30         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,DragCoefficientEnum);
    31         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,DragPEnum);
    32         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,DragQEnum);
    33         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,ElementOnIceShelfEnum);
    34         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,ElementOnBedEnum);
    35         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,ElementOnSurfaceEnum);
    36         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,ElementOnWaterEnum);
    37         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,ElementsTypeEnum);
    38         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,RheologyBEnum);
    39         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,RheologyNEnum);
    40         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,PressureEnum);
    41         IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,TemperatureEnum);
    42         IoModelFetchData(&iomodel->geothermalflux,NULL,NULL,iomodel_handle,GeothermalfluxEnum);
    43         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,VxEnum);
    44         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,VyEnum);
    45         IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,VzEnum);
    4623
    47         /*Update elements: */
    48         counter=0;
    49         for (i=0;i<iomodel->numberofelements;i++){
    50                 if(iomodel->my_elements[i]){
    51                         element=(Element*)elements->GetObjectByOffset(counter);
    52                         element->Update(i,iomodel,analysis_counter,analysis_type); //we need i to index into elements.
    53                         counter++;
    54                 }
    55         }
    56 
    57         cleanup_and_return:
    58 
     24        IoModelToInputsx(elements,iomodel,iomodel_handle,ThicknessEnum);
     25        IoModelToInputsx(elements,iomodel,iomodel_handle,SurfaceEnum);
     26        IoModelToInputsx(elements,iomodel,iomodel_handle,BedEnum);
     27        IoModelToInputsx(elements,iomodel,iomodel_handle,DragCoefficientEnum);
     28        IoModelToInputsx(elements,iomodel,iomodel_handle,DragPEnum);
     29        IoModelToInputsx(elements,iomodel,iomodel_handle,DragQEnum);
     30        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnIceShelfEnum);
     31        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnBedEnum);
     32        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnSurfaceEnum);
     33        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementOnWaterEnum);
     34        IoModelToInputsx(elements,iomodel,iomodel_handle,ElementsTypeEnum);
     35        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyBEnum);
     36        IoModelToInputsx(elements,iomodel,iomodel_handle,RheologyNEnum);
     37        IoModelToInputsx(elements,iomodel,iomodel_handle,PressureEnum);
     38        IoModelToInputsx(elements,iomodel,iomodel_handle,TemperatureEnum);
     39        IoModelToInputsx(elements,iomodel,iomodel_handle,GeothermalfluxEnum);
     40        IoModelToInputsx(elements,iomodel,iomodel_handle,VxEnum);
     41        IoModelToInputsx(elements,iomodel,iomodel_handle,VyEnum);
     42        IoModelToInputsx(elements,iomodel,iomodel_handle,VzEnum);
     43       
    5944        /*Free data: */
    6045        xfree((void**)&iomodel->elements);
    61         xfree((void**)&iomodel->thickness);
    62         xfree((void**)&iomodel->surface);
    63         xfree((void**)&iomodel->bed);
    64         xfree((void**)&iomodel->drag_coefficient);
    65         xfree((void**)&iomodel->drag_p);
    66         xfree((void**)&iomodel->drag_q);
    67         xfree((void**)&iomodel->elementoniceshelf);
    68         xfree((void**)&iomodel->elementonbed);
    69         xfree((void**)&iomodel->elementonsurface);
    70         xfree((void**)&iomodel->elementonwater);
    71         xfree((void**)&iomodel->elements_type);
    72         xfree((void**)&iomodel->rheology_B);
    73         xfree((void**)&iomodel->rheology_n);
    74         xfree((void**)&iomodel->pressure);
    75         xfree((void**)&iomodel->temperature);
    76         xfree((void**)&iomodel->geothermalflux);
    77         xfree((void**)&iomodel->vx);
    78         xfree((void**)&iomodel->vy);
    79         xfree((void**)&iomodel->vz);
     46
     47       
    8048}

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

    r8926 r8967  
    66#include "../../../toolkits/toolkits.h"
    77#include "../../../io/io.h"
     8#include "../../../modules/modules.h"
    89#include "../../../EnumDefinitions/EnumDefinitions.h"
    910#include "../../../objects/objects.h"

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

    r8799 r8967  
    4949#include "./InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h"
    5050#include "./InputArtificialNoisex/InputArtificialNoisex.h"
     51#include "./IoModelToInputsx/IoModelToInputsx.h"
    5152#include "./KMLMeshWritex/KMLFileReadx.h"
    5253#include "./KMLMeshWritex/KMLMeshWritex.h"

  • issm/trunk/src/c/objects/ElementResults/BoolElementResult.cpp

    r8224 r8967  
    162162void BoolElementResult::ProcessUnits(Parameters* parameters){
    163163       
    164         this->value=UnitConversion(this->value,IuToExtEnum,this->enum_type,parameters);
     164        this->value=UnitConversion(this->value,IuToExtEnum,this->enum_type);
    165165
    166166}

  • issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp

    r8224 r8967  
    162162void DoubleElementResult::ProcessUnits(Parameters* parameters){
    163163       
    164         this->value=UnitConversion(this->value,IuToExtEnum,this->enum_type,parameters);
     164        this->value=UnitConversion(this->value,IuToExtEnum,this->enum_type);
    165165
    166166}

  • issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp

    r8224 r8967  
    173173void PentaVertexElementResult::ProcessUnits(Parameters* parameters){
    174174       
    175         UnitConversion(this->values,6,IuToExtEnum,this->enum_type,parameters);
     175        UnitConversion(this->values,6,IuToExtEnum,this->enum_type);
    176176
    177177}

  • issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp

    r8224 r8967  
    162162void TriaVertexElementResult::ProcessUnits(Parameters* parameters){
    163163       
    164         UnitConversion(this->values,3,IuToExtEnum,this->enum_type,parameters);
     164        UnitConversion(this->values,3,IuToExtEnum,this->enum_type);
    165165
    166166}

  • issm/trunk/src/c/objects/Elements/Element.h

    r8926 r8967  
    6060                virtual void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type)=0;
    6161                virtual void   InputToResult(int enum_type,int step,double time)=0;
     62                virtual void   InputDuplicate(int original_enum,int new_enum)=0;
     63                virtual void   InputCreate(double scalar,int name,int code)=0;
     64                virtual void   InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code)=0;
    6265                virtual void   ControlInputGetGradient(Vec gradient,int enum_type)=0;
    6366                virtual void   ControlInputSetGradient(double* gradient,int enum_type)=0;
    … …  
    7578                virtual void   MaxVz(double* pmaxvz, bool process_units)=0;
    7679                virtual void   MaxAbsVz(double* pmaxabsvz, bool process_units)=0;
    77                 virtual void   InputDuplicate(int original_enum,int new_enum)=0;
    7880                virtual void   InputScale(int enum_type,double scale_factor)=0;
    7981                virtual void   GetVectorFromInputs(Vec vector,int NameEnum)=0;

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r8926 r8967  
    48664866}
    48674867/*}}}*/
     4868/*FUNCTION Penta::InputCreate(double scalar,int enum,int code);{{{1*/
     4869void Penta::InputCreate(double scalar,int name,int code){
     4870
     4871        /*Check that name is an element input*/
     4872        if (!IsInput(name)) return;
     4873       
     4874        if ((code==5) || (code==1)){ //boolean
     4875                this->inputs->AddInput(new BoolInput(name,(bool)scalar));
     4876        }
     4877        else if ((code==6) || (code==2)){ //integer
     4878                this->inputs->AddInput(new IntInput(name,(int)scalar));
     4879        }
     4880        else if ((code==7) || (code==3)){ //double
     4881                this->inputs->AddInput(new DoubleInput(name,(int)scalar));
     4882        }
     4883        else _error_("%s%i"," could not recognize nature of vector from code ",code);
     4884
     4885}
     4886/*}}}*/
     4887/*FUNCTION Penta::InputCreate(double* vector,int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){{{1*/
     4888void Penta::InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){//index into elements
     4889
     4890        /*Intermediaries*/
     4891        int    i,j,t;
     4892        int    penta_vertex_ids[6];
     4893        int    row;
     4894        double nodeinputs[6];
     4895        double time;
     4896        TransientInput* transientinput=NULL;
     4897               
     4898        /*Branch on type of vector: nodal or elementary: */
     4899        if(vector_type==1){ //nodal vector
     4900
     4901                /*Recover vertices ids needed to initialize inputs*/
     4902                for(i=0;i<6;i++){
     4903                        penta_vertex_ids[i]=(int)iomodel->elements[6*index+i]; //ids for vertices are in the elements array from Matlab
     4904                }
     4905
     4906                /*Are we in transient or static? */
     4907                if(iomodel->numberofvertices==M){
     4908
     4909                        /*create input values: */
     4910                        for(i=0;i<6;i++)nodeinputs[i]=(double)vector[penta_vertex_ids[i]-1];
     4911
     4912                        /*process units: */
     4913                        UnitConversion(&nodeinputs[0], 6 ,ExtToIuEnum, vector_enum);
     4914
     4915                        /*create static input: */
     4916                        this->inputs->AddInput(new PentaVertexInput(vector_enum,nodeinputs));
     4917                }
     4918                else if(iomodel->numberofvertices==(M+1)){
     4919                        /*create transient input: */
     4920                        for(t=0;t<N;t++){ //N is the number of times
     4921
     4922                                /*create input values: */
     4923                                for(i=0;i<6;i++){
     4924                                        row=penta_vertex_ids[i]-1;
     4925                                        nodeinputs[i]=(double)vector[N*row+t];
     4926                                }
     4927
     4928                                /*process units: */
     4929                                UnitConversion(&nodeinputs[0], 6 ,ExtToIuEnum, vector_enum);
     4930
     4931                                /*time? :*/
     4932                                time=(double)vector[(M-1)*N+t];
     4933
     4934                                if(t==0)transientinput=new TransientInput(vector_enum);
     4935                                transientinput->AddTimeInput(new PentaVertexInput(vector_enum,nodeinputs),time);
     4936                        }
     4937
     4938
     4939                }
     4940                else _error_("nodal vector is either numberofnodes, or numberofnodes+1 long");
     4941        }
     4942        else if(vector_type==2){ //element vector
     4943                /*Are we in transient or static? */
     4944                if(iomodel->numberofelements==M){
     4945
     4946                        /*static mode: create an input out of the element value: */
     4947
     4948                        if (code==5){ //boolean
     4949                                this->inputs->AddInput(new BoolInput(vector_enum,(bool)vector[i]));
     4950                        }
     4951                        else if (code==6){ //integer
     4952                                this->inputs->AddInput(new IntInput(vector_enum,(int)vector[i]));
     4953                        }
     4954                        else if (code==7){ //double
     4955                                this->inputs->AddInput(new DoubleInput(vector_enum,(double)vector[i]));
     4956                        }
     4957                        else _error_("%s%i"," could not recognize nature of vector from code ",code);
     4958                }
     4959                else {
     4960                        _error_("transient elementary inputs not supported yet!");
     4961                }
     4962        }
     4963
     4964}
     4965/*}}}*/
    48684966/*FUNCTION Penta::InputDepthAverageAtBase{{{1*/
    48694967void  Penta::InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum){
    … …  
    51035201        }
    51045202
    5105         //add as many inputs per element as requested:
    5106         if (iomodel->thickness) {
    5107                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->thickness[penta_vertex_ids[i]-1];
    5108                 this->inputs->AddInput(new PentaVertexInput(ThicknessEnum,nodeinputs));
    5109         }
    5110         if (iomodel->surface) {
    5111                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->surface[penta_vertex_ids[i]-1];
    5112                 this->inputs->AddInput(new PentaVertexInput(SurfaceEnum,nodeinputs));
    5113         }
    5114         if (iomodel->bed) {
    5115                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->bed[penta_vertex_ids[i]-1];
    5116                 this->inputs->AddInput(new PentaVertexInput(BedEnum,nodeinputs));
    5117         }
    5118         if (iomodel->drag_coefficient) {
    5119                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->drag_coefficient[penta_vertex_ids[i]-1];
    5120                 this->inputs->AddInput(new PentaVertexInput(DragCoefficientEnum,nodeinputs));
    5121 
    5122                 if (iomodel->drag_p) this->inputs->AddInput(new DoubleInput(DragPEnum,iomodel->drag_p[index]));
    5123                 if (iomodel->drag_q) this->inputs->AddInput(new DoubleInput(DragQEnum,iomodel->drag_q[index]));
    5124                 this->inputs->AddInput(new IntInput(DragTypeEnum,iomodel->drag_type));
    5125 
    5126         }
    5127         if (iomodel->basal_melting_rate) {
    5128                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->basal_melting_rate[penta_vertex_ids[i]-1]/iomodel->yts;
    5129                 this->inputs->AddInput(new PentaVertexInput(BasalMeltingRateEnum,nodeinputs));
    5130         }
    5131         if (iomodel->surface_accumulation_rate) {
    5132                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->surface_accumulation_rate[penta_vertex_ids[i]-1]/iomodel->yts;
    5133                 this->inputs->AddInput(new PentaVertexInput(SurfaceAccumulationRateEnum,nodeinputs));
    5134         }
    5135         if (iomodel->surface_ablation_rate) {
    5136                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->surface_ablation_rate[penta_vertex_ids[i]-1]/iomodel->yts;
    5137                 this->inputs->AddInput(new PentaVertexInput(SurfaceAblationRateEnum,nodeinputs));
    5138         }
    5139         if (iomodel->surface_mass_balance) {
    5140                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->surface_mass_balance[penta_vertex_ids[i]-1]/iomodel->yts;
    5141                 this->inputs->AddInput(new PentaVertexInput(SurfaceMassBalanceEnum,nodeinputs));
    5142         }
    5143         if (iomodel->geothermalflux) {
    5144                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->geothermalflux[penta_vertex_ids[i]-1];
    5145                 this->inputs->AddInput(new PentaVertexInput(GeothermalfluxEnum,nodeinputs));
    5146         }       
    5147         if (iomodel->pressure) {
    5148                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->pressure[penta_vertex_ids[i]-1];
    5149                 this->inputs->AddInput(new PentaVertexInput(PressureEnum,nodeinputs));
    5150         }
    5151         if (iomodel->temperature) {
    5152                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->temperature[penta_vertex_ids[i]-1];
    5153                 this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,nodeinputs));
    5154         }
    5155         if (iomodel->waterfraction) {
    5156                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->waterfraction[penta_vertex_ids[i]-1];
    5157                 this->inputs->AddInput(new PentaVertexInput(WaterfractionEnum,nodeinputs));
    5158         }
    5159         if (iomodel->dhdt) {
    5160                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->dhdt[penta_vertex_ids[i]-1]/iomodel->yts;
    5161                 this->inputs->AddInput(new PentaVertexInput(DhdtEnum,nodeinputs));
    5162         }
    5163         /*vx,vy and vz: */
    5164         if (iomodel->vx) {
    5165                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vx[penta_vertex_ids[i]-1]/iomodel->yts;
    5166                 this->inputs->AddInput(new PentaVertexInput(VxEnum,nodeinputs));
    5167                 this->inputs->AddInput(new PentaVertexInput(VxPicardEnum,nodeinputs));
    5168                 if(iomodel->qmu_analysis)this->inputs->AddInput(new PentaVertexInput(QmuVxEnum,nodeinputs));
    5169         }
    5170         if (iomodel->vy) {
    5171                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vy[penta_vertex_ids[i]-1]/iomodel->yts;
    5172                 this->inputs->AddInput(new PentaVertexInput(VyEnum,nodeinputs));
    5173                 this->inputs->AddInput(new PentaVertexInput(VyPicardEnum,nodeinputs));
    5174                 if(iomodel->qmu_analysis)this->inputs->AddInput(new PentaVertexInput(QmuVyEnum,nodeinputs));
    5175         }
    5176         if (iomodel->vz) {
    5177                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vz[penta_vertex_ids[i]-1]/iomodel->yts;
    5178                 this->inputs->AddInput(new PentaVertexInput(VzEnum,nodeinputs));
    5179                 this->inputs->AddInput(new PentaVertexInput(VzPicardEnum,nodeinputs));
    5180                 if(iomodel->qmu_analysis)this->inputs->AddInput(new PentaVertexInput(QmuVzEnum,nodeinputs));
    5181         }
    5182         if (iomodel->vx_obs) {
    5183                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vx_obs[penta_vertex_ids[i]-1]/iomodel->yts;
    5184                 this->inputs->AddInput(new PentaVertexInput(VxObsEnum,nodeinputs));
    5185         }
    5186         if (iomodel->vy_obs) {
    5187                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vy_obs[penta_vertex_ids[i]-1]/iomodel->yts;
    5188                 this->inputs->AddInput(new PentaVertexInput(VyObsEnum,nodeinputs));
    5189         }
    5190         if (iomodel->vz_obs) {
    5191                 for(i=0;i<6;i++)nodeinputs[i]=iomodel->vz_obs[penta_vertex_ids[i]-1]/iomodel->yts;
    5192                 this->inputs->AddInput(new PentaVertexInput(VzObsEnum,nodeinputs));
    5193         }
    5194         if (iomodel->elementoniceshelf) this->inputs->AddInput(new BoolInput(ElementOnIceShelfEnum,(IssmBool)iomodel->elementoniceshelf[index]));
    5195         if (iomodel->elementonbed) this->inputs->AddInput(new BoolInput(ElementOnBedEnum,(IssmBool)iomodel->elementonbed[index]));
    5196         if (iomodel->elementonwater) this->inputs->AddInput(new BoolInput(ElementOnWaterEnum,(IssmBool)iomodel->elementonwater[index]));
    5197         if (iomodel->elementonsurface) this->inputs->AddInput(new BoolInput(ElementOnSurfaceEnum,(IssmBool)iomodel->elementonsurface[index]));
    5198 
     5203       
    51995204        /*Control Inputs*/
    52005205        if (iomodel->control_analysis && iomodel->control_type){
    … …  
    65406545                                name==TemperatureEnum ||
    65416546                                name==DragCoefficientEnum ||
     6547                                name==DragTypeEnum ||
    65426548                                name==GradientEnum ||
    65436549                                name==OldGradientEnum  ||
    … …  
    66156621
    66166622        /*process units if requested: */
    6617         if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum,this->parameters);
     6623        if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum);
    66186624
    66196625        /*Assign output pointers:*/
    … …  
    66286634
    66296635        /*process units if requested: */
    6630         if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum,this->parameters);
     6636        if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum);
    66316637
    66326638        /*Assign output pointers:*/
    … …  
    66416647
    66426648        /*process units if requested: */
    6643         if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum,this->parameters);
     6649        if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum);
    66446650
    66456651        /*Assign output pointers:*/
    … …  
    66546660
    66556661        /*process units if requested: */
    6656         if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum,this->parameters);
     6662        if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum);
    66576663
    66586664        /*Assign output pointers:*/
    … …  
    66686674
    66696675        /*process units if requested: */
    6670         if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum,this->parameters);
     6676        if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum);
    66716677
    66726678        /*Assign output pointers:*/
    … …  
    66816687
    66826688        /*process units if requested: */
    6683         if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum,this->parameters);
     6689        if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum);
    66846690
    66856691        /*Assign output pointers:*/
    … …  
    66946700
    66956701        /*process units if requested: */
    6696         if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum,this->parameters);
     6702        if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum);
    66976703
    66986704        /*Assign output pointers:*/
    … …  
    67346740
    67356741        /*process units if requested: */
    6736         if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum,this->parameters);
     6742        if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum);
    67376743
    67386744        /*Assign output pointers:*/
    … …  
    67476753
    67486754        /*process units if requested: */
    6749         if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum,this->parameters);
     6755        if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum);
    67506756
    67516757        /*Assign output pointers:*/
    … …  
    67606766
    67616767        /*process units if requested: */
    6762         if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum,this->parameters);
     6768        if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum);
    67636769
    67646770        /*Assign output pointers:*/
    … …  
    67736779
    67746780        /*process units if requested: */
    6775         if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum,this->parameters);
     6781        if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum);
    67766782
    67776783        /*Assign output pointers:*/

  • issm/trunk/src/c/objects/Elements/Penta.h

    r8926 r8967  
    9595                void   GradjBbarStokes(Vec gradient);
    9696                int    Sid();
     97                void   InputArtificialNoise(int enum_type,double min, double max);
    9798                void   InputControlUpdate(double scalar,bool save_parameter);
    98                 void   InputArtificialNoise(int enum_type,double min, double max);
    9999                bool   InputConvergence(double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     100                void   InputCreate(double scalar,int name,int code);
     101                void   InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    100102                void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=ElementsEnum);
    101103                void   InputDuplicate(int original_enum,int new_enum);

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r8930 r8967  
    34683468        }
    34693469
    3470         /*add as many inputs per element as requested:*/
    3471         if (iomodel->thickness) {
    3472                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->thickness[tria_vertex_ids[i]-1];
    3473                 this->inputs->AddInput(new TriaVertexInput(ThicknessEnum,nodeinputs));
    3474         }
    3475         if (iomodel->thickness_coeff) {
    3476                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->thickness_coeff[tria_vertex_ids[i]-1];
    3477                 this->inputs->AddInput(new TriaVertexInput(ThicknessCoeffEnum,nodeinputs));
    3478         }
    3479         if (iomodel->surface) {
    3480                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->surface[tria_vertex_ids[i]-1];
    3481                 this->inputs->AddInput(new TriaVertexInput(SurfaceEnum,nodeinputs));
    3482         }
    3483         if (iomodel->bed) {
    3484                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->bed[tria_vertex_ids[i]-1];
    3485                 this->inputs->AddInput(new TriaVertexInput(BedEnum,nodeinputs));
    3486         }
    3487         if(iomodel->gl_migration!=NoneEnum){
    3488                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->bathymetry[tria_vertex_ids[i]-1];
    3489                 this->inputs->AddInput(new TriaVertexInput(BathymetryEnum,nodeinputs));
    3490         }
    3491         if (iomodel->drag_coefficient) {
    3492                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->drag_coefficient[tria_vertex_ids[i]-1];
    3493                 this->inputs->AddInput(new TriaVertexInput(DragCoefficientEnum,nodeinputs));
    3494 
    3495                 if (iomodel->drag_p) this->inputs->AddInput(new DoubleInput(DragPEnum,iomodel->drag_p[index]));
    3496                 if (iomodel->drag_q) this->inputs->AddInput(new DoubleInput(DragQEnum,iomodel->drag_q[index]));
    3497                 this->inputs->AddInput(new IntInput(DragTypeEnum,iomodel->drag_type));
    3498         }
    3499         if (iomodel->thickness_obs) {
    3500                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->thickness_obs[tria_vertex_ids[i]-1];
    3501                 this->inputs->AddInput(new TriaVertexInput(ThicknessObsEnum,nodeinputs));
    3502         }
    3503         if (iomodel->basal_melting_rate) {
    3504                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->basal_melting_rate[tria_vertex_ids[i]-1]/iomodel->yts;
    3505                 this->inputs->AddInput(new TriaVertexInput(BasalMeltingRateEnum,nodeinputs));
    3506         }
    3507         if (iomodel->basal_melting_rate_correction) {
    3508                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->basal_melting_rate_correction[tria_vertex_ids[i]-1]/iomodel->yts;
    3509                 this->inputs->AddInput(new TriaVertexInput(BasalMeltingRateCorrectionEnum,nodeinputs));
    3510         }
    3511         if (iomodel->watercolumn){
    3512                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->watercolumn[tria_vertex_ids[i]-1];
    3513                 this->inputs->AddInput(new TriaVertexInput(WatercolumnEnum,nodeinputs));
    3514                 this->inputs->AddInput(new TriaVertexInput(WaterColumnOldEnum,nodeinputs));
    3515         }
    3516         if (iomodel->surface_accumulation_rate) {
    3517                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->surface_accumulation_rate[tria_vertex_ids[i]-1]/iomodel->yts;
    3518                 this->inputs->AddInput(new TriaVertexInput(SurfaceAccumulationRateEnum,nodeinputs));
    3519         }
    3520         if (iomodel->surface_ablation_rate) {
    3521                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->surface_ablation_rate[tria_vertex_ids[i]-1]/iomodel->yts;
    3522                 this->inputs->AddInput(new TriaVertexInput(SurfaceAblationRateEnum,nodeinputs));
    3523         }
    3524         if (iomodel->surface_mass_balance) {
    3525                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->surface_mass_balance[tria_vertex_ids[i]-1]/iomodel->yts;
    3526                 this->inputs->AddInput(new TriaVertexInput(SurfaceMassBalanceEnum,nodeinputs));
    3527         }
    3528         if (iomodel->geothermalflux) {
    3529                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->geothermalflux[tria_vertex_ids[i]-1];
    3530                 this->inputs->AddInput(new TriaVertexInput(GeothermalfluxEnum,nodeinputs));
    3531         }
    3532         if (iomodel->dhdt){
    3533                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->dhdt[tria_vertex_ids[i]-1]/iomodel->yts;
    3534                 this->inputs->AddInput(new TriaVertexInput(DhdtEnum,nodeinputs));
    3535         }
    3536         if (iomodel->pressure){
    3537                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->pressure[tria_vertex_ids[i]-1];
    3538                 this->inputs->AddInput(new TriaVertexInput(PressureEnum,nodeinputs));
    3539         }
    3540         if (iomodel->temperature) {
    3541                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->temperature[tria_vertex_ids[i]-1];
    3542                 this->inputs->AddInput(new TriaVertexInput(TemperatureEnum,nodeinputs));
    3543         }
    3544         /*vx,vy and vz: */
    3545         if (iomodel->vx) {
    3546                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vx[tria_vertex_ids[i]-1]/iomodel->yts;
    3547                 this->inputs->AddInput(new TriaVertexInput(VxEnum,nodeinputs));
    3548                 this->inputs->AddInput(new TriaVertexInput(VxPicardEnum,nodeinputs));
    3549                 if(iomodel->qmu_analysis)this->inputs->AddInput(new TriaVertexInput(QmuVxEnum,nodeinputs));
    3550         }
    3551         if (iomodel->vy) {
    3552                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vy[tria_vertex_ids[i]-1]/iomodel->yts;
    3553                 this->inputs->AddInput(new TriaVertexInput(VyEnum,nodeinputs));
    3554                 this->inputs->AddInput(new TriaVertexInput(VyPicardEnum,nodeinputs));
    3555                 if(iomodel->qmu_analysis)this->inputs->AddInput(new TriaVertexInput(QmuVyEnum,nodeinputs));
    3556         }
    3557         if (iomodel->vz) {
    3558                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vz[tria_vertex_ids[i]-1]/iomodel->yts;
    3559                 this->inputs->AddInput(new TriaVertexInput(VzEnum,nodeinputs));
    3560                 this->inputs->AddInput(new TriaVertexInput(VzPicardEnum,nodeinputs));
    3561                 if(iomodel->qmu_analysis)this->inputs->AddInput(new TriaVertexInput(QmuVzEnum,nodeinputs));
    3562         }
    3563         if (iomodel->vx_obs) {
    3564                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vx_obs[tria_vertex_ids[i]-1]/iomodel->yts;
    3565                 this->inputs->AddInput(new TriaVertexInput(VxObsEnum,nodeinputs));
    3566         }
    3567         if (iomodel->vy_obs) {
    3568                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vy_obs[tria_vertex_ids[i]-1]/iomodel->yts;
    3569                 this->inputs->AddInput(new TriaVertexInput(VyObsEnum,nodeinputs));
    3570         }
    3571         if (iomodel->vz_obs) {
    3572                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->vz_obs[tria_vertex_ids[i]-1]/iomodel->yts;
    3573                 this->inputs->AddInput(new TriaVertexInput(VzObsEnum,nodeinputs));
    3574         }
    3575 
    3576         if (iomodel->elementoniceshelf) this->inputs->AddInput(new BoolInput(ElementOnIceShelfEnum,(IssmBool)iomodel->elementoniceshelf[index]));
    3577         if (iomodel->elementonbed) this->inputs->AddInput(new BoolInput(ElementOnBedEnum,(IssmBool)iomodel->elementonbed[index]));
    3578         if (iomodel->elementonwater) this->inputs->AddInput(new BoolInput(ElementOnWaterEnum,(IssmBool)iomodel->elementonwater[index]));
    3579         if (iomodel->elementonsurface) this->inputs->AddInput(new BoolInput(ElementOnSurfaceEnum,(IssmBool)iomodel->elementonsurface[index]));
    3580 
    35813470        /*Control Inputs*/
    35823471        if (iomodel->control_analysis && iomodel->control_type){
    … …  
    41684057}
    41694058/*}}}*/
     4059/*FUNCTION Tria::InputCreate(double scalar,int enum,int code);{{{1*/
     4060void Tria::InputCreate(double scalar,int name,int code){
     4061
     4062        /*Check that name is an element input*/
     4063        if (!IsInput(name)) return;
     4064       
     4065        if ((code==5) || (code==1)){ //boolean
     4066                this->inputs->AddInput(new BoolInput(name,(bool)scalar));
     4067        }
     4068        else if ((code==6) || (code==2)){ //integer
     4069                this->inputs->AddInput(new IntInput(name,(int)scalar));
     4070        }
     4071        else if ((code==7) || (code==3)){ //double
     4072                this->inputs->AddInput(new DoubleInput(name,(int)scalar));
     4073        }
     4074        else _error_("%s%i"," could not recognize nature of vector from code ",code);
     4075
     4076}
     4077/*}}}*/
     4078/*FUNCTION Tria::InputCreate(double* vector,int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){{{1*/
     4079void Tria::InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){//index into elements
     4080
     4081        /*Intermediaries*/
     4082        int    i,j,t;
     4083        int    tria_vertex_ids[3];
     4084        int    row;
     4085        double nodeinputs[3];
     4086        double time;
     4087               
     4088        TransientInput* transientinput=NULL;
     4089
     4090        /*Branch on type of vector: nodal or elementary: */
     4091        if(vector_type==1){ //nodal vector
     4092
     4093                /*Recover vertices ids needed to initialize inputs*/
     4094                for(i=0;i<3;i++){
     4095                        tria_vertex_ids[i]=(int)iomodel->elements[3*index+i]; //ids for vertices are in the elements array from Matlab
     4096                }
     4097
     4098                /*Are we in transient or static? */
     4099                if(iomodel->numberofvertices==M){
     4100
     4101                        /*create input values: */
     4102                        for(i=0;i<3;i++)nodeinputs[i]=(double)vector[tria_vertex_ids[i]-1];
     4103
     4104                        /*process units: */
     4105                        UnitConversion(&nodeinputs[0], 3 ,ExtToIuEnum, vector_enum);
     4106
     4107                        /*create static input: */
     4108                        this->inputs->AddInput(new TriaVertexInput(vector_enum,nodeinputs));
     4109                }
     4110                else if(iomodel->numberofvertices==(M+1)){
     4111                        /*create transient input: */
     4112                        for(t=0;t<N;t++){ //N is the number of times
     4113
     4114                                /*create input values: */
     4115                                for(i=0;i<3;i++){
     4116                                        row=tria_vertex_ids[i]-1;
     4117                                        nodeinputs[i]=(double)vector[N*row+t];
     4118                                }
     4119
     4120                                /*process units: */
     4121                                UnitConversion(&nodeinputs[0], 3 ,ExtToIuEnum, vector_enum);
     4122
     4123                                /*time? :*/
     4124                                time=(double)vector[(M-1)*N+t];
     4125
     4126                                if(t==0)transientinput=new TransientInput(vector_enum);
     4127                                transientinput->AddTimeInput(new TriaVertexInput(vector_enum,nodeinputs),time);
     4128                        }
     4129
     4130
     4131                }
     4132                else _error_("nodal vector is either numberofnodes, or numberofnodes+1 long");
     4133        }
     4134        else if(vector_type==2){ //element vector
     4135                /*Are we in transient or static? */
     4136                if(iomodel->numberofelements==M){
     4137
     4138                        /*static mode: create an input out of the element value: */
     4139
     4140                        if (code==5){ //boolean
     4141                                this->inputs->AddInput(new BoolInput(vector_enum,(bool)vector[i]));
     4142                        }
     4143                        else if (code==6){ //integer
     4144                                this->inputs->AddInput(new IntInput(vector_enum,(int)vector[i]));
     4145                        }
     4146                        else if (code==7){ //double
     4147                                this->inputs->AddInput(new DoubleInput(vector_enum,(double)vector[i]));
     4148                        }
     4149                        else _error_("%s%i"," could not recognize nature of vector from code ",code);
     4150                }
     4151                else {
     4152                        _error_("transient elementary inputs not supported yet!");
     4153                }
     4154        }
     4155
     4156}
     4157/*}}}*/
    41704158/*FUNCTION Tria::IsInput{{{1*/
    41714159bool Tria::IsInput(int name){
    … …  
    41864174                                name==DragCoefficientEnum ||
    41874175                                name==GradientEnum ||
     4176                                name==DragTypeEnum ||
    41884177                                name==OldGradientEnum
    41894178                ){
    … …  
    43024291
    43034292        /*Process units: */
    4304         mass_flux=UnitConversion(mass_flux,IuToExtEnum,MassFluxEnum,this->parameters);
     4293        mass_flux=UnitConversion(mass_flux,IuToExtEnum,MassFluxEnum);
    43054294
    43064295        /*clean up and return:*/
    … …  
    43174306
    43184307        /*process units if requested: */
    4319         if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum,this->parameters);
     4308        if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum);
    43204309
    43214310        /*Assign output pointers:*/
    … …  
    43304319
    43314320        /*process units if requested: */
    4332         if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum,this->parameters);
     4321        if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum);
    43334322
    43344323        /*Assign output pointers:*/
    … …  
    43434332
    43444333        /*process units if requested: */
    4345         if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum,this->parameters);
     4334        if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum);
    43464335
    43474336        /*Assign output pointers:*/
    … …  
    43564345
    43574346        /*process units if requested: */
    4358         if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum,this->parameters);
     4347        if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum);
    43594348
    43604349        /*Assign output pointers:*/
    … …  
    43694358
    43704359        /*process units if requested: */
    4371         if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum,this->parameters);
     4360        if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum);
    43724361
    43734362        /*Assign output pointers:*/
    … …  
    43824371
    43834372        /*process units if requested: */
    4384         if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum,this->parameters);
     4373        if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum);
    43854374
    43864375        /*Assign output pointers:*/
    … …  
    43964385
    43974386        /*process units if requested: */
    4398         if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum,this->parameters);
     4387        if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum);
    43994388
    44004389        /*Assign output pointers:*/
    … …  
    44844473
    44854474        /*process units if requested: */
    4486         if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum,this->parameters);
     4475        if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum);
    44874476
    44884477        /*Assign output pointers:*/
    … …  
    44974486
    44984487        /*process units if requested: */
    4499         if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum,this->parameters);
     4488        if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum);
    45004489
    45014490        /*Assign output pointers:*/
    … …  
    45104499
    45114500        /*process units if requested: */
    4512         if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum,this->parameters);
     4501        if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum);
    45134502
    45144503        /*Assign output pointers:*/
    … …  
    45234512
    45244513        /*process units if requested: */
    4525         if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum,this->parameters);
     4514        if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum);
    45264515
    45274516        /*Assign output pointers:*/
    … …  
    48884877                misfit=0.5*( pow(vx-vxobs,2.) + pow(vy-vyobs,2.) );
    48894878
    4890                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum,this->parameters);
     4879                if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
    48914880
    48924881                /*Add to cost function*/
    … …  
    49784967                misfit=1/S*pow( pow(vx-vxobs,2.) + pow(vy-vyobs,2.) ,0.5);
    49794968
    4980                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum,this->parameters);
     4969                if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
    49814970
    49824971                /*Add to cost function*/
    … …  
    50435032                misfit=4*pow(meanvel,2.)*pow(log(velocity_mag/obs_velocity_mag),2.);
    50445033
    5045                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVelMisfitEnum,this->parameters);
     5034                if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVelMisfitEnum);
    50465035
    50475036                /*Add to cost function*/
    … …  
    51095098                                        pow(log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)),2.) );
    51105099
    5111                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVxVyMisfitEnum,this->parameters);
     5100                if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVxVyMisfitEnum);
    51125101
    51135102                /*Add to cost function*/
    … …  
    51975186                scaley=pow(meanvel/(vyobs+epsvel),2.); if(vyobs==0)scaley=0;
    51985187                misfit=0.5*(scalex*pow((vx-vxobs),2.)+scaley*pow((vy-vyobs),2.));
    5199                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceRelVelMisfitEnum,this->parameters);
     5188                if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceRelVelMisfitEnum);
    52005189
    52015190                /*Add to cost function*/

  • issm/trunk/src/c/objects/Elements/Tria.h

    r8926 r8967  
    9797                void   GradjVxBalancedthickness(Vec gradient);
    9898                void   GradjVyBalancedthickness(Vec gradient);
     99                void   InputArtificialNoise(int enum_type,double min, double max);
    99100                void   InputControlUpdate(double scalar,bool save_parameter);
    100                 void   InputArtificialNoise(int enum_type,double min, double max);
    101101                bool   InputConvergence(double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     102                void   InputCreate(double scalar,int name,int code);
     103                void   InputCreate(double* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    102104                void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=ElementsEnum);
    103105                void   InputDuplicate(int original_enum,int new_enum);

  • issm/trunk/src/c/objects/Inputs/Input.h

    r8592 r8967  
    6464                virtual Input* PointwiseMin(Input* inputmin)=0;
    6565                virtual ElementResult* SpawnResult(int step, double time)=0;
    66                 virtual void AddTimeValues(double* values,int step,double time)=0;
    6766
    6867                /*}}}*/

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r8363 r8967  
    399399
    400400        /*Process units if requested: */
    401         if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type,parameters);
     401        if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type);
    402402
    403403        /*Now, figure out minimum of valuescopy: */

  • issm/trunk/src/c/objects/Inputs/TransientInput.cpp

    r8791 r8967  
    2222TransientInput::TransientInput(){
    2323
    24    enum_type=UNDEF;
     24        enum_type=UNDEF;
    2525        inputs=NULL;
    2626        this->numtimesteps=0;
    … …  
    5454}
    5555/*}}}*/
    56 /*FUNCTION TransientInput::AddTimeInput(double* values,int step,double time);{{{1*/
     56/*FUNCTION void TransientInput::AddTimeInput(Input* input,double time){{{1*/
    5757void TransientInput::AddTimeInput(Input* input,double time){
    5858

  • issm/trunk/src/c/objects/Inputs/TransientInput.h

    r8757 r8967  
    2727                TransientInput(int enum_type);
    2828                ~TransientInput();
    29                 void AddTimeValues(double* values,int step,double time){_error_("not implemented yet");};
    3029                void AddTimeInput(Input* input,double time);
    3130                /*}}}*/

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r8363 r8967  
    250250
    251251        /*Process units if requested: */
    252         if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type,parameters);
     252        if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type);
    253253
    254254        /*Now, figure out minimum of valuescopy: */

  • issm/trunk/src/c/objects/Materials/Matice.cpp

    r8947 r8967  
    593593                                        for (int i=0;i<3;i++) values[i]=vector[((Tria*)element)->nodes[i]->GetSidList()]; //use sid list, to index into serial oriented vector
    594594                                        this->inputs->AddInput(new TriaVertexInput(name,values));
    595                                         /*Special case for rheology B in 2D: Pourave land for this solution{{{1*/
     595                                        /*Special case for rheology B in 2D: Pourave land for this solution{{{2*/
    596596                                        if(name==RheologyBEnum){
    597597                                                /*Are we in 2D?:*/

  • issm/trunk/src/c/shared/Numerics/UnitConversion.cpp

    r8926 r8967  
    1515#include "../../shared/shared.h"
    1616
    17 double UnitConversionScaleFactor(int type_enum,Parameters* parameters);
     17double UnitConversionScaleFactor(int type_enum);
    1818/*}}}*/
    1919
    20 void UnitConversion(double* values, int numvalues,int direction_enum, int type_enum, Parameters* parameters){
     20void UnitConversion(double* values, int numvalues,int direction_enum, int type_enum){
    2121
    2222        double scale;
    … …  
    2424
    2525        /*Get scaling factor: */
    26         scale=UnitConversionScaleFactor(type_enum,parameters);
     26        scale=UnitConversionScaleFactor(type_enum);
    2727
    2828        /*Now, which direction are we going? once determined, use scale factor: */
    … …  
    3333}
    3434
    35 double UnitConversion(double value, int direction_enum, int type_enum, Parameters* parameters){
     35double UnitConversion(double value, int direction_enum, int type_enum){
    3636
    37         double scale;
    38 
    39         /*Get scaling factor: */
    40         scale=UnitConversionScaleFactor(type_enum,parameters);
    41 
    42         /*Now, which direction are we going? once determined, use scale factor: */
    43         if(direction_enum==IuToExtEnum)value=value*scale;
    44         else if(direction_enum==ExtToIuEnum)value=value/scale;
    45         else _error_(" wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
     37        UnitConversion(&value,1,direction_enum,type_enum);
    4638
    4739        return value;
    … …  
    4941
    5042
     43double UnitConversionScaleFactor(int type_enum){
    5144
    52 double UnitConversionScaleFactor(int type_enum,Parameters* parameters){
    53 
    54         double yts;
     45        double yts=365.0*24.0*3600.0;
    5546       
    56         /*Get some values from parameters, that are often needed: */
    57         parameters->FindParam(&yts,YtsEnum);
    58 
    5947        double scale;
    6048        switch(type_enum){

  • issm/trunk/src/c/shared/Numerics/numerics.h

    r8224 r8967  
    2626double norm(double* vector);
    2727void IsInputConverged(double* peps, Input** new_inputs,Input** old_inputs,int num_inputs,int criterion_enum);
    28 void UnitConversion(double* values, int numvalues,int direction_enum, int type_enum, Parameters* parameters);
    29 double UnitConversion(double value, int direction_enum, int type_enum, Parameters* parameters);
     28void UnitConversion(double* values, int numvalues,int direction_enum, int type_enum);
     29double UnitConversion(double value, int direction_enum, int type_enum);
    3030void PetscOptionsFromAnalysis(Parameters* parameters,int analysis_type);
    3131

  • issm/trunk/src/m/classes/model.m

    r8962 r8967  
    1111
    1212                 %in what follows, any field is defined according to the following convention:
    13                  %field={defaultvalue,ismarshalled,type}
     13                 %field={defaultvalue,marshall?,data type,matrix type}
    1414
    1515                 %Model general information
    … …  
    3131                 numberofelements={0,true,'Integer'};
    3232                 numberofnodes={0,true,'Integer'};
    33                  elements={NaN,true,'Mat'};
    34                  elements_type={NaN,true,'Mat'};
    35                  vertices_type={NaN,true,'Mat'};
    36                  x={NaN,true,'Mat'};
    37                  y={NaN,true,'Mat'};
    38                  z={NaN,true,'Mat'};
     33                 elements={NaN,true,'DoubleMat',2};
     34                 elements_type={NaN,true,'DoubleMat',2};
     35                 vertices_type={NaN,true,'DoubleMat',1};
     36                 x={NaN,true,'DoubleMat',1};
     37                 y={NaN,true,'DoubleMat',1};
     38                 z={NaN,true,'DoubleMat',1};
    3939                 bed_slopex={NaN,false};
    4040                 bed_slopey={NaN,false};
    … …  
    4242                 surface_slopey={NaN,false};
    4343                 nodeconnectivity={NaN,false};
    44                  elementconnectivity={NaN,true,'Mat'};
    45                  edges={NaN,true,'Mat'};
     44                 elementconnectivity={NaN,true,'DoubleMat',3};
     45                 edges={NaN,true,'DoubleMat',3};
    4646
    4747                 %I/O
    … …  
    5151                 numberofelements2d={0,true,'Integer'};
    5252                 numberofnodes2d={0,true,'Integer'};
    53                  elements2d={NaN,true,'Mat'};
     53                 elements2d={NaN,true,'DoubleMat',3};
    5454                 elements_type2d={NaN,false};
    5555                 vertices_type2d={NaN,false};
    … …  
    7575
    7676                 %Nodes
    77                  nodeonhutter={NaN,true,'Mat'};
    78                  nodeonmacayeal={NaN,true,'Mat'};
    79                  nodeonpattyn={NaN,true,'Mat'};
    80                  nodeonstokes={NaN,true,'Mat'};
    81                  borderstokes={NaN,true,'Mat'};
     77                 nodeonhutter={NaN,true,'DoubleMat',1};
     78                 nodeonmacayeal={NaN,true,'DoubleMat',1};
     79                 nodeonpattyn={NaN,true,'DoubleMat',1};
     80                 nodeonstokes={NaN,true,'DoubleMat',1};
     81                 borderstokes={NaN,true,'DoubleMat',3};
    8282
    8383                 %Stokes
    84                  stokesreconditioning={0,true,'Scalar'};
     84                 stokesreconditioning={0,true,'Double'};
    8585                 shelf_dampening={0,true,'Integer'};
    8686
    8787                 %Penalties
    88                  penalties={NaN,true,'Mat'};
    89                  penalty_offset={0,true,'Scalar'};
    90                  penalty_melting={0,true,'Scalar'};
     88                 penalties={NaN,true,'DoubleMat',3};
     89                 penalty_offset={0,true,'Double'};
     90                 penalty_melting={0,true,'Double'};
    9191                 penalty_lock={0,true,'Integer'};
    9292                 segments={NaN,false};
    9393                 segmentmarkers={NaN,false};
    9494                 rifts={NaN,false};
    95                  riftinfo={NaN,true,'Mat'};
     95                 riftinfo={NaN,true,'DoubleMat',3};
    9696                 riftproperties={NaN,false};
    9797                 numrifts={0,false};
    … …  
    9999                 %Projections
    100100                 uppernodes={NaN,false};
    101                  upperelements={NaN,true,'Mat'};
    102                  lowerelements={NaN,true,'Mat'};
     101                 upperelements={NaN,true,'DoubleMat',2};
     102                 lowerelements={NaN,true,'DoubleMat',2};
    103103                 lowernodes={NaN,false};
    104104
    … …  
    106106                 numlayers={0,true,'Integer'};
    107107                 extrusionexponent={0,false};
    108                  elementonbed={NaN,true,'Mat'};
    109                  elementonsurface={NaN,true,'Mat'};
    110                  nodeonbed={NaN,true,'Mat'};
    111                  nodeonsurface={NaN,true,'Mat'};
     108                 elementonbed={NaN,true,'DoubleMat',2};
     109                 elementonsurface={NaN,true,'DoubleMat',2};
     110                 nodeonbed={NaN,true,'DoubleMat',1};
     111                 nodeonsurface={NaN,true,'DoubleMat',1};
    112112                 minh={0,false};
    113113                 firn_layer={NaN,false};
    … …  
    118118
    119119                 %Materials parameters
    120                  rho_ice={0,true,'Scalar'};
    121                  rho_water={0,true,'Scalar'};
     120                 rho_ice={0,true,'Double'};
     121                 rho_water={0,true,'Double'};
    122122                 rho_firn={0,false};
    123                  heatcapacity={0,true,'Scalar'};
    124                  latentheat={0,true,'Scalar'};
    125                  thermalconductivity={0,true,'Scalar'};
    126                  meltingpoint={0,true,'Scalar'};
    127                  referencetemperature={0,true,'Scalar'}; %for enthalpy
    128                  beta={0,true,'Scalar'};
     123                 heatcapacity={0,true,'Double'};
     124                 latentheat={0,true,'Double'};
     125                 thermalconductivity={0,true,'Double'};
     126                 meltingpoint={0,true,'Double'};
     127                 referencetemperature={0,true,'Double'}; %for enthalpy
     128                 beta={0,true,'Double'};
    129129                 
    130                  mixed_layer_capacity={0,true,'Scalar'};
    131                  thermal_exchange_velocity={0,true,'Scalar'};
     130                 mixed_layer_capacity={0,true,'Double'};
     131                 thermal_exchange_velocity={0,true,'Double'};
    132132                 min_thermal_constraints={0,true,'Integer'};
    133133                 min_mechanical_constraints={0,true,'Integer'};
    … …  
    135135
    136136                 %Physical parameters
    137                  g={0,true,'Scalar'};
    138                  yts={0,true,'Scalar'};
     137                 g={0,true,'Double'};
     138                 yts={0,true,'Double'};
    139139                 drag_type={0,true,'Integer'};
    140                  drag_coefficient={NaN,true,'Mat'};
    141                  drag_p={NaN,true,'Mat'};
    142                  drag_q={NaN,true,'Mat'};
    143                  rheology_B={NaN,true,'Mat'};
    144                  rheology_n={NaN,true,'Mat'};
     140                 drag_coefficient={NaN,true,'DoubleMat',1};
     141                 drag_p={NaN,true,'DoubleMat',2};
     142                 drag_q={NaN,true,'DoubleMat',2};
     143                 rheology_B={NaN,true,'DoubleMat',1};
     144                 rheology_n={NaN,true,'DoubleMat',2};
    145145                 rheology_law={0,true,'Integer'};
    146146
    147147                 %Geometrical parameters
    148                  elementoniceshelf={NaN,true,'Mat'};
    149                  elementonicesheet={NaN,true,'Mat'};
    150                  elementonwater={NaN,true,'Mat'};
    151                  elementonnuna={NaN,false};
    152                  nodeoniceshelf={NaN,true,'Mat'};
    153                  nodeonicesheet={NaN,true,'Mat'};
    154                  nodeonwater={NaN,true,'Mat'};
     148                 elementoniceshelf={NaN,true,'BooleanMat',2};
     149                 elementonicesheet={NaN,true,'BooleanMat',2};
     150                 elementonwater={NaN,true,'BooleanMat',2};
     151                 elementonnuna={NaN,false,'BooleanMat',2};
     152                 nodeoniceshelf={NaN,true,'DoubleMat',1};
     153                 nodeonicesheet={NaN,true,'DoubleMat',1};
     154                 nodeonwater={NaN,true,'DoubleMat',1};
    155155                 nodeonnuna={NaN,false};
    156                  surface={NaN,true,'Mat'};
    157                  thickness={NaN,true,'Mat'};
    158                  thickness_coeff={NaN,true,'Mat'};
    159                  bed={NaN,true,'Mat'};
    160                  bathymetry={NaN,true,'Mat'};
     156                 surface={NaN,true,'DoubleMat',1};
     157                 thickness={NaN,true,'DoubleMat',1};
     158                 thickness_coeff={NaN,true,'DoubleMat',1};
     159                 bed={NaN,true,'DoubleMat',1};
     160                 bathymetry={NaN,true,'DoubleMat',1};
    161161                 mask={NaN,false};
    162162
    163163                 %Boundary conditions
    164164                 nodeonboundary={NaN,false};
    165                  pressureload={NaN,true,'Mat'};
    166                  spcvx={NaN,true,'Mat'};
    167                  spcvy={NaN,true,'Mat'};
    168                  spcvz={NaN,true,'Mat'};
    169                  spctemperature={NaN,true,'Mat'};
    170                  spcthickness={NaN,true,'Mat'};
    171                  spcwatercolumn={NaN,true,'Mat'};
    172                  diagnostic_ref={NaN,true,'Mat'};
     165                 pressureload={NaN,true,'DoubleMat',3};
     166                 spcvx={NaN,true,'DoubleMat',1};
     167                 spcvy={NaN,true,'DoubleMat',1};
     168                 spcvz={NaN,true,'DoubleMat',1};
     169                 spctemperature={NaN,true,'DoubleMat',1};
     170                 spcthickness={NaN,true,'DoubleMat',1};
     171                 spcwatercolumn={NaN,true,'DoubleMat',1};
     172                 diagnostic_ref={NaN,true,'DoubleMat',1};
    173173
    174174                 %Observations
    175                  vx_obs={NaN,true,'Mat'};
    176                  vy_obs={NaN,true,'Mat'};
     175                 vx_obs={NaN,true,'DoubleMat',1};
     176                 vy_obs={NaN,true,'DoubleMat',1};
    177177                 vel_obs={NaN,false};
    178178                 vx_obs_raw={NaN,false};
    … …  
    182182                 vel_bal={NaN,false};
    183183                 vel_obs_raw={NaN,false};
    184                  surface_accumulation_rate={NaN,true,'Mat'};
    185                  surface_ablation_rate={NaN,true,'Mat'};
    186                  surface_mass_balance={NaN,true,'Mat'};
    187                  dhdt={NaN,true,'Mat'};
    188                  geothermalflux={NaN,true,'Mat'};
     184                 surface_accumulation_rate={NaN,true,'DoubleMat',1};
     185                 surface_ablation_rate={NaN,true,'DoubleMat',1};
     186                 surface_mass_balance={NaN,true,'DoubleMat',1};
     187                 dhdt={NaN,true,'DoubleMat',1};
     188                 geothermalflux={NaN,true,'DoubleMat',1};
    189189                 observed_temperature={NaN,false};
    190                  thickness_obs={NaN,true,'Mat'};
     190                 thickness_obs={NaN,true,'DoubleMat',1};
    191191
    192192                 %Forcings
    … …  
    194194
    195195                 %Statics parameters
    196                  eps_res={0,true,'Scalar'};
    197                  eps_rel={0,true,'Scalar'};
    198                  eps_abs={0,true,'Scalar'};
    199                  max_nonlinear_iterations={0,true,'Scalar'};
    200                  sparsity={0,true,'Scalar'};
     196                 eps_res={0,true,'Double'};
     197                 eps_rel={0,true,'Double'};
     198                 eps_abs={0,true,'Double'};
     199                 max_nonlinear_iterations={0,true,'Double'};
     200                 sparsity={0,true,'Double'};
    201201                 connectivity={0,true,'Integer'};
    202202                 lowmem={0,true,'Integer'};
    203                  viscosity_overshoot={0,true,'Scalar'};
     203                 viscosity_overshoot={0,true,'Double'};
    204204
    205205                 %Transient parameters
    206                  dt={0,true,'Scalar'};
    207                  ndt={0,true,'Scalar'};
     206                 dt={0,true,'Double'};
     207                 ndt={0,true,'Double'};
    208208                 time_adapt={0,true,'Integer'};
    209                  cfl_coefficient={1/2,true,'Scalar'};
     209                 cfl_coefficient={1/2,true,'Double'};
    210210                 adaptative_cfl={0,false};
    211211                 artificial_diffusivity={0,true,'Integer'};
    … …  
    226226                 %Control
    227227                 control_analysis={0,true,'Integer'};
    228                  control_type={0,true,'Mat'};
    229                  weights={[],true,'Mat'};
     228                 control_type={0,true,'DoubleMat',3};
     229                 weights={[],true,'DoubleMat',1};
    230230                 nsteps={0,true,'Integer'};
    231                  maxiter={[],true,'Mat'};
    232                  cm_responses={[],true,'Mat'};
    233                  tolx={0,true,'Scalar'};
    234                  optscal={[],true,'Mat'};
    235                  eps_cm={0,true,'Scalar'};
    236                  cm_min={NaN,true,'Mat'};
    237                  cm_max={NaN,true,'Mat'};
    238                  cm_jump={[],true,'Mat'};
     231                 maxiter={[],true,'DoubleMat',3};
     232                 cm_responses={[],true,'DoubleMat',3};
     233                 tolx={0,true,'Double'};
     234                 optscal={[],true,'DoubleMat',3};
     235                 eps_cm={0,true,'Double'};
     236                 cm_min={NaN,true,'DoubleMat',3};
     237                 cm_max={NaN,true,'DoubleMat',3};
     238                 cm_jump={[],true,'DoubleMat',3};
    239239                 cm_gradient={0,true,'Integer'};
    240                  epsvel={0,true,'Scalar'};
    241                  meanvel={0,true,'Scalar'};
     240                 epsvel={0,true,'Double'};
     241                 meanvel={0,true,'Double'};
    242242                 num_control_type={0,true,'Integer'};
    243243                 num_cm_responses={0,true,'Integer'};
    … …  
    267267                 outputfilename={'',true,'String'};
    268268                 results={struct(),false};
    269                  vx={NaN,true,'Mat'};
    270                  vy={NaN,true,'Mat'};
    271                  vz={NaN,true,'Mat'};
     269                 vx={NaN,true,'DoubleMat',1};
     270                 vy={NaN,true,'DoubleMat',1};
     271                 vz={NaN,true,'DoubleMat',1};
    272272                 vel={NaN,false};
    273                  temperature={NaN,true,'Mat'}; %temperature solution vector
    274                  waterfraction={NaN,true,'Mat'};
    275                  gl_melting_rate={NaN,true,'Scalar'};
    276                  basal_melting_rate={NaN,true,'Mat'};
    277                  basal_melting_rate_correction={NaN,true,'Mat'};
     273                 temperature={NaN,true,'DoubleMat',1}; %temperature solution vector
     274                 waterfraction={NaN,true,'DoubleMat',1};
     275                 gl_melting_rate={NaN,true,'Double'};
     276                 basal_melting_rate={NaN,true,'DoubleMat',1};
     277                 basal_melting_rate_correction={NaN,true,'DoubleMat',1};
    278278                 basal_melting_rate_correction_apply={0,true,'Integer'};
    279                  pressure={NaN,true,'Mat'};
     279                 pressure={NaN,true,'DoubleMat',1};
    280280                 
    281281                 %hydrology
    282                  watercolumn={NaN,true,'Scalar'};
    283                  hydro_n={0,true,'Scalar'};
    284                  hydro_CR={0,true,'Scalar'};
    285                  hydro_p={0,true,'Scalar'};
    286                  hydro_q={0,true,'Scalar'};
    287                  hydro_kn={0,true,'Scalar'};
     282                 watercolumn={NaN,true,'Double'};
     283                 hydro_n={0,true,'Double'};
     284                 hydro_CR={0,true,'Double'};
     285                 hydro_p={0,true,'Double'};
     286                 hydro_q={0,true,'Double'};
     287                 hydro_kn={0,true,'Double'};
    288288                 
    289289                 %Parallelisation parameters
    … …  
    292292                 errlog={'',false};
    293293                 alloc_cleanup={1,false};
    294                  waitonlock={0,true,'Scalar'};
     294                 waitonlock={0,true,'Double'};
    295295
    296296                 %mesh2grid
    … …  
    332332                 dakotadat={'',false};
    333333                 qmu_analysis={0,true,'Integer'};
    334                  part={[],true,'Mat'};
     334                 part={[],true,'DoubleMat',2};
    335335                 npart={0,true,'Integer'};
    336336                 numberofvariables={0,true,'Integer'};

  • issm/trunk/src/m/model/WriteData.m

    r8938 r8967  
    1 function WriteData(fid,data,data_type,enum)
    2 %WRITEDATA - ...
     1function WriteData(md,fid,template,field)
     2%WRITEDATA
    33%
    44%   Usage:
    5 %      WriteData(fid,data,data_type,enum)
     5%      WriteData(md,fid,template,field)
    66%
    7 %   Eg: WriteData(fid,md.elementoniceshelf,'Mat',ElementOnIceShelfEnum);
     7%   Eg: WriteData(md,fid,template,'thickness')
     8
     9
     10%first recover data, enum of the data and type of data
     11data=md.(field);
     12enum=BuildEnum(field);
     13data_type=template.(field){3};
    814
    915if issparse(data),
    … …  
    1117end
    1218
    13 %Ok! put the length of the name, and the "name" string first!
     19%Ok! write the enum (name) to identify this record uniquely
    1420fwrite(fid,enum,'int');
    1521
    16 if strcmpi(data_type,'String'),
    17         %first write length of record
    18         fwrite(fid,length(data)+4,'int');  %4 for int32
     22%Now, write the data itself.
     23
     24if     strcmpi(data_type,'Boolean'),%{{{
     25        %first write length of record
     26        fwrite(fid,1+4,'int');  %1 bool+code
     27
     28        %write data code:
     29        fwrite(fid,TypeToCode(data_type),'int');
     30
     31        %now write integer
     32        fwrite(fid,data,'uint');
     33        %}}}
     34elseif strcmpi(data_type,'Integer'), %{{{
     35        %first write length of record
     36        fwrite(fid,4+4,'int');  %1 integer + code
     37
     38        %write data code:
     39        fwrite(fid,TypeToCode(data_type),'int');
     40
     41        %now write integer
     42        fwrite(fid,data,'int');
     43        %}}}
     44elseif strcmpi(data_type,'Double'), %{{{
     45        %first write length of record
     46        fwrite(fid,8+4,'int');  %1 double+code
     47
     48        %write data code:
     49        fwrite(fid,TypeToCode(data_type),'int');
     50
     51        %now write double
     52        fwrite(fid,data,'double');
     53        %}}}
     54elseif strcmpi(data_type,'String'), %{{{
     55        %first write length of record
     56        fwrite(fid,length(data)+4+4,'int');  %string + string size + code
     57
     58        %write data code:
     59        fwrite(fid,TypeToCode(data_type),'int');
     60
    1961        %now write string
    2062        fwrite(fid,length(data),'int');
    2163        fwrite(fid,data,'char');
    22 elseif strcmpi(data_type,'Mat'),
     64        %}}}
     65elseif strcmpi(data_type,'BooleanMat'), %{{{
     66
     67        %matrix type:
     68        mattype=template.(field){4};
     69
    2370        %Get size
    2471        s=size(data);
    … …  
    2976       
    3077        %first write length of record
    31         fwrite(fid,4+4+8*s(1)*s(2),'int');  %2 integers (32 bits) + the double matrix
     78        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
     79
     80        %write data code and matrix type:
     81        fwrite(fid,TypeToCode(data_type),'int');
     82        fwrite(fid,mattype,'int');
    3283
    3384        %now write matrix
    … …  
    3788                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
    3889        end
    39 elseif strcmpi(data_type,'Integer'),
    40         %first write length of record
    41         fwrite(fid,4,'int');  %1 integer
    42 
    43         %now write integer
    44         fwrite(fid,data,'int');
    45 elseif strcmpi(data_type,'Scalar'),
    46         %first write length of record
    47         fwrite(fid,8,'int');  %1 double
    48         %now write double
    49         fwrite(fid,data,'double');
    50 elseif strcmpi(data_type,'StringArray'),
    51 
    52         %first get length of string array:
    53         num=numel(data);
    54         %now get length of record:
    55         recordlength=4; %for length of array
    56         for i=1:num,
    57                 string=data{i};
    58                 recordlength=recordlength+4+length(string); %for each string
    59         end
    60 
    61         %write length of record
    62         fwrite(fid,recordlength,'int');
    63 
    64         %now write length of string array
    65         fwrite(fid,num,'int');
    66        
    67         %now write the strings
    68         for i=1:num,
    69                 string=data{i};
    70                 fwrite(fid,length(string),'int');
    71                 fwrite(fid,string,'char');
    72         end
    73 elseif strcmpi(data_type,'MatArray'),
     90        %}}}
     91elseif strcmpi(data_type,'IntMat'), %{{{
     92
     93        %matrix type:
     94        mattype=template.(field){4};
     95
     96        %Get size
     97        s=size(data);
     98        %if matrix = NaN, then do not write anything
     99        if (s(1)==1 & s(2)==1 & isnan(data)),
     100                s(1)=0; s(2)=0;
     101        end
     102       
     103        %first write length of record
     104        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
     105
     106        %write data code and matrix type:
     107        fwrite(fid,TypeToCode(data_type),'int');
     108        fwrite(fid,mattype,'int');
     109
     110        %now write matrix
     111        fwrite(fid,s(1),'int');
     112        fwrite(fid,s(2),'int');
     113        if s(1)*s(2),
     114                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
     115        end
     116        %}}}
     117elseif strcmpi(data_type,'DoubleMat'), %{{{
     118
     119        %matrix type:
     120        mattype=template.(field){4};
     121
     122        %Get size
     123        s=size(data);
     124        %if matrix = NaN, then do not write anything
     125        if (s(1)==1 & s(2)==1 & isnan(data)),
     126                s(1)=0; s(2)=0;
     127        end
     128       
     129        %first write length of record
     130        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
     131
     132        %write data code and matrix type:
     133        fwrite(fid,TypeToCode(data_type),'int');
     134        fwrite(fid,mattype,'int');
     135
     136        %now write matrix
     137        fwrite(fid,s(1),'int');
     138        fwrite(fid,s(2),'int');
     139        if s(1)*s(2),
     140                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
     141        end
     142        %}}}
     143elseif strcmpi(data_type,'MatArray'), %{{{1
    74144
    75145        numrecords=numel(data);
    76146       
    77147        %first get length of record
    78         recordlength=4; %number of records=
     148        recordlength=4+4; %number of records + code
    79149        for i=1:numrecords,
    80150                matrix=data{i};
    … …  
    86156        %write length of record
    87157        fwrite(fid,recordlength,'int');
     158
     159        %write data code:
     160        fwrite(fid,TypeToCode(data_type),'int');
    88161
    89162        %write data, first number of records
    … …  
    98171                fwrite(fid,matrix','double');
    99172        end
     173        %}}}
     174elseif strcmpi(data_type,'StringArray'), %{{{1
     175
     176        %first get length of string array:
     177        num=numel(data);
     178        %now get length of record:
     179        recordlength=4+4; %for length of array + code
     180        for i=1:num,
     181                string=data{i};
     182                recordlength=recordlength+4+length(string); %for each string
     183        end
     184
     185        %write length of record
     186        fwrite(fid,recordlength,'int');
     187
     188        %write data code:
     189        fwrite(fid,TypeToCode(data_type),'int');
     190
     191        %now write length of string array
     192        fwrite(fid,num,'int');
     193       
     194        %now write the strings
     195        for i=1:num,
     196                string=data{i};
     197                fwrite(fid,length(string),'int');
     198                fwrite(fid,string,'char');
     199        end
     200        %}}}
    100201else
    101202        error('WriteData error message: data type not supported yet!');
    102203end
     204
     205function code=TypeToCode(data_type) %{{{1
     206%This routine takes the data_type string, and hardcodes it into an integer, which
     207%is passed along the record, in order to identify the nature of the dataset being
     208%sent.
     209if     strcmpi(data_type,'Boolean'),
     210        code=1;
     211elseif strcmpi(data_type,'Integer'),
     212        code=2;
     213elseif strcmpi(data_type,'Double'),
     214        code=3;
     215elseif strcmpi(data_type,'String'),
     216        code=4;
     217elseif strcmpi(data_type,'BooleanMat'),
     218        code=5;
     219elseif strcmpi(data_type,'IntMat'),
     220        code=6;
     221elseif strcmpi(data_type,'DoubleMat'),
     222        code=7;
     223elseif strcmpi(data_type,'MatArray'),
     224        code=8;
     225elseif strcmpi(data_type,'StringArray'),
     226        code=9;
     227else
     228        error('TypeToCode error message: data type not supported yet!');
     229end%}}}

  • issm/trunk/src/m/model/marshall.m

    r8932 r8967  
    2323        marshall=template.(field){2};
    2424        if marshall,
    25                 enum=BuildEnum(field);
    26                 type=template.(field){3};
    27                 WriteData(fid,md.(field),type,enum);
     25                WriteData(md,fid,template,field);
    2826        end
    2927end
Note: See TracChangeset for help on using the changeset viewer.