Changeset 6372

Timestamp:

10/21/10 12:35:35 (14 years ago)

Author:

Eric.Larour

Message:

Simplified OutputResults module. Now also handles I/O in parallel. Not tested yet in parallel.

Location:

issm/trunk

Files:

• src/c/Container/DataSet.h (modified) (4 diffs)
• src/c/Container/Elements.cpp (modified) (1 diff)
• src/c/Container/Elements.h (modified) (1 diff)
• src/c/Container/Materials.h (modified) (1 diff)
• src/c/Container/Results.cpp (modified) (1 diff)
• src/c/Container/Results.h (modified) (1 diff)
• src/c/Container/Vertices.h (modified) (1 diff)
• src/c/Makefile.am (modified) (2 diffs)
• src/c/modules/ModelProcessorx/CreateParameters.cpp (modified) (1 diff)
• src/c/modules/OutputResultsx/ElementResultsToPatch.cpp (deleted)
• src/c/modules/OutputResultsx/FileWriteResults.cpp (deleted)
• src/c/modules/OutputResultsx/MatlabWriteResults.cpp (deleted)
• src/c/modules/OutputResultsx/OutputResultsx.cpp (modified) (1 diff)
• src/c/modules/OutputResultsx/OutputResultsx.h (modified) (1 diff)
• src/c/objects/FemModel.cpp (modified) (3 diffs)
• src/c/objects/FemModel.h (modified) (2 diffs)
• src/c/objects/IoModel.cpp (modified) (2 diffs)
• src/c/objects/IoModel.h (modified) (1 diff)
• src/c/solutions/issm.cpp (modified) (4 diffs)
• src/c/solutions/transient2d_core.cpp (modified) (1 diff)
• src/c/solutions/transient3d_core.cpp (modified) (1 diff)
• src/m/classes/@model/model.m (modified) (1 diff)
• src/m/classes/@model/setdefaultparameters.m (modified) (1 diff)
• src/m/enum/IoGatherEnum.m (added)
• src/m/enum/IoSplitEnum.m (added)
• src/m/enum/OutputFileNameEnum.m (added)
• src/m/model/marshall.m (modified) (1 diff)
• src/m/solutions/transient2d_core.m (modified) (1 diff)
• src/m/solutions/transient3d_core.m (modified) (1 diff)
• src/mex/OutputResults/OutputResults.cpp (modified) (2 diffs)
• test/NightlyRun/test101.m (modified) (1 diff)
• test/NightlyRun/test102.m (modified) (1 diff)

issm/trunk/src/c/Container/DataSet.h

@@ -13 +13 @@
 /*forward declarations */
 
-
 class Elements;
 class Loads;
@@ -20 +19 @@
 class Materials;
 class Parameters;
+class Patch;
+class Results;
+class Patch;
 
 class DataSet{
@@ -62 +64 @@
                 DataSet* Copy(void);
                 int   DeleteObject(Object* object);
+                Results* SpawnTriaResults(int* indices);
                 /*}}}*/
 
@@ -69 +72 @@
 DataSet* DataSetDemarshall(char* marshalled_dataset);
 DataSet* DataSetDemarshallRaw(char** pmarshalled_dataset);
+        
+
 
 #endif

issm/trunk/src/c/Container/Elements.cpp

@@ -42 +42 @@
 /*}}}*/
 
+
+
 /*Object management*/
+/*FUNCTION Elements::ProcessResultsUnits{{{1*/
+void Elements::ProcessResultsUnits(void){
+
+        int i;
+
+        //Process results to be output in the correct units
+        for(i=0;i<this->Size();i++){
+                Element* element=(Element*)this->GetObjectByOffset(i);
+                element->ProcessResultsUnits();
+        }
+}
+/*}}}*/
+/*FUNCTION Elements::DeleteResults{{{1*/
+void Elements::DeleteResults(void){
+        
+        int i;
+
+        for (i=0;i<this->Size();i++){
+                Element* element=(Element*)this->GetObjectByOffset(i);
+                element->DeleteResults();
+        }
+}
+/*}}}*/
+/*FUNCTION Elements::ToResults{{{1*/
+void Elements::ToResults(Results* results,Parameters* parameters,int step, double time){
+
+        /*output: */
+        Patch* patch=NULL;
+
+        /*I/O strategy: */
+        bool   io_gather=true; //the default
+
+        /*Recover parameters: */
+        parameters->FindParam(&io_gather,IoGatherEnum);
+
+
+        /*create patch object out of all results in this dataset: */
+        patch=this->ResultsToPatch();
+
+        /*Gather onto master cpu 0, if needed: */
+        #ifdef _PARALLEL_
+        if(io_gather)patch->MPI_Gather();
+        #endif
+        
+        /*create result object and add to results dataset:*/
+        if (patch->maxvertices && patch->maxnodes){
+                results->AddObject(new IntExternalResult(results->Size()+1,PatchVerticesEnum,patch->maxvertices,step,time));
+                results->AddObject(new IntExternalResult(results->Size()+1,PatchNodesEnum,   patch->maxnodes,step,time));
+                results->AddObject(new DoubleMatExternalResult(results->Size()+1,PatchEnum,patch->values,patch->numrows,patch->numcols,step,time));
+        }
+
+        /*Free ressources:*/
+        delete patch;
+
+}
+/*}}}*/
+/*FUNCTION Elements::ResultsToPatch{{{1*/
+Patch* Elements::ResultsToPatch(void){ 
+
+        /*output: */
+        Patch* patch=NULL;
+
+        /*intermediary: */
+        int i;
+        int count;
+        int numrows;
+        int numvertices;
+        int numnodes;
+        int max_numvertices;
+        int max_numnodes;
+        int element_numvertices;
+        int element_numrows;
+        int element_numnodes;
+
+        /*We are going to extract from the results within the elements, the desired results , and create a table 
+         * of patch information, that will hold, for each element that computed the result that 
+         * we desire, the enum_type of the result, the step and time, the id of the element, the interpolation type, the vertices ids, and the values 
+         * at the nodes (could be different from the vertices). This will be used for visualization purposes. 
+         * For example, we could build the following patch table, for velocities: 
+         * 
+         1. on a Beam element, Vx, at step 1, time .5, element id 1, interpolation type P0 (constant), vertices ids 1 and 2, one constant value 4.5
+         VxEnum 1  .5  1 P0  1 2       4.5 NaN  NaN
+         2. on a Tria element, Vz, at step 2, time .8, element id 2, interpolation type P1 (linear), vertices ids 1 3 and 4, with values at 3 nodes 4.5, 3.2, 2.5
+         VzEnum 2  .8  2 P1  1 3 4     4.5 3.2  2.5
+         * ... etc ...
+         *
+         * So what do we need to build the table: the maximum number of vertices included in the table, 
+         * and the maximum number of nodal values, as well as the number of rows. Once we have that, 
+         * we ask the elements to fill their own row in the table, by looping on the elememnts. 
+         *
+         * We will use the Patch object, which will store all of the information needed, and will be able 
+         * to output itself to disk on its own. See object/Patch.h for format of this object.*/
+        
+        /*First, determine maximum number of vertices, nodes, and number of results: */
+        numrows=0;
+        numvertices=0;
+        numnodes=0;
+
+        for(i=0;i<this->Size();i++){
+
+                Element* element=(Element*)this->GetObjectByOffset(i);
+                element->PatchSize(&element_numrows,&element_numvertices,&element_numnodes);
+
+                numrows+=element_numrows;
+                if(element_numvertices>numvertices)numvertices=element_numvertices;
+                if(element_numnodes>numnodes)numnodes=element_numnodes;
+        }
+
+        #ifdef _PARALLEL_
+        /*Synchronize across cluster, so as to not end up with different sizes for each patch on each cpu: */
+        MPI_Reduce (&numvertices,&max_numvertices,1,MPI_INT,MPI_MAX,0,MPI_COMM_WORLD );
+        MPI_Bcast(&max_numvertices,1,MPI_INT,0,MPI_COMM_WORLD);
+        numvertices=max_numvertices;
+
+        MPI_Reduce (&numnodes,&max_numnodes,1,MPI_INT,MPI_MAX,0,MPI_COMM_WORLD );
+        MPI_Bcast(&max_numnodes,1,MPI_INT,0,MPI_COMM_WORLD);
+        numnodes=max_numnodes;
+        #endif
+
+        /*Ok, initialize Patch object: */
+        patch=new Patch(numrows,numvertices,numnodes);
+
+        /*Now, go through elements, and fill the Patch object: */
+        count=0;
+        for(i=0;i<this->Size();i++){
+                Element* element=(Element*)this->GetObjectByOffset(i);
+                element->PatchFill(&count,patch);
+        }
+
+        return patch;
+
+}
+/*}}}*/

issm/trunk/src/c/Container/Elements.h

@@ -27 +27 @@
                 /*}}}*/
                 /*numerics: {{{1*/
+                void ProcessResultsUnits(void);
+                void DeleteResults(void);
+                void ToResults(Results* results,Parameters* parameters,int step, double time);
+                Patch* ResultsToPatch(void);
                 /*}}}*/
 

issm/trunk/src/c/Container/Materials.h

@@ -7 +7 @@
 
 /*forward declarations */
-class Materials;
 class Parameters;
 class Elements;

issm/trunk/src/c/Container/Results.cpp

@@ -69 +69 @@
 }
 /*}}}*/
+/*FUNCTION Results::Write{{{1*/
+#ifdef _SERIAL_
+void Results::Write(mxArray** pdataref){
+
+        int i,j;
+        int count;
+
+        /*output: */
+        mxArray* dataref=NULL;
+        mxArray* processeddataref=NULL;
+        mwSize nfields;
+        mwSize maxfields;
+        mwSize nsteps;
+        mwSize step;
+        const char **fnames      = NULL;
+        int         *enums       = NULL;
+        int          baseenum;
+        mwSize       onebyone[2] = {1,1};
+        mwSize       ndim        = 2;
+
+        /*How many time steps do we have? : */
+        nsteps=0;
+        for(i=0;i<this->Size();i++){
+                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
+                step=result->GetStep();
+                if(step>nsteps)nsteps=step;
+        }
+        onebyone[0]=nsteps;
+
+        /*How many field names do we have. First, figure out how many result types we have: */
+        maxfields=(mwSize)this->Size();
+        enums=(int*)xmalloc(maxfields*sizeof(int));
+        for(i=0;i<maxfields;i++){
+                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
+                enums[i]=result->EnumType();
+        }
+        /*Now, make result types unique: */
+        for(i=0;i<maxfields;i++){
+                if(enums[i]>=0){//if <0, it means this enum was found to replicate another one previously
+                        baseenum=enums[i];              
+                        /*is the baseenum repeated later on?:*/
+                        for(j=i+1;j<maxfields;j++){
+                                if (enums[j]==baseenum)enums[j]=-1;
+                        }
+                }
+                else continue;
+        }
+
+        /*Now, go through enums, and whatever is not null is a non repeated field name: */
+        nfields=0;
+        for(i=0;i<maxfields;i++)if(enums[i]>0)nfields++;
+
+        /*Add 2 fields for time and step: */
+        nfields=nfields+2;
+        
+        /*Fill the names of the structure field: */
+        fnames=(const char**)xmalloc(nfields*sizeof(char*));
+        count=0;
+        for(i=0;i<maxfields;i++){
+                if (enums[i]>0){
+                        fnames[count]=EnumToString(enums[i]);
+                        count++;
+                }
+        }
+        /*don't forget the extra fields "time" and "step":*/
+        fnames[nfields-2]="time";
+        fnames[nfields-1]="step";
+
+        /*Initialize structure: */
+        dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames);
+
+        /*Fill each field: */
+        for(i=0;i<nfields-2;i++){ //do not include the last one used for time
+                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
+                result->SetMatlabField(dataref);
+        }
+
+        /*Now, process the patch in the dataref structure, by calling MatlabProcessPatch.m 
+         *on the current dataref structure: */
+        mexCallMATLAB(1,&processeddataref,1,&dataref, "MatlabProcessPatch");
+
+        /*Assign output pointers:*/
+        *pdataref=processeddataref;
+}
+#else 
+void Results::Write(Parameters* parameters){
+        
+        int         i;
+        FILE       *fid          = NULL;
+
+        /*Recover file descriptor: */
+        parameters->FindParam(&fid,OutputFilePointerEnum);
+
+        for(i=0;i<this->Size();i++){
+
+                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
+
+                /*write result to disk: */
+                result->WriteData(fid);
+
+        }
+
+}
+#endif
+/*}}}*/

issm/trunk/src/c/Container/Results.h

@@ -27 +27 @@
                 /*numerics: {{{1*/
                 Results* SpawnTriaResults(int* indices);
+                #ifdef _SERIAL_
+                void Write(mxArray** pdataref);
+                #else 
+                void Write(Parameters* parameters);
+                #endif
                 /*}}}*/
-
 };
-
-
-
 #endif //ifndef _RESULTS_H_
 

issm/trunk/src/c/Container/Vertices.h

@@ -8 +8 @@
 /*forward declarations */
 class Materials;
-class Parameters;
 class Elements;
 class Vertices;

issm/trunk/src/c/Makefile.am

@@ -415 +415 @@
                                         ./modules/OutputResultsx/OutputResultsx.h\
                                         ./modules/OutputResultsx/OutputResultsx.cpp\
-                                        ./modules/OutputResultsx/ElementResultsToPatch.cpp\
-                                        ./modules/OutputResultsx/MatlabWriteResults.cpp\
                                         ./modules/MinVelx/MinVelx.h\
                                         ./modules/MinVelx/MinVelx.cpp\
@@ -989 +987 @@
                                         ./modules/OutputResultsx/OutputResultsx.h\
                                         ./modules/OutputResultsx/OutputResultsx.cpp\
-                                        ./modules/OutputResultsx/ElementResultsToPatch.cpp\
-                                        ./modules/OutputResultsx/FileWriteResults.cpp\
                                         ./modules/MinVelx/MinVelx.h\
                                         ./modules/MinVelx/MinVelx.cpp\

issm/trunk/src/c/modules/ModelProcessorx/CreateParameters.cpp

@@ -72 +72 @@
         parameters->AddObject(new IntParam(NumberOfElementsEnum,iomodel->numberofelements));
         parameters->AddObject(new BoolParam(KffEnum,iomodel->kff));
+        parameters->AddObject(new BoolParam(IoGatherEnum,iomodel->io_gather));
+        parameters->AddObject(new BoolParam(IoSplitEnum,iomodel->io_split));
 
         /*Deal with more complex parameters*/

issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp

@@ -17 +17 @@
                 
 #ifdef _SERIAL_
-void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,DataSet** presults, int step, double time){
+void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results** presults, int step, double time){
 #else                                                                                                                                                                                             
-void OutputResultsx(                    Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,DataSet** presults, int step, double time){
+void OutputResultsx(                    Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results** presults, int step, double time){
 #endif
 
-        /*Intermediaries*/
-        int      i;
-        int      solutiontype;
-        DataSet *results;
-        Element *element;
+        extern int  my_rank;
+        FILE       *fid                     = NULL;
+        char       *outputfilename          = NULL;
+        char        cpu_outputfilename[100];        //easier to convert an integer with sprintf
+        bool        io_gather;
+        bool        io_split;
+        int         solutiontype;
+        Results    *results                 = NULL;
 
-        /*Recover results*/
+        /*recover results dataset: */
         results=*presults;
-        
-        /*Transfer element results into the femmodel->results dataset: */
-        ElementResultsToPatch( elements,  nodes,  vertices,  loads, materials, parameters,results,step,time);
 
-        #ifdef _PARALLEL_
+
+        /*We have results inside our elements, loads, etc ... Get them out of there, into the results dataset: */
+        elements->ProcessResultsUnits();
+        elements->ToResults(results,parameters,step,time);
+        elements->DeleteResults();
+
+
         /*Results do not include the type of solution being run . In parallel, we output results to a filename, 
          *therefore, we need to include the solutiontype into the filename: */
-        parameters->FindParam(&solutiontype,SolutionTypeEnum);
-        results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToString(solutiontype),1,0));
+        #ifdef _PARALLEL_
+        if(my_rank==0){
+                parameters->FindParam(&solutiontype,SolutionTypeEnum);
+                results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToString(solutiontype),1,0));
+        }
+
+
+        /*Now, open file for writing, if not already done: */
+        if(!parameters->FindParam(&fid,OutputFilePointerEnum)){
+                
+                /*We don't have a file pointer. Retrieve the output file name and open it for writing:*/
+                parameters->FindParam(&outputfilename,OutputFileNameEnum);
+
+
+                /*What strategy? : */
+                parameters->FindParam(&io_gather,IoGatherEnum);
+                parameters->FindParam(&io_split,IoSplitEnum);
+                
+
+                if(io_gather){
+                        /*Just open the file for output on cpu 0. We are gathering the data on cpu 0 from all other cpus: */
+                        if(my_rank==0) fid=pfopen(outputfilename ,"wb");
+                }
+                if(io_split){
+                        /*We are opening different  files for output on all cpus. Append the  rank to the filename, and open: */
+                        sprintf(cpu_outputfilename,"%s.%i",outputfilename,my_rank);
+                        fid=pfopen(cpu_outputfilename ,"wb");
+                }
+                
+                /*Add file pointer in parameters for further calls to OutputResultsx: */
+                parameters->SetParam(fid,OutputFilePointerEnum);
+        }
+
         #endif
 
-        /*Write data to matlab structure or filename: */
+        /*Write results to disk (in parallel), or to memory (in serial mode): */
         #ifdef _SERIAL_
-                /*Write Matlab structure*/
-                MatlabWriteResults(pdataref,parameters,results);
-
-                /*DO NOT delete results serially*/
+                results->Write(pdataref);
         #else
-                /*Write File*/
-                FileWriteResults(parameters,results);
-
-                /*Now delete results (ElementResults and ExternalResults)*/
-                delete results;
-                for (i=0;i<elements->Size();i++){
-                        element=(Element*)elements->GetObjectByOffset(i);
-                        element->DeleteResults();
-                }
+                results->Write(parameters);
         #endif
 
 
+        /*Delete and reinitialize results, in parallel: */
+        #ifdef _PARALLEL_
+                delete results; results=new Results();
+        #endif
 
-        /*We have to reinitialize results for next step*/
-        results=new DataSet();
+        /*Assign output pointers:*/
         *presults=results;
-
 }

issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.h

@@ -16 +16 @@
 #ifdef _SERIAL_
 #include <mex.h>
-void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters,DataSet** results,int step=1,double time=0);
-void MatlabWriteResults(mxArray** pdataref, Parameters* parameters, DataSet* results);
+void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results** presults,int step=1,double time=0);
 #else
-void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters,DataSet** results,int step=1,double time=0);
-void FileWriteResults(Parameters* parameters, DataSet* results);
+void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results** presults,int step=1,double time=0);
 #endif
-
-/* local prototypes: */
-void ElementResultsToPatch(Elements* elements,  Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,DataSet* results,int step, double time);
 
 #endif  /* _OUTPUTRESULTS_H */

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

@@ -20 +20 @@
 /*Object constructors and destructor*/
 /*FUNCTION FemModel::constructor {{{1*/
-FemModel::FemModel(ConstDataHandle IOMODEL,const int in_solution_type,const int* analyses,const int nummodels){
+FemModel::FemModel(char* inputfilename, char* outputfilename, const int in_solution_type,const int* analyses,const int nummodels){
+#ifdef _PARALLEL_
 
         /*intermediary*/
         int i;
         int analysis_type;
+        FILE* IOMODEL;
+
+        /*Open input file on cpu 0: */
+        if(my_rank==0) IOMODEL= pfopen(inputfilename ,"rb");
 
         /*Initialize internal data: */
@@ -30 +35 @@
         this->solution_type=in_solution_type;
         this->analysis_counter=nummodels-1; //point to last analysis_type carried out.
-        this->results=new DataSet(); //not initialized by CreateDataSets
+        this->results=new Results(); //not initialized by CreateDataSets
         
         /*Dynamically allocate whatever is a list of length nummodels: */
@@ -72 +77 @@
                 ConfigureObjectsx(elements, loads, nodes, vertices, materials,parameters);
         }
+        
+        /*Close input file descriptors: */
+        if(my_rank==0) pfclose(IOMODEL,inputfilename);
+
+        /*Add output file name to parameters: */
+        this->parameters->AddObject(new StringParam(OutputFileNameEnum,outputfilename));
+
+#endif
+
 }
+
 /*}}}1*/
 /*FUNCTION FemModel::destructor {{{1*/

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

@@ -34 +34 @@
                 Materials*          materials;  //one set of materials, for each element
                 Parameters*         parameters; //one set of parameters, independent of the analysis_type
-                DataSet*            results; //results that cannot be fit into the elements (such as one time constants, arrays, strings, etc ...)
+                Results*            results; //results that cannot be fit into the elements (such as one time constants, arrays, strings, etc ...)
 
                 //multiple  sets of matrices/vectors for each analysis_type. m stands for multiple
@@ -46 +46 @@
 
                 /*constructors, destructors: */
-                FemModel(ConstDataHandle IOMODEL,const int solution_type,const int* analyses,const int nummodels);
+                FemModel(char* inputfilename, char* outputfilename, const int solution_type,const int* analyses,const int nummodels);
                 ~FemModel();
 

issm/trunk/src/c/objects/IoModel.cpp

@@ -211 +211 @@
                 IoModelFetchData(&this->qmu_mass_flux_num_profiles,iomodel_handle,"qmu_mass_flux_num_profiles");
         }
+        /*i/o: */
+        IoModelFetchData(&this->io_gather,iomodel_handle,"io_gather");
+        IoModelFetchData(&this->io_split,iomodel_handle,"io_split");
         
         /*parameter output : */
@@ -247 +250 @@
         this->gridonmacayeal=NULL;
         this->gridonpattyn=NULL;
+        this->io_gather=1;
+        this->io_split=0;
         
         this->vx_obs=NULL;

issm/trunk/src/c/objects/IoModel.h

@@ -55 +55 @@
                 double* pressure;
                 double* temperature;
+
+                /*i/o: */
+                int    io_gather;
+                int    io_split;
 
                 /*observations: */

issm/trunk/src/c/solutions/issm.cpp

@@ -12 +12 @@
 
         /*I/O: */
-        FILE     *input_fid        = NULL;
         FILE     *output_fid       = NULL;
-        char     *inputfilename    = NULL;
         char     *petscoptionsfilename = NULL;
-        char     *outputfilename   = NULL;
         char     *lockname         = NULL;
         bool      qmu_analysis     = false;
@@ -53 +50 @@
         _printf_("Launching solution sequence\n");
         solution_type=StringToEnum(argv[1]);
-        inputfilename=argv[3];
         petscoptionsfilename=argv[4];
-        outputfilename=argv[5];
         lockname=argv[6];
 
@@ -64 +59 @@
         SolutionConfiguration(&analyses,&numanalyses,&solutioncore,solution_type);
 
-        /*Open input file to process model
-         * and ouput file to start unload results*/
-        input_fid =pfopen(inputfilename ,"rb");
-        output_fid=pfopen(outputfilename,"wb");
-
-        femmodel=new FemModel(input_fid,solution_type,analyses,numanalyses);
-
-        /*add output_fid to parameters: */
-        femmodel->parameters->SetParam(output_fid,OutputFilePointerEnum);
+        /*Create femmodel, using input file: */
+        femmodel=new FemModel(argv[3] /*input*/,argv[5] /*output*/,solution_type,analyses,numanalyses);
 
         /*add petsc options to parameters: */
@@ -112 +100 @@
 
         /*Close output file and write lock file if requested*/
-        pfclose(output_fid,outputfilename);
+        femmodel->parameters->FindParam(&output_fid,OutputFilePointerEnum); pfclose(output_fid,argv[5]);
         if (waitonlock>0){
                 _printf_("write lock file:\n");

issm/trunk/src/c/solutions/transient2d_core.cpp

@@ -43 +43 @@
         
                 /*Increment*/
-                if(time_adapt) TimeAdaptx(&dt,femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters); 
+                if(time_adapt){
+                        TimeAdaptx(&dt,femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters); 
+                        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,dt,DtEnum);
+                }
                 time+=dt;
                 step+=1;

issm/trunk/src/c/solutions/transient3d_core.cpp

@@ -43 +43 @@
 
                 /*Increment*/
-                if(time_adapt) TimeAdaptx(&dt,femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters); 
+                if(time_adapt){
+                        TimeAdaptx(&dt,femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters); 
+                        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,dt,DtEnum);
+                }
                 step+=1;
                 time+=dt;

issm/trunk/src/m/classes/@model/model.m

@@ -41 +41 @@
         md.elementconnectivity=NaN;
         md.edges=NaN;
+
+        %I/O
+        md.io_gather=NaN;
+        md.io_split=NaN;
 
         %Initial 2d mesh 

issm/trunk/src/m/classes/@model/setdefaultparameters.m

@@ -245 +245 @@
 %solution speed-up
 md.kff=0;
+
+%i/o:
+md.io_gather=1;
+md.io_split=0;

issm/trunk/src/m/model/marshall.m

@@ -182 +182 @@
 WriteData(fid,md.outputfilename,'String','outputfilename');
 
+%i/o: 
+WriteData(fid,md.io_gather,'Integer','io_gather');
+WriteData(fid,md.io_split,'Integer','io_split');
+
+
 %close file
 st=fclose(fid);

issm/trunk/src/m/solutions/transient2d_core.m

@@ -22 +22 @@
 
                 %increment
-                if(time_adapt) dt=TimeAdapt(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters); end
+                if(time_adapt),
+                        dt=TimeAdapt(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters); end
+                        [femmodel.elements]=InputUpdateFromConstant(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters,dt,DtEnum);
+                end
                 step=step+1;
                 time=time+dt;

issm/trunk/src/m/solutions/transient3d_core.m

@@ -22 +22 @@
 
                 %Increment
-                if(time_adapt) dt=TimeAdapt(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters); end
+                if(time_adapt),
+                        dt=TimeAdapt(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters); end
+                        [femmodel.elements]=InputUpdateFromConstant(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters,dt,DtEnum);
+                end
                 step=step+1;
                 time=time+dt;

issm/trunk/src/mex/OutputResults/OutputResults.cpp

@@ -14 +14 @@
         Materials* materials=NULL;
         Parameters* parameters=NULL;
-        DataSet* results=NULL;
+        Results* results=NULL;
         
         /* output datasets: */
@@ -32 +32 @@
         FetchData((DataSet**)&materials,MATERIALS);
         FetchParams(&parameters,PARAMETERS);
-        FetchData(&results,RESULTS);
+        FetchData((DataSet**)&results,RESULTS);
 
         /*results might be NILL, allocate: */

issm/trunk/test/NightlyRun/test101.m

@@ -5 +5 @@
 md.cluster=none;
 md=solve(md,'analysis_type',DiagnosticSolutionEnum);
+md.verbose=verbose('mprocessor',true,'module',true,'solution',true,'solver',true,'convergence',true,'qmu',true,'control',true);
+
 
 %Fields and tolerances to track changes

issm/trunk/test/NightlyRun/test102.m

@@ -4 +4 @@
 md=setelementstype(md,'macayeal','all');
 md=SetParallel(md,3);
+md.cluster.np=1;
 md=solve(md,'analysis_type',DiagnosticSolutionEnum);