Changeset 12530


Ignore:
Timestamp:
06/25/12 12:18:07 (13 years ago)
Author:
utke
Message:

in the first round the assumption was made that the inputs remain passive but in the second round after discussion with M. Morlighem all inputs were consistently made active with the exception of the xyz_list arguments

Location:
issm/trunk-jpl/src/c/objects/Inputs
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/objects/Inputs/BoolInput.cpp

    r12529 r12530  
    2323}
    2424/*}}}*/
    25 /*FUNCTION BoolInput::BoolInput(IssmPDouble* values){{{*/
     25/*FUNCTION BoolInput::BoolInput(IssmDouble* values){{{*/
    2626BoolInput::BoolInput(int in_enum_type,IssmBool in_value){
    2727
    … …  
    9898/*}}}*/
    9999/*FUNCTION BoolInput::SpawnResult{{{*/
    100 ElementResult* BoolInput::SpawnResult(int step, IssmPDouble time){
     100ElementResult* BoolInput::SpawnResult(int step, IssmDouble time){
    101101       
    102102        return new BoolElementResult(this->enum_type,this->value,step,time);
    … …  
    114114void BoolInput::GetInputValue(int* pvalue){_error2_("not supported yet!");}
    115115/*}}}*/
    116 /*FUNCTION BoolInput::GetInputValue(IssmPDouble* pvalue){{{*/
    117 void BoolInput::GetInputValue(IssmPDouble* pvalue){_error2_("not supported yet!");}
    118 /*}}}*/
    119 /*FUNCTION BoolInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){{{*/
    120 void BoolInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
    121 /*}}}*/
    122 /*FUNCTION BoolInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){{{*/
    123 void BoolInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
    124 /*}}}*/
    125 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    126 void BoolInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
    127 /*}}}*/
    128 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    129 void BoolInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
     116/*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue){{{*/
     117void BoolInput::GetInputValue(IssmDouble* pvalue){_error2_("not supported yet!");}
     118/*}}}*/
     119/*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
     120void BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
     121/*}}}*/
     122/*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
     123void BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
     124/*}}}*/
     125/*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     126void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
     127/*}}}*/
     128/*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     129void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
    130130/*}}}*/
    131131/*FUNCTION BoolInput::ChangeEnum{{{*/
    … …  
    135135/*}}}*/
    136136/*FUNCTION BoolInput::SquareMin{{{*/
    137 void BoolInput::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
     137void BoolInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
    138138        /*square of a bool is the bool itself: */
    139139        *psquaremin=value;
    … …  
    141141/*}}}*/
    142142/*FUNCTION BoolInput::Scale{{{*/
    143 void BoolInput::Scale(IssmPDouble scale_factor){
     143void BoolInput::Scale(IssmDouble scale_factor){
    144144        /*a bool cannot be scaled: */
    145145}
    146146/*}}}*/
    147147/*FUNCTION BoolInput::AXPY{{{*/
    148 void BoolInput::AXPY(Input* xinput,IssmPDouble scalar){
     148void BoolInput::AXPY(Input* xinput,IssmDouble scalar){
    149149
    150150        BoolInput*  xboolinput=NULL;
    … …  
    167167/*}}}*/
    168168/*FUNCTION BoolInput::Constrain{{{*/
    169 void BoolInput::Constrain(IssmPDouble cm_min, IssmPDouble cm_max){
     169void BoolInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
    170170
    171171        if(!xIsNan<IssmDouble>(cm_min)) if (this->value<cm_min)this->value=cm_min;
    … …  
    189189/*}}}*/
    190190/*FUNCTION BoolInput::GetValuesPtr{{{*/
    191 void BoolInput::GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){
     191void BoolInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
    192192
    193193        _error2_("not supported yet!");

  • issm/trunk-jpl/src/c/objects/Inputs/BoolInput.h

    r12494 r12530  
    4040                Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
    4141                Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
    42                 ElementResult* SpawnResult(int step, IssmPDouble time);
     42                ElementResult* SpawnResult(int step, IssmDouble time);
    4343                void Configure(Parameters* parameters);
    44                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     44                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4545                /*}}}*/
    4646                /*numerics: {{{*/
    4747                void GetInputValue(bool* pvalue);
    4848                void GetInputValue(int* pvalue);
    49                 void GetInputValue(IssmPDouble* pvalue);
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss);
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    56                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
    57                 void GetInputAverage(IssmPDouble* pvalue){_error2_("not implemented yet");};
    58                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    59                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    60                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    61                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    62                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    63                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    64                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue);
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     51                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     56                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
     57                void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
     58                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     59                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     60                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     61                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     62                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     63                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     64                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    6565                void ChangeEnum(int newenumtype);
    66                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    67                 void ConstrainMin(IssmPDouble minimum){_error2_("not implemented yet");};
    68                 IssmPDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for booleans");};
    69                 IssmPDouble Max(void){_error2_("Max not implemented for booleans");};
    70                 IssmPDouble MaxAbs(void){_error2_("Max not implemented for booleans");};
    71                 IssmPDouble Min(void){_error2_("Min not implemented for booleans");};
    72                 IssmPDouble MinAbs(void){_error2_("Min not implemented for booleans");};
    73                 void Scale(IssmPDouble scale_factor);
    74                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    75                 void AXPY(Input* xinput,IssmPDouble scalar);
    76                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max);
     66                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     67                void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
     68                IssmDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for booleans");};
     69                IssmDouble Max(void){_error2_("Max not implemented for booleans");};
     70                IssmDouble MaxAbs(void){_error2_("Max not implemented for booleans");};
     71                IssmDouble Min(void){_error2_("Min not implemented for booleans");};
     72                IssmDouble MinAbs(void){_error2_("Min not implemented for booleans");};
     73                void Scale(IssmDouble scale_factor);
     74                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     75                void AXPY(Input* xinput,IssmDouble scalar);
     76                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
    7777                void Extrude(void);
    7878                void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
    7979                void GetVectorFromInputs(Vector* vector,int* doflist);
    80                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values);
     80                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);
    8181                /*}}}*/
    8282

  • issm/trunk-jpl/src/c/objects/Inputs/ControlInput.cpp

    r12511 r12530  
    2828}
    2929/*}}}*/
    30 /*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,IssmPDouble* pvalues,IssmPDouble* pmin,IssmPDouble* pmax,int id){{{*/
    31 ControlInput::ControlInput(int in_enum_type,int enum_input,IssmPDouble* pvalues,IssmPDouble* pmin,IssmPDouble* pmax,int id){
     30/*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id){{{*/
     31ControlInput::ControlInput(int in_enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id){
    3232
    3333        control_id=id;
    … …  
    136136        delete values; this->values=newvalues;
    137137}/*}}}*/
    138 /*FUNCTION ControlInput::Constrain(IssmPDouble min, IssmPDouble max){{{*/
    139 void ControlInput::Constrain(IssmPDouble min, IssmPDouble max){
     138/*FUNCTION ControlInput::Constrain(IssmDouble min, IssmDouble max){{{*/
     139void ControlInput::Constrain(IssmDouble min, IssmDouble max){
    140140           values->Constrain(min,max);
    141141}/*}}}*/
    … …  
    151151}/*}}}*/
    152152/*FUNCTION ControlInput::ScaleGradient{{{*/
    153 void ControlInput::ScaleGradient(IssmPDouble scaling_factor){
     153void ControlInput::ScaleGradient(IssmDouble scaling_factor){
    154154        if(!gradient) _error2_("Gradient of ControlInput " << EnumToStringx(enum_type) << " not found");
    155155        gradient->Scale(scaling_factor);
    … …  
    186186}/*}}}*/
    187187/*FUNCTION ControlInput::SpawnResult{{{*/
    188 ElementResult* ControlInput::SpawnResult(int step, IssmPDouble time){
     188ElementResult* ControlInput::SpawnResult(int step, IssmDouble time){
    189189        return savedvalues->SpawnResult(step,time);
    190190}/*}}}*/
    … …  
    194194}/*}}}*/
    195195/*FUNCTION ControlInput::SpawnGradient{{{*/
    196 ElementResult* ControlInput::SpawnGradient(int step, IssmPDouble time){
     196ElementResult* ControlInput::SpawnGradient(int step, IssmDouble time){
    197197        _assert_(gradient);
    198198        return gradient->SpawnResult(step,time);
    … …  
    224224         }
    225225}/*}}}*/
    226 /*FUNCTION ControlInput::GetInputAverage(IssmPDouble* pvalue){{{*/
    227 void ControlInput::GetInputAverage(IssmPDouble* pvalue){
     226/*FUNCTION ControlInput::GetInputAverage(IssmDouble* pvalue){{{*/
     227void ControlInput::GetInputAverage(IssmDouble* pvalue){
    228228        values->GetInputAverage(pvalue);
    229229}/*}}}*/
    … …  
    236236        values->GetInputValue(pvalue);
    237237}/*}}}*/
    238 /*FUNCTION ControlInput::GetInputValue(IssmPDouble* pvalue){{{*/
    239 void ControlInput::GetInputValue(IssmPDouble* pvalue){
     238/*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
     239void ControlInput::GetInputValue(IssmDouble* pvalue){
    240240        values->GetInputValue(pvalue);
    241241}/*}}}*/
    242 /*FUNCTION ControlInput::GetInputValue(IssmPDouble* pvalue){{{*/
    243 void ControlInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){
     242/*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
     243void ControlInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
    244244        values->GetInputValue(pvalue,gauss);
    245245}/*}}}*/
    246 /*FUNCTION ControlInput::GetInputValue(IssmPDouble* pvalue){{{*/
    247 void ControlInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){
     246/*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
     247void ControlInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){
    248248        values->GetInputValue(pvalue,gauss);
    249249}/*}}}*/
    250 /*FUNCTION ControlInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    251 void ControlInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){
     250/*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     251void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){
    252252        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    253253}/*}}}*/
    254 /*FUNCTION ControlInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    255 void ControlInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){
     254/*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     255void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){
    256256        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    257257}/*}}}*/
    … …  
    264264}/*}}}*/
    265265/*FUNCTION ControlInput::UpdateValue{{{*/
    266 void ControlInput::UpdateValue(IssmPDouble scalar){
     266void ControlInput::UpdateValue(IssmDouble scalar){
    267267        if(!gradient)    _error2_("Gradient of " << EnumToStringx(this->enum_type) << " not found");
    268268        if(!savedvalues) _error2_("Values of " << EnumToStringx(this->enum_type) << " not found");

  • issm/trunk-jpl/src/c/objects/Inputs/ControlInput.h

    r12494 r12530  
    2727                /*ControlInput constructors, destructors: {{{*/
    2828                ControlInput();
    29                 ControlInput(int enum_type,int enum_input,IssmPDouble* pvalues,IssmPDouble* pmin,IssmPDouble* pmax,int id);
     29                ControlInput(int enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id);
    3030                ~ControlInput();
    3131                /*}}}*/
    … …  
    4444                Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
    4545                Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
    46                 ElementResult* SpawnResult(int step, IssmPDouble time);
    47                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     46                ElementResult* SpawnResult(int step, IssmDouble time);
     47                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4848                void Configure(Parameters* parameters);
    4949                /*}}}*/
    … …  
    5252                void GetInputValue(bool* pvalue);
    5353                void GetInputValue(int* pvalue);
    54                 void GetInputValue(IssmPDouble* pvalue);
    55                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    56                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    57                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss);
    58                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    59                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    60                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    61                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
    62                 void GetInputAverage(IssmPDouble* pvalue);
    63                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    64                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    65                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    66                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    67                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    68                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    69                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     54                void GetInputValue(IssmDouble* pvalue);
     55                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     56                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     57                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
     58                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     59                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     60                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     61                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
     62                void GetInputAverage(IssmDouble* pvalue);
     63                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     64                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     65                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     66                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     67                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     68                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     69                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    7070                void ChangeEnum(int newenumtype){_error2_("not implemented yet");};
    71                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
    72                 void ConstrainMin(IssmPDouble minimum){_error2_("not implemented yet");};
    73                 void Scale(IssmPDouble scale_factor){_error2_("not implemented yet");};
    74                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    75                 void AXPY(Input* xinput,IssmPDouble scalar){_error2_("not implemented yet");};
     71                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
     72                void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
     73                void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
     74                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     75                void AXPY(Input* xinput,IssmDouble scalar){_error2_("not implemented yet");};
    7676                void Constrain(void);
    77                 void Constrain(IssmPDouble min,IssmPDouble max);
    78                 IssmPDouble InfinityNorm(void){_error2_("not implemented yet");};
    79                 IssmPDouble Max(void){_error2_("not implemented yet");};
    80                 IssmPDouble MaxAbs(void){_error2_("not implemented yet");};
    81                 IssmPDouble Min(void){_error2_("not implemented yet");};
    82                 IssmPDouble MinAbs(void){_error2_("not implemented yet");};
     77                void Constrain(IssmDouble min,IssmDouble max);
     78                IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
     79                IssmDouble Max(void){_error2_("not implemented yet");};
     80                IssmDouble MaxAbs(void){_error2_("not implemented yet");};
     81                IssmDouble Min(void){_error2_("not implemented yet");};
     82                IssmDouble MinAbs(void){_error2_("not implemented yet");};
    8383                void Extrude(void);
    8484                void VerticallyIntegrate(Input* thickness_input);
    8585                void GetVectorFromInputs(Vector* vector,int* doflist,const char* data);
    8686                void GetVectorFromInputs(Vector* vector,int* doflist);
    87                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
    88                 ElementResult* SpawnGradient(int step, IssmPDouble time);
     87                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
     88                ElementResult* SpawnGradient(int step, IssmDouble time);
    8989                void GetGradient(Vector* gradient_vec,int* doflist);
    90                 void ScaleGradient(IssmPDouble scale);
     90                void ScaleGradient(IssmDouble scale);
    9191                void SetGradient(Input* gradient_in);
    92                 void UpdateValue(IssmPDouble scalar);
     92                void UpdateValue(IssmDouble scalar);
    9393                void SaveValue(void);
    9494                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Inputs/DatasetInput.cpp

    r12511 r12530  
    111111}
    112112/*}}}*/
    113 /*FUNCTION DatasetInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,int index){{{*/
    114 void DatasetInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,int index){
     113/*FUNCTION DatasetInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,int index){{{*/
     114void DatasetInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,int index){
    115115
    116116        /*Get requested input within dataset*/

  • issm/trunk-jpl/src/c/objects/Inputs/DatasetInput.h

    r12494 r12530  
    4040                Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
    4141                Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
    42                 ElementResult* SpawnResult(int step, IssmPDouble time){_error2_("not implemented yet");};
    43                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     42                ElementResult* SpawnResult(int step, IssmDouble time){_error2_("not implemented yet");};
     43                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4444                void Configure(Parameters* parameters);
    4545                /*}}}*/
    … …  
    4747                void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
    4848                void GetInputValue(int* pvalue){_error2_("not implemented yet");};
    49                 void GetInputValue(IssmPDouble* pvalue){_error2_("not implemented yet");};
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
    51                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index);
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    56                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    57                 void GetInputAverage(IssmPDouble* pvalue){_error2_("not implemented yet");};
    58                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    59                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    60                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    61                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    62                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    63                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    64                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index);
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     56                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     57                void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
     58                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     59                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     60                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     61                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     62                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     63                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     64                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    6565                void ChangeEnum(int newenumtype){_error2_("not implemented yet");};
    66                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
    67                 void ConstrainMin(IssmPDouble minimum){_error2_("not implemented yet");};
    68                 void Scale(IssmPDouble scale_factor){_error2_("not implemented yet");};
    69                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    70                 void AXPY(Input* xinput,IssmPDouble scalar){_error2_("not implemented yet");};
     66                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
     67                void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
     68                void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
     69                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     70                void AXPY(Input* xinput,IssmDouble scalar){_error2_("not implemented yet");};
    7171                void Constrain(void){_error2_("not implemented yet");};
    72                 void Constrain(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    73                 IssmPDouble InfinityNorm(void){_error2_("not implemented yet");};
    74                 IssmPDouble Max(void){_error2_("not implemented yet");};
    75                 IssmPDouble MaxAbs(void){_error2_("not implemented yet");};
    76                 IssmPDouble Min(void){_error2_("not implemented yet");};
    77                 IssmPDouble MinAbs(void){_error2_("not implemented yet");};
     72                void Constrain(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     73                IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
     74                IssmDouble Max(void){_error2_("not implemented yet");};
     75                IssmDouble MaxAbs(void){_error2_("not implemented yet");};
     76                IssmDouble Min(void){_error2_("not implemented yet");};
     77                IssmDouble MinAbs(void){_error2_("not implemented yet");};
    7878                void Extrude(void){_error2_("not implemented yet");};
    7979                void VerticallyIntegrate(Input* thickness_input){_error2_("not implemented yet");};
    8080                void GetVectorFromInputs(Vector* vector,int* doflist){_error2_("not implemented yet");};
    81                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
    82                 ElementResult* SpawnGradient(int step, IssmPDouble time){_error2_("not implemented yet");};
     81                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
     82                ElementResult* SpawnGradient(int step, IssmDouble time){_error2_("not implemented yet");};
    8383                void GetGradient(Vector* gradient_vec,int* doflist){_error2_("not implemented yet");};
    84                 void ScaleGradient(IssmPDouble scale){_error2_("not implemented yet");};
     84                void ScaleGradient(IssmDouble scale){_error2_("not implemented yet");};
    8585                void SetGradient(Input* gradient_in){_error2_("not implemented yet");};
    86                 void UpdateValue(IssmPDouble scalar){_error2_("not implemented yet");};
     86                void UpdateValue(IssmDouble scalar){_error2_("not implemented yet");};
    8787                void SaveValue(void){_error2_("not implemented yet");};
    8888                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.cpp

    r12529 r12530  
    2323}
    2424/*}}}*/
    25 /*FUNCTION DoubleInput::DoubleInput(IssmPDouble value){{{*/
     25/*FUNCTION DoubleInput::DoubleInput(IssmDouble value){{{*/
    2626DoubleInput::DoubleInput(int in_enum_type,IssmDouble in_value){
    2727
    … …  
    9898/*}}}*/
    9999/*FUNCTION DoubleInput::SpawnResult{{{*/
    100 ElementResult* DoubleInput::SpawnResult(int step, IssmPDouble time){
     100ElementResult* DoubleInput::SpawnResult(int step, IssmDouble time){
    101101
    102102        return new DoubleElementResult(this->enum_type,this->value,step,time);
    … …  
    118118}
    119119/*}}}*/
    120 /*FUNCTION DoubleInput::GetInputValue(IssmPDouble* pvalue){{{*/
    121 void DoubleInput::GetInputValue(IssmPDouble* pvalue){
     120/*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue){{{*/
     121void DoubleInput::GetInputValue(IssmDouble* pvalue){
    122122
    123123        /*return value*/
    … …  
    125125}
    126126/*}}}*/
    127 /*FUNCTION DoubleInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){{{*/
    128 void DoubleInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){*pvalue=this->value;}
    129 /*}}}*/
    130 /*FUNCTION DoubleInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){{{*/
    131 void DoubleInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){*pvalue=this->value;}
    132 /*}}}*/
    133 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    134 void DoubleInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
    135 /*}}}*/
    136 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    137 void DoubleInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
    138 /*}}}*/
    139 /*FUNCTION DoubleInput::GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    140 void DoubleInput::GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){
     127/*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
     128void DoubleInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){*pvalue=this->value;}
     129/*}}}*/
     130/*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
     131void DoubleInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){*pvalue=this->value;}
     132/*}}}*/
     133/*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     134void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
     135/*}}}*/
     136/*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     137void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
     138/*}}}*/
     139/*FUNCTION DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     140void DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){
    141141        /*Epsilon is zero as vx is constant over the element*/
    142142        for(int i=0;i<3;i++) epsilonvx[i]=0;
    143143}
    144144/*}}}*/
    145 /*FUNCTION DoubleInput::GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    146 void DoubleInput::GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){
     145/*FUNCTION DoubleInput::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     146void DoubleInput::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){
    147147        /*Epsilon is zero as vy is constant over the element*/
    148148        for(int i=0;i<3;i++) epsilonvy[i]=0;
    149149}
    150150/*}}}*/
    151 /*FUNCTION DoubleInput::GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    152 void DoubleInput::GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
     151/*FUNCTION DoubleInput::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     152void DoubleInput::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
    153153        /*Epsilon is zero as vx is constant over the element*/
    154154        for(int i=0;i<6;i++) epsilonvx[i]=0;
    155155}
    156156/*}}}*/
    157 /*FUNCTION DoubleInput::GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    158 void DoubleInput::GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
     157/*FUNCTION DoubleInput::GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     158void DoubleInput::GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
    159159        /*Epsilon is zero as vy is constant over the element*/
    160160        for(int i=0;i<6;i++) epsilonvy[i]=0;
    161161}
    162162/*}}}*/
    163 /*FUNCTION DoubleInput::GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    164 void DoubleInput::GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){
     163/*FUNCTION DoubleInput::GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     164void DoubleInput::GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){
    165165        /*Epsilon is zero as vz is constant over the element*/
    166166        for(int i=0;i<6;i++) epsilonvz[i]=0;
    167167}
    168168/*}}}*/
    169 /*FUNCTION DoubleInput::GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    170 void DoubleInput::GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
     169/*FUNCTION DoubleInput::GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     170void DoubleInput::GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
    171171        /*Epsilon is zero as vx is constant over the element*/
    172172        for(int i=0;i<5;i++) epsilonvx[i]=0;
    173173}
    174174/*}}}*/
    175 /*FUNCTION DoubleInput::GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    176 void DoubleInput::GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
     175/*FUNCTION DoubleInput::GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     176void DoubleInput::GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
    177177        /*Epsilon is zero as vy is constant over the element*/
    178178        for(int i=0;i<5;i++) epsilonvy[i]=0;
    … …  
    185185/*}}}*/
    186186/*FUNCTION DoubleInput::SquareMin{{{*/
    187 void DoubleInput::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
    188 
    189         /*square min of a IssmPDouble is the square of the IssmPDouble itself: */
     187void DoubleInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     188
     189        /*square min of a IssmDouble is the square of the IssmDouble itself: */
    190190        *psquaremin=pow(value,2);
    191191}
    192192/*}}}*/
    193193/*FUNCTION DoubleInput::Scale{{{*/
    194 void DoubleInput::Scale(IssmPDouble scale_factor){
     194void DoubleInput::Scale(IssmDouble scale_factor){
    195195        value=value*scale_factor;
    196196}
    197197/*}}}*/
    198198/*FUNCTION DoubleInput::ConstrainMin{{{*/
    199 void DoubleInput::ConstrainMin(IssmPDouble minimum){
     199void DoubleInput::ConstrainMin(IssmDouble minimum){
    200200        if (value<minimum) value=minimum;
    201201}
    202202/*}}}*/
    203203/*FUNCTION DoubleInput::AXPY{{{*/
    204 void DoubleInput::AXPY(Input* xinput,IssmPDouble scalar){
    205 
    206         DoubleInput*  xIssmPDoubleinput=NULL;
     204void DoubleInput::AXPY(Input* xinput,IssmDouble scalar){
     205
     206        DoubleInput*  xIssmDoubleinput=NULL;
    207207
    208208        /*xinput is of the same type, so cast it: */
    209         xIssmPDoubleinput=(DoubleInput*)xinput;
     209        xIssmDoubleinput=(DoubleInput*)xinput;
    210210
    211211        /*Carry out the AXPY operation depending on type:*/
    … …  
    213213
    214214                case DoubleInputEnum:
    215                         this->value=this->value+scalar*xIssmPDoubleinput->value;
     215                        this->value=this->value+scalar*xIssmDoubleinput->value;
    216216                        return;
    217217
    … …  
    223223/*}}}*/
    224224/*FUNCTION DoubleInput::Constrain{{{*/
    225 void DoubleInput::Constrain(IssmPDouble cm_min, IssmPDouble cm_max){
     225void DoubleInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
    226226
    227227        if(!xIsNan<IssmDouble>(cm_min)) if (this->value<cm_min)this->value=cm_min;
    … …  
    231231/*}}}*/
    232232/*FUNCTION DoubleInput::Max{{{*/
    233 IssmPDouble DoubleInput::Max(void){
     233IssmDouble DoubleInput::Max(void){
    234234        return this->value;
    235235}
    236236/*}}}*/
    237237/*FUNCTION DoubleInput::MaxAbs{{{*/
    238 IssmPDouble DoubleInput::MaxAbs(void){
     238IssmDouble DoubleInput::MaxAbs(void){
    239239        return fabs(this->value);
    240240}
    241241/*}}}*/
    242242/*FUNCTION DoubleInput::Min{{{*/
    243 IssmPDouble DoubleInput::Min(void){
     243IssmDouble DoubleInput::Min(void){
    244244        return this->value;
    245245}
    246246/*}}}*/
    247247/*FUNCTION DoubleInput::MinAbs{{{*/
    248 IssmPDouble DoubleInput::MinAbs(void){
     248IssmDouble DoubleInput::MinAbs(void){
    249249        return fabs(this->value);
    250250}
    … …  
    258258/*}}}*/
    259259/*FUNCTION DoubleInput::GetValuesPtr{{{*/
    260 void DoubleInput::GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){
     260void DoubleInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
    261261
    262262        _error2_("not supported yet!");
    … …  
    265265/*}}}*/
    266266/*FUNCTION DoubleInput::GetInputAverage{{{*/
    267 void DoubleInput::GetInputAverage(IssmPDouble* pvalue){
     267void DoubleInput::GetInputAverage(IssmDouble* pvalue){
    268268        *pvalue=value;
    269269}
    … …  
    273273
    274274        /*Intermediaries*/
    275         IssmPDouble thickness_value;
     275        IssmDouble thickness_value;
    276276
    277277        /*Check that input provided is a thickness*/
    … …  
    298298
    299299        /*Intermediaries*/
    300         IssmPDouble       Bvalue;
     300        IssmDouble       Bvalue;
    301301
    302302        /*Check that inputB is of the same type*/
    … …  
    318318
    319319        /*Intermediaries*/
    320         IssmPDouble       min;
     320        IssmDouble       min;
    321321
    322322        /*Check that inputB is of the same type*/
    … …  
    339339
    340340        /*Intermediaries*/
    341         IssmPDouble       max;
     341        IssmDouble       max;
    342342
    343343        /*Check that inputB is of the same type*/

  • issm/trunk-jpl/src/c/objects/Inputs/DoubleInput.h

    r12494 r12530  
    1818        public:
    1919                int    enum_type;
    20                 IssmPDouble value;
     20                IssmDouble value;
    2121
    2222                /*DoubleInput constructors, destructors: {{{*/
    … …  
    3939                Input* PointwiseMin(Input* inputB);
    4040                Input* PointwiseMax(Input* inputB);
    41                 ElementResult* SpawnResult(int step, IssmPDouble time);
    42                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     41                ElementResult* SpawnResult(int step, IssmDouble time);
     42                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4343                void Configure(Parameters* parameters);
    4444                /*}}}*/
    … …  
    4646                void GetInputValue(bool* pvalue);
    4747                void GetInputValue(int* pvalue);
    48                 void GetInputValue(IssmPDouble* pvalue);
    49                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    51                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss);
    52                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    53                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    54                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
    56                 void GetInputAverage(IssmPDouble* pvalue);
    57                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss);
    58                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss);
    59                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
    60                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
    61                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss);
    62                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
    63                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
     48                void GetInputValue(IssmDouble* pvalue);
     49                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
     52                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     53                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     54                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
     56                void GetInputAverage(IssmDouble* pvalue);
     57                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss);
     58                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss);
     59                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
     60                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
     61                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss);
     62                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
     63                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
    6464                void ChangeEnum(int newenumtype);
    65                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    66                 void ConstrainMin(IssmPDouble minimum);
    67                 void Scale(IssmPDouble scale_factor);
    68                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    69                 void AXPY(Input* xinput,IssmPDouble scalar);
    70                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max);
    71                 IssmPDouble InfinityNorm(void){_error2_("not implemented yet");};
    72                 IssmPDouble Max(void);
    73                 IssmPDouble MaxAbs(void);
    74                 IssmPDouble Min(void);
    75                 IssmPDouble MinAbs(void);
     65                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     66                void ConstrainMin(IssmDouble minimum);
     67                void Scale(IssmDouble scale_factor);
     68                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     69                void AXPY(Input* xinput,IssmDouble scalar);
     70                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
     71                IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
     72                IssmDouble Max(void);
     73                IssmDouble MaxAbs(void);
     74                IssmDouble Min(void);
     75                IssmDouble MinAbs(void);
    7676                void Extrude(void){_error2_("not supported yet");};
    7777                void VerticallyIntegrate(Input* thickness_input);
    7878                void GetVectorFromInputs(Vector* vector,int* doflist);
    79                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values);
     79                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);
    8080                /*}}}*/
    8181

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

    r12426 r12530  
    2525                virtual void GetInputValue(bool* pvalue)=0;
    2626                virtual void GetInputValue(int* pvalue)=0;
    27                 virtual void GetInputValue(IssmPDouble* pvalue)=0;
    28                 virtual void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss)=0;
    29                 virtual void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time)=0;
    30                 virtual void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss)=0;
    31                 virtual void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index)=0;
    32                 virtual void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss,int index)=0;
    33                 virtual void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss)=0;
    34                 virtual void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    35                 virtual void GetInputAverage(IssmPDouble* pvalue)=0;
    36                 virtual void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss)=0;
    37                 virtual void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss)=0;
    38                 virtual void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    39                 virtual void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    40                 virtual void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    41                 virtual void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    42                 virtual void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     27                virtual void GetInputValue(IssmDouble* pvalue)=0;
     28                virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss)=0;
     29                virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time)=0;
     30                virtual void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss)=0;
     31                virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index)=0;
     32                virtual void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index)=0;
     33                virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss)=0;
     34                virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     35                virtual void GetInputAverage(IssmDouble* pvalue)=0;
     36                virtual void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss)=0;
     37                virtual void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss)=0;
     38                virtual void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     39                virtual void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     40                virtual void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     41                virtual void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
     42                virtual void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss)=0;
    4343                virtual void ChangeEnum(int newenumtype)=0;
    4444                virtual void Configure(Parameters* parameters)=0;
    4545
    46                 virtual void   SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters)=0;
    47                 virtual void   ConstrainMin(IssmPDouble minimum)=0;
    48                 virtual IssmPDouble InfinityNorm(void)=0;
    49                 virtual IssmPDouble MaxAbs(void)=0;
    50                 virtual IssmPDouble MinAbs(void)=0;
    51                 virtual IssmPDouble Max(void)=0;
    52                 virtual IssmPDouble Min(void)=0;
    53                 virtual void   Scale(IssmPDouble scale_factor)=0;
    54                 virtual void   ArtificialNoise(IssmPDouble min,IssmPDouble max)=0;
    55                 virtual void   AXPY(Input* xinput,IssmPDouble scalar)=0;
    56                 virtual void   Constrain(IssmPDouble cm_min, IssmPDouble cm_max)=0;
     46                virtual void   SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters)=0;
     47                virtual void   ConstrainMin(IssmDouble minimum)=0;
     48                virtual IssmDouble InfinityNorm(void)=0;
     49                virtual IssmDouble MaxAbs(void)=0;
     50                virtual IssmDouble MinAbs(void)=0;
     51                virtual IssmDouble Max(void)=0;
     52                virtual IssmDouble Min(void)=0;
     53                virtual void   Scale(IssmDouble scale_factor)=0;
     54                virtual void   ArtificialNoise(IssmDouble min,IssmDouble max)=0;
     55                virtual void   AXPY(Input* xinput,IssmDouble scalar)=0;
     56                virtual void   Constrain(IssmDouble cm_min, IssmDouble cm_max)=0;
    5757                virtual void   VerticallyIntegrate(Input* thickness_input)=0;
    5858                virtual void   Extrude()=0;
    5959                virtual void   GetVectorFromInputs(Vector* vector,int* doflist)=0;
    60                 virtual void   GetValuesPtr(IssmPDouble** pvalues,int* pnum_values)=0;
     60                virtual void   GetValuesPtr(IssmDouble** pvalues,int* pnum_values)=0;
    6161               
    6262                virtual Input* SpawnTriaInput(int* indices)=0;
    … …  
    6464                virtual Input* PointwiseMax(Input* inputmax)=0;
    6565                virtual Input* PointwiseMin(Input* inputmin)=0;
    66                 virtual ElementResult* SpawnResult(int step, IssmPDouble time)=0;
     66                virtual ElementResult* SpawnResult(int step, IssmDouble time)=0;
    6767
    6868                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Inputs/IntInput.cpp

    r12529 r12530  
    2323}
    2424/*}}}*/
    25 /*FUNCTION IntInput::IntInput(IssmPDouble* values){{{*/
     25/*FUNCTION IntInput::IntInput(IssmDouble* values){{{*/
    2626IntInput::IntInput(int in_enum_type,IssmInt in_value){
    2727
    … …  
    9797/*}}}*/
    9898/*FUNCTION IntInput::SpawnResult{{{*/
    99 ElementResult* IntInput::SpawnResult(int step, IssmPDouble time){
     99ElementResult* IntInput::SpawnResult(int step, IssmDouble time){
    100100       
    101101        _error2_("not supported yet!");
    … …  
    113113}
    114114/*}}}*/
    115 /*FUNCTION IntInput::GetInputValue(IssmPDouble* pvalue){{{*/
    116 void IntInput::GetInputValue(IssmPDouble* pvalue){
    117         _error2_("IntInput cannot return a IssmPDouble in parallel");
     115/*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue){{{*/
     116void IntInput::GetInputValue(IssmDouble* pvalue){
     117        _error2_("IntInput cannot return a IssmDouble in parallel");
    118118}
    119119/*}}}*/
    120 /*FUNCTION IntInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){{{*/
    121 void IntInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
     120/*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
     121void IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
    122122/*}}}*/
    123 /*FUNCTION IntInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){{{*/
    124 void IntInput::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
     123/*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
     124void IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
    125125/*}}}*/
    126 /*FUNCTION IntInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    127 void IntInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
     126/*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     127void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
    128128/*}}}*/
    129 /*FUNCTION IntInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    130 void IntInput::GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
     129/*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     130void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
    131131/*}}}*/
    132132/*FUNCTION IntInput::ChangeEnum{{{*/
    … …  
    136136/*}}}*/
    137137/*FUNCTION IntInput::SquareMin{{{*/
    138 void IntInput::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
     138void IntInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
    139139
    140140        /*square min of an integer is the square of the integer itself: */
    141         *psquaremin=pow((IssmPDouble)value,2);
     141        *psquaremin=pow((IssmDouble)value,2);
    142142}
    143143/*}}}*/
    144144/*FUNCTION IntInput::Scale{{{*/
    145 void IntInput::Scale(IssmPDouble scale_factor){
    146         IssmPDouble dvalue=(IssmPDouble)value*scale_factor;
     145void IntInput::Scale(IssmDouble scale_factor){
     146        IssmDouble dvalue=(IssmDouble)value*scale_factor;
    147147        value=(int)dvalue;
    148148}
    149149/*}}}*/
    150150/*FUNCTION IntInput::AXPY{{{*/
    151 void IntInput::AXPY(Input* xinput,IssmPDouble scalar){
     151void IntInput::AXPY(Input* xinput,IssmDouble scalar){
    152152
    153         IssmPDouble dvalue;
     153        IssmDouble dvalue;
    154154        IntInput*  xintinput=NULL;
    155155
    … …  
    161161
    162162                case IntInputEnum:
    163                         dvalue=(IssmPDouble)this->value+scalar*(IssmPDouble)xintinput->value;
     163                        dvalue=(IssmDouble)this->value+scalar*(IssmDouble)xintinput->value;
    164164                        this->value=(int)dvalue;
    165165                        return;
    … …  
    172172/*}}}*/
    173173/*FUNCTION IntInput::Constrain{{{*/
    174 void IntInput::Constrain(IssmPDouble cm_min, IssmPDouble cm_max){
     174void IntInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
    175175
    176176        if(!xIsNan<IssmDouble>(cm_min)) if (this->value<cm_min)this->value=(int)cm_min;
    … …  
    187187/*}}}*/
    188188/*FUNCTION IntInput::GetValuesPtr{{{*/
    189 void IntInput::GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){
     189void IntInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
    190190
    191191        _error2_("not supported yet!");

  • issm/trunk-jpl/src/c/objects/Inputs/IntInput.h

    r12494 r12530  
    4040                Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
    4141                Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
    42                 ElementResult* SpawnResult(int step, IssmPDouble time);
    43                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     42                ElementResult* SpawnResult(int step, IssmDouble time);
     43                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4444                void Configure(Parameters* parameters);
    4545                /*}}}*/
    … …  
    4747                void GetInputValue(bool* pvalue);
    4848                void GetInputValue(int* pvalue);
    49                 void GetInputValue(IssmPDouble* pvalue);
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss);
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    56                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
    57                 void GetInputAverage(IssmPDouble* pvalue){_error2_("not implemented yet");};
    58                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    59                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    60                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    61                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    62                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    63                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    64                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue);
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     51                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     56                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
     57                void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
     58                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     59                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     60                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     61                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     62                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     63                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     64                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    6565                void ChangeEnum(int newenumtype);
    66                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    67                 void ConstrainMin(IssmPDouble minimum){_error2_("not implemented yet");};
    68                 void Scale(IssmPDouble scale_factor);
    69                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    70                 void AXPY(Input* xinput,IssmPDouble scalar);
    71                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max);
    72                 IssmPDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for integers");};
    73                 IssmPDouble Max(void){_error2_("Max not implemented for integers");};
    74                 IssmPDouble MaxAbs(void){_error2_("Max not implemented for integers");};
    75                 IssmPDouble Min(void){_error2_("Min not implemented for integers");};
    76                 IssmPDouble MinAbs(void){_error2_("Min not implemented for integers");};
     66                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     67                void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
     68                void Scale(IssmDouble scale_factor);
     69                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     70                void AXPY(Input* xinput,IssmDouble scalar);
     71                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
     72                IssmDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for integers");};
     73                IssmDouble Max(void){_error2_("Max not implemented for integers");};
     74                IssmDouble MaxAbs(void){_error2_("Max not implemented for integers");};
     75                IssmDouble Min(void){_error2_("Min not implemented for integers");};
     76                IssmDouble MinAbs(void){_error2_("Min not implemented for integers");};
    7777                void Extrude(void){_error2_("not supported yet");};
    7878                void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
    7979                void GetVectorFromInputs(Vector* vector,int* doflist);
    80                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values);
     80                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);
    8181                /*}}}*/
    8282

  • issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.cpp

    r12529 r12530  
    2323}
    2424/*}}}*/
    25 /*FUNCTION PentaP1Input::PentaP1Input(int in_enum_type,IssmPDouble* values){{{*/
    26 PentaP1Input::PentaP1Input(int in_enum_type,IssmPDouble* in_values)
     25/*FUNCTION PentaP1Input::PentaP1Input(int in_enum_type,IssmDouble* values){{{*/
     26PentaP1Input::PentaP1Input(int in_enum_type,IssmDouble* in_values)
    2727                :PentaRef(1)
    2828{
    … …  
    9898        /*output*/
    9999        TriaP1Input* outinput=NULL;
    100         IssmPDouble newvalues[3];
     100        IssmDouble newvalues[3];
    101101
    102102        /*Loop over the new indices*/
    … …  
    119119/*}}}*/
    120120/*FUNCTION PentaP1Input::SpawnResult{{{*/
    121 ElementResult* PentaP1Input::SpawnResult(int step, IssmPDouble time){
     121ElementResult* PentaP1Input::SpawnResult(int step, IssmDouble time){
    122122
    123123        return new PentaP1ElementResult(this->enum_type,this->values,step,time);
    … …  
    127127
    128128/*Object functions*/
    129 /*FUNCTION PentaP1Input::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){{{*/
    130 void PentaP1Input::GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){
     129/*FUNCTION PentaP1Input::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
     130void PentaP1Input::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){
    131131
    132132        /*Call PentaRef function*/
    … …  
    135135}
    136136/*}}}*/
    137 /*FUNCTION PentaP1Input::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
    138 void PentaP1Input::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussPenta* gauss){
     137/*FUNCTION PentaP1Input::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussPenta* gauss){{{*/
     138void PentaP1Input::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussPenta* gauss){
    139139
    140140        /*Call PentaRef function*/
    … …  
    143143/*}}}*/
    144144/*FUNCTION PentaP1Input::GetVxStrainRate3d{{{*/
    145 void PentaP1Input::GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
     145void PentaP1Input::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
    146146        int i,j;
    147147
    148148        const int numnodes=6;
    149149        const int DOFVELOCITY=3;
    150         IssmPDouble B[8][27];
    151         IssmPDouble B_reduced[6][DOFVELOCITY*numnodes];
    152         IssmPDouble velocity[numnodes][DOFVELOCITY];
     150        IssmDouble B[8][27];
     151        IssmDouble B_reduced[6][DOFVELOCITY*numnodes];
     152        IssmDouble velocity[numnodes][DOFVELOCITY];
    153153
    154154        /*Get B matrix: */
    … …  
    188188/*}}}*/
    189189/*FUNCTION PentaP1Input::GetVyStrainRate3d{{{*/
    190 void PentaP1Input::GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
     190void PentaP1Input::GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
    191191        int i,j;
    192192
    193193        const int numnodes=6;
    194194        const int DOFVELOCITY=3;
    195         IssmPDouble B[8][27];
    196         IssmPDouble B_reduced[6][DOFVELOCITY*numnodes];
    197         IssmPDouble velocity[numnodes][DOFVELOCITY];
     195        IssmDouble B[8][27];
     196        IssmDouble B_reduced[6][DOFVELOCITY*numnodes];
     197        IssmDouble velocity[numnodes][DOFVELOCITY];
    198198
    199199        /*Get B matrix: */
    … …  
    233233/*}}}*/
    234234/*FUNCTION PentaP1Input::GetVzStrainRate3d{{{*/
    235 void PentaP1Input::GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){
     235void PentaP1Input::GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){
    236236        int i,j;
    237237
    238238        const int numnodes=6;
    239239        const int DOFVELOCITY=3;
    240         IssmPDouble B[8][27];
    241         IssmPDouble B_reduced[6][DOFVELOCITY*numnodes];
    242         IssmPDouble velocity[numnodes][DOFVELOCITY];
     240        IssmDouble B[8][27];
     241        IssmDouble B_reduced[6][DOFVELOCITY*numnodes];
     242        IssmDouble velocity[numnodes][DOFVELOCITY];
    243243
    244244        /*Get B matrix: */
    … …  
    279279/*}}}*/
    280280/*FUNCTION PentaP1Input::GetVxStrainRate3dPattyn{{{*/
    281 void PentaP1Input::GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
    282 
    283         int i;
    284         const int numnodes=6;
    285         IssmPDouble B[5][NDOF2*numnodes];
    286         IssmPDouble velocity[numnodes][NDOF2];
     281void PentaP1Input::GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){
     282
     283        int i;
     284        const int numnodes=6;
     285        IssmDouble B[5][NDOF2*numnodes];
     286        IssmDouble velocity[numnodes][NDOF2];
    287287
    288288        /*Get B matrix: */
    … …  
    303303/*}}}*/
    304304/*FUNCTION PentaP1Input::GetVyStrainRate3dPattyn{{{*/
    305 void PentaP1Input::GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
    306 
    307         int i;
    308         const int numnodes=6;
    309         IssmPDouble B[5][NDOF2*numnodes];
    310         IssmPDouble velocity[numnodes][NDOF2];
     305void PentaP1Input::GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){
     306
     307        int i;
     308        const int numnodes=6;
     309        IssmDouble B[5][NDOF2*numnodes];
     310        IssmDouble velocity[numnodes][NDOF2];
    311311
    312312        /*Get B matrix: */
    … …  
    332332/*}}}*/
    333333/*FUNCTION PentaP1Input::GetInputAverage{{{*/
    334 void PentaP1Input::GetInputAverage(IssmPDouble* pvalue){
     334void PentaP1Input::GetInputAverage(IssmDouble* pvalue){
    335335        *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]);
    336336}
    … …  
    339339/*Intermediary*/
    340340/*FUNCTION PentaP1Input::SquareMin{{{*/
    341 void PentaP1Input::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
    342 
    343         int i;
    344         const int numnodes=6;
    345         IssmPDouble valuescopy[numnodes];
    346         IssmPDouble squaremin;
     341void PentaP1Input::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     342
     343        int i;
     344        const int numnodes=6;
     345        IssmDouble valuescopy[numnodes];
     346        IssmDouble squaremin;
    347347
    348348        /*First,  copy values, to process units if requested: */
    … …  
    362362/*}}}*/
    363363/*FUNCTION PentaP1Input::ConstrainMin{{{*/
    364 void PentaP1Input::ConstrainMin(IssmPDouble minimum){
     364void PentaP1Input::ConstrainMin(IssmDouble minimum){
    365365       
    366366        int i;
    … …  
    371371/*}}}*/
    372372/*FUNCTION PentaP1Input::InfinityNorm{{{*/
    373 IssmPDouble PentaP1Input::InfinityNorm(void){
     373IssmDouble PentaP1Input::InfinityNorm(void){
    374374
    375375        /*Output*/
    376376        const int numnodes=6;
    377         IssmPDouble norm=0;
     377        IssmDouble norm=0;
    378378
    379379        for(int i=0;i<numnodes;i++) if(fabs(values[i])>norm) norm=fabs(values[i]);
    … …  
    382382/*}}}*/
    383383/*FUNCTION PentaP1Input::Max{{{*/
    384 IssmPDouble PentaP1Input::Max(void){
    385 
    386         const int numnodes=6;
    387         IssmPDouble    max=values[0];
     384IssmDouble PentaP1Input::Max(void){
     385
     386        const int numnodes=6;
     387        IssmDouble    max=values[0];
    388388
    389389        for(int i=1;i<numnodes;i++){
    … …  
    394394/*}}}*/
    395395/*FUNCTION PentaP1Input::MaxAbs{{{*/
    396 IssmPDouble PentaP1Input::MaxAbs(void){
    397 
    398         const int numnodes=6;
    399         IssmPDouble    max=fabs(values[0]);
     396IssmDouble PentaP1Input::MaxAbs(void){
     397
     398        const int numnodes=6;
     399        IssmDouble    max=fabs(values[0]);
    400400
    401401        for(int i=1;i<numnodes;i++){
    … …  
    406406/*}}}*/
    407407/*FUNCTION PentaP1Input::Min{{{*/
    408 IssmPDouble PentaP1Input::Min(void){
    409 
    410         const int numnodes=6;
    411         IssmPDouble    min=values[0];
     408IssmDouble PentaP1Input::Min(void){
     409
     410        const int numnodes=6;
     411        IssmDouble    min=values[0];
    412412
    413413        for(int i=1;i<numnodes;i++){
    … …  
    418418/*}}}*/
    419419/*FUNCTION PentaP1Input::MinAbs{{{*/
    420 IssmPDouble PentaP1Input::MinAbs(void){
    421 
    422         const int numnodes=6;
    423         IssmPDouble    min=fabs(values[0]);
     420IssmDouble PentaP1Input::MinAbs(void){
     421
     422        const int numnodes=6;
     423        IssmDouble    min=fabs(values[0]);
    424424
    425425        for(int i=1;i<numnodes;i++){
    … …  
    430430/*}}}*/
    431431/*FUNCTION PentaP1Input::Scale{{{*/
    432 void PentaP1Input::Scale(IssmPDouble scale_factor){
     432void PentaP1Input::Scale(IssmDouble scale_factor){
    433433       
    434434        int i;
    … …  
    439439/*}}}*/
    440440/*FUNCTION PentaP1Input::AXPY{{{*/
    441 void PentaP1Input::AXPY(Input* xinput,IssmPDouble scalar){
     441void PentaP1Input::AXPY(Input* xinput,IssmDouble scalar){
    442442
    443443        int i;
    … …  
    466466/*}}}*/
    467467/*FUNCTION PentaP1Input::Constrain{{{*/
    468 void PentaP1Input::Constrain(IssmPDouble cm_min, IssmPDouble cm_max){
     468void PentaP1Input::Constrain(IssmDouble cm_min, IssmDouble cm_max){
    469469
    470470        int i;
    … …  
    492492        const int  numnodes = 6;
    493493        int        num_thickness_values;
    494         IssmPDouble    *thickness_values = NULL;
     494        IssmDouble    *thickness_values = NULL;
    495495
    496496        /*Check that input provided is a thickness*/
    … …  
    526526        int               B_numvalues;
    527527        const int         numnodes    = 6;
    528         IssmPDouble            AdotBvalues[numnodes];
     528        IssmDouble            AdotBvalues[numnodes];
    529529
    530530        /*Check that inputB is of the same type*/
    … …  
    557557        int               B_numvalues;
    558558        const int         numnodes    = 6;
    559         IssmPDouble            minvalues[numnodes];
     559        IssmDouble            minvalues[numnodes];
    560560
    561561        /*Check that inputB is of the same type*/
    … …  
    588588        int               B_numvalues;
    589589        const int         numnodes    = 6;
    590         IssmPDouble            maxvalues[numnodes];
     590        IssmDouble            maxvalues[numnodes];
    591591
    592592        /*Check that inputB is of the same type*/
    … …  
    616616} /*}}}*/
    617617/*FUNCTION PentaP1Input::GetValuesPtr{{{*/
    618 void PentaP1Input::GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){
     618void PentaP1Input::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
    619619
    620620        *pvalues=this->values;

  • issm/trunk-jpl/src/c/objects/Inputs/PentaP1Input.h

    r12494 r12530  
    1919                /*just hold 6 values for 6 vertices: */
    2020                int    enum_type;
    21                 IssmPDouble values[6];
     21                IssmDouble values[6];
    2222
    2323                /*PentaP1Input constructors, destructors: {{{*/
    2424                PentaP1Input();
    25                 PentaP1Input(int enum_type,IssmPDouble* values);
     25                PentaP1Input(int enum_type,IssmDouble* values);
    2626                ~PentaP1Input();
    2727                /*}}}*/
    … …  
    4040                Input* PointwiseMin(Input* inputB);
    4141                Input* PointwiseMax(Input* inputB);
    42                 ElementResult* SpawnResult(int step, IssmPDouble time);
    43                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     42                ElementResult* SpawnResult(int step, IssmDouble time);
     43                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4444                void Configure(Parameters* parameters);
    4545                /*}}}*/
    … …  
    4747                void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
    4848                void GetInputValue(int* pvalue){_error2_("not implemented yet");};
    49                 void GetInputValue(IssmPDouble* pvalue){_error2_("not implemented yet");};
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
    51                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss);
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    56                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
    57                 void GetInputAverage(IssmPDouble* pvalue);
    58                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    59                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    60                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
    61                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
    62                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss);
    63                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
    64                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
     49                void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     56                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss);
     57                void GetInputAverage(IssmDouble* pvalue);
     58                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     59                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     60                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
     61                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
     62                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss);
     63                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss);
     64                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss);
    6565                void ChangeEnum(int newenumtype);
    6666
    67                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    68                 void ConstrainMin(IssmPDouble minimum);
    69                 void Scale(IssmPDouble scale_factor);
    70                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    71                 void AXPY(Input* xinput,IssmPDouble scalar);
    72                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max);
    73                 IssmPDouble InfinityNorm(void);
    74                 IssmPDouble Max(void);
    75                 IssmPDouble MaxAbs(void);
    76                 IssmPDouble Min(void);
    77                 IssmPDouble MinAbs(void);
     67                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     68                void ConstrainMin(IssmDouble minimum);
     69                void Scale(IssmDouble scale_factor);
     70                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     71                void AXPY(Input* xinput,IssmDouble scalar);
     72                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
     73                IssmDouble InfinityNorm(void);
     74                IssmDouble Max(void);
     75                IssmDouble MaxAbs(void);
     76                IssmDouble Min(void);
     77                IssmDouble MinAbs(void);
    7878                void Extrude(void);
    7979                void VerticallyIntegrate(Input* thickness_input);
    8080                void GetVectorFromInputs(Vector* vector,int* doflist);
    81                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values);
     81                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);
    8282                /*}}}*/
    8383

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

    r12511 r12530  
    4646/*FUNCTION TransientInput::~TransientInput{{{*/
    4747TransientInput::~TransientInput(){
    48         xDelete<double>(this->timesteps);
     48        xDelete<IssmDouble>(this->timesteps);
    4949        this->timesteps=NULL;
    5050        this->numtimesteps=0;
    … …  
    100100        output->enum_type=this->enum_type;
    101101        output->numtimesteps=this->numtimesteps;
    102         output->timesteps=xNew<IssmPDouble>(this->numtimesteps);
    103    memcpy(output->timesteps,this->timesteps,this->numtimesteps*sizeof(IssmPDouble));
     102        output->timesteps=xNew<IssmDouble>(this->numtimesteps);
     103   memcpy(output->timesteps,this->timesteps,this->numtimesteps*sizeof(IssmDouble));
    104104        output->inputs=(Inputs*)this->inputs->Copy();
    105105        output->parameters=this->parameters;
    … …  
    128128        outinput->enum_type=this->enum_type;
    129129        outinput->numtimesteps=this->numtimesteps;
    130         outinput->timesteps=xNew<IssmPDouble>(this->numtimesteps);
    131         memcpy(outinput->timesteps,this->timesteps,this->numtimesteps*sizeof(IssmPDouble));
     130        outinput->timesteps=xNew<IssmDouble>(this->numtimesteps);
     131        memcpy(outinput->timesteps,this->timesteps,this->numtimesteps*sizeof(IssmDouble));
    132132        outinput->inputs=(Inputs*)this->inputs->SpawnTriaInputs(indices);
    133133        outinput->parameters=this->parameters;
    … …  
    139139/*}}}*/
    140140/*FUNCTION TransientInput::SpawnResult{{{*/
    141 ElementResult* TransientInput::SpawnResult(int step, IssmPDouble time){
     141ElementResult* TransientInput::SpawnResult(int step, IssmDouble time){
    142142
    143143        ElementResult* elementresult=NULL;
    … …  
    156156
    157157/*Object functions*/
    158 /*FUNCTION TransientInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){{{*/
    159 void TransientInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){
    160         IssmPDouble time;
     158/*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
     159void TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
     160        IssmDouble time;
    161161
    162162        /*First, recover current time from parameters: */
    … …  
    172172}
    173173/*}}}*/
    174 /*FUNCTION TransientInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){{{*/
    175 void TransientInput::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){
     174/*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){{{*/
     175void TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){
    176176
    177177        /*Retrieve interpolated values for this time step: */
    … …  
    184184}
    185185/*}}}*/
    186 /*FUNCTION TransientInput::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    187 void TransientInput::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){
    188 
    189         IssmPDouble time;
     186/*FUNCTION TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     187void TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){
     188
     189        IssmDouble time;
    190190
    191191        /*First, recover current time from parameters: */
    … …  
    208208/*}}}*/
    209209/*FUNCTION TransientInput::GetInputAverage{{{*/
    210 void TransientInput::GetInputAverage(IssmPDouble* pvalue){
     210void TransientInput::GetInputAverage(IssmDouble* pvalue){
    211211       
    212         IssmPDouble time;
     212        IssmDouble time;
    213213
    214214        /*First, recover current time from parameters: */
    … …  
    228228/*Intermediary*/
    229229/*FUNCTION TransientInput::AddTimeInput{{{*/
    230 void TransientInput::AddTimeInput(Input* input,IssmPDouble time){
     230void TransientInput::AddTimeInput(Input* input,IssmDouble time){
    231231
    232232        /*insert values at time step: */
    … …  
    234234
    235235        //copy timesteps, add the new time, delete previous timesteps, and add the new input: inputs->AddObject(input);
    236         IssmPDouble* old_timesteps=NULL;
     236        IssmDouble* old_timesteps=NULL;
    237237
    238238        if (this->numtimesteps > 0){
    239                 old_timesteps=xNew<IssmPDouble>(this->numtimesteps);
    240                 memcpy(old_timesteps,this->timesteps,this->numtimesteps*sizeof(IssmPDouble));
    241                 xDelete<double>(this->timesteps);
     239                old_timesteps=xNew<IssmDouble>(this->numtimesteps);
     240                memcpy(old_timesteps,this->timesteps,this->numtimesteps*sizeof(IssmDouble));
     241                xDelete<IssmDouble>(this->timesteps);
    242242        }
    243243
    244244        this->numtimesteps=this->numtimesteps+1;
    245         this->timesteps=xNew<IssmPDouble>(this->numtimesteps);
     245        this->timesteps=xNew<IssmDouble>(this->numtimesteps);
    246246
    247247        if (this->numtimesteps > 1){
    248                 memcpy(this->timesteps,old_timesteps,(this->numtimesteps-1)*sizeof(IssmPDouble));
    249                 xDelete<double>(old_timesteps);
     248                memcpy(this->timesteps,old_timesteps,(this->numtimesteps-1)*sizeof(IssmDouble));
     249                xDelete<IssmDouble>(old_timesteps);
    250250        }
    251251
    … …  
    257257/*}}}*/
    258258/*FUNCTION TransientInput::SquareMin{{{*/
    259 void TransientInput::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
    260 
    261         IssmPDouble time;
     259void TransientInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     260
     261        IssmDouble time;
    262262
    263263        /*First, recover current time from parameters: */
    … …  
    275275/*}}}*/
    276276/*FUNCTION TransientInput::InfinityNorm{{{*/
    277 IssmPDouble TransientInput::InfinityNorm(void){
    278 
    279         IssmPDouble time;
    280         IssmPDouble infnorm;
     277IssmDouble TransientInput::InfinityNorm(void){
     278
     279        IssmDouble time;
     280        IssmDouble infnorm;
    281281
    282282        /*First, recover current time from parameters: */
    … …  
    295295/*}}}*/
    296296/*FUNCTION TransientInput::Max{{{*/
    297 IssmPDouble TransientInput::Max(void){
    298 
    299         IssmPDouble time;
    300         IssmPDouble max;
     297IssmDouble TransientInput::Max(void){
     298
     299        IssmDouble time;
     300        IssmDouble max;
    301301
    302302        /*First, recover current time from parameters: */
    … …  
    315315/*}}}*/
    316316/*FUNCTION TransientInput::MaxAbs{{{*/
    317 IssmPDouble TransientInput::MaxAbs(void){
    318 
    319         IssmPDouble time;
    320         IssmPDouble maxabs;
     317IssmDouble TransientInput::MaxAbs(void){
     318
     319        IssmDouble time;
     320        IssmDouble maxabs;
    321321
    322322        /*First, recover current time from parameters: */
    … …  
    336336/*}}}*/
    337337/*FUNCTION TransientInput::Min{{{*/
    338 IssmPDouble TransientInput::Min(void){
    339 
    340         IssmPDouble time;
    341         IssmPDouble min;
     338IssmDouble TransientInput::Min(void){
     339
     340        IssmDouble time;
     341        IssmDouble min;
    342342
    343343        /*First, recover current time from parameters: */
    … …  
    357357/*}}}*/
    358358/*FUNCTION TransientInput::MinAbs{{{*/
    359 IssmPDouble TransientInput::MinAbs(void){
    360 
    361         IssmPDouble time;
    362         IssmPDouble minabs;
     359IssmDouble TransientInput::MinAbs(void){
     360
     361        IssmDouble time;
     362        IssmDouble minabs;
    363363
    364364        /*First, recover current time from parameters: */
    … …  
    379379void TransientInput::GetVectorFromInputs(Vector* vector,int* doflist){
    380380
    381         IssmPDouble time;
     381        IssmDouble time;
    382382
    383383        /*First, recover current time from parameters: */
    … …  
    394394} /*}}}*/
    395395/*FUNCTION TransientInput::GetTimeInput{{{*/
    396 Input* TransientInput::GetTimeInput(IssmPDouble intime){
     396Input* TransientInput::GetTimeInput(IssmDouble intime){
    397397
    398398        int     i,j;
    399         IssmPDouble  deltat;
    400         IssmPDouble  alpha1,alpha2;
     399        IssmDouble  deltat;
     400        IssmDouble  alpha1,alpha2;
    401401        bool    found=false;
    402402        Input*  input=NULL;

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

    r12494 r12530  
    2020                int     numtimesteps;
    2121                Inputs* inputs;
    22                 IssmPDouble* timesteps;
     22                IssmDouble* timesteps;
    2323                Parameters* parameters; //to find current time.
    2424
    … …  
    2727                TransientInput(int enum_type);
    2828                ~TransientInput();
    29                 void AddTimeInput(Input* input,IssmPDouble time);
     29                void AddTimeInput(Input* input,IssmDouble time);
    3030                /*}}}*/
    3131                /*Object virtual functions definitions:{{{*/
    … …  
    4343                Input* PointwiseMin(Input* forcingB){_error2_("not implemented yet");};
    4444                Input* PointwiseMax(Input* forcingB){_error2_("not implemented yet");};
    45                 ElementResult* SpawnResult(int step, IssmPDouble time);
     45                ElementResult* SpawnResult(int step, IssmDouble time);
    4646                void Configure(Parameters* parameters);
    4747                /*}}}*/
    … …  
    4949                void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
    5050                void GetInputValue(int* pvalue){_error2_("not implemented yet");};
    51                 void GetInputValue(IssmPDouble* pvalue){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time);
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
    55                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    56                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
    57                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    58                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    59                 void GetInputAverage(IssmPDouble* pvalue);
    60                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    61                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
    62                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    63                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    64                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    65                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    66                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time);
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
     55                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     56                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
     57                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     58                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     59                void GetInputAverage(IssmDouble* pvalue);
     60                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     61                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
     62                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     63                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     64                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     65                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     66                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    6767                void ChangeEnum(int newenumtype);
    6868
    69                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    70                 void ConstrainMin(IssmPDouble minimum){_error2_("not implemented yet");};
    71                 void Scale(IssmPDouble scale_factor){_error2_("not implemented yet");};
    72                 void ArtificialNoise(IssmPDouble min,IssmPDouble max){_error2_("not implemented yet");};
    73                 void AXPY(Input* xforcing,IssmPDouble scalar){_error2_("not implemented yet");};
    74                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max){_error2_("not implemented yet");};
    75                 IssmPDouble InfinityNorm(void);
    76                 IssmPDouble Max(void);
    77                 IssmPDouble MaxAbs(void);
    78                 IssmPDouble Min(void);
    79                 IssmPDouble MinAbs(void);
     69                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     70                void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
     71                void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
     72                void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
     73                void AXPY(Input* xforcing,IssmDouble scalar){_error2_("not implemented yet");};
     74                void Constrain(IssmDouble cm_min, IssmDouble cm_max){_error2_("not implemented yet");};
     75                IssmDouble InfinityNorm(void);
     76                IssmDouble Max(void);
     77                IssmDouble MaxAbs(void);
     78                IssmDouble Min(void);
     79                IssmDouble MinAbs(void);
    8080                void Extrude(void){_error2_("not supported yet");}
    8181                void VerticallyIntegrate(Input* thickness_forcing){_error2_("not supported yet");};
    8282                void GetVectorFromInputs(Vector* vector,int* doflist);
    83                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){_error2_("not supported yet");};
    84       void GetTimeValues(IssmPDouble* values,IssmPDouble time){_error2_("not implemented yet");};
    85                 Input* GetTimeInput(IssmPDouble time);
     83                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not supported yet");};
     84      void GetTimeValues(IssmDouble* values,IssmDouble time){_error2_("not implemented yet");};
     85                Input* GetTimeInput(IssmDouble time);
    8686                /*}}}*/
    8787

  • issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.cpp

    r12529 r12530  
    2323}
    2424/*}}}*/
    25 /*FUNCTION TriaP1Input::TriaP1Input(int in_enum_type,IssmPDouble* values){{{*/
    26 TriaP1Input::TriaP1Input(int in_enum_type,IssmPDouble* in_values)
     25/*FUNCTION TriaP1Input::TriaP1Input(int in_enum_type,IssmDouble* values){{{*/
     26TriaP1Input::TriaP1Input(int in_enum_type,IssmDouble* in_values)
    2727        :TriaRef(1)
    2828{
    … …  
    108108/*}}}*/
    109109/*FUNCTION TriaP1Input::SpawnResult{{{*/
    110 ElementResult* TriaP1Input::SpawnResult(int step, IssmPDouble time){
     110ElementResult* TriaP1Input::SpawnResult(int step, IssmDouble time){
    111111
    112112        return new TriaP1ElementResult(this->enum_type,this->values,step,time);
    … …  
    116116
    117117/*Object functions*/
    118 /*FUNCTION TriaP1Input::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){{{*/
    119 void TriaP1Input::GetInputValue(IssmPDouble* pvalue,GaussTria* gauss){
     118/*FUNCTION TriaP1Input::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
     119void TriaP1Input::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
    120120
    121121        /*Call TriaRef function*/
    … …  
    124124}
    125125/*}}}*/
    126 /*FUNCTION TriaP1Input::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
    127 void TriaP1Input::GetInputDerivativeValue(IssmPDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){
     126/*FUNCTION TriaP1Input::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){{{*/
     127void TriaP1Input::GetInputDerivativeValue(IssmDouble* p, IssmPDouble* xyz_list, GaussTria* gauss){
    128128
    129129        /*Call TriaRef function*/
    … …  
    132132/*}}}*/
    133133/*FUNCTION TriaP1Input::GetVxStrainRate2d{{{*/
    134 void TriaP1Input::GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){
     134void TriaP1Input::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss){
    135135
    136136        /*Intermediary*/
    137137        int       i;
    138138        const int numnodes=3;
    139         IssmPDouble B[3][NDOF2*numnodes];
    140         IssmPDouble velocity[3][NDOF2];
     139        IssmDouble B[3][NDOF2*numnodes];
     140        IssmDouble velocity[3][NDOF2];
    141141
    142142        /*Get B matrix: */
    … …  
    155155/*}}}*/
    156156/*FUNCTION TriaP1Input::GetVyStrainRate2d{{{*/
    157 void TriaP1Input::GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){
     157void TriaP1Input::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss){
    158158
    159159        /*Intermediary*/
    160160        int       i;
    161161        const int numnodes=3;
    162         IssmPDouble B[3][NDOF2*numnodes];
    163         IssmPDouble velocity[3][NDOF2];
     162        IssmDouble B[3][NDOF2*numnodes];
     163        IssmDouble velocity[3][NDOF2];
    164164
    165165        /*Get B matrix: */
    … …  
    183183/*}}}*/
    184184/*FUNCTION TriaP1Input::GetInputAverage{{{*/
    185 void TriaP1Input::GetInputAverage(IssmPDouble* pvalue){
     185void TriaP1Input::GetInputAverage(IssmDouble* pvalue){
    186186        *pvalue=1./3.*(values[0]+values[1]+values[2]);
    187187}
    … …  
    190190/*Intermediary*/
    191191/*FUNCTION TriaP1Input::SquareMin{{{*/
    192 void TriaP1Input::SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters){
    193 
    194         int i;
    195         const int numnodes=3;
    196         IssmPDouble valuescopy[numnodes];
    197         IssmPDouble squaremin;
     192void TriaP1Input::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     193
     194        int i;
     195        const int numnodes=3;
     196        IssmDouble valuescopy[numnodes];
     197        IssmDouble squaremin;
    198198
    199199        /*First,  copy values, to process units if requested: */
    … …  
    213213/*}}}*/
    214214/*FUNCTION TriaP1Input::ContrainMin{{{*/
    215 void TriaP1Input::ConstrainMin(IssmPDouble minimum){
     215void TriaP1Input::ConstrainMin(IssmDouble minimum){
    216216       
    217217        int i;
    … …  
    222222/*}}}*/
    223223/*FUNCTION TriaP1Input::InfinityNorm{{{*/
    224 IssmPDouble TriaP1Input::InfinityNorm(void){
     224IssmDouble TriaP1Input::InfinityNorm(void){
    225225
    226226        /*Output*/
    227         IssmPDouble norm=0;
     227        IssmDouble norm=0;
    228228        const int numnodes=3;
    229229
    … …  
    233233/*}}}*/
    234234/*FUNCTION TriaP1Input::Max{{{*/
    235 IssmPDouble TriaP1Input::Max(void){
    236 
    237         const int numnodes=3;
    238         IssmPDouble    max=values[0];
     235IssmDouble TriaP1Input::Max(void){
     236
     237        const int numnodes=3;
     238        IssmDouble    max=values[0];
    239239
    240240        for(int i=1;i<numnodes;i++){
    … …  
    245245/*}}}*/
    246246/*FUNCTION TriaP1Input::MaxAbs{{{*/
    247 IssmPDouble TriaP1Input::MaxAbs(void){
    248 
    249         const int numnodes=3;
    250         IssmPDouble    max=fabs(values[0]);
     247IssmDouble TriaP1Input::MaxAbs(void){
     248
     249        const int numnodes=3;
     250        IssmDouble    max=fabs(values[0]);
    251251
    252252        for(int i=1;i<numnodes;i++){
    … …  
    257257/*}}}*/
    258258/*FUNCTION TriaP1Input::Min{{{*/
    259 IssmPDouble TriaP1Input::Min(void){
    260 
    261         const int numnodes=3;
    262         IssmPDouble    min=values[0];
     259IssmDouble TriaP1Input::Min(void){
     260
     261        const int numnodes=3;
     262        IssmDouble    min=values[0];
    263263
    264264        for(int i=1;i<numnodes;i++){
    … …  
    269269/*}}}*/
    270270/*FUNCTION TriaP1Input::MinAbs{{{*/
    271 IssmPDouble TriaP1Input::MinAbs(void){
    272 
    273         const int numnodes=3;
    274         IssmPDouble    min=fabs(values[0]);
     271IssmDouble TriaP1Input::MinAbs(void){
     272
     273        const int numnodes=3;
     274        IssmDouble    min=fabs(values[0]);
    275275
    276276        for(int i=1;i<numnodes;i++){
    … …  
    281281/*}}}*/
    282282/*FUNCTION TriaP1Input::Scale{{{*/
    283 void TriaP1Input::Scale(IssmPDouble scale_factor){
     283void TriaP1Input::Scale(IssmDouble scale_factor){
    284284       
    285285        int i;
    … …  
    290290/*}}}*/
    291291/*FUNCTION TriaP1Input::ArtificialNoise{{{*/
    292 void TriaP1Input::ArtificialNoise(IssmPDouble min,IssmPDouble max){
    293 
    294         int i;
    295         const int numnodes=3;
    296         IssmPDouble noise;
     292void TriaP1Input::ArtificialNoise(IssmDouble min,IssmDouble max){
     293
     294        int i;
     295        const int numnodes=3;
     296        IssmDouble noise;
    297297
    298298        /*Compute random number between bounds:
    299299         * rand() outputs an integer in [0 RAND_MAX]
    300          * (IssmPDouble)rand()/RAND_MAX is in [0 1]
     300         * (IssmDouble)rand()/RAND_MAX is in [0 1]
    301301         */
    302          noise=min+(max-min)*(IssmPDouble)rand()/RAND_MAX;
     302         noise=min+(max-min)*(IssmDouble)rand()/RAND_MAX;
    303303
    304304        for(i=0;i<numnodes;i++)values[i]=values[i]+noise;
    … …  
    306306/*}}}*/
    307307/*FUNCTION TriaP1Input::AXPY{{{*/
    308 void TriaP1Input::AXPY(Input* xinput,IssmPDouble scalar){
     308void TriaP1Input::AXPY(Input* xinput,IssmDouble scalar){
    309309
    310310        int i;
    … …  
    329329/*}}}*/
    330330/*FUNCTION TriaP1Input::Constrain{{{*/
    331 void TriaP1Input::Constrain(IssmPDouble cm_min, IssmPDouble cm_max){
     331void TriaP1Input::Constrain(IssmDouble cm_min, IssmDouble cm_max){
    332332
    333333        int i;
    … …  
    347347} /*}}}*/
    348348/*FUNCTION TriaP1Input::GetValuesPtr{{{*/
    349 void TriaP1Input::GetValuesPtr(IssmPDouble** pvalues,int* pnum_values){
     349void TriaP1Input::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
    350350
    351351        *pvalues=this->values;
    … …  
    365365        int               B_numvalues;
    366366        const int         numnodes    = 3;
    367         IssmPDouble            minvalues[numnodes];
     367        IssmDouble            minvalues[numnodes];
    368368
    369369        /*Check that inputB is of the same type*/
    … …  
    396396        int               B_numvalues;
    397397        const int         numnodes    = 3;
    398         IssmPDouble            maxvalues[numnodes];
     398        IssmDouble            maxvalues[numnodes];
    399399
    400400        /*Check that inputB is of the same type*/

  • issm/trunk-jpl/src/c/objects/Inputs/TriaP1Input.h

    r12494 r12530  
    1919                /*just hold 3 values for 3 vertices: */
    2020                int    enum_type;
    21                 IssmPDouble values[3];
     21                IssmDouble values[3];
    2222
    2323                /*TriaP1Input constructors, destructors: {{{*/
    2424                TriaP1Input();
    25                 TriaP1Input(int enum_type,IssmPDouble* values);
     25                TriaP1Input(int enum_type,IssmDouble* values);
    2626                ~TriaP1Input();
    2727                /*}}}*/
    … …  
    4040                Input* PointwiseMin(Input* inputB);
    4141                Input* PointwiseMax(Input* inputB);
    42                 ElementResult* SpawnResult(int step, IssmPDouble time);
    43                 void AddTimeValues(IssmPDouble* values,int step,IssmPDouble time){_error2_("not supported yet");};
     42                ElementResult* SpawnResult(int step, IssmDouble time);
     43                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
    4444                void Configure(Parameters* parameters);
    4545                /*}}}*/
    … …  
    4747                void GetInputValue(bool* pvalue){_error2_("not implemented yet");}
    4848                void GetInputValue(int* pvalue){_error2_("not implemented yet");}
    49                 void GetInputValue(IssmPDouble* pvalue){_error2_("not implemented yet");}
    50                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss,IssmPDouble time){_error2_("not implemented yet");};
    52                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
    53                 void GetInputValue(IssmPDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
    54                 void GetInputValue(IssmPDouble* pvalue,GaussPenta* gauss,int index){_error2_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
    56                 void GetInputDerivativeValue(IssmPDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    57                 void GetInputAverage(IssmPDouble* pvalue);
    58                 void GetVxStrainRate2d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss);
    59                 void GetVyStrainRate2d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss);
    60                 void GetVxStrainRate3d(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    61                 void GetVyStrainRate3d(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    62                 void GetVzStrainRate3d(IssmPDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    63                 void GetVxStrainRate3dPattyn(IssmPDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    64                 void GetVyStrainRate3dPattyn(IssmPDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");}
     50                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
     51                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
     53                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
     54                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index){_error2_("not implemented yet");};
     55                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussTria* gauss);
     56                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     57                void GetInputAverage(IssmDouble* pvalue);
     58                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussTria* gauss);
     59                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussTria* gauss);
     60                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     61                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     62                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     63                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
     64                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmPDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
    6565                void ChangeEnum(int newenumtype);
    6666
    67                 void SquareMin(IssmPDouble* psquaremin, bool process_units,Parameters* parameters);
    68                 void ConstrainMin(IssmPDouble minimum);
    69                 void Scale(IssmPDouble scale_factor);
    70                 void ArtificialNoise(IssmPDouble min,IssmPDouble max);
    71                 void AXPY(Input* xinput,IssmPDouble scalar);
    72                 void Constrain(IssmPDouble cm_min, IssmPDouble cm_max);
    73                 IssmPDouble InfinityNorm(void);
    74                 IssmPDouble Max(void);
    75                 IssmPDouble MaxAbs(void);
    76                 IssmPDouble Min(void);
    77                 IssmPDouble MinAbs(void);
     67                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     68                void ConstrainMin(IssmDouble minimum);
     69                void Scale(IssmDouble scale_factor);
     70                void ArtificialNoise(IssmDouble min,IssmDouble max);
     71                void AXPY(Input* xinput,IssmDouble scalar);
     72                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
     73                IssmDouble InfinityNorm(void);
     74                IssmDouble Max(void);
     75                IssmDouble MaxAbs(void);
     76                IssmDouble Min(void);
     77                IssmDouble MinAbs(void);
    7878                void Extrude(void){_error2_("not supported yet");};
    7979                void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
    8080                void GetVectorFromInputs(Vector* vector,int* doflist);
    81                 void GetValuesPtr(IssmPDouble** pvalues,int* pnum_values);
     81                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);
    8282                /*}}}*/
    8383
Note: See TracChangeset for help on using the changeset viewer.