Changeset 15749


Ignore:
Timestamp:
08/08/13 09:07:34 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removing elements and vertices on water, which is now included in icelevelset

Location:
issm/trunk-jpl/src
Files:
2 deleted
53 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r15747 r15749  
    395395
    396396        /*Skip if water element*/
    397         if(IsOnWater()) return;
     397        if(NoIceInElement()) return;
    398398
    399399        /*Create element stiffness matrix*/
    … …  
    446446
    447447        /*Skip if water element*/
    448         if(IsOnWater()) return NULL;
     448        if(NoIceInElement()) return NULL;
    449449
    450450        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    568568
    569569        /*Skip if water element*/
    570         if(IsOnWater()) return;
     570        if(NoIceInElement()) return;
    571571
    572572        /*Create element load vector*/
    … …  
    629629
    630630        /*Skip if water element*/
    631         if(IsOnWater()) return NULL;
     631        if(NoIceInElement()) return NULL;
    632632
    633633        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    736736
    737737        /*Skip if water element*/
    738         if(IsOnWater()) return;
     738        if(NoIceInElement()) return;
    739739
    740740        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    26212621}
    26222622/*}}}*/
    2623 /*FUNCTION Penta::IsOnWater {{{*/
    2624 bool   Penta::IsOnWater(){
    2625 
    2626         bool onwater;
    2627         inputs->GetInputValue(&onwater,MaskElementonwaterEnum);
    2628         return onwater;
     2623/*FUNCTION Penta::NoIceInElement {{{*/
     2624bool   Penta::NoIceInElement(){
     2625
     2626        /*Get levelset*/
     2627        IssmDouble ls[NUMVERTICES];
     2628        GetInputListOnVertices(&ls[0],MaskIcelevelsetEnum);
     2629
     2630        /*If the level set is >0, ice is present in this element*/
     2631        if(ls[0]>0. || ls[1]>0. || ls[2]>0.) return false;
     2632
     2633        /*If the level set is awlays <=0, there is no ice here*/
     2634        return true;
    26292635}
    26302636/*}}}*/
    … …  
    31693175
    31703176        /*If on water, return 0: */
    3171         if(IsOnWater())return 0;
     3177        if(NoIceInElement())return 0;
    31723178
    31733179        /*Bail out if this element if:
    … …  
    36093615        IssmDouble xyz_list[NUMVERTICES][3];
    36103616
    3611         if(IsOnWater())return 0;
     3617        if(NoIceInElement())return 0;
    36123618
    36133619        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    38013807        rho_ice=matpar->GetRhoIce();
    38023808
    3803         if(IsOnWater() || !IsOnSurface()) return 0.;
     3809        if(NoIceInElement() || !IsOnSurface()) return 0.;
    38043810
    38053811        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    57045710
    57055711        /*If on water, skip grad (=0): */
    5706         if(IsOnWater())return;
     5712        if(NoIceInElement())return;
    57075713
    57085714        /*First deal with ∂/∂alpha(KU-F)*/
    … …  
    61726178
    61736179        /*If on water, return 0: */
    6174         if(IsOnWater())return 0;
     6180        if(NoIceInElement())return 0;
    61756181
    61766182        /*Bail out if this element if:
    … …  
    62096215
    62106216        /*If on water, return 0: */
    6211         if(IsOnWater())return 0;
     6217        if(NoIceInElement())return 0;
    62126218
    62136219        /*Bail out if this element if:
    … …  
    62466252
    62476253        /*If on water, return 0: */
    6248         if(IsOnWater())return 0;
     6254        if(NoIceInElement())return 0;
    62496255
    62506256        /*Bail out if this element if:
    … …  
    62856291
    62866292        /*If on water, return 0: */
    6287         if(IsOnWater())return 0;
     6293        if(NoIceInElement())return 0;
    62886294
    62896295        /*Bail out if this element if:
    … …  
    63226328
    63236329        /*If on water, return 0: */
    6324         if(IsOnWater())return 0;
     6330        if(NoIceInElement())return 0;
    63256331
    63266332        /*Bail out if this element if:
    … …  
    63656371
    63666372        /*If on water, return 0: */
    6367         if(IsOnWater())return 0;
     6373        if(NoIceInElement())return 0;
    63686374        _error_("Not implemented yet");
    63696375
    … …  
    63816387
    63826388        /*If on water, on shelf or not on bed, skip: */
    6383         if(IsOnWater()|| IsFloating() || !IsOnBed()) return 0;
     6389        if(NoIceInElement()|| IsFloating() || !IsOnBed()) return 0;
    63846390
    63856391        tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1
    … …  
    63966402
    63976403        /*If on water, on shelf or not on bed, skip: */
    6398         if(IsOnWater() || !IsOnBed()) return 0;
     6404        if(NoIceInElement() || !IsOnBed()) return 0;
    63996405
    64006406        tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r15737 r15749  
    177177                /*}}}*/
    178178                /*Penta specific routines:{{{*/
    179                 void      BedNormal(IssmDouble* bed_normal, IssmDouble xyz_list[3][3]);
     179                void             BedNormal(IssmDouble* bed_normal, IssmDouble xyz_list[3][3]);
    180180                ElementMatrix* CreateBasalMassMatrix(void);
    181181                ElementMatrix* CreateKMatrix(void);
    … …  
    203203                void             GetSolutionFromInputsEnthalpy(Vector<IssmDouble>* solutiong);
    204204                IssmDouble     GetStabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa);
    205                 void    GetStrainRate3dHO(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input);
    206                 void    GetStrainRate3d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input, Input* vz_input);
    207                 Penta*  GetUpperElement(void);
    208                 void    GetZeroLevelsetCoordinates(IssmDouble* xyz_zero,IssmDouble xyz_list[6][3],int levelsetenum);
    209                 Penta*  GetLowerElement(void);
    210                 Penta*  GetBasalElement(void);
    211                 void      InputExtrude(int enum_type,int object_type);
    212                 void    InputUpdateFromSolutionPrognostic(IssmDouble* solutiong);
    213                 void    InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type);
    214                 void    InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);
    215                 bool      IsInput(int name);
    216                 bool      IsOnSurface(void);
    217                 bool      IsOnBed(void);
    218                 bool    IsFloating(void);
    219                 bool    IsNodeOnShelf();
    220                 bool    IsNodeOnShelfFromFlags(IssmDouble* flags);
    221                 bool    IsOnWater(void);
    222                 IssmDouble  MinEdgeLength(IssmDouble xyz_list[6][3]);
    223                 void      ReduceMatrixFS(IssmDouble* Ke_reduced, IssmDouble* Ke_temp);
    224                 void      ReduceVectorFS(IssmDouble* Pe_reduced, IssmDouble* Ke_temp, IssmDouble* Pe_temp);
    225                 void      SetClone(int* minranks);
    226                 Tria*     SpawnTria(int location);
    227                 void      SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
    228                 void     UpdateConstraints(void);
     205                void           GetStrainRate3dHO(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input);
     206                void           GetStrainRate3d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input, Input* vz_input);
     207                Penta*         GetUpperElement(void);
     208                void           GetZeroLevelsetCoordinates(IssmDouble* xyz_zero,IssmDouble xyz_list[6][3],int levelsetenum);
     209                Penta*         GetLowerElement(void);
     210                Penta*         GetBasalElement(void);
     211                void             InputExtrude(int enum_type,int object_type);
     212                void           InputUpdateFromSolutionPrognostic(IssmDouble* solutiong);
     213                void           InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type);
     214                void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);
     215                bool             IsInput(int name);
     216                bool             IsOnSurface(void);
     217                bool             IsOnBed(void);
     218                bool           IsFloating(void);
     219                bool           IsNodeOnShelf();
     220                bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
     221                bool           NoIceInElement(void);
     222                IssmDouble     MinEdgeLength(IssmDouble xyz_list[6][3]);
     223                void             ReduceMatrixFS(IssmDouble* Ke_reduced, IssmDouble* Ke_temp);
     224                void             ReduceVectorFS(IssmDouble* Pe_reduced, IssmDouble* Ke_temp, IssmDouble* Pe_temp);
     225                void             SetClone(int* minranks);
     226                Tria*            SpawnTria(int location);
     227                void             SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
     228                void           UpdateConstraints(void);
    229229
    230230                #ifdef _HAVE_DIAGNOSTIC_
    … …  
    303303                ElementVector* CreatePVectorDiagnosticVertVolume(void);
    304304                ElementVector* CreatePVectorDiagnosticVertBase(void);
    305                 void GetL1L2Viscosity(IssmDouble*, IssmDouble*, GaussPenta*, Input*, Input*, Input*);
     305                void           GetL1L2Viscosity(IssmDouble*, IssmDouble*, GaussPenta*, Input*, Input*, Input*);
    306306                #endif
    307307
    … …  
    314314                ElementVector* CreatePVectorAdjointHO(void);
    315315                ElementVector* CreatePVectorAdjointFS(void);
    316                 void    InputUpdateFromSolutionAdjointHoriz( IssmDouble* solutiong);
    317                 void    InputUpdateFromSolutionAdjointFS( IssmDouble* solutiong);
     316                void           InputUpdateFromSolutionAdjointHoriz( IssmDouble* solutiong);
     317                void           InputUpdateFromSolutionAdjointFS( IssmDouble* solutiong);
    318318                #endif
    319319
    320320                #ifdef _HAVE_HYDROLOGY_
    321 
    322321                ElementMatrix* CreateKMatrixHydrologyDCInefficient(void);
    323322                ElementMatrix* CreateKMatrixHydrologyDCEfficient(void);
    324323                ElementVector* CreatePVectorHydrologyDCInefficient(void);
    325324                ElementVector* CreatePVectorHydrologyDCEfficient(void);
    326 
    327325                void    GetHydrologyDCInefficientHmax(IssmDouble* ph_max, Node* innode);
    328326                void    GetHydrologyTransfer(Vector<IssmDouble>* transfer);
    … …  
    332330                void    InputUpdateFromSolutionHydrologyDCInefficient(IssmDouble* solution);
    333331                #endif
     332
    334333                #ifdef _HAVE_THERMAL_
    335334                ElementMatrix* CreateKMatrixEnthalpy(void);
    … …  
    349348                ElementVector* CreatePVectorThermalShelf(void);
    350349                ElementVector* CreatePVectorThermalSheet(void);
    351                 void           GetSolutionFromInputsThermal(Vector<IssmDouble>* solutiong);
     350                void             GetSolutionFromInputsThermal(Vector<IssmDouble>* solutiong);
    352351                void           InputUpdateFromSolutionThermal( IssmDouble* solutiong);
    353352                void           InputUpdateFromSolutionEnthalpy( IssmDouble* solutiong);
    354353                #endif
     354
    355355                #ifdef _HAVE_BALANCED_
    356356                ElementMatrix* CreateKMatrixBalancethickness(void);

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r15741 r15749  
    176176
    177177        /*Skip if water element*/
    178         if(IsOnWater()) return;
     178        if(NoIceInElement()) return;
    179179
    180180        /*Create element stiffness matrix*/
    … …  
    211211
    212212        /*Skip if water element*/
    213         if(IsOnWater()) return NULL;
     213        if(NoIceInElement()) return NULL;
    214214
    215215        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    310310
    311311        /*Skip if water element*/
    312         if(IsOnWater()) return;
     312        if(NoIceInElement()) return;
    313313
    314314        /*Create element load vector*/
    … …  
    353353
    354354        /*Skip if water element*/
    355         if(IsOnWater()) return NULL;
     355        if(NoIceInElement()) return NULL;
    356356
    357357        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    … …  
    468468
    469469        /*Skip if water element*/
    470         if(IsOnWater()) return;
     470        if(NoIceInElement()) return;
    471471
    472472        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    19891989}
    19901990/*}}}*/
    1991 /*FUNCTION Tria::IsOnWater {{{*/
    1992 bool   Tria::IsOnWater(){
    1993 
    1994         bool water;
    1995         inputs->GetInputValue(&water,MaskElementonwaterEnum);
    1996         return water;
     1991/*FUNCTION Tria::NoIceInElement {{{*/
     1992bool   Tria::NoIceInElement(){
     1993
     1994        /*Get levelset*/
     1995        IssmDouble ls[NUMVERTICES];
     1996        GetInputListOnVertices(&ls[0],MaskIcelevelsetEnum);
     1997
     1998        /*If the level set is >0, ice is present in this element*/
     1999        if(ls[0]>0. || ls[1]>0. || ls[2]>0.) return false;
     2000
     2001        /*If the level set is awlays <=0, there is no ice here*/
     2002        return true;
    19972003}
    19982004/*}}}*/
    … …  
    22872293
    22882294        /*If on water, return 0: */
    2289         if(IsOnWater())return 0;
     2295        if(NoIceInElement())return 0;
    22902296
    22912297        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    25012507
    25022508        /*Skip if water element*/
    2503         if(IsOnWater()) return;
     2509        if(NoIceInElement()) return;
    25042510
    25052511}
    … …  
    25532559        IssmDouble xyz_list[NUMVERTICES][3];
    25542560
    2555         if(IsOnWater())return 0;
     2561        if(NoIceInElement())return 0;
    25562562
    25572563        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    27892795        rho_ice=matpar->GetRhoIce();
    27902796
    2791    if(IsOnWater())return 0;
     2797   if(NoIceInElement())return 0;
    27922798
    27932799        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    36393645
    36403646        /*If on water, return 0: */
    3641         if(IsOnWater()) return 0;
     3647        if(NoIceInElement()) return 0;
    36423648
    36433649        /*Retrieve all inputs we will be needing: */
    … …  
    37813787
    37823788        /*If on water, grad = 0: */
    3783         if(IsOnWater()) return;
     3789        if(NoIceInElement()) return;
    37843790
    37853791        /*First deal with ∂/∂alpha(KU-F)*/
    … …  
    44084414
    44094415        /*If on water, return 0: */
    4410         if(IsOnWater()) return 0;
     4416        if(NoIceInElement()) return 0;
    44114417
    44124418        /*Retrieve all inputs we will be needing: */
    … …  
    44474453
    44484454        /*If on water, return 0: */
    4449         if(IsOnWater())return 0;
     4455        if(NoIceInElement())return 0;
    44504456
    44514457        /* Get node coordinates and dof list: */
    … …  
    45064512
    45074513        /*If on water, return 0: */
    4508         if(IsOnWater())return 0;
     4514        if(NoIceInElement())return 0;
    45094515
    45104516        /* Get node coordinates and dof list: */
    … …  
    45664572
    45674573        /*If on water, return 0: */
    4568         if(IsOnWater())return 0;
     4574        if(NoIceInElement())return 0;
    45694575
    45704576        /* Get node coordinates and dof list: */
    … …  
    46244630
    46254631        /*If on water, return 0: */
    4626         if(IsOnWater())return 0;
     4632        if(NoIceInElement())return 0;
    46274633
    46284634        /* Get node coordinates and dof list: */
    … …  
    46834689
    46844690        /*If on water, return 0: */
    4685         if(IsOnWater())return 0;
     4691        if(NoIceInElement())return 0;
    46864692
    46874693        /* Get node coordinates and dof list: */
    … …  
    47454751
    47464752        /*If on water, return 0: */
    4747         if(IsOnWater()) return 0;
     4753        if(NoIceInElement()) return 0;
    47484754
    47494755        /*Retrieve all inputs we will be needing: */
    … …  
    47894795
    47904796        /*If on water, return 0: */
    4791         if(IsOnWater()) return 0;
     4797        if(NoIceInElement()) return 0;
    47924798
    47934799        /*Retrieve all inputs we will be needing: */
    … …  
    48404846
    48414847        /*If on water, return 0: */
    4842         if(IsOnWater()) return 0;
     4848        if(NoIceInElement()) return 0;
    48434849
    48444850        /*Retrieve all inputs we will be needing: */
    … …  
    48884894
    48894895        /*If on water, return 0: */
    4890         if(IsOnWater())return 0;
     4896        if(NoIceInElement())return 0;
    48914897
    48924898        /*Retrieve all inputs we will be needing: */
    … …  
    52075213
    52085214        /*If on water, return 0: */
    5209         if(IsOnWater()) return 0;
     5215        if(NoIceInElement()) return 0;
    52105216
    52115217        /*Retrieve all inputs we will be needing: */
    … …  
    55745580
    55755581        /*Skip if water or ice shelf element*/
    5576         if(IsOnWater() | IsFloating()) return NULL;
     5582        if(NoIceInElement() | IsFloating()) return NULL;
    55775583
    55785584        /*Fetch number of nodes and dof for this finite element*/
    … …  
    57995805
    58005806        /*Skip if water or ice shelf element*/
    5801         if(IsOnWater() | IsFloating()) return NULL;
     5807        if(NoIceInElement() | IsFloating()) return NULL;
    58025808
    58035809        /*Fetch number of nodes and dof for this finite element*/

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r15731 r15749  
    7171                /*}}}*/
    7272                /*Element virtual functions definitions: {{{*/
    73                 void   ComputeBasalStress(Vector<IssmDouble>* sigma_b);
    74                 void   ComputeStrainRate(Vector<IssmDouble>* eps);
    75                 void   ComputeStressTensor();
    76                 void   Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
    77                 void   SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);
    78                 void   SetwiseNodeConnectivity(int* d_nz,int* o_nz,Node* node,bool* flags,int set1_enum,int set2_enum);
    79                 void   CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs);
    80                 void   CreateDVector(Vector<IssmDouble>* df);
    81                 void   CreatePVector(Vector<IssmDouble>* pf);
    82                 void   CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
    83                 void   Delta18oParameterization(void);
    84                 int    GetNodeIndex(Node* node);
    85                 void   GetNodesSidList(int* sidlist);
    86                 int    GetNumberOfNodes(void);
    87                 int    Sid();
    88                 bool   IsOnBed();
    89                 bool   IsFloating();
    90                 bool   IsNodeOnShelf();
    91                 bool   IsNodeOnShelfFromFlags(IssmDouble* flags);
    92                 bool   IsOnWater();
    93                 void   GetSolutionFromInputs(Vector<IssmDouble>* solution);
    94                 void   GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum);
    95                 void   GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp);
    96                 void   InputArtificialNoise(int enum_type,IssmDouble min, IssmDouble max);
    97                 void   InputCreate(IssmDouble scalar,int name,int code);
    98                 void   InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    99                 void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
    100                 void   InputDuplicate(int original_enum,int new_enum);
    101                 void   InputScale(int enum_type,IssmDouble scale_factor);
    102                 void   InputToResult(int enum_type,int step,IssmDouble time);
    103                 void   DeleteResults(void);
    104                 void   MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
    105                 int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);
    106                 void   PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
    107                 void   RequestedOutput(int output_enum,int step,IssmDouble time);
    108                 void   ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
    109                 void   PatchFill(int* pcount, Patch* patch);
    110                 void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    111                 void   ResetCoordinateSystem(void){_error_("not implemented yet");};
    112                 void     SmbGradients();
    113                 IssmDouble SurfaceArea(void);
    114                 void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    115                 IssmDouble TimeAdapt();
     73                void        ComputeBasalStress(Vector<IssmDouble>* sigma_b);
     74                void        ComputeStrainRate(Vector<IssmDouble>* eps);
     75                void        ComputeStressTensor();
     76                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
     77                void        SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);
     78                void        SetwiseNodeConnectivity(int* d_nz,int* o_nz,Node* node,bool* flags,int set1_enum,int set2_enum);
     79                void        CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs);
     80                void        CreateDVector(Vector<IssmDouble>* df);
     81                void        CreatePVector(Vector<IssmDouble>* pf);
     82                void        CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
     83                void        Delta18oParameterization(void);
     84                int         GetNodeIndex(Node* node);
     85                void        GetNodesSidList(int* sidlist);
     86                int         GetNumberOfNodes(void);
     87                int         Sid();
     88                bool        IsOnBed();
     89                bool        IsFloating();
     90                bool        IsNodeOnShelf();
     91                bool        IsNodeOnShelfFromFlags(IssmDouble* flags);
     92                bool        NoIceInElement();
     93                void        GetSolutionFromInputs(Vector<IssmDouble>* solution);
     94                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum);
     95                void        GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp);
     96                void        InputArtificialNoise(int enum_type,IssmDouble min, IssmDouble max);
     97                void        InputCreate(IssmDouble scalar,int name,int code);
     98                void        InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
     99                void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
     100                void        InputDuplicate(int original_enum,int new_enum);
     101                void        InputScale(int enum_type,IssmDouble scale_factor);
     102                void        InputToResult(int enum_type,int step,IssmDouble time);
     103                void        DeleteResults(void);
     104                void        MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
     105                int         NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);
     106                void        PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
     107                void        RequestedOutput(int output_enum,int step,IssmDouble time);
     108                void        ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
     109                void        PatchFill(int* pcount, Patch* patch);
     110                void        PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     111                void        ResetCoordinateSystem(void){_error_("not implemented yet");};
     112                void          SmbGradients();
     113                IssmDouble  SurfaceArea(void);
     114                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
     115                IssmDouble  TimeAdapt();
    116116
    117117                #ifdef _HAVE_RESPONSES_
    118                 void   AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
     118                void       AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
    119119                IssmDouble IceVolume(void);
    120120                IssmDouble TotalSmb(void);
    121                 void   MinVel(IssmDouble* pminvel);
    122                 void   MinVx(IssmDouble* pminvx);
    123                 void   MinVy(IssmDouble* pminvy);
    124                 void   MinVz(IssmDouble* pminvz);
     121                void       MinVel(IssmDouble* pminvel);
     122                void       MinVx(IssmDouble* pminvx);
     123                void       MinVy(IssmDouble* pminvy);
     124                void       MinVz(IssmDouble* pminvz);
    125125                IssmDouble MassFlux(IssmDouble* segment);
    126                 void   MaxAbsVx(IssmDouble* pmaxabsvx);
    127                 void   MaxAbsVy(IssmDouble* pmaxabsvy);
    128                 void   MaxAbsVz(IssmDouble* pmaxabsvz);
    129                 void   ElementResponse(IssmDouble* presponse,int response_enum);
    130                 void   MaxVel(IssmDouble* pmaxvel);
    131                 void   MaxVx(IssmDouble* pmaxvx);
    132                 void   MaxVy(IssmDouble* pmaxvy);
    133                 void   MaxVz(IssmDouble* pmaxvz);
     126                void       MaxAbsVx(IssmDouble* pmaxabsvx);
     127                void       MaxAbsVy(IssmDouble* pmaxabsvy);
     128                void       MaxAbsVz(IssmDouble* pmaxabsvz);
     129                void       ElementResponse(IssmDouble* presponse,int response_enum);
     130                void       MaxVel(IssmDouble* pmaxvel);
     131                void       MaxVx(IssmDouble* pmaxvx);
     132                void       MaxVy(IssmDouble* pmaxvy);
     133                void       MaxVz(IssmDouble* pmaxvz);
    134134                #endif
    135135
    … …  
    140140                #ifdef _HAVE_CONTROL_
    141141                IssmDouble DragCoefficientAbsGradient(int weight_index);
    142                 void   GradientIndexing(int* indexing,int control_index);
    143                 void   Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index);
    144                 void   GradjBGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
    145                 void   GradjZGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
    146                 void   GradjBSSA(Vector<IssmDouble>* gradient,int control_index);
    147                 void   GradjZSSA(Vector<IssmDouble>* gradient,int control_index);
    148                 void   GradjDragSSA(Vector<IssmDouble>* gradient,int control_index);
    149                 void   GradjDragFS(Vector<IssmDouble>* gradient,int control_index);
    150                 void   GradjDragGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
    151                 void   GradjDhDtBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
    152                 void   GradjVxBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
    153                 void   GradjVyBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
    154                 void   GradjThicknessBalancethicknessSoft(Vector<IssmDouble>* gradient,int control_index);
    155                 void   GetVectorFromControlInputs(Vector<IssmDouble>* gradient,int control_enum,int control_index,const char* data);
    156                 void   SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);
    157                 void   ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index);
    158                 void   ControlInputScaleGradient(int enum_type,IssmDouble scale);
    159                 void   ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
     142                void       GradientIndexing(int* indexing,int control_index);
     143                void       Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index);
     144                void       GradjBGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
     145                void       GradjZGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
     146                void       GradjBSSA(Vector<IssmDouble>* gradient,int control_index);
     147                void       GradjZSSA(Vector<IssmDouble>* gradient,int control_index);
     148                void       GradjDragSSA(Vector<IssmDouble>* gradient,int control_index);
     149                void       GradjDragFS(Vector<IssmDouble>* gradient,int control_index);
     150                void       GradjDragGradient(Vector<IssmDouble>* gradient,int weight_index,int control_index);
     151                void       GradjDhDtBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
     152                void       GradjVxBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
     153                void       GradjVyBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
     154                void       GradjThicknessBalancethicknessSoft(Vector<IssmDouble>* gradient,int control_index);
     155                void       GetVectorFromControlInputs(Vector<IssmDouble>* gradient,int control_enum,int control_index,const char* data);
     156                void       SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);
     157                void       ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index);
     158                void       ControlInputScaleGradient(int enum_type,IssmDouble scale);
     159                void       ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
    160160                IssmDouble RheologyBbarAbsGradient(int weight_index);
    161161                IssmDouble ThicknessAbsMisfit(     int weight_index);
    … …  
    169169                IssmDouble SurfaceLogVxVyMisfit(   int weight_index);
    170170                IssmDouble SurfaceAverageVelMisfit(int weight_index);
    171                 void   InputControlUpdate(IssmDouble scalar,bool save_parameter);
    172                 #endif
     171                void       InputControlUpdate(IssmDouble scalar,bool save_parameter);
     172                #endif
     173
    173174                #ifdef _HAVE_GROUNDINGLINE_
    174175                void   PotentialUngrounding(Vector<IssmDouble>* potential_sheet_ungrounding);

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

    r15689 r15749  
    10441044void  IoModel::FetchData(int num,...){
    10451045
    1046         va_list ap;
    1047         int     dataenum;
    1048         IssmDouble* matrix=NULL;
    1049         int     M,N;
    1050         int     i;
     1046        va_list     ap;
     1047        int         dataenum;
     1048        IssmDouble *matrix   = NULL;
     1049        int         M,N;
     1050        int         i;
    10511051
    10521052        /*Go through the entire list of enums and fetch the corresponding data. Add it to the iomodel->data dataset. Everything
    … …  
    10571057
    10581058                dataenum=va_arg(ap, int);
     1059                _assert_(dataenum<MaximumNumberOfDefinitionsEnum);
     1060                _assert_(dataenum>=0);
    10591061
    10601062                if (this->independents[dataenum]){

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

    r15611 r15749  
    457457        /*Initialize Element matrix and return if necessary*/
    458458        Tria*  tria=(Tria*)element;
    459         if(tria->IsOnWater()) return NULL;
     459        if(tria->NoIceInElement()) return NULL;
    460460        ElementMatrix* Ke=new ElementMatrix(nodes,NUMNODES_INTERNAL,this->parameters);
    461461
    … …  
    521521        ElementMatrix* Ke = NULL;
    522522        Tria*  tria=(Tria*)element;
    523         if(tria->IsOnWater()) return NULL;
     523        if(tria->NoIceInElement()) return NULL;
    524524
    525525        /*Retrieve all inputs and parameters*/
    … …  
    610610        /*Initialize Element matrix and return if necessary*/
    611611        Tria*  tria=(Tria*)element;
    612         if(tria->IsOnWater()) return NULL;
     612        if(tria->NoIceInElement()) return NULL;
    613613        ElementMatrix* Ke=new ElementMatrix(nodes,NUMNODES_INTERNAL,this->parameters);
    614614
    … …  
    673673        ElementMatrix* Ke = NULL;
    674674        Tria*  tria=(Tria*)element;
    675         if(tria->IsOnWater()) return NULL;
     675        if(tria->NoIceInElement()) return NULL;
    676676
    677677        /*Retrieve all inputs and parameters*/
    … …  
    799799        ElementVector* pe = NULL;
    800800        Tria*  tria=(Tria*)element;
    801         if(tria->IsOnWater()) return NULL;
     801        if(tria->NoIceInElement()) return NULL;
    802802
    803803        /*Retrieve all inputs and parameters*/
    … …  
    893893        ElementVector* pe = NULL;
    894894        Tria*  tria=(Tria*)element;
    895         if(tria->IsOnWater()) return NULL;
     895        if(tria->NoIceInElement()) return NULL;
    896896
    897897        /*Retrieve all inputs and parameters*/

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

    r15654 r15749  
    5353        if(iomodel->Data(MaskVertexongroundediceEnum))
    5454          this->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,reCast<bool>(iomodel->Data(MaskVertexongroundediceEnum)[io_index])));
    55         /*set single point constraints: */
    56 
    57         /*spc all nodes on water*/
    58         if(!iomodel->Data(MaskVertexonwaterEnum)) _error_("iomodel->nodeonwater is NULL");
    59         if(reCast<bool>(iomodel->Data(MaskVertexonwaterEnum)[io_index])){
    60                 this->Deactivate();
    61         }
    6255
    6356        /*Diagnostic Horiz*/

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

    r15464 r15749  
    1919
    2020        /*First fetch data: */
    21         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     21        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2222        if(stabilization!=3){
    2323                CreateNodes(pnodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);
    … …  
    2626                CreateNodes(pnodes,iomodel,BalancethicknessAnalysisEnum,P1DGEnum);
    2727        }
    28         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     28        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2929}

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

    r15613 r15749  
    3636        iomodel->FetchDataToInput(elements,BedEnum);
    3737        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    38         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3938        iomodel->FetchDataToInput(elements,VxEnum);
    4039        iomodel->FetchDataToInput(elements,VyEnum);

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

    r15464 r15749  
    1111void    CreateNodesBedSlope(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     13        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1414        CreateNodes(pnodes,iomodel,BedSlopeAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     15        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1616}

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

    r15613 r15749  
    2323        iomodel->FetchDataToInput(elements,SurfaceEnum);
    2424        iomodel->FetchDataToInput(elements,BedEnum);
    25         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    2625        if(iomodel->dim==3){
    2726                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);

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

    r15747 r15749  
    7474                        }
    7575                }
    76                 iomodel->FetchData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    77                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     76                iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     77                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    7878                CreateNodes(pnodes,iomodel,DiagnosticHorizAnalysisEnum,finiteelement,approximation);
    79                 iomodel->DeleteData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    80                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     79                iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     80                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    8181        }
    8282        else{
    … …  
    8888                if(!nodes) nodes = new Nodes();
    8989
    90                 iomodel->FetchData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    91                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     90                iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     91                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    9292                if(isFS){
    9393                        /*P1+ velocity*/
    … …  
    125125                        }
    126126                }
    127                 iomodel->DeleteData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    128                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     127                iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     128                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    129129
    130130                /*Assign output pointer: */

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

    r15734 r15749  
    9090        else{
    9191                if(isFS){
    92                         _error_("COupling under development");
    9392                        for(int i=0;i<iomodel->numberofelements;i++){
    9493                                approximation=reCast<int>(iomodel->Data(FlowequationElementEquationEnum)[i]);
    … …  
    128127        iomodel->FetchDataToInput(elements,FrictionQEnum);
    129128        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    130         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    131129        iomodel->FetchDataToInput(elements,MaskIcelevelsetEnum);
    132130        iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum);

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

    r15594 r15749  
    2525        if(!nodes) nodes = new Nodes();
    2626
    27         iomodel->FetchData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    28                                 MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     27        iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     28                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    2929
    3030        for(int i=0;i<iomodel->numberofvertices;i++){
    … …  
    4444        }
    4545
    46         iomodel->DeleteData(9,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    47                                 MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     46        iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
     47                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    4848
    4949        /*Assign output pointer: */

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

    r15564 r15749  
    1414        if(iomodel->dim==2) return;
    1515
    16         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     16        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1717        CreateNodes(pnodes,iomodel,DiagnosticVertAnalysisEnum,P1Enum);
    18         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     18        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1919}

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

    r15613 r15749  
    3131        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3232        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    33         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3433        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    3534        iomodel->FetchDataToInput(elements,SurfaceforcingsMassBalanceEnum);

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

    r15464 r15749  
    1111void    CreateNodesEnthalpy(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     13        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1414        CreateNodes(pnodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     15        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1616}

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

    r15613 r15749  
    3636        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3737        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    38         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3938        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    4039        iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum);

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

    r15464 r15749  
    1010
    1111void    CreateNodesGia(Nodes** pnodes, IoModel* iomodel){
    12 
    13         iomodel->FetchData(1,MaskVertexonwaterEnum);
    1412        CreateNodes(pnodes,iomodel,GiaAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(1,MaskVertexonwaterEnum);
    1613}

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

    r15464 r15749  
    2121        if(!isefficientlayer) return;
    2222
    23         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     23        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2424        CreateNodes(pnodes,iomodel,HydrologyDCEfficientAnalysisEnum,P1Enum);
    25         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     25        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2626}

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

    r15613 r15749  
    3838        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3939        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    40         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    4140        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    4241        iomodel->FetchDataToInput(elements,EplHeadEnum);

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

    r15464 r15749  
    1818        if(hydrology_model!=HydrologydcEnum) return;
    1919
    20         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     20        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2121        CreateNodes(pnodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
    22         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     22        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2323}

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

    r15613 r15749  
    3939        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    4040        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    41         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    4241        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    4342        iomodel->FetchDataToInput(elements,SedimentHeadEnum);

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

    r15464 r15749  
    1818        if(hydrology_model!=HydrologyshreveEnum) return;
    1919
    20         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     20        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2121        CreateNodes(pnodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    22         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     22        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2323}

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

    r15613 r15749  
    3232        iomodel->FetchDataToInput(elements,SurfaceEnum);
    3333        iomodel->FetchDataToInput(elements,BedEnum);
    34         iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    3534        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3635        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    37         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3836        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    3937        iomodel->FetchDataToInput(elements,WatercolumnEnum);

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

    r15464 r15749  
    1111void    CreateNodesMelting(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     13        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1414        CreateNodes(pnodes,iomodel,MeltingAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     15        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1616}

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

    r15613 r15749  
    3434        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3535        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    36         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3736        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    3837        iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum);

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

    r15464 r15749  
    1919
    2020        /*Create Nodes either DG or CG depending on stabilization*/
    21         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     21        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2222        if(stabilization!=3){
    2323                CreateNodes(pnodes,iomodel,PrognosticAnalysisEnum,P1Enum);
    … …  
    2626                CreateNodes(pnodes,iomodel,PrognosticAnalysisEnum,P1DGEnum);
    2727        }
    28         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     28        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    2929}

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

    r15613 r15749  
    4545        iomodel->FetchDataToInput(elements,BathymetryEnum);
    4646        iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum);
    47         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    4847        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    4948        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateCorrectionEnum);

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

    r15464 r15749  
    1111void    CreateNodesSurfaceSlope(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     13        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1414        CreateNodes(pnodes,iomodel,SurfaceSlopeAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     15        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1616}

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

    r15613 r15749  
    2323        iomodel->FetchDataToInput(elements,SurfaceEnum);
    2424        iomodel->FetchDataToInput(elements,BedEnum);
    25         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    26 
    2725        if(iomodel->dim==3){
    2826                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);

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

    r15464 r15749  
    1111void    CreateNodesThermal(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     13        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1414        CreateNodes(pnodes,iomodel,ThermalAnalysisEnum,P1Enum);
    15         iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     15        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1616}

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

    r15613 r15749  
    3333        iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3434        iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    35         iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    3635        iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum);
    3736        iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum);

  • issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r15689 r15749  
    144144        MaskElementonfloatingiceEnum,
    145145        MaskElementongroundediceEnum,
    146         MaskElementonwaterEnum,
    147146        MaskVertexonfloatingiceEnum,
    148147        MaskVertexongroundediceEnum,
    149         MaskVertexonwaterEnum,
    150148        MaskIcelevelsetEnum,
    151149        MaterialsBetaEnum,

  • issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r15689 r15749  
    152152                case MaskElementonfloatingiceEnum : return "MaskElementonfloatingice";
    153153                case MaskElementongroundediceEnum : return "MaskElementongroundedice";
    154                 case MaskElementonwaterEnum : return "MaskElementonwater";
    155154                case MaskVertexonfloatingiceEnum : return "MaskVertexonfloatingice";
    156155                case MaskVertexongroundediceEnum : return "MaskVertexongroundedice";
    157                 case MaskVertexonwaterEnum : return "MaskVertexonwater";
    158156                case MaskIcelevelsetEnum : return "MaskIcelevelset";
    159157                case MaterialsBetaEnum : return "MaterialsBeta";

  • issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r15689 r15749  
    155155              else if (strcmp(name,"MaskElementonfloatingice")==0) return MaskElementonfloatingiceEnum;
    156156              else if (strcmp(name,"MaskElementongroundedice")==0) return MaskElementongroundediceEnum;
    157               else if (strcmp(name,"MaskElementonwater")==0) return MaskElementonwaterEnum;
    158157              else if (strcmp(name,"MaskVertexonfloatingice")==0) return MaskVertexonfloatingiceEnum;
    159158              else if (strcmp(name,"MaskVertexongroundedice")==0) return MaskVertexongroundediceEnum;
    160               else if (strcmp(name,"MaskVertexonwater")==0) return MaskVertexonwaterEnum;
    161159              else if (strcmp(name,"MaskIcelevelset")==0) return MaskIcelevelsetEnum;
    162160              else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum;
    … …  
    260258              else if (strcmp(name,"ThermalIsenthalpy")==0) return ThermalIsenthalpyEnum;
    261259              else if (strcmp(name,"GiaMantleViscosity")==0) return GiaMantleViscosityEnum;
     260              else if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum;
     261              else if (strcmp(name,"Thickness")==0) return ThicknessEnum;
    262262         else stage=3;
    263263   }
    264264   if(stage==3){
    265               if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum;
    266               else if (strcmp(name,"Thickness")==0) return ThicknessEnum;
    267               else if (strcmp(name,"TimesteppingStartTime")==0) return TimesteppingStartTimeEnum;
     265              if (strcmp(name,"TimesteppingStartTime")==0) return TimesteppingStartTimeEnum;
    268266              else if (strcmp(name,"TimesteppingFinalTime")==0) return TimesteppingFinalTimeEnum;
    269267              else if (strcmp(name,"TimesteppingCflCoefficient")==0) return TimesteppingCflCoefficientEnum;
    … …  
    383381              else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum;
    384382              else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
     383              else if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
     384              else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
    389               else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
    390               else if (strcmp(name,"RiftfrontType")==0) return RiftfrontTypeEnum;
     388              if (strcmp(name,"RiftfrontType")==0) return RiftfrontTypeEnum;
    391389              else if (strcmp(name,"Segment")==0) return SegmentEnum;
    392390              else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum;
    … …  
    506504              else if (strcmp(name,"P1bubblecondensed")==0) return P1bubblecondensedEnum;
    507505              else if (strcmp(name,"P2")==0) return P2Enum;
     506              else if (strcmp(name,"P2xP1")==0) return P2xP1Enum;
     507              else if (strcmp(name,"P1xP2")==0) return P1xP2Enum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"P2xP1")==0) return P2xP1Enum;
    512               else if (strcmp(name,"P1xP2")==0) return P1xP2Enum;
    513               else if (strcmp(name,"P1P1")==0) return P1P1Enum;
     511              if (strcmp(name,"P1P1")==0) return P1P1Enum;
    514512              else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum;
    515513              else if (strcmp(name,"MINI")==0) return MINIEnum;

  • issm/trunk-jpl/src/m/classes/mask.m

    r15596 r15749  
    88                elementonfloatingice = NaN;
    99                elementongroundedice = NaN;
    10                 elementonwater       = NaN;
    1110                vertexonfloatingice  = NaN;
    1211                vertexongroundedice  = NaN;
    13                 vertexonwater        = NaN;
    1412                vertexonrock         = NaN;
    1513                icelevelset          = NaN;
    … …  
    3129                        md = checkfield(md,'mask.elementonfloatingice','size',[md.mesh.numberofelements 1],'values',[0 1]);
    3230                        md = checkfield(md,'mask.elementongroundedice','size',[md.mesh.numberofelements 1],'values',[0 1]);
    33                         md = checkfield(md,'mask.elementonwater'      ,'size',[md.mesh.numberofelements 1],'values',[0 1]);
    3431                        md = checkfield(md,'mask.vertexonfloatingice','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    3532                        md = checkfield(md,'mask.vertexongroundedice','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    36                         md = checkfield(md,'mask.vertexonwater'      ,'size',[md.mesh.numberofvertices 1],'values',[0 1]);
    3733                        md = checkfield(md,'mask.icelevelset'         ,'size',[md.mesh.numberofvertices 1]);
    3834                        isice=(md.mask.icelevelset>0);
    … …  
    4945                        fielddisplay(obj,'elementongroundedice','element on grounded ice  list');
    5046                        fielddisplay(obj,'vertexongroundedice','vertex on grounded ice flags list');
    51                         fielddisplay(obj,'elementonwater','element on rock flags list');
    52                         fielddisplay(obj,'vertexonwater','vertex on water flags list');
    5347                        fielddisplay(obj,'vertexonrock','vertex on rock flags list');
    5448                        fielddisplay(obj,'icelevelset','presence of ice if > 0, icefront position if = 0, no ice if < 0');
    … …  
    5751                        WriteData(fid,'object',obj,'fieldname','elementonfloatingice','format','BooleanMat','mattype',2);
    5852                        WriteData(fid,'object',obj,'fieldname','elementongroundedice','format','BooleanMat','mattype',2);
    59                         WriteData(fid,'object',obj,'fieldname','elementonwater','format','BooleanMat','mattype',2);
    6053                        WriteData(fid,'object',obj,'fieldname','vertexonfloatingice','format','DoubleMat','mattype',1);
    6154                        WriteData(fid,'object',obj,'fieldname','vertexongroundedice','format','DoubleMat','mattype',1);
    62                         WriteData(fid,'object',obj,'fieldname','vertexonwater','format','DoubleMat','mattype',1);
    6355                        WriteData(fid,'object',obj,'fieldname','icelevelset','format','DoubleMat','mattype',1);
    6456                end % }}}

  • issm/trunk-jpl/src/m/classes/mask.py

    r15604 r15749  
    1515                self.elementonfloatingice = float('NaN')
    1616                self.elementongroundedice = float('NaN')
    17                 self.elementonwater       = float('NaN')
    1817                self.vertexonfloatingice  = float('NaN')
    1918                self.vertexongroundedice  = float('NaN')
    20                 self.vertexonwater        = float('NaN')
    2119                self.icelevelset          = float('NaN')
    2220
    … …  
    3230                string="%s\n%s"%(string,fielddisplay(self,"elementongroundedice","element on grounded ice list"))
    3331                string="%s\n%s"%(string,fielddisplay(self,"vertexongroundedice","vertex on grounded ice flags list"))
    34                 string="%s\n%s"%(string,fielddisplay(self,"elementonwater","element on water flags list"))
    35                 string="%s\n%s"%(string,fielddisplay(self,"vertexonwater","vertex on water flags list"))
    3632                string="%s\n%s"%(string,fielddisplay(self,"icelevelset","presence of ice if > 0, icefront position if = 0, no ice if < 0"))
    3733                return string
    … …  
    4440                md = checkfield(md,'mask.elementonfloatingice','size',[md.mesh.numberofelements],'values',[0,1])
    4541                md = checkfield(md,'mask.elementongroundedice','size',[md.mesh.numberofelements],'values',[0,1])
    46                 md = checkfield(md,'mask.elementonwater'      ,'size',[md.mesh.numberofelements],'values',[0,1])
    4742                md = checkfield(md,'mask.vertexonfloatingice' ,'size',[md.mesh.numberofvertices],'values',[0,1])
    4843                md = checkfield(md,'mask.vertexongroundedice' ,'size',[md.mesh.numberofvertices],'values',[0,1])
    49                 md = checkfield(md,'mask.vertexonwater'       ,'size',[md.mesh.numberofvertices],'values',[0,1])
    5044                md = checkfield(md,'mask.icelevelset'         ,'size',[md.mesh.numberofvertices])
    5145                isice=numpy.array(md.mask.icelevelset>0,int)
    … …  
    5953                WriteData(fid,'object',self,'fieldname','elementonfloatingice','format','BooleanMat','mattype',2)
    6054                WriteData(fid,'object',self,'fieldname','elementongroundedice','format','BooleanMat','mattype',2)
    61                 WriteData(fid,'object',self,'fieldname','elementonwater','format','BooleanMat','mattype',2)
    6255                WriteData(fid,'object',self,'fieldname','vertexonfloatingice','format','DoubleMat','mattype',1)
    6356                WriteData(fid,'object',self,'fieldname','vertexongroundedice','format','DoubleMat','mattype',1)
    64                 WriteData(fid,'object',self,'fieldname','vertexonwater','format','DoubleMat','mattype',1)
    6557                WriteData(fid,'object',self,'fieldname','icelevelset','format','DoubleMat','mattype',1)
    6658        # }}}

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

    r15643 r15749  
    224224                        md.mask.elementongroundedice=project2d(md,md.mask.elementongroundedice,1);
    225225                        md.mask.vertexongroundedice=project2d(md,md.mask.vertexongroundedice,1);
    226                         md.mask.elementonwater=project2d(md,md.mask.elementonwater,1);
    227                         md.mask.vertexonwater=project2d(md,md.mask.vertexonwater,1);
    228226                        if ~isnan(md.mask.vertexonrock)
    229227                                md.mask.vertexonrock=project2d(md,md.mask.vertexonrock,1);
    … …  
    754752                        md.mask.elementongroundedice=project3d(md,'vector',md.mask.elementongroundedice,'type','element');
    755753                        md.mask.vertexongroundedice=project3d(md,'vector',md.mask.vertexongroundedice,'type','node');
    756                         md.mask.elementonwater=project3d(md,'vector',md.mask.elementonwater,'type','element');
    757                         md.mask.vertexonwater=project3d(md,'vector',md.mask.vertexonwater,'type','node');
    758754                        md.mask.vertexonrock=project3d(md,'vector',md.mask.vertexonrock,'type','node');
    759755                        md.mask.icelevelset=project3d(md,'vector',md.mask.icelevelset,'type','node');
    … …  
    809805                        if isfield(structmd,'gridoniceshelf'), md.mask.vertexonfloatingice=structmd.gridoniceshelf; end
    810806                        if isfield(structmd,'gridonicesheet'), md.mask.vertexongroundedice=structmd.gridonicesheet; end
    811                         if isfield(structmd,'gridonwater'), md.mask.vertexonwater=structmd.gridonwater; end
    812807                        if isfield(structmd,'gridonboundary'), md.mesh.vertexonboundary=structmd.gridonboundary; end
    813808                        if isfield(structmd,'petscoptions') & ~isempty(structmd.petscoptions), md.toolkits=structmd.petscoptions; end
    … …  
    861856                        if isfield(structmd,'elementoniceshelf'), md.mask.elementonfloatingice=structmd.elementoniceshelf; end
    862857                        if isfield(structmd,'elementonicesheet'), md.mask.elementongroundedice=structmd.elementonicesheet; end
    863                         if isfield(structmd,'elementonwater'), md.mask.elementonwater=structmd.elementonwater; end
    864858                        if isfield(structmd,'nodeoniceshelf'), md.mask.vertexonfloatingice=structmd.nodeoniceshelf; end
    865859                        if isfield(structmd,'nodeonicesheet'), md.mask.vertexongroundedice=structmd.nodeonicesheet; end
    866                         if isfield(structmd,'nodeonwater'), md.mask.vertexonwater=structmd.nodeonwater; end
    867860                        if isfield(structmd,'spcthickness'), md.balancethickness.spcthickness=structmd.spcthickness; end
    868861                        if isfield(structmd,'artificial_diffusivity'), md.balancethickness.stabilization=structmd.artificial_diffusivity; end

  • issm/trunk-jpl/src/m/classes/model/model.py

    r15615 r15749  
    642642                md.mask.elementongroundedice=project3d(md,'vector',md.mask.elementongroundedice,'type','element')
    643643                md.mask.vertexongroundedice=project3d(md,'vector',md.mask.vertexongroundedice,'type','node')
    644                 md.mask.elementonwater=project3d(md,'vector',md.mask.elementonwater,'type','element')
    645                 md.mask.vertexonwater=project3d(md,'vector',md.mask.vertexonwater,'type','node')
    646644                md.mask.icelevelset=project3d(md,'vector',md.mask.icelevelset,'type','node')
    647645                if not numpy.any(numpy.isnan(md.inversion.cost_functions_coefficients)):

  • issm/trunk-jpl/src/m/contrib/bamg/BamgCall.m

    r13012 r15749  
    2525%Compute metric
    2626t1=clock; fprintf('%s','      computing metric...');
    27 if length(md.nodeonwater)==md.mesh.numberofvertices,
    28         pos=find(md.nodeonwater);
    29 else
    30         pos=[];
    31 end
    32 metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,pos);
     27metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,[]);
    3328t2=clock;fprintf('%s\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    3429

  • issm/trunk-jpl/src/m/contrib/bamg/YamsCall.m

    r14094 r15749  
    2525%Compute metric
    2626t1=clock; fprintf('%s','      computing metric...');
    27 if length(md.mask.vertexonwater)==md.mesh.numberofvertices,
    28         pos=find(md.mask.vertexonwater);
    29 else
    30         pos=[];
    31 end
    32 metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,pos);
     27metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,[]);
    3328t2=clock;fprintf('%s\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    3429

  • issm/trunk-jpl/src/m/contrib/bamg/YamsCall.py

    r14094 r15749  
    3838        t1=time.time()
    3939        print "%s" % '      computing metric...'
    40         if numpy.size(md.mask.vertexonwater)==md.mesh.numberofvertices:
    41                 pos=numpy.nonzero(md.mask.vertexonwater)[0]
    42         else:
    43                 pos=numpy.empty(0,int)
    44         metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,pos)
     40        metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,numpy.empty(0,int))
    4541        t2=time.time()
    4642        print "%s%d%s\n" % (' done (',t2-t1,' seconds)')

  • issm/trunk-jpl/src/m/contrib/bamg/yams.m

    r13730 r15749  
    7979        field=sqrt(vx_obs.^2+vy_obs.^2);
    8080
    81         %set mask.vertexonwater  field
    82         if ~strcmp(groundeddomain,'N/A'),
    83                 nodeground=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,groundeddomain,'node',2);
    84                 md.mask.vertexonwater=ones(md.mesh.numberofvertices,1);
    85                 md.mask.vertexonwater(find(nodeground))=0;
    86         else
    87                 md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    88         end
    89 
    9081        %adapt according to velocities
    9182        disp('   adapting...');
    … …  
    119110md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    120111md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    121 if ~strcmp(groundeddomain,'N/A'),
    122         nodeground=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,groundeddomain,'node',2);
    123         md.mask.vertexonwater=ones(md.mesh.numberofvertices,1);
    124         md.mask.vertexonwater(find(nodeground))=0;
    125 else
    126         md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    127 end
    128112if strcmpi(Names.interp,'node'),
    129113        md.inversion.vx_obs=InterpFromGridToMesh(Vel.(Names.xname),Vel.(Names.yname),Vel.(Names.vxname),md.mesh.x,md.mesh.y,0);

  • issm/trunk-jpl/src/m/enum/EnumDefinitions.py

    r15690 r15749  
    144144def MaskElementonfloatingiceEnum(): return StringToEnum("MaskElementonfloatingice")[0]
    145145def MaskElementongroundediceEnum(): return StringToEnum("MaskElementongroundedice")[0]
    146 def MaskElementonwaterEnum(): return StringToEnum("MaskElementonwater")[0]
    147146def MaskVertexonfloatingiceEnum(): return StringToEnum("MaskVertexonfloatingice")[0]
    148147def MaskVertexongroundediceEnum(): return StringToEnum("MaskVertexongroundedice")[0]
    149 def MaskVertexonwaterEnum(): return StringToEnum("MaskVertexonwater")[0]
    150148def MaskIcelevelsetEnum(): return StringToEnum("MaskIcelevelset")[0]
    151149def MaterialsBetaEnum(): return StringToEnum("MaterialsBeta")[0]

  • issm/trunk-jpl/src/m/mesh/ComputeMetric.m

    r14098 r15749  
    77%
    88%   Example:
    9 %      metric=ComputeMetric(hessian,2/9,10^-1,100,10^5,find(md.nodeonwater)
     9%      metric=ComputeMetric(hessian,2/9,10^-1,100,10^5,[])
    1010
    1111%first, find the eigen values of each line of H=[hessian(i,1) hessian(i,2); hessian(i,2) hessian(i,3)]

  • issm/trunk-jpl/src/m/mesh/ComputeMetric.py

    r14098 r15749  
    1010
    1111           Example:
    12               metric=ComputeMetric(hessian,2/9,10^-1,100,10^5,find(md.nodeonwater)
     12              metric=ComputeMetric(hessian,2/9,10^-1,100,10^5,[])
    1313        """
    1414

  • issm/trunk-jpl/src/m/mesh/MeshQuality.m

    r13730 r15749  
    1717
    1818%Compute metric
    19 if length(md.nodeonwater)==md.mesh.numberofvertices,
    20         pos=find(md.nodeonwater);
    21 else
    22         pos=[];
    23 end
    24 metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,pos);
     19metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,[]);
    2520
    2621%Get Areas

  • issm/trunk-jpl/src/m/mesh/bamg.m

    r15220 r15749  
    325325md.mesh.z=zeros(md.mesh.numberofvertices,1);
    326326md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    327 md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    328327md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    329328md.mesh.elementonbed=ones(md.mesh.numberofelements,1);

  • issm/trunk-jpl/src/m/mesh/bamg.py

    r14098 r15749  
    332332        md.mesh.z=numpy.zeros(md.mesh.numberofvertices)
    333333        md.mesh.vertexonbed=numpy.ones(md.mesh.numberofvertices,bool)
    334         md.mask.vertexonwater=numpy.zeros(md.mesh.numberofvertices,bool)
    335334        md.mesh.vertexonsurface=numpy.ones(md.mesh.numberofvertices,bool)
    336335        md.mesh.elementonbed=numpy.ones(md.mesh.numberofelements,bool)

  • issm/trunk-jpl/src/m/mesh/meshconvert.m

    r13009 r15749  
    4242md.mesh.z=zeros(md.mesh.numberofvertices,1);
    4343md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    44 md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    4544md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    4645md.mesh.elementonbed=ones(md.mesh.numberofelements,1);

  • issm/trunk-jpl/src/m/parameterization/setmask.m

    r15595 r15749  
    4646md.mask.elementongroundedice=elementongroundedice;
    4747md.mask.vertexongroundedice=vertexongroundedice;
    48 md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
    49 md.mask.elementonwater=zeros(md.mesh.numberofelements,1);
    5048md.mask.icelevelset=ones(md.mesh.numberofvertices,1);

  • issm/trunk-jpl/src/m/parameterization/setmask.py

    r15602 r15749  
    4646        md.mask.elementongroundedice = elementongroundedice
    4747        md.mask.vertexongroundedice = vertexongroundedice
    48         md.mask.vertexonwater = numpy.zeros(md.mesh.numberofvertices,bool)
    49         md.mask.elementonwater = numpy.zeros(md.mesh.numberofelements,bool)
    5048        md.mask.icelevelset = numpy.ones(md.mesh.numberofvertices,bool)
    5149
Note: See TracChangeset for help on using the changeset viewer.