Changeset 12477


Ignore:
Timestamp:
06/20/12 12:31:14 (13 years ago)
Author:
utke
Message:

type renames

Location:
issm/trunk-jpl/src/c
Files:
23 edited

Legend:

Unmodified
Added
Removed

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

    r12439 r12477  
    2020        int     num_controls,num_responses;
    2121        int     nsteps;
    22         double  tol_cm;
     22        IssmDouble  tol_cm;
    2323        bool    cm_gradient;
    2424        int     dim;
    … …  
    2828
    2929        int*    control_type = NULL;
    30         double* responses=NULL;
     30        IssmDouble* responses=NULL;
    3131        int*    step_responses=NULL;
    32         double* maxiter=NULL;
    33         double* cm_jump=NULL;
     32        IssmDouble* maxiter=NULL;
     33        IssmDouble* cm_jump=NULL;
    3434               
    3535        /*intermediary: */
    36         double  search_scalar=1;
     36        IssmDouble  search_scalar=1;
    3737        OptArgs optargs;
    3838        OptPars optpars;
    … …  
    4343
    4444        /*output: */
    45         double* J=NULL;
     45        IssmDouble* J=NULL;
    4646
    4747        /*Recover parameters used throughout the solution*/
    … …  
    7070
    7171        /*Initialize responses: */
    72         J=xNew<double>(nsteps);
     72        J=xNew<IssmDouble>(nsteps);
    7373        step_responses=xNew<int>(num_responses);
    7474               
    … …  
    122122        xDelete<int>(control_type);
    123123        xDelete<int>(step_responses);
    124         xDelete<double>(maxiter);
    125         xDelete<double>(responses);
    126         xDelete<double>(cm_jump);
    127         xDelete<double>(J);
     124        xDelete<IssmDouble>(maxiter);
     125        xDelete<IssmDouble>(responses);
     126        xDelete<IssmDouble>(cm_jump);
     127        xDelete<IssmDouble>(J);
    128128}

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

    r10197 r12477  
    1717#include "./solutions.h"
    1818
    19 bool controlconvergence(double J, double tol_cm){
     19bool controlconvergence(IssmDouble J, IssmDouble tol_cm){
    2020
    2121        int i;

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

    r12439 r12477  
    77#include "../EnumDefinitions/EnumDefinitions.h"
    88
    9 void controlrestart(FemModel* femmodel,double* J){
     9void controlrestart(FemModel* femmodel,IssmDouble* J){
    1010
    1111        int      num_controls;

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

    r12439 r12477  
    1717
    1818/*Local prototype*/
    19 int FormFunctionGradient(TaoSolver,Vec,double*,Vec,void*);
     19int FormFunctionGradient(TaoSolver,Vec,IssmDouble*,Vec,void*);
    2020int IssmMonitor(TaoSolver,void*);
    2121typedef struct {
    … …  
    3131        AppCtx     user;
    3232        TaoSolver  tao;
    33         double    *dummy          = NULL;
     33        IssmDouble    *dummy          = NULL;
    3434        int       *control_list   = NULL;
    3535        Vector    *X              = NULL;
    … …  
    5050        femmodel->parameters->FindParam(&dummy,NULL,NULL,InversionMaxiterPerStepEnum);
    5151        femmodel->parameters->SetParam(false,SaveResultsEnum);
    52         maxiter=nsteps*(int)dummy[0]; xDelete<double>(dummy);
     52        maxiter=nsteps*(int)dummy[0]; xDelete<IssmDouble>(dummy);
    5353
    5454        /*Initialize TAO*/
    … …  
    100100        TaoFinalize();
    101101}
    102 int FormFunctionGradient(TaoSolver tao, Vec Xpetsc, double *fcn,Vec G,void *userCtx){
     102int FormFunctionGradient(TaoSolver tao, Vec Xpetsc, IssmDouble *fcn,Vec G,void *userCtx){
    103103
    104104        /*Retreive arguments*/
    … …  
    107107        FemModel *femmodel       = user->femmodel;
    108108        int      *cost_functions = NULL;
    109         double   *cost_functionsd= NULL;
     109        IssmDouble   *cost_functionsd= NULL;
    110110        Vector   *gradient       = NULL;
    111111        Vector   *X              = NULL;
    … …  
    147147        /*Clean-up and return*/
    148148        xDelete<int>(cost_functions);
    149         xDelete<double>(cost_functionsd);
     149        xDelete<IssmDouble>(cost_functionsd);
    150150        return 0;
    151151}
    … …  
    153153
    154154        int       i,its,num_responses;
    155         double    f,gnorm,cnorm,xdiff;
     155        IssmDouble    f,gnorm,cnorm,xdiff;
    156156        AppCtx   *user      = (AppCtx *)userCtx;
    157157        FemModel *femmodel  = user->femmodel;

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

    r11921 r12477  
    1919        Vector* KUoldF=NULL;
    2020        Vector* duf=NULL;
    21         double ndu,nduinf,nu;
    22         double nKUF;
    23         double nKUoldF;
    24         double nF;
    25         double solver_residue,res;
     21        IssmDouble ndu,nduinf,nu;
     22        IssmDouble nKUF;
     23        IssmDouble nKUoldF;
     24        IssmDouble nF;
     25        IssmDouble solver_residue,res;
    2626
    2727        /*convergence options*/
    28         double eps_res;
    29         double eps_rel;
    30         double eps_abs;
    31         double yts;
     28        IssmDouble eps_res;
     29        IssmDouble eps_rel;
     30        IssmDouble eps_abs;
     31        IssmDouble yts;
    3232
    3333        /*If uf is NULL in input, f-set is nil, model is fully constrained, therefore converged from

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

    r12439 r12477  
    1616
    1717        /*Intermediaries*/
    18         double  norm_inf;
    19         double *norm_list    = NULL;
     18        IssmDouble  norm_inf;
     19        IssmDouble *norm_list    = NULL;
    2020        Vector*     new_gradient = NULL;
    2121        Vector*     gradient     = NULL;
    … …  
    4848
    4949        /*Clean up and return*/
    50         xDelete<double>(norm_list);
     50        xDelete<IssmDouble>(norm_list);
    5151}

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

    r11832 r12477  
    1717
    1818        /*intermediary*/
    19         double time;
     19        IssmDouble time;
    2020        int    nsteps;
    21         double starttime,final_time;
    22         double dt;
     21        IssmDouble starttime,final_time;
     22        IssmDouble dt;
    2323        bool   save_results;
    2424        int    output_frequency;

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

    r9761 r12477  
    1313#include "../solvers/solvers.h"
    1414
    15 void hydrology_core_step(FemModel* femmodel,int step, double time){
     15void hydrology_core_step(FemModel* femmodel,int step, IssmDouble time){
    1616       
    1717        bool modify_loads=true;

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

    r12439 r12477  
    3030
    3131        /*time*/
    32         double   start, finish;
    33         double   start_core, finish_core;
    34         double   start_init, finish_init;
     32        IssmPDouble   start, finish;
     33        IssmPDouble   start_core, finish_core;
     34        IssmPDouble   start_init, finish_init;
    3535        int      ierr;
    3636
    … …  
    5050        MPI_Barrier(MPI_COMM_WORLD); start=MPI_Wtime();
    5151        #else
    52         start=(double)clock();
     52        start=(IssmPDouble)clock();
    5353        #endif
    5454
    … …  
    7373        MPI_Barrier(MPI_COMM_WORLD); start_init=MPI_Wtime();
    7474        #else
    75         start_init=(double)clock();
     75        start_init=(IssmPDouble)clock();
    7676        #endif
    7777        femmodel=new FemModel(binfilename,outbinfilename,solution_type,analyses,numanalyses);
    … …  
    9797        MPI_Barrier(MPI_COMM_WORLD); finish_init=MPI_Wtime();
    9898        #else
    99         finish_init=(double)clock();
     99        finish_init=(IssmPDouble)clock();
    100100        #endif
    101101
    … …  
    104104        MPI_Barrier(MPI_COMM_WORLD); start_core=MPI_Wtime( );
    105105        #else
    106         start_core=(double)clock();
     106        start_core=(IssmPDouble)clock();
    107107        #endif
    108108       
    … …  
    130130        MPI_Barrier(MPI_COMM_WORLD); finish_core=MPI_Wtime( );
    131131        #else
    132         finish_core=(double)clock();
     132        finish_core=(IssmPDouble)clock();
    133133        #endif
    134134       
    … …  
    158158        _printf_(true,"\n   %s %i hrs %i min %i sec\n\n","Total elapsed time:",int((finish-start)/3600),int(int(finish-start)%3600/60),int(finish-start)%60);
    159159        #else
    160         finish=(double)clock();
     160        finish=(IssmPDouble)clock();
    161161        _printf_(true,"\n   %-34s %f seconds  \n","FemModel initialization elapsed time:",(finish_init-start_init)/CLOCKS_PER_SEC);
    162162        _printf_(true,"   %-34s %f seconds  \n","Core solution elapsed time:",(finish_core-start_core)/CLOCKS_PER_SEC);

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

    r12439 r12477  
    88/*Local prototypes*/
    99void ProcessArguments2(char** pbinfilename,char** poutbinfilename,char** plockfilename,int argc,char **argv);
    10 void ProcessInputfile(double **px,double **py,double **pdata,int *pnobs,double **px_interp,double **py_interp,int *pninterp,Options **poptions,FILE* fid);
     10void ProcessInputfile(IssmDouble **px,IssmDouble **py,IssmDouble **pdata,int *pnobs,IssmDouble **px_interp,IssmDouble **py_interp,int *pninterp,Options **poptions,FILE* fid);
    1111
    1212int main(int argc,char **argv){
    … …  
    2424        /*Input*/
    2525        int      ninterp,nobs;
    26         double  *x        = NULL;
    27         double  *y        = NULL;
    28         double  *data     = NULL;
    29         double  *x_interp = NULL;
    30         double  *y_interp = NULL;
     26        IssmDouble  *x        = NULL;
     27        IssmDouble  *y        = NULL;
     28        IssmDouble  *data     = NULL;
     29        IssmDouble  *x_interp = NULL;
     30        IssmDouble  *y_interp = NULL;
    3131        Options *options  = NULL;
    3232
    3333        /*Output*/
    34         double *predictions = NULL;
    35         double *error       = NULL;
     34        IssmDouble *predictions = NULL;
     35        IssmDouble *error       = NULL;
    3636
    3737        ISSMBOOT();
    … …  
    8989        xDelete<char>(binfilename);
    9090        xDelete<char>(outbinfilename);
    91         xDelete<double>(x);
    92         xDelete<double>(y);
    93         xDelete<double>(data);
    94         xDelete<double>(x_interp);
    95         xDelete<double>(y_interp);
    96         xDelete<double>(predictions);
    97         xDelete<double>(error);
     91        xDelete<IssmDouble>(x);
     92        xDelete<IssmDouble>(y);
     93        xDelete<IssmDouble>(data);
     94        xDelete<IssmDouble>(x_interp);
     95        xDelete<IssmDouble>(y_interp);
     96        xDelete<IssmDouble>(predictions);
     97        xDelete<IssmDouble>(error);
    9898        delete options;
    9999        delete results;
    … …  
    134134}
    135135
    136 void ProcessInputfile(double **px,double **py,double **pdata,int *pnobs,double **px_interp,double **py_interp,int *pninterp,Options **poptions,FILE* fid){
     136void ProcessInputfile(IssmDouble **px,IssmDouble **py,IssmDouble **pdata,int *pnobs,IssmDouble **px_interp,IssmDouble **py_interp,int *pninterp,Options **poptions,FILE* fid){
    137137
    138138        int      ninterp,nobs,numoptions;
    139         double  *x        = NULL;
    140         double  *y        = NULL;
    141         double  *data     = NULL;
    142         double  *x_interp = NULL;
    143         double  *y_interp = NULL;
     139        IssmDouble  *x        = NULL;
     140        IssmDouble  *y        = NULL;
     141        IssmDouble  *data     = NULL;
     142        IssmDouble  *x_interp = NULL;
     143        IssmDouble  *y_interp = NULL;
    144144        Options *options  = NULL;
    145145        Option  *option   = NULL;

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

    r12365 r12477  
    2020/*}}}*/
    2121
    22 double objectivefunction(double search_scalar,OptArgs* optargs){
     22IssmDouble objectivefunction(IssmDouble search_scalar,OptArgs* optargs){
    2323
    2424        int i; 
    2525       
    2626        /*output: */
    27         double J;
     27        IssmDouble J;
    2828       
    2929        /*parameters: */

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

    r11830 r12477  
    1818void diagnostic_core(FemModel* femmodel);
    1919void hydrology_core(FemModel* femmodel);
    20 void hydrology_core_step(FemModel* femmodel,int step, double time);
     20void hydrology_core_step(FemModel* femmodel,int step, IssmDouble time);
    2121void thermal_core(FemModel* femmodel);
    2222void enthalpy_core(FemModel* femmodel);
    … …  
    3030void steadystate_core(FemModel* femmodel);
    3131void transient_core(FemModel* femmodel);
    32 double objectivefunction(double search_scalar,OptArgs* optargs);
     32IssmDouble objectivefunction(IssmDouble search_scalar,OptArgs* optargs);
    3333
    3434//convergence:
    3535void convergence(bool* pconverged, Matrix* K_ff,Vector* p_f,Vector* u_f,Vector* u_f_old,Parameters* parameters);
    36 bool controlconvergence(double J,double tol_cm);
     36bool controlconvergence(IssmDouble J,IssmDouble tol_cm);
    3737bool steadystateconvergence(FemModel* femmodel);
    3838
    3939//optimization
    40 int GradJSearch(double* search_vector,FemModel* femmodel,int step);
     40int GradJSearch(IssmDouble* search_vector,FemModel* femmodel,int step);
    4141
    4242//diverse
    4343void ProcessArguments(int* solution,char** pbinname,char** poutbinname,char** ppetscname,char** plockname,int argc,char **argv);
    4444void WriteLockFile(char* filename);
    45 void controlrestart(FemModel* femmodel,double* J);
     45void controlrestart(FemModel* femmodel,IssmDouble* J);
    4646void ResetBoundaryConditions(FemModel* femmodel, int analysis_type);
    4747

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

    r9677 r12477  
    2828        int temperatureenums[2]={TemperatureEnum,TemperatureOldEnum};
    2929        int convergencecriterion[1]={RelativeEnum}; //criterions for convergence, RelativeEnum or AbsoluteEnum
    30         double convergencecriterionvalue[1]; //value of criterion to be respected
     30        IssmDouble convergencecriterionvalue[1]; //value of criterion to be respected
    3131
    3232        /*retrieve parameters: */

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

    r11830 r12477  
    1616
    1717        /*intermediary*/
    18         double melting_offset;
     18        IssmDouble melting_offset;
    1919        bool   save_results;
    2020        bool   dakota_analysis  = false;

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

    r12439 r12477  
    2323
    2424        /*parameters: */
    25         double starttime,finaltime,dt,yts;
     25        IssmDouble starttime,finaltime,dt,yts;
    2626        bool   isdiagnostic,isprognostic,isthermal,isgroundingline,isenthalpy;
    2727        bool   save_results,dakota_analysis;
    … …  
    3434        /*intermediary: */
    3535        int    step;
    36         double time;
     36        IssmDouble time;
    3737
    3838        //first recover parameters common to all solutions

  • issm/trunk-jpl/src/c/solvers/solver_newton.cpp

    r12271 r12477  
    1717        int    num_unstable_constraints;
    1818        int    count;
    19         double kmax;
     19        IssmDouble kmax;
    2020        Matrix* Kff = NULL;
    2121        Matrix* Kfs    = NULL;
    … …  
    7070                        bool max_iteration_state=false;
    7171                        int tempStep=1;
    72                         double tempTime=1.0;
     72                        IssmDouble tempTime=1.0;
    7373                        femmodel->results->AddObject(new BoolExternalResult(femmodel->results->Size()+1, MaxIterationConvergenceFlagEnum, max_iteration_state, tempStep, tempTime));
    7474                        break;
    … …  
    7878                        bool max_iteration_state=true;
    7979                        int tempStep=1;
    80                         double tempTime=1.0;
     80                        IssmDouble tempTime=1.0;
    8181                        femmodel->results->AddObject(new BoolExternalResult(femmodel->results->Size()+1, MaxIterationConvergenceFlagEnum, max_iteration_state, tempStep, tempTime));
    8282                        break;

  • issm/trunk-jpl/src/c/solvers/solver_nonlinear.cpp

    r12271 r12477  
    8888                        bool max_iteration_state=false;
    8989                        int tempStep=1;
    90                         double tempTime=1.0;
     90                        IssmDouble tempTime=1.0;
    9191                        femmodel->results->AddObject(new BoolExternalResult(femmodel->results->Size()+1, MaxIterationConvergenceFlagEnum, max_iteration_state, tempStep, tempTime));
    9292                        break;
    … …  
    9999                        bool max_iteration_state=true;
    100100                        int tempStep=1;
    101                         double tempTime=1.0;
     101                        IssmDouble tempTime=1.0;
    102102                        femmodel->results->AddObject(new BoolExternalResult(femmodel->results->Size()+1, MaxIterationConvergenceFlagEnum, max_iteration_state, tempStep, tempTime));
    103103                        break;

  • issm/trunk-jpl/src/c/solvers/solver_thermal_nonlinear.cpp

    r11679 r12477  
    1616        Vector* tf_old=NULL;
    1717        Vector* ys=NULL;
    18         double melting_offset;
     18        IssmDouble melting_offset;
    1919
    2020        /*intermediary: */

  • issm/trunk-jpl/src/c/toolkits/issm/SeqMat.cpp

    r12446 r12477  
    3333        this->N=pN;
    3434        this->matrix=NULL;
    35         if(M*N) this->matrix=xNewZeroInit<double>(pM*pN);
    36 }
    37 /*}}}*/
    38 /*FUNCTION SeqMat::SeqMat(int M,int N, double sparsity){{{*/
    39 SeqMat::SeqMat(int pM,int pN, double sparsity){
    40 
    41         this->M=pM;
    42         this->N=pN;
    43         this->matrix=NULL;
    44         if(M*N) this->matrix=xNewZeroInit<double>(pM*pN);
    45 }
    46 /*}}}*/
    47 /*FUNCTION SeqMat(double* serial_mat,int M,int N,double sparsity){{{*/
    48 SeqMat::SeqMat(double* serial_mat,int pM,int pN,double sparsity){
     35        if(M*N) this->matrix=xNewZeroInit<IssmDouble>(pM*pN);
     36}
     37/*}}}*/
     38/*FUNCTION SeqMat::SeqMat(int M,int N, IssmDouble sparsity){{{*/
     39SeqMat::SeqMat(int pM,int pN, IssmDouble sparsity){
     40
     41        this->M=pM;
     42        this->N=pN;
     43        this->matrix=NULL;
     44        if(M*N) this->matrix=xNewZeroInit<IssmDouble>(pM*pN);
     45}
     46/*}}}*/
     47/*FUNCTION SeqMat(IssmDouble* serial_mat,int M,int N,IssmDouble sparsity){{{*/
     48SeqMat::SeqMat(IssmDouble* serial_mat,int pM,int pN,IssmDouble sparsity){
    4949
    5050        int i,j;
    … …  
    5454        this->matrix=NULL;
    5555        if(M*N){
    56                 this->matrix=xNewZeroInit<double>(pM*pN);
    57                 memcpy(this->matrix,serial_mat,pM*pN*sizeof(double));
     56                this->matrix=xNewZeroInit<IssmDouble>(pM*pN);
     57                xMemCpy<IssmDouble>(this->matrix,serial_mat,pM*pN);
    5858        }
    5959
    … …  
    6666        this->N=pN;
    6767        this->matrix=NULL;
    68         if(M*N) this->matrix=xNewZeroInit<double>(pM*pN);
     68        if(M*N) this->matrix=xNewZeroInit<IssmDouble>(pM*pN);
    6969}
    7070/*}}}*/
    … …  
    7272SeqMat::~SeqMat(){
    7373
    74         xDelete<double>(this->matrix);
     74        xDelete<IssmDouble>(this->matrix);
    7575        M=0;
    7676        N=0;
    … …  
    100100/*}}}*/
    101101/*FUNCTION SeqMat::Norm{{{*/
    102 double SeqMat::Norm(NormMode mode){
    103 
    104         double norm;
    105         double absolute;
     102IssmDouble SeqMat::Norm(NormMode mode){
     103
     104        IssmDouble norm;
     105        IssmDouble absolute;
    106106        int i,j;
    107107
    … …  
    145145        int i,j;
    146146        int XM,AXM;
    147         double dummy;
     147        IssmDouble dummy;
    148148
    149149        X->GetSize(&XM);
    … …  
    166166SeqMat* SeqMat::Duplicate(void){
    167167
    168         double dummy=0;
     168        IssmDouble dummy=0;
    169169
    170170        return new SeqMat(this->matrix,this->M,this->N,dummy);
    … …  
    173173/*}}}*/
    174174/*FUNCTION SeqMat::ToSerial{{{*/
    175 double* SeqMat::ToSerial(void){
    176 
    177         double* buffer=NULL;
     175IssmDouble* SeqMat::ToSerial(void){
     176
     177        IssmDouble* buffer=NULL;
    178178
    179179        if(this->M*this->N){
    180                 buffer=xNew<double>(this->M*this->N);
    181                 memcpy(buffer,this->matrix,this->M*this->N*sizeof(double));
     180                buffer=xNew<IssmDouble>(this->M*this->N);
     181                xMemCpy<IssmDouble>(buffer,this->matrix,this->M*this->N);
    182182        }
    183183        return buffer;
    … …  
    186186/*}}}*/
    187187/*FUNCTION SeqMat::SetValues{{{*/
    188 void SeqMat::SetValues(int m,int* idxm,int n,int* idxn,double* values,InsMode mode){
     188void SeqMat::SetValues(int m,int* idxm,int n,int* idxn,IssmDouble* values,InsMode mode){
    189189       
    190190        int i,j;

  • issm/trunk-jpl/src/c/toolkits/issm/SeqMat.h

    r12365 r12477  
    11/*!\file:  SeqMat.h
    2  * \brief wrapper to SeqMat objects, which are just wrappers to a simple double* buffer.
     2 * \brief wrapper to SeqMat objects, which are just wrappers to a simple IssmDouble* buffer.
    33 */
    44
    … …  
    2424       
    2525                int M,N;
    26                 double* matrix;
     26                IssmDouble* matrix;
    2727
    2828                /*SeqMat constructors, destructors {{{*/
    2929                SeqMat();
    3030                SeqMat(int M,int N);
    31                 SeqMat(int M,int N,double sparsity);
    32                 SeqMat(double* serial_mat,int M,int N,double sparsity);
     31                SeqMat(int M,int N,IssmDouble sparsity);
     32                SeqMat(IssmDouble* serial_mat,int M,int N,IssmDouble sparsity);
    3333                SeqMat(int M,int N,int connectivity,int numberofdofspernode);
    3434                ~SeqMat();
    … …  
    3737                void Echo(void);
    3838                void Assemble(void);
    39                 double Norm(NormMode norm_type);
     39                IssmDouble Norm(NormMode norm_type);
    4040                void GetSize(int* pM,int* pN);
    4141                void GetLocalSize(int* pM,int* pN);
    4242                void MatMult(SeqVec* X,SeqVec* AX);
    4343                SeqMat* Duplicate(void);
    44                 double* ToSerial(void);
    45                 void SetValues(int m,int* idxm,int n,int* idxn,double* values,InsMode mode);
     44                IssmDouble* ToSerial(void);
     45                void SetValues(int m,int* idxm,int n,int* idxn,IssmDouble* values,InsMode mode);
    4646                void Convert(MatrixType type);
    4747                /*}}}*/

  • issm/trunk-jpl/src/c/toolkits/issm/SeqVec.cpp

    r12446 r12477  
    3131        this->M=pM;
    3232        this->vector=NULL;
    33         if(this->M) this->vector=xNewZeroInit<double>(pM);
    34 }
    35 /*}}}*/
    36 /*FUNCTION SeqVec::SeqVec(double* serial_vec,int M){{{*/
    37 SeqVec::SeqVec(double* buffer,int pM){
     33        if(this->M) this->vector=xNewZeroInit<IssmDouble>(pM);
     34}
     35/*}}}*/
     36/*FUNCTION SeqVec::SeqVec(IssmDouble* serial_vec,int M){{{*/
     37SeqVec::SeqVec(IssmDouble* buffer,int pM){
    3838
    3939        int i,j;
    … …  
    4242        this->vector=NULL;
    4343        if(this->M){
    44                 this->vector=xNewZeroInit<double>(pM);
    45                 memcpy(this->vector,buffer,pM*sizeof(double));
     44                this->vector=xNewZeroInit<IssmDouble>(pM);
     45                xMemCpy<IssmDouble>(this->vector,buffer,pM);
    4646        }
    4747}
    … …  
    4949                /*FUNCTION SeqVec::~SeqVec(){{{*/
    5050SeqVec::~SeqVec(){
    51         xDelete<double>(this->vector);
     51        xDelete<IssmDouble>(this->vector);
    5252        M=0;
    5353}
    … …  
    7474/*}}}*/
    7575/*FUNCTION SeqVec::SetValues{{{*/
    76 void SeqVec::SetValues(int ssize, int* list, double* values, InsMode mode){
     76void SeqVec::SetValues(int ssize, int* list, IssmDouble* values, InsMode mode){
    7777       
    7878        int i;
    … …  
    9292/*}}}*/
    9393/*FUNCTION SeqVec::SetValue{{{*/
    94 void SeqVec::SetValue(int dof, double value, InsMode mode){
     94void SeqVec::SetValue(int dof, IssmDouble value, InsMode mode){
    9595
    9696        switch(mode){
    … …  
    108108/*}}}*/
    109109/*FUNCTION SeqVec::GetValue{{{*/
    110 void SeqVec::GetValue(double* pvalue,int dof){
     110void SeqVec::GetValue(IssmDouble* pvalue,int dof){
    111111
    112112        *pvalue=this->vector[dof];
    … …  
    137137/*}}}*/
    138138/*FUNCTION SeqVec::Set{{{*/
    139 void SeqVec::Set(double value){
     139void SeqVec::Set(IssmDouble value){
    140140
    141141        int i;
    … …  
    145145/*}}}*/
    146146/*FUNCTION SeqVec::AXPY{{{*/
    147 void SeqVec::AXPY(SeqVec* X, double a){
     147void SeqVec::AXPY(SeqVec* X, IssmDouble a){
    148148
    149149        int i;
    … …  
    155155/*}}}*/
    156156/*FUNCTION SeqVec::AYPX{{{*/
    157 void SeqVec::AYPX(SeqVec* X, double a){
     157void SeqVec::AYPX(SeqVec* X, IssmDouble a){
    158158       
    159159        int i;
    … …  
    165165/*}}}*/
    166166/*FUNCTION SeqVec::ToMPISerial{{{*/
    167 double* SeqVec::ToMPISerial(void){
    168 
    169         double* buffer=NULL;
     167IssmDouble* SeqVec::ToMPISerial(void){
     168
     169        IssmDouble* buffer=NULL;
    170170
    171171        if(this->M){
    172                 buffer=xNew<double>(this->M);
    173                 memcpy(buffer,this->vector,this->M*sizeof(double));
     172                buffer=xNew<IssmDouble>(this->M);
     173                xMemCpy<IssmDouble>(buffer,this->vector,this->M);
    174174        }
    175175        return buffer;
    … …  
    188188/*}}}*/
    189189/*FUNCTION SeqVec::Norm{{{*/
    190 double SeqVec::Norm(NormMode mode){
    191 
    192         double norm;
     190IssmDouble SeqVec::Norm(NormMode mode){
     191
     192        IssmDouble norm;
    193193        int i;
    194194
    … …  
    210210/*}}}*/
    211211/*FUNCTION SeqVec::Scale{{{*/
    212 void SeqVec::Scale(double scale_factor){
     212void SeqVec::Scale(IssmDouble scale_factor){
    213213
    214214        int i;
    … …  
    218218/*}}}*/
    219219/*FUNCTION SeqVec::Dot{{{*/
    220 double SeqVec::Dot(SeqVec* input){
    221 
    222         int i;
    223 
    224         double dot=0;
     220IssmDouble SeqVec::Dot(SeqVec* input){
     221
     222        int i;
     223
     224        IssmDouble dot=0;
    225225        for(i=0;i<this->M;i++)dot+=this->vector[i]*input->vector[i];
    226226        return dot;

  • issm/trunk-jpl/src/c/toolkits/issm/SeqVec.h

    r12365 r12477  
    11/*!\file:  SeqVec.h
    2  * \brief wrapper to our SeqVec object, which is just a wrapper to a double*
     2 * \brief wrapper to our SeqVec object, which is just a wrapper to a IssmDouble*
    33 */
    44
    … …  
    2222        public:
    2323       
    24                 double* vector;
     24                IssmDouble* vector;
    2525                int M;
    2626
    … …  
    2828                SeqVec();
    2929                SeqVec(int M,bool fromlocalsize=false);
    30                 SeqVec(double* buffer, int M);
     30                SeqVec(IssmDouble* buffer, int M);
    3131                ~SeqVec();
    3232                /*}}}*/
    … …  
    3434                void Echo(void);
    3535                void Assemble(void);
    36                 void SetValues(int ssize, int* list, double* values, InsMode mode);
    37                 void SetValue(int dof, double value, InsMode  mode);
    38                 void GetValue(double* pvalue, int dof);
     36                void SetValues(int ssize, int* list, IssmDouble* values, InsMode mode);
     37                void SetValue(int dof, IssmDouble value, InsMode  mode);
     38                void GetValue(IssmDouble* pvalue, int dof);
    3939                void GetSize(int* pM);
    4040                void GetLocalSize(int* pM);
    4141                SeqVec* Duplicate(void);
    42                 void Set(double value);
    43                 void AXPY(SeqVec* X, double a);
    44                 void AYPX(SeqVec* X, double a);
    45                 double* ToMPISerial(void);
     42                void Set(IssmDouble value);
     43                void AXPY(SeqVec* X, IssmDouble a);
     44                void AYPX(SeqVec* X, IssmDouble a);
     45                IssmDouble* ToMPISerial(void);
    4646                void Copy(SeqVec* to);
    47                 double Norm(NormMode norm_type);
    48                 void Scale(double scale_factor);
     47                IssmDouble Norm(NormMode norm_type);
     48                void Scale(IssmDouble scale_factor);
    4949                void PointwiseDivide(SeqVec* x,SeqVec* y);
    50                 double Dot(SeqVec* vector);
     50                IssmDouble Dot(SeqVec* vector);
    5151                /*}}}*/
    5252};

  • issm/trunk-jpl/src/c/toolkits/issm/issmtoolkit.h

    r11733 r12477  
    66#define _ISSM_TOOLKIT_H_
    77
     8#include "../../include/include.h"
     9
    810#include "./SeqMat.h"
    911#include "./SeqVec.h"
Note: See TracChangeset for help on using the changeset viewer.