Index: /issm/trunk/src/c/Container/Options.cpp =================================================================== --- /issm/trunk/src/c/Container/Options.cpp (revision 8909) +++ /issm/trunk/src/c/Container/Options.cpp (revision 8910) @@ -42,5 +42,5 @@ if (!mxIsClass(prhs[i],"char")) _error_("Argument %d must be name of option.",i+1); - FetchData(&name,prhs[i]); + FetchMatlabData(&name,prhs[i]); if (i+1 == nrhs) _error_("Argument %d must exist and be value of option \"%s\".",i+2,name); Index: /issm/trunk/src/c/Makefile.am =================================================================== --- /issm/trunk/src/c/Makefile.am (revision 8909) +++ /issm/trunk/src/c/Makefile.am (revision 8910) @@ -402,12 +402,13 @@ ./toolkits.h\ ./io/io.h\ - ./io/FetchData.cpp\ - ./io/WriteData.cpp\ - ./io/IoModelFetchData.cpp\ - ./io/WriteParams.cpp\ - ./io/FetchParams.cpp\ - ./io/OptionParse.cpp\ - ./io/pfopen.cpp\ - ./io/pfclose.cpp\ + ./io/Disk/diskio.h\ + ./io/Disk/IoModelFetchData.cpp\ + ./io/Disk/pfopen.cpp\ + ./io/Disk/pfclose.cpp\ + ./io/Disk/FetchData.cpp\ + ./io/Matlab/matlabio.h\ + ./io/Matlab/WriteMatlabData.cpp\ + ./io/Matlab/FetchMatlabData.cpp\ + ./io/Matlab/OptionParse.cpp\ ./EnumDefinitions/EnumDefinitions.h\ ./EnumDefinitions/EnumToModelField.cpp\ @@ -1075,10 +1076,13 @@ ./toolkits.h\ ./io/io.h\ - ./io/FetchData.cpp\ - ./io/WriteData.cpp\ - ./io/IoModelFetchData.cpp\ - ./io/WriteParams.cpp\ - ./io/pfopen.cpp\ - ./io/pfclose.cpp\ + ./io/Disk/diskio.h\ + ./io/Disk/IoModelFetchData.cpp\ + ./io/Disk/pfopen.cpp\ + ./io/Disk/pfclose.cpp\ + ./io/Disk/FetchData.cpp\ + ./io/Matlab/matlabio.h\ + ./io/Matlab/WriteMatlabData.cpp\ + ./io/Matlab/FetchMatlabData.cpp\ + ./io/Matlab/OptionParse.cpp\ ./EnumDefinitions/EnumDefinitions.h\ ./EnumDefinitions/EnumToModelField.cpp\ Index: /issm/trunk/src/c/io/Disk/FetchData.cpp =================================================================== --- /issm/trunk/src/c/io/Disk/FetchData.cpp (revision 8910) +++ /issm/trunk/src/c/io/Disk/FetchData.cpp (revision 8910) @@ -0,0 +1,137 @@ +/*\file FetchData.cpp: + * \brief: general I/O interface to fetch data. + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../../shared/shared.h" +#include "../../include/include.h" + +#if defined(_HAVE_PETSC_) +/*FUNCTION FetchData(double** pmatrix, int* pM,int* pN,FILE* fid){{{1*/ +void FetchData(double** pmatrix, int* pM,int* pN,FILE* fid){ + + extern int my_rank; + extern int num_procs; + + /*output: */ + int M,N; + double* matrix=NULL; + + /*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */ + /*numberofelements: */ + if(my_rank==0){ + if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix "); + } + + MPI_Bcast(&M,1,MPI_INT,0,MPI_COMM_WORLD); + + if(my_rank==0){ + if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix "); + } + MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD); + + /*Now allocate matrix: */ + if(M*N){ + matrix=(double*)xmalloc(M*N*sizeof(double)); + + /*Read matrix on node 0, then broadcast: */ + if(my_rank==0){ + if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix "); + } + + MPI_Bcast(matrix,M*N,MPI_DOUBLE,0,MPI_COMM_WORLD); + } + + + /*Assign output pointers: */ + *pmatrix=matrix; + if (pM)*pM=M; + if (pN)*pN=N; + +} +/*}}}*/ +/*FUNCTION FetchData(char** pstring,FILE* fid){{{1*/ +void FetchData(char** pstring,FILE* fid){ + + extern int my_rank; + extern int num_procs; + + /*output: */ + char* string=NULL; + int string_size; + + /*We have to read a string from disk. First read the dimensions of the string, then the string: */ + if(my_rank==0){ + if(fread(&string_size,sizeof(int),1,fid)!=1) _error_(" could not read length of string "); + } + + MPI_Bcast(&string_size,1,MPI_INT,0,MPI_COMM_WORLD); + + /*Now allocate string: */ + if(string_size){ + string=(char*)xmalloc((string_size+1)*sizeof(char)); + string[string_size]='\0'; + + /*Read string on node 0, then broadcast: */ + if(my_rank==0){ + if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_(" could not read string "); + } + MPI_Bcast(string,string_size,MPI_CHAR,0,MPI_COMM_WORLD); + } + else{ + string=(char*)xmalloc(sizeof(char)); + string[0]='\0'; + } + + + /*Assign output pointers: */ + *pstring=string; +} +/*}}}*/ +/*FUNCTION FetchData(double* pscalar,FILE* fid){{{1*/ +void FetchData(double* pscalar,FILE* fid){ + + extern int my_rank; + extern int num_procs; + + /*output: */ + double scalar; + + /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */ + if(my_rank==0){ + if(fread(&scalar,sizeof(double),1,fid)!=1)_error_(" could not read scalar "); + } + MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + + /*Assign output pointers: */ + *pscalar=scalar; + +} +/*}}}*/ +/*FUNCTION FetchData(int* pinteger,FILE* fid){{{1*/ +void FetchData(int* pinteger,FILE* fid){ + + extern int my_rank; + extern int num_procs; + + /*output: */ + int integer; + + /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */ + if(my_rank==0){ + if(fread(&integer,sizeof(int),1,fid)!=1) _error_(" could not read integer "); + } + + MPI_Bcast(&integer,1,MPI_INT,0,MPI_COMM_WORLD); + + /*Assign output pointers: */ + *pinteger=integer; + +} +/*}}}*/ +#endif Index: /issm/trunk/src/c/io/Disk/IoModelFetchData.cpp =================================================================== --- /issm/trunk/src/c/io/Disk/IoModelFetchData.cpp (revision 8910) +++ /issm/trunk/src/c/io/Disk/IoModelFetchData.cpp (revision 8910) @@ -0,0 +1,127 @@ +/*! \file IoModelFetchData.c + * \brief: wrapper to the I/O routines, for special processing of the IoModel structure. + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "./diskio.h" + +/*FUNCTION IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,char* data_name){{{1*/ +void IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,char* data_name){ + + FILE* fid=NULL; + + /*Set file pointer to beginning of the data: */ + fid=SetFilePointerToData(model_handle,data_name); + + /*Now fetch: */ + FetchData(pmatrix,pM,pN,fid); + +} +/*}}}*/ +/*FUNCTION IoModelFetchData(char** pstring,FILE* model_handle,char* data_name){{{1*/ +void IoModelFetchData(char** pstring,FILE* model_handle,char* data_name){ + + FILE* fid=NULL; + + /*Set file pointer to beginning of the data: */ + fid=SetFilePointerToData(model_handle,data_name); + + /*Now fetch: */ + FetchData(pstring,fid); +} +/*}}}*/ +/*FUNCTION IoModelFetchData(double* pscalar,FILE* model_handle,char* data_name){{{1*/ +void IoModelFetchData(double* pscalar,FILE* model_handle,char* data_name){ + + FILE* fid=NULL; + + /*Set file pointer to beginning of the data: */ + fid=SetFilePointerToData(model_handle,data_name); + + /*Now fetch: */ + FetchData(pscalar,fid); +} +/*}}}*/ +/*FUNCTION IoModelFetchData(int* pinteger,FILE* model_handle,char* data_name){{{1*/ +void IoModelFetchData(int* pinteger,FILE* model_handle,char* data_name){ + + FILE* fid=NULL; + + /*Set file pointer to beginning of the data: */ + fid=SetFilePointerToData(model_handle,data_name); + + /*Now fetch: */ + FetchData(pinteger,fid); +} +/*}}}*/ +/*FUNCTION SetFilePointerToData(FILE* model_handle,char* data_name){{{1*/ +FILE* SetFilePointerToData(FILE* model_handle,char* data_name){ + + extern int my_rank; + extern int num_procs; + + int string_size; + int record_length; + char* string=NULL; + char* repository=NULL; + FILE* fid=NULL; + int found=0; + + /*Go find in the binary file, the position of the data we want to fetch: */ + if(my_rank==0){ + + /*First set FILE* position to the beginning of the file: */ + fid=(FILE*)model_handle; + fseek(fid,0,SEEK_SET); + + /*Now march through file looking for the correct name: */ + for(;;){ + /*Read size of first string name: */ + if(fread(&string_size,sizeof(int),1,fid)==0){ + /*Ok, we have reached the end of the file. break: */ + found=0; + break; + } + /*Allocate string of correct size: */ + string=(char*)xmalloc((string_size+1)*sizeof(char)); + string[string_size]='\0'; + + /*Read string: */ + if(fread(string,string_size*sizeof(char),1,fid)==0){ + /*Ok, we have reached the end of the file. break: */ + found=0; + break; + } + /*Is this the correct string? : */ + if (strcmp(string,data_name)==0){ + /*Ok, we have found the correct string. Pass the record length, and break: */ + fseek(fid,sizeof(int),SEEK_CUR); + found=1; + break; + } + else{ + /*This is not the correct string, read the record length, and skip it: */ + fread(&record_length,sizeof(int),1,fid); + /*skip: */ + fseek(fid,record_length,SEEK_CUR); + } + /*Erase string: */ + xfree((void**)&string); + } + /*erase string, if we broke from the for() loop:*/ + xfree((void**)&string); + } + MPI_Bcast(&found,1,MPI_INT,0,MPI_COMM_WORLD); + + if(!found)_error_("%s %s ","could not find data with name",data_name); + + return fid; +} +/*}}}*/ Index: /issm/trunk/src/c/io/Disk/diskio.h =================================================================== --- /issm/trunk/src/c/io/Disk/diskio.h (revision 8910) +++ /issm/trunk/src/c/io/Disk/diskio.h (revision 8910) @@ -0,0 +1,29 @@ +/*\file diskio.h + *\brief: I/O for ISSM from disk + */ + +#ifndef _DISK_IO_H_ +#define _DISK_IO_H_ + +#include "../../objects/objects.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +class DataSet; +class Parameters; + +FILE* pfopen(char* filename,char* format); +void pfclose(FILE* fid,char* filename); + +void FetchData(double** pmatrix, int* pM,int* pN,FILE* fid); +void FetchData(char** pstring,FILE* fid); +void FetchData(double* pscalar,FILE* fid); +void FetchData(int* pinteger,FILE* fid); + +void IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,char* data_name); +void IoModelFetchData(char** pstring,FILE* model_handle,char* data_name); +void IoModelFetchData(double* pscalar,FILE* model_handle,char* data_name); +void IoModelFetchData(int* pinteger,FILE* model_handle,char* data_name); +FILE* SetFilePointerToData(FILE* model_handle,char* data_name); + +#endif /* _IO_H_ */ Index: /issm/trunk/src/c/io/Disk/pfclose.cpp =================================================================== --- /issm/trunk/src/c/io/Disk/pfclose.cpp (revision 8910) +++ /issm/trunk/src/c/io/Disk/pfclose.cpp (revision 8910) @@ -0,0 +1,21 @@ +/*!\file: pfclose.cpp + * \brief fclose wrapper for parallel solution + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "stdio.h" +#include "../../shared/shared.h" +#include "../../include/include.h" + +void pfclose(FILE* fid,char* filename){ + + /*Close file handle: */ + extern int my_rank; + _assert_(fid); + if(fclose(fid)!=0)_error_("%s%s","could not close file ",filename); +} Index: /issm/trunk/src/c/io/Disk/pfopen.cpp =================================================================== --- /issm/trunk/src/c/io/Disk/pfopen.cpp (revision 8910) +++ /issm/trunk/src/c/io/Disk/pfopen.cpp (revision 8910) @@ -0,0 +1,26 @@ +/*!\file: pfopen.cpp + * \brief fopen wrapper for parallel solution + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "stdio.h" +#include "../../shared/shared.h" +#include "../../include/include.h" + +FILE* pfopen(char* filename,char* format){ + + FILE* fid=NULL; + extern int my_rank; + + /*Open handle to data on disk: */ + fid=fopen(filename,format); + if(fid==NULL) _error_("%s%s%s","could not open file ",filename," for binary reading or writing"); + + return fid; +} + Index: sm/trunk/src/c/io/FetchData.cpp =================================================================== --- /issm/trunk/src/c/io/FetchData.cpp (revision 8909) +++ (revision ) @@ -1,696 +1,0 @@ -/*\file FetchData.cpp: - * \brief: general I/O interface to fetch data. - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "./io.h" -#include "../shared/shared.h" -#include "../include/include.h" - -#ifdef _SERIAL_ -#include -/*FUNCTION FetchData(DataSet** pdataset,const mxArray* dataref){{{1*/ -void FetchData(DataSet** pdataset,const mxArray* dataref){ - - /*output*/ - DataSet* outdataset=NULL; - char* outdataset_buffer=NULL; - int outdataset_size; - - /*First, check that our reference is a double, otherwise, error out: */ - if (mxIsClass(dataref,"double")){ - - /*We need to copy the data pointed by dataref, so that our dataset is not actually a pointer!:*/ - if (!mxIsEmpty(dataref)){ - outdataset_buffer=(char*)mxGetPr(dataref); - outdataset_size=mxGetM(dataref)*mxGetN(dataref); - if(outdataset_size)outdataset=DataSetDemarshall(outdataset_buffer); - } - } - else{ - if (mxIsEmpty(dataref)){ - /*Nothing to pick up. Just initialize pointer to NULL, and warn the server we are not uploading anything: */ - outdataset_size=0; - outdataset=NULL; - } - else{ - /*This is an error: we don't have the correct input!: */ - _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); - } - } - - /*Assign output pointers:*/ - *pdataset=outdataset; -} -/*}}}*/ -/*FUNCTION FetchData(double** pmatrix,int* pM,int *pN,const mxArray* dataref){{{1*/ -void FetchData(double** pmatrix,int* pM,int *pN,const mxArray* dataref){ - - double* outmatrix=NULL; - int outmatrix_rows,outmatrix_cols; - - if(mxIsEmpty(dataref) ){ - /*Nothing to pick up. Just initialize matrix pointer to NULL: */ - outmatrix_rows=0; - outmatrix_cols=0; - outmatrix=NULL; - } - else if (mxIsClass(dataref,"double") ){ - - /*Check dataref is not pointing to NaN: */ - if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){ - outmatrix_rows=0; - outmatrix_cols=0; - outmatrix=NULL; - } - else{ - - /*Convert matlab matrix to double* matrix: */ - MatlabMatrixToDoubleMatrix(&outmatrix,&outmatrix_rows,&outmatrix_cols,dataref); - } - } - else{ - /*This is an error: we don't have the correct input!: */ - _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); - } - - /*Assign output pointers:*/ - *pmatrix=outmatrix; - if (pM)*pM=outmatrix_rows; - if (pN)*pN=outmatrix_cols; - -} -/*}}}*/ -/*FUNCTION FetchData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref){{{1*/ -void FetchData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref){ - - double* outmatrix=NULL; - int outmatrix_numel,outmatrix_ndims; - int* outmatrix_size=NULL; - - if(mxIsEmpty(dataref) ){ - /*Nothing to pick up. Just initialize matrix pointer to NULL: */ - outmatrix_numel=0; - outmatrix_ndims=0; - outmatrix_size =NULL; - outmatrix=NULL; - } - else if (mxIsClass(dataref,"double") ){ - - /*Check dataref is not pointing to NaN: */ - if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetNumberOfElements(dataref)==1) ){ - outmatrix_numel=0; - outmatrix_ndims=0; - outmatrix_size =NULL; - outmatrix=NULL; - } - else{ - - /*Convert matlab n-dim array to double* matrix: */ - MatlabNArrayToNArray(&outmatrix,&outmatrix_numel,&outmatrix_ndims,&outmatrix_size,dataref); - } - } - else{ - /*This is an error: we don't have the correct input!: */ - _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); - } - - /*Assign output pointers:*/ - *pmatrix=outmatrix; - if (pnumel)*pnumel=outmatrix_numel; - if (pndims)*pndims=outmatrix_ndims; - if (psize )*psize =outmatrix_size; - else xfree((void**)&outmatrix_size); - -} -/*}}}*/ -/*FUNCTION FetchData(int** pmatrix,int* pM,int *pN,const mxArray* dataref){{{1*/ -void FetchData(int** pmatrix,int* pM,int *pN,const mxArray* dataref){ - - int i,outmatrix_rows,outmatrix_cols; - double *doublematrix=NULL; - int *outmatrix=NULL; - - if(mxIsEmpty(dataref) ){ - /*Nothing to pick up. Just initialize matrix pointer to NULL: */ - outmatrix_rows=0; - outmatrix_cols=0; - outmatrix=NULL; - } - else if (mxIsClass(dataref,"double") ){ - - /*Check dataref is not pointing to NaN: */ - if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){ - outmatrix_rows=0; - outmatrix_cols=0; - outmatrix=NULL; - } - else{ - - /*Convert matlab matrix to double* matrix: */ - MatlabMatrixToDoubleMatrix(&doublematrix,&outmatrix_rows,&outmatrix_cols,dataref); - - /*Convert double matrix into integer matrix: */ - outmatrix=(int*)xmalloc(outmatrix_rows*outmatrix_cols*sizeof(int)); - for(i=0;i - -#include "../objects/NodeSets.h" -#include "./io.h" - -void FetchNodeSets(NodeSets** pnodesets,ConstDataHandle dataref){ - - /*output: */ - NodeSets* nodesets=NULL; - double* pv_f=NULL; - double* pv_s=NULL; - int gsize; - int fsize; - int ssize; - - if(mxIsEmpty(dataref)){ - nodesets=NULL; - } - else{ - - FetchData(&pv_f,NULL,mxGetField(dataref,0,"pv_f")); - FetchData(&pv_s,NULL,mxGetField(dataref,0,"pv_s")); - - gsize=(int)mxGetScalar(mxGetField(dataref,0,"gsize")); - fsize=(int)mxGetScalar(mxGetField(dataref,0,"fsize")); - ssize=(int)mxGetScalar(mxGetField(dataref,0,"ssize")); - - nodesets=new NodeSets( pv_f,pv_s,gsize,fsize,ssize); - } - - /*Assign output pointers:*/ - *pnodesets=nodesets; - -} -#endif Index: sm/trunk/src/c/io/FetchParams.cpp =================================================================== --- /issm/trunk/src/c/io/FetchParams.cpp (revision 8909) +++ (revision ) @@ -1,184 +1,0 @@ -/* \file FetchParams.c: - * \brief: interface for fetching matlab parameters into a "C" dataset - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#ifdef _SERIAL_ - -#include -#include "./io.h" -#include "../objects/objects.h" -#include "../shared/shared.h" -#include "../include/include.h" -#include "../EnumDefinitions/EnumDefinitions.h" - -void FetchParams(Parameters** pparameters, DataHandle dataref){ - - int i,j; - int count; - - /*output: */ - Param* param=NULL; - Parameters* parameters=NULL; - - /*intermediary: */ - int M,N; - double* tmatrix=NULL; - double* matrix=NULL; - char** stringarray=NULL; - double** array=NULL; - int* mdims_array=NULL; - int* ndims_array=NULL; - int nfields; - char* name=NULL; - mxArray* pfield=NULL; - mxArray* pfield2=NULL; - int enum_type; - - - /*First, create parameters : */ - parameters=new Parameters(); - - /*go through matlab params structure, and create Param object for each field: */ - - nfields=mxGetNumberOfFields(dataref); - - for(count=0;countAddObject(param); - - } - else{ - if (N==1){ - - /*vector: */ - param= new DoubleVecParam(enum_type,mxGetPr(pfield),M); - parameters->AddObject(param); - - } - else{ - /*matrix: first, transpose, then plug into Param */ - matrix=mxGetPr(pfield); - tmatrix=(double*)xmalloc(M*N*sizeof(double)); - for (i=0;iAddObject(param); - - /*Free ressources:*/ - xfree((void**)&tmatrix); - } - } - - } - else if (mxIsClass(pfield,"char")){ - /* we have a string parameter:*/ - - int stringlen; - char* string=NULL; - - stringlen = mxGetM(pfield)*mxGetN(pfield)+1; - string = (char*)xmalloc(sizeof(mxChar)*stringlen); - mxGetString(pfield,string,stringlen); - - param= new StringParam(enum_type,string); - parameters->AddObject(param); - - xfree((void**)&string); - } - else if (mxIsClass(pfield,"cell")){ - - /*This can be a string array, or a matrix array. Check the first - *element type to decide: */ - pfield2=mxGetCell(pfield,0); - if (mxIsClass(pfield2,"char")){ - - /*string array: */ - M=mxGetM(pfield); - stringarray=(char**)xmalloc(M*sizeof(char*)); - - for(i=0;iAddObject(param); - - /*Free ressources:*/ - for(i=0;iAddObject(param); - - /*Free ressources:*/ - for(i=0;i +/*FUNCTION FetchMatlabData(DataSet** pdataset,const mxArray* dataref){{{1*/ +void FetchMatlabData(DataSet** pdataset,const mxArray* dataref){ + + /*output*/ + DataSet* outdataset=NULL; + char* outdataset_buffer=NULL; + int outdataset_size; + + /*First, check that our reference is a double, otherwise, error out: */ + if (mxIsClass(dataref,"double")){ + + /*We need to copy the data pointed by dataref, so that our dataset is not actually a pointer!:*/ + if (!mxIsEmpty(dataref)){ + outdataset_buffer=(char*)mxGetPr(dataref); + outdataset_size=mxGetM(dataref)*mxGetN(dataref); + if(outdataset_size)outdataset=DataSetDemarshall(outdataset_buffer); + } + } + else{ + if (mxIsEmpty(dataref)){ + /*Nothing to pick up. Just initialize pointer to NULL, and warn the server we are not uploading anything: */ + outdataset_size=0; + outdataset=NULL; + } + else{ + /*This is an error: we don't have the correct input!: */ + _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); + } + } + + /*Assign output pointers:*/ + *pdataset=outdataset; +} +/*}}}*/ +/*FUNCTION FetchMatlabData(double** pmatrix,int* pM,int *pN,const mxArray* dataref){{{1*/ +void FetchMatlabData(double** pmatrix,int* pM,int *pN,const mxArray* dataref){ + + double* outmatrix=NULL; + int outmatrix_rows,outmatrix_cols; + + if(mxIsEmpty(dataref) ){ + /*Nothing to pick up. Just initialize matrix pointer to NULL: */ + outmatrix_rows=0; + outmatrix_cols=0; + outmatrix=NULL; + } + else if (mxIsClass(dataref,"double") ){ + + /*Check dataref is not pointing to NaN: */ + if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){ + outmatrix_rows=0; + outmatrix_cols=0; + outmatrix=NULL; + } + else{ + + /*Convert matlab matrix to double* matrix: */ + MatlabMatrixToDoubleMatrix(&outmatrix,&outmatrix_rows,&outmatrix_cols,dataref); + } + } + else{ + /*This is an error: we don't have the correct input!: */ + _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); + } + + /*Assign output pointers:*/ + *pmatrix=outmatrix; + if (pM)*pM=outmatrix_rows; + if (pN)*pN=outmatrix_cols; + +} +/*}}}*/ +/*FUNCTION FetchMatlabData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref){{{1*/ +void FetchMatlabData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref){ + + double* outmatrix=NULL; + int outmatrix_numel,outmatrix_ndims; + int* outmatrix_size=NULL; + + if(mxIsEmpty(dataref) ){ + /*Nothing to pick up. Just initialize matrix pointer to NULL: */ + outmatrix_numel=0; + outmatrix_ndims=0; + outmatrix_size =NULL; + outmatrix=NULL; + } + else if (mxIsClass(dataref,"double") ){ + + /*Check dataref is not pointing to NaN: */ + if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetNumberOfElements(dataref)==1) ){ + outmatrix_numel=0; + outmatrix_ndims=0; + outmatrix_size =NULL; + outmatrix=NULL; + } + else{ + + /*Convert matlab n-dim array to double* matrix: */ + MatlabNArrayToNArray(&outmatrix,&outmatrix_numel,&outmatrix_ndims,&outmatrix_size,dataref); + } + } + else{ + /*This is an error: we don't have the correct input!: */ + _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref)); + } + + /*Assign output pointers:*/ + *pmatrix=outmatrix; + if (pnumel)*pnumel=outmatrix_numel; + if (pndims)*pndims=outmatrix_ndims; + if (psize )*psize =outmatrix_size; + else xfree((void**)&outmatrix_size); + +} +/*}}}*/ +/*FUNCTION FetchMatlabData(int** pmatrix,int* pM,int *pN,const mxArray* dataref){{{1*/ +void FetchMatlabData(int** pmatrix,int* pM,int *pN,const mxArray* dataref){ + + int i,outmatrix_rows,outmatrix_cols; + double *doublematrix=NULL; + int *outmatrix=NULL; + + if(mxIsEmpty(dataref) ){ + /*Nothing to pick up. Just initialize matrix pointer to NULL: */ + outmatrix_rows=0; + outmatrix_cols=0; + outmatrix=NULL; + } + else if (mxIsClass(dataref,"double") ){ + + /*Check dataref is not pointing to NaN: */ + if ( mxIsNaN(*(mxGetPr(dataref))) && (mxGetM(dataref)==1) && (mxGetN(dataref)==1) ){ + outmatrix_rows=0; + outmatrix_cols=0; + outmatrix=NULL; + } + else{ + + /*Convert matlab matrix to double* matrix: */ + MatlabMatrixToDoubleMatrix(&doublematrix,&outmatrix_rows,&outmatrix_cols,dataref); + + /*Convert double matrix into integer matrix: */ + outmatrix=(int*)xmalloc(outmatrix_rows*outmatrix_cols*sizeof(int)); + for(i=0;iAddObject(param); + + } + else{ + if (N==1){ + + /*vector: */ + param= new DoubleVecParam(enum_type,mxGetPr(pfield),M); + parameters->AddObject(param); + + } + else{ + /*matrix: first, transpose, then plug into Param */ + matrix=mxGetPr(pfield); + tmatrix=(double*)xmalloc(M*N*sizeof(double)); + for (i=0;iAddObject(param); + + /*Free ressources:*/ + xfree((void**)&tmatrix); + } + } + + } + else if (mxIsClass(pfield,"char")){ + /* we have a string parameter:*/ + + int stringlen; + char* string=NULL; + + stringlen = mxGetM(pfield)*mxGetN(pfield)+1; + string = (char*)xmalloc(sizeof(mxChar)*stringlen); + mxGetString(pfield,string,stringlen); + + param= new StringParam(enum_type,string); + parameters->AddObject(param); + + xfree((void**)&string); + } + else if (mxIsClass(pfield,"cell")){ + + /*This can be a string array, or a matrix array. Check the first + *element type to decide: */ + pfield2=mxGetCell(pfield,0); + if (mxIsClass(pfield2,"char")){ + + /*string array: */ + M=mxGetM(pfield); + stringarray=(char**)xmalloc(M*sizeof(char*)); + + for(i=0;iAddObject(param); + + /*Free ressources:*/ + for(i=0;iAddObject(param); + + /*Free ressources:*/ + for(i=0;i + +/*FUNCTION OptionDoubleParse {{{1*/ +OptionDouble* OptionDoubleParse( char* name, const mxArray* prhs[]){ + + OptionDouble *odouble = NULL; + + /*check and parse the name */ + odouble=new OptionDouble; + odouble->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); + strcpy(odouble->name,name); + + /*check and parse the value */ + if (!mxIsClass(prhs[0],"double")){ + _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",odouble->name,"double",odouble->name,mxGetClassName(prhs[0])); + } + + FetchMatlabData(&odouble->values,&odouble->numel,&odouble->ndims,&odouble->size,prhs[0]); + + return(odouble); +}/*}}}*/ +/*FUNCTION OptionLogicalParse {{{1*/ +OptionLogical* OptionLogicalParse( char* name, const mxArray* prhs[]){ + + OptionLogical *ological = NULL; + + /*check and parse the name */ + ological=new OptionLogical; + ological->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); + strcpy(ological->name,name); + + /*check and parse the value */ + if (!mxIsClass(prhs[0],"logical")){ + _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ological->name,"logical",ological->name,mxGetClassName(prhs[0])); + } + + FetchMatlabData(&ological->values,&ological->numel,&ological->ndims,&ological->size,prhs[0]); + + return(ological); +}/*}}}*/ +/*FUNCTION OptionCharParse {{{1*/ +OptionChar* OptionCharParse( char* name, const mxArray* prhs[]){ + + OptionChar *ochar = NULL; + + /*check and parse the name */ + ochar=new OptionChar; + ochar->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); + strcpy(ochar->name,name); + + /*check and parse the value */ + if (!mxIsClass(prhs[0],"char")){ + _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ochar->name,"char",ochar->name,mxGetClassName(prhs[0])); + } + + FetchMatlabData(&ochar->values,&ochar->numel,&ochar->ndims,&ochar->size,prhs[0]); + + return(ochar); +}/*}}}*/ +/*FUNCTION OptionStructParse {{{1*/ +OptionStruct* OptionStructParse( char* name, const mxArray* prhs[]){ + + int i; + char namei[161]; + OptionStruct *ostruct = NULL; + Option *option = NULL; + const mwSize *ipt = NULL; + const mxArray *structi; + mwIndex sindex; + + /*check and parse the name */ + ostruct=new OptionStruct; + ostruct->name =(char*)xmalloc((strlen(name)+1)*sizeof(char)); + strcpy(ostruct->name,name); + + /*check and parse the value */ + if (!mxIsClass(prhs[0],"struct")){ + _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ostruct->name,"struct",ostruct->name,mxGetClassName(prhs[0])); + } + + ostruct->numel=mxGetNumberOfElements(prhs[0]); + ostruct->ndims=mxGetNumberOfDimensions(prhs[0]); + ipt =mxGetDimensions(prhs[0]); + ostruct->size =(int *) xmalloc(ostruct->ndims*sizeof(int)); + for (i=0; indims; i++) ostruct->size[i]=(int)ipt[i]; + if (ostruct->numel) ostruct->values=(Options**) xmalloc(ostruct->numel*sizeof(Options *)); + + /*loop through and process each element of the struct array */ + for (sindex=0; sindexnumel; sindex++) { + ostruct->values[sindex]=new Options; + + /*loop through and process each field for the element */ + for (i=0; ivalues[sindex]->AddObject((Object*)option); + option=NULL; + } + } + + return(ostruct); +}/*}}}*/ +/*FUNCTION OptionCellParse {{{1*/ +OptionCell* OptionCellParse( char* name, const mxArray* prhs[]){ + + int i; + int *dims; + char namei[161]; + char cstr[81]; + OptionCell *ocell = NULL; + Option *option = NULL; + const mwSize *ipt = NULL; + const mxArray *celli; + mwIndex cindex; + + /*check and parse the name */ + ocell=new OptionCell; + ocell->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); + strcpy(ocell->name,name); + + /*check and parse the value */ + if (!mxIsClass(prhs[0],"cell")){ + _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ocell->name,"cell",ocell->name,mxGetClassName(prhs[0])); + } + + ocell->numel=mxGetNumberOfElements(prhs[0]); + ocell->ndims=mxGetNumberOfDimensions(prhs[0]); + ipt =mxGetDimensions(prhs[0]); + ocell->size =(int *) xmalloc(ocell->ndims*sizeof(int)); + for (i=0; indims; i++) ocell->size[i]=(int)ipt[i]; + ocell->values=new Options; + + /*loop through and process each element of the cell array */ + dims=(int *) xmalloc(ocell->ndims*sizeof(int)); + for (cindex=0; cindexnumel; cindex++) { + ColumnWiseDimsFromIndex(dims,(int)cindex,ocell->size,ocell->ndims); + StringFromDims(cstr,dims,ocell->ndims); + sprintf(namei,"%s%s",name,cstr); + celli=mxGetCell(prhs[0],cindex); + + option=(Option*)OptionParse(namei,&celli); + ocell->values->AddObject((Object*)option); + option=NULL; + } + xfree((void**)&dims); + + return(ocell); +}/*}}}*/ +/*FUNCTION OptionParse{{{1*/ +Option* OptionParse(char* name, const mxArray* prhs[]){ + + Option *option = NULL; + mxArray *lhs[1]; + + /*parse the value according to the matlab data type */ + if (mxIsClass(prhs[0],"double")) option=(Option*)OptionDoubleParse(name,prhs); + else if(mxIsClass(prhs[0],"logical")) option=(Option*)OptionLogicalParse(name,prhs); + else if(mxIsClass(prhs[0],"char")) option=(Option*)OptionCharParse(name,prhs); + else if(mxIsClass(prhs[0],"struct")) option=(Option*)OptionStructParse(name,prhs); + else if(mxIsClass(prhs[0],"cell")) option=(Option*)OptionCellParse(name,prhs); + else { + _printf_(true," Converting value of option \"%s\" from unrecognized class \"%s\" to class \"%s\".\n",name,mxGetClassName(prhs[0]),"struct"); + if (!mexCallMATLAB(1,lhs,1,(mxArray**)prhs,"struct")) { + option=(Option*)OptionStructParse(name,(const mxArray**)lhs); + mxDestroyArray(lhs[0]); + } + else _error_("Second argument value of option \"%s\" is of unrecognized class \"%s\".",name,mxGetClassName(prhs[0])); + } + + return(option); +}/*}}}*/ + +#endif Index: /issm/trunk/src/c/io/Matlab/WriteMatlabData.cpp =================================================================== --- /issm/trunk/src/c/io/Matlab/WriteMatlabData.cpp (revision 8910) +++ /issm/trunk/src/c/io/Matlab/WriteMatlabData.cpp (revision 8910) @@ -0,0 +1,185 @@ +/* \file WriteMatlabData.c: + * \brief: general interface for writing data + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../../include/include.h" +#include "../../shared/shared.h" + +#ifdef _SERIAL_ +#include + +/*FUNCTION WriteMatlabData(mxArray** pdataref,DataSet* dataset){{{1*/ +void WriteMatlabData(mxArray** pdataref,DataSet* dataset){ + + mxArray* dataref=NULL; + char* marshalled_dataset=NULL; + int marshalled_dataset_size; + + /*Write a dataset: */ + if(dataset){ + /* marshall the dataset: */ + marshalled_dataset=dataset->Marshall(); + marshalled_dataset_size=dataset->MarshallSize(); + + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + mxSetM(dataref,(mwSize)(marshalled_dataset_size/sizeof(double))); + mxSetN(dataref,(mwSize)1); + mxSetPr(dataref,(double*)marshalled_dataset); + } + else{ + /* return empty matrix: */ + dataref=mxCreateDoubleMatrix(0,0,mxREAL); + } + *pdataref=dataref; + +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,Mat matrix){{{1*/ +void WriteMatlabData(mxArray** pdataref,Mat matrix){ + + mxArray* dataref=NULL; + + if(matrix){ + + /*call toolkit routine: */ + PetscMatrixToMatlabMatrix(&dataref,matrix); + } + else{ + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + } + + *pdataref=dataref; +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,double* matrix, int M,int N){{{1*/ +void WriteMatlabData(mxArray** pdataref,double* matrix, int M,int N){ + + mxArray* dataref=NULL; + mxArray* tdataref=NULL; + + if(matrix){ + + /*data is a double* pointer. Copy into a matrix: */ + tdataref = mxCreateDoubleMatrix(0,0,mxREAL); + mxSetM(tdataref,(mwSize)N); + mxSetN(tdataref,(mwSize)M); + mxSetPr(tdataref,(double*)matrix); + + //transpose + mexCallMATLAB(1,&dataref,1,&tdataref, "transpose"); + } + else{ + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + } + *pdataref=dataref; +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,Vec vector){{{1*/ +void WriteMatlabData(mxArray** pdataref,Vec vector){ + + mxArray* dataref=NULL; + + if(vector){ + + /*call toolkit routine: */ + PetscVectorToMatlabVector(&dataref,vector); + } + else{ + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + } + *pdataref=dataref; + +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,double* vector, int M){{{1*/ +void WriteMatlabData(mxArray** pdataref,double* vector, int M){ + + mxArray* dataref=NULL; + + if(vector){ + + /*data is a double* pointer. Copy into a vector: */ + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + mxSetM(dataref,(mwSize)M); + mxSetN(dataref,(mwSize)1); + mxSetPr(dataref,vector); + } + else{ + dataref = mxCreateDoubleMatrix(0,0,mxREAL); + } + + *pdataref=dataref; +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,double scalar){{{1*/ +void WriteMatlabData(mxArray** pdataref,double scalar){ + + *pdataref=mxCreateDoubleScalar(scalar); +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,int integer){{{1*/ +void WriteMatlabData(mxArray** pdataref,int integer){ + + *pdataref=mxCreateDoubleScalar((double)integer); + +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,int boolean){{{1*/ +void WriteMatlabData(mxArray** pdataref,bool boolean){ + + *pdataref=mxCreateDoubleScalar((double)boolean); + +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,char* string){{{1*/ +void WriteMatlabData(mxArray** pdataref,char* string){ + + *pdataref=mxCreateString(string); +} +/*}}}*/ +/*FUNCTION WriteMatlabData(mxArray** pdataref,Parameters* parameters){{{1*/ +void WriteMatlabData(mxArray** pdataref,Parameters* parameters){ + + int i; + + /*output: */ + mxArray* dataref=NULL; + mwSize nfields; + const char** fnames=NULL; + mwSize onebyone[2] = {1,1}; + mwSize ndim=2; + + /*intermediary: */ + Param* param=NULL; + + /*Recover data from the parameters dataset: */ + nfields=(mwSize)parameters->Size(); + fnames=(const char**)xmalloc(nfields*sizeof(char*)); + + /*Build structure in matlab workspace with all the parameter fields: */ + for(i=0;iGetObjectByOffset(i); + fnames[i]=param->GetParameterName(); + } + /*Initialize structure: */ + dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames); + + /*Fill each field: */ + for(i=0;iGetObjectByOffset(i); + param->SetMatlabField(dataref); + } + + /*Assign output pointers:*/ + *pdataref=dataref; + +} +/*}}}*/ +#endif Index: /issm/trunk/src/c/io/Matlab/matlabio.h =================================================================== --- /issm/trunk/src/c/io/Matlab/matlabio.h (revision 8910) +++ /issm/trunk/src/c/io/Matlab/matlabio.h (revision 8910) @@ -0,0 +1,54 @@ +/*\file matlabio.h + *\brief: I/O for ISSM in matlab mode + */ + +#ifndef _MATLAB_IO_H_ +#define _MATLAB_IO_H_ + +#include "../../objects/objects.h" +#include "../../Container/Container.h" +#include "../../include/include.h" + +class DataSet; +class Parameters; + +#ifdef _SERIAL_ +#include +void WriteMatlabData(mxArray** pdataref,DataSet* dataset); +void WriteMatlabData(mxArray** pdataref,Mat matrix); +void WriteMatlabData(mxArray** pdataref,double* matrix, int M,int N); +void WriteMatlabData(mxArray** pdataref,Vec vector); +void WriteMatlabData(mxArray** pdataref,double* vector, int M); +void WriteMatlabData(mxArray** pdataref,int integer); +void WriteMatlabData(mxArray** pdataref,bool boolean); +void WriteMatlabData(mxArray** pdataref,double scalar); +void WriteMatlabData(mxArray** pdataref,char* string); +void WriteMatlabData(DataHandle* pdataref,Parameters* parameters); + +void FetchMatlabData(DataSet** pdataset,const mxArray* dataref); +void FetchMatlabData(double** pmatrix,int* pM,int *pN,const mxArray* dataref); +void FetchMatlabData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); +void FetchMatlabData(int** pmatrix,int* pM,int *pN,const mxArray* dataref); +void FetchMatlabData(bool** pmatrix,int* pM,int *pN,const mxArray* dataref); +void FetchMatlabData(bool** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); +void FetchMatlabData(Mat* pmatrix,const mxArray* dataref); +void FetchMatlabData(int** pvector,int* pM,const mxArray* dataref); +void FetchMatlabData(float** pvector,int* pM,const mxArray* dataref); +void FetchMatlabData(double** pvector,int* pM,const mxArray* dataref); +void FetchMatlabData(bool** pvector,int* pM,const mxArray* dataref); +void FetchMatlabData(Vec* pvector,const mxArray* dataref); +void FetchMatlabData(char** pstring,const mxArray* dataref); +void FetchMatlabData(char** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); +void FetchMatlabData(double* pscalar,const mxArray* dataref); +void FetchMatlabData(int* pinteger,const mxArray* dataref); +void FetchMatlabData(bool* pbool,const mxArray* dataref); +void FetchMatlabData(Parameters** pparameters, DataHandle dataref); + +Option* OptionParse(char* name, const mxArray* prhs[]); +OptionDouble* OptionDoubleParse( char* name, const mxArray* prhs[]); +OptionLogical* OptionLogicalParse( char* name, const mxArray* prhs[]); +OptionChar* OptionCharParse( char* name, const mxArray* prhs[]); +OptionStruct* OptionStructParse( char* name, const mxArray* prhs[]); +OptionCell* OptionCellParse( char* name, const mxArray* prhs[]); +#endif +#endif /* _IO_H_ */ Index: sm/trunk/src/c/io/OptionParse.cpp =================================================================== --- /issm/trunk/src/c/io/OptionParse.cpp (revision 8909) +++ (revision ) @@ -1,189 +1,0 @@ -/*\file OptionParse.c - *\brief: functions to parse the mex options. - */ -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "./io.h" -#include "../shared/shared.h" -#include "../include/include.h" - -#ifdef _SERIAL_ -#include - -/*FUNCTION OptionParse{{{1*/ -Option* OptionParse(char* name, const mxArray* prhs[]){ - - Option *option = NULL; - mxArray *lhs[1]; - - /*parse the value according to the matlab data type */ - if (mxIsClass(prhs[0],"double")) option=(Option*)OptionDoubleParse(name,prhs); - else if(mxIsClass(prhs[0],"logical")) option=(Option*)OptionLogicalParse(name,prhs); - else if(mxIsClass(prhs[0],"char")) option=(Option*)OptionCharParse(name,prhs); - else if(mxIsClass(prhs[0],"struct")) option=(Option*)OptionStructParse(name,prhs); - else if(mxIsClass(prhs[0],"cell")) option=(Option*)OptionCellParse(name,prhs); - else { - _printf_(true," Converting value of option \"%s\" from unrecognized class \"%s\" to class \"%s\".\n",name,mxGetClassName(prhs[0]),"struct"); - if (!mexCallMATLAB(1,lhs,1,(mxArray**)prhs,"struct")) { - option=(Option*)OptionStructParse(name,(const mxArray**)lhs); - mxDestroyArray(lhs[0]); - } - else _error_("Second argument value of option \"%s\" is of unrecognized class \"%s\".",name,mxGetClassName(prhs[0])); - } - - return(option); -}/*}}}*/ -/*FUNCTION OptionDoubleParse {{{1*/ -OptionDouble* OptionDoubleParse( char* name, const mxArray* prhs[]){ - - OptionDouble *odouble = NULL; - - /*check and parse the name */ - odouble=new OptionDouble; - odouble->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); - strcpy(odouble->name,name); - - /*check and parse the value */ - if (!mxIsClass(prhs[0],"double")){ - _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",odouble->name,"double",odouble->name,mxGetClassName(prhs[0])); - } - - FetchData(&odouble->values,&odouble->numel,&odouble->ndims,&odouble->size,prhs[0]); - - return(odouble); -}/*}}}*/ -/*FUNCTION OptionLogicalParse {{{1*/ -OptionLogical* OptionLogicalParse( char* name, const mxArray* prhs[]){ - - OptionLogical *ological = NULL; - - /*check and parse the name */ - ological=new OptionLogical; - ological->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); - strcpy(ological->name,name); - - /*check and parse the value */ - if (!mxIsClass(prhs[0],"logical")){ - _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ological->name,"logical",ological->name,mxGetClassName(prhs[0])); - } - - FetchData(&ological->values,&ological->numel,&ological->ndims,&ological->size,prhs[0]); - - return(ological); -}/*}}}*/ -/*FUNCTION OptionCharParse {{{1*/ -OptionChar* OptionCharParse( char* name, const mxArray* prhs[]){ - - OptionChar *ochar = NULL; - - /*check and parse the name */ - ochar=new OptionChar; - ochar->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); - strcpy(ochar->name,name); - - /*check and parse the value */ - if (!mxIsClass(prhs[0],"char")){ - _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ochar->name,"char",ochar->name,mxGetClassName(prhs[0])); - } - - FetchData(&ochar->values,&ochar->numel,&ochar->ndims,&ochar->size,prhs[0]); - - return(ochar); -}/*}}}*/ -/*FUNCTION OptionStructParse {{{1*/ -OptionStruct* OptionStructParse( char* name, const mxArray* prhs[]){ - - int i; - char namei[161]; - OptionStruct *ostruct = NULL; - Option *option = NULL; - const mwSize *ipt = NULL; - const mxArray *structi; - mwIndex sindex; - - /*check and parse the name */ - ostruct=new OptionStruct; - ostruct->name =(char*)xmalloc((strlen(name)+1)*sizeof(char)); - strcpy(ostruct->name,name); - - /*check and parse the value */ - if (!mxIsClass(prhs[0],"struct")){ - _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ostruct->name,"struct",ostruct->name,mxGetClassName(prhs[0])); - } - - ostruct->numel=mxGetNumberOfElements(prhs[0]); - ostruct->ndims=mxGetNumberOfDimensions(prhs[0]); - ipt =mxGetDimensions(prhs[0]); - ostruct->size =(int *) xmalloc(ostruct->ndims*sizeof(int)); - for (i=0; indims; i++) ostruct->size[i]=(int)ipt[i]; - if (ostruct->numel) ostruct->values=(Options**) xmalloc(ostruct->numel*sizeof(Options *)); - - /*loop through and process each element of the struct array */ - for (sindex=0; sindexnumel; sindex++) { - ostruct->values[sindex]=new Options; - - /*loop through and process each field for the element */ - for (i=0; ivalues[sindex]->AddObject((Object*)option); - option=NULL; - } - } - - return(ostruct); -}/*}}}*/ -/*FUNCTION OptionCellParse {{{1*/ -OptionCell* OptionCellParse( char* name, const mxArray* prhs[]){ - - int i; - int *dims; - char namei[161]; - char cstr[81]; - OptionCell *ocell = NULL; - Option *option = NULL; - const mwSize *ipt = NULL; - const mxArray *celli; - mwIndex cindex; - - /*check and parse the name */ - ocell=new OptionCell; - ocell->name =(char *) xmalloc((strlen(name)+1)*sizeof(char)); - strcpy(ocell->name,name); - - /*check and parse the value */ - if (!mxIsClass(prhs[0],"cell")){ - _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ocell->name,"cell",ocell->name,mxGetClassName(prhs[0])); - } - - ocell->numel=mxGetNumberOfElements(prhs[0]); - ocell->ndims=mxGetNumberOfDimensions(prhs[0]); - ipt =mxGetDimensions(prhs[0]); - ocell->size =(int *) xmalloc(ocell->ndims*sizeof(int)); - for (i=0; indims; i++) ocell->size[i]=(int)ipt[i]; - ocell->values=new Options; - - /*loop through and process each element of the cell array */ - dims=(int *) xmalloc(ocell->ndims*sizeof(int)); - for (cindex=0; cindexnumel; cindex++) { - ColumnWiseDimsFromIndex(dims,(int)cindex,ocell->size,ocell->ndims); - StringFromDims(cstr,dims,ocell->ndims); - sprintf(namei,"%s%s",name,cstr); - celli=mxGetCell(prhs[0],cindex); - - option=(Option*)OptionParse(namei,&celli); - ocell->values->AddObject((Object*)option); - option=NULL; - } - xfree((void**)&dims); - - return(ocell); -}/*}}}*/ - -#endif Index: sm/trunk/src/c/io/WriteData.cpp =================================================================== --- /issm/trunk/src/c/io/WriteData.cpp (revision 8909) +++ (revision ) @@ -1,155 +1,0 @@ -/* \file WriteData.c: - * \brief: general interface for writing data - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "../include/include.h" -#include "./shared/shared.h" -#include "./io.h" - -#ifdef _SERIAL_ -#include -/*Several prototypes for WriteData, according to type: */ -/*FUNCTION WriteData(mxArray** pdataref,DataSet* dataset){{{1*/ -void WriteData(mxArray** pdataref,DataSet* dataset){ - - mxArray* dataref=NULL; - char* marshalled_dataset=NULL; - int marshalled_dataset_size; - - /*Write a dataset: */ - if(dataset){ - /* marshall the dataset: */ - marshalled_dataset=dataset->Marshall(); - marshalled_dataset_size=dataset->MarshallSize(); - - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - mxSetM(dataref,(mwSize)(marshalled_dataset_size/sizeof(double))); - mxSetN(dataref,(mwSize)1); - mxSetPr(dataref,(double*)marshalled_dataset); - } - else{ - /* return empty matrix: */ - dataref=mxCreateDoubleMatrix(0,0,mxREAL); - } - *pdataref=dataref; - -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,Mat matrix){{{1*/ -void WriteData(mxArray** pdataref,Mat matrix){ - - mxArray* dataref=NULL; - - if(matrix){ - - /*call toolkit routine: */ - PetscMatrixToMatlabMatrix(&dataref,matrix); - } - else{ - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - } - - *pdataref=dataref; -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,double* matrix, int M,int N){{{1*/ -void WriteData(mxArray** pdataref,double* matrix, int M,int N){ - - mxArray* dataref=NULL; - mxArray* tdataref=NULL; - - if(matrix){ - - /*data is a double* pointer. Copy into a matrix: */ - tdataref = mxCreateDoubleMatrix(0,0,mxREAL); - mxSetM(tdataref,(mwSize)N); - mxSetN(tdataref,(mwSize)M); - mxSetPr(tdataref,(double*)matrix); - - //transpose - mexCallMATLAB(1,&dataref,1,&tdataref, "transpose"); - } - else{ - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - } - *pdataref=dataref; -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,Vec vector){{{1*/ -void WriteData(mxArray** pdataref,Vec vector){ - - mxArray* dataref=NULL; - - if(vector){ - - /*call toolkit routine: */ - PetscVectorToMatlabVector(&dataref,vector); - } - else{ - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - } - *pdataref=dataref; - -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,double* vector, int M){{{1*/ -void WriteData(mxArray** pdataref,double* vector, int M){ - - mxArray* dataref=NULL; - - if(vector){ - - /*data is a double* pointer. Copy into a vector: */ - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - mxSetM(dataref,(mwSize)M); - mxSetN(dataref,(mwSize)1); - mxSetPr(dataref,vector); - } - else{ - dataref = mxCreateDoubleMatrix(0,0,mxREAL); - } - - *pdataref=dataref; -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,double scalar){{{1*/ -void WriteData(mxArray** pdataref,double scalar){ - - *pdataref=mxCreateDoubleScalar(scalar); -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,int integer){{{1*/ -void WriteData(mxArray** pdataref,int integer){ - - *pdataref=mxCreateDoubleScalar((double)integer); - -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,int boolean){{{1*/ -void WriteData(mxArray** pdataref,bool boolean){ - - *pdataref=mxCreateDoubleScalar((double)boolean); - -} -/*}}}*/ -/*FUNCTION WriteData(mxArray** pdataref,char* string){{{1*/ -void WriteData(mxArray** pdataref,char* string){ - - *pdataref=mxCreateString(string); -} -/*}}}*/ - -#else -/*FUNCTION WriteData(int* pdummy,void* data,char* data_type){{{1*/ -void WriteData(int* pdummy,void* data,char* data_type){ - - /*In parallel mode, WriteData is not used, instead we access the data directly through pointers in the solution sequences. */ -} -/*}}}*/ -#endif Index: sm/trunk/src/c/io/WriteNodeSets.cpp =================================================================== --- /issm/trunk/src/c/io/WriteNodeSets.cpp (revision 8909) +++ (revision ) @@ -1,90 +1,0 @@ -/* \file WriteNodeSets.c: - * \brief: interface for writing nodesets to matlab workspace - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#ifdef _SERIAL_ -#include - -#include "../objects/NodeSets.h" -#include "./io.h" -#include "../shared/shared.h" - -void WriteNodeSets(DataHandle* pdataref,NodeSets* nodesets){ - - /*output: */ - mxArray* dataref=NULL; - int gsize=0; - int fsize=0; - int ssize=0; - const mwSize nfields=5; - const char* fnames[nfields]; - mwSize onebyone[2] = {1,1}; - mwSize ndim=2; - - - /*intermediary: */ - double* pv_f=NULL; - double* pv_s=NULL; - mxArray* field=NULL; - - if(nodesets){ - /*Recover data from the nodesets class: */ - gsize=nodesets->GetGSize(); - fsize=nodesets->GetFSize(); - ssize=nodesets->GetSSize(); - - if(fsize){ - pv_f=(double*)xmalloc(fsize*sizeof(double)); - memcpy(pv_f,nodesets->GetPV_F(),fsize*sizeof(double)); - } - if(ssize){ - pv_s=(double*)xmalloc(ssize*sizeof(double)); - memcpy(pv_s,nodesets->GetPV_S(),ssize*sizeof(double)); - } - - /*Build structure in matlab workspace with all these fields: */ - fnames[0] = "gsize"; - fnames[1] = "fsize"; - fnames[2] = "ssize"; - fnames[3] = "pv_f"; - fnames[4] = "pv_s"; - - dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames); - - mxSetField( dataref, 0, "gsize",mxCreateDoubleScalar((double)gsize)); - mxSetField( dataref, 0, "fsize",mxCreateDoubleScalar((double)fsize)); - mxSetField( dataref, 0, "ssize",mxCreateDoubleScalar((double)ssize)); - - if(fsize){ - field = mxCreateDoubleMatrix(0,0,mxREAL); - mxSetM(field,fsize); mxSetN(field,1); mxSetPr(field,pv_f); - } - else{ - field = mxCreateDoubleMatrix(0,0,mxREAL); - } - mxSetField( dataref, 0, "pv_f",field); - - if(ssize){ - field = mxCreateDoubleMatrix(0,0,mxREAL); - mxSetM(field,ssize); mxSetN(field,1); mxSetPr(field,pv_s); - } - else{ - field = mxCreateDoubleMatrix(0,0,mxREAL); - } - mxSetField( dataref, 0, "pv_s",field); - } - else{ - dataref=mxCreateDoubleMatrix(0,0,mxREAL); - } - - /*Assign output pointers:*/ - *pdataref=dataref; - -} -#endif Index: sm/trunk/src/c/io/WriteParams.cpp =================================================================== --- /issm/trunk/src/c/io/WriteParams.cpp (revision 8909) +++ (revision ) @@ -1,57 +1,0 @@ -/* \file WriteParams.c: - * \brief: interface for writing parameters dataset into a matlab structure - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - - -#ifdef _SERIAL_ -#include - -#include "./io.h" -#include "../objects/objects.h" -#include "../shared/shared.h" -#include "../include/include.h" - -void WriteParams(DataHandle* pdataref,Parameters* parameters){ - - int i; - - /*output: */ - mxArray* dataref=NULL; - mwSize nfields; - const char** fnames=NULL; - mwSize onebyone[2] = {1,1}; - mwSize ndim=2; - - /*intermediary: */ - Param* param=NULL; - - /*Recover data from the parameters dataset: */ - nfields=(mwSize)parameters->Size(); - fnames=(const char**)xmalloc(nfields*sizeof(char*)); - - /*Build structure in matlab workspace with all the parameter fields: */ - for(i=0;iGetObjectByOffset(i); - fnames[i]=param->GetParameterName(); - } - /*Initialize structure: */ - dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames); - - /*Fill each field: */ - for(i=0;iGetObjectByOffset(i); - param->SetMatlabField(dataref); - } - - /*Assign output pointers:*/ - *pdataref=dataref; - -} -#endif Index: /issm/trunk/src/c/io/io.h =================================================================== --- /issm/trunk/src/c/io/io.h (revision 8909) +++ /issm/trunk/src/c/io/io.h (revision 8910) @@ -6,64 +6,6 @@ #define _IO_H_ -#include "../objects/objects.h" -#include "../Container/Container.h" -#include "../include/include.h" +#include "./Disk/diskio.h" +#include "./Matlab/matlabio.h" -class DataSet; -class Parameters; - -FILE* pfopen(char* filename,char* format); -void pfclose(FILE* fid,char* filename); - -void FetchData(double** pmatrix, int* pM,int* pN,FILE* fid); -void FetchData(char** pstring,FILE* fid); -void FetchData(double* pscalar,FILE* fid); -void FetchData(int* pinteger,FILE* fid); - -void IoModelFetchData(double** pmatrix,int* pM,int* pN,FILE* model_handle,char* data_name); -void IoModelFetchData(char** pstring,FILE* model_handle,char* data_name); -void IoModelFetchData(double* pscalar,FILE* model_handle,char* data_name); -void IoModelFetchData(int* pinteger,FILE* model_handle,char* data_name); -FILE* SetFilePointerToData(FILE* model_handle,char* data_name); - -#ifdef _SERIAL_ -void WriteData(mxArray** pdataref,DataSet* dataset); -void WriteData(mxArray** pdataref,Mat matrix); -void WriteData(mxArray** pdataref,double* matrix, int M,int N); -void WriteData(mxArray** pdataref,Vec vector); -void WriteData(mxArray** pdataref,double* vector, int M); -void WriteData(mxArray** pdataref,int integer); -void WriteData(mxArray** pdataref,bool boolean); -void WriteData(mxArray** pdataref,double scalar); -void WriteData(mxArray** pdataref,char* string); -void WriteNodeSets(DataHandle* pdataref,NodeSets* nodesets); -void WriteParams(DataHandle* pdataref,Parameters* parameters); - -void FetchData(DataSet** pdataset,const mxArray* dataref); -void FetchData(double** pmatrix,int* pM,int *pN,const mxArray* dataref); -void FetchData(double** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); -void FetchData(int** pmatrix,int* pM,int *pN,const mxArray* dataref); -void FetchData(bool** pmatrix,int* pM,int *pN,const mxArray* dataref); -void FetchData(bool** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); -void FetchData(Mat* pmatrix,const mxArray* dataref); -void FetchData(int** pvector,int* pM,const mxArray* dataref); -void FetchData(float** pvector,int* pM,const mxArray* dataref); -void FetchData(double** pvector,int* pM,const mxArray* dataref); -void FetchData(bool** pvector,int* pM,const mxArray* dataref); -void FetchData(Vec* pvector,const mxArray* dataref); -void FetchData(char** pstring,const mxArray* dataref); -void FetchData(char** pmatrix,int* pnumel,int* pndims,int** psize,const mxArray* dataref); -void FetchData(double* pscalar,const mxArray* dataref); -void FetchData(int* pinteger,const mxArray* dataref); -void FetchData(bool* pbool,const mxArray* dataref); -void FetchNodeSets(NodeSets** pnodesets,ConstDataHandle dataref); -void FetchParams(Parameters** pparameters, DataHandle dataref); - -Option* OptionParse(char* name, const mxArray* prhs[]); -OptionDouble* OptionDoubleParse( char* name, const mxArray* prhs[]); -OptionLogical* OptionLogicalParse( char* name, const mxArray* prhs[]); -OptionChar* OptionCharParse( char* name, const mxArray* prhs[]); -OptionStruct* OptionStructParse( char* name, const mxArray* prhs[]); -OptionCell* OptionCellParse( char* name, const mxArray* prhs[]); -#endif #endif /* _IO_H_ */ Index: sm/trunk/src/c/io/pfclose.cpp =================================================================== --- /issm/trunk/src/c/io/pfclose.cpp (revision 8909) +++ (revision ) @@ -1,21 +1,0 @@ -/*!\file: pfclose.cpp - * \brief fclose wrapper for parallel solution - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "stdio.h" -#include "../shared/shared.h" -#include "../include/include.h" - -void pfclose(FILE* fid,char* filename){ - - /*Close file handle: */ - extern int my_rank; - _assert_(fid); - if(fclose(fid)!=0)_error_("%s%s","could not close file ",filename); -} Index: sm/trunk/src/c/io/pfopen.cpp =================================================================== --- /issm/trunk/src/c/io/pfopen.cpp (revision 8909) +++ (revision ) @@ -1,26 +1,0 @@ -/*!\file: pfopen.cpp - * \brief fopen wrapper for parallel solution - */ - -#ifdef HAVE_CONFIG_H - #include "config.h" -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "stdio.h" -#include "../shared/shared.h" -#include "../include/include.h" - -FILE* pfopen(char* filename,char* format){ - - FILE* fid=NULL; - extern int my_rank; - - /*Open handle to data on disk: */ - fid=fopen(filename,format); - if(fid==NULL) _error_("%s%s%s","could not open file ",filename," for binary reading or writing"); - - return fid; -} - Index: /issm/trunk/src/c/objects/Bamg/BamgGeom.cpp =================================================================== --- /issm/trunk/src/c/objects/Bamg/BamgGeom.cpp (revision 8909) +++ /issm/trunk/src/c/objects/Bamg/BamgGeom.cpp (revision 8910) @@ -22,12 +22,12 @@ BamgGeom::BamgGeom(mxArray* matlab_struct){ - FetchData(&this->Vertices, &this->VerticesSize[0], &this->VerticesSize[1], mxGetAssignedField(matlab_struct,0,"Vertices")); - FetchData(&this->Edges, &this->EdgesSize[0], &this->EdgesSize[1], mxGetAssignedField(matlab_struct,0,"Edges")); + FetchMatlabData(&this->Vertices, &this->VerticesSize[0], &this->VerticesSize[1], mxGetAssignedField(matlab_struct,0,"Vertices")); + FetchMatlabData(&this->Edges, &this->EdgesSize[0], &this->EdgesSize[1], mxGetAssignedField(matlab_struct,0,"Edges")); this->TangentAtEdgesSize[0]=0, this->TangentAtEdgesSize[1]=0; this->TangentAtEdges=NULL; - FetchData(&this->Corners, &this->CornersSize[0], &this->CornersSize[1], mxGetAssignedField(matlab_struct,0,"Corners")); - FetchData(&this->RequiredVertices,&this->RequiredVerticesSize[0],&this->RequiredVerticesSize[1],mxGetAssignedField(matlab_struct,0,"RequiredVertices")); - FetchData(&this->RequiredEdges, &this->RequiredEdgesSize[0], &this->RequiredEdgesSize[1], mxGetAssignedField(matlab_struct,0,"RequiredEdges")); - FetchData(&this->CrackedEdges, &this->CrackedEdgesSize[0], &this->CrackedEdgesSize[1], mxGetAssignedField(matlab_struct,0,"CrackedEdges")); - FetchData(&this->SubDomains, &this->SubDomainsSize[0], &this->SubDomainsSize[1], mxGetAssignedField(matlab_struct,0,"SubDomains")); + FetchMatlabData(&this->Corners, &this->CornersSize[0], &this->CornersSize[1], mxGetAssignedField(matlab_struct,0,"Corners")); + FetchMatlabData(&this->RequiredVertices,&this->RequiredVerticesSize[0],&this->RequiredVerticesSize[1],mxGetAssignedField(matlab_struct,0,"RequiredVertices")); + FetchMatlabData(&this->RequiredEdges, &this->RequiredEdgesSize[0], &this->RequiredEdgesSize[1], mxGetAssignedField(matlab_struct,0,"RequiredEdges")); + FetchMatlabData(&this->CrackedEdges, &this->CrackedEdgesSize[0], &this->CrackedEdgesSize[1], mxGetAssignedField(matlab_struct,0,"CrackedEdges")); + FetchMatlabData(&this->SubDomains, &this->SubDomainsSize[0], &this->SubDomainsSize[1], mxGetAssignedField(matlab_struct,0,"SubDomains")); } Index: /issm/trunk/src/c/objects/Bamg/BamgMesh.cpp =================================================================== --- /issm/trunk/src/c/objects/Bamg/BamgMesh.cpp (revision 8909) +++ /issm/trunk/src/c/objects/Bamg/BamgMesh.cpp (revision 8910) @@ -37,7 +37,7 @@ int lines,cols; - FetchData(&this->Vertices, &this->VerticesSize[0], &this->VerticesSize[1], mxGetAssignedField(matlab_struct,0,"Vertices")); - FetchData(&this->Edges, &this->EdgesSize[0], &this->EdgesSize[1], mxGetAssignedField(matlab_struct,0,"Edges")); - FetchData(&this->Triangles, &this->TrianglesSize[0], &this->TrianglesSize[1], mxGetAssignedField(matlab_struct,0,"Triangles")); + FetchMatlabData(&this->Vertices, &this->VerticesSize[0], &this->VerticesSize[1], mxGetAssignedField(matlab_struct,0,"Vertices")); + FetchMatlabData(&this->Edges, &this->EdgesSize[0], &this->EdgesSize[1], mxGetAssignedField(matlab_struct,0,"Edges")); + FetchMatlabData(&this->Triangles, &this->TrianglesSize[0], &this->TrianglesSize[1], mxGetAssignedField(matlab_struct,0,"Triangles")); this->QuadrilateralsSize[0]=0, this->QuadrilateralsSize[1]=0; this->Quadrilaterals=NULL; @@ -45,12 +45,12 @@ this->SubDomainsFromGeomSize[0]=0, this->SubDomainsFromGeomSize[1]=0; this->SubDomainsFromGeom=NULL; this->CrackedVerticesSize[0]=0, this->CrackedVerticesSize[1]=0; this->CrackedVertices=NULL; - FetchData(&this->CrackedEdges, &this->CrackedEdgesSize[0], &this->CrackedEdgesSize[1], mxGetAssignedField(matlab_struct,0,"CrackedEdges")); + FetchMatlabData(&this->CrackedEdges, &this->CrackedEdgesSize[0], &this->CrackedEdgesSize[1], mxGetAssignedField(matlab_struct,0,"CrackedEdges")); - FetchData(&this->VerticesOnGeomEdge, &this->VerticesOnGeomEdgeSize[0], &this->VerticesOnGeomEdgeSize[1], mxGetAssignedField(matlab_struct,0,"VerticesOnGeomEdge")); - FetchData(&this->VerticesOnGeomVertex,&this->VerticesOnGeomVertexSize[0],&this->VerticesOnGeomVertexSize[1],mxGetAssignedField(matlab_struct,0,"VerticesOnGeomVertex")); - FetchData(&this->EdgesOnGeomEdge, &this->EdgesOnGeomEdgeSize[0], &this->EdgesOnGeomEdgeSize[1], mxGetAssignedField(matlab_struct,0,"EdgesOnGeomEdge")); + FetchMatlabData(&this->VerticesOnGeomEdge, &this->VerticesOnGeomEdgeSize[0], &this->VerticesOnGeomEdgeSize[1], mxGetAssignedField(matlab_struct,0,"VerticesOnGeomEdge")); + FetchMatlabData(&this->VerticesOnGeomVertex,&this->VerticesOnGeomVertexSize[0],&this->VerticesOnGeomVertexSize[1],mxGetAssignedField(matlab_struct,0,"VerticesOnGeomVertex")); + FetchMatlabData(&this->EdgesOnGeomEdge, &this->EdgesOnGeomEdgeSize[0], &this->EdgesOnGeomEdgeSize[1], mxGetAssignedField(matlab_struct,0,"EdgesOnGeomEdge")); this->IssmEdgesSize[0]=0, this->IssmEdgesSize[1]=0; this->IssmEdges=NULL; - FetchData(&this->IssmSegments, &this->IssmSegmentsSize[0], &this->IssmSegmentsSize[1], mxGetAssignedField(matlab_struct,0,"IssmSegments")); + FetchMatlabData(&this->IssmSegments, &this->IssmSegmentsSize[0], &this->IssmSegmentsSize[1], mxGetAssignedField(matlab_struct,0,"IssmSegments")); this->ElementConnectivitySize[0]=0, this->ElementConnectivitySize[1]=0; this->ElementConnectivity=NULL; Index: /issm/trunk/src/c/objects/Bamg/BamgOpts.cpp =================================================================== --- /issm/trunk/src/c/objects/Bamg/BamgOpts.cpp (revision 8909) +++ /issm/trunk/src/c/objects/Bamg/BamgOpts.cpp (revision 8910) @@ -45,33 +45,33 @@ BamgOpts::BamgOpts(mxArray* matlab_struct){ - FetchData(&this->anisomax,mxGetField(matlab_struct,0,"anisomax")); - FetchData(&this->cutoff,mxGetField(matlab_struct,0,"cutoff")); - FetchData(&this->coeff,mxGetField(matlab_struct,0,"coeff")); - FetchData(&this->errg,mxGetField(matlab_struct,0,"errg")); - FetchData(&this->gradation,mxGetField(matlab_struct,0,"gradation")); - FetchData(&this->Hessiantype,mxGetField(matlab_struct,0,"Hessiantype")); - FetchData(&this->MaxCornerAngle,mxGetField(matlab_struct,0,"MaxCornerAngle")); - FetchData(&this->maxnbv,mxGetField(matlab_struct,0,"maxnbv")); - FetchData(&this->maxsubdiv,mxGetField(matlab_struct,0,"maxsubdiv")); - FetchData(&this->Metrictype,mxGetField(matlab_struct,0,"Metrictype")); - FetchData(&this->nbjacobi,mxGetField(matlab_struct,0,"nbjacobi")); - FetchData(&this->nbsmooth,mxGetField(matlab_struct,0,"nbsmooth")); - FetchData(&this->omega,mxGetField(matlab_struct,0,"omega")); - FetchData(&this->power,mxGetField(matlab_struct,0,"power")); - FetchData(&this->verbose,mxGetField(matlab_struct,0,"verbose")); + FetchMatlabData(&this->anisomax,mxGetField(matlab_struct,0,"anisomax")); + FetchMatlabData(&this->cutoff,mxGetField(matlab_struct,0,"cutoff")); + FetchMatlabData(&this->coeff,mxGetField(matlab_struct,0,"coeff")); + FetchMatlabData(&this->errg,mxGetField(matlab_struct,0,"errg")); + FetchMatlabData(&this->gradation,mxGetField(matlab_struct,0,"gradation")); + FetchMatlabData(&this->Hessiantype,mxGetField(matlab_struct,0,"Hessiantype")); + FetchMatlabData(&this->MaxCornerAngle,mxGetField(matlab_struct,0,"MaxCornerAngle")); + FetchMatlabData(&this->maxnbv,mxGetField(matlab_struct,0,"maxnbv")); + FetchMatlabData(&this->maxsubdiv,mxGetField(matlab_struct,0,"maxsubdiv")); + FetchMatlabData(&this->Metrictype,mxGetField(matlab_struct,0,"Metrictype")); + FetchMatlabData(&this->nbjacobi,mxGetField(matlab_struct,0,"nbjacobi")); + FetchMatlabData(&this->nbsmooth,mxGetField(matlab_struct,0,"nbsmooth")); + FetchMatlabData(&this->omega,mxGetField(matlab_struct,0,"omega")); + FetchMatlabData(&this->power,mxGetField(matlab_struct,0,"power")); + FetchMatlabData(&this->verbose,mxGetField(matlab_struct,0,"verbose")); - FetchData(&this->Crack,mxGetField(matlab_struct,0,"Crack")); - FetchData(&this->geometricalmetric,mxGetField(matlab_struct,0,"geometricalmetric")); - FetchData(&this->KeepVertices,mxGetField(matlab_struct,0,"KeepVertices")); - FetchData(&this->splitcorners,mxGetField(matlab_struct,0,"splitcorners")); + FetchMatlabData(&this->Crack,mxGetField(matlab_struct,0,"Crack")); + FetchMatlabData(&this->geometricalmetric,mxGetField(matlab_struct,0,"geometricalmetric")); + FetchMatlabData(&this->KeepVertices,mxGetField(matlab_struct,0,"KeepVertices")); + FetchMatlabData(&this->splitcorners,mxGetField(matlab_struct,0,"splitcorners")); - FetchData(&this->hmin,mxGetField(matlab_struct,0,"hmin")); - FetchData(&this->hmax,mxGetField(matlab_struct,0,"hmax")); - FetchData(&this->hminVertices,&this->hminVerticesSize[0],&this->hminVerticesSize[1],mxGetField(matlab_struct,0,"hminVertices")); - FetchData(&this->hmaxVertices,&this->hmaxVerticesSize[0],&this->hmaxVerticesSize[1],mxGetField(matlab_struct,0,"hmaxVertices")); - FetchData(&this->hVertices,&this->hVerticesSize[0],&this->hVerticesSize[1],mxGetField(matlab_struct,0,"hVertices")); - FetchData(&this->metric,&this->metricSize[0],&this->metricSize[1],mxGetField(matlab_struct,0,"metric")); - FetchData(&this->field,&this->fieldSize[0],&this->fieldSize[1],mxGetField(matlab_struct,0,"field")); - FetchData(&this->err,&this->errSize[0],&this->errSize[1],mxGetField(matlab_struct,0,"err")); + FetchMatlabData(&this->hmin,mxGetField(matlab_struct,0,"hmin")); + FetchMatlabData(&this->hmax,mxGetField(matlab_struct,0,"hmax")); + FetchMatlabData(&this->hminVertices,&this->hminVerticesSize[0],&this->hminVerticesSize[1],mxGetField(matlab_struct,0,"hminVertices")); + FetchMatlabData(&this->hmaxVertices,&this->hmaxVerticesSize[0],&this->hmaxVerticesSize[1],mxGetField(matlab_struct,0,"hmaxVertices")); + FetchMatlabData(&this->hVertices,&this->hVerticesSize[0],&this->hVerticesSize[1],mxGetField(matlab_struct,0,"hVertices")); + FetchMatlabData(&this->metric,&this->metricSize[0],&this->metricSize[1],mxGetField(matlab_struct,0,"metric")); + FetchMatlabData(&this->field,&this->fieldSize[0],&this->fieldSize[1],mxGetField(matlab_struct,0,"field")); + FetchMatlabData(&this->err,&this->errSize[0],&this->errSize[1],mxGetField(matlab_struct,0,"err")); /*Additional checks*/ Index: /issm/trunk/src/mex/AddExternalResult/AddExternalResult.cpp =================================================================== --- /issm/trunk/src/mex/AddExternalResult/AddExternalResult.cpp (revision 8909) +++ /issm/trunk/src/mex/AddExternalResult/AddExternalResult.cpp (revision 8910) @@ -19,7 +19,7 @@ /*Input datasets: */ - FetchData(&results,RESULTS); - FetchData(&type,TYPE); - FetchData(&value,&nraws,&ncols,VALUE); + FetchMatlabData(&results,RESULTS); + FetchMatlabData(&type,TYPE); + FetchMatlabData(&value,&nraws,&ncols,VALUE); /*results might be NILL, allocate: */ @@ -38,5 +38,5 @@ /*write output datasets: */ - WriteData(RESULTSOUT,results); + WriteMatlabData(RESULTSOUT,results); /*Free ressources: */ Index: /issm/trunk/src/mex/AverageFilter/AverageFilter.cpp =================================================================== --- /issm/trunk/src/mex/AverageFilter/AverageFilter.cpp (revision 8909) +++ /issm/trunk/src/mex/AverageFilter/AverageFilter.cpp (revision 8910) @@ -37,6 +37,6 @@ /*Fetch data: */ - FetchData(&imagein,&imagein_rows,&imagein_cols,IMAGEIN); - FetchData(&smooth,SMOOTH); + FetchMatlabData(&imagein,&imagein_rows,&imagein_cols,IMAGEIN); + FetchMatlabData(&smooth,SMOOTH); /*Run core hole filler routine: */ @@ -44,5 +44,5 @@ /* output: */ - WriteData(IMAGEOUT,imageout,imagein_rows,imagein_cols); + WriteMatlabData(IMAGEOUT,imageout,imagein_rows,imagein_cols); /*end module: */ Index: /issm/trunk/src/mex/BamgConvertMesh/BamgConvertMesh.cpp =================================================================== --- /issm/trunk/src/mex/BamgConvertMesh/BamgConvertMesh.cpp (revision 8909) +++ /issm/trunk/src/mex/BamgConvertMesh/BamgConvertMesh.cpp (revision 8910) @@ -38,7 +38,7 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs\n"); - FetchData(&index,&nels,&index_rows,INDEXHANDLE); - FetchData(&x,&nods,&x_cols,XHANDLE); - FetchData(&y,&y_rows,&y_cols,YHANDLE); + FetchMatlabData(&index,&nels,&index_rows,INDEXHANDLE); + FetchMatlabData(&x,&nods,&x_cols,XHANDLE); + FetchMatlabData(&y,&y_rows,&y_cols,YHANDLE); /*Check inputs*/ Index: /issm/trunk/src/mex/Chaco/Chaco.cpp =================================================================== --- /issm/trunk/src/mex/Chaco/Chaco.cpp (revision 8909) +++ /issm/trunk/src/mex/Chaco/Chaco.cpp (revision 8910) @@ -74,17 +74,17 @@ /*Fetch rest of data: */ - FetchData(&vwgts,&nterms,VWGTS_IN); + FetchMatlabData(&vwgts,&nterms,VWGTS_IN); - FetchData(&x,&nterms,X_IN); - FetchData(&y,&nterms,Y_IN); - FetchData(&z,&nterms,Z_IN); + FetchMatlabData(&x,&nterms,X_IN); + FetchMatlabData(&y,&nterms,Y_IN); + FetchMatlabData(&z,&nterms,Z_IN); - FetchData(&in_options,&nterms,OPTNS_IN); + FetchMatlabData(&in_options,&nterms,OPTNS_IN); for (i=0;i<(nterms<10?nterms:10);i++) options[i]=in_options[i]; //copy in_options into default options - FetchData(&npart,NPARTS_IN); + FetchMatlabData(&npart,NPARTS_IN); nparts=(int*)xmalloc(sizeof(int)); nparts[0]=npart; //weird Chacox interface ain't it? - FetchData(&goal,&nterms,GOAL_IN); + FetchMatlabData(&goal,&nterms,GOAL_IN); /*Some debugging print: {{{*/ @@ -120,5 +120,5 @@ doubleassignment=(double*)xmalloc(nvtxs*sizeof(double)); for (i=0;i=7){ /*default values: */ - FetchData(&default_values,&num_default_values,DEFAULTHANDLE); + FetchMatlabData(&default_values,&num_default_values,DEFAULTHANDLE); } else{ @@ -146,5 +146,5 @@ /*Write data: */ - WriteData(DATAPRIME,data_prime); + WriteMatlabData(DATAPRIME,data_prime); /*end module: */ Index: /issm/trunk/src/mex/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp =================================================================== --- /issm/trunk/src/mex/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp (revision 8909) +++ /issm/trunk/src/mex/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp (revision 8910) @@ -35,15 +35,15 @@ /*Input datasets: */ - FetchData(&index,&nel,NULL,INDEX); - FetchData(&x,&nods,NULL,X); - FetchData(&y,NULL,NULL,Y); - FetchData(&meshdata,&meshdata_length,NULL,MESHDATA); - FetchData(&cornereast,CORNEREAST); - FetchData(&cornernorth,CORNERNORTH); - FetchData(&xposting,XPOSTING); - FetchData(&yposting,YPOSTING); - FetchData(&nlines,NLINES); - FetchData(&ncols,NCOLS); - FetchData(&default_value,DEFAULTVALUE); + FetchMatlabData(&index,&nel,NULL,INDEX); + FetchMatlabData(&x,&nods,NULL,X); + FetchMatlabData(&y,NULL,NULL,Y); + FetchMatlabData(&meshdata,&meshdata_length,NULL,MESHDATA); + FetchMatlabData(&cornereast,CORNEREAST); + FetchMatlabData(&cornernorth,CORNERNORTH); + FetchMatlabData(&xposting,XPOSTING); + FetchMatlabData(&yposting,YPOSTING); + FetchMatlabData(&nlines,NLINES); + FetchMatlabData(&ncols,NCOLS); + FetchMatlabData(&default_value,DEFAULTVALUE); /*Call core of computation: */ @@ -51,7 +51,7 @@ /*Write results: */ - WriteData(XM,x_m,ncols+1); - WriteData(YM,y_m,nlines+1); - WriteData(GRIDDATA,griddata,nlines,ncols); + WriteMatlabData(XM,x_m,ncols+1); + WriteMatlabData(YM,y_m,nlines+1); + WriteMatlabData(GRIDDATA,griddata,nlines,ncols); /*Free ressources: */ Index: /issm/trunk/src/mex/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp =================================================================== --- /issm/trunk/src/mex/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp (revision 8909) +++ /issm/trunk/src/mex/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp (revision 8910) @@ -61,10 +61,10 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs\n"); - FetchData(&index,&nels_data,&index_cols,INDEXHANDLE); - FetchData(&x_data,&x_data_rows,NULL,XHANDLE); - FetchData(&y_data,&y_data_rows,NULL,YHANDLE); - FetchData(&data,&data_rows,&data_cols,DATAHANDLE); - FetchData(&x_interp,&x_interp_rows,NULL,XINTERPHANDLE); - FetchData(&y_interp,&y_interp_rows,NULL,YINTERPHANDLE); + FetchMatlabData(&index,&nels_data,&index_cols,INDEXHANDLE); + FetchMatlabData(&x_data,&x_data_rows,NULL,XHANDLE); + FetchMatlabData(&y_data,&y_data_rows,NULL,YHANDLE); + FetchMatlabData(&data,&data_rows,&data_cols,DATAHANDLE); + FetchMatlabData(&x_interp,&x_interp_rows,NULL,XINTERPHANDLE); + FetchMatlabData(&y_interp,&y_interp_rows,NULL,YINTERPHANDLE); if(nrhs==8){ @@ -74,5 +74,5 @@ /*default values: */ - FetchData(&default_values,&num_default_values,DEFAULTHANDLE); + FetchMatlabData(&default_values,&num_default_values,DEFAULTHANDLE); /*contours: */ @@ -129,5 +129,5 @@ /*Write data: */ - WriteData(DATAINTERP,data_interp,nods_interp,data_cols); + WriteMatlabData(DATAINTERP,data_interp,nods_interp,data_cols); /*end module: */ Index: /issm/trunk/src/mex/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp =================================================================== --- /issm/trunk/src/mex/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp (revision 8909) +++ /issm/trunk/src/mex/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp (revision 8910) @@ -64,13 +64,13 @@ /*Input datasets: */ - FetchData(&index_data,&index_data_rows,NULL,INDEXHANDLE); - FetchData(&x_data,&x_data_rows,NULL,XHANDLE); - FetchData(&y_data,&y_data_rows,NULL,YHANDLE); - FetchData(&z_data,&z_data_rows,NULL,ZHANDLE); - FetchData(&data,&data_rows,&data_cols,DATAHANDLE); - FetchData(&x_prime,&x_prime_rows,NULL,XPRIMEHANDLE); - FetchData(&y_prime,&y_prime_rows,NULL,YPRIMEHANDLE); - FetchData(&z_prime,&z_prime_rows,NULL,ZPRIMEHANDLE); - FetchData(&default_value,DEFAULTHANDLE); + FetchMatlabData(&index_data,&index_data_rows,NULL,INDEXHANDLE); + FetchMatlabData(&x_data,&x_data_rows,NULL,XHANDLE); + FetchMatlabData(&y_data,&y_data_rows,NULL,YHANDLE); + FetchMatlabData(&z_data,&z_data_rows,NULL,ZHANDLE); + FetchMatlabData(&data,&data_rows,&data_cols,DATAHANDLE); + FetchMatlabData(&x_prime,&x_prime_rows,NULL,XPRIMEHANDLE); + FetchMatlabData(&y_prime,&y_prime_rows,NULL,YPRIMEHANDLE); + FetchMatlabData(&z_prime,&z_prime_rows,NULL,ZPRIMEHANDLE); + FetchMatlabData(&default_value,DEFAULTHANDLE); /*some checks*/ @@ -90,5 +90,5 @@ /*Write data: */ - WriteData(DATAPRIME,data_prime); + WriteMatlabData(DATAPRIME,data_prime); /*end module: */ Index: /issm/trunk/src/mex/KMLMeshWrite/KMLFileRead.cpp =================================================================== --- /issm/trunk/src/mex/KMLMeshWrite/KMLFileRead.cpp (revision 8909) +++ /issm/trunk/src/mex/KMLMeshWrite/KMLFileRead.cpp (revision 8910) @@ -67,5 +67,5 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs:\n"); - FetchData(&filnam,FILENAME); + FetchMatlabData(&filnam,FILENAME); if (verbose) printf(" filnam =\"%s\"\n",filnam); @@ -112,5 +112,5 @@ /*Write data: */ - WriteData(ERRORFLAG,ierror); + WriteMatlabData(ERRORFLAG,ierror); /*Clean-up*/ Index: /issm/trunk/src/mex/KMLMeshWrite/KMLMeshWrite.cpp =================================================================== --- /issm/trunk/src/mex/KMLMeshWrite/KMLMeshWrite.cpp (revision 8909) +++ /issm/trunk/src/mex/KMLMeshWrite/KMLMeshWrite.cpp (revision 8910) @@ -62,5 +62,5 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs:\n"); - FetchData(&name,NAME); + FetchMatlabData(&name,NAME); if (verbose) printf(" name =\"%s\"\n",name); @@ -84,25 +84,25 @@ } else - FetchData(¬es,NOTES); + FetchMatlabData(¬es,NOTES); if (verbose) printf(" notes =\"%s\"\n",notes); - FetchData(&elem,&melem,&nelem,ELEMHANDLE); + FetchMatlabData(&elem,&melem,&nelem,ELEMHANDLE); if (verbose) printf(" elem =size [%d x %d]\n",melem,nelem); - FetchData(&nodecon,&mncon,&nncon,NODECONHANDLE); + FetchMatlabData(&nodecon,&mncon,&nncon,NODECONHANDLE); if (verbose) printf(" nodecon=size [%d x %d]\n",mncon,nncon); - FetchData(&lat,&mlat,&nlat,LATHANDLE); + FetchMatlabData(&lat,&mlat,&nlat,LATHANDLE); llat=mlat*nlat; if (verbose) printf(" lat =length [%d]\n",llat); - FetchData(&lng,&mlng,&nlng,LNGHANDLE); + FetchMatlabData(&lng,&mlng,&nlng,LNGHANDLE); llng=mlng*nlng; if (verbose) printf(" lng =length [%d]\n",llng); - FetchData(&part,&mprt,&nprt,PARTHANDLE); + FetchMatlabData(&part,&mprt,&nprt,PARTHANDLE); lprt=mprt*nprt; if (verbose) printf(" part =length [%d]\n",lprt); - FetchData(&data,&mdata,&ndata,DATAHANDLE); + FetchMatlabData(&data,&mdata,&ndata,DATAHANDLE); if (verbose) printf(" data =size [%d x %d]\n",mdata,ndata); - FetchData(&cmap,&mcmap,&ncmap,CMAPHANDLE); + FetchMatlabData(&cmap,&mcmap,&ncmap,CMAPHANDLE); if (verbose) printf(" cmap =size [%d x %d]\n",mcmap,ncmap); - FetchData(&filnam,FILENAME); + FetchMatlabData(&filnam,FILENAME); if (verbose) printf(" filnam =\"%s\"\n",filnam); @@ -160,5 +160,5 @@ /*Write data: */ - WriteData(ERRORFLAG,ierror); + WriteMatlabData(ERRORFLAG,ierror); /*Clean-up*/ Index: /issm/trunk/src/mex/KMLOverlay/KMLOverlay.cpp =================================================================== --- /issm/trunk/src/mex/KMLOverlay/KMLOverlay.cpp (revision 8909) +++ /issm/trunk/src/mex/KMLOverlay/KMLOverlay.cpp (revision 8910) @@ -41,5 +41,5 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs:\n"); - FetchData(&filkml,FILENAME); + FetchMatlabData(&filkml,FILENAME); if (verbose) printf(" filkml=\"%s\"\n",filkml); @@ -109,5 +109,5 @@ /*Write data: */ - WriteData(ERRORFLAG,ierror); + WriteMatlabData(ERRORFLAG,ierror); /*Clean-up*/ Index: /issm/trunk/src/mex/Ll2xy/Ll2xy.cpp =================================================================== --- /issm/trunk/src/mex/Ll2xy/Ll2xy.cpp (revision 8909) +++ /issm/trunk/src/mex/Ll2xy/Ll2xy.cpp (revision 8910) @@ -35,15 +35,15 @@ /*Input datasets: */ if (verbose) printf("Fetching inputs:\n"); - FetchData(&lat,&nlat,LAT_IN); + FetchMatlabData(&lat,&nlat,LAT_IN); if (verbose) if (nlat == 1) printf(" lat=%g\n",lat[0]); else printf(" lat=[%d values]\n",nlat); // for (i=0; i