Changeset 2316


Ignore:
Timestamp:
09/24/09 18:12:14 (15 years ago)
Author:
Eric.Larour
Message:

Started switching to new DofVec framework.
partition, tpartition and now yg are dofvecs.

Location:
issm/trunk
Files:
1 deleted
62 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Dofx/Dofx.cpp

    r1 r2316  
    1313#include "../EnumDefinitions/EnumDefinitions.h"
    1414
    15 int Dofx( Vec* ppartition, Vec* ptpartition,DataSet* elements,DataSet* nodes, DataSet* params) {
     15int Dofx( DofVec** ppartition, DofVec** ptpartition,DataSet* elements,DataSet* nodes, DataSet* params) {
    1616
    1717        int noerr=1;
    … …  
    2727
    2828        /*output: */
    29         Vec partition=NULL;
    30         Vec tpartition=NULL;
     29        DofVec* partition=NULL;
     30        DofVec* tpartition=NULL;
     31
     32        /*Initialize dofvecs: */
     33        partition=new DofVec("partition");
     34        tpartition=new DofVec("tpartition");
    3135
    3236        /*First, recover number of grids from parameters: */
    … …  
    4852
    4953        /*Now that dofs have been distributed, create partitioning vector and its transpose: */
    50         nodes->CreatePartitioningVector(&partition,numberofnodes,numberofdofspernode);
     54        nodes->CreatePartitioningVector(&partition->vector,numberofnodes,numberofdofspernode);
    5155
    5256        /*Transpose partition into tpartition: */
    53         VecTranspose(&tpartition,partition);
    54        
     57        VecTranspose(&tpartition->vector,partition->vector);
     58
     59        /*Now, setup numdof and numentries for dofvec: */
     60        partition->numdofs=1;
     61        VecGetSize(partition->vector,&partition->numentries);
     62
     63        tpartition->numdofs=1;
     64        VecGetSize(tpartition->vector,&tpartition->numentries);
     65
    5566        /*Assign output pointers: */
    5667        *ppartition=partition;

  • issm/trunk/src/c/Dofx/Dofx.h

    r1 r2316  
    99
    1010/* local prototypes: */
    11 int             Dofx( Vec* partition, Vec* ptpartition,DataSet* elements,DataSet* nodesin,DataSet* params);
     11int             Dofx( DofVec** partition, DofVec** ptpartition,DataSet* elements,DataSet* nodesin,DataSet* params);
    1212
    1313#endif  /* _DOFX_H */

  • issm/trunk/src/c/Makefile.am

    r2313 r2316  
    171171                                        ./io/WriteDataToDisk.cpp\
    172172                                        ./io/SerialFetchData.cpp\
    173                                         ./io/SerialWriteData.cpp\
    174173                                        ./io/ParallelFetchData.cpp\
    175174                                        ./io/ParallelFetchInteger.cpp\
    … …  
    469468                                        ./io/WriteDataToDisk.cpp\
    470469                                        ./io/SerialFetchData.cpp\
    471                                         ./io/SerialWriteData.cpp\
    472470                                        ./io/ParallelFetchData.cpp\
    473471                                        ./io/ParallelFetchInteger.cpp\

  • issm/trunk/src/c/SpcNodesx/SpcNodesx.cpp

    r304 r2316  
    1313#include "../EnumDefinitions/EnumDefinitions.h"
    1414
    15 int SpcNodesx( Vec* pyg, DataSet* nodes,DataSet* constraints){
     15void SpcNodesx( DofVec** pyg, DataSet* nodes,DataSet* constraints){
    1616
    1717        int i;
    1818        int numberofdofs;
     19        int gsize;
    1920
    2021        /*output: */
    21         Vec yg=NULL;
     22        DofVec* yg=NULL;
    2223
    2324        /*First, recover number of dofs from nodes: */
    … …  
    2526
    2627        if(numberofdofs){
     28               
     29                /*Allocate dofvec: */
     30                yg=new DofVec("yg");
     31                yg->numdofs=numberofdofs;
     32
    2733                /*Allocate yg: */
    28                 yg=NewVec(numberofdofs);
     34                yg->vector=NewVec(numberofdofs);
    2935
    3036                /*Now, go through constraints, and update the nodes and the constraint vector at the same time: */
    31                 constraints->SetupSpcs(nodes,yg);
     37                constraints->SetupSpcs(nodes,yg->vector);
     38
     39                /*Specify numentries: */
     40                VecGetSize(yg->vector,&gsize);
     41                yg->numentries=(int)gsize/yg->numdofs;
     42        }
     43        else{
     44                /*Allocate dofvec: */
     45                yg=new DofVec("yg");
    3246        }
    3347
    3448        /*Assign output pointers: */
    3549        *pyg=yg;
    36 
    37         return 1;
    38        
    3950}

  • issm/trunk/src/c/SpcNodesx/SpcNodesx.h

    r1 r2316  
    1010
    1111/* local prototypes: */
    12 int             SpcNodesx( Vec* yg, DataSet* nodesin,DataSet* constraints);
     12void    SpcNodesx( DofVec** pyg, DataSet* nodesin,DataSet* constraints);
    1313
    1414#endif  /* _SPCNODESX_H */

  • issm/trunk/src/c/io/WriteData.cpp

    r1 r2316  
    1919
    2020#include <mex.h>
    21 void WriteData(mxArray** pdataref,void* data,int M,int N,char* data_type,char* sub_data_type){
     21
     22
     23/*Several prototypes for WriteData, according to type: */
     24
     25/*DataSet: */
     26void WriteData(mxArray** pdataref,DataSet* dataset){
     27
     28        mxArray* dataref=NULL;
     29        char* marshalled_dataset=NULL;
     30        int   marshalled_dataset_size;
     31
     32        /*Write a dataset: */
     33        if(dataset){
     34                        /* marshall the dataset: */
     35                        marshalled_dataset=dataset->Marshall();
     36                        marshalled_dataset_size=dataset->MarshallSize();
     37                       
     38                        dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     39                        mxSetM(dataref,(mwSize)(marshalled_dataset_size/sizeof(double)));
     40                        mxSetN(dataref,(mwSize)1);
     41                        mxSetPr(dataref,(double*)marshalled_dataset);   
     42        }
     43        else{
     44                /* return empty matrix: */
     45                dataref=mxCreateDoubleMatrix(0,0,mxREAL);
     46        }
     47        *pdataref=dataref;
    2248       
    23         SerialWriteData(pdataref,data,M,N,data_type,sub_data_type);
    2449}
     50
     51void WriteData(mxArray** pdataref,Mat matrix){
     52               
     53        mxArray* dataref=NULL;
     54       
     55        if(matrix){
     56               
     57                /*call toolkit routine: */
     58                PetscMatrixToMatlabMatrix(&dataref,matrix);
     59        }
     60        else{
     61                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     62        }
     63
     64        *pdataref=dataref;
     65}
     66
     67void WriteData(mxArray** pdataref,double* matrix, int M,int N){
     68       
     69        mxArray* dataref=NULL;
     70        mxArray* tdataref=NULL;
     71               
     72        if(matrix){
     73               
     74                /*data is a double* pointer. Copy into a matrix: */
     75                tdataref = mxCreateDoubleMatrix(0,0,mxREAL);
     76                mxSetM(tdataref,(mwSize)N);
     77                mxSetN(tdataref,(mwSize)M);
     78                mxSetPr(tdataref,(double*)matrix);
     79
     80                //transpose
     81                mexCallMATLAB(1,&dataref,1,&tdataref, "'");
     82        }
     83        else{
     84                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     85        }
     86        *pdataref=dataref;
     87}
     88
     89
     90void WriteData(mxArray** pdataref,Vec vector){
     91       
     92        mxArray* dataref=NULL;
     93       
     94        if(vector){
     95               
     96                /*call toolkit routine: */
     97                PetscVectorToMatlabVector(&dataref,vector);
     98        }
     99        else{
     100                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     101        }
     102        *pdataref=dataref;
     103
     104}
     105
     106
     107void WriteData(mxArray** pdataref,DofVec* dofvec){
     108       
     109        mxArray* mxvector=NULL;
     110        mxArray* structdataref=NULL;
     111        mxArray* dataref=NULL;
     112
     113        int nfields=4;
     114        const   char*   fnames[nfields];
     115        mwSize          onebyone[2] = {1,1};
     116        mwSize          ndim=2;
     117
     118        fnames[0] = "name";
     119        fnames[1] = "numdofs";
     120        fnames[2] = "numentries";
     121        fnames[3] = "vector";
     122       
     123        if(dofvec){
     124               
     125                /*call toolkit routine: */
     126                if(dofvec->vector)PetscVectorToMatlabVector(&mxvector,dofvec->vector);
     127                else mxvector=mxCreateDoubleMatrix(0,0,mxREAL);
     128
     129                /*use the mxvector to create a dofvec object: */
     130                structdataref=mxCreateStructArray( ndim,onebyone,nfields,fnames);
     131       
     132                mxSetField( structdataref, 0, "name",mxCreateString(dofvec->name));
     133                mxSetField( structdataref, 0, "numdofs",mxCreateDoubleScalar(dofvec->numdofs));
     134                mxSetField( structdataref, 0, "numentries",mxCreateDoubleScalar(dofvec->numentries));
     135                mxSetField( structdataref, 0, "vector",mxvector);
     136
     137
     138                /*transform structure into dofvec class: */
     139                mexCallMATLAB( 1, &dataref, 1, &structdataref, "dofvec");
     140        }
     141        else{
     142                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     143        }
     144        *pdataref=dataref;
     145}
     146
     147void WriteData(mxArray** pdataref,double* vector, int M){
     148       
     149        mxArray* dataref=NULL;
     150
     151        if(vector){
     152
     153                /*data is a double* pointer. Copy into a vector: */
     154                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     155                mxSetM(dataref,(mwSize)M);
     156                mxSetN(dataref,(mwSize)1);
     157                mxSetPr(dataref,vector);
     158        }
     159        else{
     160                dataref = mxCreateDoubleMatrix(0,0,mxREAL);
     161        }
     162
     163        *pdataref=dataref;
     164}
     165
     166void WriteData(mxArray** pdataref,double scalar){
     167
     168        *pdataref=mxCreateDoubleScalar(scalar);
     169}
     170
     171void WriteData(mxArray** pdataref,int integer){
     172
     173                *pdataref=mxCreateDoubleScalar((double)integer);
     174
     175}
     176
     177void WriteData(mxArray** pdataref,char* string){
     178
     179                *pdataref=mxCreateString(string);
     180}
     181
    25182#else
    26183void WriteData(int* pdummy,void* data,char* data_type){

  • issm/trunk/src/c/io/io.h

    r1881 r2316  
    77
    88#include "../objects/NodeSets.h"
     9#include "../objects/DofVec.h"
    910#include "../DataSet/DataSet.h"
    1011#include "../include/types.h"
    … …  
    1314
    1415void FetchData(void** pdata,int* pM,int* pN,ConstDataHandle data_handle,char* data_type,char* sub_data_type);
    15 void WriteData(DataHandle* pdata_handle,void* data,int M,int N,char* data_type,char* sub_data_type);
    1616void IoModelFetchData(void** pdata,int* pM,int* pN,ConstDataHandle model_handle,char* data_name,char* data_type,char* sub_data_type);
    1717
    1818/*Serial: */
    1919#ifdef _SERIAL_
    20 void SerialFetchData(void** pdata,int* pM,int* pN,ConstDataHandle data_handle,char* data_type,char* sub_data_type);
    21 void SerialWriteData(DataHandle* pdata_handle,void* data,int M,int N,char* data_type,char* sub_data_type);
    22 void FetchNodeSets(NodeSets** pnodesets,ConstDataHandle dataref);
     20/*Write: */
     21void WriteData(mxArray** pdataref,DataSet* dataset);
     22void WriteData(mxArray** pdataref,Mat matrix);
     23void WriteData(mxArray** pdataref,double* matrix, int M,int N);
     24void WriteData(mxArray** pdataref,Vec vector);
     25void WriteData(mxArray** pdataref,double* vector, int M);
     26void WriteData(mxArray** pdataref,int integer);
     27void WriteData(mxArray** pdataref,double scalar);
     28void WriteData(mxArray** pdataref,char* string);
     29void WriteData(mxArray** pdataref,DofVec* vector);
    2330void WriteNodeSets(DataHandle* pdataref,NodeSets* nodesets);
    2431void WriteParams(DataHandle* pdataref,DataSet* parameters);
     32
     33/*Fetch: */
     34void SerialFetchData(void** pdata,int* pM,int* pN,ConstDataHandle data_handle,char* data_type,char* sub_data_type);
     35void FetchNodeSets(NodeSets** pnodesets,ConstDataHandle dataref);
    2536#endif
    2637
    … …  
    3344void ParallelFetchInteger(int* pdata,DataHandle data_handle);
    3445void WriteDataToDisk(void* data,int* pM,int* pN,char* datatype,FILE* fid);
     46void WriteData(int* pdummy,void* data,char* data_type);
    3547#endif
    3648

  • issm/trunk/src/c/objects/DofVec.cpp

    r2310 r2316  
    1515DofVec::DofVec(){
    1616        return;
     17}
     18               
     19DofVec::DofVec(char* name){
     20
     21        strcpy(this->name,name);
     22        this->numdofs=0;
     23        this->numentries=0;
     24        this->vector=NULL;
     25
    1726}
    1827

  • issm/trunk/src/c/objects/DofVec.h

    r2310 r2316  
    1313
    1414class DofVec: public Object{
    15 
    16         private:
     15       
     16        public:
    1717
    1818                char name[DOFVECNAMESIZE];
    … …  
    2121                Vec vector; //vector itself.
    2222
    23         public:
    2423
    2524                DofVec();
     25                DofVec(char* name);
    2626                DofVec(int total_size,char* name); //default numdofs=1, numentries=total_size, default_value=0;
    2727                DofVec(int total_size,double default_value,char* name); //default numdofs=1, numentries=total_size

  • issm/trunk/src/c/objects/FemModel.cpp

    r1935 r2316  
    3434
    3535FemModel::FemModel(DataSet* femmodel_elements,DataSet* femmodel_nodes,DataSet* femmodel_constraints,DataSet* femmodel_loads,
    36                 DataSet* femmodel_materials,DataSet* femmodel_parameters, Vec femmodel_partition,Vec femmodel_tpartition,Vec femmodel_yg,
     36                DataSet* femmodel_materials,DataSet* femmodel_parameters, DofVec* femmodel_partition,DofVec* femmodel_tpartition,DofVec* femmodel_yg,
    3737                Mat femmodel_Rmg,Mat femmodel_Gmn,NodeSets* femmodel_nodesets,Vec femmodel_ys,Vec femmodel_ys0){
    3838
    … …  
    6565        delete parameters;
    6666
    67         VecFree(&partition);
    68         VecFree(&tpartition);
    69         VecFree(&yg);
     67        delete partition;
     68        delete tpartition;
     69        delete yg;
    7070        MatFree(&Rmg);
    7171        delete nodesets;
    … …  
    116116       
    117117        printf("   partition: \n");
    118         VecView(partition,PETSC_VIEWER_STDOUT_WORLD);
     118        partition->Echo();
    119119        printf("   tpartition: \n");
    120         VecView(tpartition,PETSC_VIEWER_STDOUT_WORLD);
     120        tpartition->Echo();
    121121        printf("   yg: \n");
    122         VecView(yg,PETSC_VIEWER_STDOUT_WORLD);
     122        yg->Echo();
    123123        printf("   Rmg: \n");
    124124        MatView(Rmg,PETSC_VIEWER_STDOUT_WORLD);
    … …  
    192192DataSet*            FemModel::get_materials(void){return materials;}
    193193DataSet*            FemModel::get_parameters(void){return parameters;}
    194 Vec                 FemModel::get_partition(void){return partition;}
    195 Vec                 FemModel::get_tpartition(void){return tpartition;}
    196 Vec                 FemModel::get_yg(void){return yg;}
     194DofVec*                 FemModel::get_partition(void){return partition;}
     195DofVec*                 FemModel::get_tpartition(void){return tpartition;}
     196DofVec*                 FemModel::get_yg(void){return yg;}
    197197Mat                 FemModel::get_Rmg(void){return Rmg;}
    198198NodeSets*           FemModel::get_nodesets(void){return nodesets;}

  • issm/trunk/src/c/objects/FemModel.h

    r1935 r2316  
    99#include "../DataSet/DataSet.h"
    1010#include "../parallel/parallel.h"
     11#include "./DofVec.h"
    1112
    1213class DataSet;
    … …  
    2627                DataSet*            parameters;
    2728
    28                 Vec                 partition;
    29                 Vec                 tpartition;
    30                 Vec                 yg;
     29                DofVec*                 partition;
     30                DofVec*                 tpartition;
     31                DofVec*                 yg;
    3132                Mat                 Rmg;
    3233                NodeSets*           nodesets;
    … …  
    3839                ~FemModel();
    3940                FemModel(DataSet* elements,DataSet* nodes,DataSet* constraints,DataSet* loads,DataSet* materials,DataSet* parameters,
    40                                       Vec partition,Vec tpartition,Vec yg,Mat Rmg,Mat Gmn,NodeSets* nodesets,Vec ys,Vec ys0);
     41                                      DofVec* partition,DofVec* tpartition,DofVec* yg,Mat Rmg,Mat Gmn,NodeSets* nodesets,Vec ys,Vec ys0);
    4142     
    4243                /*virtual resolves: */
    … …  
    5960                DataSet* get_materials(void);
    6061                DataSet* get_parameters(void);
    61                 Vec      get_partition(void);
    62                 Vec      get_tpartition(void);
    63                 Vec      get_yg(void);
     62                DofVec*      get_partition(void);
     63                DofVec*      get_tpartition(void);
     64                DofVec*      get_yg(void);
    6465                Mat      get_Rmg(void);
    6566                NodeSets* get_nodesets(void);

  • issm/trunk/src/c/objects/Model.cpp

    r1886 r2316  
    6161        DataSet*            materials=NULL;
    6262        DataSet*            parameters=NULL;
    63         Vec                 partition=NULL;
    64         Vec                 tpartition=NULL;
    65         Vec                 yg=NULL;
     63        DofVec*                 partition=NULL;
     64        DofVec*                 tpartition=NULL;
     65        DofVec*                 yg=NULL;
    6666        Mat                 Rmg=NULL;
    6767        Mat                 Gmn=NULL;
    … …  
    100100
    101101        _printf_("   reducing single point constraints vector:\n");
    102         Reducevectorgtosx(&ys,&ys0, yg,nodesets);
     102        Reducevectorgtosx(&ys,&ys0, yg->vector,nodesets);
    103103       
    104104        _printf_("   normalizing rigid body constraints matrix:\n");
    … …  
    109109
    110110        _printf_("   process parameters:\n");
    111         ProcessParamsx( parameters, partition);
     111        ProcessParamsx( parameters, partition->vector);
    112112
    113113        _printf_("   free ressources:\n");
    … …  
    135135        DataSet*            materials=NULL;
    136136        DataSet*            parameters=NULL;
    137         Vec                 partition=NULL;
    138         Vec                 tpartition=NULL;
    139         Vec                 yg=NULL;
     137        DofVec*                 partition=NULL;
     138        DofVec*                 tpartition=NULL;
     139        DofVec*                 yg=NULL;
    140140        Mat                 Rmg=NULL;
    141141        Mat                 Gmn=NULL;
    … …  
    178178
    179179        _printf_("   reducing single point constraints vector:\n");
    180         Reducevectorgtosx(&ys,&ys0, yg,nodesets);
     180        Reducevectorgtosx(&ys,&ys0, yg->vector,nodesets);
    181181       
    182182        _printf_("   normalizing rigid body constraints matrix:\n");
    … …  
    187187
    188188        _printf_("   process parameters:\n");
    189         ProcessParamsx( parameters, partition);
     189        ProcessParamsx( parameters, partition->vector);
    190190
    191191        _printf_("   free ressources:\n");

  • issm/trunk/src/c/parallel/ControlInitialization.cpp

    r2019 r2316  
    128128        //update spcs
    129129        if(debug)_printf_("%s\n"," update boundary conditions for stokes using velocities previously computed...");
    130         xfree((void**)&dofset);dofset=dofsetgen(3,dof012,4,numberofnodes*4); VecMerge(fem_ds->yg,ug,dofset,3*numberofnodes);
     130        xfree((void**)&dofset);dofset=dofsetgen(3,dof012,4,numberofnodes*4); VecMerge(fem_ds->yg->vector,ug,dofset,3*numberofnodes);
    131131       
    132132        VecFree(&fem_ds->ys); VecFree(&fem_ds->ys0);
    133         Reducevectorgtosx(&fem_ds->ys,&fem_ds->ys0, fem_ds->yg,fem_ds->nodesets);
     133        Reducevectorgtosx(&fem_ds->ys,&fem_ds->ys0, fem_ds->yg->vector,fem_ds->nodesets);
    134134
    135135        //Compute Stokes velocities to speed up later runs

  • issm/trunk/src/c/parallel/ProcessResults.cpp

    r2112 r2316  
    127127                                if(ismacayealpattyn){
    128128                                        fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    129                                         VecToMPISerial(&partition,fem_dh->partition);
     129                                        VecToMPISerial(&partition,fem_dh->partition->vector);
    130130                                        fem_dh->parameters->FindParam((void*)&yts,"yts");
    131131                                }
    132132                                else{
    133133                                        fem_dhu->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    134                                         VecToMPISerial(&partition,fem_dhu->partition);
     134                                        VecToMPISerial(&partition,fem_dhu->partition->vector);
    135135                                        fem_dhu->parameters->FindParam((void*)&yts,"yts");
    136136                                }
    … …  
    153153                                        if(ismacayealpattyn){
    154154                                                fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    155                                                 VecToMPISerial(&partition,fem_dh->partition);
     155                                                VecToMPISerial(&partition,fem_dh->partition->vector);
    156156                                                fem_dh->parameters->FindParam((void*)&yts,"yts");
    157157                                        }
    158158                                        else{
    159159                                                fem_dhu->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    160                                                 VecToMPISerial(&partition,fem_dhu->partition);
     160                                                VecToMPISerial(&partition,fem_dhu->partition->vector);
    161161                                                fem_dhu->parameters->FindParam((void*)&yts,"yts");
    162162                                        }
    … …  
    176176                                        /* 4 dofs on number of nodes. discard pressure: */
    177177                                        fem_ds->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    178                                         VecToMPISerial(&partition,fem_ds->partition);
     178                                        VecToMPISerial(&partition,fem_ds->partition->vector);
    179179                                        fem_ds->parameters->FindParam((void*)&yts,"yts");
    180180                                        vx=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    221221                                if(ismacayealpattyn){
    222222                                        fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    223                                         VecToMPISerial(&partition,fem_dh->partition);
     223                                        VecToMPISerial(&partition,fem_dh->partition->vector);
    224224                                }
    225225                                else{
    226226                                        fem_dhu->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    227                                         VecToMPISerial(&partition,fem_dhu->partition);
     227                                        VecToMPISerial(&partition,fem_dhu->partition->vector);
    228228                                }
    229229                        }
    230230                        else{
    231231                                fem_ds->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    232                                 VecToMPISerial(&partition,fem_ds->partition);
     232                                VecToMPISerial(&partition,fem_ds->partition->vector);
    233233                        }
    234234
    … …  
    254254                        VecToMPISerial(&t_g_serial,t_g);
    255255                        fem_t->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    256                         VecToMPISerial(&partition,fem_t->partition);
     256                        VecToMPISerial(&partition,fem_t->partition->vector);
    257257
    258258                        temperature=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    278278                        fem_t->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    279279                        fem_t->parameters->FindParam((void*)&yts,"yts");
    280                         VecToMPISerial(&partition,fem_t->partition);
     280                        VecToMPISerial(&partition,fem_t->partition->vector);
    281281
    282282                        melting=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    301301                        VecToMPISerial(&h_g_serial,h_g);
    302302                        fem_p->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    303                         VecToMPISerial(&partition,fem_p->partition);
     303                        VecToMPISerial(&partition,fem_p->partition->vector);
    304304
    305305                        thickness=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    324324                        VecToMPISerial(&s_g_serial,s_g);
    325325                        fem_p->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    326                         VecToMPISerial(&partition,fem_p->partition);
     326                        VecToMPISerial(&partition,fem_p->partition->vector);
    327327
    328328                        surface=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    347347                        VecToMPISerial(&b_g_serial,b_g);
    348348                        fem_p->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    349                         VecToMPISerial(&partition,fem_p->partition);
     349                        VecToMPISerial(&partition,fem_p->partition->vector);
    350350
    351351                        bed=(double*)xmalloc(numberofnodes*sizeof(double));
    … …  
    369369                        result->GetField(&param_g);
    370370                        fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    371                         VecToMPISerial(&partition,fem_dh->partition);
     371                        VecToMPISerial(&partition,fem_dh->partition->vector);
    372372
    373373                        parameter=(double*)xmalloc(numberofnodes*sizeof(double));

  • issm/trunk/src/c/parallel/diagnostic_core.cpp

    r2110 r2316  
    116116                if(debug)_printf_("%s\n"," update boundary conditions for macyeal pattyn using hutter results...");
    117117                if (ismacayealpattyn){
    118                         VecFree(&fem_dh->yg); VecFree(&fem_dh->ys);VecFree(&fem_dh->ys0);
    119                         VecDuplicatePatch(&fem_dh->yg,ug);
    120                         Reducevectorgtosx(&fem_dh->ys,&fem_dh->ys0, fem_dh->yg,fem_dh->nodesets);
     118                        xdelete((void**)&fem_dh->yg); VecFree(&fem_dh->ys);VecFree(&fem_dh->ys0);
     119                        VecDuplicatePatch(&fem_dh->yg->vector,ug);
     120                        Reducevectorgtosx(&fem_dh->ys,&fem_dh->ys0, fem_dh->yg->vector,fem_dh->nodesets);
    121121                }
    122122
    … …  
    179179
    180180                        if(debug)_printf_("%s\n"," update boundary conditions for stokes using velocities previously computed...");
    181                         xfree((void**)&dofset);dofset=dofsetgen(3,dof012,4,numberofnodes*4); VecMerge(fem_ds->yg,ug,dofset,3*numberofnodes);
     181                        xfree((void**)&dofset);dofset=dofsetgen(3,dof012,4,numberofnodes*4); VecMerge(fem_ds->yg->vector,ug,dofset,3*numberofnodes);
    182182                        VecFree(&fem_ds->ys); VecFree(&fem_ds->ys0);
    183                         Reducevectorgtosx(&fem_ds->ys,&fem_ds->ys0, fem_ds->yg,fem_ds->nodesets);
     183                        Reducevectorgtosx(&fem_ds->ys,&fem_ds->ys0, fem_ds->yg->vector,fem_ds->nodesets);
    184184
    185185                        if(debug)_printf_("%s\n"," computing stokes velocities and pressure ...");

  • issm/trunk/src/c/shared/Alloc/alloc.cpp

    r1 r2316  
    103103        return value;
    104104}
     105
     106void xdelete( void* *pv) {
     107
     108        if (pv && *pv) {
     109
     110                delete *pv;
     111
     112                *pv=NULL;
     113        }
     114}

  • issm/trunk/src/c/shared/Alloc/alloc.h

    r1 r2316  
    1212void  xfree(void** pvptr);
    1313void* xrealloc ( void* pv, int size);
     14void xdelete( void* *pv) ;
    1415
    1516#endif

  • issm/trunk/src/m/classes/@dofvec/display.m

    r2315 r2316  
    66disp(sprintf('\n%s = \n',inputname(1)));
    77disp(sprintf('   name:      ''%s''',dofvec.name));
    8 disp(sprintf('   numdof:     %i',dofvec.numdof));
     8disp(sprintf('   numdofs:     %i',dofvec.numdofs));
    99disp(sprintf('   numentries: %i',dofvec.numentries));
    1010disp(sprintf('%s\n','   vector = '));
    1111for i=1:dofvec.numentries,
    12         for j=1:dofvec.numdof,
     12        for j=1:dofvec.numdofs,
    1313                disp(sprintf('            %i|%i|%g',i,j,dofvec.vector(i)));
    1414        end

  • issm/trunk/src/m/classes/@dofvec/dofvec.m

    r2315 r2316  
    99        % if no input arguments, create a default object
    1010        object.name='';
    11         object.numdof=1;
     11        object.numdofs=1;
    1212        object.numentries=0;
    1313        object.vector=zeros(0,1);
    … …  
    1717        if (isa(varargin{1},'dofvec'))
    1818                object = varargin{1};
     19        elseif (isa(varargin{1},'struct'))
     20                object = varargin{1};
     21                object=class(object,'dofvec');
    1922        elseif ischar(varargin{1}),
    2023                object= dofvec;

  • issm/trunk/src/m/solutions/cielo/CreateFemModel.m

    r2110 r2316  
    2424
    2525        displaystring(md.debug,'%s','   reducing single point constraints vector...');
    26         [m.ys m.ys0]=Reducevectorgtos(m.yg,m.nodesets);
     26        [m.ys m.ys0]=Reducevectorgtos(m.yg.vector,m.nodesets);
    2727       
    2828        displaystring(md.debug,'%s','   normalizing rigid body constraints matrix...');
    … …  
    3333
    3434        displaystring(md.debug,'%s','   processing parameters...');
    35         parameters= ProcessParams(parameters,m.part);
     35        parameters= ProcessParams(parameters,m.part.vector);
    3636
    3737        displaystring(md.debug,'%s','   creating parameters in matlab workspace...');

  • issm/trunk/src/mex/ComputePressure/ComputePressure.cpp

    r1464 r2316  
    4545
    4646        /*write output datasets: */
    47         WriteData(PRESSURE,p_g,0,0,"Vector",NULL);
     47        WriteData(PRESSURE,p_g);
    4848
    4949        /*Free ressources: */

  • issm/trunk/src/mex/ConfigureObjects/ConfigureObjects.cpp

    r103 r2316  
    3434
    3535        /*write output datasets: */
    36         WriteData(ELEMENTS,elements,0,0,"DataSet",NULL);
    37         WriteData(LOADS,loads,0,0,"DataSet",NULL);
    38         WriteData(NODESOUT,nodes,0,0,"DataSet",NULL);
     36        WriteData(ELEMENTS,elements);
     37        WriteData(LOADS,loads);
     38        WriteData(NODESOUT,nodes);
    3939
    4040        /*Free ressources: */

  • issm/trunk/src/mex/ContourToMesh/ContourToMesh.cpp

    r1904 r2316  
    101101        /* output: */
    102102        if (strcmp(interptype,"node")==0){
    103                 WriteData(PLHS0,in_nod,0,0,"Vector",NULL);
     103                WriteData(PLHS0,in_nod);
    104104        }
    105105        else if (strcmp(interptype,"element")==0){
    106                 WriteData(PLHS0,in_elem,0,0,"Vector",NULL);
     106                WriteData(PLHS0,in_elem);
    107107        }
    108108        else if (strcmp(interptype,"element and node")==0){
    109                 WriteData(PLHS0,in_nod,0,0,"Vector",NULL);
    110                 WriteData(PLHS1,in_elem,0,0,"Vector",NULL);
     109                WriteData(PLHS0,in_nod);
     110                WriteData(PLHS1,in_elem);
    111111        }
    112112        else throw ErrorException(__FUNCT__," wrong interpolation type");

  • issm/trunk/src/mex/ContourToNodes/ContourToNodes.cpp

    r1904 r2316  
    9090
    9191        /* output: */
    92         WriteData(FLAGS,flags,0,0,"Vector",NULL);
     92        WriteData(FLAGS,flags);
    9393
    9494        /*end module: */

  • issm/trunk/src/mex/ControlConstrain/ControlConstrain.cpp

    r1 r2316  
    3333
    3434        /*write output : */
    35         WriteData(PGOUT,p_g,gsize,1,"Vector","Vec");
     35        WriteData(PGOUT,p_g,gsize);
    3636
    3737        /*Free ressources: */

  • issm/trunk/src/mex/ControlOptimization/ControlOptimization.cpp

    r2267 r2316  
    6666
    6767        /*write output : */
    68         WriteData(SEARCHSCALAR,&search_scalar,0,0,"Scalar",NULL);
    69         WriteData(MISFIT,&J,0,0,"Scalar",NULL);
     68        WriteData(SEARCHSCALAR,search_scalar);
     69        WriteData(MISFIT,J);
    7070
    7171        /*Free ressources: */

  • issm/trunk/src/mex/Dof/Dof.cpp

    r1 r2316  
    1616
    1717        /* output datasets: */
    18         Vec partition=NULL;
    19         Vec tpartition=NULL;
     18        DofVec* partition=NULL;
     19        DofVec* tpartition=NULL;
    2020
    2121        /*Boot module: */
    … …  
    3434
    3535        /*partition and tpartition should be incremented by 1: */
    36         VecShift(partition,1.0); //matlab indexing starts at 1.
    37         VecShift(tpartition,1.0);
     36        VecShift(partition->vector,1.0); //matlab indexing starts at 1.
     37        VecShift(tpartition->vector,1.0);
    3838
    3939        /*write output datasets: */
    40         WriteData(NODES,nodes,0,0,"DataSet",NULL);
    41         WriteData(PARTITION,partition,0,0,"Vector",NULL);
    42         WriteData(TPARTITION,tpartition,0,0,"Vector",NULL);
     40        WriteData(NODES,nodes);
     41        WriteData(PARTITION,partition);
     42        WriteData(TPARTITION,tpartition);
    4343
    4444        /*Free ressources: */
    … …  
    4646        delete elements;
    4747        delete params;
    48         VecFree(&partition);
    49         VecFree(&tpartition);
     48        delete partition;
     49        delete tpartition;
    5050
    5151        /*end module: */

  • issm/trunk/src/mex/Du/Du.cpp

    r1649 r2316  
    4545
    4646        /*write output : */
    47         WriteData(DUG,du_g,0,0,"Vector",NULL);
     47        WriteData(DUG,du_g);
    4848
    4949        /*Free ressources: */

  • issm/trunk/src/mex/ElementConnectivity/ElementConnectivity.cpp

    r1103 r2316  
    3030
    3131        /*write output datasets: */
    32         WriteData(ELEMENTCONNECTIVITY,elementconnectivity,nel,3,"Matrix","Mat");
     32        WriteData(ELEMENTCONNECTIVITY,elementconnectivity,nel,3);
    3333
    3434        /*Free ressources: */

  • issm/trunk/src/mex/FieldDepthAverage/FieldDepthAverage.cpp

    r847 r2316  
    3636
    3737        /*write output : */
    38         WriteData(FIELDOUT,field,0,0,"Vector",NULL);
     38        WriteData(FIELDOUT,field);
     39
    3940        /*Free ressources: */
    4041        delete elements;

  • issm/trunk/src/mex/FieldExtrude/FieldExtrude.cpp

    r847 r2316  
    3838
    3939        /*write output : */
    40         WriteData(FIELDOUT,field,0,0,"Vector",NULL);
     40        WriteData(FIELDOUT,field);
     41
    4142        /*Free ressources: */
    4243        delete elements;

  • issm/trunk/src/mex/Gradj/Gradj.cpp

    r1649 r2316  
    4949
    5050        /*write output : */
    51         WriteData(GRADG,grad_g,0,0,"Vector",NULL);
     51        WriteData(GRADG,grad_g);
    5252
    5353        /*Free ressources: */

  • issm/trunk/src/mex/HoleFiller/HoleFiller.cpp

    r1213 r2316  
    5151
    5252        /* output: */
    53         WriteData(IMAGEOUT,imageout,imagein_rows,imagein_cols,"Matrix","Mat");
     53        WriteData(IMAGEOUT,imageout,imagein_rows,imagein_cols);
    5454
    5555        /*end module: */

  • issm/trunk/src/mex/InterpFromGridToMesh/InterpFromGridToMesh.cpp

    r2290 r2316  
    6464
    6565        /*Write data: */
    66         WriteData(DATAMESH,data_mesh,0,0,"Vector",NULL);
     66        WriteData(DATAMESH,data_mesh);
    6767
    6868        /*end module: */

  • issm/trunk/src/mex/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp

    r2295 r2316  
    5151
    5252        /*Write results: */
    53         WriteData(XM,x_m,ncols+1,1,"Vector","Vec");
    54         WriteData(YM,y_m,nlines+1,1,"Vector","Vec");
    55         WriteData(GRIDDATA,griddata,nlines,ncols,"Matrix","Mat");
     53        WriteData(XM,x_m,ncols+1);
     54        WriteData(YM,y_m,nlines+1);
     55        WriteData(GRIDDATA,griddata,nlines,ncols);
    5656
    5757        /*Free ressources: */

  • issm/trunk/src/mex/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp

    r2290 r2316  
    8585
    8686        /*Write data: */
    87         WriteData(DATAPRIME,data_prime,0,0,"Vector",NULL);
     87        WriteData(DATAPRIME,data_prime);
    8888
    8989        /*end module: */

  • issm/trunk/src/mex/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp

    r2290 r2316  
    9090
    9191        /*Write data: */
    92         WriteData(DATAPRIME,data_prime,0,0,"Vector",NULL);
     92        WriteData(DATAPRIME,data_prime);
    9393
    9494        /*end module: */

  • issm/trunk/src/mex/MassFlux/MassFlux.cpp

    r2112 r2316  
    4545
    4646        /*write output datasets: */
    47         WriteData(RESPONSE,&mass_flux,0,0,"Scalar",NULL);
     47        WriteData(RESPONSE,mass_flux);
    4848       
    4949        /*Free ressources: */

  • issm/trunk/src/mex/Mergesolutionfromftog/Mergesolutionfromftog.cpp

    r1 r2316  
    3535
    3636        /*write output datasets: */
    37         WriteData(UG,ug,0,0,"Vector",NULL);
     37        WriteData(UG,ug);
    3838
    3939        /*Free ressources: */

  • issm/trunk/src/mex/MeshPartition/MeshPartition.cpp

    r1 r2316  
    9090
    9191        /*Write data:*/
    92         WriteData(ELEMENTPARTITIONING,element_partitioning,numberofelements,1,"Matrix","Mat");
    93         WriteData(NODEPARTITIONING,node_partitioning,numberofgrids,1,"Matrix","Mat");
     92        WriteData(ELEMENTPARTITIONING,element_partitioning,numberofelements);
     93        WriteData(NODEPARTITIONING,node_partitioning,numberofgrids);
    9494       
    9595        /*Free ressources:*/

  • issm/trunk/src/mex/Misfit/Misfit.cpp

    r1649 r2316  
    4444
    4545        /*write output : */
    46         WriteData(MISFIT,&J,0,0,"Scalar",NULL);
     46        WriteData(MISFIT,J);
    4747
    4848        /*Free ressources: */

  • issm/trunk/src/mex/ModelProcessor/ModelProcessor.cpp

    r1810 r2316  
    3535       
    3636        /*Write output data: */
    37         WriteData(ELEMENTS,elements,0,0,"DataSet",NULL);
    38         WriteData(NODES,nodes,0,0,"DataSet",NULL);
    39         WriteData(CONSTRAINTS,constraints,0,0,"DataSet",NULL);
    40         WriteData(LOADS,loads,0,0,"DataSet",NULL);
    41         WriteData(MATERIALS,materials,0,0,"DataSet",NULL);
    42         WriteData(PARAMETERS,parameters,0,0,"DataSet",NULL);
     37        WriteData(ELEMENTS,elements);
     38        WriteData(NODES,nodes);
     39        WriteData(CONSTRAINTS,constraints);
     40        WriteData(LOADS,loads);
     41        WriteData(MATERIALS,materials);
     42        WriteData(PARAMETERS,parameters);
    4343       
    4444

  • issm/trunk/src/mex/MpcNodes/MpcNodes.cpp

    r1 r2316  
    3232       
    3333        /*write output datasets: */
    34         WriteData(RMG,Rmg,0,0,"Matrix",NULL);
    35         WriteData(NODES,nodes,0,0,"DataSet",NULL);
     34        WriteData(RMG,Rmg);
     35        WriteData(NODES,nodes);
    3636
    3737        /*Free ressources: */

  • issm/trunk/src/mex/NodeConnectivity/NodeConnectivity.cpp

    r1103 r2316  
    2929
    3030        /*write output datasets: */
    31         WriteData(CONNECTIVITY,connectivity,nods,width,"Matrix","Mat");
     31        WriteData(CONNECTIVITY,connectivity,nods,width);
    3232
    3333        /*Free ressources: */

  • issm/trunk/src/mex/NormalizeConstraints/NormalizeConstraints.cpp

    r1 r2316  
    3131
    3232        /*write output datasets: */
    33         WriteData(GMN,Gmn,0,0,"Matrix",NULL);
     33        WriteData(GMN,Gmn);
    3434
    3535        /*Free ressources: */

  • issm/trunk/src/mex/Orth/Orth.cpp

    r1 r2316  
    3131
    3232        /*write output datasets: */
    33         WriteData(NEWGRADJ,newgradj,0,0,"Vector",NULL);
     33        WriteData(NEWGRADJ,newgradj);
    3434
    3535        /*Free ressources: */

  • issm/trunk/src/mex/OutputRifts/OutputRifts.cpp

    r1805 r2316  
    3232
    3333        /*write output : */
    34         WriteData(RIFTPROPERTIES,riftproperties,0,0,"Vector",NULL);
     34        WriteData(RIFTPROPERTIES,riftproperties);
    3535
    3636        /*Free ressources: */

  • issm/trunk/src/mex/PenaltyConstraints/PenaltyConstraints.cpp

    r1649 r2316  
    4747
    4848        /*write output datasets: */
    49         WriteData(LOADS,loads,0,0,"DataSet",NULL);
    50         WriteData(CONVERGED,(void*)&converged,0,0,"Integer",NULL);
    51         WriteData(NUMUNSTABLECONSTRAINTS,(void*)&num_unstable_constraints,0,0,"Integer",NULL);
     49        WriteData(LOADS,loads);
     50        WriteData(CONVERGED,converged);
     51        WriteData(NUMUNSTABLECONSTRAINTS,num_unstable_constraints);
    5252       
    5353       

  • issm/trunk/src/mex/PenaltySystemMatrices/PenaltySystemMatrices.cpp

    r1649 r2316  
    5252
    5353        /*write output datasets: */
    54         WriteData(KGG,Kgg,0,0,"Matrix",NULL);
    55         WriteData(PG,pg,0,0,"Vector",NULL);
    56         WriteData(KMAX,&kmax,0,0,"Scalar",NULL);
     54        WriteData(KGG,Kgg);
     55        WriteData(PG,pg);
     56        WriteData(KMAX,kmax);
    5757       
    5858        /*Free ressources: */

  • issm/trunk/src/mex/ProcessParams/ProcessParams.cpp

    r304 r2316  
    3131
    3232        /*write output datasets: */
    33         WriteData(PARAMETERSOUT,parameters,0,0,"DataSet",NULL);
     33        WriteData(PARAMETERSOUT,parameters);
    3434
    3535        /*Free ressources: */

  • issm/trunk/src/mex/Reduceloadfromgtof/Reduceloadfromgtof.cpp

    r1 r2316  
    3737
    3838        /*write output datasets: */
    39         WriteData(PF,pf,0,0,"Vector",NULL);
     39        WriteData(PF,pf);
    4040
    4141        /*Free ressources: */

  • issm/trunk/src/mex/Reducematrixfromgtof/Reducematrixfromgtof.cpp

    r1 r2316  
    3434
    3535        /*write output datasets: */
    36         WriteData(KFF,Kff,0,0,"Matrix",NULL);
    37         WriteData(KFS,Kfs,0,0,"Matrix",NULL);
     36        WriteData(KFF,Kff);
     37        WriteData(KFS,Kfs);
    3838
    3939        /*Free ressources: */

  • issm/trunk/src/mex/Reducevectorgtof/Reducevectorgtof.cpp

    r1665 r2316  
    3131
    3232        /*write output datasets: */
    33         WriteData(UF,uf,0,0,"Vector",NULL);
     33        WriteData(UF,uf);
    3434
    3535        /*Free ressources: */

  • issm/trunk/src/mex/Reducevectorgtos/Reducevectorgtos.cpp

    r1 r2316  
    3232
    3333        /*write output datasets: */
    34         WriteData(YS,ys,0,0,"Vector",NULL);
    35         WriteData(YS0,ys0,0,0,"Vector",NULL);
     34        WriteData(YS,ys);
     35        WriteData(YS0,ys0);
    3636
    3737        /*Free ressources: */

  • issm/trunk/src/mex/Solver/Solver.cpp

    r1 r2316  
    3535
    3636        /*write output datasets: */
    37         WriteData(UF,uf,0,0,"Vector",NULL);
     37        WriteData(UF,uf);
    3838
    3939        /*Free ressources: */

  • issm/trunk/src/mex/SpcNodes/SpcNodes.cpp

    r1 r2316  
    1616
    1717        /* output datasets: */
    18         Vec         yg=NULL;
     18        DofVec*         yg=NULL;
    1919
    2020        /*Boot module: */
    … …  
    3232
    3333        /*write output datasets: */
    34         WriteData(NODES,nodes,0,0,"DataSet",NULL);
    35         WriteData(YG,yg,0,0,"Vector",NULL);
     34        WriteData(NODES,nodes);
     35        WriteData(YG,yg);
    3636
    3737        /*Free ressources: */
    3838        delete nodes;
    3939        delete constraints;
    40         VecFree(&yg);
     40        delete yg;
    4141
    4242        /*end module: */

  • issm/trunk/src/mex/SystemMatrices/SystemMatrices.cpp

    r1649 r2316  
    5353
    5454        /*write output datasets: */
    55         WriteData(KGG,Kgg,0,0,"Matrix",NULL);
    56         WriteData(PG,pg,0,0,"Vector",NULL);
     55        WriteData(KGG,Kgg);
     56        WriteData(PG,pg);
    5757       
    5858       

  • issm/trunk/src/mex/UpdateFromInputs/UpdateFromInputs.cpp

    r246 r2316  
    3737
    3838        /*write output datasets: */
    39         WriteData(ELEMENTS,elements,0,0,"DataSet",NULL);
    40         WriteData(NODES,nodes,0,0,"DataSet",NULL);
    41         WriteData(LOADS,loads,0,0,"DataSet",NULL);
    42         WriteData(MATERIALS,materials,0,0,"DataSet",NULL);
     39        WriteData(ELEMENTS,elements);
     40        WriteData(NODES,nodes);
     41        WriteData(LOADS,loads);
     42        WriteData(MATERIALS,materials);
    4343
    4444        /*Free ressources: */

  • issm/trunk/src/mex/UpdateGeometry/UpdateGeometry.cpp

    r822 r2316  
    4444
    4545        /*write output data: */
    46         WriteData(OUTTHICKNESS,outthickness,0,0,"Vector",NULL);
    47         WriteData(OUTBED,outbed,0,0,"Vector",NULL);
    48         WriteData(OUTSURFACE,outsurface,0,0,"Vector",NULL);
     46        WriteData(OUTTHICKNESS,outthickness);
     47        WriteData(OUTBED,outbed);
     48        WriteData(OUTSURFACE,outsurface);
    4949
    5050        /*Free ressources: */

  • issm/trunk/src/mex/UpdateNodePositions/UpdateNodePositions.cpp

    r876 r2316  
    3636
    3737        /*write output datasets: */
    38         WriteData(NODESOUT,nodes,0,0,"DataSet",NULL);
     38        WriteData(NODESOUT,nodes);
    3939
    4040        /*Free ressources: */

  • issm/trunk/startup.m

    r1572 r2316  
    4343addpath(genpath_ice([ISSM_DIR '/src/m']));
    4444addpath(genpath_ice([ISSM_DIR '/src/pro']));
     45addpath(genpath_ice([ISSM_DIR '/externalpackages/subplotSpacing']));
    4546
    4647%Check on any warning messages that might indicate that the paths were not correct.

  • issm/trunk/test/Verification/test01_IceShelfIceFrontM2d/testpresolve.m

    r2151 r2316  
    22        load Velocities; md.vx=0.5*vx; md.vy=0.5*vy;
    33end
     4md.debug=1;
Note: See TracChangeset for help on using the changeset viewer.