Changeset 12426


Ignore:
Timestamp:
06/15/12 15:18:34 (13 years ago)
Author:
utke
Message:

currently all data held in "Inputs" classes are not carrying
differentiable dependencies (discussed w M. Morlighem)

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

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    r12365 r12426  
    2525                virtual void GetInputValue(bool* pvalue)=0;
    2626                virtual void GetInputValue(int* pvalue)=0;
    27                 virtual void GetInputValue(double* pvalue)=0;
    28                 virtual void GetInputValue(double* pvalue,GaussTria* gauss)=0;
    29                 virtual void GetInputValue(double* pvalue,GaussTria* gauss,double time)=0;
    30                 virtual void GetInputValue(double* pvalue,GaussPenta* gauss)=0;
    31                 virtual void GetInputValue(double* pvalue,GaussTria* gauss ,int index)=0;
    32                 virtual void GetInputValue(double* pvalue,GaussPenta* gauss,int index)=0;
    33                 virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss)=0;
    34                 virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss)=0;
    35                 virtual void GetInputAverage(double* pvalue)=0;
    36                 virtual void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss)=0;
    37                 virtual void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss)=0;
    38                 virtual void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss)=0;
    39                 virtual void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss)=0;
    40                 virtual void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss)=0;
    41                 virtual void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss)=0;
    42                 virtual void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss)=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;
    4343                virtual void ChangeEnum(int newenumtype)=0;
    4444                virtual void Configure(Parameters* parameters)=0;
    4545
    46                 virtual void   SquareMin(double* psquaremin, bool process_units,Parameters* parameters)=0;
    47                 virtual void   ConstrainMin(double minimum)=0;
    48                 virtual double InfinityNorm(void)=0;
    49                 virtual double MaxAbs(void)=0;
    50                 virtual double MinAbs(void)=0;
    51                 virtual double Max(void)=0;
    52                 virtual double Min(void)=0;
    53                 virtual void   Scale(double scale_factor)=0;
    54                 virtual void   ArtificialNoise(double min,double max)=0;
    55                 virtual void   AXPY(Input* xinput,double scalar)=0;
    56                 virtual void   Constrain(double cm_min, double cm_max)=0;
     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;
    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(double** pvalues,int* pnum_values)=0;
     60                virtual void   GetValuesPtr(IssmPDouble** 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, double time)=0;
     66                virtual ElementResult* SpawnResult(int step, IssmPDouble time)=0;
    6767
    6868                /*}}}*/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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