Changeset 4039


Ignore:
Timestamp:
06/11/10 11:10:11 (15 years ago)
Author:
Eric.Larour
Message:

New OutputResults module, relying on patches, and embedded element results

Location:
issm/trunk
Files:
14 added
5 deleted
266 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp

    r4032 r4039  
    3131                case AnalysisTypeEnum : return "AnalysisType";
    3232                case SubAnalysisTypeEnum : return "SubAnalysisType";
     33                case AnalysisCounterEnum : return "AnalysisCounter";
    3334                case DiagnosticAnalysisEnum : return "DiagnosticAnalysis";
    3435                case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis";
    … …  
    201202                case P0Enum : return "P0";
    202203                case P1Enum : return "P1";
    203                 case StringResultEnum : return "StringResult";
    204                 case DoubleVecResultEnum : return "DoubleVecResult";
    205                 case DoubleMatResultEnum : return "DoubleMatResult";
     204                case DoubleResultEnum : return "DoubleResult";
     205                case TriaVertexResultEnum : return "TriaVertexResult";
     206                case PentaVertexResultEnum : return "PentaVertexResult";
     207                case SingVertexResultEnum : return "SingVertexResult";
     208                case BeamVertexResultEnum : return "BeamVertexResult";
    206209                case BetaEnum : return "Beta";
    207210                case CmGradientEnum : return "CmGradient";

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

    r4037 r4039  
    238238        TriaVertexResultEnum,
    239239        PentaVertexResultEnum,
     240        SingVertexResultEnum,
     241        BeamVertexResultEnum,
    240242        /*}}}*/
    241243        /*Parameters{{{1*/

  • issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp

    r4032 r4039  
    2929        else if (strcmp(name,"AnalysisType")==0) return AnalysisTypeEnum;
    3030        else if (strcmp(name,"SubAnalysisType")==0) return SubAnalysisTypeEnum;
     31        else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum;
    3132        else if (strcmp(name,"DiagnosticAnalysis")==0) return DiagnosticAnalysisEnum;
    3233        else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum;
    … …  
    199200        else if (strcmp(name,"P0")==0) return P0Enum;
    200201        else if (strcmp(name,"P1")==0) return P1Enum;
    201         else if (strcmp(name,"StringResult")==0) return StringResultEnum;
    202         else if (strcmp(name,"DoubleVecResult")==0) return DoubleVecResultEnum;
    203         else if (strcmp(name,"DoubleMatResult")==0) return DoubleMatResultEnum;
     202        else if (strcmp(name,"DoubleResult")==0) return DoubleResultEnum;
     203        else if (strcmp(name,"TriaVertexResult")==0) return TriaVertexResultEnum;
     204        else if (strcmp(name,"PentaVertexResult")==0) return PentaVertexResultEnum;
     205        else if (strcmp(name,"SingVertexResult")==0) return SingVertexResultEnum;
     206        else if (strcmp(name,"BeamVertexResult")==0) return BeamVertexResultEnum;
    204207        else if (strcmp(name,"Beta")==0) return BetaEnum;
    205208        else if (strcmp(name,"CmGradient")==0) return CmGradientEnum;

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

    r4037 r4039  
    103103                                        ./objects/Node.h\
    104104                                        ./objects/Node.cpp\
    105                                         ./objects/Results/DoubleResults.h\
    106                                         ./objects/Results/DoubleResults.cpp\
    107                                         ./objects/Results/TriaVertexResults.h\
    108                                         ./objects/Results/TriaVertexResults.cpp\
    109                                         ./objects/Results/PentaVertexResults.h\
    110                                         ./objects/Results/PentaVertexResults.cpp\
     105                                        ./objects/Results/ResultLocal.h\
     106                                        ./objects/Results/NodalValuesUnitConversion.cpp\
     107                                        ./objects/Results/DoubleResult.h\
     108                                        ./objects/Results/DoubleResult.cpp\
     109                                        ./objects/Results/TriaVertexResult.h\
     110                                        ./objects/Results/TriaVertexResult.cpp\
     111                                        ./objects/Results/PentaVertexResult.h\
     112                                        ./objects/Results/PentaVertexResult.cpp\
     113                                        ./objects/Results/SingVertexResult.h\
     114                                        ./objects/Results/SingVertexResult.cpp\
     115                                        ./objects/Results/BeamVertexResult.h\
     116                                        ./objects/Results/BeamVertexResult.cpp\
    111117                                        ./objects/Elements/Tria.h\
    112118                                        ./objects/Elements/Tria.cpp\
    … …  
    131137                                        ./objects/Inputs/DoubleInput.h\
    132138                                        ./objects/Inputs/DoubleInput.cpp\
    133                                         ./objects/Inputs/ProcessResults.cpp\
    134139                                        ./objects/Elements/Sing.h\
    135140                                        ./objects/Elements/Sing.cpp\
    … …  
    518523                                        ./objects/Bamg/GeometricalVertex.h\
    519524                                        ./objects/Bamg/GeometricalVertex.cpp\
    520                                         ./objects/Bamg/Geometry.cpp\
    521525                                        ./objects/Bamg/Geometry.h\
    522526                                        ./objects/Bamg/ListofIntersectionTriangles.cpp\
    … …  
    536540                                        ./objects/Bamg/Triangle.cpp\
    537541                                        ./objects/Bamg/Triangle.h\
    538                                         ./objects/Bamg/Triangles.cpp\
    539542                                        ./objects/Bamg/Triangles.h\
    540543                                        ./objects/Bamg/MeshVertex.cpp\
    … …  
    571574                                        ./objects/Hook.h\
    572575                                        ./objects/Hook.cpp\
    573                                         ./objects/Results/DoubleResults.h\
    574                                         ./objects/Results/DoubleResults.cpp\
    575                                         ./objects/Results/TriaVertexResults.h\
    576                                         ./objects/Results/TriaVertexResults.cpp\
    577                                         ./objects/Results/PentaVertexResults.h\
    578                                         ./objects/Results/PentaVertexResults.cpp\
     576                                        ./objects/Results/ResultLocal.h\
     577                                        ./objects/Results/NodalValuesUnitConversion.cpp\
     578                                        ./objects/Results/DoubleResult.h\
     579                                        ./objects/Results/DoubleResult.cpp\
     580                                        ./objects/Results/TriaVertexResult.h\
     581                                        ./objects/Results/TriaVertexResult.cpp\
     582                                        ./objects/Results/PentaVertexResult.h\
     583                                        ./objects/Results/PentaVertexResult.cpp\
     584                                        ./objects/Results/SingVertexResult.h\
     585                                        ./objects/Results/SingVertexResult.cpp\
     586                                        ./objects/Results/BeamVertexResult.h\
     587                                        ./objects/Results/BeamVertexResult.cpp\
    579588                                        ./objects/Elements/Tria.h\
    580589                                        ./objects/Elements/Tria.cpp\
    … …  
    599608                                        ./objects/Inputs/DoubleInput.h\
    600609                                        ./objects/Inputs/DoubleInput.cpp\
    601                                         ./objects/Inputs/ProcessResults.cpp\
    602610                                        ./objects/Elements/Sing.h\
    603611                                        ./objects/Elements/Sing.cpp\

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

    r4021 r4039  
    11/*!\file:  OutputResults.cpp
    2  * \brief: go through results dataset, and for each result, write it to disk.
     2 * \brief: go through our finite elements, and see what results they have stored within.
     3 * Then output them into serialized patch arrays, and dump to disk.
    34 */
    45
    … …  
    1415#include "../../objects/objects.h"
    1516               
    16 void OutputResults(FemModel* femmodel, char* filename,int analysis_type){
     17void OutputResults(FemModel* femmodel, char* filename){
    1718
     19        int solutiontype;
     20        int numrows;
     21        int numvertices;
     22        int numnodes;
     23        int max_numvertices;
     24        int max_numnodes;
    1825
    19         ISSMERROR(" not supported yet!");
     26        /*First, configure elements*/
     27        femmodel->elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     28
     29        //Recover solutiontype which will be output to disk:
     30        femmodel->parameters->FindParam(&solutiontype,SolutionTypeEnum);
     31
     32        //Process results to be output in the correct units
     33        for(i=0;i<femmodel->elements->Size();i++){
     34                Element* element=femmodel->elements->GetObjectByOffset(i);
     35                element->ProcessResultsUnits();
     36        }
     37
     38        /*We are going to extract from the results within the elements, the desired results , and create a table
     39         * of patch information, that will hold, for each element that computed the result that
     40         * 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
     41         * at the nodes (could be different from the vertices). This will be used for visualization purposes.
     42         * For example, we could build the following patch table, for velocities:
     43         *
     44         * VxEnum 1  .5  1 P0  1 2       4.5 NaN  NaN //on a Beam element, Vx, at step 1, time .5, element id 1, interpolation type P0 (constant value on a beam element), vertices ids 1 and 2, one constant value 4.5
     45         * VzEnum 2  .8  2 P1  1 3 4     4.5 3.2  2.5 //on a Tria element, Vz, at step 2, time .8, element id 2, interpolation type P1  (linear values on a tria element), vertices ids 1 3 and 4, with values at 3 nodes 4.5, 3.2, 2.5
     46         * ... etc ...
     47         *
     48         * So what do we need to build the table: the maximum number of vertices included in the table,
     49         * and the maximum number of nodal values, as well as the number of rows. Once we have that,
     50         * we ask the elements to fill their own row in the table, by looping on the elememnts.
     51         *
     52         * We will use the Patch object, which will store all of the information needed, and will be able
     53         * to output itself to disk on its own. See object/Patch.h for format of this object.*/
    2054       
    21        
    22 //     
    23 //     
    24 //      int i;
    25 //      Result* result=NULL;
    26 //      FILE* fid=NULL;
    27 //      extern int my_rank;
    28 //
    29 //      /* Open output file to write raw binary data: */
    30 //      if(my_rank==0){
    31 //              fid=pfopen(filename,"wb");
    32 //
    33 //              for(i=0;i<results->Size();i++){
    34 //                      result=(Result*)results->GetObjectByOffset(i);
    35 //
    36 //                      /*write result to disk: */
    37 //                      result->WriteData(fid);
    38 //              }
    39 //             
    40 //              /*Close file: */
    41 //              pfclose(fid,filename);
    42 //      }
    43 //
    44 //
    45 //      /*output if we have rifts: */
    46 //      if(numrifts){
    47 //              OutputRiftsx( &riftproperties,fem_dh->loads,numrifts);
    48 //              results->AddObject(new Result(results->Size()+1,0,1,"riftproperties",riftproperties));
    49 //      }
    50 //
     55        /*First, determine maximum number of vertices, nodes, and number of results: */
     56        numrows=0;
     57        numvertices=0;
     58        numnodes=0;
     59
     60        for(i=0;i<femmodel->elements->Size();i++){
     61                Element* element=femmodel->elements->GetObjectByOffset(i);
     62                element->PatchSize(&element_numrows,&element_numvertices,&element_numnodes);
     63
     64                numrows+=element_numrows;
     65                if(element_numvertices>numvertices)numvertices=element_numvertices;
     66                if(element_numnodes>numnodes)numnodes=element_numnodes;
     67        }
     68
     69        #ifdef _PARALLEL_
     70        /*Synchronize across cluster, so as to not end up with different sizes for each patch on each cpu: */
     71        MPI_Reduce (&numvertices,&max_numvertices,1,MPI_INT,MPI_MAX,0,MPI_COMM_WORLD );
     72        MPI_Bcast(&max_numvertices,1,MPI_INT,0,MPI_COMM_WORLD);
     73        numvertices=max_numvertices;
     74
     75        MPI_Reduce (&numnodes,&max_numnodes,1,MPI_INT,MPI_MAX,0,MPI_COMM_WORLD );
     76        MPI_Bcast(&max_numnodes,1,MPI_INT,0,MPI_COMM_WORLD);
     77        numnodes=max_numnodes;
     78        #endif
     79
     80        /*Ok, initialize Patch object: */
     81        patch=new Patch(numrows,numvertices,numnodes);
     82
     83        /*Now, go through elements, and fill the Patch object: */
     84        count=0;
     85        for(i=0;i<elements->Size();i++){
     86                Element* element=(Element*)elements->GetObjectByOffset(i);
     87                element->PatchFill(&count,patch);
     88        }
     89
     90        /*Now, gather patch onto node 0, so that we do not dump to disk from every node: */
     91        patch->MPI_Gather();
     92
     93        /*Write to disk:*/
     94        patch->WriteToDisk(solutiontype,filename);
    5195
    5296}

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

    r4021 r4039  
    99
    1010/* local prototypes: */
    11 void OutputResults(FemModel* femmodel, char* filename,int analysis_type);
     11void OutputResults(FemModel* femmodel, char* filename);
    1212
    1313#endif  /* _OUTPUTRESULTS_H */

  • issm/trunk/src/c/objects/Elements/Beam.cpp

    r4037 r4039  
    142142/*FUNCTION Beam::InputToResult(int enum_type,int step,double time){{{1*/
    143143void  Beam::InputToResult(int enum_type,int step,double time){
     144        ISSMERROR(" not supported yet!");
     145}
     146/*}}}*/
     147/*FUNCTION Beam::ProcessResultsUnits(void){{{1*/
     148void  Beam::ProcessResultsUnits(void){
    144149        ISSMERROR(" not supported yet!");
    145150}
    … …  
    618623}
    619624/*}}}*/
    620 /*FUNCTION Beam::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){{{1*/
    621 void  Beam::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){
    622 
    623         int    i;
    624         Input *input       = NULL;
    625         bool   found       = false;
    626         int    numrows;
    627         int    numvertices;
    628         int    numnodes;
    629 
    630         /*Recover counter: */
    631         numrows=*pnumrows;
    632 
    633         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    634         for (i=0;i<this->inputs->Size();i++){
    635                 input=(Input*)this->inputs->GetObjectByOffset(i);
    636                 if (input->EnumType()==enum_type){
    637                         found=true;
    638                         break;
    639                 }
    640         }
    641 
    642         if (!found){
    643                 /*Ok, the input looked for does not exist. No problem. Just be sure numvertices and numnodes
    644                  * are 0, so that they do not increase the size of the patches array. Also, do not increase
    645                  * the counter, as this element has nothing to do with results: */
    646                 numvertices=0;
    647                 numnodes=0;
    648         }
    649         else{
    650                 /*Ok, we found an input with the correct enum_type. Ask it to tell us how many nodal values it
    651                  * holds. : */
    652                 numnodes=input->PatchSize();
    653                 /*We know the number of vertices from this element: */
    654                 numvertices=2;
    655                 /*Increase counter, because this element does hold a result in its inputs: */
     625/*FUNCTION Beam::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){{{1*/
     626void  Beam::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){
     627
     628        int     i;
     629       
     630        /*output: */
     631        int     numrows     = 0;
     632        int     numvertices = 0;
     633        int     numnodes    = 0;
     634
     635        /*Go through all the results objects, and update the counters: */
     636        for (i=0;i<this->results->Size();i++){
     637                Result* result=(Result*)this->results->GetObjectByOffset(i);
     638                /*first, we have one more result: */
    656639                numrows++;
     640                /*now, how many vertices and how many nodal values for this result? :*/
     641                numvertices=2; //this is a beam element, with 2 vertices
     642                numnodes=result->NumberOfNodalValues(); //ask result object.
    657643        }
    658644
    … …  
    664650}
    665651/*}}}*/
    666 /*FUNCTION Beam::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){{{1*/
    667 void  Beam::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){
    668 
    669         /*A patch is made of the following information:
    670          * element_id  interpolation_type  vertex_ids    values.
    671          * For example:
    672 
    673          1 P0  1 2       4.5 NaN
    674          2 P1  1 3       4.5 3.2
    675          3 P0  1 5       5.5 NaN
    676          4 P1  2 4       4.5 3.2
    677 
    678          Here, we will provide the nodal values, after having processed them, can provide: id, and vertices ids.
    679          Then go find an input with enum_type. If we find it, fill in the values at the nodal points.
    680          If we don't find an input, get out of here doing nothing, as this element is not involved in
    681          outputting results.
    682          */
    683 
    684         int      i;
    685         Input   *input      = NULL;
    686         bool     found      = false;
    687         int      count      = 0;
    688         double  *this_patch = NULL;
    689 
    690 
    691         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    692         for (i=0;i<this->inputs->Size();i++){
    693                 input=(Input*)this->inputs->GetObjectByOffset(i);
    694                 if (input->EnumType()==enum_type){
    695                         found=true;
    696                         break;
    697                 }
    698         }
    699 
    700         if (!found){
    701                 /*Ok, the input looked for does not exist. No problem. Just return :*/
    702         }
    703         else{
     652/*FUNCTION Beam::PatchFill(int* pcount, Patch* patch){{{1*/
     653void  Beam::PatchFill(int* pcount, Patch* patch){
     654
     655        int i;
     656        int count;
     657        int vertices_ids[2];
     658
     659
     660        /*recover pointer: */
     661        count=*pcount;
    704662               
    705                 /*First, recover the patches row where we will plug in the information: */
    706                 count=*pcount;
    707 
    708                 /*set this_patch to point at the beginning of the patches row, where we will plug our information :*/
    709                 this_patch=patches+numcols*count;
    710 
    711                 /*Fill in id: */
    712                 this_patch[0]=this->id;
    713 
    714                 /*Fill in vertices ids: */
    715                 for(i=0;i<2;i++) this_patch[2+i]=nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
    716 
    717                 /*We found the input, get it to fill the interpolation type, and the nodal values:*/
    718                 input->PatchFill(this_patch,max_vertices,this->parameters);
    719                
    720                 /*Increase counter, so that next time, we don't point to the same patches row: */
     663        /*will be needed later: */
     664        for(i=0;i<2;i++) vertices_ids[i]=nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
     665
     666        for(i=0;i<this->results->Size();i++){
     667                Result* result=(Result*)this->results->GetObjectByOffset(i);
     668
     669                /*For this result,fill the information in the Patch object (element id + vertices ids), and then hand
     670                 *it to the result object, to fill the rest: */
     671                patch->fillelementinfo(count,this->id,vertices_ids,2);
     672                result->PatchFill(count,patch);
     673
     674                /*increment counter: */
    721675                count++;
    722 
    723                 /*Assign output pointers:*/
    724                 *pcount=count;
    725         }
    726 }
    727 /*}}}*/
     676        }
     677
     678        /*Assign output pointers:*/
     679        *pcount=count;
     680}

  • issm/trunk/src/c/objects/Elements/Beam.h

    r4037 r4039  
    6464                void  DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);
     66                void   ProcessResultsUnits(void);
    6667                /*}}}*/
    6768                /*numerics: {{{1*/
    … …  
    8081                void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
    8182                void  GetNodes(void** vpnodes);
    82                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes,int enum_type);
    83                 void  PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type);
     83                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     84                void  PatchFill(int* pcount, Patch* patch);
    8485
    8586                /*}}}*/

  • issm/trunk/src/c/objects/Elements/Element.h

    r4037 r4039  
    1515class DataSet;
    1616class Parameters;
     17class Patch;
    1718
    1819#include "../../toolkits/toolkits.h"
    … …  
    4748                virtual void   ComputeStrainRate(Vec eps,     int analysis_type,int sub_analysis_type)=0;
    4849                virtual double MassFlux(double* segment,double* ug)=0;
    49                 virtual void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes,int enum_type)=0;
    50                 virtual void   PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type)=0;
     50                virtual void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes)=0;
     51                virtual void   PatchFill(int* pcount, Patch* patch)=0;
    5152                virtual void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type)=0;
    52                 virtual void   InputToResult(int enum_type,int step,double time);
     53                virtual void   InputToResult(int enum_type,int step,double time)=0;
     54                virtual void   ProcessResultsUnits(void)=0;
    5355
    5456                /*Implementation: */

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r4037 r4039  
    613613         * object out of the input, with the additional step and time information: */
    614614        this->results->AddObject(input->SpawnResult(step,time));
     615
     616}
     617/*}}}*/
     618/*FUNCTION Penta::ProcessResultsUnits(void){{{1*/
     619void  Penta::ProcessResultsUnits(void){
     620
     621        int i;
     622
     623        for(i=0;i<this->results->Size();i++){
     624                Result* result=this->results->GetObjectByOffset(i);
     625                result->ProcessUnits(this->parameters);
     626        }
    615627
    616628}
    … …  
    48854897}
    48864898/*}}}*/
    4887 /*FUNCTION Penta::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){{{1*/
    4888 void  Penta::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){
    4889 
    4890         int    i;
    4891         Input *input       = NULL;
    4892         bool   found       = false;
    4893         int    numrows;
    4894         int    numvertices;
    4895         int    numnodes;
    4896 
    4897         /*Recover counter: */
    4898         numrows=*pnumrows;
    4899 
    4900         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    4901         for (i=0;i<this->inputs->Size();i++){
    4902                 input=(Input*)this->inputs->GetObjectByOffset(i);
    4903                 if (input->EnumType()==enum_type){
    4904                         found=true;
    4905                         break;
    4906                 }
    4907         }
    4908 
    4909         if (!found){
    4910                 /*Ok, the input looked for does not exist. No problem. Just be sure numvertices and numnodes
    4911                  * are 0, so that they do not increase the size of the patches array. Also, do not increase
    4912                  * the counter, as this element has nothing to do with results: */
    4913                 numvertices=0;
    4914                 numnodes=0;
    4915         }
    4916         else{
    4917                 /*Ok, we found an input with the correct enum_type. Ask it to tell us how many nodal values it
    4918                  * holds. : */
    4919                 numnodes=input->PatchSize();
    4920                 /*We know the number of vertices from this element: */
    4921                 numvertices=6;
    4922                 /*Increase counter, because this element does hold a result in its inputs: */
     4899/*FUNCTION Penta::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){{{1*/
     4900void  Penta::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){
     4901
     4902        int     i;
     4903       
     4904        /*output: */
     4905        int     numrows     = 0;
     4906        int     numvertices = 0;
     4907        int     numnodes    = 0;
     4908
     4909        /*Go through all the results objects, and update the counters: */
     4910        for (i=0;i<this->results->Size();i++){
     4911                Result* result=(Result*)this->results->GetObjectByOffset(i);
     4912                /*first, we have one more result: */
    49234913                numrows++;
     4914                /*now, how many vertices and how many nodal values for this result? :*/
     4915                numvertices=6; //this is a penta element, with 6 vertices
     4916                numnodes=result->NumberOfNodalValues(); //ask result object.
    49244917        }
    49254918
    … …  
    49314924}
    49324925/*}}}*/
    4933 /*FUNCTION Penta::PatchFill(int* pcount, double* patches,int numcols,int max_vertices);{{{1*/
    4934 void  Penta::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){
    4935 
    4936         /*A patch is made of the following information:
    4937          * element_id  interpolation_type  vertex_ids    values.
    4938          * For example:
    4939 
    4940          1 P0  1 2 4 11 12 14      4.5  NaN  NaN    NaN NaN NaN
    4941          2 P1  2 4 5 12 14 15      4.5  23.3 23.3   4.2 4.2 3.2
    4942          3 P0  5 2 1 15 12 11      5.5  NaN  NaN    NaN NaN NaN
    4943          4 P1  2 3 5 12 13 15      4.5  30.2 322.2  4.2 3.2 8.3
    4944          ...
    4945 
    4946          Here, we can provide: id, and vertices ids.
    4947          Then go find an input with enum_type. If we find it, fill in the values at the nodal points.
    4948          If we don't find an input, get out of here doing nothing, as this element is not involved in
    4949          outputting results.
    4950          */
    4951 
    4952         int      i;
    4953         Input   *input      = NULL;
    4954         bool     found      = false;
    4955         int      count      = 0;
    4956         double  *this_patch = NULL;
    4957 
    4958 
    4959         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    4960         for (i=0;i<this->inputs->Size();i++){
    4961                 input=(Input*)this->inputs->GetObjectByOffset(i);
    4962                 if (input->EnumType()==enum_type){
    4963                         found=true;
    4964                         break;
    4965                 }
    4966         }
    4967 
    4968         if (!found){
    4969                 /*Ok, the input looked for does not exist. No problem. Just return :*/
    4970         }
    4971         else{
     4926/*FUNCTION Penta::PatchFill(int* pcount, Patch* patch){{{1*/
     4927void  Penta::PatchFill(int* pcount, Patch* patch){
     4928
     4929        int i;
     4930        int count;
     4931        int vertices_ids[6];
     4932
     4933
     4934        /*recover pointer: */
     4935        count=*pcount;
    49724936               
    4973                 /*First, recover the patches row where we will plug in the information: */
    4974                 count=*pcount;
    4975 
    4976                 /*set this_patch to point at the beginning of the patches row, where we will plug our information :*/
    4977                 this_patch=patches+numcols*count;
    4978 
    4979                 /*Fill in id: */
    4980                 this_patch[0]=this->id;
    4981 
    4982                 /*Fill in vertices ids: */
    4983                 for(i=0;i<6;i++) this_patch[2+i]=this->nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
    4984 
    4985                 /*We found the input, get it to fill the interpolation type, and the nodal values:*/
    4986                 input->PatchFill(this_patch,max_vertices,this->parameters);
    4987                
    4988                 /*Increase counter, so that next time, we don't point to the same patches row: */
     4937        /*will be needed later: */
     4938        for(i=0;i<6;i++) vertices_ids[i]=nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
     4939
     4940        for(i=0;i<this->results->Size();i++){
     4941                Result* result=(Result*)this->results->GetObjectByOffset(i);
     4942
     4943                /*For this result,fill the information in the Patch object (element id + vertices ids), and then hand
     4944                 *it to the result object, to fill the rest: */
     4945                patch->fillelementinfo(count,this->id,vertices_ids,6);
     4946                result->PatchFill(count,patch);
     4947
     4948                /*increment counter: */
    49894949                count++;
    4990 
    4991                 /*Assign output pointers:*/
    4992                 *pcount=count;
    4993         }
    4994 }
    4995 /*}}}*/
     4950        }
     4951
     4952        /*Assign output pointers:*/
     4953        *pcount=count;
     4954}

  • issm/trunk/src/c/objects/Elements/Penta.h

    r4037 r4039  
    6767                double* GaussFromNode(Node* node);
    6868                void  InputToResult(int enum_type,int step,double time);
    69 
     69                void   ProcessResultsUnits(void);
    7070                /*}}}*/
    7171                /*FUNCTION element numerical routines {{{1*/
    … …  
    150150                void  GetPhi(double* phi, double*  epsilon, double viscosity);
    151151                double MassFlux(double* segment,double* ug);
    152                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes,int enum_type);
    153                 void  PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type);
     152                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     153                void  PatchFill(int* pcount, Patch* patch);
    154154
    155155                /*updates: */

  • issm/trunk/src/c/objects/Elements/Sing.cpp

    r4037 r4039  
    139139/*FUNCTION Sing::InputToResult(int enum_type,int step,double time){{{1*/
    140140void  Sing::InputToResult(int enum_type,int step,double time){
     141        ISSMERROR(" not supported yet!");
     142}
     143/*}}}*/
     144/*FUNCTION Sing::ProcessResultsUnits(void){{{1*/
     145void  Sing::ProcessResultsUnits(void){
    141146        ISSMERROR(" not supported yet!");
    142147}
    … …  
    442447}
    443448/*}}}*/
    444 /*FUNCTION Sing::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){{{1*/
    445 void  Sing::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){
    446 
    447         int    i;
    448         Input *input       = NULL;
    449         bool   found       = false;
    450         int    numrows;
    451         int    numvertices;
    452         int    numnodes;
    453 
    454         /*Recover counter: */
    455         numrows=*pnumrows;
    456 
    457         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    458         for (i=0;i<this->inputs->Size();i++){
    459                 input=(Input*)this->inputs->GetObjectByOffset(i);
    460                 if (input->EnumType()==enum_type){
    461                         found=true;
    462                         break;
    463                 }
    464         }
    465 
    466         if (!found){
    467                 /*Ok, the input looked for does not exist. No problem. Just be sure numvertices and numnodes
    468                  * are 0, so that they do not increase the size of the patches array. Also, do not increase
    469                  * the counter, as this element has nothing to do with results: */
    470                 numvertices=0;
    471                 numnodes=0;
    472         }
    473         else{
    474                 /*Ok, we found an input with the correct enum_type. Ask it to tell us how many nodal values it
    475                  * holds. : */
    476                 numnodes=input->PatchSize();
    477                 /*We know the number of vertices from this element: */
    478                 numvertices=1;
    479                 /*Increase counter, because this element does hold a result in its inputs: */
     449/*FUNCTION Sing::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){{{1*/
     450void  Sing::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){
     451
     452        int     i;
     453       
     454        /*output: */
     455        int     numrows     = 0;
     456        int     numvertices = 0;
     457        int     numnodes    = 0;
     458
     459        /*Go through all the results objects, and update the counters: */
     460        for (i=0;i<this->results->Size();i++){
     461                Result* result=(Result*)this->results->GetObjectByOffset(i);
     462                /*first, we have one more result: */
    480463                numrows++;
     464                /*now, how many vertices and how many nodal values for this result? :*/
     465                numvertices=1; //this is a sing element, with 1 vertex
     466                numnodes=result->NumberOfNodalValues(); //ask result object.
    481467        }
    482468
    … …  
    485471        *pnumvertices=numvertices;
    486472        *pnumnodes=numnodes;
    487 }
    488        
    489 /*FUNCTION Sing::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){{{1*/
    490 void  Sing::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){
    491 
    492         /*A patch is made of the following information:
    493          * element_id  interpolation_type  vertex_ids    values.
    494          * For example:
    495 
    496          1 P0  1       4.5
    497          2 P1  3       4.5
    498          3 P0  5       5.5
    499          4 P1  4       4.5
    500 
    501          Here, we will provide the nodal values, after having processed them, can provide: id, and vertices ids.
    502          Then go find an input with enum_type. If we find it, fill in the values at the nodal points.
    503          If we don't find an input, get out of here doing nothing, as this element is not involved in
    504          outputting results.
    505          */
    506 
    507         int      i;
    508         Input   *input      = NULL;
    509         bool     found      = false;
    510         int      count      = 0;
    511         double  *this_patch = NULL;
    512 
    513 
    514         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    515         for (i=0;i<this->inputs->Size();i++){
    516                 input=(Input*)this->inputs->GetObjectByOffset(i);
    517                 if (input->EnumType()==enum_type){
    518                         found=true;
    519                         break;
    520                 }
    521         }
    522 
    523         if (!found){
    524                 /*Ok, the input looked for does not exist. No problem. Just return :*/
    525         }
    526         else{
     473       
     474}
     475/*}}}*/
     476/*FUNCTION Sing::PatchFill(int* pcount, Patch* patch){{{1*/
     477void  Sing::PatchFill(int* pcount, Patch* patch){
     478
     479        int i;
     480        int count;
     481        int vertices_ids[1];
     482
     483
     484        /*recover pointer: */
     485        count=*pcount;
    527486               
    528                 /*First, recover the patches row where we will plug in the information: */
    529                 count=*pcount;
    530 
    531                 /*set this_patch to point at the beginning of the patches row, where we will plug our information :*/
    532                 this_patch=patches+numcols*count;
    533 
    534                 /*Fill in id: */
    535                 this_patch[0]=this->id;
    536 
    537                 /*Fill in vertices ids: */
    538                 for(i=0;i<1;i++) this_patch[2+i]=node->GetVertexId(); //vertices id start at column 3 of the patch.
    539 
    540                 /*We found the input, get it to fill the interpolation type, and the nodal values:*/
    541                 input->PatchFill(this_patch,max_vertices,this->parameters);
    542                
    543                 /*Increase counter, so that next time, we don't point to the same patches row: */
     487        /*will be needed later: */
     488        for(i=0;i<1;i++) vertices_ids[i]=nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
     489
     490        for(i=0;i<this->results->Size();i++){
     491                Result* result=(Result*)this->results->GetObjectByOffset(i);
     492
     493                /*For this result,fill the information in the Patch object (element id + vertices ids), and then hand
     494                 *it to the result object, to fill the rest: */
     495                patch->fillelementinfo(count,this->id,vertices_ids,1);
     496                result->PatchFill(count,patch);
     497
     498                /*increment counter: */
    544499                count++;
    545 
    546                 /*Assign output pointers:*/
    547                 *pcount=count;
    548         }
    549 }
    550 /*}}}*/
     500        }
     501
     502        /*Assign output pointers:*/
     503        *pcount=count;
     504}

  • issm/trunk/src/c/objects/Elements/Sing.h

    r4037 r4039  
    6464                void  DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);
     66                void   ProcessResultsUnits(void);
    6667                /*}}}*/
    6768                /*numerics: {{{1*/
    … …  
    7980                void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
    8081                void  GetNodes(void** vpnodes);
    81                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes,int enum_type);
    82                 void  PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type);
     82                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     83                void  PatchFill(int* pcount, Patch* patch);
    8384
    8485                /*}}}*/

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r4037 r4039  
    509509         * object out of the input, with the additional step and time information: */
    510510        this->results->AddObject(input->SpawnResult(step,time));
     511
     512}
     513/*}}}*/
     514/*FUNCTION Tria::ProcessResultsUnits(void){{{1*/
     515void  Tria::ProcessResultsUnits(void){
     516
     517        int i;
     518
     519        for(i=0;i<this->results->Size();i++){
     520                Result* result=this->results->GetObjectByOffset(i);
     521                result->ProcessUnits(this->parameters);
     522        }
    511523
    512524}
    … …  
    49975009}
    49985010/*}}}*/
    4999 /*FUNCTION Tria::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){{{1*/
    5000 void  Tria::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes, int enum_type){
    5001 
    5002         int    i;
    5003         Input *input       = NULL;
    5004         bool   found       = false;
    5005         int    numrows;
    5006         int    numvertices;
    5007         int    numnodes;
    5008 
    5009         /*Recover counter: */
    5010         numrows=*pnumrows;
    5011 
    5012         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    5013         for (i=0;i<this->inputs->Size();i++){
    5014                 input=(Input*)this->inputs->GetObjectByOffset(i);
    5015                 if (input->EnumType()==enum_type){
    5016                         found=true;
    5017                         break;
    5018                 }
    5019         }
    5020 
    5021         if (!found){
    5022                 /*Ok, the input looked for does not exist. No problem. Just be sure numvertices and numnodes
    5023                  * are 0, so that they do not increase the size of the patches array. Also, do not increase
    5024                  * the counter, as this element has nothing to do with results: */
    5025                 numvertices=0;
    5026                 numnodes=0;
    5027         }
    5028         else{
    5029                 /*Ok, we found an input with the correct enum_type. Ask it to tell us how many nodal values it
    5030                  * holds. : */
    5031                 numnodes=input->PatchSize();
    5032                 /*We know the number of vertices from this element: */
    5033                 numvertices=3;
    5034                 /*Increase counter, because this element does hold a result in its inputs: */
     5011/*FUNCTION Tria::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){{{1*/
     5012void  Tria::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){
     5013
     5014        int     i;
     5015       
     5016        /*output: */
     5017        int     numrows     = 0;
     5018        int     numvertices = 0;
     5019        int     numnodes    = 0;
     5020
     5021        /*Go through all the results objects, and update the counters: */
     5022        for (i=0;i<this->results->Size();i++){
     5023                Result* result=(Result*)this->results->GetObjectByOffset(i);
     5024                /*first, we have one more result: */
    50355025                numrows++;
     5026                /*now, how many vertices and how many nodal values for this result? :*/
     5027                numvertices=3; //this is a tria element, with 3 vertices
     5028                numnodes=result->NumberOfNodalValues(); //ask result object.
    50365029        }
    50375030
    … …  
    50435036}
    50445037/*}}}*/
    5045 /*FUNCTION Tria::PatchFill(int* pcount, double* patches,int numcols,int max_vertices);{{{1*/
    5046 void  Tria::PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type){
    5047 
    5048         /*A patch is made of the following information:
    5049          * element_id  interpolation_type  vertex_ids    values.
    5050          * For example:
    5051 
    5052          1 P0  1 2 4       4.5  NaN  NaN
    5053          2 P1  2 4 5       4.5  23.3 23.3
    5054          3 P0  5 2 1       5.5  NaN  NaN
    5055          4 P1  2 3 5       4.5  30.2 322.2
    5056          ...
    5057 
    5058          Here, we can provide: id, and vertices ids.
    5059          Then go find an input with enum_type. If we find it, fill in the values at the nodal points.
    5060          If we don't find an input, get out of here doing nothing, as this element is not involved in
    5061          outputting results.
    5062          */
    5063 
    5064         int      i;
    5065         Input   *input      = NULL;
    5066         bool     found      = false;
    5067         int      count      = 0;
    5068         double  *this_patch = NULL;
    5069 
    5070 
    5071         /*Go through all the input objects, and find the one corresponding to enum_type, if it exists: */
    5072         for (i=0;i<this->inputs->Size();i++){
    5073                 input=(Input*)this->inputs->GetObjectByOffset(i);
    5074                 if (input->EnumType()==enum_type){
    5075                         found=true;
    5076                         break;
    5077                 }
    5078         }
    5079 
    5080         if (!found){
    5081                 /*Ok, the input looked for does not exist. No problem. Just return :*/
    5082         }
    5083         else{
     5038/*FUNCTION Tria::PatchFill(int* prow, Patch* patch){{{1*/
     5039void  Tria::PatchFill(int* prow, Patch* patch){
     5040
     5041        int i;
     5042        int row;
     5043        int vertices_ids[3];
     5044
     5045
     5046        /*recover pointer: */
     5047        row=*prow;
    50845048               
    5085                 /*First, recover the patches row where we will plug in the information: */
    5086                 count=*pcount;
    5087 
    5088                 /*set this_patch to point at the beginning of the patches row, where we will plug our information :*/
    5089                 this_patch=patches+numcols*count;
    5090 
    5091                 /*Fill in id: */
    5092                 this_patch[0]=this->id;
    5093 
    5094                 /*Fill in vertices ids: */
    5095                 for(i=0;i<3;i++) this_patch[2+i]=this->nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
    5096 
    5097                 /*We found the input, get it to fill the interpolation type, and the nodal values:*/
    5098                 input->PatchFill(this_patch,max_vertices,this->parameters);
    5099                
    5100                 /*Increase counter, so that next time, we don't point to the same patches row: */
    5101                 count++;
    5102 
    5103                 /*Assign output pointers:*/
    5104                 *pcount=count;
    5105         }
    5106 }
    5107 /*}}}*/
     5049        /*will be needed later: */
     5050        for(i=0;i<3;i++) vertices_ids[i]=nodes[i]->GetVertexId(); //vertices id start at column 3 of the patch.
     5051
     5052        for(i=0;i<this->results->Size();i++){
     5053                Result* result=(Result*)this->results->GetObjectByOffset(i);
     5054
     5055                /*For this result,fill the information in the Patch object (element id + vertices ids), and then hand
     5056                 *it to the result object, to fill the rest: */
     5057                patch->fillelementinfo(row,this->id,vertices_ids,3);
     5058                result->PatchFill(row,patch);
     5059
     5060                /*increment rower: */
     5061                row++;
     5062        }
     5063
     5064        /*Assign output pointers:*/
     5065        *prow=row;
     5066}

  • issm/trunk/src/c/objects/Elements/Tria.h

    r4037 r4039  
    5959                void*  SpawnBeam(int g0, int g1);
    6060                void  InputToResult(int enum_type,int step,double time);
     61                void   ProcessResultsUnits(void);
    6162                /*}}}*/
    6263                /*FUNCTION element numerical routines {{{1*/
    … …  
    125126                double GetArea(void);
    126127                double GetAreaCoordinate(double x, double y, int which_one);
    127                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes,int enum_type);
    128                 void  PatchFill(int* pcount, double* patches,int numcols,int max_vertices,int enum_type);
     128                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     129                void  PatchFill(int* pcount, Patch* patch);
    129130
    130131                /*}}}*/

  • issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    228227}
    229228/*}}}*/
    230 /*FUNCTION BeamVertexInput::PatchSize(void);{{{1*/
    231 int BeamVertexInput::PatchSize(void){
    232 
    233         /*Return the number of nodal values this input holds, so that
    234          * results can be correctl dimensionned. See InputToResultsx
    235          * module for more explanations: */
    236         return 2;
    237 }
    238 /*}}}*/
    239 /*FUNCTION BeamVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    240 void BeamVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    241        
    242         /*A patch is made of the following information:
    243          * element_id  interpolation_type  vertex_ids    values.
    244          * For example:
    245 
    246          1 P0  1 2       4.5 NaN
    247          2 P1  1 3       4.5 3.2
    248          3 P0  1 5       5.5 NaN
    249          4 P1  2 4       4.5 3.2
    250 
    251          Here, we fill the info relevant to the input, ie interpolation_type and nodal values: */
    252         int i;
    253 
    254         patches[1]=P1Enum;
    255         for(i=0;i<2;i++)patches[2+max_vertices+i]=values[i]; //start of nodal values is at position 2+max_vertices (2 for id and interpolation_type) and max_vertices for vertices ids.
    256 
    257         /*Now, post-processing (essentially, unit conversion): */
    258         ProcessResults(patches+2+max_vertices,2,this->enum_type,parameters);
    259 
    260 }
    261 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/BeamVertexInput.h

    r4037 r4039  
    1515class BeamVertexInput: public Input{
    1616
    17         private:
     17        public:
    1818                /*just hold 2 values for 2 vertices: */
    1919                int    enum_type;
    2020                double values[2];
    21 
    22         public:
    2321
    2422                /*constructors, destructors: {{{1*/
    … …  
    7573                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
    7674                void ChangeEnum(int newenumtype);
    77                 int  PatchSize(void);
    78                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    7975                /*}}}*/
    8076

  • issm/trunk/src/c/objects/Inputs/BoolInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    218217}
    219218/*}}}*/
    220 /*FUNCTION BoolInput::PatchSize(void);{{{1*/
    221 int BoolInput::PatchSize(void){
    222 
    223         /*Return the number of nodal values this input holds, so that
    224          * results can be correctl dimensionned. See InputToResultsx
    225          * module for more explanations: */
    226         return 1;
    227 }
    228 /*}}}*/
    229 /*FUNCTION BoolInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    230 void BoolInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    231 
    232         ISSMERROR(" not supported yet!");
    233 }
    234 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/BoolInput.h

    r4037 r4039  
    1515class BoolInput: public Input{
    1616
    17         private:
     17        public:
    1818                /*just hold 3 values for 3 vertices: */
    1919                int    enum_type;
    2020                IssmBool value;
    21 
    22         public:
    2321
    2422                /*constructors, destructors: {{{1*/
    … …  
    7573                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
    7674                void ChangeEnum(int newenumtype);
    77                 int  PatchSize(void);
    78                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    7975                /*}}}*/
    8076

  • issm/trunk/src/c/objects/Inputs/DoubleInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    228227}
    229228/*}}}*/
    230 /*FUNCTION DoubleInput::PatchSize(void);{{{1*/
    231 int DoubleInput::PatchSize(void){
    232 
    233         /*Return the number of nodal values this input holds, so that
    234          * results can be correctl dimensionned. See InputToResultsx
    235          * module for more explanations: */
    236         return 1;
    237 }
    238 /*}}}*/
    239 /*FUNCTION DoubleInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    240 void DoubleInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    241 
    242         ISSMERROR(" not supported yet!");
    243 }
    244 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/DoubleInput.h

    r4037 r4039  
    1515class DoubleInput: public Input{
    1616
    17         private:
     17        public:
     18
    1819                /*just hold 3 values for 3 vertices: */
    1920                int    enum_type;
    2021                IssmDouble value;
    21 
    22         public:
    2322
    2423                /*constructors, destructors: {{{1*/
    … …  
    3837                Object* copy();
    3938                int   EnumType();
     39
    4040                void    UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4141                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    … …  
    4444                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46 
    4746                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4847
    … …  
    7574                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
    7675                void ChangeEnum(int newenumtype);
    77                 int  PatchSize(void);
    78                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    7976                /*}}}*/
    8077

  • issm/trunk/src/c/objects/Inputs/Input.h

    r4037 r4039  
    5050                virtual Input* SpawnTriaInput(int* indices)=0;
    5151                virtual Result* SpawnResult(int step, double time)=0;
    52                 virtual int  PatchSize(void)=0;
    53                 virtual void PatchFill(double* patch, int max_vertices,Parameters* parameters)=0;
    5452
    5553

  • issm/trunk/src/c/objects/Inputs/IntInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    215214}
    216215/*}}}*/
    217 /*FUNCTION IntInput::PatchSize(void);{{{1*/
    218 int IntInput::PatchSize(void){
    219 
    220         /*Return the number of nodal values this input holds, so that
    221          * results can be correctl dimensionned. See InputToResultsx
    222          * module for more explanations: */
    223         return 1;
    224 }
    225 /*}}}*/
    226 /*FUNCTION IntInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    227 void IntInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    228 
    229         ISSMERROR(" not supported yet!");
    230 }
    231 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/IntInput.h

    r4037 r4039  
    1515class IntInput: public Input{
    1616
    17         private:
     17        public:
    1818                /*just hold 3 values for 3 vertices: */
    1919                int    enum_type;
    2020                IssmInt value;
    21 
    22         public:
    2321
    2422                /*constructors, destructors: {{{1*/
    … …  
    7573                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
    7674                void ChangeEnum(int newenumtype);
    77                 int  PatchSize(void);
    78                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    7975                /*}}}*/
    8076

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    877876}
    878877/*}}}*/
    879 /*FUNCTION PentaVertexInput::PatchSize(void);{{{1*/
    880 int PentaVertexInput::PatchSize(void){
    881 
    882         /*Return the number of nodal values this input holds, so that
    883          * results can be correctl dimensionned. See InputToResultsx
    884          * module for more explanations: */
    885         return 6;
    886 }
    887 /*}}}*/
    888 /*FUNCTION PentaVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    889 void PentaVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    890        
    891         /*A patch is made of the following information:
    892          * element_id  interpolation_type  vertex_ids    values.
    893          * For example:
    894 
    895          1 P0  1 2 4 11 12 14      4.5  NaN  NaN    NaN NaN NaN
    896          2 P1  2 4 5 12 14 15      4.5  23.3 23.3   4.2 4.2 3.2
    897          3 P0  5 2 1 15 12 11      5.5  NaN  NaN    NaN NaN NaN
    898          4 P1  2 3 5 12 13 15      4.5  30.2 322.2  4.2 3.2 8.3
    899          ...
    900          
    901          Here, we fill the info relevant to the input, ie interpolation_type and nodal values: */
    902 
    903         int i;
    904 
    905 
    906         patches[1]=P1Enum;
    907         for(i=0;i<6;i++)patches[2+max_vertices+i]=values[i]; //start of nodal values is at position 2+max_vertices (2 for id and interpolation_type) and max_vertices for vertices ids.
    908 
    909         /*Now, post-processing (essentially, unit conversion): */
    910         ProcessResults(patches+2+max_vertices,6,this->enum_type,parameters);
    911 
    912 }
    913 /*}}}*/
    914 
    915 

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.h

    r4037 r4039  
    1414class PentaVertexInput: public Input{
    1515
    16         private:
     16        public:
    1717                /*just hold 3 values for 3 vertices: */
    1818                int    enum_type;
    1919                double values[6];
    20 
    21         public:
    2220
    2321                /*constructors, destructors: {{{1*/
    … …  
    8482                void GetBPattyn(double* B, double* xyz_list, double* gauss_coord);
    8583                void GetBStokes(double* B, double* xyz_list, double* gauss_coord);
    86                 int  PatchSize(void);
    87                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    8884                /*}}}*/
    8985

  • issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    206205}
    207206/*}}}*/
    208 /*FUNCTION SingVertexInput::PatchSize(void);{{{1*/
    209 int SingVertexInput::PatchSize(void){
    210 
    211         /*Return the number of nodal values this input holds, so that
    212          * results can be correctl dimensionned. See InputToResultsx
    213          * module for more explanations: */
    214         return 1;
    215 }
    216 /*}}}*/
    217 /*FUNCTION SingVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    218 void SingVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    219        
    220         /*A patch is made of the following information:
    221          * element_id  interpolation_type  vertex_ids    values.
    222          * For example:
    223 
    224          1 P0   2       4.5
    225          2 P1   3       4.5
    226          3 P0   5       5.5
    227          4 P1   4       4.5
    228 
    229          Here, we fill the info relevant to the input, ie interpolation_type and nodal values: */
    230         int i;
    231 
    232         patches[1]=P1Enum;
    233         patches[2+max_vertices+0]=value; //start of nodal values is at position 2+max_vertices (2 for id and interpolation_type) and max_vertices for vertices ids.
    234 
    235         /*Now, post-processing (essentially, unit conversion): */
    236         ProcessResults(patches+2+max_vertices,1,this->enum_type,parameters);
    237 
    238 }
    239 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/SingVertexInput.h

    r4037 r4039  
    1414class SingVertexInput: public Input{
    1515
    16         private:
     16        public:
    1717                /*just hold 1 value for 1 vertex: */
    1818                int    enum_type;
    1919                double value;
    20 
    21         public:
    2220
    2321                /*constructors, destructors: {{{1*/
    … …  
    7472                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
    7573                void ChangeEnum(int newenumtype);
    76                 int  PatchSize(void);
    77                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    7874                /*}}}*/
    7975

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r4037 r4039  
    1111#include "stdio.h"
    1212#include <string.h>
    13 #include "./InputLocal.h"
    1413#include "../objects.h"
    1514#include "../../EnumDefinitions/EnumDefinitions.h"
    … …  
    451450}
    452451/*}}}*/
    453 /*FUNCTION TriaVertexInput::PatchSize(void);{{{1*/
    454 int TriaVertexInput::PatchSize(void){
    455 
    456         /*Return the number of nodal values this input holds, so that
    457          * results can be correctl dimensionned. See InputToResultsx
    458          * module for more explanations: */
    459         return 3;
    460 }
    461 /*}}}*/
    462 /*FUNCTION TriaVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters);{{{1*/
    463 void TriaVertexInput::PatchFill(double* patches, int max_vertices,Parameters* parameters){
    464        
    465         /*A patch is made of the following information:
    466          * element_id  interpolation_type  vertex_ids    values.
    467          * For example:
    468 
    469          1 P0  1 2 4       4.5  NaN  NaN
    470          2 P1  2 4 5       4.5  23.3 23.3
    471          3 P0  5 2 1       5.5  NaN  NaN
    472          4 P1  2 3 5       4.5  30.2 322.2
    473          ...
    474          
    475          Here, we fill the info relevant to the input, ie interpolation_type and nodal values: */
    476 
    477         int i;
    478 
    479         patches[1]=P1Enum;
    480         for(i=0;i<3;i++)patches[2+max_vertices+i]=values[i]; //start of nodal values is at position 2+max_vertices (2 for id and interpolation_type) and max_vertices for vertices ids.
    481 
    482         /*Now, post-processing (essentially, unit conversion): */
    483         ProcessResults(patches+2+max_vertices,3,this->enum_type,parameters);
    484 
    485 }
    486 /*}}}*/

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.h

    r4037 r4039  
    1515class TriaVertexInput: public Input,public TriaRef{
    1616
    17         private:
     17        public:
    1818                /*just hold 3 values for 3 vertices: */
    1919                int    enum_type;
    2020                double values[3];
    21 
    22         public:
    2321
    2422                /*constructors, destructors: {{{1*/
    … …  
    8179                void GetJacobian(double* J, double* xyz_list,double* gauss);
    8280                void GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss);
    83                 int  PatchSize(void);
    84                 void PatchFill(double* patches, int max_vertices,Parameters* parameters);
    8581                /*}}}*/
    8682

  • issm/trunk/src/c/objects/Results/DoubleResult.cpp

    r4037 r4039  
    4040/*FUNCTION DoubleResult::copy{{{1*/
    4141Object* DoubleResult::copy() {
    42        
    43         return new DoubleResult(this->enum_type,this->value,this->step,this->time);
     42
     43        DoubleResult* result=new DoubleResult(this->enum_type,this->value,this->step,this->time);
     44        return (Object*)result;
     45        //return new DoubleResult(this->enum_type,this->value,this->step,this->time);
    4446
    4547}
    … …  
    191193}
    192194/*}}}*/
    193 
     195/*FUNCTION DoubleResult::ProcessUnits(Parameters* parameters){{{1*/
     196void DoubleResult::ProcessUnits(Parameters* parameters){
     197       
     198        NodalValuesUnitConversion(&this->value,1,this->enum_type,parameters);
     199
     200}
     201/*}}}*/
     202/*FUNCTION DoubleResult::NumberOfNodalValues(void){{{1*/
     203int DoubleResult::NumberOfNodalValues(void){
     204        return 1;
     205}
     206/*}}}*/
     207/*FUNCTION DoubleResult::DoubleResult::PatchFill(int row, Patch* patch){{{1*/
     208void DoubleResult::PatchFill(int row, Patch* patch){
     209       
     210         /*Here, we fill the result information into the patch object. First, let's remember what is in a row
     211          * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values
     212          * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */
     213        patch->fillresultinfo(row,this->enum_type,this->step,this->time,P0Enum,&this->value,1);
     214
     215}
     216/*}}}*/

  • issm/trunk/src/c/objects/Results/DoubleResult.h

    r4037 r4039  
    1212#include "../Inputs/Input.h"
    1313#include "../../include/include.h"
     14class Parameters;
    1415/*}}}*/
    1516
    … …  
    3839                Object* copy();
    3940                int   EnumType();
     41
     42                void    UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     43                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     45                void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     47                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     48                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     49
    4050                                /*}}}*/
    4151                /*result virtual functions: {{{1*/
    … …  
    4353                Result* SpawnBeamResult(int* indices);
    4454                Result* SpawnTriaResult(int* indices);
     55                void    ProcessUnits(Parameters* parameters);
     56                int     NumberOfNodalValues(void);
     57                void    PatchFill(int row, Patch* patch);
    4558                /*}}}*/
    4659

  • issm/trunk/src/c/objects/Results/PentaVertexResult.cpp

    r4037 r4039  
    205205}
    206206/*}}}*/
    207 
     207/*FUNCTION PentaVertexResult::ProcessUnits(Parameters* parameters){{{1*/
     208Result* PentaVertexResult::ProcessUnits(Parameters* parameters){
     209       
     210        NodalValuesUnitConversion(this->values,6,this->enum_type,parameters);
     211
     212}
     213/*}}}*/
     214/*FUNCTION PentaVertexResult::NumberOfNodalValues(void){{{1*/
     215int PentaVertexResult::NumberOfNodalValues(void){
     216        return 6;
     217}
     218/*}}}*/
     219/*FUNCTION PentaVertexResult::PentaVertexResult::PatchFill(int row, Patch* patch){{{1*/
     220void PentaVertexResult::PatchFill(int row, Patch* patch){
     221       
     222         /*Here, we fill the result information into the patch object. First, let's remember what is in a row
     223          * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values
     224          * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */
     225        patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,6);
     226
     227}
     228/*}}}*/

  • issm/trunk/src/c/objects/Results/PentaVertexResult.h

    r4037 r4039  
    3838                Object* copy();
    3939                int   EnumType();
     40               
     41                void    UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     42                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     43                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     47                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     48
    4049                /*}}}*/
    4150                /*result virtual functions: {{{1*/
    … …  
    4352                Result* SpawnBeamResult(int* indices);
    4453                Result* SpawnTriaResult(int* indices);
     54                void    ProcessUnits(Parameters* parameters);
     55                int     NumberOfNodalValues(void);
     56                void    PatchFill(int row, Patch* patch);
    4557                /*}}}*/
    4658

  • issm/trunk/src/c/objects/Results/Result.h

    r4037 r4039  
    1212/*}}}*/
    1313
    14 class Result: public Object{
     14class Result{
    1515
    1616        public:
    … …  
    2121                virtual Result* SpawnBeamResult(int* indices)=0;
    2222                virtual Result* SpawnTriaResult(int* indices)=0;
     23                virtual void    ProcessUnits(Parameters* parameters)=0;
     24                virtual int     NumberOfNodalValues(void)=0;
     25                virtual void    PatchFill(int row, Patch* patch)=0;
    2326
    2427};

  • issm/trunk/src/c/objects/Results/TriaVertexResult.cpp

    r4037 r4039  
    194194}
    195195/*}}}*/
    196 
     196/*FUNCTION TriaVertexResult::ProcessUnits(Parameters* parameters){{{1*/
     197Result* TriaVertexResult::ProcessUnits(Parameters* parameters){
     198       
     199        NodalValuesUnitConversion(this->values,3,this->enum_type,parameters);
     200
     201}
     202/*}}}*/
     203/*FUNCTION TriaVertexResult::NumberOfNodalValues(void){{{1*/
     204int TriaVertexResult::NumberOfNodalValues(void){
     205        return 3;
     206}
     207/*}}}*/
     208/*FUNCTION TriaVertexResult::TriaVertexResult::PatchFill(int row, Patch* patch){{{1*/
     209void TriaVertexResult::PatchFill(int row, Patch* patch){
     210       
     211         /*Here, we fill the result information into the patch object. First, let's remember what is in a row
     212          * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values
     213          * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */
     214        patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,3);
     215
     216}
     217/*}}}*/

  • issm/trunk/src/c/objects/Results/TriaVertexResult.h

    r4037 r4039  
    3737                Object* copy();
    3838                int   EnumType();
     39               
     40                void    UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     41                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     42                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     43                void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     47
    3948                /*}}}*/
    4049                /*result virtual functions: {{{1*/
    … …  
    4251                Result* SpawnBeamResult(int* indices);
    4352                Result* SpawnTriaResult(int* indices);
     53                void    ProcessUnits(Parameters* parameters);
     54                int     NumberOfNodalValues(void);
     55                void    PatchFill(int row, Patch* patch);
    4456                /*}}}*/
    4557

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

    r4037 r4039  
    1616#include "./NodeSets.h"
    1717#include "./IoModel.h"
     18#include "./Patch.h"
    1819
    1920/*Constraints: */
    … …  
    5455#include "./Results/TriaVertexResult.h"
    5556#include "./Results/PentaVertexResult.h"
     57#include "./Results/SingVertexResult.h"
     58#include "./Results/BeamVertexResult.h"
    5659
    5760/*Materials: */

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

    r4037 r4039  
    9494
    9595                _printf_("write results to disk:\n");
    96                 OutputResults(femmodel,outputfilename,DiagnosticSolutionEnum);
     96                OutputResults(femmodel,outputfilename);
    9797        }
    9898        else{

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

    r4037 r4039  
    8585               
    8686                _printf_("write results to disk:\n");
    87                 OutputResults(femmodel,outputfilename,ThermalSolutionEnum);
     87                OutputResults(femmodel,outputfilename);
    8888
    8989        }

  • issm/trunk/src/m/enum/AccumulationRateEnum.m

    r4033 r4039  
    99%      macro=AccumulationRateEnum()
    1010
    11 macro=106;
     11macro=107;

  • issm/trunk/src/m/enum/AdjointAnalysisEnum.m

    r4033 r4039  
    99%      macro=AdjointAnalysisEnum()
    1010
    11 macro=24;
     11macro=25;

  • issm/trunk/src/m/enum/AdjointxEnum.m

    r4033 r4039  
    99%      macro=AdjointxEnum()
    1010
    11 macro=107;
     11macro=108;

  • issm/trunk/src/m/enum/AdjointyEnum.m

    r4033 r4039  
    99%      macro=AdjointyEnum()
    1010
    11 macro=108;
     11macro=109;

  • issm/trunk/src/m/enum/AdjointzEnum.m

    r4033 r4039  
    99%      macro=AdjointzEnum()
    1010
    11 macro=109;
     11macro=110;

  • issm/trunk/src/m/enum/AirEnum.m

    r4033 r4039  
    99%      macro=AirEnum()
    1010
    11 macro=104;
     11macro=105;

  • issm/trunk/src/m/enum/ArtDiffEnum.m

    r4033 r4039  
    99%      macro=ArtDiffEnum()
    1010
    11 macro=110;
     11macro=111;

  • issm/trunk/src/m/enum/Balancedthickness2AnalysisEnum.m

    r4033 r4039  
    99%      macro=Balancedthickness2AnalysisEnum()
    1010
    11 macro=36;
     11macro=37;

  • issm/trunk/src/m/enum/BalancedthicknessAnalysisEnum.m

    r4033 r4039  
    99%      macro=BalancedthicknessAnalysisEnum()
    1010
    11 macro=37;
     11macro=38;

  • issm/trunk/src/m/enum/BalancedvelocitiesAnalysisEnum.m

    r4033 r4039  
    99%      macro=BalancedvelocitiesAnalysisEnum()
    1010
    11 macro=38;
     11macro=39;

  • issm/trunk/src/m/enum/BeamEnum.m

    r4033 r4039  
    99%      macro=BeamEnum()
    1010
    11 macro=55;
     11macro=56;

  • issm/trunk/src/m/enum/BeamVertexInputEnum.m

    r4033 r4039  
    99%      macro=BeamVertexInputEnum()
    1010
    11 macro=78;
     11macro=79;

  • issm/trunk/src/m/enum/BedEnum.m

    r4033 r4039  
    99%      macro=BedEnum()
    1010
    11 macro=111;
     11macro=112;

  • issm/trunk/src/m/enum/BedSlopeXAnalysisEnum.m

    r4033 r4039  
    99%      macro=BedSlopeXAnalysisEnum()
    1010
    11 macro=32;
     11macro=33;

  • issm/trunk/src/m/enum/BedSlopeXEnum.m

    r4033 r4039  
    99%      macro=BedSlopeXEnum()
    1010
    11 macro=112;
     11macro=113;

  • issm/trunk/src/m/enum/BedSlopeYAnalysisEnum.m

    r4033 r4039  
    99%      macro=BedSlopeYAnalysisEnum()
    1010
    11 macro=33;
     11macro=34;

  • issm/trunk/src/m/enum/BedSlopeYEnum.m

    r4033 r4039  
    99%      macro=BedSlopeYEnum()
    1010
    11 macro=113;
     11macro=114;

  • issm/trunk/src/m/enum/BetaEnum.m

    r4033 r4039  
    99%      macro=BetaEnum()
    1010
    11 macro=188;
     11macro=191;

  • issm/trunk/src/m/enum/BoolInputEnum.m

    r4033 r4039  
    99%      macro=BoolInputEnum()
    1010
    11 macro=79;
     11macro=80;

  • issm/trunk/src/m/enum/BoolParamEnum.m

    r4033 r4039  
    99%      macro=BoolParamEnum()
    1010
    11 macro=86;
     11macro=87;

  • issm/trunk/src/m/enum/BoundaryEnum.m

    r4033 r4039  
    99%      macro=BoundaryEnum()
    1010
    11 macro=114;
     11macro=115;

  • issm/trunk/src/m/enum/CmGradientEnum.m

    r4033 r4039  
    99%      macro=CmGradientEnum()
    1010
    11 macro=189;
     11macro=192;

  • issm/trunk/src/m/enum/CmJumpEnum.m

    r4033 r4039  
    99%      macro=CmJumpEnum()
    1010
    11 macro=190;
     11macro=193;

  • issm/trunk/src/m/enum/CmMaxDmpSlopeEnum.m

    r4033 r4039  
    99%      macro=CmMaxDmpSlopeEnum()
    1010
    11 macro=115;
     11macro=116;

  • issm/trunk/src/m/enum/CmMaxDmpValueEnum.m

    r4033 r4039  
    99%      macro=CmMaxDmpValueEnum()
    1010
    11 macro=116;
     11macro=117;

  • issm/trunk/src/m/enum/CmMaxEnum.m

    r4033 r4039  
    99%      macro=CmMaxEnum()
    1010
    11 macro=191;
     11macro=194;

  • issm/trunk/src/m/enum/CmMinDmpSlopeEnum.m

    r4033 r4039  
    99%      macro=CmMinDmpSlopeEnum()
    1010
    11 macro=117;
     11macro=118;

  • issm/trunk/src/m/enum/CmMinDmpValueEnum.m

    r4033 r4039  
    99%      macro=CmMinDmpValueEnum()
    1010
    11 macro=118;
     11macro=119;

  • issm/trunk/src/m/enum/CmMinEnum.m

    r4033 r4039  
    99%      macro=CmMinEnum()
    1010
    11 macro=192;
     11macro=195;

  • issm/trunk/src/m/enum/CmNoiseDmpEnum.m

    r4033 r4039  
    99%      macro=CmNoiseDmpEnum()
    1010
    11 macro=119;
     11macro=120;

  • issm/trunk/src/m/enum/CollapseEnum.m

    r4033 r4039  
    99%      macro=CollapseEnum()
    1010
    11 macro=120;
     11macro=121;

  • issm/trunk/src/m/enum/ConnectivityEnum.m

    r4033 r4039  
    99%      macro=ConnectivityEnum()
    1010
    11 macro=193;
     11macro=196;

  • issm/trunk/src/m/enum/ConstantEnum.m

    r4033 r4039  
    99%      macro=ConstantEnum()
    1010
    11 macro=121;
     11macro=122;

  • issm/trunk/src/m/enum/ControlAnalysisEnum.m

    r4033 r4039  
    99%      macro=ControlAnalysisEnum()
    1010
    11 macro=25;
     11macro=26;

  • issm/trunk/src/m/enum/ControlParameterEnum.m

    r4033 r4039  
    99%      macro=ControlParameterEnum()
    1010
    11 macro=194;
     11macro=197;

  • issm/trunk/src/m/enum/ControlSteadyEnum.m

    r4033 r4039  
    99%      macro=ControlSteadyEnum()
    1010
    11 macro=195;
     11macro=198;

  • issm/trunk/src/m/enum/ControlTypeEnum.m

    r4033 r4039  
    99%      macro=ControlTypeEnum()
    1010
    11 macro=122;
     11macro=123;

  • issm/trunk/src/m/enum/ConvergedEnum.m

    r4033 r4039  
    99%      macro=ConvergedEnum()
    1010
    11 macro=123;
     11macro=124;

  • issm/trunk/src/m/enum/DakotaParameterEnum.m

    r4033 r4039  
    99%      macro=DakotaParameterEnum()
    1010
    11 macro=196;
     11macro=199;

  • issm/trunk/src/m/enum/DhDtEnum.m

    r4033 r4039  
    99%      macro=DhDtEnum()
    1010
    11 macro=124;
     11macro=125;

  • issm/trunk/src/m/enum/DiagnosticAnalysisEnum.m

    r4033 r4039  
    99%      macro=DiagnosticAnalysisEnum()
    1010
    11 macro=15;
     11macro=16;

  • issm/trunk/src/m/enum/DiagnosticHorizAnalysisEnum.m

    r4033 r4039  
    99%      macro=DiagnosticHorizAnalysisEnum()
    1010
    11 macro=16;
     11macro=17;

  • issm/trunk/src/m/enum/DiagnosticHutterAnalysisEnum.m

    r4033 r4039  
    99%      macro=DiagnosticHutterAnalysisEnum()
    1010
    11 macro=18;
     11macro=19;

  • issm/trunk/src/m/enum/DiagnosticStokesAnalysisEnum.m

    r4033 r4039  
    99%      macro=DiagnosticStokesAnalysisEnum()
    1010
    11 macro=19;
     11macro=20;

  • issm/trunk/src/m/enum/DiagnosticVertAnalysisEnum.m

    r4033 r4039  
    99%      macro=DiagnosticVertAnalysisEnum()
    1010
    11 macro=17;
     11macro=18;

  • issm/trunk/src/m/enum/DimEnum.m

    r4033 r4039  
    99%      macro=DimEnum()
    1010
    11 macro=197;
     11macro=200;

  • issm/trunk/src/m/enum/DofIndexingEnum.m

    r4033 r4039  
    99%      macro=DofIndexingEnum()
    1010
    11 macro=56;
     11macro=57;

  • issm/trunk/src/m/enum/DofVecEnum.m

    r4033 r4039  
    99%      macro=DofVecEnum()
    1010
    11 macro=98;
     11macro=99;

  • issm/trunk/src/m/enum/DoubleInputEnum.m

    r4033 r4039  
    99%      macro=DoubleInputEnum()
    1010
    11 macro=80;
     11macro=81;

  • issm/trunk/src/m/enum/DoubleMatParamEnum.m

    r4033 r4039  
    99%      macro=DoubleMatParamEnum()
    1010
    11 macro=87;
     11macro=88;

  • issm/trunk/src/m/enum/DoubleParamEnum.m

    r4033 r4039  
    99%      macro=DoubleParamEnum()
    1010
    11 macro=88;
     11macro=89;

  • issm/trunk/src/m/enum/DoubleVecParamEnum.m

    r4033 r4039  
    99%      macro=DoubleVecParamEnum()
    1010
    11 macro=89;
     11macro=90;

  • issm/trunk/src/m/enum/DragCoefficientEnum.m

    r4033 r4039  
    99%      macro=DragCoefficientEnum()
    1010
    11 macro=125;
     11macro=126;

  • issm/trunk/src/m/enum/DragPEnum.m

    r4033 r4039  
    99%      macro=DragPEnum()
    1010
    11 macro=126;
     11macro=127;

  • issm/trunk/src/m/enum/DragQEnum.m

    r4033 r4039  
    99%      macro=DragQEnum()
    1010
    11 macro=127;
     11macro=128;

  • issm/trunk/src/m/enum/DragTypeEnum.m

    r4033 r4039  
    99%      macro=DragTypeEnum()
    1010
    11 macro=128;
     11macro=129;

  • issm/trunk/src/m/enum/DtEnum.m

    r4033 r4039  
    99%      macro=DtEnum()
    1010
    11 macro=129;
     11macro=130;

  • issm/trunk/src/m/enum/ElementEnum.m

    r4033 r4039  
    99%      macro=ElementEnum()
    1010
    11 macro=54;
     11macro=55;

  • issm/trunk/src/m/enum/ElementOnBedEnum.m

    r4033 r4039  
    99%      macro=ElementOnBedEnum()
    1010
    11 macro=130;
     11macro=131;

  • issm/trunk/src/m/enum/ElementOnIceShelfEnum.m

    r4033 r4039  
    99%      macro=ElementOnIceShelfEnum()
    1010
    11 macro=131;
     11macro=132;

  • issm/trunk/src/m/enum/ElementOnSurfaceEnum.m

    r4033 r4039  
    99%      macro=ElementOnSurfaceEnum()
    1010
    11 macro=132;
     11macro=133;

  • issm/trunk/src/m/enum/ElementOnWaterEnum.m

    r4033 r4039  
    99%      macro=ElementOnWaterEnum()
    1010
    11 macro=133;
     11macro=134;

  • issm/trunk/src/m/enum/ElementPropertiesEnum.m

    r4033 r4039  
    99%      macro=ElementPropertiesEnum()
    1010
    11 macro=57;
     11macro=58;

  • issm/trunk/src/m/enum/EnumAsString.m

    r4033 r4039  
    2626        case AnalysisTypeEnum(), string='AnalysisType'; return
    2727        case SubAnalysisTypeEnum(), string='SubAnalysisType'; return
     28        case AnalysisCounterEnum(), string='AnalysisCounter'; return
    2829        case DiagnosticAnalysisEnum(), string='DiagnosticAnalysis'; return
    2930        case DiagnosticHorizAnalysisEnum(), string='DiagnosticHorizAnalysis'; return
    … …  
    196197        case P0Enum(), string='P0'; return
    197198        case P1Enum(), string='P1'; return
    198         case StringResultEnum(), string='StringResult'; return
    199         case DoubleVecResultEnum(), string='DoubleVecResult'; return
    200         case DoubleMatResultEnum(), string='DoubleMatResult'; return
     199        case DoubleResultEnum(), string='DoubleResult'; return
     200        case TriaVertexResultEnum(), string='TriaVertexResult'; return
     201        case PentaVertexResultEnum(), string='PentaVertexResult'; return
     202        case SingVertexResultEnum(), string='SingVertexResult'; return
     203        case BeamVertexResultEnum(), string='BeamVertexResult'; return
    201204        case BetaEnum(), string='Beta'; return
    202205        case CmGradientEnum(), string='CmGradient'; return

  • issm/trunk/src/m/enum/EpsAbsEnum.m

    r4033 r4039  
    99%      macro=EpsAbsEnum()
    1010
    11 macro=198;
     11macro=201;

  • issm/trunk/src/m/enum/EpsCmEnum.m

    r4033 r4039  
    99%      macro=EpsCmEnum()
    1010
    11 macro=199;
     11macro=202;

  • issm/trunk/src/m/enum/EpsRelEnum.m

    r4033 r4039  
    99%      macro=EpsRelEnum()
    1010
    11 macro=200;
     11macro=203;

  • issm/trunk/src/m/enum/EpsResEnum.m

    r4033 r4039  
    99%      macro=EpsResEnum()
    1010
    11 macro=201;
     11macro=204;

  • issm/trunk/src/m/enum/EpsVelEnum.m

    r4033 r4039  
    99%      macro=EpsVelEnum()
    1010
    11 macro=134;
     11macro=135;

  • issm/trunk/src/m/enum/ExtrudeParamEnum.m

    r4033 r4039  
    99%      macro=ExtrudeParamEnum()
    1010
    11 macro=202;
     11macro=205;

  • issm/trunk/src/m/enum/FillEnum.m

    r4033 r4039  
    99%      macro=FillEnum()
    1010
    11 macro=135;
     11macro=136;

  • issm/trunk/src/m/enum/FitEnum.m

    r4033 r4039  
    99%      macro=FitEnum()
    1010
    11 macro=136;
     11macro=137;

  • issm/trunk/src/m/enum/FormulationEnum.m

    r4033 r4039  
    99%      macro=FormulationEnum()
    1010
    11 macro=46;
     11macro=47;

  • issm/trunk/src/m/enum/FractionIncrementEnum.m

    r4033 r4039  
    99%      macro=FractionIncrementEnum()
    1010
    11 macro=137;
     11macro=138;

  • issm/trunk/src/m/enum/FrictionEnum.m

    r4033 r4039  
    99%      macro=FrictionEnum()
    1010
    11 macro=138;
     11macro=139;

  • issm/trunk/src/m/enum/GeographyEnum.m

    r4033 r4039  
    99%      macro=GeographyEnum()
    1010
    11 macro=99;
     11macro=100;

  • issm/trunk/src/m/enum/GeothermalFluxEnum.m

    r4033 r4039  
    99%      macro=GeothermalFluxEnum()
    1010
    11 macro=139;
     11macro=140;

  • issm/trunk/src/m/enum/GradientAnalysisEnum.m

    r4033 r4039  
    99%      macro=GradientAnalysisEnum()
    1010
    11 macro=26;
     11macro=27;

  • issm/trunk/src/m/enum/HeatCapacityEnum.m

    r4033 r4039  
    99%      macro=HeatCapacityEnum()
    1010
    11 macro=203;
     11macro=206;

  • issm/trunk/src/m/enum/HookEnum.m

    r4033 r4039  
    99%      macro=HookEnum()
    1010
    11 macro=53;
     11macro=54;

  • issm/trunk/src/m/enum/HorizAnalysisEnum.m

    r4033 r4039  
    99%      macro=HorizAnalysisEnum()
    1010
    11 macro=20;
     11macro=21;

  • issm/trunk/src/m/enum/HutterAnalysisEnum.m

    r4033 r4039  
    99%      macro=HutterAnalysisEnum()
    1010
    11 macro=21;
     11macro=22;

  • issm/trunk/src/m/enum/HutterFormulationEnum.m

    r4033 r4039  
    99%      macro=HutterFormulationEnum()
    1010
    11 macro=47;
     11macro=48;

  • issm/trunk/src/m/enum/IceEnum.m

    r4033 r4039  
    99%      macro=IceEnum()
    1010
    11 macro=103;
     11macro=104;

  • issm/trunk/src/m/enum/IceSheetEnum.m

    r4033 r4039  
    99%      macro=IceSheetEnum()
    1010
    11 macro=100;
     11macro=101;

  • issm/trunk/src/m/enum/IceShelfEnum.m

    r4033 r4039  
    99%      macro=IceShelfEnum()
    1010
    11 macro=101;
     11macro=102;

  • issm/trunk/src/m/enum/IcefrontEnum.m

    r4033 r4039  
    99%      macro=IcefrontEnum()
    1010
    11 macro=65;
     11macro=66;

  • issm/trunk/src/m/enum/InputEnum.m

    r4033 r4039  
    99%      macro=InputEnum()
    1010
    11 macro=77;
     11macro=78;

  • issm/trunk/src/m/enum/IntInputEnum.m

    r4033 r4039  
    99%      macro=IntInputEnum()
    1010
    11 macro=81;
     11macro=82;

  • issm/trunk/src/m/enum/IntParamEnum.m

    r4033 r4039  
    99%      macro=IntParamEnum()
    1010
    11 macro=90;
     11macro=91;

  • issm/trunk/src/m/enum/InternalEnum.m

    r4033 r4039  
    99%      macro=InternalEnum()
    1010
    11 macro=140;
     11macro=141;

  • issm/trunk/src/m/enum/InverseAnalysisEnum.m

    r4033 r4039  
    99%      macro=InverseAnalysisEnum()
    1010
    11 macro=27;
     11macro=28;

  • issm/trunk/src/m/enum/IsHutterEnum.m

    r4033 r4039  
    99%      macro=IsHutterEnum()
    1010
    11 macro=204;
     11macro=207;

  • issm/trunk/src/m/enum/IsMacAyealPattynEnum.m

    r4033 r4039  
    99%      macro=IsMacAyealPattynEnum()
    1010
    11 macro=205;
     11macro=208;

  • issm/trunk/src/m/enum/IsStokesEnum.m

    r4033 r4039  
    99%      macro=IsStokesEnum()
    1010
    11 macro=206;
     11macro=209;

  • issm/trunk/src/m/enum/KflagEnum.m

    r4033 r4039  
    99%      macro=KflagEnum()
    1010
    11 macro=141;
     11macro=142;

  • issm/trunk/src/m/enum/LatentHeatEnum.m

    r4033 r4039  
    99%      macro=LatentHeatEnum()
    1010
    11 macro=207;
     11macro=210;

  • issm/trunk/src/m/enum/LoadEnum.m

    r4033 r4039  
    99%      macro=LoadEnum()
    1010
    11 macro=64;
     11macro=65;

  • issm/trunk/src/m/enum/LowmemEnum.m

    r4033 r4039  
    99%      macro=LowmemEnum()
    1010
    11 macro=208;
     11macro=211;

  • issm/trunk/src/m/enum/MacAyealFormulationEnum.m

    r4033 r4039  
    99%      macro=MacAyealFormulationEnum()
    1010
    11 macro=48;
     11macro=49;

  • issm/trunk/src/m/enum/MaterialEnum.m

    r4033 r4039  
    99%      macro=MaterialEnum()
    1010
    11 macro=74;
     11macro=75;

  • issm/trunk/src/m/enum/MaticeEnum.m

    r4033 r4039  
    99%      macro=MaticeEnum()
    1010
    11 macro=75;
     11macro=76;

  • issm/trunk/src/m/enum/MatparEnum.m

    r4033 r4039  
    99%      macro=MatparEnum()
    1010
    11 macro=76;
     11macro=77;

  • issm/trunk/src/m/enum/MaxIterEnum.m

    r4033 r4039  
    99%      macro=MaxIterEnum()
    1010
    11 macro=209;
     11macro=212;

  • issm/trunk/src/m/enum/MaxNonlinearIterationsEnum.m

    r4033 r4039  
    99%      macro=MaxNonlinearIterationsEnum()
    1010
    11 macro=210;
     11macro=213;

  • issm/trunk/src/m/enum/MaxPenetrationEnum.m

    r4033 r4039  
    99%      macro=MaxPenetrationEnum()
    1010
    11 macro=142;
     11macro=143;

  • issm/trunk/src/m/enum/MeanVelEnum.m

    r4033 r4039  
    99%      macro=MeanVelEnum()
    1010
    11 macro=143;
     11macro=144;

  • issm/trunk/src/m/enum/MelangeEnum.m

    r4033 r4039  
    99%      macro=MelangeEnum()
    1010
    11 macro=105;
     11macro=106;

  • issm/trunk/src/m/enum/MeltingAnalysisEnum.m

    r4033 r4039  
    99%      macro=MeltingAnalysisEnum()
    1010
    11 macro=41;
     11macro=42;

  • issm/trunk/src/m/enum/MeltingOffsetEnum.m

    r4033 r4039  
    99%      macro=MeltingOffsetEnum()
    1010
    11 macro=144;
     11macro=145;

  • issm/trunk/src/m/enum/MeltingPointEnum.m

    r4033 r4039  
    99%      macro=MeltingPointEnum()
    1010
    11 macro=211;
     11macro=214;

  • issm/trunk/src/m/enum/MeltingRateEnum.m

    r4033 r4039  
    99%      macro=MeltingRateEnum()
    1010
    11 macro=145;
     11macro=146;

  • issm/trunk/src/m/enum/Mesh2gridAnalysisEnum.m

    r4033 r4039  
    99%      macro=Mesh2gridAnalysisEnum()
    1010
    11 macro=42;
     11macro=43;

  • issm/trunk/src/m/enum/MinMechanicalConstraintsEnum.m

    r4033 r4039  
    99%      macro=MinMechanicalConstraintsEnum()
    1010
    11 macro=212;
     11macro=215;

  • issm/trunk/src/m/enum/MinThermalConstraintsEnum.m

    r4033 r4039  
    99%      macro=MinThermalConstraintsEnum()
    1010
    11 macro=213;
     11macro=216;

  • issm/trunk/src/m/enum/NStepsEnum.m

    r4033 r4039  
    99%      macro=NStepsEnum()
    1010
    11 macro=214;
     11macro=217;

  • issm/trunk/src/m/enum/NdtEnum.m

    r4033 r4039  
    99%      macro=NdtEnum()
    1010
    11 macro=215;
     11macro=218;

  • issm/trunk/src/m/enum/NodeEnum.m

    r4033 r4039  
    99%      macro=NodeEnum()
    1010
    11 macro=62;
     11macro=63;

  • issm/trunk/src/m/enum/NodeOnBedEnum.m

    r4033 r4039  
    99%      macro=NodeOnBedEnum()
    1010
    11 macro=146;
     11macro=147;

  • issm/trunk/src/m/enum/NodeOnIceSheetEnum.m

    r4033 r4039  
    99%      macro=NodeOnIceSheetEnum()
    1010
    11 macro=147;
     11macro=148;

  • issm/trunk/src/m/enum/NodeOnIceShelfEnum.m

    r4033 r4039  
    99%      macro=NodeOnIceShelfEnum()
    1010
    11 macro=148;
     11macro=149;

  • issm/trunk/src/m/enum/NodeOnSurfaceEnum.m

    r4033 r4039  
    99%      macro=NodeOnSurfaceEnum()
    1010
    11 macro=149;
     11macro=150;

  • issm/trunk/src/m/enum/NodePropertiesEnum.m

    r4033 r4039  
    99%      macro=NodePropertiesEnum()
    1010
    11 macro=58;
     11macro=59;

  • issm/trunk/src/m/enum/NoneAnalysisEnum.m

    r4033 r4039  
    99%      macro=NoneAnalysisEnum()
    1010
    11 macro=45;
     11macro=46;

  • issm/trunk/src/m/enum/NoneFormulationEnum.m

    r4033 r4039  
    99%      macro=NoneFormulationEnum()
    1010
    11 macro=49;
     11macro=50;

  • issm/trunk/src/m/enum/NumOutputEnum.m

    r4033 r4039  
    99%      macro=NumOutputEnum()
    1010
    11 macro=216;
     11macro=219;

  • issm/trunk/src/m/enum/NumRiftsEnum.m

    r4033 r4039  
    99%      macro=NumRiftsEnum()
    1010
    11 macro=217;
     11macro=220;

  • issm/trunk/src/m/enum/NumberNodeToElementConnectivityEnum.m

    r4033 r4039  
    99%      macro=NumberNodeToElementConnectivityEnum()
    1010
    11 macro=150;
     11macro=151;

  • issm/trunk/src/m/enum/NumberOfDofsPerNodeEnum.m

    r4033 r4039  
    99%      macro=NumberOfDofsPerNodeEnum()
    1010
    11 macro=218;
     11macro=221;

  • issm/trunk/src/m/enum/NumberOfElementsEnum.m

    r4033 r4039  
    99%      macro=NumberOfElementsEnum()
    1010
    11 macro=219;
     11macro=222;

  • issm/trunk/src/m/enum/NumberOfNodesEnum.m

    r4033 r4039  
    99%      macro=NumberOfNodesEnum()
    1010
    11 macro=220;
     11macro=223;

  • issm/trunk/src/m/enum/NumberOfVerticesEnum.m

    r4033 r4039  
    99%      macro=NumberOfVerticesEnum()
    1010
    11 macro=221;
     11macro=224;

  • issm/trunk/src/m/enum/NumericalfluxEnum.m

    r4033 r4039  
    99%      macro=NumericalfluxEnum()
    1010
    11 macro=66;
     11macro=67;

  • issm/trunk/src/m/enum/ObjectEnum.m

    r4033 r4039  
    99%      macro=ObjectEnum()
    1010
    11 macro=52;
     11macro=53;

  • issm/trunk/src/m/enum/OptScalEnum.m

    r4033 r4039  
    99%      macro=OptScalEnum()
    1010
    11 macro=222;
     11macro=225;

  • issm/trunk/src/m/enum/OutputFileNameEnum.m

    r4033 r4039  
    99%      macro=OutputFileNameEnum()
    1010
    11 macro=223;
     11macro=226;

  • issm/trunk/src/m/enum/P0Enum.m

    r4033 r4039  
    99%      macro=P0Enum()
    1010
    11 macro=183;
     11macro=184;

  • issm/trunk/src/m/enum/P1Enum.m

    r4033 r4039  
    99%      macro=P1Enum()
    1010
    11 macro=184;
     11macro=185;

  • issm/trunk/src/m/enum/ParamEnum.m

    r4033 r4039  
    99%      macro=ParamEnum()
    1010
    11 macro=85;
     11macro=86;

  • issm/trunk/src/m/enum/ParameterOutputEnum.m

    r4033 r4039  
    99%      macro=ParameterOutputEnum()
    1010
    11 macro=224;
     11macro=227;

  • issm/trunk/src/m/enum/ParametersAnalysisEnum.m

    r4033 r4039  
    99%      macro=ParametersAnalysisEnum()
    1010
    11 macro=43;
     11macro=44;

  • issm/trunk/src/m/enum/PattynFormulationEnum.m

    r4033 r4039  
    99%      macro=PattynFormulationEnum()
    1010
    11 macro=50;
     11macro=51;

  • issm/trunk/src/m/enum/PenaltyMeltingEnum.m

    r4033 r4039  
    99%      macro=PenaltyMeltingEnum()
    1010
    11 macro=225;
     11macro=228;

  • issm/trunk/src/m/enum/PenaltyOffsetEnum.m

    r4033 r4039  
    99%      macro=PenaltyOffsetEnum()
    1010
    11 macro=151;
     11macro=152;

  • issm/trunk/src/m/enum/PengridEnum.m

    r4033 r4039  
    99%      macro=PengridEnum()
    1010
    11 macro=67;
     11macro=68;

  • issm/trunk/src/m/enum/PenpairEnum.m

    r4033 r4039  
    99%      macro=PenpairEnum()
    1010
    11 macro=68;
     11macro=69;

  • issm/trunk/src/m/enum/PentaEnum.m

    r4033 r4039  
    99%      macro=PentaEnum()
    1010
    11 macro=59;
     11macro=60;

  • issm/trunk/src/m/enum/PentaVertexInputEnum.m

    r4033 r4039  
    99%      macro=PentaVertexInputEnum()
    1010
    11 macro=82;
     11macro=83;

  • issm/trunk/src/m/enum/PetscMatParamEnum.m

    r4033 r4039  
    99%      macro=PetscMatParamEnum()
    1010
    11 macro=91;
     11macro=92;

  • issm/trunk/src/m/enum/PetscVecParamEnum.m

    r4033 r4039  
    99%      macro=PetscVecParamEnum()
    1010
    11 macro=92;
     11macro=93;

  • issm/trunk/src/m/enum/PflagEnum.m

    r4033 r4039  
    99%      macro=PflagEnum()
    1010
    11 macro=152;
     11macro=153;

  • issm/trunk/src/m/enum/PressureEnum.m

    r4033 r4039  
    99%      macro=PressureEnum()
    1010
    11 macro=153;
     11macro=154;

  • issm/trunk/src/m/enum/PressureOldEnum.m

    r4033 r4039  
    99%      macro=PressureOldEnum()
    1010
    11 macro=154;
     11macro=155;

  • issm/trunk/src/m/enum/Prognostic2AnalysisEnum.m

    r4033 r4039  
    99%      macro=Prognostic2AnalysisEnum()
    1010
    11 macro=39;
     11macro=40;

  • issm/trunk/src/m/enum/PrognosticAnalysisEnum.m

    r4033 r4039  
    99%      macro=PrognosticAnalysisEnum()
    1010
    11 macro=40;
     11macro=41;

  • issm/trunk/src/m/enum/QmuAnalysisEnum.m

    r4033 r4039  
    99%      macro=QmuAnalysisEnum()
    1010
    11 macro=226;
     11macro=229;

  • issm/trunk/src/m/enum/QmuErrNameEnum.m

    r4033 r4039  
    99%      macro=QmuErrNameEnum()
    1010
    11 macro=227;
     11macro=230;

  • issm/trunk/src/m/enum/QmuInNameEnum.m

    r4033 r4039  
    99%      macro=QmuInNameEnum()
    1010
    11 macro=228;
     11macro=231;

  • issm/trunk/src/m/enum/QmuMassFluxSegmentsEnum.m

    r4033 r4039  
    99%      macro=QmuMassFluxSegmentsEnum()
    1010
    11 macro=229;
     11macro=232;

  • issm/trunk/src/m/enum/QmuNPartEnum.m

    r4033 r4039  
    99%      macro=QmuNPartEnum()
    1010
    11 macro=230;
     11macro=233;

  • issm/trunk/src/m/enum/QmuOutNameEnum.m

    r4033 r4039  
    99%      macro=QmuOutNameEnum()
    1010
    11 macro=231;
     11macro=234;

  • issm/trunk/src/m/enum/QmuPartEnum.m

    r4033 r4039  
    99%      macro=QmuPartEnum()
    1010
    11 macro=232;
     11macro=235;

  • issm/trunk/src/m/enum/QuadIceFrontEnum.m

    r4033 r4039  
    99%      macro=QuadIceFrontEnum()
    1010
    11 macro=69;
     11macro=70;

  • issm/trunk/src/m/enum/QuadRiftFrontEnum.m

    r4033 r4039  
    99%      macro=QuadRiftFrontEnum()
    1010
    11 macro=70;
     11macro=71;

  • issm/trunk/src/m/enum/ResetPenaltiesEnum.m

    r4033 r4039  
    99%      macro=ResetPenaltiesEnum()
    1010
    11 macro=155;
     11macro=156;

  • issm/trunk/src/m/enum/ResponseDescriptorsEnum.m

    r4033 r4039  
    99%      macro=ResponseDescriptorsEnum()
    1010
    11 macro=233;
     11macro=236;

  • issm/trunk/src/m/enum/ResultEnum.m

    r4033 r4039  
    99%      macro=ResultEnum()
    1010
    11 macro=95;
     11macro=96;

  • issm/trunk/src/m/enum/RgbEnum.m

    r4033 r4039  
    99%      macro=RgbEnum()
    1010
    11 macro=96;
     11macro=97;

  • issm/trunk/src/m/enum/RheologyBEnum.m

    r4033 r4039  
    99%      macro=RheologyBEnum()
    1010
    11 macro=156;
     11macro=157;

  • issm/trunk/src/m/enum/RheologyNEnum.m

    r4033 r4039  
    99%      macro=RheologyNEnum()
    1010
    11 macro=157;
     11macro=158;

  • issm/trunk/src/m/enum/RiftfrontEnum.m

    r4033 r4039  
    99%      macro=RiftfrontEnum()
    1010
    11 macro=71;
     11macro=72;

  • issm/trunk/src/m/enum/SegmentIcefrontEnum.m

    r4033 r4039  
    99%      macro=SegmentIcefrontEnum()
    1010
    11 macro=72;
     11macro=73;

  • issm/trunk/src/m/enum/SegmentOnIceShelfEnum.m

    r4033 r4039  
    99%      macro=SegmentOnIceShelfEnum()
    1010
    11 macro=158;
     11macro=159;

  • issm/trunk/src/m/enum/SegmentRiftfrontEnum.m

    r4033 r4039  
    99%      macro=SegmentRiftfrontEnum()
    1010
    11 macro=73;
     11macro=74;

  • issm/trunk/src/m/enum/SingEnum.m

    r4033 r4039  
    99%      macro=SingEnum()
    1010
    11 macro=60;
     11macro=61;

  • issm/trunk/src/m/enum/SingVertexInputEnum.m

    r4033 r4039  
    99%      macro=SingVertexInputEnum()
    1010
    11 macro=83;
     11macro=84;

  • issm/trunk/src/m/enum/SlopeComputeAnalysisEnum.m

    r4033 r4039  
    99%      macro=SlopeComputeAnalysisEnum()
    1010
    11 macro=31;
     11macro=32;

  • issm/trunk/src/m/enum/SolverStringEnum.m

    r4033 r4039  
    99%      macro=SolverStringEnum()
    1010
    11 macro=234;
     11macro=237;

  • issm/trunk/src/m/enum/SparsityEnum.m

    r4033 r4039  
    99%      macro=SparsityEnum()
    1010
    11 macro=235;
     11macro=238;

  • issm/trunk/src/m/enum/SpcEnum.m

    r4033 r4039  
    99%      macro=SpcEnum()
    1010
    11 macro=97;
     11macro=98;

  • issm/trunk/src/m/enum/StabilizeConstraintsEnum.m

    r4033 r4039  
    99%      macro=StabilizeConstraintsEnum()
    1010
    11 macro=159;
     11macro=160;

  • issm/trunk/src/m/enum/SteadyAnalysisEnum.m

    r4033 r4039  
    99%      macro=SteadyAnalysisEnum()
    1010
    11 macro=30;
     11macro=31;

  • issm/trunk/src/m/enum/SteadystateAnalysisEnum.m

    r4033 r4039  
    99%      macro=SteadystateAnalysisEnum()
    1010
    11 macro=44;
     11macro=45;

  • issm/trunk/src/m/enum/StokesAnalysisEnum.m

    r4033 r4039  
    99%      macro=StokesAnalysisEnum()
    1010
    11 macro=22;
     11macro=23;

  • issm/trunk/src/m/enum/StokesFormulationEnum.m

    r4033 r4039  
    99%      macro=StokesFormulationEnum()
    1010
    11 macro=51;
     11macro=52;

  • issm/trunk/src/m/enum/StokesReconditioningEnum.m

    r4033 r4039  
    99%      macro=StokesReconditioningEnum()
    1010
    11 macro=160;
     11macro=161;

  • issm/trunk/src/m/enum/StringArrayParamEnum.m

    r4033 r4039  
    99%      macro=StringArrayParamEnum()
    1010
    11 macro=93;
     11macro=94;

  • issm/trunk/src/m/enum/StringAsEnum.m

    r4033 r4039  
    2424elseif (strcmpi(name,'AnalysisType')), enum=AnalysisTypeEnum(); return
    2525elseif (strcmpi(name,'SubAnalysisType')), enum=SubAnalysisTypeEnum(); return
     26elseif (strcmpi(name,'AnalysisCounter')), enum=AnalysisCounterEnum(); return
    2627elseif (strcmpi(name,'DiagnosticAnalysis')), enum=DiagnosticAnalysisEnum(); return
    2728elseif (strcmpi(name,'DiagnosticHorizAnalysis')), enum=DiagnosticHorizAnalysisEnum(); return
    … …  
    194195elseif (strcmpi(name,'P0')), enum=P0Enum(); return
    195196elseif (strcmpi(name,'P1')), enum=P1Enum(); return
    196 elseif (strcmpi(name,'StringResult')), enum=StringResultEnum(); return
    197 elseif (strcmpi(name,'DoubleVecResult')), enum=DoubleVecResultEnum(); return
    198 elseif (strcmpi(name,'DoubleMatResult')), enum=DoubleMatResultEnum(); return
     197elseif (strcmpi(name,'DoubleResult')), enum=DoubleResultEnum(); return
     198elseif (strcmpi(name,'TriaVertexResult')), enum=TriaVertexResultEnum(); return
     199elseif (strcmpi(name,'PentaVertexResult')), enum=PentaVertexResultEnum(); return
     200elseif (strcmpi(name,'SingVertexResult')), enum=SingVertexResultEnum(); return
     201elseif (strcmpi(name,'BeamVertexResult')), enum=BeamVertexResultEnum(); return
    199202elseif (strcmpi(name,'Beta')), enum=BetaEnum(); return
    200203elseif (strcmpi(name,'CmGradient')), enum=CmGradientEnum(); return

  • issm/trunk/src/m/enum/StringParamEnum.m

    r4033 r4039  
    99%      macro=StringParamEnum()
    1010
    11 macro=94;
     11macro=95;

  • issm/trunk/src/m/enum/SurfaceAreaEnum.m

    r4033 r4039  
    99%      macro=SurfaceAreaEnum()
    1010
    11 macro=161;
     11macro=162;

  • issm/trunk/src/m/enum/SurfaceEnum.m

    r4033 r4039  
    99%      macro=SurfaceEnum()
    1010
    11 macro=162;
     11macro=163;

  • issm/trunk/src/m/enum/SurfaceSlopeXAnalysisEnum.m

    r4033 r4039  
    99%      macro=SurfaceSlopeXAnalysisEnum()
    1010
    11 macro=34;
     11macro=35;

  • issm/trunk/src/m/enum/SurfaceSlopeXEnum.m

    r4033 r4039  
    99%      macro=SurfaceSlopeXEnum()
    1010
    11 macro=163;
     11macro=164;

  • issm/trunk/src/m/enum/SurfaceSlopeYAnalysisEnum.m

    r4033 r4039  
    99%      macro=SurfaceSlopeYAnalysisEnum()
    1010
    11 macro=35;
     11macro=36;

  • issm/trunk/src/m/enum/SurfaceSlopeYEnum.m

    r4033 r4039  
    99%      macro=SurfaceSlopeYEnum()
    1010
    11 macro=164;
     11macro=165;

  • issm/trunk/src/m/enum/TemperatureAverageEnum.m

    r4033 r4039  
    99%      macro=TemperatureAverageEnum()
    1010
    11 macro=166;
     11macro=167;

  • issm/trunk/src/m/enum/TemperatureEnum.m

    r4033 r4039  
    99%      macro=TemperatureEnum()
    1010
    11 macro=165;
     11macro=166;

  • issm/trunk/src/m/enum/ThermalAnalysisEnum.m

    r4033 r4039  
    99%      macro=ThermalAnalysisEnum()
    1010
    11 macro=28;
     11macro=29;

  • issm/trunk/src/m/enum/ThicknessEnum.m

    r4033 r4039  
    99%      macro=ThicknessEnum()
    1010
    11 macro=167;
     11macro=168;

  • issm/trunk/src/m/enum/TolXEnum.m

    r4033 r4039  
    99%      macro=TolXEnum()
    1010
    11 macro=236;
     11macro=239;

  • issm/trunk/src/m/enum/TransientAnalysisEnum.m

    r4033 r4039  
    99%      macro=TransientAnalysisEnum()
    1010
    11 macro=29;
     11macro=30;

  • issm/trunk/src/m/enum/TriaEnum.m

    r4033 r4039  
    99%      macro=TriaEnum()
    1010
    11 macro=61;
     11macro=62;

  • issm/trunk/src/m/enum/TriaVertexInputEnum.m

    r4033 r4039  
    99%      macro=TriaVertexInputEnum()
    1010
    11 macro=84;
     11macro=85;

  • issm/trunk/src/m/enum/TypeEnum.m

    r4033 r4039  
    99%      macro=TypeEnum()
    1010
    11 macro=168;
     11macro=169;

  • issm/trunk/src/m/enum/VariableDescriptorsEnum.m

    r4033 r4039  
    99%      macro=VariableDescriptorsEnum()
    1010
    11 macro=237;
     11macro=240;

  • issm/trunk/src/m/enum/VerboseEnum.m

    r4033 r4039  
    99%      macro=VerboseEnum()
    1010
    11 macro=238;
     11macro=241;

  • issm/trunk/src/m/enum/VertAnalysisEnum.m

    r4033 r4039  
    99%      macro=VertAnalysisEnum()
    1010
    11 macro=23;
     11macro=24;

  • issm/trunk/src/m/enum/VertexEnum.m

    r4033 r4039  
    99%      macro=VertexEnum()
    1010
    11 macro=63;
     11macro=64;

  • issm/trunk/src/m/enum/ViscosityOvershootEnum.m

    r4033 r4039  
    99%      macro=ViscosityOvershootEnum()
    1010
    11 macro=169;
     11macro=170;

  • issm/trunk/src/m/enum/VxAverageEnum.m

    r4033 r4039  
    99%      macro=VxAverageEnum()
    1010
    11 macro=170;
     11macro=171;

  • issm/trunk/src/m/enum/VxEnum.m

    r4033 r4039  
    99%      macro=VxEnum()
    1010
    11 macro=171;
     11macro=172;

  • issm/trunk/src/m/enum/VxObsEnum.m

    r4033 r4039  
    99%      macro=VxObsEnum()
    1010
    11 macro=172;
     11macro=173;

  • issm/trunk/src/m/enum/VxOldEnum.m

    r4033 r4039  
    99%      macro=VxOldEnum()
    1010
    11 macro=173;
     11macro=174;

  • issm/trunk/src/m/enum/VyAverageEnum.m

    r4033 r4039  
    99%      macro=VyAverageEnum()
    1010
    11 macro=174;
     11macro=175;

  • issm/trunk/src/m/enum/VyEnum.m

    r4033 r4039  
    99%      macro=VyEnum()
    1010
    11 macro=175;
     11macro=176;

  • issm/trunk/src/m/enum/VyObsEnum.m

    r4033 r4039  
    99%      macro=VyObsEnum()
    1010
    11 macro=176;
     11macro=177;

  • issm/trunk/src/m/enum/VyOldEnum.m

    r4033 r4039  
    99%      macro=VyOldEnum()
    1010
    11 macro=177;
     11macro=178;

  • issm/trunk/src/m/enum/VzAverageEnum.m

    r4033 r4039  
    99%      macro=VzAverageEnum()
    1010
    11 macro=178;
     11macro=179;

  • issm/trunk/src/m/enum/VzEnum.m

    r4033 r4039  
    99%      macro=VzEnum()
    1010
    11 macro=179;
     11macro=180;

  • issm/trunk/src/m/enum/VzObsEnum.m

    r4033 r4039  
    99%      macro=VzObsEnum()
    1010
    11 macro=180;
     11macro=181;

  • issm/trunk/src/m/enum/VzOldEnum.m

    r4033 r4039  
    99%      macro=VzOldEnum()
    1010
    11 macro=181;
     11macro=182;

  • issm/trunk/src/m/enum/WaitOnLockEnum.m

    r4033 r4039  
    99%      macro=WaitOnLockEnum()
    1010
    11 macro=239;
     11macro=242;

  • issm/trunk/src/m/enum/WaterEnum.m

    r4033 r4039  
    99%      macro=WaterEnum()
    1010
    11 macro=102;
     11macro=103;

  • issm/trunk/src/m/enum/WeightsEnum.m

    r4033 r4039  
    99%      macro=WeightsEnum()
    1010
    11 macro=182;
     11macro=183;

  • issm/trunk/src/m/enum/YtsEnum.m

    r4033 r4039  
    99%      macro=YtsEnum()
    1010
    11 macro=240;
     11macro=243;

  • issm/trunk/todo

    r3919 r4039  
    8787test commit
    8888test2
     89
     90
     91
     92
     93transfer slope computation scripts in serial, to reflect new scripts in parallel. 
     94md=solve(md,'SolutionType','DiagnosticSolutionEnum'); instead of md=solve(md,'AnalysisType','DiagnosticSolutionEnum');  do the work of transferring
     95
     96
     97
     98
Note: See TracChangeset for help on using the changeset viewer.