Changeset 23524


Ignore:
Timestamp:
12/09/18 19:45:10 (6 years ago)
Author:
Mathieu Morlighem
Message:

CHG: cleaning up inputupdate, removing Update class, now that inputs are always in element

Location:
issm/trunk-jpl/src/c
Files:
1 deleted
27 edited

Legend:

Unmodified
Added
Removed

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

    r23366 r23524  
    33 * This class is a place holder for the Tria and the Penta elements.
    44 * It is derived from Element, so DataSets can contain them.
    5  */
     5*/
    66
    77#ifndef _ELEMENT_H_
    … …  
    1212#include "../../datastructures/datastructures.h"
    1313#include "../../toolkits/toolkits.h"
    14 #include "../Update.h"
    1514class DataSet;
    1615class Parameters;
    … …  
    2726class Inputs;
    2827class Input;
     28class IoModel;
    2929class Gauss;
    3030class ElementVector;
    … …  
    3535/*}}}*/
    3636
    37 class Element: public Object,public Update{
     37class Element: public Object{
    3838
    3939        public:
    … …  
    131131                void               InputUpdateFromConstant(int constant, int name);
    132132                void               InputUpdateFromConstant(bool constant, int name);
     133
    133134                bool               IsFloating();
    134135                bool               IsIceInElement();
    … …  
    189190                void               ViscousHeatingCreateInput(void);
    190191
     192
    191193                /*Virtual functions*/
    192194                virtual void       AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    … …  
    240242                virtual void       InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int inputenum)=0;
    241243                virtual void       InputUpdateFromSolutionOneDof(IssmDouble* solution,int inputenum)=0;
     244                #ifdef _HAVE_DAKOTA_
     245                virtual void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int rows, int ncols, int name, int type)=0;
     246                virtual void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type)=0;
     247                #endif
     248                virtual void  InputUpdateFromIoModel(int index, IoModel* iomodel)=0;
     249                virtual void  InputUpdateFromVector(IssmDouble* vector, int name, int type)=0;
    242250                virtual bool       IsFaceOnBoundary(void)=0;
    243251                virtual bool       IsIcefront(void)=0;

  • issm/trunk-jpl/src/c/classes/Loads/Load.h

    r18926 r23524  
    1919class Parameters;
    2020#include "../../datastructures/datastructures.h"
    21 #include "../Update.h"
    2221
    23 class Load: public Object,public Update{
     22class Load: public Object{
    2423
    2524        public:

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

    r23490 r23524  
    1616
    1717#include "../../shared/io/Comm/IssmComm.h"
     18#include "../../shared/Numerics/recast.h"
     19#include "../../shared/Enum/EnumDefinitions.h"
     20#include "../../shared/Exceptions/exceptions.h"
    1821#include "./Loads.h"
    1922#include "./Load.h"

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

    r22856 r23524  
    355355/*}}}*/
    356356
    357 /*Update virtual functions definitions:*/
    358 void  Pengrid::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    359         /*Nothing*/
    360 }
    361 /*}}}*/
    362 void  Pengrid::InputUpdateFromConstant(int constant, int name){/*{{{*/
    363         /*Nothing updated yet*/
    364 }
    365 /*}}}*/
    366 void  Pengrid::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    367 
    368         switch(name){
    369 
    370                 case ResetPenaltiesEnum:
    371                         if (constant) zigzag_counter=0;
    372                         return;
    373 
    374         }
    375 }
    376 /*}}}*/
    377 void  Pengrid::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
    378         /*Nothing updated yet*/
    379 }
    380 /*}}}*/
    381 void  Pengrid::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    382         /*Nothing updated yet*/
    383 }
    384 /*}}}*/
    385 void  Pengrid::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    386         /*Nothing updated yet*/
    387 }
    388 /*}}}*/
    389 
    390357/*Pengrid management:*/
    391358void           Pengrid::ConstraintActivate(int* punstable){/*{{{*/
    … …  
    693660}
    694661/*}}}*/
     662void           Pengrid::ResetZigzagCounter(){/*{{{*/
     663
     664        zigzag_counter=0;
     665}
     666/*}}}*/

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.h

    r21915 r23524  
    5757                int   ObjectEnum();
    5858                /*}}}*/
    59                 /*Update virtual functions resolution: {{{*/
    60                 void  InputUpdateFromConstant(IssmDouble constant, int name);
    61                 void  InputUpdateFromConstant(int constant, int name);
    62                 void  InputUpdateFromConstant(bool constant, int name);
    63                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    64                 void  InputUpdateFromMatrixDakota(IssmDouble* matrix ,int nrows, int ncols, int name, int type);
    65                 void  InputUpdateFromVector(IssmDouble* vector, int name, int type);
    66                 void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
    67                 /*}}}*/
    6859                /*Load virtual functions definitions: {{{*/
    6960                void  Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
    … …  
    9485                ElementVector* PenaltyCreatePVectorThermal(IssmDouble kmax);
    9586                void  ResetConstraint(void);
     87                void  ResetZigzagCounter(void);
    9688                /*}}}*/
    9789

  • issm/trunk-jpl/src/c/classes/Materials/Material.h

    r22105 r23524  
    1111template <class doubletype> class Vector;
    1212#include "../../datastructures/datastructures.h"
    13 #include "../Update.h"
     13#include "../../toolkits/toolkits.h"
    1414class Element;
    1515class Elements;
    … …  
    1818/*}}}*/
    1919
    20 class Material: public Object,public Update{
     20class Material: public Object{
    2121
    2222        public:
    2323                virtual ~Material(){};
    24                 /*WARNING: input should not be public but it is an easy way to update B from T (using UpdateFromSolution) from Pentas*/
    2524
    2625                /*Numerics*/

  • issm/trunk-jpl/src/c/classes/Materials/Matestar.cpp

    r23066 r23524  
    370370}
    371371/*}}}*/
    372 void  Matestar::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    373         /*Nothing updated yet*/
    374 }
    375 /*}}}*/
    376 void  Matestar::InputUpdateFromConstant(int constant, int name){/*{{{*/
    377         /*Nothing updated yet*/
    378 }
    379 /*}}}*/
    380 void  Matestar::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    381         /*Nothing updated yet*/
    382 }
    383 /*}}}*/
    384 void  Matestar::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    385         /*Nothing updated yet*/
    386 }
    387 /*}}}*/
    388 void  Matestar::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    389 
    390 }
    391 /*}}}*/
    392 void  Matestar::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    393 
    394 }
    395 /*}}}*/
    396372bool Matestar::IsDamage(){/*{{{*/
    397373

  • issm/trunk-jpl/src/c/classes/Materials/Matestar.h

    r22105 r23524  
    4444                int   ObjectEnum();
    4545                /*}}}*/
    46                 /*Update virtual funictions definitions: {{{*/
    47                 void  InputUpdateFromConstant(IssmDouble constant, int name);
    48                 void  InputUpdateFromConstant(int constant, int name);
    49                 void  InputUpdateFromConstant(bool constant, int name);
    50                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    51                 void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols, int name, int type);
    52                 void  InputUpdateFromVector(IssmDouble* vector, int name, int type);
    53                 void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
    54                 /*}}}*/
    5546                /*Material virtual functions resolution: {{{*/
    5647                void   Configure(Elements* elements);

  • issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

    r23066 r23524  
    654654}
    655655/*}}}*/
    656 void  Matice::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    657         /*Nothing updated yet*/
    658 }
    659 /*}}}*/
    660 void  Matice::InputUpdateFromConstant(int constant, int name){/*{{{*/
    661         /*Nothing updated yet*/
    662 }
    663 /*}}}*/
    664 void  Matice::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    665         /*Nothing updated yet*/
    666 }
    667 /*}}}*/
    668 void  Matice::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    669         /*Nothing updated yet*/
    670 }
    671 /*}}}*/
    672 void  Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    673 
    674 }
    675 /*}}}*/
    676 void  Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    677 
    678 }
    679 /*}}}*/
    680656void  Matice::ResetHooks(){/*{{{*/
    681657

  • issm/trunk-jpl/src/c/classes/Materials/Matice.h

    r22105 r23524  
    4848                int   ObjectEnum();
    4949                /*}}}*/
    50                 /*Update virtual funictions definitions: {{{*/
    51                 void  InputUpdateFromConstant(IssmDouble constant, int name);
    52                 void  InputUpdateFromConstant(int constant, int name);
    53                 void  InputUpdateFromConstant(bool constant, int name);
    54                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    55                 void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols, int name, int type);
    56                 void  InputUpdateFromVector(IssmDouble* vector, int name, int type);
    57                 void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
    58                 /*}}}*/
    5950                /*Material virtual functions resolution: {{{*/
    6051                void   Configure(Elements* elements);

  • issm/trunk-jpl/src/c/classes/Materials/Matlitho.cpp

    r23066 r23524  
    182182/*}}}*/
    183183
    184 /*Update virtual functions definitions:*/
    185 
    186184/*Matlitho management: */
    187185void       Matlitho::Configure(Elements* elementsin){/*{{{*/

  • issm/trunk-jpl/src/c/classes/Materials/Matlitho.h

    r22105 r23524  
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                int     ObjectEnum();
    41                 /*}}}*/
    42                 /*Update virtual functions resolution: {{{*/
    43                 void   InputUpdateFromConstant(IssmDouble constant, int name){_error_("not implemented");};
    44                 void   InputUpdateFromConstant(int constant, int name){_error_("not implemented");};
    45                 void   InputUpdateFromConstant(bool constant, int name){_error_("not implemented");};
    46                 void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    47                 void   InputUpdateFromMatrixDakota(IssmDouble* matrix,int nrows,int ncols, int name, int type){_error_("not implemented");};
    48                 void   InputUpdateFromVector(IssmDouble* vector, int name, int type){_error_("not implemented");};
    49                 void   InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("not implemented");};
    5041                /*}}}*/
    5142                /*Material virtual functions resolution: {{{*/

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp

    r23366 r23524  
    529529}
    530530/*}}}*/
    531 void   Matpar::InputUpdateFromConstant(int constant, int name){/*{{{*/
    532         /*Nothing updated yet*/
    533 }
    534 /*}}}*/
    535 void   Matpar::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    536         /*Nothing updated yet*/
    537 }
    538 /*}}}*/
    539 void  Matpar::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    540         /*Nothing updated yet*/
    541 }
    542 /*}}}*/
    543 void   Matpar::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    544         /*Nothing updated yet*/
    545 }
    546 /*}}}*/
    547 void   Matpar::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    548         /*Nothing updated yet*/
    549 }
    550 /*}}}*/
    551531
    552532/*Matpar management: */

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.h

    r22955 r23524  
    7777                int     ObjectEnum();
    7878                /*}}}*/
    79                 /*Update virtual functions resolution: {{{*/
    80                 void   InputUpdateFromConstant(IssmDouble constant, int name);
    81                 void   InputUpdateFromConstant(int constant, int name);
    82                 void   InputUpdateFromConstant(bool constant, int name);
    83                 void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");};
    84                 void   InputUpdateFromMatrixDakota(IssmDouble* matrix,int nrows,int ncols, int name, int type);
    85                 void   InputUpdateFromVector(IssmDouble* vector, int name, int type);
    86                 void   InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
    87                 /*}}}*/
    8879                /*Material virtual functions resolution: {{{*/
    8980                Material*  copy2(Element* element){_error_("not implemented");};
    … …  
    131122                void       ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure);
    132123                IssmDouble TMeltingPoint(IssmDouble pressure);
     124                void       InputUpdateFromConstant(IssmDouble constant, int name);
    133125                /*}}}*/
    134126

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

    r21484 r23524  
    1111#include "../shared/shared.h"
    1212#include "./DofIndexing.h"
    13 #include "./Update.h"
    1413class  Inputs;
    1514class  Hook;

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

    r22612 r23524  
    131131#include "./DofIndexing.h"
    132132#include "./IoModel.h"
    133 #include "./Update.h"
    134133#include "./FemModel.h"
    135134#include "./GiaDeflectionCoreArgs.h"

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

    r18521 r23524  
    1818        }
    1919
    20         for(i=0;i<femmodel->loads->Size();i++){
    21                 Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    22                 load->InputUpdateFromConstant(constant,name);
    23         }
    24 
    2520        for(i=0;i<femmodel->materials->Size();i++){
    2621                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    27                 material->InputUpdateFromConstant(constant,name);
     22                if(material->ObjectEnum()==MatparEnum){
     23                        ((Matpar*)material)->InputUpdateFromConstant(constant,name);
     24                }
    2825        }
    2926}
    … …  
    3835                element->InputUpdateFromConstant(constant,name);
    3936        }
    40 
    41         for(i=0;i<femmodel->loads->Size();i++){
    42                 Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    43                 load->InputUpdateFromConstant(constant,name);
    44         }
    45 
    4637        for(i=0;i<femmodel->materials->Size();i++){
    4738                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    48                 material->InputUpdateFromConstant(constant,name);
     39                if(material->ObjectEnum()==MatparEnum){
     40                        ((Matpar*)material)->InputUpdateFromConstant(constant,name);
     41                }
    4942        }
    5043}
    … …  
    5952                element->InputUpdateFromConstant(constant,name);
    6053        }
    61 
    62         for(i=0;i<femmodel->loads->Size();i++){
    63                 Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    64                 load->InputUpdateFromConstant(constant,name);
    65         }
    66 
    6754        for(i=0;i<femmodel->materials->Size();i++){
    6855                Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    69                 material->InputUpdateFromConstant(constant,name);
     56                if(material->ObjectEnum()==MatparEnum){
     57                        ((Matpar*)material)->InputUpdateFromConstant(constant,name);
     58                }
    7059        }
    7160
    … …  
    7362void InputUpdateFromConstantx(Elements* elements,IssmDouble constant, int name){
    7463
    75         int i;
    7664        if(VerboseModule()) _printf0_("   Input updates from constant\n");
    7765
    7866        /*Elements and loads drive the update: */
    79         for(i=0;i<elements->Size();i++){
     67        for(int i=0;i<elements->Size();i++){
    8068                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    8169                element->InputUpdateFromConstant(constant,name);

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

    r22200 r23524  
    2323                element->InputUpdateFromVectorDakota(vector,name,type);
    2424        }
    25         for(int i=0;i<femmodel->loads->Size();i++){
    26                 Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    27                 load->InputUpdateFromVectorDakota(vector,name,type);
    28         }
    29         for(int i=0;i<femmodel->materials->Size();i++){
    30                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    31                 material->InputUpdateFromVectorDakota(vector,name,type);
    32         }
    33         for(int i=0;i<femmodel->constraints->Size();i++){
    34                 Constraint* constraint=(Constraint*)femmodel->constraints->GetObjectByOffset(i);
    35                 constraint->InputUpdateFromVectorDakota(vector,femmodel->nodes,name,type);
    36         }
    3725}

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

    r18521 r23524  
    1616void InputUpdateFromVectorx(FemModel* femmodel,IssmDouble* vector, int name, int type){
    1717
    18         int i;
    19 
    2018        /*Update elements, nodes, loads and materials from inputs: */
    21         for(i=0;i<femmodel->elements->Size();i++){
     19        for(int i=0;i<femmodel->elements->Size();i++){
    2220                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2321                element->InputUpdateFromVector(vector,name,type);
    2422        }
    25         for(i=0;i<femmodel->loads->Size();i++){
    26                 Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
    27                 load->InputUpdateFromVector(vector,name,type);
    28         }
    29         for(i=0;i<femmodel->materials->Size();i++){
    30                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    31                 material->InputUpdateFromVector(vector,name,type);
    32         }
    3323}

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

    r23490 r23524  
    3838        }
    3939}
     40void ResetZigzagCounterx(FemModel* femmodel){
     41
     42        /*Display message*/
     43        if(VerboseModule()) _printf0_("   Resetting penalties\n");
     44
     45        /*Deal with rift first*/
     46        if(RiftIsPresent(femmodel->loads,femmodel->analysis_type_list[femmodel->analysis_counter])){
     47                _error_("rift constraints reset not supported yet!");
     48        }
     49
     50        /*Reset pengrid to inactive mode*/
     51        for(int i=0;i<femmodel->loads->Size();i++){
     52                Load* load=(Load*)femmodel->loads->GetObjectByOffset(i);
     53                if(load->ObjectEnum()==PengridEnum){
     54                        Pengrid* pengrid=(Pengrid*)load;
     55                        pengrid->ResetZigzagCounter();
     56                }
     57        }
     58}

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

    r16206 r23524  
    1010/* local prototypes: */
    1111void ResetConstraintsx(FemModel* femmodel);
     12void ResetZigzagCounterx(FemModel* femmodel);
    1213
    1314#endif  /* _RESETCONSTRAINTSX_H */

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

    r23173 r23524  
    7777        /*Assemble vector and serialize */
    7878        vec_mask_ice->Assemble();
    79         IssmDouble* mask_ice=vec_mask_ice->ToMPISerial();
    80         InputUpdateFromVectorx(femmodel,mask_ice,IceMaskNodeActivationEnum,VertexSIdEnum);
    81 
    82         /*Clean up and return*/
     79        InputUpdateFromVectorx(femmodel,vec_mask_ice,IceMaskNodeActivationEnum,VertexSIdEnum);
    8380        delete vec_mask_ice;
    84         xDelete<IssmDouble>(mask_ice);
    8581}/*}}}*/
    8682void GetMaskOfIceVerticesLSMx(FemModel* femmodel){/*{{{*/

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

    r23474 r23524  
    10701070        RegionaloutputEnum,
    10711071        RegularEnum,
    1072         ResetPenaltiesEnum,
    10731072        RiftfrontEnum,
    10741073        ScaledEnum,

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

    r23474 r23524  
    10741074                case RegionaloutputEnum : return "Regionaloutput";
    10751075                case RegularEnum : return "Regular";
    1076                 case ResetPenaltiesEnum : return "ResetPenalties";
    10771076                case RiftfrontEnum : return "Riftfront";
    10781077                case ScaledEnum : return "Scaled";

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

    r23474 r23524  
    10981098              else if (strcmp(name,"Regionaloutput")==0) return RegionaloutputEnum;
    10991099              else if (strcmp(name,"Regular")==0) return RegularEnum;
    1100               else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum;
    11011100              else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
    11021101              else if (strcmp(name,"Scaled")==0) return ScaledEnum;
    … …  
    11211120              else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
    11221121              else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum;
     1122              else if (strcmp(name,"SmbAnalysis")==0) return SmbAnalysisEnum;
    11231123         else stage=10;
    11241124   }
    11251125   if(stage==10){
    1126               if (strcmp(name,"SmbAnalysis")==0) return SmbAnalysisEnum;
    1127               else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
     1126              if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
    11281127              else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
    11291128              else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;

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

    r23387 r23524  
    8484                /*Loop on sediment layer to deal with transfer and head value*/
    8585                femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
    86                 InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     86                ResetZigzagCounterx(femmodel);
    8787                InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
    8888                femmodel->UpdateConstraintsx();
    … …  
    161161                        femmodel->HydrologyEPLupdateDomainx(&ThickCount);
    162162                        inefanalysis->ElementizeEplMask(femmodel);
    163                         InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     163                        ResetZigzagCounterx(femmodel);
    164164                        InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
    165165

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

    r23066 r23524  
    5656        else{
    5757                femmodel->parameters->FindParam(&thermal_penalty_threshold,ThermalPenaltyThresholdEnum);
    58                 InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
     58                ResetZigzagCounterx(femmodel);
    5959                femmodel->UpdateConstraintsx();
    6060        }
Note: See TracChangeset for help on using the changeset viewer.