Changeset 12011


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

Preliminary commit of new issm version, where serial code is starting to be stripped away. Will not run before some major debugging is done

Location:
issm/trunk-jpl
Files:
42 added
2 deleted
73 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/externalpackages/boost/install.sh

    r11944 r12011  
    2626        --with-python-root="$ISSM_TIER/externalpackages/python/install"
    2727
     28exit
     29
    2830#Compile boost
    2931./bjam install

  • issm/trunk-jpl/src/c/Container/Options.h

    r11861 r12011  
    1515                /*constructors, destructors*/
    1616                Options();
    17                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    18                 Options(int istart, int nrhs, const mxArray* prhs[]);
    19                 #endif
     17                Options(int istart, int nrhs, void* module_references);
    2018                ~Options();
    2119

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

    r11861 r12011  
    6565/*}}}*/
    6666/*FUNCTION Results::Write{{{1*/
    67 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    68 void Results::Write(mxArray** pdataref){
    69 
    70         int i,j;
    71         int count;
    72 
    73         /*output: */
    74         mxArray* dataref=NULL;
    75         mxArray* processeddataref=NULL;
    76         mwSize nfields;
    77         mwSize maxfields;
    78         mwSize nsteps;
    79         mwSize step;
    80         const char **fnames      = NULL;
    81         int         *enums       = NULL;
    82         int          baseenum;
    83         mwSize       onebyone[2] = {1,1};
    84         mwSize       ndim        = 2;
    85 
    86         /*How many time steps do we have? : */
    87         nsteps=0;
    88         for(i=0;i<this->Size();i++){
    89                 ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
    90                 step=result->GetStep();
    91                 if(step>nsteps)nsteps=step;
    92         }
    93         onebyone[0]=nsteps;
    94 
    95         /*How many field names do we have. First, figure out how many result types we have: */
    96         maxfields=(mwSize)this->Size();
    97         enums=(int*)xmalloc(maxfields*sizeof(int));
    98         for(i=0;i<maxfields;i++){
    99                 ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
    100                 enums[i]=result->InstanceEnum();
    101         }
    102         /*Now, make result types unique: */
    103         for(i=0;i<maxfields;i++){
    104                 if(enums[i]>=0){//if <0, it means this enum was found to replicate another one previously
    105                         baseenum=enums[i];             
    106                         /*is the baseenum repeated later on?:*/
    107                         for(j=i+1;j<maxfields;j++){
    108                                 if (enums[j]==baseenum)enums[j]=-1;
    109                         }
    110                 }
    111                 else continue;
    112         }
    113 
    114         /*Now, go through enums, and whatever is not null is a non repeated field name: */
    115         nfields=0;
    116         for(i=0;i<maxfields;i++)if(enums[i]>0)nfields++;
    117 
    118         /*Add 2 fields for time and step: */
    119         nfields=nfields+2;
    120        
    121         /*Fill the names of the structure field: */
    122         fnames=(const char**)xmalloc(nfields*sizeof(char*));
    123         count=0;
    124         for(i=0;i<maxfields;i++){
    125                 if (enums[i]>0){
    126                         fnames[count]=EnumToStringx(enums[i]);
    127                         count++;
    128                 }
    129         }
    130         /*don't forget the extra fields "time" and "step":*/
    131         fnames[nfields-2]="time";
    132         fnames[nfields-1]="step";
    133 
    134         /*Initialize structure: */
    135         dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames);
    136 
    137         /*Fill each field: */
    138         for(i=0;i<this->Size();i++){ //do not include the last one used for time
    139                 ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
    140                 result->SetMatlabField(dataref);
    141         }
    142 
    143         /*Now, process the patch in the dataref structure, by calling MatlabProcessPatch.m
    144          *on the current dataref structure: */
    145         mexCallMATLAB(1,&processeddataref,1,&dataref, "MatlabProcessPatch");
    146 
    147         /*Assign output pointers:*/
    148         *pdataref=processeddataref;
    149 }
    150 #else
    15167void Results::Write(Parameters* parameters){
    15268       
    … …  
    16783
    16884}
    169 #endif
    17085/*}}}*/

  • issm/trunk-jpl/src/c/Container/Results.h

    r11861 r12011  
    2626                /*numerics: {{{1*/
    2727                Results* SpawnTriaResults(int* indices);
    28                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    29                 void Write(mxArray** pdataref);
    30                 #else
    3128                void Write(Parameters* parameters);
    32                 #endif
    3329                /*}}}*/
    3430};

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

    r11980 r12011  
    44
    55#Library declaration {{{1
    6 #Compile serial library, and then try and compile parallel library
    7 if NOSERIAL
    8 if NOPARALLEL
    9 lib_LIBRARIES =
    10 else
    11 lib_LIBRARIES = libpISSM.a libOverload.a
    12 endif
    13 else
    14 if NOPARALLEL
    15 lib_LIBRARIES = libISSM.a libOverload.a
    16 else
    17 lib_LIBRARIES = libISSM.a libpISSM.a libOverload.a
    18 endif
     6lib_LIBRARIES = libISSMCore.a libISSMModules.a libISSMOverload.a
     7if PYTHON
     8lib_LIBRARIES += libISSMPython.a
     9endif
     10if MATLAB
     11lib_LIBRARIES += libISSMMatlab.a
    1912endif
    2013#}}}
    … …  
    362355                                          ./modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp\
    363356                                          ./modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp\
    364                                           ./modules/AverageOntoPartitionx/AverageOntoPartitionx.h
    365 dakota_psources= ./modules/Dakotax/SpawnCoreParallel.cpp
     357                                          ./modules/AverageOntoPartitionx/AverageOntoPartitionx.h\
     358                                          ./modules/Dakotax/SpawnCoreParallel.cpp
    366359#}}}
    367360#Transient sources  {{{1
    … …  
    443436                                          ./objects/Inputs/ControlInput.cpp\
    444437                                          ./shared/Numerics/BrentSearch.cpp\
    445                                           ./shared/Numerics/OptimalSearch.cpp\
    446                                           ./shared/Numerics/OptFunc.cpp
     438                                          ./shared/Numerics/OptimalSearch.cpp
    447439
    448440control_psources=./solutions/control_core.cpp\
    … …  
    694686                             ./objects/KML/KMLFileReadUtils.h
    695687#}}}
    696 #Matlab sources  {{{1
    697 matlab_sources= ./toolkits/matlab/matlabincludes.h\
    698                                     ./toolkits/matlab/MatlabNArrayToNArray.cpp\
    699                                     ./toolkits/double/MatlabVectorToDoubleVector.cpp\
    700                                     ./toolkits/double/double.h\
    701                                     ./toolkits/double/MatlabMatrixToDoubleMatrix.cpp\
    702                                     ./io/Matlab/matlabio.h\
    703                                     ./io/Matlab/CheckNumMatlabArguments.cpp\
    704                                     ./io/Matlab/mxGetAssignedField.cpp\
    705                                     ./io/Matlab/WriteMatlabData.cpp\
    706                                     ./io/Matlab/FetchMatlabData.cpp\
    707                                     ./io/Matlab/OptionParse.cpp
    708 #}}}
    709 #Python sources  {{{1
    710 python_sources=     ./io/Python/pythonio.h\
    711                                     ./io/Python/WritePythonData.cpp\
    712                                     ./io/Python/CheckNumPythonArguments.cpp\
    713                                     ./io/Python/FetchPythonData.cpp
    714 #}}}
    715688#Petsc sources  {{{1
    716689petsc_sources= ./toolkits/petsc\
    … …  
    718691                                        ./toolkits/petsc/patches/SolverEnum.h\
    719692                                        ./toolkits/petsc/patches/petscpatches.h\
    720                                         ./toolkits/petsc/patches/MatlabMatrixToPetscMatrix.cpp\
    721                                         ./toolkits/petsc/patches/MatlabVectorToPetscVector.cpp\
    722                                         ./toolkits/petsc/patches/PetscMatrixToMatlabMatrix.cpp\
    723                                         ./toolkits/petsc/patches/PetscVectorToMatlabVector.cpp\
    724693                                        ./toolkits/petsc/patches/VecTranspose.cpp\
    725694                                        ./toolkits/petsc/patches/VecToMPISerial.cpp\
    … …  
    754723
    755724#}}}
    756 #Serialsources  {{{1
    757 serial_sources= ./objects/Options/Option.cpp\
     725#Python sources  {{{1
     726python_sources=     ./python/io/pythonio.h\
     727                                    ./python/io/WritePythonData.cpp\
     728                                    ./python/io/CheckNumPythonArguments.cpp\
     729                                    ./python/io/FetchPythonData.cpp\
     730                                        ./python/objects/Bamg/BamgGeom.h\
     731                                        ./python/objects/Bamg/BamgGeom.cpp\
     732                                        ./python/objects/Bamg/BamgMesh.h\
     733                                        ./python/objects/Bamg/BamgMesh.cpp\
     734                                        ./python/objects/Bamg/BamgOpts.h\
     735                                        ./python/objects/Bamg/BamgOpts.cpp
     736
     737#}}}
     738#Matlab sources  {{{1
     739matlab_sources= ./toolkits/matlab/matlabincludes.h\
     740                                    ./matlab/io/matlabio.h\
     741                                    ./matlab/io/MatlabNArrayToNArray.cpp\
     742                                    ./matlab/io/CheckNumMatlabArguments.cpp\
     743                                    ./matlab/io/mxGetAssignedField.cpp\
     744                                    ./matlab/io/WriteMatlabData.cpp\
     745                                    ./matlab/io/FetchMatlabData.cpp\
     746                                    ./matlab/io/OptionParse.cpp\
     747                                    ./matlab/io/MatlabMatrixToMatrix.cpp\
     748                                    ./matlab/io/MatlabVectorToVector.cpp\
     749                                        ./matlab/io/MatlabVectorToDoubleVector.cpp\
     750                                    ./matlab/io/MatlabMatrixToDoubleMatrix.cpp\
     751                                        ./matlab/io/Container/Options.cpp\
     752                                        ./matlab/objects/Bamg/BamgGeom.h\
     753                                        ./matlab/objects/Bamg/BamgGeom.cpp\
     754                                        ./matlab/objects/Bamg/BamgMesh.h\
     755                                        ./matlab/objects/Bamg/BamgMesh.cpp\
     756                                        ./matlab/objects/Bamg/BamgOpts.h\
     757                                        ./matlab/objects/Bamg/BamgOpts.cpp\
     758                                        ./matlab/io/MatlabMatrixToPetscMatrix.cpp\
     759                                        ./matlab/io/MatlabVectorToPetscVector.cpp\
     760                                        ./matlab/io/PetscMatrixToDoubleMatrix.cpp\
     761                                        ./matlab/io/PetscVectorToDoubleVector.cpp\
     762                                        ./matlab/io/MatlabMatrixToSeqMat.cpp\
     763                                        ./matlab/io/MatlabVectorToSeqVec.cpp
     764#}}}
     765#Modules sources{{{1
     766module_sources= ./objects/Options/Option.cpp\
    758767                        ./objects/Options/Option.h\
    759768                        ./objects/Options/OptionDouble.cpp\
    … …  
    769778                        ./objects/Options/OptionUtilities.cpp\
    770779                        ./objects/Options/OptionUtilities.h\
     780                        ./shared/Alloc/alloc_module.h\
     781                        ./shared/Alloc/alloc_module.cpp\
    771782                        ./shared/Threads/issm_threads.h\
    772783                        ./shared/Threads/LaunchThread.cpp\
    … …  
    790801                        ./modules/Chacox/chaco_seconds.cpp\
    791802                        ./modules/Chacox/user_params.cpp\
    792                         ./modules/Dakotax/SpawnCoreSerial.cpp\
    793803                        ./modules/TriaSearchx/TriaSearchx.h\
    794804                        ./modules/TriaSearchx/TriaSearchx.cpp\
    … …  
    841851#}}}
    842852
     853#{{{1 Conditional build-up of sources
    843854#ISSM sources are a combination of core sources and sources related to specific capabilities (which can
    844855#be activated by autotools conditionals
    845 #{{{1
     856
    846857
    847858#First the core
    848859issm_sources  =  $(core_sources)
    849 issm_psources = 
    850860
    851861#Now the optional source
    852862if DAKOTA
    853863issm_sources  +=  $(dakota_sources)
    854 issm_psources +=  $(dakota_psources)
    855864endif
    856865
    857866if PETSC
    858867issm_sources  +=  $(petsc_sources)
    859 issm_psources +=  $(petsc_psources)
    860868endif
    861869
    862870if GSL
    863871issm_sources  +=  $(gsl_sources)
    864 issm_psources +=  $(gsl_psources)
    865 endif
    866 
     872endif
    867873
    868874if TRANSIENT
    869875issm_sources  +=  $(transient_sources)
    870 issm_psources +=  $(transient_psources)
    871876endif
    872877
    873878if STEADYSTATE
    874879issm_sources  +=  $(steadystate_sources)
    875 issm_psources +=  $(steadystate_psources)
    876880endif
    877881
    878882if PROGNOSTIC
    879883issm_sources  +=  $(prognostic_sources)
    880 issm_psources +=  $(prognostic_psources)
    881884endif
    882885
    883886if THERMAL
    884887issm_sources  +=  $(thermal_sources)
    885 issm_psources +=  $(thermal_psources)
    886888endif
    887889
    888890if CONTROL
    889891issm_sources  +=  $(control_sources)
    890 issm_psources +=  $(control_psources)
    891892endif
    892893
    893894if HYDROLOGY
    894895issm_sources  +=  $(hydrology_sources)
    895 issm_psources +=  $(hydrology_psources)
    896896endif
    897897
    898898if DIAGNOSTIC
    899899issm_sources  +=  $(diagnostic_sources)
    900 issm_psources +=  $(diagnostic_psources)
    901900endif
    902901
    903902if BALANCED
    904903issm_sources  +=  $(balanced_sources)
    905 issm_psources +=  $(balanced_psources)
    906904endif
    907905
    … …  
    912910if SLOPE
    913911issm_sources  +=  $(slope_sources)
    914 issm_psources +=  $(slope_psources)
    915912endif
    916913
    … …  
    927924endif
    928925#}}}
    929 
    930 #ISSM serial library {{{1
    931 if SERIAL
    932 libISSM_a_SOURCES  = $(issm_sources)
    933 libISSM_a_SOURCES += $(serial_sources)
    934 libISSM_a_SOURCES += $(bamg_sources)
    935 libISSM_a_SOURCES += $(kml_sources)
    936 libISSM_a_CXXFLAGS = -fPIC -D_SERIAL_ -D_GNU_SOURCE -fno-omit-frame-pointer -pthread -D_CPP_  $(CXXFLAGS) $(CXXOPTFLAGS)
    937 #libISSM_a_CXXFLAGS = -D_SERIAL_ -DTRILIBRARY -DANSI_DECLARATORS -DNO_TIMER   $(CXXFLAGS) $(CXXOPTFLAGS)
     926#Library flags and sources {{{1
     927ALLCXXFLAGS= -fPIC -D_GNU_SOURCE -fno-omit-frame-pointer -pthread -D_CPP_  $(CXXFLAGS) $(CXXOPTFLAGS)
     928
     929libISSMCore_a_SOURCES  = $(issm_sources)
     930libISSMCore_a_CXXFLAGS = $(ALLCXXFLAGS)
     931
     932libISSMModules_a_SOURCES = $(module_sources)
     933libISSMModules_a_SOURCES += $(bamg_sources)
     934libISSMModules_a_SOURCES += $(kml_sources)
     935libISSMModules_a_CXXFLAGS = $(ALLCXXFLAGS)
    938936
    939937if PYTHON
    940 libISSM_a_CXXFLAGS+=  -DNPY_NO_DEPRECATED_API
    941 libISSM_a_SOURCES += $(python_sources)
     938libISSMPython_a_SOURCES = $(python_sources)
     939libISSMPython_a_CXXFLAGS= $(ALLCXXFLAGS)
     940libISSMPython_a_CXXFLAGS+=  -DNPY_NO_DEPRECATED_API
    942941endif
    943942
    944943if MATLAB
    945 libISSM_a_SOURCES += $(matlab_sources)
    946 endif
    947 
    948 endif
    949 #}}}
    950 #ISSM parallel library {{{1
    951 if PARALLEL
    952 libpISSM_a_SOURCES  = $(issm_sources)
    953 libpISSM_a_SOURCES += $(issm_psources)
    954 libpISSM_a_CXXFLAGS = -fPIC -D_PARALLEL_   -D_C_ $(CXXFLAGS) $(CXXOPTFLAGS)
    955 endif
     944libISSMMatlab_a_SOURCES = $(matlab_sources)
     945libISSMMatlab_a_CXXFLAGS= $(ALLCXXFLAGS)
     946endif
     947
    956948#}}}
    957949#Overload library, to overload any non-standard symbols. {{{1
    958 libOverload_a_SOURCES = ./shared/String/stricmp.c
    959 libOverload_a_CFLAGS  = -fPIC -D_PARALLEL_  -D_C_ $(COPTFLAGS) $(CFLAGS)
     950libISSMOverload_a_SOURCES = ./shared/String/stricmp.c
     951libISSMOverload_a_CFLAGS  = -fPIC -D_C_ $(COPTFLAGS) $(CFLAGS)
    960952#}}}
    961953
    962954#Executable {{{1
    963 if NOPARALLEL
    964 bin_PROGRAMS =
    965 else
    966955bin_PROGRAMS = issm
    967 endif
    968956
    969957#Standard libraries
    970 LDADD = ./libpISSM.a ./libOverload.a
     958LDADD = ./libISSMCore.a ./libISSMOverload.a
    971959
    972960#External packages
    … …  
    974962
    975963issm_SOURCES = solutions/issm.cpp
    976 issm_CXXFLAGS= -fPIC -D_PARALLEL_ $(CXXFLAGS) $(CXXOPTFLAGS) $(COPTFLAGS)
     964issm_CXXFLAGS= -fPIC $(CXXFLAGS) $(CXXOPTFLAGS) $(COPTFLAGS)
    977965#}}}
    978966#Automatic differentiation: append this fold to the end of the src/c/Makefile.am to get this Makefile.am {{{
    979967if ADIC2
    980 lib_LIBRARIES += libAD.a libpISSMRose.a
     968lib_LIBRARIES += libAD.a libISSMRose.a
    981969
    982970#ADIC2 library, for automatic differentiation
    983971#libAD_a_SOURCES = ./mini1.ad.c
    984972libAD_a_SOURCES =
    985 libAD_a_CFLAGS = -fPIC -D_PARALLEL_   -D_C_ $(COPTFLAGS)
    986 
     973libAD_a_CFLAGS = -fPIC -D_C_ $(COPTFLAGS)
    987974
    988975
    … …  
    990977%.r2cpp.cpp : %.cpp
    991978        testTranslator -rose:o $@ -rose:skipfinalCompileStep -DHAVE_CONFIG_H -D_PARALLEL_ -D_C_ -I. -I../.. $(INCLUDES) $<
    992 libpISSMRose_a_SOURCES = $(libpISSM_a_SOURCES:.cpp=.r2cpp.cpp)
    993 libpISSMRose_a_CXXFLAGS= -fPIC -D_PARALLEL_ -D_C_ $(CXXOPTFLAGS)
     979libISSMRose_a_SOURCES = $(libISSMCore_a_SOURCES:.cpp=.r2cpp.cpp)
     980libISSMRose_a_CXXFLAGS= -fPIC -D_C_ $(CXXOPTFLAGS)
    994981
    995982
    … …  
    1003990#Executable
    1004991bin_PROGRAMS +=  issmRose.exe
    1005 issmRose_exe_LDADD = ./libpISSMRose.a $(LDADD)
     992issmRose_exe_LDADD = ./libISSMRose.a $(LDADD)
    1006993issmRose_exe_SOURCES = solutions/issm.cpp
    1007 issmRose_exe_CXXFLAGS= -fPIC -D_PARALLEL_  $(CXXOPTFLAGS) $(COPTFLAGS)
     994issmRose_exe_CXXFLAGS= -fPIC $(CXXOPTFLAGS) $(COPTFLAGS)
    1008995LDADD +=  $(ADIC2LIB)
    1009996

  • issm/trunk-jpl/src/c/include/macros.h

    r11974 r12011  
    4848
    4949#ifdef _SERIAL_
    50 #ifdef _HAVE_MATLAB_ //{{{2
    51 #define MODULEBOOT(); ModuleBoot(); \
    52         try{
    53 
    54 #define MODULEEND(); ModuleEnd(); }\
    55         catch(ErrorException &exception){\
    56                 exception.Report(); \
    57                 mexErrMsgTxt(""); \
    58         }\
    59         catch (exception& e) {\
    60                 _printf_(true,"Standard exception: %s\n",e.what());\
    61                 mexErrMsgTxt(" ");\
    62         }
    63 #endif //}}}
    6450#ifdef _HAVE_PYTHON_ //{{{2
    6551#define MODULEBOOT(); ModuleBoot();  \
    … …  
    8773/*}}}*/
    8874/* WRAPPER {{{1*/
    89 #ifdef _HAVE_MATLAB_
    90 #define WRAPPER(modulename,...) void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
    91 #endif
    9275#ifdef _HAVE_PYTHON_
    9376#define WRAPPER(modulename,...)  \
    … …  
    120103/*}}}*/
    121104/* CHECKARGUMENTS {{{1*/
    122 #ifdef _HAVE_MATLAB_
    123 #define CHECKARGUMENTS(NLHS,NRHS,functionpointer) CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,functionpointer)
    124 #endif
    125105#ifdef _HAVE_PYTHON_
    126106#define CHECKARGUMENTS(NLHS,NRHS,functionpointer) CheckNumPythonArguments(args, NRHS,functionpointer)
    … …  
    128108/*}}}*/
    129109
    130 
    131110#endif

  • issm/trunk-jpl/src/c/include/types.h

    r11861 r12011  
    1616
    1717/*Define abstract type for I/O: */
    18 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    19 #include <mex.h>
    20 typedef const mxArray* ConstDataHandle;  //serially, we are reading data from a matlab array.
    21 typedef mxArray* DataHandle; 
    22 #else
    23 typedef FILE* ConstDataHandle; //in parallel, we are reading data from a file.
    24 typedef FILE* DataHandle;
    25 #endif
    2618enum param_type { STRING, INTEGER, STRINGARRAY, DOUBLE, DOUBLEVEC, DOUBLEMAT, PETSCVEC, PETSCMAT };
    2719

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

    r11951 r12011  
    5151#endif
    5252
    53 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    54 void Dakotax(mxArray* femmodel){
    55 #else
    5653void Dakotax(FemModel* femmodel){
    57 #endif
    5854
    5955
    … …  
    6965
    7066        /*Retrieve parameters: */
    71         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    72         FetchData((Parameters**)&parameters,mxGetField((mxArray*)femmodel,0,"parameters"));
    73         #else
    7467        parameters=femmodel->parameters;
    75         #endif
    7668
    7769        /*Recover dakota_input_file, dakota_output_file and dakota_error_file, in the parameters dataset in parallel */
    … …  
    8678                // Instantiate/initialize the parallel library and problem description
    8779                // database objects.
    88                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    89                         Dakota::ParallelLibrary parallel_lib; //use Dakota's standard library mode constructor
    90                 #else
    91                         Dakota::ParallelLibrary parallel_lib("serial"); //use our own ISSM Dakota library mode constructor, which only fires up Dakota on CPU 0.
    92                 #endif
     80                Dakota::ParallelLibrary parallel_lib("serial"); //use our own ISSM Dakota library mode constructor, which only fires up Dakota on CPU 0.
    9381                Dakota::ProblemDescDB problem_db(parallel_lib);
    9482
    … …  
    143131        xfree((void**)&dakota_output_file);
    144132
    145         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    146         delete parameters;
    147         #endif
    148 
    149133        #endif //#ifdef _HAVE_DAKOTA_
    150134}

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

    r11861 r12011  
    1010
    1111/* local prototypes: */
    12 int SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int counter);
     12int  SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int counter);
    1313int  DescriptorIndex(char* root, int* pindex,char* descriptor);
    1414
    15 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    16 void Dakotax(mxArray* femmodel);
    17 void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* femmodel,int counter);
    18 #else
    1915void Dakotax(FemModel* femmodel);
    2016void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int counter);
    21 #endif
    2217void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,FemModel* femmodel);
    2318void DakotaMPI_Bcast(double** pvariables, char*** pvariables_descriptors,int* pnumvariables, int* pnumresponses);

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

    r11861 r12011  
    2121        /*Branch into a serial SpawnCore and a parallel SpawnCore: */
    2222
    23         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    24                 SpawnCoreSerial(responses, numresponses, variables, variables_descriptors,numvariables, (mxArray*)femmodel, counter);
    25         #else
    26                 /*Call SpawnCoreParallel unless counter=-1 on cpu0, in which case, bail out and return 0: */
    27                 MPI_Bcast(&counter,1,MPI_INT,0,MPI_COMM_WORLD);
    28                 if(counter==-1)return 0;
    29                 SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel,counter);
    30         #endif
     23        /*Call SpawnCoreParallel unless counter=-1 on cpu0, in which case, bail out and return 0: */
     24        MPI_Bcast(&counter,1,MPI_INT,0,MPI_COMM_WORLD);
     25        if(counter==-1)return 0;
     26
     27        SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel,counter);
    3128        return 1;
    3229}

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

    r11922 r12011  
    1616#include "../../objects/objects.h"
    1717               
    18 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    19 void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results* results){
    20 #else
    2118void OutputResultsx(                    Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results* results){
    22 #endif
    2319
    2420        extern int  my_rank;
    … …  
    3127        bool        dakota_analysis         = false;
    3228       
    33         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    34         const char **fnames      = NULL;
    35         mwSize       onebyone[2] = {0,0};
    36         mwSize       ndim        = 2;
    37         int          nfields=0;
    38         #endif
    39 
    4029        /*retrieve parameters: */
    4130        parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    … …  
    4332        if(dakota_analysis){
    4433                //no need to output anything, Dakota analysis has different outputs
    45                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    46                 *pdataref=mxCreateStructArray( ndim,onebyone,nfields,fnames);
    47                 #endif
    4834                return;
    4935        }
    … …  
    5642        /*Results do not include the type of solution being run . In parallel, we output results to a filename,
    5743         *therefore, we need to include the solutiontype into the filename: */
    58         #ifdef _PARALLEL_
    5944        if(my_rank==0){
    6045                parameters->FindParam(&solutiontype,SolutionTypeEnum);
    … …  
    8873                parameters->SetParam(fid,OutputFilePointerEnum);
    8974        }
    90         #endif
    9175
    92         /*Write results to disk (in parallel), or to memory (in serial mode): */
    93         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    94                 results->Write(pdataref);
    95         #else
    96                 results->Write(parameters);
    97         #endif
     76        /*Write results to disk: */
     77        results->Write(parameters);
    9878
    9979        /*Delete and reinitialize results, in parallel: */
    100         #ifdef _PARALLEL_
    101                 results->clear();
     80        results->clear();
    10281
    103                 /*Close output file? :*/
    104                 /*WARNING: issm.cpp is taking care of it for now (quick fix)
    105                 if((step==1) && (time==0)){
    106                         if(io_gather){
    107                                 if(my_rank==0) pfclose(fid,outputfilename);
    108                         }
    109                         else pfclose(fid,cpu_outputfilename);
    110                 }
    111                 */
    112         #endif
     82        /*Close output file? :*/
     83        /*WARNING: issm.cpp is taking care of it for now (quick fix)
     84          if((step==1) && (time==0)){
     85          if(io_gather){
     86          if(my_rank==0) pfclose(fid,outputfilename);
     87          }
     88          else pfclose(fid,cpu_outputfilename);
     89          }
     90        */
    11391}

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

    r11861 r12011  
    1414#include "../../Container/Container.h"
    1515
    16 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    17 #include <mex.h>
    18 void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results* results);
    19 #else
    2016void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results* results);
    21 #endif
    2217
    2318#endif  /* _OUTPUTRESULTS_H */

  • issm/trunk-jpl/src/c/objects/Bamg/BamgGeom.cpp

    r11936 r12011  
    1919}
    2020/*}}}*/
    21 /*FUNCTION BamgGeom::BamgGeom(mxArray* matlab_struct){{{1*/
    22 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    23 BamgGeom::BamgGeom(mxArray* matlab_struct){
    24 
    25         FetchData(&this->Vertices,        &this->VerticesSize[0],        &this->VerticesSize[1],        mxGetAssignedField(matlab_struct,0,"Vertices"));
    26         FetchData(&this->Edges,           &this->EdgesSize[0],           &this->EdgesSize[1],           mxGetAssignedField(matlab_struct,0,"Edges"));
    27         this->TangentAtEdgesSize[0]=0,    this->TangentAtEdgesSize[1]=0;    this->TangentAtEdges=NULL;
    28         FetchData(&this->Corners,         &this->CornersSize[0],         &this->CornersSize[1],         mxGetAssignedField(matlab_struct,0,"Corners"));
    29         FetchData(&this->RequiredVertices,&this->RequiredVerticesSize[0],&this->RequiredVerticesSize[1],mxGetAssignedField(matlab_struct,0,"RequiredVertices"));
    30         FetchData(&this->RequiredEdges,   &this->RequiredEdgesSize[0],   &this->RequiredEdgesSize[1],   mxGetAssignedField(matlab_struct,0,"RequiredEdges"));
    31         FetchData(&this->CrackedEdges,    &this->CrackedEdgesSize[0],    &this->CrackedEdgesSize[1],    mxGetAssignedField(matlab_struct,0,"CrackedEdges"));
    32         FetchData(&this->SubDomains,      &this->SubDomainsSize[0],      &this->SubDomainsSize[1],      mxGetAssignedField(matlab_struct,0,"SubDomains"));
    33 
    34 }
    35 #endif
    36 /*}}}*/
    3721/*FUNCTION BamgGeom::~BamgGeom(){{{1*/
    3822BamgGeom::~BamgGeom(){
    … …  
    4933}
    5034/*}}}*/
    51 
    52 /*Methods*/
    53 /*FUNCTION BamgGeom::SetMatlabStructureFields{{{1*/
    54 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    55 void BamgGeom::SetMatlabStructureFields(mxArray** matlab_struct){
    56 
    57         /*Intermediary*/
    58         int         i;
    59         mxArray*    output=NULL;
    60         const int         numfields=7;
    61         const char* fnames[numfields];
    62         mwSize      ndim=2;
    63         mwSize      dimensions[2]={1,1};
    64 
    65         /*Initialize field names*/
    66         i=0;
    67         fnames[i++] = "Vertices";
    68         fnames[i++] = "Edges";
    69         fnames[i++] = "TangentAtEdges";
    70         fnames[i++] = "RequiredVertices";
    71         fnames[i++] = "RequiredEdges";
    72         fnames[i++] = "CrackedEdges";
    73         fnames[i++] = "SubDomains";
    74         _assert_(i==numfields);
    75 
    76         /*Initialize Matlab structure*/
    77         output=mxCreateStructArray(ndim,dimensions,numfields,fnames);
    78 
    79         /*set each matlab each field*/
    80         i=0;
    81         i++; SetMatlabStructureField(output,"Vertices",        this->VerticesSize[0],        this->VerticesSize[1],        this->Vertices);
    82         i++; SetMatlabStructureField(output,"Edges",           this->EdgesSize[0],           this->EdgesSize[1],           this->Edges);
    83         i++; SetMatlabStructureField(output,"TangentAtEdges",  this->TangentAtEdgesSize[0],  this->TangentAtEdgesSize[1],  this->TangentAtEdges);
    84         i++; SetMatlabStructureField(output,"RequiredVertices",this->RequiredVerticesSize[0],this->RequiredVerticesSize[1],this->RequiredVertices);
    85         i++; SetMatlabStructureField(output,"RequiredEdges",   this->RequiredEdgesSize[0],   this->RequiredEdgesSize[1],   this->RequiredEdges);
    86         i++; SetMatlabStructureField(output,"CrackedEdges",    this->CrackedEdgesSize[0],    this->CrackedEdgesSize[1],    this->CrackedEdges);
    87         i++; SetMatlabStructureField(output,"SubDomains",      this->SubDomainsSize[0],      this->SubDomainsSize[1],      this->SubDomains);
    88         _assert_(i==numfields);
    89 
    90         /*Assign output*/
    91         *matlab_struct=output;
    92 
    93 }
    94 #endif
    95 /*}}}*/
    96 /*FUNCTION BamgGeom::SetMatlabStructureField{{{1*/
    97 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    98 void BamgGeom::SetMatlabStructureField(mxArray* matlab_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer){
    99 
    100         /*Intermediary*/
    101         int         i1,i2;
    102         mxArray*    pfield=NULL;
    103         mxArray*    pfield2=NULL;
    104 
    105         /*Copy field*/
    106         double*  fieldcopy=NULL;
    107         if (fieldrows*fieldcols){
    108                 fieldcopy=(double*)xmalloc(fieldrows*fieldcols*sizeof(double));
    109                 for(i1=0;i1<fieldrows;i1++){
    110                         for(i2=0;i2<fieldcols;i2++){
    111                                 fieldcopy[fieldcols*i1+i2]=fieldpointer[fieldcols*i1+i2];
    112                         }
    113                 }
    114         }
    115 
    116         /*Set matlab field*/
    117         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    118         mxSetM(pfield,fieldcols);
    119         mxSetN(pfield,fieldrows);
    120         mxSetPr(pfield,fieldcopy);
    121         mexCallMATLAB(1,&pfield2,1,&pfield,"transpose");//transpose
    122         mxSetField(matlab_struct,0,fieldname,pfield2);
    123 }
    124 #endif
    125 /*}}}*/

  • issm/trunk-jpl/src/c/objects/Bamg/BamgGeom.h

    r11861 r12011  
    44#ifndef _BAMGGEOM_H_
    55#define _BAMGGEOM_H_
    6 
    7 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    8 #include <mex.h>
    9 #endif
    106
    117class BamgGeom{
    … …  
    3026
    3127                BamgGeom();
    32                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    33                 BamgGeom(mxArray* matlab_struct);
    34                 #endif
     28                BamgGeom(void* module_struct);
    3529                ~BamgGeom();
    3630
    37                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    38                 void SetMatlabStructureFields(mxArray** matlab_struct);
    39                 void SetMatlabStructureField(mxArray* matlab_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
    40                 #endif
     31                void SetStructureFields(void* matlab_struct);
     32                void SetStructureField(void* matlab_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
    4133};
    4234

  • issm/trunk-jpl/src/c/objects/Bamg/BamgMesh.cpp

    r11936 r12011  
    3232}
    3333/*}}}*/
    34 /*FUNCTION BamgMesh::BamgMesh(mxArray* matlab_struct){{{1*/
    35 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    36 BamgMesh::BamgMesh(mxArray* matlab_struct){
    37 
    38         int lines,cols;
    39 
    40         FetchData(&this->Vertices,            &this->VerticesSize[0],            &this->VerticesSize[1],            mxGetAssignedField(matlab_struct,0,"Vertices"));
    41         FetchData(&this->Edges,               &this->EdgesSize[0],               &this->EdgesSize[1],               mxGetAssignedField(matlab_struct,0,"Edges"));
    42         FetchData(&this->Triangles,           &this->TrianglesSize[0],           &this->TrianglesSize[1],           mxGetAssignedField(matlab_struct,0,"Triangles"));
    43         this->QuadrilateralsSize[0]=0,        this->QuadrilateralsSize[1]=0;     this->Quadrilaterals=NULL;
    44 
    45         this->SubDomainsSize[0]=0,            this->SubDomainsSize[1]=0;         this->SubDomains=NULL;
    46         this->SubDomainsFromGeomSize[0]=0,    this->SubDomainsFromGeomSize[1]=0; this->SubDomainsFromGeom=NULL;
    47         this->CrackedVerticesSize[0]=0,       this->CrackedVerticesSize[1]=0;    this->CrackedVertices=NULL;
    48         FetchData(&this->CrackedEdges,        &this->CrackedEdgesSize[0],        &this->CrackedEdgesSize[1],        mxGetAssignedField(matlab_struct,0,"CrackedEdges"));
    49 
    50         FetchData(&this->VerticesOnGeomEdge,  &this->VerticesOnGeomEdgeSize[0],  &this->VerticesOnGeomEdgeSize[1],  mxGetAssignedField(matlab_struct,0,"VerticesOnGeomEdge"));
    51         FetchData(&this->VerticesOnGeomVertex,&this->VerticesOnGeomVertexSize[0],&this->VerticesOnGeomVertexSize[1],mxGetAssignedField(matlab_struct,0,"VerticesOnGeomVertex"));
    52         FetchData(&this->EdgesOnGeomEdge,     &this->EdgesOnGeomEdgeSize[0],     &this->EdgesOnGeomEdgeSize[1],     mxGetAssignedField(matlab_struct,0,"EdgesOnGeomEdge"));
    53 
    54         this->IssmEdgesSize[0]=0,             this->IssmEdgesSize[1]=0;          this->IssmEdges=NULL;
    55         FetchData(&this->IssmSegments,        &this->IssmSegmentsSize[0],        &this->IssmSegmentsSize[1],        mxGetAssignedField(matlab_struct,0,"IssmSegments"));
    56 
    57         this->ElementConnectivitySize[0]=0,      this->ElementConnectivitySize[1]=0;      this->ElementConnectivity=NULL;
    58         this->NodalConnectivitySize[0]=0,        this->NodalConnectivitySize[1]=0;        this->NodalConnectivity=NULL;
    59         this->NodalElementConnectivitySize[0]=0, this->NodalElementConnectivitySize[1]=0; this->NodalElementConnectivity=NULL;
    60 
    61 }
    62 #endif
    63 /*}}}*/
    6434/*FUNCTION BamgMesh::~BamgMesh(){{{1*/
    6535BamgMesh::~BamgMesh(){
    … …  
    8959}
    9060/*}}}*/
    91 
    92 /*Methods*/
    93 /*FUNCTION BamgMesh::SetMatlabStructureFields{{{1*/
    94 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    95 void BamgMesh::SetMatlabStructureFields(mxArray** matlab_struct){
    96 
    97         /*Intermediary*/
    98         int         i;
    99         mxArray*    output=NULL;
    100         const int         numfields=16;
    101         const char* fnames[numfields];
    102         mwSize      ndim=2;
    103         mwSize      dimensions[2]={1,1};
    104 
    105         /*Initialize field names*/
    106         i=0;
    107         fnames[i++] = "Triangles";
    108         fnames[i++] = "Vertices";
    109         fnames[i++] = "Edges";
    110         fnames[i++] = "IssmSegments";
    111         fnames[i++] = "IssmEdges";
    112         fnames[i++] = "Quadrilaterals";
    113         fnames[i++] = "VerticesOnGeomVertex";
    114         fnames[i++] = "VerticesOnGeomEdge";
    115         fnames[i++] = "EdgesOnGeomEdge";
    116         fnames[i++] = "SubDomains";
    117         fnames[i++] = "SubDomainsFromGeom";
    118         fnames[i++] = "ElementConnectivity";
    119         fnames[i++] = "NodalConnectivity";
    120         fnames[i++] = "NodalElementConnectivity";
    121         fnames[i++] = "CrackedVertices";
    122         fnames[i++] = "CrackedEdges";
    123         _assert_(i==numfields);
    124 
    125         /*Initialize Matlab structure*/
    126         output=mxCreateStructArray(ndim,dimensions,numfields,fnames);
    127 
    128         /*set each matlab each field*/
    129         i=0;
    130         i++; SetMatlabStructureField(output,"Triangles",                this->TrianglesSize[0],                this->TrianglesSize[1],                 this->Triangles);
    131         i++; SetMatlabStructureField(output,"Vertices",                 this->VerticesSize[0],                 this->VerticesSize[1],                  this->Vertices);
    132         i++; SetMatlabStructureField(output,"Edges",                    this->EdgesSize[0],                    this->EdgesSize[1],                     this->Edges);
    133         i++; SetMatlabStructureField(output,"IssmSegments",             this->IssmSegmentsSize[0],             this->IssmSegmentsSize[1],              this->IssmSegments);
    134         i++; SetMatlabStructureField(output,"IssmEdges",                this->IssmEdgesSize[0],                this->IssmEdgesSize[1],                 this->IssmEdges);
    135         i++; SetMatlabStructureField(output,"Quadrilaterals",           this->QuadrilateralsSize[0],           this->QuadrilateralsSize[1],            this->Quadrilaterals);
    136         i++; SetMatlabStructureField(output,"VerticesOnGeomVertex",this->VerticesOnGeomVertexSize[0],this->VerticesOnGeomVertexSize[1], this->VerticesOnGeomVertex);
    137         i++; SetMatlabStructureField(output,"VerticesOnGeomEdge",  this->VerticesOnGeomEdgeSize[0],  this->VerticesOnGeomEdgeSize[1],   this->VerticesOnGeomEdge);
    138         i++; SetMatlabStructureField(output,"EdgesOnGeomEdge",     this->EdgesOnGeomEdgeSize[0],     this->EdgesOnGeomEdgeSize[1],      this->EdgesOnGeomEdge);
    139         i++; SetMatlabStructureField(output,"SubDomains",               this->SubDomainsSize[0],               this->SubDomainsSize[1],                this->SubDomains);
    140         i++; SetMatlabStructureField(output,"SubDomainsFromGeom",       this->SubDomainsFromGeomSize[0],       this->SubDomainsFromGeomSize[1],        this->SubDomainsFromGeom);
    141         i++; SetMatlabStructureField(output,"ElementConnectivity",      this->ElementConnectivitySize[0],      this->ElementConnectivitySize[1],       this->ElementConnectivity);
    142         i++; SetMatlabStructureField(output,"NodalConnectivity",        this->NodalConnectivitySize[0],        this->NodalConnectivitySize[1],         this->NodalConnectivity);
    143         i++; SetMatlabStructureField(output,"NodalElementConnectivity", this->NodalElementConnectivitySize[0], this->NodalElementConnectivitySize[1],  this->NodalElementConnectivity);
    144         i++; SetMatlabStructureField(output,"CrackedVertices",          this->CrackedVerticesSize[0],          this->CrackedVerticesSize[1],           this->CrackedVertices);
    145         i++; SetMatlabStructureField(output,"CrackedEdges",             this->CrackedEdgesSize[0],             this->CrackedEdgesSize[1],              this->CrackedEdges);
    146         _assert_(i==numfields);
    147 
    148         /*Assign output*/
    149         *matlab_struct=output;
    150 
    151 }
    152 #endif
    153 /*}}}*/
    154 /*FUNCTION BamgMesh::SetMatlabStructureField{{{1*/
    155 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    156 void BamgMesh::SetMatlabStructureField(mxArray* matlab_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer){
    157 
    158         /*Intermediary*/
    159         int         i1,i2;
    160         mxArray*    pfield=NULL;
    161         mxArray*    pfield2=NULL;
    162 
    163         /*Copy field*/
    164         double*  fieldcopy=NULL;
    165         if (fieldrows*fieldcols){
    166                 fieldcopy=(double*)xmalloc(fieldrows*fieldcols*sizeof(double));
    167                 for(i1=0;i1<fieldrows;i1++){
    168                         for(i2=0;i2<fieldcols;i2++){
    169                                 fieldcopy[fieldcols*i1+i2]=fieldpointer[fieldcols*i1+i2];
    170                         }
    171                 }
    172         }
    173 
    174         /*Set matlab field*/
    175         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    176         mxSetM(pfield,fieldcols);
    177         mxSetN(pfield,fieldrows);
    178         mxSetPr(pfield,fieldcopy);
    179         mexCallMATLAB(1,&pfield2,1,&pfield,"transpose");//transpose
    180         mxSetField(matlab_struct,0,fieldname,pfield2);
    181 }
    182 #endif
    183 /*}}}*/

  • issm/trunk-jpl/src/c/objects/Bamg/BamgMesh.h

    r11861 r12011  
    44#ifndef _BAMGMESH_H_
    55#define _BAMGMESH_H_
    6 
    7 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    8 #include <mex.h>
    9 #endif
    106
    117class BamgMesh{
    … …  
    5147
    5248                BamgMesh();
    53                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    54                 BamgMesh(mxArray* matlab_struct);
    55                 #endif
     49                BamgMesh(void* module_struct);
    5650                ~BamgMesh();
    5751
    58                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    59                 void SetMatlabStructureFields(mxArray** matlab_struct);
    60                 void SetMatlabStructureField(mxArray* matlab_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
    61                 #endif
     52                void SetStructureFields(void* module_struct);
     53                void SetStructureField(void* module_struct,const char* fieldname,int fieldrows,int fieldcols,double* fieldpointer);
    6254
    6355};

  • issm/trunk-jpl/src/c/objects/Bamg/BamgOpts.cpp

    r11936 r12011  
    4040
    4141}
    42 /*}}}*/
    43 /*FUNCTION BamgOpts::BamgOpts(mxArray* matlab_struct){{{1*/
    44 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    45 BamgOpts::BamgOpts(mxArray* matlab_struct){
    46 
    47         FetchData(&this->anisomax,mxGetField(matlab_struct,0,"anisomax"));
    48         FetchData(&this->cutoff,mxGetField(matlab_struct,0,"cutoff"));
    49         FetchData(&this->coeff,mxGetField(matlab_struct,0,"coeff"));
    50         FetchData(&this->errg,mxGetField(matlab_struct,0,"errg"));
    51         FetchData(&this->gradation,mxGetField(matlab_struct,0,"gradation"));
    52         FetchData(&this->Hessiantype,mxGetField(matlab_struct,0,"Hessiantype"));
    53         FetchData(&this->MaxCornerAngle,mxGetField(matlab_struct,0,"MaxCornerAngle"));
    54         FetchData(&this->maxnbv,mxGetField(matlab_struct,0,"maxnbv"));
    55         FetchData(&this->maxsubdiv,mxGetField(matlab_struct,0,"maxsubdiv"));
    56         FetchData(&this->Metrictype,mxGetField(matlab_struct,0,"Metrictype"));
    57         FetchData(&this->nbjacobi,mxGetField(matlab_struct,0,"nbjacobi"));
    58         FetchData(&this->nbsmooth,mxGetField(matlab_struct,0,"nbsmooth"));
    59         FetchData(&this->omega,mxGetField(matlab_struct,0,"omega"));
    60         FetchData(&this->power,mxGetField(matlab_struct,0,"power"));
    61         FetchData(&this->verbose,mxGetField(matlab_struct,0,"verbose"));
    62 
    63         FetchData(&this->Crack,mxGetField(matlab_struct,0,"Crack"));
    64         FetchData(&this->geometricalmetric,mxGetField(matlab_struct,0,"geometricalmetric"));
    65         FetchData(&this->KeepVertices,mxGetField(matlab_struct,0,"KeepVertices"));
    66         FetchData(&this->splitcorners,mxGetField(matlab_struct,0,"splitcorners"));
    67 
    68         FetchData(&this->hmin,mxGetField(matlab_struct,0,"hmin"));
    69         FetchData(&this->hmax,mxGetField(matlab_struct,0,"hmax"));
    70         FetchData(&this->hminVertices,&this->hminVerticesSize[0],&this->hminVerticesSize[1],mxGetField(matlab_struct,0,"hminVertices"));
    71         FetchData(&this->hmaxVertices,&this->hmaxVerticesSize[0],&this->hmaxVerticesSize[1],mxGetField(matlab_struct,0,"hmaxVertices"));
    72         FetchData(&this->hVertices,&this->hVerticesSize[0],&this->hVerticesSize[1],mxGetField(matlab_struct,0,"hVertices"));
    73         FetchData(&this->metric,&this->metricSize[0],&this->metricSize[1],mxGetField(matlab_struct,0,"metric"));
    74         FetchData(&this->field,&this->fieldSize[0],&this->fieldSize[1],mxGetField(matlab_struct,0,"field"));
    75         FetchData(&this->err,&this->errSize[0],&this->errSize[1],mxGetField(matlab_struct,0,"err"));
    76 
    77         /*Additional checks*/
    78         this->Check();
    79 
    80 }
    81 #endif
    8242/*}}}*/
    8343/*FUNCTION BamgOpts::~BamgOpts() {{{1*/

  • issm/trunk-jpl/src/c/objects/Bamg/BamgOpts.h

    r11861 r12011  
    55#ifndef _BAMGOPTS_H_
    66#define _BAMGOPTS_H_
    7 
    8 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    9 #include <mex.h>
    10 #endif
    117
    128class BamgOpts{
    … …  
    5450
    5551                BamgOpts();
    56                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    57                 BamgOpts(mxArray* matlab_struct);
    58                 #endif
     52                BamgOpts(void* module_struct);
    5953                ~BamgOpts();
    6054

  • issm/trunk-jpl/src/c/objects/ExternalResults/BoolExternalResult.cpp

    r11936 r12011  
    185185}
    186186/*}}}*/
    187 /*FUNCTION BoolExternalResult::SetMatlabField{{{1*/
    188 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    189 void BoolExternalResult::SetMatlabField(mxArray* dataref){
    190 
    191         char* name=NULL;
    192         this->GetResultName(&name);
    193        
    194         mxSetField( dataref, this->step-1, name,mxCreateDoubleScalar((double)value));
    195         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    196         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    197 }
    198 #endif
    199 /*}}}*/
    200187/*FUNCTION BoolExternalResult::GetStep{{{1*/
    201188int BoolExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/BoolExternalResult.h

    r11936 r12011  
    5959                void  WriteData(FILE* fid,bool io_gather);
    6060                void  GetResultName(char**);
    61             #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    62                 void  SetMatlabField(mxArray* dataref);
    63                 #endif
    6461                int   GetStep(void);
    6562                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleExternalResult.cpp

    r11936 r12011  
    181181}
    182182/*}}}*/
    183 /*FUNCTION DoubleExternalResult::SetMatlabField{{{1*/
    184 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    185 void DoubleExternalResult::SetMatlabField(mxArray* dataref){
    186 
    187         char* name=NULL;
    188         this->GetResultName(&name);
    189         mxSetField( dataref,this->step-1, name,mxCreateDoubleScalar(value));
    190         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    191         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    192 
    193 }
    194 #endif
    195 /*}}}*/
    196183/*FUNCTION DoubleExternalResult::GetStep{{{1*/
    197184int DoubleExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleExternalResult.h

    r11936 r12011  
    6060                void  WriteData(FILE* fid,bool io_gather);
    6161                void  GetResultName(char**);
    62                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    63                 void  SetMatlabField(mxArray* dataref);
    64                 #endif
    6562                int   GetStep(void);
    6663                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp

    r11936 r12011  
    222222}
    223223/*}}}*/
    224 /*FUNCTION DoubleMatExternalResult::SetMatlabField{{{1*/
    225 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    226 void DoubleMatExternalResult::SetMatlabField(mxArray* dataref){
    227 
    228         mxArray* pfield=NULL;
    229         mxArray* pfield2=NULL;
    230         char* name=NULL;
    231         double* doublemat=NULL;
    232 
    233         /*Make a copy of the value, to be used by matlab: */
    234         doublemat=(double*)xmalloc(M*N*sizeof(double));
    235         memcpy(doublemat,values,M*N*sizeof(double));
    236 
    237         /*recover name: */
    238         this->GetResultName(&name);
    239                                
    240         /*create matlab matrix: */
    241         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    242         mxSetM(pfield,N);
    243         mxSetN(pfield,M);
    244         mxSetPr(pfield,doublemat);
    245        
    246         /*transpose the matrix, from c to matlab format */
    247         mexCallMATLAB(1,&pfield2, 1, &pfield, "transpose");
    248 
    249         /*set tranpose matrix inside the dataref structure: */
    250         mxSetField( dataref, this->step-1, name,pfield2);
    251         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    252         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    253 
    254 }
    255 #endif
    256 /*}}}*/
    257224/*FUNCTION DoubleMatExternalResult::GetStep{{{1*/
    258225int DoubleMatExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleMatExternalResult.h

    r11936 r12011  
    6161                void  WriteData(FILE* fid,bool io_gather);
    6262                void  GetResultName(char**);
    63                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    64                 void  SetMatlabField(mxArray* dataref);
    65                 #endif
    6663                int   GetStep(void);
    6764                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp

    r11936 r12011  
    206206}
    207207/*}}}*/
    208 /*FUNCTION DoubleVecExternalResult::SetMatlabField{{{1*/
    209 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    210 void DoubleVecExternalResult::SetMatlabField(mxArray* dataref){
    211 
    212         mxArray *pfield    = NULL;
    213         double  *doublemat = NULL;
    214         char    *name      = NULL;
    215         double  *doublevec = NULL;
    216 
    217         /*Make a copy of the value, to be used by matlab: */
    218         doublevec=(double*)xmalloc(M*sizeof(double));
    219         memcpy(doublevec,values,M*sizeof(double));
    220 
    221         /*recover name: */
    222         this->GetResultName(&name);
    223                                
    224         /*create matlab matrix: */
    225         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    226         mxSetM(pfield,M);
    227         mxSetN(pfield,1);
    228         mxSetPr(pfield,doublevec);
    229 
    230         mxSetField( dataref, this->step-1, name,pfield);
    231         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    232         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    233 }
    234 #endif
    235 /*}}}*/
    236208/*FUNCTION DoubleVecExternalResult::GetStep{{{1*/
    237209int DoubleVecExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleVecExternalResult.h

    r11936 r12011  
    6060                void  WriteData(FILE* fid,bool io_gather);
    6161                void  GetResultName(char**);
    62                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    63                 void  SetMatlabField(mxArray* dataref);
    64                 #endif
    6562                int   GetStep(void);
    6663                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/ExternalResult.h

    r11861 r12011  
    3333                virtual void  WriteData(FILE* fid,bool io_gather)=0;
    3434                virtual void  GetResultName(char**)=0;
    35                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    36                 virtual void  SetMatlabField(mxArray* dataref)=0;
    37                 #endif
    3835                virtual int   GetStep(void)=0;
    3936                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/IntExternalResult.cpp

    r11936 r12011  
    185185}
    186186/*}}}*/
    187 /*FUNCTION IntExternalResult::SetMatlabField{{{1*/
    188 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    189 void IntExternalResult::SetMatlabField(mxArray* dataref){
    190 
    191         char* name=NULL;
    192         this->GetResultName(&name);
    193 
    194         mxSetField( dataref, this->step-1, name,mxCreateDoubleScalar(value));
    195         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    196         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    197 
    198 }
    199 #endif
    200 /*}}}*/
    201187/*FUNCTION IntExternalResult::GetStep{{{1*/
    202188int IntExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/IntExternalResult.h

    r11936 r12011  
    5858                void  WriteData(FILE* fid,bool io_gather);
    5959                void  GetResultName(char**);
    60                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    61                 void  SetMatlabField(mxArray* dataref);
    62                 #endif
    6360                int   GetStep(void);
    6461                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/PetscVecExternalResult.cpp

    r11936 r12011  
    244244}
    245245/*}}}*/
    246 /*FUNCTION PetscVecExternalResult::SetMatlabField{{{1*/
    247 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    248 void  PetscVecExternalResult::SetMatlabField(mxArray* dataref){
    249 
    250         mxArray* pfield=NULL;
    251         char* name=NULL;
    252         double* doublevec=NULL;
    253         int M;
    254        
    255         VecToMPISerial(&doublevec,value);
    256         VecGetSize(value,&M);
    257         this->GetResultName(&name);
    258        
    259         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    260         mxSetM(pfield,M);
    261         mxSetN(pfield,1);
    262         mxSetPr(pfield,doublevec);
    263        
    264         mxSetField( dataref, this->step-1, name, pfield);
    265         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    266         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    267 
    268 }
    269 #endif
    270 /*}}}*/
    271246/*FUNCTION PetscVecExternalResult::GetStep{{{1*/
    272247int PetscVecExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/PetscVecExternalResult.h

    r11936 r12011  
    6060                void  WriteData(FILE* fid,bool io_gather);
    6161                void  GetResultName(char**);
    62                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    63                 void  SetMatlabField(mxArray* dataref);
    64                 #endif
    6562                int   GetStep(void);
    6663                /*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/StringExternalResult.cpp

    r11936 r12011  
    197197}
    198198/*}}}*/
    199 /*FUNCTION StringExternalResult::SetMatlabField{{{1*/
    200 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    201 void  StringExternalResult::SetMatlabField(mxArray* dataref){
    202        
    203         char* name=NULL;
    204 
    205         this->GetResultName(&name);
    206 
    207         mxSetField( dataref, this->step-1, name, mxCreateString(value));
    208         mxSetField( dataref, this->step-1, "time",mxCreateDoubleScalar((double)this->time));
    209         mxSetField( dataref, this->step-1, "step",mxCreateDoubleScalar((double)this->step));
    210 
    211 }
    212 #endif
    213 /*}}}*/
    214199/*FUNCTION StringExternalResult::GetStep{{{1*/
    215200int StringExternalResult::GetStep(void){

  • issm/trunk-jpl/src/c/objects/ExternalResults/StringExternalResult.h

    r11936 r12011  
    6060                void  WriteData(FILE* fid,bool io_gather);
    6161                void  GetResultName(char**);
    62                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    63                 void  SetMatlabField(mxArray* dataref);
    64                 #endif
    6562                int   GetStep(void);
    6663                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Numerics/Matrix.cpp

    r11936 r12011  
    140140}
    141141/*}}}*/
    142 
    143 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    144 /*FUNCTION Matrix::ToMatlabMatrix{{{1*/
    145 mxArray* Matrix::ToMatlabMatrix(void){
    146 
    147         mxArray* dataref=NULL;
    148         #ifdef _HAVE_PETSC_
    149         PetscMatrixToMatlabMatrix(&dataref,this->matrix);
    150         #else
    151         dataref=this->matrix->ToMatlabMatrix();
    152         #endif
    153         return dataref;
    154 
    155 }
    156 /*}}}*/
    157 /*FUNCTION MatlabMatrixToMatrix{{{1*/
    158 Matrix* MatlabMatrixToMatrix(const mxArray* mxmatrix){
    159 
    160         int dummy;
    161         Matrix* matrix=NULL;
    162 
    163         /*allocate matrix object: */
    164         matrix=new Matrix();
    165 
    166         #ifdef _HAVE_PETSC_
    167         MatlabMatrixToPetscMatrix(&matrix->matrix,NULL,NULL,mxmatrix);
    168         #else
    169         matrix->matrix=MatlabMatrixToSeqMat(mxmatrix);
    170         #endif
    171        
    172         return matrix;
    173 }
    174 /*}}}*/
    175 #endif
    176142/*FUNCTION Matrix::Assemble{{{1*/
    177143void Matrix::Assemble(void){

  • issm/trunk-jpl/src/c/objects/Numerics/Matrix.h

    r11936 r12011  
    5151                /*Matrix specific routines {{{1*/
    5252                void Echo(void);
    53                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    54                 mxArray* ToMatlabMatrix(void);
    55                 #endif
    5653                void Assemble(void);
    5754                double Norm(NormMode norm_type);
    … …  
    6663
    6764};
    68 /*API: */
    69 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    70 Matrix* MatlabMatrixToMatrix(const mxArray* mxmatrix);
    71 #endif
    7265
    7366#endif //#ifndef _MATRIX_H_

  • issm/trunk-jpl/src/c/objects/Numerics/Vector.cpp

    r11920 r12011  
    132132}
    133133/*}}}*/
    134 
    135 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    136 /*FUNCTION Vector::ToMatlabVector{{{1*/
    137 mxArray* Vector::ToMatlabVector(void){
    138 
    139         mxArray* dataref=NULL;
    140         #ifdef _HAVE_PETSC_
    141         PetscVectorToMatlabVector(&dataref,this->vector);
    142         #else
    143         dataref=this->vector->ToMatlabVector();
    144         #endif
    145         return dataref;
    146 
    147 }
    148 /*}}}*/
    149 /*FUNCTION MatlabVectorToVector{{{1*/
    150 Vector* MatlabVectorToVector(const mxArray* mxvector){
    151 
    152         int dummy;
    153         Vector* vector=NULL;
    154 
    155         /*allocate vector object: */
    156         vector=new Vector();
    157 
    158         #ifdef _HAVE_PETSC_
    159         MatlabVectorToPetscVector(&vector->vector,&dummy,mxvector);
    160         #else
    161         vector->vector=MatlabVectorToSeqVec(mxvector);
    162         #endif
    163        
    164         return vector;
    165 }
    166 /*}}}*/
    167 #endif
    168134/*FUNCTION Vector::Assemble{{{1*/
    169135void Vector::Assemble(void){

  • issm/trunk-jpl/src/c/objects/Numerics/Vector.h

    r11861 r12011  
    5454                /*Vector specific routines {{{1*/
    5555                void Echo(void);
    56                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    57                 mxArray* ToMatlabVector(void);
    58                 #endif
    5956                void    AXPY(Vector *X, double a);
    6057                void    AYPX(Vector *X, double a);
    … …  
    7774};
    7875
    79 /*API: */
    80 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    81 Vector* MatlabVectorToVector(const mxArray* mxvector);
    82 #endif
    8376
    8477#endif //#ifndef _VECTOR_H_

  • issm/trunk-jpl/src/c/objects/OptArgs.h

    r11861 r12011  
    66#define _OPTARGS_H_
    77
    8 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    9 
    10 #include "mex.h"
    11 struct OptArgs{
    12         char* function_name;
    13         mxArray* femmodel;
    14 };
    15 
    16 #else
    17 
    188class Model;
    199struct OptArgs{
    2010        FemModel* femmodel;
    2111};
    22 #endif
    2312
    2413#endif

  • issm/trunk-jpl/src/c/objects/Params/BoolParam.cpp

    r11936 r12011  
    134134}
    135135/*}}}*/
    136 /*FUNCTION BoolParam::SetMatlabField{{{1*/
    137 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    138 void  BoolParam::SetMatlabField(mxArray* dataref){
    139         char* name=NULL;
    140         this->GetParameterName(&name);
    141         mxSetField( dataref, 0, name,mxCreateDoubleScalar((double)value));
    142 }
    143 #endif
    144 /*}}}*/
    145136/*FUNCTION BoolParam::UnitConversion{{{1*/
    146137void  BoolParam::UnitConversion(int direction_enum){

  • issm/trunk-jpl/src/c/objects/Params/BoolParam.h

    r11936 r12011  
    8181               
    8282                void GetParameterName(char**pname);
    83                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    84                 void  SetMatlabField(mxArray* dataref);
    85                 #endif
    8683                /*}}}*/
    8784};

  • issm/trunk-jpl/src/c/objects/Params/DoubleMatArrayParam.cpp

    r11936 r12011  
    308308}
    309309/*}}}*/
    310 /*FUNCTION StringArrayParam::SetMatlabField{{{1*/
    311 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    312 void  DoubleMatArrayParam::SetMatlabField(mxArray* dataref){
    313        
    314         int      i,m,n;
    315         double*  matrix=NULL;
    316         double*  outmatrix=NULL;
    317         char*    name=NULL;
    318         mwSize   dims[2]={0};
    319         mxArray* pfield=NULL;
    320         mxArray* pfield2=NULL;
    321         mxArray* pfield3=NULL;
    322        
    323         this->GetParameterName(&name);
    324         dims[0]=this->M;
    325         dims[1]=1;
    326         pfield=mxCreateCellArray(2,dims);
    327 
    328         for(i=0;i<this->M;i++){
    329                 matrix=this->array[i];
    330                 m=this->mdim_array[i];
    331                 n=this->ndim_array[i];
    332                 outmatrix=(double*)xmalloc(m*n*sizeof(double));
    333                 memcpy(outmatrix,matrix,m*n*sizeof(double));
    334        
    335                 pfield2=mxCreateDoubleMatrix(0,0,mxREAL);
    336                 mxSetM(pfield2,n);
    337                 mxSetN(pfield2,m);
    338                 mxSetPr(pfield2,outmatrix);
    339 
    340                 //transpose the outmatrix, written directly to matlab! from C to matlab.
    341                 mexCallMATLAB(1,&pfield3, 1, &pfield2, "transpose");
    342        
    343                 mxSetCell(pfield,i,pfield3);
    344         }
    345        
    346         mxSetField( dataref, 0, name,pfield);
    347 }
    348 #endif
    349 /*}}}*/
    350310/*FUNCTION DoubleMatArrayParam::SetValue(double** array, int M, int* mdim_array, int* ndim_array){{{1*/
    351311void  DoubleMatArrayParam::SetValue(double** in_array, int in_M, int* in_mdim_array, int* in_ndim_array){

  • issm/trunk-jpl/src/c/objects/Params/DoubleMatArrayParam.h

    r11936 r12011  
    8484
    8585                void GetParameterName(char**pname);
    86                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    87                 void  SetMatlabField(mxArray* dataref);
    88                 #endif
    8986
    9087                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/DoubleMatParam.cpp

    r11936 r12011  
    190190}
    191191/*}}}*/
    192 /*FUNCTION DoubleMatParam::SetMatlabField{{{1*/
    193 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    194 void  DoubleMatParam::SetMatlabField(mxArray* dataref){
    195 
    196         mxArray* pfield=NULL;
    197         mxArray* pfield2=NULL;
    198         double* doublemat=NULL;
    199         char* name=NULL;
    200        
    201         this->GetParameterName(&name);
    202         this->GetParameterValue(&doublemat,NULL,NULL);
    203                                
    204         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    205         mxSetM(pfield,N);
    206         mxSetN(pfield,M);
    207         mxSetPr(pfield,doublemat);
    208        
    209         //transpose the matrix, written directly to matlab! from C to matlab.
    210         mexCallMATLAB(1,&pfield2, 1, &pfield, "transpose");
    211         mxSetField( dataref, 0, name,pfield2);
    212 }
    213 #endif
    214 /*}}}*/
    215192/*FUNCTION DoubleMatParam::SetValue{{{1*/
    216193void  DoubleMatParam::SetValue(double* doublearray,int in_M,int in_N){

  • issm/trunk-jpl/src/c/objects/Params/DoubleMatParam.h

    r11936 r12011  
    8484
    8585                void GetParameterName(char**pname);
    86                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    87                 void  SetMatlabField(mxArray* dataref);
    88                 #endif
    8986
    9087                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/DoubleParam.cpp

    r11936 r12011  
    219219}
    220220/*}}}*/
    221 /*FUNCTION DoubleParam::SetMatlabField{{{1*/
    222 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    223 void  DoubleParam::SetMatlabField(mxArray* dataref){
    224 
    225         char* name=NULL;
    226         this->GetParameterName(&name);
    227         mxSetField( dataref, 0, name,mxCreateDoubleScalar(value));
    228 }
    229 #endif
    230 /*}}}*/
    231221/*FUNCTION DoubleParam::UnitConversion{{{1*/
    232222void  DoubleParam::UnitConversion(int direction_enum){

  • issm/trunk-jpl/src/c/objects/Params/DoubleParam.h

    r11936 r12011  
    8282
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784
    8885                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/DoubleVecParam.cpp

    r11936 r12011  
    202202}
    203203/*}}}*/
    204 /*FUNCTION DoubleVecParam::SetMatlabField{{{1*/
    205 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    206 void  DoubleVecParam::SetMatlabField(mxArray* dataref){
    207 
    208         char* name=NULL;
    209         double* doublevec=NULL;
    210         mxArray* pfield=NULL;
    211 
    212         this->GetParameterValue(&doublevec,NULL);
    213         this->GetParameterName(&name);
    214                                
    215         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    216         mxSetM(pfield,M);
    217         mxSetN(pfield,1);
    218         mxSetPr(pfield,doublevec);
    219        
    220         mxSetField( dataref, 0, name, pfield);
    221 }
    222 #endif
    223 /*}}}*/
    224204/*FUNCTION DoubleVecParam::SetValue{{{1*/
    225205void  DoubleVecParam::SetValue(double* doublearray,int in_M){

  • issm/trunk-jpl/src/c/objects/Params/DoubleVecParam.h

    r11936 r12011  
    8282               
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784                /*}}}*/
    8885};

  • issm/trunk-jpl/src/c/objects/Params/FileParam.cpp

    r11936 r12011  
    101101}
    102102/*}}}*/
    103 /*FUNCTION FileParam::SetMatlabField{{{1*/
    104 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    105 void  FileParam::SetMatlabField(mxArray* dataref){
    106        
    107         _error_("FileParam is a pointer and cannot be converted into a matlab object");
    108 }
    109 #endif
    110 /*}}}*/
    111103/*FUNCTION FileParam::UnitConversion{{{1*/
    112104void  FileParam::UnitConversion(int direction_enum){

  • issm/trunk-jpl/src/c/objects/Params/FileParam.h

    r11936 r12011  
    8181
    8282                void GetParameterName(char**pname);
    83                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    84                 void  SetMatlabField(mxArray* dataref);
    85                 #endif
    8683
    8784                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/IntMatParam.cpp

    r11936 r12011  
    172172}
    173173/*}}}*/
    174 /*FUNCTION IntMatParam::SetMatlabField{{{1*/
    175 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    176 void  IntMatParam::SetMatlabField(mxArray* dataref){
    177 
    178         char    *name        = NULL;
    179         double  *doublearray = NULL;
    180         int     *intarray    = NULL;
    181         mxArray *pfield      = NULL;
    182         mxArray *pfield2     = NULL;
    183 
    184         this->GetParameterValue(&intarray,NULL,NULL);
    185         this->GetParameterName(&name);
    186 
    187         /*cast intarray into doublearray for Matlab*/
    188         doublearray=(double*)xmalloc(M*N*sizeof(double));
    189         for(int i=0;i<M*N;i++)doublearray[i]=(double)intarray[i];
    190         xfree((void**)&intarray);
    191 
    192         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    193         mxSetM(pfield,M);
    194         mxSetN(pfield,N);
    195         mxSetPr(pfield,doublearray);
    196 
    197         //transpose the matrix, written directly to matlab! from C to matlab.
    198         mexCallMATLAB(1,&pfield2, 1, &pfield, "transpose");
    199         mxSetField( dataref, 0, name,pfield2);
    200 }
    201 #endif
    202 /*}}}*/
    203174/*FUNCTION IntMatParam::SetValue{{{1*/
    204175void  IntMatParam::SetValue(int* intarray,int in_M,int in_N){

  • issm/trunk-jpl/src/c/objects/Params/IntMatParam.h

    r11936 r12011  
    8383
    8484                void GetParameterName(char**pname);
    85                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    86                 void  SetMatlabField(mxArray* dataref);
    87                 #endif
    8885
    8986                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/IntParam.cpp

    r11936 r12011  
    134134}
    135135/*}}}*/
    136 /*FUNCTION IntParam::SetMatlabField{{{1*/
    137 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    138 void  IntParam::SetMatlabField(mxArray* dataref){
    139        
    140         char* name=NULL;
    141         this->GetParameterName(&name);
    142         mxSetField( dataref, 0, name,mxCreateDoubleScalar((double)value));
    143 }
    144 #endif
    145 /*}}}*/
    146136/*FUNCTION IntParam::UnitConversion{{{1*/
    147137void  IntParam::UnitConversion(int direction_enum){

  • issm/trunk-jpl/src/c/objects/Params/IntParam.h

    r11936 r12011  
    8282
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784
    8885                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/IntVecParam.cpp

    r11936 r12011  
    185185}
    186186/*}}}*/
    187 /*FUNCTION IntVecParam::SetMatlabField{{{1*/
    188 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    189 void  IntVecParam::SetMatlabField(mxArray* dataref){
    190 
    191         char    *name      = NULL;
    192         double  *doublevec = NULL;
    193         int     *intvec    = NULL;
    194         mxArray *pfield    = NULL;
    195 
    196         this->GetParameterValue(&intvec,NULL);
    197         this->GetParameterName(&name);
    198 
    199         /*cast intvec into doublevec for Matlab*/
    200         if(M){
    201                 doublevec=(double*)xmalloc(M*sizeof(double));
    202                 for(int i=0;i<M;i++)doublevec[i]=(double)intvec[i];
    203         }
    204         else doublevec=NULL;
    205         xfree((void**)&intvec);
    206                                
    207         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    208         mxSetM(pfield,M);
    209         mxSetN(pfield,1);
    210         mxSetPr(pfield,doublevec);
    211        
    212         mxSetField(dataref, 0, name, pfield);
    213 }
    214 #endif
    215 /*}}}*/
    216187/*FUNCTION IntVecParam::SetValue{{{1*/
    217188void  IntVecParam::SetValue(int* intarray,int in_M){

  • issm/trunk-jpl/src/c/objects/Params/IntVecParam.h

    r11936 r12011  
    8383               
    8484                void GetParameterName(char**pname);
    85                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    86                 void  SetMatlabField(mxArray* dataref);
    87                 #endif
    8885                /*}}}*/
    8986};

  • issm/trunk-jpl/src/c/objects/Params/MatrixParam.cpp

    r11936 r12011  
    190190}
    191191/*}}}*/
    192 /*FUNCTION MatrixParam::SetMatlabField{{{1*/
    193 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    194 void  MatrixParam::SetMatlabField(mxArray* dataref){
    195        
    196         char* name=NULL;
    197         int   M,N;
    198         double* doublemat=NULL;
    199         mxArray* pfield=NULL;
    200 
    201         doublemat=value->ToSerial();
    202         value->GetSize(&M,&N);
    203         this->GetParameterName(&name);
    204                                
    205         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    206         mxSetM(pfield,M);
    207         mxSetN(pfield,N);
    208         mxSetPr(pfield,doublemat);
    209         mxSetField( dataref, 0, name, pfield);
    210 }
    211 #endif
    212 /*}}}*/
    213192/*FUNCTION MatrixParam::SetValue{{{1*/
    214193void  MatrixParam::SetValue(Matrix* matrix){

  • issm/trunk-jpl/src/c/objects/Params/MatrixParam.h

    r11936 r12011  
    8282
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784
    8885                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/Param.h

    r11861 r12011  
    6060                virtual void  UnitConversion(int direction_enum)=0;
    6161                virtual void  GetParameterName(char**pname)=0;
    62                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    63                 virtual void  SetMatlabField(mxArray* dataref)=0;
    64                 #endif
    6562};
    6663#endif

  • issm/trunk-jpl/src/c/objects/Params/StringArrayParam.cpp

    r11936 r12011  
    236236}
    237237/*}}}*/
    238 /*FUNCTION StringArrayParam::SetMatlabField{{{1*/
    239 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    240 void  StringArrayParam::SetMatlabField(mxArray* dataref){
    241        
    242         int      i;
    243         char*    name=NULL;
    244         mwSize   dims[2]={0};
    245         mxArray* pfield=NULL;
    246        
    247         this->GetParameterName(&name);
    248 
    249         dims[0]=this->numstrings;
    250         dims[1]=1;
    251         pfield=mxCreateCellArray(2,dims);
    252         for(i=0;i<this->numstrings;i++){
    253                 char* string=value[i];
    254                 mxSetCell(pfield,i,mxCreateString(string));
    255         }
    256         mxSetField( dataref, 0, name,pfield);
    257 }
    258 #endif
    259 /*}}}*/
    260238/*FUNCTION StringArrayParam::SetValue{{{1*/
    261239void  StringArrayParam::SetValue(char** stringarray,int M){

  • issm/trunk-jpl/src/c/objects/Params/StringArrayParam.h

    r11936 r12011  
    8484
    8585                void GetParameterName(char**pname);
    86                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    87                 void  SetMatlabField(mxArray* dataref);
    88                 #endif
    8986                /*}}}*/
    9087};

  • issm/trunk-jpl/src/c/objects/Params/StringParam.cpp

    r11936 r12011  
    164164}
    165165/*}}}*/
    166 /*FUNCTION StringParam::SetMatlabField{{{1*/
    167 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    168 void  StringParam::SetMatlabField(mxArray* dataref){
    169        
    170         char* name=NULL;
    171 
    172         this->GetParameterName(&name);
    173         mxSetField( dataref, 0, name, mxCreateString(value));
    174 }
    175 #endif
    176 /*}}}*/
    177166/*FUNCTION StringParam::SetValue{{{1*/
    178167void  StringParam::SetValue(char* string){

  • issm/trunk-jpl/src/c/objects/Params/StringParam.h

    r11936 r12011  
    8282
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784
    8885                /*}}}*/

  • issm/trunk-jpl/src/c/objects/Params/VectorParam.cpp

    r11936 r12011  
    188188}
    189189/*}}}*/
    190 /*FUNCTION VectorParam::SetMatlabField{{{1*/
    191 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    192 void  VectorParam::SetMatlabField(mxArray* dataref){
    193 
    194         mxArray* pfield=NULL;
    195         char* name=NULL;
    196         double* doublevec=NULL;
    197         int M;
    198        
    199         doublevec=value->ToMPISerial();
    200         value->GetSize(&M);
    201         this->GetParameterName(&name);
    202        
    203         pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    204         mxSetM(pfield,M);
    205         mxSetN(pfield,1);
    206         mxSetPr(pfield,doublevec);
    207        
    208         mxSetField( dataref, 0, name, pfield);
    209 }
    210 #endif
    211 /*}}}*/
    212190/*FUNCTION VectorParam::SetValue{{{1*/
    213191void  VectorParam::SetValue(Vector* vector){

  • issm/trunk-jpl/src/c/objects/Params/VectorParam.h

    r11936 r12011  
    8282
    8383                void GetParameterName(char**pname);
    84                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    85                 void  SetMatlabField(mxArray* dataref);
    86                 #endif
    8784
    8885                /*}}}*/

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

    r11861 r12011  
    1919#endif
    2020
    21 #if defined(_SERIAL_) && defined(_HAVE_MATLAB_)
    22 #include "mex.h"
    23 #endif
    24 
    2521#include <stdio.h>
    2622#include <stdlib.h>
    … …  
    3733        if(!size)_error_(" attempting to 0 size allocation!");
    3834
    39         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    40         /* Use the matlab api to do the allocation: */
    41         memptr=mxMalloc(size);
    42         #else
    4335        /* Use the c library to do the allocation: */
    4436        memptr=malloc(size);
    45         #endif
    4637        if(!memptr) _error_("memory allocation failed!");
    4738
    … …  
    5546        if(!size)_error_("attempting to 0 size allocation!");
    5647
    57         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    58         /* Use the matlab api to do the allocation: */
    59         memptr=mxCalloc(n,size);
    60         #else
    6148        /* Use the c library to do the allocation: */
    6249        memptr=calloc(n,size);
    63         #endif
    6450        if(!memptr) _error_("memory allocation failed!");
    6551
    … …  
    7056
    7157        if (pv && *pv){
    72                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    73                         mxFree(*pv);
    74                 #else
    75                         free(*pv);
    76                 #endif
     58                free(*pv);
    7759
    7860                *pv=NULL;
    … …  
    8365       
    8466        if (pv && *pv){
    85                 #ifdef _PARALLEL_
    8667                /*There is no mxDelete in the Matlab API -> using delete trips up Matlab. So we
    8768                 * don't actually free memory in Matlab, we let the memory manager do that. We only
    8869                 * free in parallel: */
    8970                delete *pv;
    90                 #else
    91                 /*Actually, still get rid of internal Petsc matrix. Quick fix until Matlab handles C++
    92                  * correctly: */
    93                 #ifdef _HAVE_PETSC_
    94                         MatFree(&(*pv)->matrix);
    95                 #endif
    96                 #endif
    9771                *pv=NULL;
    9872        }
    … …  
    10276
    10377        if (pv && *pv){
    104                 #ifdef _PARALLEL_
    10578                /*There is no mxDelete in the Matlab API -> using delete trips up Matlab. So we
    10679                 * don't actually free memory in Matlab, we let the memory manager do that. We only
    10780                 * free in parallel: */
    10881                delete *pv;
    109                 #else
    110                 /*Actually, still get rid of internal Petsc vector. Quick fix until Matlab handles C++
    111                  * correctly: */
    112                 #ifdef _HAVE_PETSC_
    113                         VecFree(&(*pv)->vector);
    114                 #endif
    115                 #endif
    11682                *pv=NULL;
    11783        }
    … …  
    12490       
    12591        if(!size)_error_("attempting to realloc to zero");
    126 
    127         #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    128         value = (void*)mxRealloc(pv,size);
    129         #else
    13092        value = (void*)realloc(pv,size);
    131         #endif
    13293
    13394        if (value == NULL) {

  • issm/trunk-jpl/src/c/shared/Numerics/Verbosity.cpp

    r11861 r12011  
    3939        if(level<0) _error_("vebosity level should be a positive integer (user provided %i)",level);
    4040
    41 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    42 
    43         mxArray* output=NULL;
    44         mxArray* input=NULL;
    45         input=mxCreateDoubleScalar((double)level);
    46 
    47         mexCallMATLAB(0,&output,1,&input,"SetVerbosityLevel");
    48 #else
    49 
    5041        verbositylevel = level;
    5142
    52 #endif
    5343}/*}}}*/
    5444/*FUNCTION GetVerbosityLevel {{{*/
    5545int  GetVerbosityLevel(void){
    56 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    57 
    58         mxArray* output=NULL;
    59         mxArray* input=NULL;
    60         double   level;
    61 
    62         mexCallMATLAB(1,&output,0,&input,"GetVerbosityLevel");
    63         level=mxGetScalar(output);
    64 
    65         verbositylevel = (int)level;
    66         return verbositylevel;
    67 
    68 #else
    6946
    7047        _assert_(verbositylevel>=0);
    7148        return verbositylevel;
    7249
    73 #endif
    7450}/*}}}*/

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

    r11941 r12011  
    9292}
    9393/*}}}*/
    94 
    95 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    96 /*FUNCTION SeqMat::ToMatlabMatrix{{{1*/
    97 mxArray* SeqMat::ToMatlabMatrix(void){
    98 
    99         /*Intermediary: */
    100         double* buffer=NULL;
    101         mxArray* pfield=NULL;
    102        
    103         /*output: */
    104         mxArray* dataref=NULL;
    105 
    106         /*copy vector into a new buffer: */
    107         if(this->M*this->N){
    108                 buffer=(double*)xmalloc(this->M*this->N*sizeof(double));
    109                 memcpy(buffer,this->matrix,M*N*sizeof(double));
    110 
    111                 pfield=mxCreateDoubleMatrix(0,0,mxREAL);
    112                 mxSetM(pfield,this->N);
    113                 mxSetN(pfield,this->M);
    114                 mxSetPr(pfield,buffer);
    115                
    116                 //transpose the matrix, written directly to matlab! from C to matlab.
    117                 mexCallMATLAB(1,&dataref, 1, &pfield, "transpose");
    118         }
    119         else dataref=mxCreateDoubleMatrix(0,0,mxREAL);
    120 
    121         /*do not erase buffer!: */
    122         return dataref;
    123 
    124 }
    125 
    126 
    127        
    128        
    129 /*}}}*/
    130 /*FUNCTION MatlabMatrixToSeqMat{{{1*/
    131 SeqMat* MatlabMatrixToSeqMat(const mxArray* dataref){
    132 
    133         SeqMat* output=NULL;
    134 
    135         output=new SeqMat();
    136         MatlabMatrixToDoubleMatrix(&output->matrix,&output->M,&output->N,dataref);
    137         return output;
    138 
    139 }
    140 /*}}}*/
    141 #endif
    14294/*FUNCTION SeqMat::Assemble{{{1*/
    14395void SeqMat::Assemble(void){

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

    r11941 r12011  
    4040                /*SeqMat specific routines {{{1*/
    4141                void Echo(void);
    42                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    43                 mxArray* ToMatlabMatrix(void);
    44                 #endif
    4542                void Assemble(void);
    4643                double Norm(NormMode norm_type);
    … …  
    5653};
    5754               
    58 /*API :*/
    59 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    60 SeqMat*  MatlabMatrixToSeqMat(const mxArray* dataref);
    61 #endif
    62 
    6355#endif //#ifndef _SEQMAT_H_

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

    r11861 r12011  
    6666/*}}}*/
    6767
    68 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    69 /*FUNCTION SeqVec::ToMatlabVector{{{1*/
    70 mxArray* SeqVec::ToMatlabVector(void){
    71 
    72         double* buffer=NULL;
    73        
    74         mxArray* dataref=NULL;
    75 
    76         /*copy vector into a new buffer: */
    77         if(this->M){
    78                 buffer=(double*)xmalloc(this->M*sizeof(double));
    79                 memcpy(buffer,vector,M*sizeof(double));
    80 
    81                 dataref = mxCreateDoubleMatrix(0,0,mxREAL);
    82                 mxSetM(dataref,this->M);
    83                 mxSetN(dataref,1);
    84                 mxSetPr(dataref,buffer);       
    85         }
    86         else dataref = mxCreateDoubleMatrix(0,0,mxREAL);
    87 
    88 
    89         /*do not erase buffer!: */
    90         return dataref;
    91 
    92 }
    93 /*}}}*/
    94 /*FUNCTION MatlabVectorToSeqVec{{{1*/
    95 SeqVec* MatlabVectorToSeqVec(const mxArray* dataref){
    96 
    97         SeqVec* output=NULL;
    98 
    99         output=new SeqVec();
    100         MatlabVectorToDoubleVector(&output->vector,&output->M,dataref);
    101         return output;
    102 
    103 }
    104 /*}}}*/
    105 #endif
    10668/*FUNCTION SeqVec::Assemble{{{1*/
    10769void SeqVec::Assemble(void){

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

    r11861 r12011  
    3737                /*SeqVec specific routines {{{1*/
    3838                void Echo(void);
    39                 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    40                 mxArray* ToMatlabVector(void);
    41                 #endif
    4239                void Assemble(void);
    4340                void SetValues(int ssize, int* list, double* values, InsMode mode);
    … …  
    5956};
    6057
    61 
    62 /*API :*/
    63 #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    64 SeqVec*  MatlabVectorToSeqVec(const mxArray* dataref);
    65 #endif
    66 
    6758#endif //#ifndef _SEQVEC_H_

  • issm/trunk-jpl/startup.py

    r11930 r12011  
    7979from miscellaneous import *
    8080from private import *
    81 from TriMesh import *
    8281
    8382#}}}

  • issm/trunk-jpl/test/NightlyRun/test101.py

    r11977 r12011  
    11from model import *
    2 from TriMesh import *
     2from TriMesh.Python import *
    33
    4 md=model()
     4#md=model()
     5#md=triangle(md,'../Exp/Square.exp',150000);
     6
    57[a,b,c,d,e]=TriMesh('../Exp/Square.exp',15000.0**2.0,True)
    68print(a,b,c,d,e)
Note: See TracChangeset for help on using the changeset viewer.