Changeset 12450


Ignore:
Timestamp:
06/18/12 15:26:50 (13 years ago)
Author:
Mathieu Morlighem
Message:

changing xmalloc to xNew and xfree to xDelete

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

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/EnumDefinitions/Synchronize.sh

    r12365 r12450  
    4848
    4949        len=strlen(EnumToStringx(enum_in));
    50         string=(char*)xmalloc((len+1)*sizeof(char));
     50        string=xNew<char>(len+1);
    5151        memcpy(string,EnumToStringx(enum_in),(len+1)*sizeof(char));
    5252

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

    r3913 r12450  
    1818
    1919        /*output: */
    20         double*         imageout=NULL;
     20        double* imageout=NULL;
    2121
    22         imageout=(double*)xmalloc(samps*lines*sizeof(double));
     22        imageout=xNew<double>(samps*lines);
    2323
    2424        for ( i = 0; i < lines; i++ ){

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

    r11695 r12450  
    6565
    6666        /*Free ressources:*/
    67         xfree((void**)&qmu_part);
     67        xDelete<int>(qmu_part);
    6868        xdelete(&partition_contributions);
    6969        xdelete(&partition_areas);

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

    r12127 r12450  
    7070
    7171        /*Free ressources:*/
    72         xfree((void**)&in_nod_serial);
     72        xDelete<double>(in_nod_serial);
    7373
    7474        return noerr;

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

    r11695 r12450  
    3333
    3434        /*Clean up and return*/
    35         xfree((void**)&control_type);
     35        xDelete<int>(control_type);
    3636        *pgradient=gradient;
    3737}

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

    r11313 r12450  
    3737
    3838        /*Clean up and return*/
    39         xfree((void**)&control_type);
    40         xfree((void**)&scalar_list);
     39        xDelete<int>(control_type);
     40        xDelete<double>(scalar_list);
    4141}

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

    r11695 r12450  
    2727
    2828        /*Clean up and return*/
    29         xfree((void**)&control_type);
     29        xDelete<int>(control_type);
    3030
    3131}
    … …  
    3939
    4040        /*Clean up and return*/
    41         xfree((void**)&serial_gradient);
     41        xDelete<double>(serial_gradient);
    4242}

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

    r11901 r12450  
    3535
    3636        /*Assign output pointers: */
    37         xfree((void**)&responses);
     37        xDelete<int>(responses);
    3838        *pJ=J;
    3939}

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

    r9650 r12450  
    3030        double femmodel_response;
    3131        int    flag;
    32         double* vertex_response=NULL;
    33         double* qmu_response=NULL;
    34 
    35         double* responses_pointer=NULL;
     32        double *vertex_response   = NULL;
     33        double *qmu_response      = NULL;
     34        double *responses_pointer = NULL;
    3635
    3736        /*retrieve npart: */
    … …  
    6665
    6766                        /*Free ressources:*/
    68                         xfree((void**)&vertex_response);
    69                         xfree((void**)&qmu_response);
     67                        xDelete<double>(vertex_response);
     68                        xDelete<double>(qmu_response);
    7069
    7170                }

  • issm/trunk-jpl/src/c/modules/Dakotax/DakotaFree.cpp

    r9761 r12450  
    2222        extern int my_rank;
    2323       
    24         double* variables=NULL;
    25         char**  variables_descriptors=NULL;
    26         char**  responses_descriptors=NULL;
    27         char*   string=NULL;
     24        double  *variables             = NULL;
     25        char   **variables_descriptors = NULL;
     26        char   **responses_descriptors = NULL;
     27        char    *string                = NULL;
    2828
    2929        /*recover pointers: */
    … …  
    3535        /*Free variables and variables_descriptors only on cpu !=0*/
    3636        if(my_rank!=0){
    37                 xfree((void**)&variables);
     37                xDelete<double>(variables);
    3838                for(i=0;i<numvariables;i++){
    3939                        string=variables_descriptors[i];
    40                         xfree((void**)&string);
     40                        xDelete<char>(string);
    4141                }
    42                 xfree((void**)&variables_descriptors);
     42                xDelete<char*>(variables_descriptors);
    4343        }
    4444       
    … …  
    4646        for(i=0;i<numresponses;i++){
    4747                string=responses_descriptors[i];
    48                 xfree((void**)&string);
     48                xDelete<char>(string);
    4949        }
    5050        //rest of dynamic allocations.
    51         xfree((void**)&responses_descriptors);
     51        xDelete<char*>(responses_descriptors);
    5252
    5353        /*Assign output pointers:*/
    … …  
    5656        *presponses_descriptors=responses_descriptors;
    5757}
    58 

  • issm/trunk-jpl/src/c/modules/Dakotax/DakotaMPI_Bcast.cpp

    r9761 r12450  
    3838       
    3939        /*variables:*/
    40         if(my_rank!=0)variables=(double*)xmalloc(numvariables*sizeof(double));
     40        if(my_rank!=0)variables=xNew<double>(numvariables);
    4141        MPI_Bcast(variables,numvariables,MPI_DOUBLE,0,MPI_COMM_WORLD);
    4242
    4343        /*variables_descriptors: */
    4444        if(my_rank!=0){
    45                 variables_descriptors=(char**)xmalloc(numvariables*sizeof(char*));
     45                variables_descriptors=xNew<char*>(numvariables);
    4646        }
    4747        for(i=0;i<numvariables;i++){
    … …  
    5151                }
    5252                MPI_Bcast(&string_length,1,MPI_INT,0,MPI_COMM_WORLD);
    53                 if(my_rank!=0)string=(char*)xmalloc(string_length);
     53                if(my_rank!=0)string=xNew<char>(string_length);
    5454                MPI_Bcast(string,string_length,MPI_CHAR,0,MPI_COMM_WORLD);
    5555                if(my_rank!=0)variables_descriptors[i]=string;

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

    r12016 r12450  
    121121
    122122        /*Free ressources:*/
    123         xfree((void**)&dakota_input_file);
    124         xfree((void**)&dakota_error_file);
    125         xfree((void**)&dakota_output_file);
     123        xDelete<char>(dakota_input_file);
     124        xDelete<char>(dakota_error_file);
     125        xDelete<char>(dakota_output_file);
    126126
    127127        #endif //#ifdef _HAVE_DAKOTA_

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

    r3913 r12450  
    3636        maxels=width-1;
    3737        /*Allocate connectivity: */
    38         elementconnectivity=(double*)xcalloc(nel*3,sizeof(double));
     38        elementconnectivity=xNewZeroInit<double>(nel*3);
    3939
    4040        /*Go through all elements, and for each element, go through its nodes, to get the neighbouring elements.

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

    r12341 r12450  
    466466
    467467        len=strlen(EnumToStringx(enum_in));
    468         string=(char*)xmalloc((len+1)*sizeof(char));
     468        string=xNew<char>(len+1);
    469469        memcpy(string,EnumToStringx(enum_in),(len+1)*sizeof(char));
    470470

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

    r11695 r12450  
    3232
    3333        /*Assign output pointers:*/
    34         xfree((void**)&control_type);
     34        xDelete<int>(control_type);
    3535        *pvector=vector;
    3636}

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

    r11695 r12450  
    1414        int     i,j,numberofvertices;
    1515        int     num_controls;
    16         double  norm_inf;
    17         double *norm_list       = NULL;
    18         int    *control_type    = NULL;
    19         Vector*     gradient        = NULL;
    20         Vector*    *gradient_list  = NULL;
     16        double   norm_inf;
     17        double  *norm_list     = NULL;
     18        int     *control_type  = NULL;
     19        Vector  *gradient      = NULL;
     20        Vector **gradient_list = NULL;
    2121       
    2222        /*retrieve some parameters: */
    … …  
    2626
    2727        /*Allocate gradient_list */
    28         gradient_list = (Vector**)xmalloc(num_controls*sizeof(Vector*));
    29         norm_list = (double*)xmalloc(num_controls*sizeof(double));
     28        gradient_list = xNew<Vector*>(num_controls);
     29        norm_list = xNew<double>(num_controls);
    3030        for(i=0;i<num_controls;i++){
    3131                gradient_list[i]=new Vector(num_controls*numberofvertices);
    … …  
    6262        }
    6363        else{
    64                 xfree((void**)&norm_list);
     64                xDelete<double>(norm_list);
    6565        }
    6666        if(pgradient)  *pgradient=gradient;
    67         xfree((void**)&gradient_list);
    68         xfree((void**)&control_type);
     67        xDelete<Vector*>(gradient_list);
     68        xDelete<int>(control_type);
    6969}

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

    r12365 r12450  
    4949        /*free ressouces: */
    5050        xdelete(&vec_old_floatingice);
    51         xfree((void**)&vertices_potentially_ungrounding);
    52         xfree((void**)&vertices_ungrounding);
    53         xfree((void**)&old_floatingice);
     51        xDelete<double>(vertices_potentially_ungrounding);
     52        xDelete<double>(vertices_ungrounding);
     53        xDelete<double>(old_floatingice);
    5454}
    5555
    … …  
    164164
    165165                /*Avoid leaks: */
    166                 xfree((void**)&elements_neighboring_floatingce);
    167                 xfree((void**)&nodes_on_floatingice);
     166                xDelete<double>(elements_neighboring_floatingce);
     167                xDelete<double>(nodes_on_floatingice);
    168168
    169169                /*Assemble and serialize:*/
    … …  
    174174        /*Free ressources:*/
    175175        xdelete(&vec_nodes_on_floatingice);
    176         xfree((void**)&elements_neighboring_floatingce);
     176        xDelete<double>(elements_neighboring_floatingce);
    177177
    178178        return nodes_on_floatingice;

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

    r9313 r12450  
    4343
    4444         /*^^^^^^^^^^^^^  Remove pixels close to the holes ^^^^^^^^^^^^^*/
    45         image2 = (double*) xmalloc( lines*samps*sizeof(double));
     45        image2 = xNew<double>(lines*samps);
    4646        memcpy(image2,image,lines*samps*sizeof(double));
    4747       
    … …  
    6464        }
    6565
    66         image3 = (double*) xmalloc( lines*samps*sizeof(double));
     66        image3 = xNew<double>(lines*samps);
    6767        memcpy(image3,image2,lines*samps*sizeof(double));
    6868
    … …  
    304304/************************ SMOOTH THE RESULT ***********************/           
    305305               
    306         image4 = (double*) xmalloc( lines*samps*sizeof(double));
     306        image4 = xNew<double>(lines*samps);
    307307        memcpy(image4,image3,lines*samps*sizeof(double));
    308308
    … …  
    348348
    349349        /*Allocate output image: */
    350         imageout=(double*)xmalloc(samps*lines*sizeof(double));
     350        imageout=xNew<double>(samps*lines);
    351351        memcpy(imageout,image3,lines*samps*sizeof(double));
    352352
    … …  
    363363        /*Assign output pointers: */
    364364        *pimageout=imageout;
    365 
    366365        return 1;
    367        
    368366}

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

    r12102 r12450  
    1212
    1313        /*intermediary:*/
    14         int         i;
    15         bool        converged;
    16         int         num_notconverged=0;
    17         int         total_notconverged;
    18         double     *eps       = NULL;
    19         Element*    element=NULL;
     14        int      i;
     15        bool     converged;
     16        int      num_notconverged   = 0;
     17        int      total_notconverged;
     18        double  *eps                = NULL;
     19        Element *element            = NULL;
    2020
    2121        /*allocate dynamic memory: */
    22         eps=(double*)xmalloc(num_criterionenums*sizeof(double));
     22        eps=xNew<double>(num_criterionenums);
    2323
    2424        /*Go through elements, and ask them to do the job: */
    … …  
    3737
    3838        /*Free ressources:*/
    39         xfree((void**)&eps);
     39        xDelete<double>(eps);
    4040
    4141        /*return: */

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

    r10571 r12450  
    2121        double *qmu_part  = NULL;
    2222
    23         double* distributed_values=NULL;
    24         double* parameter=NULL;
    25         char*   descriptor=NULL;
     23        double *distributed_values = NULL;
     24        double *parameter          = NULL;
     25        char   *descriptor         = NULL;
    2626        char    root[50]; //root name of variable, ex: DragCoefficent, RhoIce, etc ...
    2727
    … …  
    4949
    5050
    51                         distributed_values=(double*)xmalloc(npart*sizeof(double));
     51                        distributed_values=xNew<double>(npart);
    5252                        for(j=0;j<npart;j++){
    5353                                distributed_values[j]=variables[i+j];
    … …  
    9191
    9292                        /*Free allocations: */
    93                         xfree((void**)&parameter);
    94                         xfree((void**)&distributed_values);
     93                        xDelete<double>(parameter);
     94                        xDelete<double>(distributed_values);
    9595                }
    9696                else if (strncmp(descriptor,"indexed_",8)==0){
    … …  
    107107
    108108        /*Free ressources:*/
    109         xfree((void**)&qmu_part);
    110 
     109        xDelete<double>(qmu_part);
    111110}

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

    r11679 r12450  
    2020
    2121        /*Free ressources:*/
    22         xfree((void**)&serial_solution);
    23 
     22        xDelete<double>(serial_solution);
    2423}
    2524
    … …  
    3635                element->InputUpdateFromSolution(solution);
    3736        }
    38 
    3937}

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

    r11695 r12450  
    1818
    1919        /*Free ressources:*/
    20         xfree((void**)&serial_vector);
     20        xDelete<double>(serial_vector);
    2121}
    2222

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

    r11695 r12450  
    1818
    1919        /*Free ressources:*/
    20         xfree((void**)&serial_vector);
     20        xDelete<double>(serial_vector);
    2121}
    2222

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

    r12365 r12450  
    5252
    5353                /*The coordinates given in input describe the contour of each pixel. Take the center of each pixel*/
    54                 x=(double*)xmalloc(N*sizeof(double));
    55                 y=(double*)xmalloc(M*sizeof(double));
     54                x=xNew<double>(N);
     55                y=xNew<double>(M);
    5656                for (i=0;i<N;i++) x[i]=(x_in[i]+x_in[i+1])/2;
    5757                for (i=0;i<M;i++) y[i]=(y_in[i]+y_in[i+1])/2;
    … …  
    6262
    6363                /*The coordinates given in input describe the center each pixel. Keep them*/
    64                 x=(double*)xmalloc(N*sizeof(double));
    65                 y=(double*)xmalloc(M*sizeof(double));
     64                x=xNew<double>(N);
     65                y=xNew<double>(M);
    6666                for (i=0;i<N;i++) x[i]=x_in[i];
    6767                for (i=0;i<M;i++) y[i]=y_in[i];

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

    r11918 r12450  
    4545
    4646        /*First, allocate pointers: */
    47         griddata=(double*)xcalloc(nlines*ncols,sizeof(double));
    48         x_grid=(double*)xcalloc(ncols,sizeof(double));
    49         y_grid=(double*)xcalloc(nlines,sizeof(double));
     47        griddata=xNewZeroInit<double>(nlines*ncols);
     48        x_grid=xNewZeroInit<double>(ncols);
     49        y_grid=xNewZeroInit<double>(nlines);
    5050
    5151        /*Set debug to 1 if there are lots of elements*/

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

    r12121 r12450  
    5555        /*Initialize output*/
    5656        if (verbose) printf("Initializing output vector\n");
    57         data_interp=(double*)xmalloc(nods_interp*data_cols*sizeof(double));
     57        data_interp=xNew<double>(nods_interp*data_cols);
    5858
    5959        // read background mesh

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

    r11295 r12450  
    4444
    4545//              _printf_(true,"%s\n",kstr);
    46                 xfree((void**)&kstr);
     46                xDelete<char>(kstr);
    4747        }
    4848

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

    r12446 r12450  
    184184                                                                                                                cmap,mcmap,ncmap));
    185185
    186         if(edfree) xfree((void**)&edata);
    187         if(ncfree) xfree((void**)&nodecon);
     186        if(edfree) xDelete<double>(edata);
     187        if(ncfree) xDelete<int>(nodecon);
    188188        clock0a=clock();
    189189        time0a =time(NULL);

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

    r12422 r12450  
    4444
    4545        /*Allocate output*/
    46         predictions =(double*)xcalloc(n_interp,sizeof(double));
    47         error       =(double*)xcalloc(n_interp,sizeof(double));
     46        predictions =xNewZeroInit<double>(n_interp);
     47        error       =xNewZeroInit<double>(n_interp);
    4848
    4949        /*Get output*/
    … …  
    6868                printf("Generation Delaunay Triangulation\n");
    6969                BamgTriangulatex(&index,&nel,x,y,nobs);
    70                 indexd =(double*)xcalloc(nel*3,sizeof(double));
     70                indexd =xNewZeroInit<double>(nel*3);
    7171                for(int i=0;i<nel*3;i++) indexd[i]=(double)index[i];
    72                 xfree((void**)&index);
     72                xDelete<int>(index);
    7373
    7474                printf("Interpolating\n");
    75                 xfree((void**)&predictions);
     75                xDelete<double>(predictions);
    7676                InterpFromMeshToMesh2dx(&predictions,indexd,x,y,nobs,nel,data,nobs,1,x_interp,y_interp,n_interp,NULL,0,new DataSet());
    77                 xfree((void**)&x);
    78                 xfree((void**)&y);
    79                 xfree((void**)&index);
    80                 xfree((void**)&data);
     77                xDelete<double>(x);
     78                xDelete<double>(y);
     79                xDelete<double>(data);
     80                xDelete<int>(index);
    8181        }
    8282        else if(strcmp(output,"nearestneighbor")==0){
    … …  
    9292                gate.predictions  = predictions;
    9393                gate.error        = error;
    94                 gate.percent      = (double*)xcalloc(num,sizeof(double));
     94                gate.percent      = xNewZeroInit<double>(num);
    9595
    9696                /*launch the thread manager with Krigingxt as a core: */
    9797                LaunchThread(NearestNeighbort,(void*)&gate,num);
    9898                printf("\r      interpolation progress:  100.00%%\n");
    99                 xfree((void**)&gate.percent);
     99                xDelete<double>(gate.percent);
    100100        }
    101101        else if(strcmp(output,"idw")==0){ //Inverse distance weighting
    … …  
    111111                gate.predictions  = predictions;
    112112                gate.error        = error;
    113                 gate.percent      = (double*)xcalloc(num,sizeof(double));
     113                gate.percent      = xNewZeroInit<double>(num);
    114114
    115115                /*launch the thread manager with Krigingxt as a core: */
    116116                LaunchThread(idwt,(void*)&gate,num);
    117117                printf("\r      interpolation progress:  100.00%%\n");
    118                 xfree((void**)&gate.percent);
     118                xDelete<double>(gate.percent);
    119119        }
    120120        else if(strcmp(output,"prediction")==0){
    … …  
    131131                gate.predictions  = predictions;
    132132                gate.error        = error;
    133                 gate.percent      = (double*)xcalloc(num,sizeof(double));
     133                gate.percent      = xNewZeroInit<double>(num);
    134134
    135135                /*launch the thread manager with Krigingxt as a core: */
    136136                LaunchThread(Krigingxt,(void*)&gate,num);
    137137                printf("\r      interpolation progress:  100.00%%\n");
    138                 xfree((void**)&gate.percent);
     138                xDelete<double>(gate.percent);
    139139        }
    140140        else{
    … …  
    145145        delete variogram;
    146146        delete observations;
    147         xfree((void**)&output);
     147        xDelete<char>(output);
    148148        *ppredictions = predictions;
    149149        *perror       = error;
    … …  
    311311
    312312        /*Assign output pointer*/
    313         xfree((void**)&model);
     313        xDelete<char>(model);
    314314        *pvariogram = variogram;
    315315}/*}}}*/

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

    r12102 r12450  
    6767        for(j=0;j<M;j++){
    6868                double* matrix=array[j];
    69                 xfree((void**)&matrix);
     69                xDelete<double>(matrix);
    7070        }
    71         xfree((void**)&mdims_array);
    72         xfree((void**)&ndims_array);
    73         xfree((void**)&array);
     71        xDelete<int>(mdims_array);
     72        xDelete<int>(ndims_array);
     73        xDelete<double*>(array);
    7474       
    7575        /*Assign output pointers: */

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

    r12102 r12450  
    3131
    3232        if(dim==2){
    33                 epart=(int*)xmalloc(numberofelements*sizeof(int));
    34                 npart=(int*)xmalloc(numberofnodes*sizeof(int));
    35                 index=(int*)xmalloc(elements_width*numberofelements*sizeof(int));
     33                epart=xNew<int>(numberofelements);
     34                npart=xNew<int>(numberofnodes);
     35                index=xNew<int>(elements_width*numberofelements);
    3636                for (i=0;i<numberofelements;i++){
    3737                        for (j=0;j<elements_width;j++){
    … …  
    5757
    5858                /*First build concatenated 2d mesh  from 2d_coll and 2d_noncoll: */
    59                 epart2d=(int*)xmalloc(numberofelements2d*sizeof(int));
    60                 npart2d=(int*)xmalloc(numberofnodes2d*sizeof(int));
    61                 index2d=(int*)xmalloc(3*numberofelements2d*sizeof(int));
     59                epart2d=xNew<int>(numberofelements2d);
     60                npart2d=xNew<int>(numberofnodes2d);
     61                index2d=xNew<int>(3*numberofelements2d);
    6262
    6363                for (i=0;i<numberofelements2d;i++){
    … …  
    8181
    8282                /*Extrude epart2d to epart, using numlayers: */
    83                 epart=(int*)xmalloc(numberofelements*sizeof(int));
     83                epart=xNew<int>(numberofelements);
    8484               
    8585                count=0;
    … …  
    9292
    9393                /*Extrude npart2d to npart, using numlayers: */
    94                 npart=(int*)xmalloc(numberofnodes*sizeof(int));
     94                npart=xNew<int>(numberofnodes);
    9595               
    9696                count=0;
    … …  
    108108
    109109        /*Free ressources: */
    110         xfree((void**)&index);
    111         xfree((void**)&epart2d);
    112         xfree((void**)&npart2d);
    113         xfree((void**)&index2d);
    114 
     110        xDelete<int>(index);
     111        xDelete<int>(epart2d);
     112        xDelete<int>(npart2d);
     113        xDelete<int>(index2d);
    115114        return noerr;
    116 
    117115}

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

    r8303 r12450  
    55
    66void MeshProfileIntersectionx( double** psegments, int* pnumsegs, int* index, double* x, double* y, int nel, int nods,  Contour** contours,int numcontours){
    7 
    87
    98        int i,j,k;
    … …  
    2827
    2928        /*Allocate: */
    30         allsegments=(double**)xmalloc(numcontours*sizeof(double*));
    31         allnumsegs=(int*)xmalloc(numcontours*sizeof(int));
     29        allsegments=xNew<double*>(numcontours);
     30        allnumsegs=xNew<int>(numcontours);
    3231
    3332        /*Loop through all contours: */
    … …  
    5352
    5453        /*Out of all segments, create one common array of segments: */
    55         segments=(double*)xmalloc(5*numsegs*sizeof(double));
     54        segments=xNew<double>(5*numsegs);
    5655        count=0;
    5756        for(i=0;i<numcontours;i++){

  • issm/trunk-jpl/src/c/modules/MeshProfileIntersectionx/MeshSegmentsIntersection.cpp

    r8303 r12450  
    3232        /*Using the segments_dataset dataset, create segments: */
    3333        numsegs=segments_dataset->Size();
    34         segments=(double*)xmalloc(5*numsegs*sizeof(double));
     34        segments=xNew<double>(5*numsegs);
    3535        for(i=0;i<numsegs;i++){
    3636                Segment* segment=(Segment*)segments_dataset->GetObjectByOffset(i);

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

    r11447 r12450  
    6363                parameters->AddObject(new DoubleVecParam(InversionMaxiterPerStepEnum,maxiter,nsteps));
    6464
    65                 xfree((void**)&control_type);
    66                 xfree((void**)&cm_responses);
    67                 xfree((void**)&cm_jump);
    68                 xfree((void**)&optscal);
    69                 xfree((void**)&maxiter);
     65                xDelete<int>(control_type);
     66                xDelete<double>(cm_responses);
     67                xDelete<double>(cm_jump);
     68                xDelete<double>(optscal);
     69                xDelete<double>(maxiter);
    7070        }
    7171

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

    r11001 r12450  
    4343
    4444        /*Allocate ouput*/
    45         connectivity=(int*)xcalloc(numberofvertices,sizeof(int));
     45        connectivity=xNewZeroInit<int>(numberofvertices);
    4646
    4747        /*Get element width (3 or 6)*/

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

    r12326 r12450  
    105105        parameters->AddObject(new IntParam(DiagnosticNumRequestedOutputsEnum,numoutputs));
    106106        if(numoutputs)parameters->AddObject(new IntVecParam(DiagnosticRequestedOutputsEnum,requestedoutputs,numoutputs));
    107         xfree((void**)&requestedoutputs);
     107        xDelete<double>(requestedoutputs);
    108108        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,TransientRequestedOutputsEnum);
    109109        parameters->AddObject(new IntParam(TransientNumRequestedOutputsEnum,numoutputs));
    110110        if(numoutputs)parameters->AddObject(new IntVecParam(TransientRequestedOutputsEnum,requestedoutputs,numoutputs));
    111         xfree((void**)&requestedoutputs);
     111        xDelete<double>(requestedoutputs);
    112112        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,SteadystateRequestedOutputsEnum);
    113113        parameters->AddObject(new IntParam(SteadystateNumRequestedOutputsEnum,numoutputs));
    114114        if(numoutputs)parameters->AddObject(new IntVecParam(SteadystateRequestedOutputsEnum,requestedoutputs,numoutputs));
    115         xfree((void**)&requestedoutputs);
     115        xDelete<double>(requestedoutputs);
    116116       
    117117        /*Before returning, create parameters in case we are running Qmu or control types runs: */

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

    r9733 r12450  
    4444
    4545        /*Allocate ouput*/
    46         connectivity=(int*)xcalloc(numberofvertices,sizeof(int));
     46        connectivity=xNewZeroInit<int>(numberofvertices);
    4747
    4848        /*Get element width (3 or 6)*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp

    r12365 r12450  
    7474
    7575                /*name of qmu input, error and output files:{{{*/
    76                 qmuinname=(char*)xmalloc((strlen(name)+strlen(".qmu.in")+1)*sizeof(char));
     76                qmuinname=xNew<char>((strlen(name)+strlen(".qmu.in")+1));
    7777                sprintf(qmuinname,"%s%s",name,".qmu.in");
    7878                parameters->AddObject(new   StringParam(QmuInNameEnum,qmuinname));
    7979
    80                 qmuoutname=(char*)xmalloc((strlen(name)+strlen(".qmu.out")+1)*sizeof(char));
     80                qmuoutname=xNew<char>((strlen(name)+strlen(".qmu.out")+1));
    8181                sprintf(qmuoutname,"%s%s",name,".qmu.out");
    8282                parameters->AddObject(new   StringParam(QmuOutNameEnum,qmuoutname));
    8383
    84                 qmuerrname=(char*)xmalloc((strlen(name)+strlen(".qmu.err")+1)*sizeof(char));
     84                qmuerrname=xNew<char>((strlen(name)+strlen(".qmu.err")+1));
    8585                sprintf(qmuerrname,"%s%s",name,".qmu.err");
    8686                parameters->AddObject(new   StringParam(QmuErrNameEnum,qmuerrname));
    … …  
    111111                        ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
    112112
    113                         dpart=(double*)xmalloc(numberofvertices*sizeof(double));
     113                        dpart=xNew<double>(numberofvertices);
    114114                        for(i=0;i<numberofvertices;i++)dpart[i]=iomodel->my_vertices[i];
    115115                }
    … …  
    136136                               
    137137                                /*Free ressources:*/
    138                                 xfree((void**)&dakota_parameter);
     138                                xDelete<int>(dakota_parameter);
    139139                        }
    140140                }
    … …  
    166166                                }
    167167                                if(m){
    168                                         matrix=(double*)xcalloc(5*m,sizeof(double));
     168                                        matrix=xNewZeroInit<double>(5*m);
    169169                                        count=0;
    170170                                        for(j=0;j<temp_m;j++){
    … …  
    185185
    186186                                /*Free temporary matrix: */
    187                                 xfree((void**)&temp_matrix);
     187                                xDelete<double>(temp_matrix);
    188188                        }
    189189
    … …  
    194194                        for(i=0;i<qmu_mass_flux_num_profiles;i++){
    195195                                double* matrix=array[i];
    196                                 xfree((void**)&matrix);
    197                         }
    198                         xfree((void**)&mdims_array);
    199                         xfree((void**)&ndims_array);
    200                         xfree((void**)&array);
     196                                xDelete<double>(matrix);
     197                        }
     198                        xDelete<int>(mdims_array);
     199                        xDelete<int>(ndims_array);
     200                        xDelete<double*>(array);
    201201                }
    202202                /*}}}*/
    … …  
    204204                for(i=0;i<numresponsedescriptors;i++){
    205205                        descriptor=responsedescriptors[i];
    206                         xfree((void**)&descriptor);
    207                 }
    208                 xfree((void**)&responsedescriptors);
     206                        xDelete<char>(descriptor);
     207                }
     208                xDelete<char*>(responsedescriptors);
    209209
    210210                for(i=0;i<numvariabledescriptors;i++){
    211211                        descriptor=variabledescriptors[i];
    212                         xfree((void**)&descriptor);
    213                 }
    214                 xfree((void**)&variabledescriptors);
    215                 xfree((void**)&part);
    216                 xfree((void**)&dpart);
    217                 xfree((void**)&qmuinname);
    218                 xfree((void**)&qmuerrname);
    219                 xfree((void**)&qmuoutname);
     212                        xDelete<char>(descriptor);
     213                }
     214                xDelete<char*>(variabledescriptors);
     215                xDelete<int>(part);
     216                xDelete<int>(dpart);
     217                xDelete<char>(qmuinname);
     218                xDelete<char>(qmuerrname);
     219                xDelete<char>(qmuoutname);
    220220                /*}}}*/
    221221        } //if(dakota_analysis)
    222222
    223223        /*Free data*/
    224         xfree((void**)&name);
     224        xDelete<char>(name);
    225225
    226226        /*Assign output pointer: */

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

    r10544 r12450  
    8787
    8888        /*figure out times: */
    89         timesx=(double*)xmalloc(Nx*sizeof(double));
     89        timesx=xNew<double>(Nx);
    9090        for(j=0;j<Nx;j++){
    9191                timesx[j]=spcvx[(Mx-1)*Nx+j];
    … …  
    9494        UnitConversion(timesx,Nx,ExtToIuEnum,TimeEnum);
    9595        /*figure out times: */
    96         timesy=(double*)xmalloc(Ny*sizeof(double));
     96        timesy=xNew<double>(Ny);
    9797        for(j=0;j<Ny;j++){
    9898                timesy[j]=spcvy[(My-1)*Ny+j];
    … …  
    101101        UnitConversion(timesy,Ny,ExtToIuEnum,TimeEnum);
    102102        /*figure out times: */
    103         timesz=(double*)xmalloc(Nz*sizeof(double));
     103        timesz=xNew<double>(Nz);
    104104        for(j=0;j<Nz;j++){
    105105                timesz[j]=spcvz[(Mz-1)*Nz+j];
    … …  
    107107        /*unit conversion: */
    108108        UnitConversion(timesz,Nz,ExtToIuEnum,TimeEnum);
    109 
    110109
    111110        /*Create spcs from x,y,z, as well as the spc values on those spcs: */
    … …  
    236235                                else if (Mx==numberofvertices+1) {
    237236                                        /*figure out times and values: */
    238                                         values=(double*)xmalloc(Nx*sizeof(double));
     237                                        values=xNew<double>(Nx);
    239238                                        spcpresent=false;
    240239                                        for(j=0;j<Nx;j++){
    … …  
    247246                                                count++;
    248247                                        }
    249                                         xfree((void**)&values);
     248                                        xDelete<double>(values);
    250249                                }
    251250                                else if (vertices_type[i]==HutterApproximationEnum){
    … …  
    260259                                else if (My==numberofvertices+1){
    261260                                        /*figure out times and values: */
    262                                         values=(double*)xmalloc(Ny*sizeof(double));
     261                                        values=xNew<double>(Ny);
    263262                                        spcpresent=false;
    264263                                        for(j=0;j<Ny;j++){
    … …  
    270269                                                count++;
    271270                                        }
    272                                         xfree((void**)&values);
     271                                        xDelete<double>(values);
    273272                                }
    274273                                else if (vertices_type[i]==HutterApproximationEnum){
    … …  
    284283                                        else if (Mz==numberofvertices+1){
    285284                                                /*figure out times and values: */
    286                                                 values=(double*)xmalloc(Nz*sizeof(double));
     285                                                values=xNew<double>(Nz);
    287286                                                spcpresent=false;
    288287                                                for(j=0;j<Nz;j++){
    … …  
    294293                                                        count++;
    295294                                                }
    296                                                 xfree((void**)&values);
     295                                                xDelete<double>(values);
    297296                                        }
    298297
    … …  
    326325         
    327326        /*Free data: */
    328         xfree((void**)&spcvx);
    329         xfree((void**)&spcvy);
    330         xfree((void**)&spcvz);
    331         xfree((void**)&nodeonmacayeal);
    332         xfree((void**)&nodeonpattyn);
    333         xfree((void**)&nodeonstokes);
    334         xfree((void**)&nodeonicesheet);
    335         xfree((void**)&nodeonbed);
    336         xfree((void**)&vertices_type);
    337         xfree((void**)&surface);
    338         xfree((void**)&z);
     327        xDelete<double>(spcvx);
     328        xDelete<double>(spcvy);
     329        xDelete<double>(spcvz);
     330        xDelete<double>(nodeonmacayeal);
     331        xDelete<double>(nodeonpattyn);
     332        xDelete<double>(nodeonstokes);
     333        xDelete<double>(nodeonicesheet);
     334        xDelete<double>(nodeonbed);
     335        xDelete<double>(vertices_type);
     336        xDelete<double>(surface);
     337        xDelete<double>(z);
    339338
    340339        /*Free resources:*/
    341         xfree((void**)&timesx);
    342         xfree((void**)&timesy);
    343         xfree((void**)&timesz);
    344         xfree((void**)&values);
     340        xDelete<double>(timesx);
     341        xDelete<double>(timesy);
     342        xDelete<double>(timesz);
     343        xDelete<double>(values);
    345344
    346345        /*Assign output pointer: */

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

    r10522 r12450  
    120120        /*Free data: */
    121121        iomodel->DeleteData(3,DiagnosticIcefrontEnum,ThicknessEnum,BedEnum);
    122         xfree((void**)&elements_type);
    123         xfree((void**)&pressureload);
     122        xDelete<double>(elements_type);
     123        xDelete<double>(pressureload);
    124124
    125125        /*Create Penpair for penalties: */
    … …  
    144144
    145145        /*free ressources: */
    146         xfree((void**)&penalties);
     146        xDelete<double>(penalties);
    147147
    148148        /*Create Riffront loads for rifts: */
    … …  
    157157                }
    158158                iomodel->DeleteData(5,RiftsRiftstructEnum,ThicknessEnum,BedEnum,SurfaceEnum,MaskVertexonfloatingiceEnum);
    159                 xfree((void**)&riftfront);
     159                xDelete<Riftfront>(riftfront);
    160160        }
    161161

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

    r9218 r12450  
    3535                else if (vertices_type[0]==MacAyealPattynApproximationEnum){
    3636                        numdofs=4;
    37                         doftype=(int*)xmalloc(numdofs*sizeof(int));
     37                        doftype=xNew<int>(numdofs);
    3838                        doftype[0]=MacAyealApproximationEnum;
    3939                        doftype[1]=MacAyealApproximationEnum;
    … …  
    4343                else if (vertices_type[0]==PattynStokesApproximationEnum){
    4444                        numdofs=6;
    45                         doftype=(int*)xmalloc(numdofs*sizeof(int));
     45                        doftype=xNew<int>(numdofs);
    4646                        doftype[0]=PattynApproximationEnum;
    4747                        doftype[1]=PattynApproximationEnum;
    … …  
    5353                else if (vertices_type[0]==MacAyealStokesApproximationEnum){
    5454                        numdofs=6;
    55                         doftype=(int*)xmalloc(numdofs*sizeof(int));
     55                        doftype=xNew<int>(numdofs);
    5656                        doftype[0]=MacAyealApproximationEnum;
    5757                        doftype[1]=MacAyealApproximationEnum;
    … …  
    9696
    9797        /*Clean up*/
    98          xfree((void**)&doftype);
     98         xDelete<int>(doftype);
    9999}

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

    r12016 r12450  
    7676
    7777        /*Free elements and elements2d: */
    78         xfree((void**)&elements);
    79         xfree((void**)&elements2d);
     78        xDelete<double>(elements);
     79        xDelete<double>(elements2d);
    8080
    8181        /*Deal with rifts, they have to be included into one partition only, not several: */
    … …  
    8787                        epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding vertices;
    8888                }
    89                 xfree((void**)&riftinfo);
     89                xDelete<double>(riftinfo);
    9090        }
    9191
    9292        /*Used later on: */
    93         my_vertices=(int*)xcalloc(numberofvertices,sizeof(int));
    94         my_elements=(bool*)xcalloc(numberofelements,sizeof(bool));
     93        my_vertices=xNewZeroInit<int>(numberofvertices);
     94        my_elements=xNewZeroInit<bool>(numberofelements);
    9595
    9696        /*Start figuring out, out of the partition, which elements belong to this cpu: */
    … …  
    119119        }//for (i=0;i<numberofelements;i++)
    120120        /*Free data : */
    121         xfree((void**)&elements);
     121        xDelete<double>(elements);
    122122
    123123        /*We might have vertex_pairing in which case, some vertices have to be cloned:
    … …  
    130130                }
    131131        }
    132         xfree((void**)&vertex_pairing);
     132        xDelete<double>(vertex_pairing);
    133133        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum);
    134134        for(i=0;i<numvertex_pairing;i++){
    … …  
    137137                }
    138138        }
    139         xfree((void**)&vertex_pairing);
     139        xDelete<double>(vertex_pairing);
    140140
    141141        /*Free ressources:*/
    142         xfree((void**)&npart);
    143         xfree((void**)&epart);
     142        xDelete<int>(npart);
     143        xDelete<int>(epart);
    144144
    145145        /*Assign output pointers:*/

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

    r11270 r12450  
    6565
    6666        /*Free data: */
    67         xfree((void**)&spctemperature);
     67        xDelete<double>(spctemperature);
    6868       
    6969        /*Assign output pointer: */

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

    r9733 r12450  
    2424       
    2525        /*First thing, this is a new partition for a new analysis_type, therefore, to avoid a leak, erase the nodes partition that might come through pmy_nodes: */
    26         xfree((void**)pmy_nodes);
     26        xDelete<bool>(*pmy_nodes);
    2727
    2828        /*Now, depending on whether we are running galerkin discontinous or continuous elements, carry out a different partition of the nodes: */
    … …  
    4444        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    4545
    46         my_nodes=(bool*)xmalloc(numberofvertices*sizeof(bool));
    47         memcpy(my_nodes,my_vertices,numberofvertices*sizeof(bool));
     46        my_nodes=xNew<bool>(numberofvertices);
     47        for(int i=0;i<numberofvertices;i++) my_nodes[i]=(bool)my_vertices[i];
    4848
    4949        /*Assign output pointers:*/
    … …  
    9090
    9191        /*Allocate*/
    92         my_nodes=(bool*)xcalloc(3*numberofelements,sizeof(int));
     92        my_nodes=xNewZeroInit<bool>(3*numberofelements);
    9393
    9494        /*First: add all the nodes of all the elements belonging to this cpu*/
    … …  
    9696                for (i=0;i<numberofelements;i++){
    9797                        if (my_elements[i]){
    98                                 my_nodes[3*i+0]=1;
    99                                 my_nodes[3*i+1]=1;
    100                                 my_nodes[3*i+2]=1;
     98                                my_nodes[3*i+0]=true;
     99                                my_nodes[3*i+1]=true;
     100                                my_nodes[3*i+2]=true;
    101101                        }
    102102                }
    … …  
    140140                         * we can now create the corresponding nodes:*/
    141141                        if (pos==0){
    142                                 my_nodes[(int)e2*3+0]=1;
    143                                 my_nodes[(int)e2*3+2]=1;
     142                                my_nodes[(int)e2*3+0]=true;
     143                                my_nodes[(int)e2*3+2]=true;
    144144                        }
    145145                        else if(pos==1){
    146                                 my_nodes[(int)e2*3+1]=1;
    147                                 my_nodes[(int)e2*3+0]=1;
     146                                my_nodes[(int)e2*3+1]=true;
     147                                my_nodes[(int)e2*3+0]=true;
    148148                        }
    149149                        else if (pos==2){
    150                                 my_nodes[(int)e2*3+2]=1;
    151                                 my_nodes[(int)e2*3+1]=1;
     150                                my_nodes[(int)e2*3+2]=true;
     151                                my_nodes[(int)e2*3+1]=true;
    152152                        }
    153153                        else{
    … …  
    158158
    159159        /*Free data: */
    160         xfree((void**)&elements);
    161         xfree((void**)&edges);
     160        xDelete<double>(elements);
     161        xDelete<double>(edges);
    162162
    163163        /*Assign output pointers:*/

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

    r10522 r12450  
    9090
    9191        /*free ressources: */
    92         xfree((void**)&vertex_pairing);
    93         xfree((void**)&nodeonbed);
    94 
     92        xDelete<double>(vertex_pairing);
     93        xDelete<double>(nodeonbed);
    9594
    9695        /*Assign output pointer: */

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

    r6412 r12450  
    3737
    3838        /*Allocate connectivity: */
    39         connectivity=(double*)xcalloc(nods*width,sizeof(double));
     39        connectivity=xNewZeroInit<double>(nods*width);
    4040
    4141        /*Go through all elements, and for each elements, plug into the connectivity, all the nodes.

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

    r12377 r12450  
    4646                EnumToStringx(&solutiontypestring,solutiontype);
    4747                results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,solutiontypestring,1,0));
    48                 xfree((void**)&solutiontypestring);
     48                xDelete<char>(solutiontypestring);
    4949        }
    5050
    … …  
    6868                        fid=pfopen(cpu_outputfilename ,"wb");
    6969                }
    70                 xfree((void**)&outputfilename);
     70                xDelete<char>(outputfilename);
    7171               
    7272                /*Add file pointer in parameters for further calls to OutputResultsx: */

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

    r12319 r12450  
    4848
    4949                /*Now, allocate analyses and strings: */
    50                 analyses=(double*)xmalloc(numanalyses*sizeof(double));
    51                 strings=(char**)xmalloc(numanalyses*sizeof(char*));
     50                analyses=xNew<double>(numanalyses);
     51                strings=xNew<char*>(numanalyses);
    5252                for(i=0;i<numanalyses;i++)strings[i]=NULL;
    5353
    … …  
    7070                        to the already existing options*/
    7171                                if(strings[numanalyses-1]==NULL){
    72                                         string=(char*)xmalloc((strlen(line)+1)*sizeof(char));
     72                                        string=xNew<char>((strlen(line)+1));
    7373                                        memcpy(string,line,(strlen(line)+1)*sizeof(char));
    7474
    … …  
    7777                                else{
    7878                                        string=strings[numanalyses-1];
    79                                         newstring=(char*)xmalloc((strlen(line)+1)*sizeof(char));
     79                                        newstring=xNew<char>((strlen(line)+1));
    8080                                        memcpy(newstring,line,(strlen(line)+1)*sizeof(char));
    8181
    8282                                        /*concatenate:*/
    83                                         catstring=(char*)xmalloc((strlen(string)+1+strlen(newstring)+1+1)*sizeof(char)); //fit in a space " "
     83                                        catstring=xNew<char>(strlen(string)+1+strlen(newstring)+1+1); //fit in a space " "
    8484                                        memcpy(catstring,string,(strlen(string)+1)*sizeof(char));
    8585
    … …  
    8787                                        strcat(catstring,newstring);
    8888                                        strings[numanalyses-1]=catstring;
    89                                         xfree((void**)&newstring);
    90                                         xfree((void**)&string);
     89                                        xDelete<char>(newstring);
     90                                        xDelete<char>(string);
    9191                                }
    9292                        }
    … …  
    9898        MPI_Bcast(&numanalyses,1,MPI_INT,0,MPI_COMM_WORLD);
    9999        if(my_rank!=0){
    100                 analyses=(double*)xmalloc(numanalyses*sizeof(double));
    101                 strings=(char**)xmalloc(numanalyses*sizeof(char*));
     100                analyses=xNew<double>(numanalyses);
     101                strings=xNew<char*>(numanalyses);
    102102        }
    103103        MPI_Bcast(analyses,numanalyses,MPI_DOUBLE,0,MPI_COMM_WORLD);
    … …  
    111111                #ifdef _HAVE_MPI_
    112112                MPI_Bcast(&stringlength,1,MPI_INT,0,MPI_COMM_WORLD);
    113                 if(my_rank!=0)string=(char*)xmalloc(stringlength);
     113                if(my_rank!=0)string=xNew<char>(stringlength);
    114114                MPI_Bcast(string,stringlength,MPI_CHAR,0,MPI_COMM_WORLD);
    115115                if(my_rank!=0)strings[i]=string;
    … …  
    122122
    123123        /*Clean up and return*/
    124         for(i=0;i<numanalyses;i++) xfree((void**)&strings[i]);
    125         xfree((void**)&strings);
    126         xfree((void**)&analyses);
     124        for(i=0;i<numanalyses;i++) xDelete<char>(strings[i]);
     125        xDelete<char*>(strings);
     126        xDelete<double>(analyses);
    127127        return;
    128128}
    129 

  • issm/trunk-jpl/src/c/modules/PointCloudFindNeighborsx/PointCloudFindNeighborsxt.cpp

    r11695 r12450  
    3939
    4040        /*allocate: */
    41         already=(bool*)xcalloc(nods,sizeof(bool));
     41        already=xNewZeroInit<bool>(nods);
    4242
    4343        /*partition loop across threads: */
    … …  
    7373
    7474        /*Free ressources:*/
    75         xfree((void**)&already);
     75        xDelete<bool>(already);
    7676       
    7777        return NULL;

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

    r12326 r12450  
    4040  Element* element = NULL;
    4141 
    42   pdds=(double*)xmalloc(NPDMAX*sizeof(double)+1);
    43   pds=(double*)xmalloc(NPDCMAX*sizeof(double)+1);
     42  pdds=xNew<double>(NPDMAX+1);
     43  pds=xNew<double>(NPDCMAX+1);
    4444 
    4545  // initialize PDD (creation of a lookup table)
    … …  
    106106  }
    107107  /*free ressouces: */
    108   xfree((void**)&pdds);
    109   xfree((void**)&pds);
     108  xDelete<double>(pdds);
     109  xDelete<double>(pds);
    110110 
    111111}

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

    r11679 r12450  
    5151
    5252        /*Free ressources:*/
    53         xfree((void**)&ug_serial);
     53        xDelete<double>(ug_serial);
    5454
    5555        /*Assign output pointers:*/

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

    r11679 r12450  
    5151
    5252        /*Free ressources:*/
    53         xfree((void**)&yg_serial);
     53        xDelete<double>(yg_serial);
    5454
    5555        /*Assign output pointers:*/

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

    r11695 r12450  
    2525        }
    2626
    27         xfree((void**)&control_type);
     27        xDelete<int>(control_type);
    2828}
    2929
    … …  
    3737
    3838        /*Free ressources:*/
    39         xfree((void**)&serial_vector);
     39        xDelete<double>(serial_vector);
    4040}

  • issm/trunk-jpl/src/c/modules/Solverx/DofTypesToIndexSet.cpp

    r9826 r12450  
    4646
    4747                /*Allocate indices: */
    48                 if(pressure_num)pressure_indices=(int*)xmalloc(pressure_num*sizeof(int));
    49                 if(velocity_num)velocity_indices=(int*)xmalloc(velocity_num*sizeof(int));
     48                if(pressure_num)pressure_indices=xNew<int>(pressure_num);
     49                if(velocity_num)velocity_indices=xNew<int>(velocity_num);
    5050
    5151                pressure_count=0;
    … …  
    7474
    7575        /*Free ressources:*/
    76         xfree((void**)&pressure_indices);
    77         xfree((void**)&velocity_indices);
     76        xDelete<int>(pressure_indices);
     77        xDelete<int>(velocity_indices);
    7878
    7979        /*Assign output pointers:*/

  • issm/trunk-jpl/src/c/modules/Solverx/SolverxGsl.cpp

    r12445 r12450  
    1818void SolverxGsl(SeqVec** puf,SeqMat* Kff, SeqVec* pf){/*{{{*/
    1919
    20         /*Intermediaries*/
    21         SeqMat* KffCopy = NULL;
    22         SeqVec*  uf = NULL;
    23        
    24         /*GSL Matrices and vectors: */
    25         gsl_matrix_view m;
    26         gsl_vector_view b;
    27         gsl_vector* x=NULL;
    28         gsl_permutation* p=NULL;
    29        
    30         /*We are going to do an in place LU decomp, so we need to save the matrix with its original structure: */
    31         KffCopy=Kff->Duplicate();
    32 
    3320        /*Intermediary: */
    3421        int M,N,N2,s;
     22        SeqVec *uf = NULL;
     23        double *x  = NULL;
    3524
    3625        Kff->GetSize(&M,&N);
    … …  
    4029        if(M!=N)_error_("Stiffness matrix should be square!");
    4130
    42         /*Initialize gsl matrices and vectors: */
    43         m = gsl_matrix_view_array (KffCopy->matrix, M, N);
    44         b = gsl_vector_view_array (pf->vector, N);
    45         x = gsl_vector_alloc (N);
    46 
    47         /*Run LU and solve: */
    48         p = gsl_permutation_alloc (N);
    49         gsl_linalg_LU_decomp (&m.matrix, p, &s);
    50         gsl_linalg_LU_solve (&m.matrix, p, &b.vector, x);
    51 
    52         //printf ("x = \n");
    53         //gsl_vector_fprintf (stdout, x, "%g");
    54 
    55         /*Get uf initialized with the results: */
    56         uf=new SeqVec(gsl_vector_ptr(x,0),M);
    57 
    58         /*Free resources:*/
    59         gsl_permutation_free (p);
    60         gsl_vector_free (x);
    61         delete KffCopy;
     31        SolverxGsl(&x,Kff->matrix,pf->vector,N);
     32        uf=new SeqVec(x,N);
    6233
    6334        /*Assign output pointers:*/
    … …  
    7445
    7546        /*A will be modified by LU decomposition. Use copy*/
    76         double* Acopy = (double*)xmalloc(n*n*sizeof(double));
     47        double* Acopy = xNew<double>(n*n);
    7748        memcpy(Acopy,A,n*n*sizeof(double));
    7849
    … …  
    9162
    9263        /*Copy result*/
    93         double* X = (double*)xmalloc(n*sizeof(double));
     64        double* X = xNew<double>(n);
    9465        memcpy(X,gsl_vector_ptr(x,0),n*sizeof(double));
    9566
    9667        /*Clean up and assign output pointer*/
    97         xfree((void**)&Acopy);
     68        xDelete<double>(Acopy);
    9869        gsl_permutation_free(p);
    9970        gsl_vector_free(x);

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

    r12442 r12450  
    9898       
    9999        in.segmentlist = xNew<int>(in.numberofsegments*2);
    100         in.segmentmarkerlist = (int*)xcalloc(in.numberofsegments,sizeof(int));
     100        in.segmentmarkerlist = xNewZeroInit<int>(in.numberofsegments);
    101101        counter=0;
    102102        backcounter=0;

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

    r8303 r12450  
    1919
    2020        /*allocate: */
    21         tria=(double*)xmalloc(numberofnodes*sizeof(double));
     21        tria=xNew<double>(numberofnodes);
    2222
    2323        /*Intermediary*/
    … …  
    5252        }
    5353
    54 
    5554        /*Assign output pointers:*/
    5655        *ptria=tria;

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

    r11679 r12450  
    3434
    3535        /*Free ressources:*/
    36         xfree((void**)&yg_serial);
     36        xDelete<double>(yg_serial);
    3737}

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

    r11707 r12450  
    3838
    3939        /*Free ressources:*/
    40         xfree((void**)&thickness);
    41         xfree((void**)&bed);
     40        xDelete<double>(thickness);
     41        xDelete<double>(bed);
    4242        xdelete(&vz);
    4343        return 1;

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

    r11679 r12450  
    4141        }
    4242        /*Free ressources:*/
    43         xfree((void**)&uf_serial);
     43        xDelete<double>(uf_serial);
    4444
    4545        /*Assemble vector: */

  • issm/trunk-jpl/src/c/objects/IoModel.cpp

    r12418 r12450  
    205205                dataenum=va_arg(ap, int);
    206206                _assert_(dataenum<MaximumNumberOfEnums);
    207                 xfree((void**)&this->data[dataenum]);
     207                xDelete<double>(this->data[dataenum]);
    208208        }
    209209        va_end(ap);
    … …  
    691691        /*Now allocate matrix: */
    692692        if(M*N){
    693                 matrix=(IssmPDouble*)xmalloc(M*N*sizeof(IssmPDouble));
     693                matrix=xNew<IssmPDouble>(M*N);
    694694
    695695                /*Read matrix on node 0, then broadcast: */
Note: See TracChangeset for help on using the changeset viewer.