Changeset 13073


Ignore:
Timestamp:
08/16/12 18:30:40 (13 years ago)
Author:
Eric.Larour
Message:

CHG: extended rest of the code (except for kriging code) to use IssmDouble
and IssmPDouble active and passive types, for use with AD type constructs (using
ADOLC or ADIC in the future).

Location:
issm/trunk-jpl
Files:
92 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/configs/config-macosx64-larour-ad.sh

    r12988 r13073  
    33./configure \
    44        --prefix=$ISSM_DIR \
    5         --without-modules\
    6         --without-thermal \
    7         --without-control \
    8         --without-hydrology \
    9         --without-diagnostic \
    10         --without-balanced \
    11         --without-responses \
    12         --without-slope \
    13         --without-rifts \
    14         --without-steadystate \
    15         --without-transient \
    16         --without-3d \
    17         --without-groundingline \
     5        --without-modules \
    186        --without-kriging  \
    197        --with-gsl-dir=$ISSM_DIR/externalpackages/gsl/install \

  • issm/trunk-jpl/src/c/Container/Observations.cpp

    r13056 r13073  
    6464                options->Get(&minlength,"boxlength");
    6565                if(minlength<=0)_error_("boxlength should be a positive number");
    66                 maxdepth=int(log(max(xmax-xmin,ymax-ymin)/minlength +1)/log(2.0));
     66                maxdepth=reCast<int,IssmDouble>(log(max(xmax-xmin,ymax-ymin)/minlength +1)/log(2.0));
    6767        }
    6868        else{

  • issm/trunk-jpl/src/c/classes/gauss/GaussTria.cpp

    r13056 r13073  
    197197/*}}}*/
    198198/*FUNCTION GaussTria::GaussFromCoords{{{*/
    199 void GaussTria::GaussFromCoords(IssmPDouble x,IssmPDouble y,IssmPDouble* xyz_list){
     199void GaussTria::GaussFromCoords(IssmDouble x,IssmDouble y,IssmDouble* xyz_list){
    200200
    201201        /*Intermediaries*/
    202         IssmPDouble    area = 0;
    203         IssmPDouble    x1,y1,x2,y2,x3,y3;
     202        IssmDouble    area = 0;
     203        IssmDouble    x1,y1,x2,y2,x3,y3;
    204204
    205205        /*in debugging mode: check that the default constructor has been called*/

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

    r12822 r13073  
    2222        public:
    2323                IssmPDouble weight;
    24                 IssmPDouble coord1;
    25                 IssmPDouble coord2;
    26                 IssmPDouble coord3;
     24                IssmDouble coord1;
     25                IssmDouble coord2;
     26                IssmDouble coord3;
    2727               
    2828        public:
    … …  
    3838                int  end(void);
    3939                void Echo(void);
    40                 void GaussFromCoords(IssmPDouble x1,IssmPDouble y1,IssmPDouble* xyz_list);
     40                void GaussFromCoords(IssmDouble x1,IssmDouble y1,IssmDouble* xyz_list);
    4141                void GaussPoint(int ig);
    4242                void GaussVertex(int iv);

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

    r13065 r13073  
    6767        /*Build neighbors list*/
    6868        if (xIsNan<IssmDouble>(iomodel->Data(MeshUpperelementsEnum)[index])) penta_elements_ids[1]=this->id; //upper penta is the same penta
    69         else                                    penta_elements_ids[1]=(int)(iomodel->Data(MeshUpperelementsEnum)[index]);
     69        else                                    penta_elements_ids[1]=reCast<int,IssmDouble>((iomodel->Data(MeshUpperelementsEnum)[index]));
    7070        if (xIsNan<IssmDouble>(iomodel->Data(MeshLowerelementsEnum)[index])) penta_elements_ids[0]=this->id; //lower penta is the same penta
    71         else                                    penta_elements_ids[0]=(int)(iomodel->Data(MeshLowerelementsEnum)[index]);
     71        else                                    penta_elements_ids[0]=reCast<int,IssmDouble>((iomodel->Data(MeshLowerelementsEnum)[index]));
    7272        this->InitHookNeighbors(penta_elements_ids);
    7373
    7474        /*Build horizontalneighborsids list: */
    7575        _assert_(iomodel->Data(MeshElementconnectivityEnum));
    76         for(i=0;i<3;i++) this->horizontalneighborsids[i]=(int)iomodel->Data(MeshElementconnectivityEnum)[3*index+i]-1;
     76        for(i=0;i<3;i++) this->horizontalneighborsids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementconnectivityEnum)[3*index+i])-1;
    7777
    7878        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    … …  
    12531253       
    12541254        if ((code==5) || (code==1)){ //boolean
    1255                 this->inputs->AddInput(new BoolInput(name,(bool)scalar));
     1255                this->inputs->AddInput(new BoolInput(name,reCast<bool,IssmDouble>(scalar)));
    12561256        }
    12571257        else if ((code==6) || (code==2)){ //integer
    1258                 this->inputs->AddInput(new IntInput(name,(int)scalar));
     1258                this->inputs->AddInput(new IntInput(name,reCast<int,IssmDouble>(scalar)));
    12591259        }
    12601260        else if ((code==7) || (code==3)){ //IssmDouble
    1261                 this->inputs->AddInput(new DoubleInput(name,(IssmDouble)scalar));
     1261                this->inputs->AddInput(new DoubleInput(name,scalar));
    12621262        }
    12631263        else _error_("could not recognize nature of vector from code " << code);
    … …  
    12911291                for(i=0;i<6;i++){
    12921292                        _assert_(iomodel->Data(MeshElementsEnum));
    1293                         penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     1293                        penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
    12941294                }
    12951295
    … …  
    13361336
    13371337                        if (code==5){ //boolean
    1338                                 this->inputs->AddInput(new BoolInput(vector_enum,(bool)vector[index]));
     1338                                this->inputs->AddInput(new BoolInput(vector_enum,reCast<bool,IssmDouble>(vector[index])));
    13391339                        }
    13401340                        else if (code==6){ //integer
    1341                                 this->inputs->AddInput(new IntInput(vector_enum,(int)vector[index]));
     1341                                this->inputs->AddInput(new IntInput(vector_enum,reCast<int,IssmDouble>(vector[index])));
    13421342                        }
    13431343                        else if (code==7){ //IssmDouble
    1344                                 this->inputs->AddInput(new DoubleInput(vector_enum,(IssmDouble)vector[index]));
     1344                                this->inputs->AddInput(new DoubleInput(vector_enum,vector[index]));
    13451345                        }
    13461346                        else _error_("could not recognize nature of vector from code " << code);
    … …  
    16261626        /*Recover vertices ids needed to initialize inputs*/
    16271627        for(i=0;i<6;i++){
    1628                 penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     1628                penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
    16291629        }
    16301630
    … …  
    16331633        if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    16341634                for(i=0;i<num_control_type;i++){
    1635                         switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
     1635                        switch(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])){
    16361636                                case BalancethicknessThickeningRateEnum:
    16371637                                        if (iomodel->Data(BalancethicknessThickeningRateEnum)){
    … …  
    16691669                                        /*Matice will take care of it*/ break;
    16701670                                default:
    1671                                         _error_("Control " << EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]) << " not implemented yet");
     1671                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
    16721672                        }
    16731673                }
    … …  
    17051705                }
    17061706                else{
    1707                         _error_("Approximation type " << EnumToStringx((int)iomodel->Data(FlowequationElementEquationEnum)[index]) << " not supported yet");
     1707                        _error_("Approximation type " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(FlowequationElementEquationEnum)[index])) << " not supported yet");
    17081708                }
    17091709        }
    … …  
    19511951
    19521952                case VertexEnum:
    1953 
    1954                         /*New PentaVertexInpu*/
    1955                         IssmDouble values[6];
    1956 
    1957                         /*Get values on the 6 vertices*/
    1958                         for (int i=0;i<6;i++){
    1959                                 values[i]=vector[this->nodes[i]->GetVertexDof()];
     1953                        {
     1954
     1955                                /*New PentaVertexInpu*/
     1956                                IssmDouble values[6];
     1957
     1958                                /*Get values on the 6 vertices*/
     1959                                for (int i=0;i<6;i++){
     1960                                        values[i]=vector[this->nodes[i]->GetVertexDof()];
     1961                                }
     1962
     1963                                /*update input*/
     1964                                this->inputs->AddInput(new PentaP1Input(name,values));
     1965                                return;
     1966                                break;
    19601967                        }
    1961 
    1962                         /*update input*/
    1963                         this->inputs->AddInput(new PentaP1Input(name,values));
    1964                         return;
    19651968
    19661969                default:
    … …  
    20632066
    20642067        for(i=0;i<NUMVERTICES;i++){
    2065                 if (flags[nodes[i]->Sid()]){
     2068                if (reCast<bool,IssmDouble>(flags[nodes[i]->Sid()])){
    20662069                        shelf=true;
    20672070                        break;
    … …  
    21642167        for(i=0;i<NUMVERTICES;i++){
    21652168                /*Ice shelf: if bed below bathymetry, impose it at the bathymetry and update surface, elso do nothing */
    2166                 if(old_floating_ice[nodes[i]->Sid()]){
     2169                if(reCast<bool,IssmDouble>(old_floating_ice[nodes[i]->Sid()])){
    21672170                        if(b[i]<=ba[i]){
    21682171                                b[i]=ba[i];
    … …  
    21842187                                        nodes[i]->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,false));
    21852188                                }
    2186                                 else if(migration_style==SoftMigrationEnum && sheet_ungrounding[nodes[i]->Sid()]){
     2189                                else if(migration_style==SoftMigrationEnum && reCast<int,IssmDouble>(sheet_ungrounding[nodes[i]->Sid()])){
    21872190                                        s[i]=(1-density)*h[i];
    21882191                                        b[i]=-density*h[i];
    … …  
    28432846
    28442847        /*Recover vertices ids needed to initialize inputs*/
    2845         for(i=0;i<6;i++) penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     2848        for(i=0;i<6;i++) penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
    28462849
    28472850        /*Recover nodes ids needed to initialize the node hook.*/
    … …  
    28492852                //go recover node ids, needed to initialize the node hook.
    28502853                //WARNING: We assume P1 elements here!!!!!
    2851                 penta_node_ids[i]=iomodel->nodecounter+(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
     2854                penta_node_ids[i]=iomodel->nodecounter+reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
    28522855        }
    28532856
    … …  
    29622965        /*Go through nodes, and whoever is on the potential_sheet_ungrounding, ends up in nodes_on_iceshelf: */
    29632966        for(i=0;i<NUMVERTICES;i++){
    2964                 if (vertices_potentially_ungrounding[nodes[i]->Sid()]){
     2967                if (reCast<bool,IssmDouble>(vertices_potentially_ungrounding[nodes[i]->Sid()])){
    29652968                        vec_nodes_on_iceshelf->SetValue(nodes[i]->Sid(),1,INS_VAL);
    29662969               
    … …  
    32283231                        break;
    32293232                case VelEnum:
    3230 
    3231                         /*Get input:*/
    3232                         IssmDouble vel;
    3233                         Input* vel_input;
    3234 
    3235                         vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
    3236                         vel_input->GetInputAverage(&vel);
    3237 
    3238                         /*process units if requested: */
    3239                         if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
    3240 
    3241                         /*Assign output pointers:*/
    3242                         *presponse=vel;
     3233                        {
     3234
     3235                                /*Get input:*/
     3236                                IssmDouble vel;
     3237                                Input* vel_input;
     3238
     3239                                vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
     3240                                vel_input->GetInputAverage(&vel);
     3241
     3242                                /*process units if requested: */
     3243                                if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
     3244
     3245                                /*Assign output pointers:*/
     3246                                *presponse=vel;
     3247                        }
     3248                        break;
    32433249                default: 
    32443250                        _error_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
    … …  
    33653371                kappa=matpar->GetEnthalpyDiffusionParameter(enthalpy,pressure);
    33663372                D_scalar_conduct=gauss->weight*Jdet*kappa;
    3367                 if(dt) D_scalar_conduct=D_scalar_conduct*dt;
     3373                if(reCast<bool,IssmDouble>(dt)) D_scalar_conduct=D_scalar_conduct*dt;
    33683374
    33693375                D[0][0]=D_scalar_conduct; D[0][1]=0; D[0][2]=0;
    … …  
    33853391
    33863392                D_scalar_advec=gauss->weight*Jdet;
    3387                 if(dt) D_scalar_advec=D_scalar_advec*dt;
     3393                if(reCast<bool,IssmDouble>(dt)) D_scalar_advec=D_scalar_advec*dt;
    33883394
    33893395                D[0][0]=D_scalar_advec*vx;D[0][1]=0;                D[0][2]=0;
    … …  
    33973403
    33983404                /*Transient: */
    3399                 if(dt){
     3405                if(reCast<bool,IssmDouble>(dt)){
    34003406                        GetNodalFunctionsP1(&L[0], gauss);
    34013407                        D_scalar_trans=gauss->weight*Jdet;
    … …  
    34183424                        K[2][0]=h/(2*vel)*vz*vx;  K[2][1]=h/(2*vel)*vz*vy; K[2][2]=h/(2*vel)*vz*vz;
    34193425                        D_scalar_stab=gauss->weight*Jdet;
    3420                         if(dt) D_scalar_stab=D_scalar_stab*dt;
     3426                        if(reCast<bool,IssmDouble>(dt)) D_scalar_stab=D_scalar_stab*dt;
    34213427                        for(i=0;i<3;i++) for(j=0;j<3;j++) K[i][j] = D_scalar_stab*K[i][j];
    34223428
    … …  
    34383444                                }
    34393445                        }
    3440                         if(dt){
     3446                        if(reCast<bool,IssmDouble>(dt)){
    34413447                                for(i=0;i<numdof;i++){
    34423448                                        for(j=0;j<numdof;j++){
    … …  
    34943500                               
    34953501                D_scalar=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity/(rho_ice*heatcapacity);
    3496                 if(dt) D_scalar=dt*D_scalar;
     3502                if(reCast<bool,IssmDouble>(dt)) D_scalar=dt*D_scalar;
    34973503
    34983504                TripleMultiply(&basis[0],numdof,1,0,
    … …  
    35943600
    35953601                D_scalar_conduct=gauss->weight*Jdet*kappa;
    3596                 if(dt) D_scalar_conduct=D_scalar_conduct*dt;
     3602                if(reCast<bool,IssmDouble>(dt)) D_scalar_conduct=D_scalar_conduct*dt;
    35973603
    35983604                D[0][0]=D_scalar_conduct; D[0][1]=0; D[0][2]=0;
    … …  
    36153621
    36163622                D_scalar_advec=gauss->weight*Jdet;
    3617                 if(dt) D_scalar_advec=D_scalar_advec*dt;
     3623                if(reCast<bool,IssmDouble>(dt)) D_scalar_advec=D_scalar_advec*dt;
    36183624
    36193625                D[0][0]=D_scalar_advec*vx;    D[0][1]=0;                    D[0][2]=0;
    … …  
    36273633
    36283634                /*Transient: */
    3629                 if(dt){
     3635                if(reCast<bool,IssmDouble>(dt)){
    36303636                        GetNodalFunctionsP1(&L[0], gauss);
    36313637                        D_scalar_trans=gauss->weight*Jdet;
    … …  
    36503656
    36513657                        D_scalar_stab=gauss->weight*Jdet;
    3652                         if(dt) D_scalar_stab=D_scalar_stab*dt;
     3658                        if(reCast<bool,IssmDouble>(dt)) D_scalar_stab=D_scalar_stab*dt;
    36533659                        for(i=0;i<3;i++) for(j=0;j<3;j++) K[i][j] = D_scalar_stab*K[i][j];
    36543660
    … …  
    36703676                                }
    36713677                        }
    3672                         if(dt){
     3678                        if(reCast<bool,IssmDouble>(dt)){
    36733679                                for(i=0;i<numdof;i++){
    36743680                                        for(j=0;j<numdof;j++){
    … …  
    37273733                               
    37283734                D_scalar=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity/(heatcapacity*rho_ice);
    3729                 if(dt) D_scalar=dt*D_scalar;
     3735                if(reCast<bool,IssmDouble>(dt)) D_scalar=dt*D_scalar;
    37303736
    37313737                TripleMultiply(&basis[0],numdof,1,0,
    … …  
    37963802        Input* enthalpy_input=NULL;
    37973803        Input* enthalpypicard_input=NULL;
    3798         if(dt){
     3804        if(reCast<bool,IssmDouble>(dt)){
    37993805                enthalpy_input=inputs->GetInput(EnthalpyEnum); _assert_(enthalpy_input);
    38003806        }
    … …  
    38183824
    38193825                scalar_def=phi/rho_ice*Jdet*gauss->weight;
    3820                 if(dt) scalar_def=scalar_def*dt;
     3826                if(reCast<bool,IssmDouble>(dt)) scalar_def=scalar_def*dt;
    38213827
    38223828                for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_def*L[i];
    38233829
    38243830                /* Build transient now */
    3825                 if(dt){
     3831                if(reCast<bool,IssmDouble>(dt)){
    38263832                        enthalpy_input->GetInputValue(&enthalpy, gauss);
    38273833                        scalar_transient=enthalpy*Jdet*gauss->weight;
    … …  
    38413847
    38423848                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    3843                         if(dt){
     3849                        if(reCast<bool,IssmDouble>(dt)){
    38443850                                for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_transient*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    38453851                        }
    … …  
    38993905
    39003906                scalar_ocean=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity*(h_pmp)/(rho_ice*heatcapacity);
    3901                 if(dt) scalar_ocean=dt*scalar_ocean;
     3907                if(reCast<bool,IssmDouble>(dt)) scalar_ocean=dt*scalar_ocean;
    39023908
    39033909                for(i=0;i<numdof;i++) pe->values[i]+=scalar_ocean*basis[i];
    … …  
    39853991
    39863992                        scalar=gauss->weight*Jdet2d*(basalfriction+geothermalflux_value)/(rho_ice);
    3987                         if(dt) scalar=dt*scalar;
     3993                        if(reCast<bool,IssmDouble>(dt)) scalar=dt*scalar;
    39883994
    39893995                        for(i=0;i<numdof;i++) pe->values[i]+=scalar*basis[i];
    … …  
    40574063        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    40584064        Input* temperature_input=NULL;
    4059         if (dt) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
     4065        if (reCast<bool,IssmDouble>(dt)) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
    40604066        if (stabilization==2) diameter=MinEdgeLength(xyz_list);
    40614067
    … …  
    40744080
    40754081                scalar_def=phi/(rho_ice*heatcapacity)*Jdet*gauss->weight;
    4076                 if(dt) scalar_def=scalar_def*dt;
     4082                if(reCast<bool,IssmDouble>(dt)) scalar_def=scalar_def*dt;
    40774083
    40784084                for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_def*L[i];
    40794085
    40804086                /* Build transient now */
    4081                 if(dt){
     4087                if(reCast<bool,IssmDouble>(dt)){
    40824088                        temperature_input->GetInputValue(&temperature, gauss);
    40834089                        scalar_transient=temperature*Jdet*gauss->weight;
    … …  
    40954101
    40964102                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    4097                         if(dt){
     4103                        if(reCast<bool,IssmDouble>(dt)){
    40984104                                for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_transient*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    40994105                        }
    … …  
    41534159
    41544160                scalar_ocean=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity*(t_pmp)/(heatcapacity*rho_ice);
    4155                 if(dt) scalar_ocean=dt*scalar_ocean;
     4161                if(reCast<bool,IssmDouble>(dt)) scalar_ocean=dt*scalar_ocean;
    41564162
    41574163                for(i=0;i<numdof;i++) pe->values[i]+=scalar_ocean*basis[i];
    … …  
    42194225
    42204226                        scalar=gauss->weight*Jdet2d*(basalfriction+geothermalflux_value)/(heatcapacity*rho_ice);
    4221                         if(dt) scalar=dt*scalar;
     4227                        if(reCast<bool,IssmDouble>(dt)) scalar=dt*scalar;
    42224228
    42234229                        for(i=0;i<numdof;i++) pe->values[i]+=scalar*basis[i];

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

    r13051 r13073  
    14691469        if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    14701470                for(i=0;i<num_control_type;i++){
    1471                         switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
     1471                        switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
    14721472                                case BalancethicknessThickeningRateEnum:
    14731473                                        if (iomodel->Data(BalancethicknessThickeningRateEnum)){
    … …  
    15051505                                        /*Matice will take care of it*/ break;
    15061506                                default:
    1507                                         _error_("Control " << EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]) << " not implemented yet");
     1507                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
    15081508                        }
    15091509                }
    … …  
    25912591
    25922592        /*First off, check that this segment belongs to this element: */
    2593         if ((int)*(segment+4)!=this->id)_error_("error message: segment with id " << (int)*(segment+4) << " does not belong to element with id:" << this->id);
     2593        if (reCast<int>(*(segment+4))!=this->id)_error_("error message: segment with id " << reCast<int>(*(segment+4)) << " does not belong to element with id:" << this->id);
    25942594
    25952595        /*Recover segment node locations: */
    … …  
    27952795                        *presponse=this->matice->GetBbar();
    27962796                        break;
    2797                 case VelEnum:
     2797                case VelEnum:{
    27982798
    27992799                        /*Get input:*/
    … …  
    28082808
    28092809                        /*Assign output pointers:*/
    2810                         *presponse=vel;
     2810                        *presponse=vel;}
     2811                        break;
    28112812                default: 
    28122813                        _error_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
    … …  
    53645365                old_watercolumn_input->GetInputValue(&old_watercolumn_g,gauss);
    53655366
    5366                 if(dt)for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
     5367                if(reCast<int,IssmDouble>(dt))for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
    53675368                else  for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*basal_melting_g*basis[i];
    53685369        }

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

    r13036 r13073  
    572572        }
    573573        else{
    574                 if (dt) pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp)/dt;
     574                if (reCast<bool>(dt)) pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp)/dt;
    575575                else    pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp);
    576576        }

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

    r13036 r13073  
    6060
    6161        /*Ok, retrieve all the data needed to add a penalty between the two nodes: */
    62         el1=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+2);
    63         el2=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+3);
    64 
    65         node1=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+0);
    66         node2=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+1);
     62        el1=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+2));
     63        el2=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+3)) ;
     64
     65        node1=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+0));
     66        node2=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+1));
    6767
    6868        /*id: */
    … …  
    9393        this->length=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+6);
    9494        this->fraction=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+9);
    95         this->state=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+11);
     95        this->state=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+11));
    9696
    9797        //intialize inputs, and add as many inputs per element as requested:
    … …  
    9999               
    100100        riftfront_type=SegmentRiftfrontEnum;
    101         riftfront_fill = (int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+7);
     101        riftfront_fill = reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+7));
    102102        riftfront_friction=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+8);
    103103        riftfront_fractionincrement=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+10);
    104         riftfront_shelf=(bool)iomodel->Data(MaskVertexonfloatingiceEnum)[node1-1];
     104        riftfront_shelf=reCast<bool,IssmDouble>(iomodel->Data(MaskVertexonfloatingiceEnum)[node1-1]);
    105105
    106106        this->inputs->AddInput(new IntInput(TypeEnum,riftfront_type));
    … …  
    679679        this->inputs->GetInputValue(&converged,ConvergedEnum);
    680680
    681         if(converged){
     681        if(reCast<int,IssmDouble>(converged)){
    682682                /*ok, material non-linearity has converged. If that was already the case, we keep
    683683                 * constraining the rift front. If it was not, and this is the first time the material

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

    r13056 r13073  
    705705                if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    706706                        for(i=0;i<num_control_type;i++){
    707                                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
     707                                switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
    708708                                        case MaterialsRheologyBbarEnum:
    709709                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    710710                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    711                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    712                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    713                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     711                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
     712                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     713                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    714714                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    715715                                                }
    … …  
    733733                /*Get B*/
    734734                if (iomodel->Data(MaterialsRheologyBEnum)) {
    735                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     735                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
    736736                        this->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,nodeinputs));
    737737                }
    … …  
    747747                if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
    748748                        for(i=0;i<num_control_type;i++){
    749                                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
     749                                switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
    750750                                        case MaterialsRheologyBbarEnum:
    751751                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    752752                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    753                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    754                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    755                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     753                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
     754                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     755                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    756756                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    757757                                                }

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

    r13051 r13073  
    8989                        _assert_(iomodel->Data(MeshVertexonbedEnum));
    9090                        _assert_(iomodel->Data(FlowequationVertexEquationEnum));
    91                         if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !iomodel->Data(MeshVertexonbedEnum)[io_index]){
     91                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
    9292                                for(k=1;k<=gsize;k++) this->FreezeDof(k);
    9393                        }
    94                         if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==L1L2ApproximationEnum && !iomodel->Data(MeshVertexonbedEnum)[io_index]){
     94                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==L1L2ApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
    9595                                for(k=1;k<=gsize;k++) this->FreezeDof(k);
    9696                        }
    97                         if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealPattynApproximationEnum && iomodel->Data(FlowequationBordermacayealEnum)[io_index]){
    98                                 if(!iomodel->Data(MeshVertexonbedEnum)[io_index]){
     97                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealPattynApproximationEnum && reCast<int>(iomodel->Data(FlowequationBordermacayealEnum)[io_index])){
     98                                if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
    9999                                        for(k=1;k<=gsize;k++) this->FreezeDof(k);
    100100                                }
    101101                        }
    102                         if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealStokesApproximationEnum && iomodel->Data(FlowequationBordermacayealEnum)[io_index]){
    103                                 if(!iomodel->Data(MeshVertexonbedEnum)[io_index]){
     102                        if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealStokesApproximationEnum && reCast<int>(iomodel->Data(FlowequationBordermacayealEnum)[io_index])){
     103                                if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
    104104                                        for(k=1;k<=2;k++) this->FreezeDof(k);
    105105                                }

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

    r12450 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* norm_list,int step){
     11void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* norm_list,int step){
    1212
    1313        /*Intermediaries*/
    1414        int     i,j,num_controls;
    1515        int    *control_type = NULL;
    16         double *scalar_list = NULL;
    17         double  scalar;
     16        IssmDouble *scalar_list = NULL;
     17        IssmDouble  scalar;
    1818
    1919
    … …  
    3838        /*Clean up and return*/
    3939        xDelete<int>(control_type);
    40         xDelete<double>(scalar_list);
     40        xDelete<IssmDouble>(scalar_list);
    4141}

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

    r12832 r13073  
    88#include "../../Container/Container.h"
    99
    10 void    ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,double* norm_list,int step);
     10void    ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,IssmDouble* norm_list,int step);
    1111
    1212#endif

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

    r12450 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void ControlInputSetGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* gradient){
     11void ControlInputSetGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* gradient){
    1212
    1313        /*Intermediaries*/
    … …  
    3333
    3434        /*Serialize gradient*/
    35         double* serial_gradient=NULL;
     35        IssmDouble* serial_gradient=NULL;
    3636        serial_gradient=gradient->ToMPISerial();
    3737
    … …  
    3939
    4040        /*Clean up and return*/
    41         xDelete<double>(serial_gradient);
     41        xDelete<IssmDouble>(serial_gradient);
    4242}

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

    r12450 r13073  
    1111#include "../Responsex/Responsex.h"
    1212
    13 void CostFunctionx(double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void CostFunctionx(IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    1414
    1515        /*Intermediary*/
    1616        int      i;
    1717        int      num_responses;
    18         double   S;
    1918        Element *element       = NULL;
    2019        int     *responses     = NULL;
    2120
    2221        /*output: */
    23         double J,Jplus;
     22        IssmDouble J,Jplus;
    2423       
    2524        /*Recover parameters*/

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void CostFunctionx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void DragCoefficientAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void DragCoefficientAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r13056 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void ElementResponsex( double* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int response_enum,bool process_units){
     12void ElementResponsex( IssmDouble* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int response_enum,bool process_units){
    1313       
    1414
    … …  
    2020        int cpu_found=-1;
    2121        int index;
    22         double response;
     22        IssmDouble response;
    2323        Element* element=NULL;
    2424

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void ElementResponsex( double* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int response_enum,bool process_units);
     12void ElementResponsex( IssmDouble* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int response_enum,bool process_units);
    1313
    1414#endif  /* _ELEMENTRESPONSEX_H */

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

    r12450 r13073  
    3636}
    3737
    38 void GetVectorFromControlInputsx( double** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, const char* data){
     38void GetVectorFromControlInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, const char* data){
    3939       
    4040        /*output: */
    41         double* vector=NULL;
     41        IssmDouble* vector=NULL;
    4242       
    4343        /*intermediary: */

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

    r12832 r13073  
    1010/* local prototypes: */
    1111void    GetVectorFromControlInputsx( Vector** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,const char* data="value");
    12 void    GetVectorFromControlInputsx( double** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,const char* data="value");
     12void    GetVectorFromControlInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,const char* data="value");
    1313
    1414#endif  /* _GETVECTORFROMCONTROLINPUTSXX_H */

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

    r13056 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void Gradjx(Vector** pgradient,double** pnorm_list, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters){
     12void Gradjx(Vector** pgradient,IssmDouble** pnorm_list, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters){
    1313
    1414        int     i,j,numberofvertices;
    1515        int     num_controls;
    16         double   norm_inf;
    17         double  *norm_list     = NULL;
     16        IssmDouble   norm_inf;
     17        IssmDouble  *norm_list     = NULL;
    1818        int     *control_type  = NULL;
    1919        Vector  *gradient      = NULL;
    … …  
    2727        /*Allocate gradient_list */
    2828        gradient_list = xNew<Vector*>(num_controls);
    29         norm_list = xNew<double>(num_controls);
     29        norm_list = xNew<IssmDouble>(num_controls);
    3030        for(i=0;i<num_controls;i++){
    3131                gradient_list[i]=new Vector(num_controls*numberofvertices);
    … …  
    6262        }
    6363        else{
    64                 xDelete<double>(norm_list);
     64                xDelete<IssmDouble>(norm_list);
    6565        }
    6666        if(pgradient)  *pgradient=gradient;

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void Gradjx(Vector** pgrad_g,double** pgrad_norm,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters);
     12void Gradjx(Vector** pgrad_g,IssmDouble** pgrad_norm,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters);
    1313
    1414#endif  /* _GRADJX_H */

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

    r13056 r13073  
    1414
    1515        int      i, migration_style,analysis_type;
    16         double*  vertices_potentially_ungrounding = NULL;
    17         double*  vertices_ungrounding             = NULL;
    18         double*  old_floatingice                  = NULL;
     16        IssmDouble*  vertices_potentially_ungrounding = NULL;
     17        IssmDouble*  vertices_ungrounding             = NULL;
     18        IssmDouble*  old_floatingice                  = NULL;
    1919        Vector*      vec_old_floatingice              = NULL;
    2020        Element* element                          = NULL;
    … …  
    4949        /*free ressouces: */
    5050        xdelete(&vec_old_floatingice);
    51         xDelete<double>(vertices_potentially_ungrounding);
    52         xDelete<double>(vertices_ungrounding);
    53         xDelete<double>(old_floatingice);
     51        xDelete<IssmDouble>(vertices_potentially_ungrounding);
     52        xDelete<IssmDouble>(vertices_ungrounding);
     53        xDelete<IssmDouble>(old_floatingice);
    5454}
    5555
    … …  
    8282/*%}}}*/
    8383/*FUNCTION PotentialSheetUngrounding {{{*/
    84 double*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters){
     84IssmDouble*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters){
    8585
    8686        int      i,numberofvertices;
    87         double*  vertices_potentially_ungrounding      = NULL;
     87        IssmDouble*  vertices_potentially_ungrounding      = NULL;
    8888        Vector*      vec_vertices_potentially_ungrounding  = NULL;
    8989        Element* element                               = NULL;
    … …  
    109109/*}}}*/
    110110/*FUNCTION PropagateFloatingiceToGroundedNeighbors {{{*/
    111 double*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,double* vertices_potentially_ungrounding){
     111IssmDouble*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,IssmDouble* vertices_potentially_ungrounding){
    112112
    113113        int      i,analysis_type;
    114114        int      numberofvertices;
    115115        int      nflipped,local_nflipped;
    116         double*  nodes_on_floatingice                  = NULL;
    117         double*  elements_neighboring_floatingce      = NULL;
     116        IssmDouble*  nodes_on_floatingice                  = NULL;
     117        IssmDouble*  elements_neighboring_floatingce      = NULL;
    118118        Vector*      vec_elements_neighboring_floatingice = NULL;
    119119        Vector*      vec_nodes_on_floatingice              = NULL;
    … …  
    150150                for(i=0;i<elements->Size();i++){
    151151                        element=(Element*)elements->GetObjectByOffset(i);
    152                         if(elements_neighboring_floatingce[element->Sid()]){
     152                        if(reCast<int,IssmDouble>(elements_neighboring_floatingce[element->Sid()])){
    153153                                local_nflipped+=element->UpdatePotentialSheetUngrounding(vertices_potentially_ungrounding,vec_nodes_on_floatingice,nodes_on_floatingice);
    154154                        }
    … …  
    164164
    165165                /*Avoid leaks: */
    166                 xDelete<double>(elements_neighboring_floatingce);
    167                 xDelete<double>(nodes_on_floatingice);
     166                xDelete<IssmDouble>(elements_neighboring_floatingce);
     167                xDelete<IssmDouble>(nodes_on_floatingice);
    168168
    169169                /*Assemble and serialize:*/
    … …  
    174174        /*Free ressources:*/
    175175        xdelete(&vec_nodes_on_floatingice);
    176         xDelete<double>(elements_neighboring_floatingce);
     176        xDelete<IssmDouble>(elements_neighboring_floatingce);
    177177
    178178        return nodes_on_floatingice;

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

    r11695 r13073  
    1515
    1616Vector*        CreateNodesOnFloatingIce(Nodes* nodes,int configuration_type);
    17 double*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters);
    18 double*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,double* vertices_potentially_ungrounding);
     17IssmDouble*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters);
     18IssmDouble*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,IssmDouble* vertices_potentially_ungrounding);
    1919#endif  /* _GROUNDINGLINEMIGRATIONX_H */

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void IceVolumex(double* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     12void IceVolumex(IssmDouble* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313
    14         double local_ice_volume = 0;
    15         double total_ice_volume;
     14        IssmDouble local_ice_volume = 0;
     15        IssmDouble total_ice_volume;
    1616
    1717        for(int i=0;i<elements->Size();i++){

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void IceVolumex(double* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void IceVolumex(IssmDouble* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif

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

    r4967 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,double scalar,bool save_parameter){
     11void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,IssmDouble scalar,bool save_parameter){
    1212
    1313        /*Go through elemnets, and ask to carry out the operation on inputs: */

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

    r4967 r13073  
    99
    1010/* local prototypes: */
    11 void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, double scalar,bool save_parameter);
     11void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, IssmDouble scalar,bool save_parameter);
    1212
    1313#endif

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

    r12450 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units){
     12void MassFluxx(IssmDouble* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units){
    1313
    1414        int i,j;
    … …  
    2020       
    2121        /*output: */
    22         double mass_flux=0;
    23         double all_mass_flux=0;
     22        IssmDouble mass_flux=0;
     23        IssmDouble all_mass_flux=0;
    2424
    2525        int  counter;
    2626
    2727        /*all segments: */
    28         double** array=NULL;
     28        IssmDouble** array=NULL;
    2929        int      M;
    3030        int*     mdims_array=NULL;
    … …  
    3232
    3333        /*our segments of interest: */
    34         double*  segments=NULL;
     34        IssmDouble*  segments=NULL;
    3535        int      num_segments;
    3636
    … …  
    4848         * When we find one, use the element to compute the mass flux on the segment: */
    4949        for(i=0;i<num_segments;i++){
    50                 element_id=(int)*(segments+5*i+4);
     50                element_id=reCast<int,IssmDouble>(*(segments+5*i+4));
    5151                for(j=0;j<elements->Size();j++){
    5252                        element=(Element*)elements->GetObjectByOffset(j);
    … …  
    6666        /*Free ressources:*/
    6767        for(j=0;j<M;j++){
    68                 double* matrix=array[j];
    69                 xDelete<double>(matrix);
     68                IssmDouble* matrix=array[j];
     69                xDelete<IssmDouble>(matrix);
    7070        }
    7171        xDelete<int>(mdims_array);
    7272        xDelete<int>(ndims_array);
    73         xDelete<double*>(array);
     73        xDelete<IssmDouble*>(array);
    7474       
    7575        /*Assign output pointers: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units);
     12void MassFluxx(IssmDouble* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MaxAbsVxx( IssmDouble* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double maxabsvx;
    15         double node_maxabsvx;
    16         double element_maxabsvx;
     14        IssmDouble maxabsvx;
     15        IssmDouble node_maxabsvx;
     16        IssmDouble element_maxabsvx;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxAbsVxx( IssmDouble* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVXX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MaxAbsVyx( IssmDouble* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double maxabsvy;
    15         double node_maxabsvy;
    16         double element_maxabsvy;
     14        IssmDouble maxabsvy;
     15        IssmDouble node_maxabsvy;
     16        IssmDouble element_maxabsvy;
    1717
    1818

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxAbsVyx( IssmDouble* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVYX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MaxAbsVzx( IssmDouble* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double maxabsvz;
    15         double node_maxabsvz;
    16         double element_maxabsvz;
     14        IssmDouble maxabsvz;
     15        IssmDouble node_maxabsvz;
     16        IssmDouble element_maxabsvz;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxAbsVzx( IssmDouble* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVZX_H */

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     12void MaxVelx( IssmDouble* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    15         double maxvel;
    16         double node_maxvel;
    17         double element_maxvel;
     15        IssmDouble maxvel;
     16        IssmDouble node_maxvel;
     17        IssmDouble element_maxvel;
    1818
    1919        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxVelx( IssmDouble* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVELX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MaxVxx( IssmDouble* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double maxvx;
    15         double node_maxvx;
    16         double element_maxvx;
     14        IssmDouble maxvx;
     15        IssmDouble node_maxvx;
     16        IssmDouble element_maxvx;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    99
    1010/* local prototypes: */
    11 void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     11void MaxVxx( IssmDouble* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1212
    1313#endif  /* _MAXVXX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MaxVyx( IssmDouble* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212
    1313        int i;
    14         double maxvy;
    15         double node_maxvy;
    16         double element_maxvy;
     14        IssmDouble maxvy;
     15        IssmDouble node_maxvy;
     16        IssmDouble element_maxvy;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxVyx( IssmDouble* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVYX_H */

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     12void MaxVzx( IssmDouble* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    15         double maxvz;
    16         double node_maxvz;
    17         double element_maxvz;
     15        IssmDouble maxvz;
     16        IssmDouble node_maxvz;
     17        IssmDouble element_maxvz;
    1818
    1919        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MaxVzx( IssmDouble* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVZX_H */

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     12void MinVelx( IssmDouble* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    15         double minvel;
    16         double node_minvel;
    17         double element_minvel;
     15        IssmDouble minvel;
     16        IssmDouble node_minvel;
     17        IssmDouble element_minvel;
    1818
    1919        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MinVelx( IssmDouble* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVELX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MinVxx( IssmDouble* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double minvx;
    15         double node_minvx;
    16         double element_minvx;
     14        IssmDouble minvx;
     15        IssmDouble node_minvx;
     16        IssmDouble element_minvx;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MinVxx( IssmDouble* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MinVyx( IssmDouble* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double minvy;
    15         double node_minvy;
    16         double element_minvy;
     14        IssmDouble minvy;
     15        IssmDouble node_minvy;
     16        IssmDouble element_minvy;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MinVyx( IssmDouble* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVYX_H */

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

    r12102 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     11void MinVzx( IssmDouble* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1212       
    1313        int i;
    14         double minvz;
    15         double node_minvz;
    16         double element_minvz;
     14        IssmDouble minvz;
     15        IssmDouble node_minvz;
     16        IssmDouble element_minvz;
    1717
    1818        /*Go through elements, and request velocity: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void MinVzx( IssmDouble* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVZX_H */

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

    r12832 r13073  
    4242
    4343                        /*Get left and right elements*/
    44                         element=(int)iomodel->Data(MeshEdgesEnum)[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
     44                        element=reCast<int,IssmDouble>(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
    4545
    4646                        /*Now, if this element is not in the partition, pass: */

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

    r13056 r13073  
    7272
    7373                                        //Get index of the vertex on which the current node is located
    74                                         vertex_id=(int)*(iomodel->Data(MeshElementsEnum)+3*i+j); //(Matlab indexing)
     74                                        vertex_id=reCast<int,IssmDouble>(*(iomodel->Data(MeshElementsEnum)+3*i+j)); //(Matlab indexing)
    7575                                        io_index=vertex_id-1;                      //(C indexing)
    7676                                        _assert_(vertex_id>0 && vertex_id<=numberofvertices);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/CreateParametersControl.cpp

    r12832 r13073  
    2121        int         num_cm_responses;
    2222        int        *control_type     = NULL;
    23         double     *cm_responses     = NULL;
    24         double     *cm_jump          = NULL;
    25         double     *optscal          = NULL;
    26         double     *maxiter          = NULL;
     23        IssmDouble     *cm_responses     = NULL;
     24        IssmDouble     *cm_jump          = NULL;
     25        IssmDouble     *optscal          = NULL;
     26        IssmDouble     *maxiter          = NULL;
    2727
    2828        /*Get parameters: */
    … …  
    6464
    6565                xDelete<int>(control_type);
    66                 xDelete<double>(cm_responses);
    67                 xDelete<double>(cm_jump);
    68                 xDelete<double>(optscal);
    69                 xDelete<double>(maxiter);
     66                xDelete<IssmDouble>(cm_responses);
     67                xDelete<IssmDouble>(cm_jump);
     68                xDelete<IssmDouble>(optscal);
     69                xDelete<IssmDouble>(maxiter);
    7070        }
    7171

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

    r13056 r13073  
    4242        iomodel->FetchData(4,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    4343        for(i=0;i<num_control_type;i++){
    44                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
     44                switch(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])){
    4545                        case BalancethicknessThickeningRateEnum: iomodel->FetchData(1,BalancethicknessThickeningRateEnum); break;
    4646                        case VxEnum:   iomodel->FetchData(1,VxEnum); break;
    … …  
    4848                        case FrictionCoefficientEnum: iomodel->FetchData(1,FrictionCoefficientEnum); break;
    4949                        case MaterialsRheologyBbarEnum:    iomodel->FetchData(1,MaterialsRheologyBEnum); break;
    50                         default: _error_("Control " << EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]) << " not implemented yet");
     50                        default: _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
    5151                }
    5252        }

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

    r13056 r13073  
    1616        int     i,j;
    1717        int     count;
    18         double  yts;
    19         double  g;
    20         double  rho_ice;
    21         double  stokesreconditioning;
     18        IssmDouble  yts;
     19        IssmDouble  g;
     20        IssmDouble  rho_ice;
     21        IssmDouble  stokesreconditioning;
    2222        bool    isstokes,isl1l2,ismacayealpattyn;
    2323   bool    spcpresent=false;
    … …  
    2525        int My,Ny;
    2626        int Mz,Nz;
    27         double *spcvx          = NULL;
    28         double *spcvy          = NULL;
    29         double *spcvz          = NULL;
    30         double *nodeonmacayeal = NULL;
    31         double *nodeonpattyn   = NULL;
    32         double *nodeonstokes   = NULL;
    33         double *nodeonbed      = NULL;
    34         double *nodeonicesheet = NULL;
    35         double *vertices_type  = NULL;
    36         double *surface        = NULL;
    37         double *z              = NULL;
    38         double *timesx=NULL;
    39         double *timesy=NULL;
    40         double *timesz=NULL;
    41    double* values=NULL;
     27        IssmDouble *spcvx          = NULL;
     28        IssmDouble *spcvy          = NULL;
     29        IssmDouble *spcvz          = NULL;
     30        IssmDouble *nodeonmacayeal = NULL;
     31        IssmDouble *nodeonpattyn   = NULL;
     32        IssmDouble *nodeonstokes   = NULL;
     33        IssmDouble *nodeonbed      = NULL;
     34        IssmDouble *nodeonicesheet = NULL;
     35        IssmDouble *vertices_type  = NULL;
     36        IssmDouble *surface        = NULL;
     37        IssmDouble *z              = NULL;
     38        IssmDouble *timesx=NULL;
     39        IssmDouble *timesy=NULL;
     40        IssmDouble *timesz=NULL;
     41   IssmDouble* values=NULL;
    4242
    4343        /*Output*/
    … …  
    8888
    8989        /*figure out times: */
    90         timesx=xNew<double>(Nx);
     90        timesx=xNew<IssmDouble>(Nx);
    9191        for(j=0;j<Nx;j++){
    9292                timesx[j]=spcvx[(Mx-1)*Nx+j];
    … …  
    9595        UnitConversion(timesx,Nx,ExtToIuEnum,TimeEnum);
    9696        /*figure out times: */
    97         timesy=xNew<double>(Ny);
     97        timesy=xNew<IssmDouble>(Ny);
    9898        for(j=0;j<Ny;j++){
    9999                timesy[j]=spcvy[(My-1)*Ny+j];
    … …  
    102102        UnitConversion(timesy,Ny,ExtToIuEnum,TimeEnum);
    103103        /*figure out times: */
    104         timesz=xNew<double>(Nz);
     104        timesz=xNew<IssmDouble>(Nz);
    105105        for(j=0;j<Nz;j++){
    106106                timesz[j]=spcvz[(Mz-1)*Nz+j];
    … …  
    114114
    115115                        /*Start with adding spcs of coupling: zero at the border macayeal/pattyn for the appropriate dofs*/
    116                         if ((int)vertices_type[i]==MacAyealPattynApproximationEnum){
     116                        if (reCast<int,IssmDouble>(vertices_type[i]==MacAyealPattynApproximationEnum)){
    117117                                /*If grionmacayeal, spc pattyn dofs: 3 & 4*/
    118                                         if ((int)nodeonpattyn[i]){
     118                                        if (reCast<int,IssmDouble>(nodeonpattyn[i])){
    119119                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    120120                                                count++;
    … …  
    131131
    132132                                        }
    133                                         else if ((int)nodeonmacayeal[i]){
     133                                        else if (reCast<int,IssmDouble>(nodeonmacayeal[i])){
    134134                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    135135                                                count++;
    … …  
    149149                        }
    150150                        /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
    151                         else if ((int)vertices_type[i]==PattynStokesApproximationEnum){
     151                        else if (reCast<int,IssmDouble>(vertices_type[i])==PattynStokesApproximationEnum){
    152152                                /*If grion,pattyn spc stokes dofs: 3 4 & 5*/
    153                                         if ((int)nodeonpattyn[i]){
     153                                        if (reCast<int,IssmDouble>(nodeonpattyn[i])){
    154154                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    155155                                                count++;
    … …  
    168168
    169169                                        }
    170                                         else if ((int)nodeonstokes[i]){ //spc pattyn nodes: 1 & 2
     170                                        else if (reCast<int,IssmDouble>(nodeonstokes[i])){ //spc pattyn nodes: 1 & 2
    171171                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    172172                                                count++;
    … …  
    189189                        }
    190190                        /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
    191                         else if ((int)vertices_type[i]==MacAyealStokesApproximationEnum){
     191                        else if (reCast<int,IssmDouble>(vertices_type[i])==MacAyealStokesApproximationEnum){
    192192                                /*If grion,pattyn spc stokes dofs: 3 4 & 5*/
    193                                         if ((int)nodeonmacayeal[i]){
     193                                        if (reCast<int,IssmDouble>(nodeonmacayeal[i])){
    194194                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    195195                                                count++;
    … …  
    208208
    209209                                        }
    210                                         else if ((int)nodeonstokes[i]){ //spc macayeal nodes: 1 & 2
     210                                        else if (reCast<int,IssmDouble>(nodeonstokes[i])){ //spc macayeal nodes: 1 & 2
    211211                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    212212                                                count++;
    … …  
    236236                                else if (Mx==numberofvertices+1) {
    237237                                        /*figure out times and values: */
    238                                         values=xNew<double>(Nx);
     238                                        values=xNew<IssmDouble>(Nx);
    239239                                        spcpresent=false;
    240240                                        for(j=0;j<Nx;j++){
    … …  
    247247                                                count++;
    248248                                        }
    249                                         xDelete<double>(values);
     249                                        xDelete<IssmDouble>(values);
    250250                                }
    251251                                else if (vertices_type[i]==HutterApproximationEnum){
    … …  
    260260                                else if (My==numberofvertices+1){
    261261                                        /*figure out times and values: */
    262                                         values=xNew<double>(Ny);
     262                                        values=xNew<IssmDouble>(Ny);
    263263                                        spcpresent=false;
    264264                                        for(j=0;j<Ny;j++){
    … …  
    270270                                                count++;
    271271                                        }
    272                                         xDelete<double>(values);
     272                                        xDelete<IssmDouble>(values);
    273273                                }
    274274                                else if (vertices_type[i]==HutterApproximationEnum){
    … …  
    277277                                }
    278278
    279                                 if ((int)vertices_type[i]==StokesApproximationEnum ||  ((int)vertices_type[i]==NoneApproximationEnum)){
     279                                if (reCast<int,IssmDouble>(vertices_type[i])==StokesApproximationEnum ||  (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum)){
    280280                                        if (Mz==numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
    281281                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i]/yts,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    … …  
    284284                                        else if (Mz==numberofvertices+1){
    285285                                                /*figure out times and values: */
    286                                                 values=xNew<double>(Nz);
     286                                                values=xNew<IssmDouble>(Nz);
    287287                                                spcpresent=false;
    288288                                                for(j=0;j<Nz;j++){
    … …  
    294294                                                        count++;
    295295                                                }
    296                                                 xDelete<double>(values);
    297                                         }
    298 
    299                                 }
    300                                 if ((int)vertices_type[i]==NoneApproximationEnum){
     296                                                xDelete<IssmDouble>(values);
     297                                        }
     298
     299                                }
     300                                if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
    301301                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,g*rho_ice*(surface[i]-z[i])/stokesreconditioning,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    302302                                        count++;
    … …  
    305305
    306306                        /*Constraint at the bedrock interface (v.n = vz = 0) (Coordinates will be updated according to the bed slope)*/
    307                         if (dim==3) if(nodeonbed[i] && nodeonicesheet[i] && nodeonstokes[i]){
    308                                  switch((int)vertices_type[i]){
     307                        if (dim==3) if(reCast<int,IssmDouble>(nodeonbed[i]) && reCast<int,IssmDouble>(nodeonicesheet[i]) && reCast<int,IssmDouble>(nodeonstokes[i])){
     308                                 switch(reCast<int,IssmDouble>(vertices_type[i])){
    309309                                        case MacAyealStokesApproximationEnum:
    310310                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,DiagnosticHorizAnalysisEnum));
    … …  
    319319                                                count++;
    320320                                                break;
    321                                         default: _error_("Vertex approximation " << EnumToStringx((int)vertices_type[i]) << " not supported");
     321                                        default: _error_("Vertex approximation " << EnumToStringx(reCast<int,IssmDouble>(vertices_type[i])) << " not supported");
    322322                                }
    323323                        }
    … …  
    326326         
    327327        /*Free data: */
    328         xDelete<double>(spcvx);
    329         xDelete<double>(spcvy);
    330         xDelete<double>(spcvz);
    331         xDelete<double>(nodeonmacayeal);
    332         xDelete<double>(nodeonpattyn);
    333         xDelete<double>(nodeonstokes);
    334         xDelete<double>(nodeonicesheet);
    335         xDelete<double>(nodeonbed);
    336         xDelete<double>(vertices_type);
    337         xDelete<double>(surface);
    338         xDelete<double>(z);
     328        xDelete<IssmDouble>(spcvx);
     329        xDelete<IssmDouble>(spcvy);
     330        xDelete<IssmDouble>(spcvz);
     331        xDelete<IssmDouble>(nodeonmacayeal);
     332        xDelete<IssmDouble>(nodeonpattyn);
     333        xDelete<IssmDouble>(nodeonstokes);
     334        xDelete<IssmDouble>(nodeonicesheet);
     335        xDelete<IssmDouble>(nodeonbed);
     336        xDelete<IssmDouble>(vertices_type);
     337        xDelete<IssmDouble>(surface);
     338        xDelete<IssmDouble>(z);
    339339
    340340        /*Free resources:*/
    341         xDelete<double>(timesx);
    342         xDelete<double>(timesy);
    343         xDelete<double>(timesz);
    344         xDelete<double>(values);
     341        xDelete<IssmDouble>(timesx);
     342        xDelete<IssmDouble>(timesy);
     343        xDelete<IssmDouble>(timesz);
     344        xDelete<IssmDouble>(values);
    345345
    346346        /*Assign output pointer: */

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

    r13066 r13073  
    2929        bool ismacayealpattyn,isstokes,isl1l2;
    3030        int  numpenalties,numberofpressureloads,numrifts,numriftsegments;
    31         double *pressureload   = NULL;
    32         double *elements_type  = NULL;
    33         double *nodeoniceshelf = NULL;
    34         double *riftinfo       = NULL;
    35         double *nodeonbed      = NULL;
    36         double *nodeonstokes   = NULL;
    37         double *nodeonicesheet = NULL;
    38         double *vertices_type  = NULL;
    39         double *penalties      = NULL;
     31        IssmDouble *pressureload   = NULL;
     32        IssmDouble *elements_type  = NULL;
     33        IssmDouble *nodeoniceshelf = NULL;
     34        IssmDouble *riftinfo       = NULL;
     35        IssmDouble *nodeonbed      = NULL;
     36        IssmDouble *nodeonstokes   = NULL;
     37        IssmDouble *nodeonicesheet = NULL;
     38        IssmDouble *vertices_type  = NULL;
     39        IssmDouble *penalties      = NULL;
    4040
    4141        /*Fetch parameters: */
    … …  
    7474                if (dim==2) segment_width=4;
    7575                else segment_width=6;
    76                 element=(int)(*(pressureload+segment_width*i+segment_width-2)-1); //element is in the penultimate column (node1 node2 ... elem fill)
     76                element=reCast<int,IssmDouble>(*(pressureload+segment_width*i+segment_width-2)-1); //element is in the penultimate column (node1 node2 ... elem fill)
    7777
    7878                /*Now, if this element is not in the partition, pass: */
    … …  
    8080               
    8181                /*Do not create ice front if Hutter or Stokes elements*/
    82                 if ((int)*(elements_type+element)==HutterApproximationEnum) continue;
     82                if (reCast<int,IssmDouble>(*(elements_type+element))==HutterApproximationEnum) continue;
    8383
    8484                /*Create and  add load: */
    85                 if ((int)*(elements_type+element)==(MacAyealApproximationEnum) && dim==2){
     85                if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealApproximationEnum) && dim==2){
    8686                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal2dIceFrontEnum,DiagnosticHorizAnalysisEnum));
    8787                        count++;
    8888                }
    89                 else if ((int)*(elements_type+element)==(MacAyealApproximationEnum) && dim==3){
     89                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealApproximationEnum) && dim==3){
    9090                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
    9191                        count++;
    9292                }
    93                 else if ((int)*(elements_type+element)==(L1L2ApproximationEnum)){
     93                else if (reCast<int,IssmDouble>(*(elements_type+element))==(L1L2ApproximationEnum)){
    9494                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
    9595                        count++;
    9696                }
    97                 else if ((int)*(elements_type+element)==(PattynApproximationEnum)){
     97                else if (reCast<int,IssmDouble>(*(elements_type+element))==(PattynApproximationEnum)){
    9898                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,PattynIceFrontEnum,DiagnosticHorizAnalysisEnum));
    9999                        count++;
    100100                }
    101                 else if ((int)*(elements_type+element)==(L1L2ApproximationEnum)){
     101                else if (reCast<int,IssmDouble>(*(elements_type+element))==(L1L2ApproximationEnum)){
    102102                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,L1L2IceFrontEnum,DiagnosticHorizAnalysisEnum));
    103103                        count++;
    104104                }
    105                 else if ((int)*(elements_type+element)==(StokesApproximationEnum)){
     105                else if (reCast<int,IssmDouble>(*(elements_type+element))==(StokesApproximationEnum)){
    106106                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,StokesIceFrontEnum,DiagnosticHorizAnalysisEnum));
    107107                        count++;
    108108                }
    109                 else if ((int)*(elements_type+element)==(MacAyealPattynApproximationEnum)){
     109                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealPattynApproximationEnum)){
    110110                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
    111111                        count++;
    … …  
    113113                        count++;
    114114                }
    115                 else if ((int)*(elements_type+element)==(PattynStokesApproximationEnum)){
     115                else if (reCast<int,IssmDouble>(*(elements_type+element))==(PattynStokesApproximationEnum)){
    116116                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,PattynIceFrontEnum,DiagnosticHorizAnalysisEnum));
    117117                        count++;
    … …  
    119119                        count++;
    120120                }
    121                 else if ((int)*(elements_type+element)==(MacAyealStokesApproximationEnum)){
     121                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealStokesApproximationEnum)){
    122122                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
    123123                        count++;
    … …  
    129129        /*Free data: */
    130130        iomodel->DeleteData(3,DiagnosticIcefrontEnum,ThicknessEnum,BedEnum);
    131         xDelete<double>(elements_type);
    132         xDelete<double>(pressureload);
     131        xDelete<IssmDouble>(elements_type);
     132        xDelete<IssmDouble>(pressureload);
    133133
    134134        /*Create Penpair for penalties: */
    … …  
    137137        for(i=0;i<numpenalties;i++){
    138138
    139                 if(iomodel->my_vertices[(int)penalties[2*i+0]-1]){
     139                if(iomodel->my_vertices[reCast<int,IssmDouble>(penalties[2*i+0]-1)]){
    140140
    141141                        /*In debugging mode, check that the second node is in the same cpu*/
    … …  
    143143
    144144                        /*Get node ids*/
    145                         penpair_ids[0]=iomodel->nodecounter+(int)penalties[2*i+0];
    146                         penpair_ids[1]=iomodel->nodecounter+(int)penalties[2*i+1];
     145                        penpair_ids[0]=iomodel->nodecounter+reCast<int,IssmDouble>(penalties[2*i+0]);
     146                        penpair_ids[1]=iomodel->nodecounter+reCast<int,IssmDouble>(penalties[2*i+1]);
    147147
    148148                        /*Create Load*/
    … …  
    153153
    154154        /*free ressources: */
    155         xDelete<double>(penalties);
     155        xDelete<IssmDouble>(penalties);
    156156
    157157        /*Create Riffront loads for rifts: */
    … …  
    160160                iomodel->FetchData(5,RiftsRiftstructEnum,ThicknessEnum,BedEnum,SurfaceEnum,MaskVertexonfloatingiceEnum);
    161161                for(i=0;i<numriftsegments;i++){
    162                         if(iomodel->my_elements[(int)*(riftinfo+RIFTINFOSIZE*i+2)-1]){
     162                        if(iomodel->my_elements[reCast<int,IssmDouble>(*(riftinfo+RIFTINFOSIZE*i+2))-1]){
    163163                                loads->AddObject(new Riftfront(iomodel->loadcounter+count+1,i,iomodel,DiagnosticHorizAnalysisEnum));
    164164                                count++;

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

    r12832 r13073  
    1616        int i;
    1717        int count;
    18         double yts;
     18        IssmDouble yts;
    1919        int    numberofvertices;
    2020        bool   ishutter;
    … …  
    5151                /*keep only this partition's nodes:*/
    5252                if((iomodel->my_vertices[i])){
    53                         if (!(int)iomodel->Data(FlowequationVertexEquationEnum)[i]==HutterApproximationEnum){
     53                        if (!reCast<int,IssmDouble>(iomodel->Data(FlowequationVertexEquationEnum)[i])==HutterApproximationEnum){
    5454
    5555                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHutterAnalysisEnum));

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

    r12832 r13073  
    1717        int dim;
    1818        int count;
    19         double yts;
     19        IssmDouble yts;
    2020        int    numberofvertices;
    2121
    … …  
    5252                if(iomodel->my_vertices[i]){
    5353
    54                         if ((int)iomodel->Data(FlowequationBorderstokesEnum)[i]){
     54                        if (reCast<int,IssmDouble>(iomodel->Data(FlowequationBorderstokesEnum)[i])){
    5555                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticVertAnalysisEnum)); //spc to zero as vertical velocity is done in Horiz for Stokes
    5656                                count++;

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

    r13056 r13073  
    2121        int    numberofvertices;
    2222        bool   spcpresent=false;
    23         double heatcapacity;
    24         double referencetemperature;
     23        IssmDouble heatcapacity;
     24        IssmDouble referencetemperature;
    2525       
    2626        /*Output*/

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

    r13056 r13073  
    4040        for (i=0;i<numberofvertices;i++){
    4141                if((iomodel->my_vertices[i]==1)){
    42                         if (iomodel->Data(MeshVertexonbedEnum)[i]){
     42                        if (reCast<int>(iomodel->Data(MeshVertexonbedEnum)[i])){
    4343                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,MeltingAnalysisEnum));
    4444                        }

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

    r12832 r13073  
    2323        bool   ispdd;
    2424        bool   isdelta18o;
    25         IssmDouble *size, Delta18oTimeSerie,Delta18oSurfaceTimeSerie ;
    2625
    2726        /*Fetch data needed: */

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

    r11695 r13073  
    1111
    1212        /*intermediary:*/
    13         double norm_new,norm_old,dot_product;;
     13        IssmDouble norm_new,norm_old,dot_product;;
    1414
    1515        /*Initialize output*/

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void RheologyBbarAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void RheologyBbarAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12450 r13073  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* vector){
     11void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* vector){
    1212
    1313        int  num_controls;
    … …  
    3030void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Vector* vector){
    3131       
    32         double* serial_vector=NULL;
     32        IssmDouble* serial_vector=NULL;
    3333
    3434        serial_vector=vector->ToMPISerial();
    … …  
    3737
    3838        /*Free ressources:*/
    39         xDelete<double>(serial_vector);
     39        xDelete<IssmDouble>(serial_vector);
    4040}

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

    r12832 r13073  
    1010/* local prototypes: */
    1111void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,Vector* vector);
    12 void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,double* vector);
     12void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials,  Parameters* parameters,IssmDouble* vector);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceAbsVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     12void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void SurfaceAbsVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void SurfaceAverageVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     13void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
    1414
    1515        /*Intermediary*/
    … …  
    1818
    1919        /*output: */
    20         double J=0;
    21         double J_sum;
     20        IssmDouble J=0;
     21        IssmDouble J_sum;
    2222
    2323        /*Compute surface area and add to elements inputs */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void SurfaceAverageVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceLogVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     12void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void SurfaceLogVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceLogVxVyMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     12void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void SurfaceLogVxVyMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceRelVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     12void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void SurfaceRelVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void ThicknessAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void ThicknessAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void ThicknessAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void ThicknessAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12102 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void ThicknessAbsMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void ThicknessAbsMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12927 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void ThicknessAcrossGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12927 r13073  
    1010
    1111/* local prototypes: */
    12 void ThicknessAcrossGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12927 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void ThicknessAlongGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     12void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
    1313
    1414        /*Intermediary*/
    … …  
    1717
    1818        /*output: */
    19         double J=0;
    20         double J_sum;
     19        IssmDouble J=0;
     20        IssmDouble J_sum;
    2121
    2222        /*Compute Misfit: */

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

    r12927 r13073  
    1010
    1111/* local prototypes: */
    12 void ThicknessAlongGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     12void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
    1313
    1414#endif

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

    r12773 r13073  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void TotalSmbx(double* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     12void TotalSmbx(IssmDouble* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313
    14         double local_smb = 0;
    15         double total_smb;
     14        IssmDouble local_smb = 0;
     15        IssmDouble total_smb;
    1616
    1717        for(int i=0;i<elements->Size();i++){

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

    r12832 r13073  
    1010
    1111/* local prototypes: */
    12 void TotalSmbx(double* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     12void TotalSmbx(IssmDouble* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif

  • issm/trunk-jpl/src/c/solutions/control_core.cpp

    r12832 r13073  
    8282                /*Display info*/
    8383                if(VerboseControl()) _pprintLine_("\n" << "   control method step " << n+1 << "/" << nsteps);
    84                 for(i=0;i<num_responses;i++) step_responses[i]=(int)responses[n*num_responses+i];
     84                for(i=0;i<num_responses;i++) step_responses[i]=reCast<int,IssmDouble>(responses[n*num_responses+i]);
    8585                femmodel->parameters->SetParam(step_responses,1,num_responses,StepResponsesEnum);
    8686               
    … …  
    9999
    100100                if(VerboseControl()) _pprintLine_("   optimizing along gradient direction");
    101                 optpars.maxiter=(int)maxiter[n]; optpars.cm_jump=cm_jump[n];
     101                optpars.maxiter=reCast<int,IssmDouble>(maxiter[n]); optpars.cm_jump=cm_jump[n];
    102102                BrentSearch(&search_scalar,J+n,&optpars,&objectivefunction,&optargs);
    103103

  • issm/trunk-jpl/src/c/solutions/hydrology_core.cpp

    r12832 r13073  
    3939                nsteps=1;
    4040        }
    41         else nsteps=(int)((final_time-starttime)/dt);
     41        else nsteps=reCast<int,IssmDouble>((final_time-starttime)/dt);
    4242        time=starttime;
    4343

  • issm/trunk-jpl/src/c/solutions/issm.cpp

    r13067 r13073  
    1515
    1616        /*AD: */
    17         size_t   tape_stats[11];
     17        int   tape_stats[11];
    1818
    1919        /*FemModel: */
Note: See TracChangeset for help on using the changeset viewer.