Changeset 16486


Ignore:
Timestamp:
10/21/13 16:11:53 (11 years ago)
Author:
Mathieu Morlighem
Message:

DEL: removing results from elements

Location:
issm/trunk-jpl/src/c
Files:
1 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified issm/trunk-jpl/src/c/CMakeLists.txt

    r16485 r16486  
    99                          $ENV{ISSM_DIR}/src/c/classes
    1010                          $ENV{ISSM_DIR}/src/c/classes/Options
    11                           $ENV{ISSM_DIR}/src/c/classes/ElementResults
    1211                          $ENV{ISSM_DIR}/src/c/classes/ExternalResults
    1312                          $ENV{ISSM_DIR}/src/c/classes/Elements
    … …  
    9594                                        ./classes/Vertex.cpp
    9695                                        ./classes/Hook.cpp
    97                                         ./classes/ElementResults/DoubleElementResult.cpp
    98                                         ./classes/ElementResults/TriaP1ElementResult.cpp
    99                                         ./classes/ElementResults/BoolElementResult.cpp
    10096                                        ./classes/ExternalResults/Results.cpp
    10197                                        ./classes/Elements/Elements.cpp
    … …  
    395391#3D sources  {{{
    396392set(threed_sources                           ./classes/gauss/GaussPenta.cpp
    397                                                              ./classes/ElementResults/PentaP1ElementResult.cpp
    398393                                                             ./classes/Inputs/PentaInput.cpp
    399394                                                             ./classes/Elements/Penta.cpp

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

    r16485 r16486  
    6363                                        ./classes/Hook.h\
    6464                                        ./classes/Hook.cpp\
    65                                         ./classes/ElementResults/ElementResultLocal.h\
    66                                         ./classes/ElementResults/DoubleElementResult.h\
    67                                         ./classes/ElementResults/DoubleElementResult.cpp\
    68                                         ./classes/ElementResults/TriaP1ElementResult.h\
    69                                         ./classes/ElementResults/TriaP1ElementResult.cpp\
    70                                         ./classes/ElementResults/BoolElementResult.h\
    71                                         ./classes/ElementResults/BoolElementResult.cpp\
    7265                                        ./classes/ExternalResults/Results.h\
    7366                                        ./classes/ExternalResults/Results.cpp\
    … …  
    594587threed_sources = ./classes/gauss/GaussPenta.h\
    595588                                     ./classes/gauss/GaussPenta.cpp\
    596                                      ./classes/ElementResults/PentaP1ElementResult.h\
    597                                      ./classes/ElementResults/PentaP1ElementResult.cpp\
    598589                                     ./classes/Inputs/PentaInput.h\
    599590                                     ./classes/Inputs/PentaInput.cpp\

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Element.h

    r16485 r16486  
    5959                virtual void   ComputeBasalStress(Vector<IssmDouble>* sigma_b)=0;
    6060                virtual void   ComputeStrainRate(Vector<IssmDouble>* eps)=0;
    61                 virtual void   ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results)=0;
    6261                virtual void   ResultInterpolation(int* pinterpolation,int output_enum)=0;
    6362                virtual void   ResultToVector(Vector<IssmPDouble>* vector,int output_enum)=0;
    64                 virtual void   DeleteResults(void)=0;
    6563                virtual void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;
    6664                virtual void   InputDuplicate(int original_enum,int new_enum)=0;
    … …  
    7068                virtual void   InputScale(int enum_type,IssmDouble scale_factor)=0;
    7169                virtual void   GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum)=0;
    72                 virtual void   GetVectorFromResults(Vector<IssmDouble>* vector,int id,int enum_in,int interp)=0;
    7370                virtual IssmDouble TimeAdapt()=0;
    7471                virtual void   PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm)=0;

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Elements.cpp

    r16470 r16486  
    5151}
    5252/*}}}*/
    53 /*FUNCTION Elements::DeleteResults{{{*/
    54 void Elements::DeleteResults(void){
    55 
    56         for (int i=0;i<this->Size();i++){
    57                 Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(i));
    58                 element->DeleteResults();
    59         }
    60 }
    61 /*}}}*/
    6253/*FUNCTION Elements::SetCurrentConfiguration{{{*/
    6354void Elements::SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){
    … …  
    7364        }
    7465
    75 }
    76 /*}}}*/
    77 /*FUNCTION Elements::ToResults{{{*/
    78 void Elements::ToResults(Results* results,Parameters* parameters){
    79 
    80         int my_rank;
    81         int num_procs;
    82 
    83         int                 *resultsenums       = NULL;
    84         int                 *resultssizes       = NULL;
    85         int                 *resultssteps       = NULL;
    86         IssmDouble          *resultstimes       = NULL;
    87         IssmDouble          *vector_serial      = NULL;
    88         Vector<IssmDouble> *vector = NULL;
    89         bool                io_gather;
    90         int                 numberofvertices,numberofelements;
    91         int                 numberofresults ,vectorsize;
    92         int                 rank;
    93         int                 minrank;
    94 
    95         /*recover my_rank:*/
    96         my_rank=IssmComm::GetRank();
    97         num_procs=IssmComm::GetSize();
    98 
    99         /*Recover parameters: */
    100         parameters->FindParam(&io_gather,SettingsIoGatherEnum);
    101         parameters->FindParam(&numberofvertices,MeshNumberofverticesEnum);
    102         parameters->FindParam(&numberofelements,MeshNumberofelementsEnum);
    103 
    104         /*Get rank of first cpu that has results*/
    105         if(this->Size()) rank=my_rank;
    106         else rank=num_procs;
    107         ISSM_MPI_Allreduce (&rank,&minrank,1,ISSM_MPI_INT,ISSM_MPI_MIN,IssmComm::GetComm());
    108 
    109         /*see what the first element of this partition has in stock (this is common to all partitions)*/
    110         if(my_rank==minrank){
    111                 if(this->Size()==0) _error_("Cannot write results because there is no element??");
    112                 Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(0));
    113                 element->ListResultsInfo(&resultsenums,&resultssizes,&resultstimes,&resultssteps,&numberofresults);
    114         }
    115         ISSM_MPI_Bcast(&numberofresults,1,ISSM_MPI_INT,minrank,IssmComm::GetComm());
    116 
    117         /*Get out if there is no results. Otherwise broadcast info*/
    118         if(!numberofresults) return;
    119         if(my_rank!=minrank){
    120                 resultsenums=xNew<int>(numberofresults);
    121                 resultssizes=xNew<int>(numberofresults);
    122                 resultstimes=xNew<IssmDouble>(numberofresults);
    123                 resultssteps=xNew<int>(numberofresults);
    124         }
    125         ISSM_MPI_Bcast(resultsenums,numberofresults,ISSM_MPI_INT,minrank,IssmComm::GetComm());
    126         ISSM_MPI_Bcast(resultssizes,numberofresults,ISSM_MPI_INT,minrank,IssmComm::GetComm());
    127         ISSM_MPI_Bcast(resultstimes,numberofresults,ISSM_MPI_DOUBLE,minrank,IssmComm::GetComm());
    128         ISSM_MPI_Bcast(resultssteps,numberofresults,ISSM_MPI_INT,minrank,IssmComm::GetComm());
    129 
    130         /*Loop over all results and get nodal vector*/
    131         for(int i=0;i<numberofresults;i++){
    132 
    133                 /*Get vector for result number i*/
    134                 if(resultssizes[i]==P1Enum)      vectorsize=numberofvertices;
    135                 else if(resultssizes[i]==P0Enum) vectorsize=numberofelements;
    136                 else _error_("Unkown result size: " << EnumToStringx(resultssizes[i]));
    137                 vector=new Vector<IssmDouble>(vectorsize);
    138 
    139                 for(int j=0;j<this->Size();j++){
    140                         Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(j));
    141                         element->GetVectorFromResults(vector,i,resultsenums[i],resultssizes[i]);
    142                 }
    143                 vector->Assemble();
    144 
    145                 /*Serialize and add to results*/
    146                 vector_serial=vector->ToMPISerial();
    147                 results->DeleteResult(resultsenums[i],resultssteps[i]);
    148                 if(my_rank==0){
    149                         /*No need to add this vector for all cpus*/
    150 #ifdef _HAVE_ADOLC_
    151                         IssmPDouble* vector_serial_passive=xNew<IssmPDouble>(vectorsize);
    152                         for(int k=0;k<vectorsize;k++)vector_serial_passive[k]=reCast<IssmPDouble>(vector_serial[k]);
    153                         results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,resultsenums[i],vector_serial_passive,vectorsize,1,resultssteps[i],resultstimes[i]));
    154                         xDelete<IssmPDouble>(vector_serial_passive);
    155 #else
    156                         results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,resultsenums[i],vector_serial,vectorsize,1,resultssteps[i],resultstimes[i]));
    157 #endif
    158                 }
    159 
    160                 /*clean up*/
    161                 delete vector;
    162                 xDelete<IssmDouble>(vector_serial);
    163         }
    164 
    165         /*Free ressources:*/
    166         xDelete<int>(resultsenums);
    167         xDelete<int>(resultssizes);
    168         xDelete<int>(resultssteps);
    169         xDelete<IssmDouble>(resultstimes);
    17066}
    17167/*}}}*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Elements.h

    r16470 r16486  
    2525                /*numerics*/
    2626                void   Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    27                 void   DeleteResults(void);
    2827                int    MaxNumNodes(void);
    2928                void   SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    30                 void   ToResults(Results* results,Parameters* parameters);
    3129                int    NumberOfElements(void);
    3230                void   InputDuplicate(int input_enum,int output_enum);

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r16485 r16486  
    3030        this->inputs            = NULL;
    3131        this->parameters        = NULL;
    32         this->results           = NULL;
    3332}
    3433/*}}}*/
    … …  
    3635Penta::~Penta(){
    3736        delete inputs;
    38         delete results;
    3937        this->parameters=NULL;
    4038}
    … …  
    6563        this->parameters=NULL;
    6664
    67         /*intialize inputs and results: */
     65        /*intialize inputs: */
    6866        this->inputs=new Inputs();
    69         this->results=new Results();
    7067
    7168        /*initialize pointers:*/
    … …  
    107104        else{
    108105                penta->inputs=new Inputs();
    109         }
    110         if(this->results){
    111                 penta->results=(Results*)this->results->Copy();
    112         }
    113         else{
    114                 penta->results=new Results();
    115106        }
    116107        /*point parameters: */
    … …  
    845836        _printf_("   inputs\n");
    846837        inputs->DeepEcho();
    847         _printf_("   results\n");
    848         results->DeepEcho();
    849 }
    850 /*}}}*/
    851 /*FUNCTION Penta::DeleteResults {{{*/
    852 void  Penta::DeleteResults(void){
    853 
    854         /*Delete and reinitialize results*/
    855         delete this->results;
    856         this->results=new Results();
    857 
    858838}
    859839/*}}}*/
    … …  
    16561636        /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
    16571637        input->GetVectorFromInputs(vector,&vertexpidlist[0]);
    1658 }
    1659 /*}}}*/
    1660 /*FUNCTION Penta::GetVectorFromResults{{{*/
    1661 void  Penta::GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp){
    1662 
    1663         /*Get result*/
    1664         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
    1665         if(interp==P1Enum){
    1666                 int vertexpidlist[NUMVERTICES];
    1667                 int connectivity[NUMVERTICES];
    1668                 this->GetVertexSidList(&vertexpidlist[0]);
    1669                 this->GetConnectivityList(&connectivity[0]);
    1670                 elementresult->GetVectorFromResults(vector,&vertexpidlist[0],&connectivity[0],NUMVERTICES);
    1671         }
    1672         else if(interp==P0Enum){
    1673                 elementresult->GetElementVectorFromResults(vector,sid);
    1674         }
    1675         else{
    1676                 _printf_("Interpolation " << EnumToStringx(interp) << " not supported\n");
    1677         }
    16781638}
    16791639/*}}}*/
    … …  
    27592719}
    27602720/*}}}*/
    2761 /*FUNCTION Penta::ListResultsInfo{{{*/
    2762 void Penta::ListResultsInfo(int** in_resultsenums,int** in_resultssizes,IssmDouble** in_resultstimes,int** in_resultssteps,int* in_num_results){
    2763 
    2764         /*Intermediaries*/
    2765         int        *resultsenums    = NULL;
    2766         int        *resultssizes    = NULL;
    2767         IssmDouble *resultstimes    = NULL;
    2768         int        *resultssteps    = NULL;
    2769 
    2770         /*Checks*/
    2771         _assert_(in_num_results);
    2772 
    2773         /*Count number of results*/
    2774         int numberofresults = this->results->Size();
    2775 
    2776         if(numberofresults){
    2777                 /*Allocate output*/
    2778                 resultsenums=xNew<int>(numberofresults);
    2779                 resultssizes=xNew<int>(numberofresults);
    2780                 resultstimes=xNew<IssmDouble>(numberofresults);
    2781                 resultssteps=xNew<int>(numberofresults);
    2782 
    2783                 /*populate enums*/
    2784                 for(int i=0;i<this->results->Size();i++){
    2785                         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2786                         resultsenums[i]=StringToEnumx(elementresult->GetResultName());
    2787                         resultstimes[i]=elementresult->GetTime();
    2788                         resultssteps[i]=elementresult->GetStep();
    2789                         if(elementresult->ObjectEnum()==PentaP1ElementResultEnum){
    2790                                 resultssizes[i]=P1Enum;
    2791                         }
    2792                         else{
    2793                                 resultssizes[i]=P0Enum;
    2794                         }
    2795                 }
    2796         }
    2797 
    2798         /*Assign output pointers:*/
    2799         *in_num_results=numberofresults;
    2800         *in_resultsenums=resultsenums;
    2801         *in_resultssizes=resultssizes;
    2802         *in_resultstimes=resultstimes;
    2803         *in_resultssteps=resultssteps;
    2804 
    2805 }/*}}}*/
    28062721/*FUNCTION Penta::MinEdgeLength{{{*/
    28072722IssmDouble Penta::MinEdgeLength(IssmDouble xyz_list[6][3]){

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r16485 r16486  
    4343                Parameters  *parameters;                  //pointer to solution parameters
    4444                Inputs      *inputs;
    45                 Results     *results;
    4645
    4746                /*Penta constructors and destructor: {{{*/
    … …  
    8281                void   CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
    8382                void   Delta18oParameterization(void);
    84                 void   DeleteResults(void);
    8583                int    GetNodeIndex(Node* node);
    8684                void   GetNodesSidList(int* sidlist);
    … …  
    9088                IssmDouble GetZcoord(GaussPenta* gauss);
    9189                void   GetVectorFromInputs(Vector<IssmDouble>* vector,int name_enum);
    92                 void   GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int name_enum,int interp);
    9390
    9491                int    Sid();
    … …  
    9895                void   InputScale(int enum_type,IssmDouble scale_factor);
    9996
    100                 void   ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
    10197                void   ResultInterpolation(int* pinterpolation,int output_enum);
    10298                void   ResultToVector(Vector<IssmPDouble>* vector,int output_enum);

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Seg.cpp

    r16434 r16486  
    2727        this->inputs     = NULL;
    2828        this->parameters = NULL;
    29         this->results    = NULL;
    3029}
    3130/*}}}*/
    … …  
    4140                        this->parameters = NULL;
    4241
    43                         /*intialize inputs and results: */
     42                        /*intialize inputs: */
    4443                        this->inputs  = new Inputs();
    45                         this->results = new Results();
    4644
    4745                        /*initialize pointers:*/
    … …  
    5654Seg::~Seg(){
    5755        delete inputs;
    58         delete results;
    5956        this->parameters=NULL;
    6057}
    … …  
    8986        if (inputs) inputs->Echo();
    9087        else _printf_("inputs=NULL\n");
    91 
    92         if (results) results->Echo();
    93         else _printf_("results=NULL\n");
    9488}
    9589/*}}}*/
    … …  
    118112        if (inputs) inputs->DeepEcho();
    119113        else _printf_("inputs=NULL\n");
    120 
    121         if (results) results->DeepEcho();
    122         else _printf_("results=NULL\n");
    123114
    124115        return;

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Seg.h

    r16485 r16486  
    4040                Parameters  *parameters;                  //pointer to solution parameters
    4141                Inputs      *inputs;
    42                 Results     *results;
    4342
    4443                /*Seg constructors, destructors {{{*/
    … …  
    105104                void        GetSolutionFromInputs(Vector<IssmDouble>* solution){_error_("not implemented yet");};
    106105                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum){_error_("not implemented yet");};
    107                 void        GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp){_error_("not implemented yet");};
    108106                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){_error_("not implemented yet");};
    109107                void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum){_error_("not implemented yet");};
    110108                void        InputDuplicate(int original_enum,int new_enum){_error_("not implemented yet");};
    111109                void        InputScale(int enum_type,IssmDouble scale_factor){_error_("not implemented yet");};
    112                 void        DeleteResults(void){_error_("not implemented yet");};
    113110                void        MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
    114111                int         NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){_error_("not implemented yet");};
    115112                void        PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm){_error_("not implemented yet");};
    116                 void        ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results){_error_("not implemented yet");};
    117113                void        ResultInterpolation(int* pinterpolation,int output_enum){_error_("not implemented");};
    118114                void        ResultToVector(Vector<IssmPDouble>* vector,int output_enum){_error_("not implemented");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r16485 r16486  
    3232        this->inputs     = NULL;
    3333        this->parameters = NULL;
    34         this->results    = NULL;
    3534
    3635}
    … …  
    4746                this->parameters = NULL;
    4847
    49                 /*intialize inputs and results: */
     48                /*intialize inputs: */
    5049                this->inputs  = new Inputs();
    51                 this->results = new Results();
    5250
    5351                /*initialize pointers:*/
    … …  
    6260Tria::~Tria(){
    6361        delete inputs;
    64         delete results;
    6562        this->parameters=NULL;
    6663}
    … …  
    9491        else{
    9592                tria->inputs=new Inputs();
    96         }
    97         if(this->results){
    98                 tria->results=(Results*)this->results->Copy();
    99         }
    100         else{
    101                 tria->results=new Results();
    10293        }
    10394        /*point parameters: */
    … …  
    759750        else _printf_("inputs=NULL\n");
    760751
    761         if (results) results->DeepEcho();
    762         else _printf_("results=NULL\n");
    763 
    764752        return;
    765 }
    766 /*}}}*/
    767 /*FUNCTION Tria::DeleteResults {{{*/
    768 void  Tria::DeleteResults(void){
    769 
    770         /*Delete and reinitialize results*/
    771         delete this->results;
    772         this->results=new Results();
    773 
    774753}
    775754/*}}}*/
    … …  
    869848        if (inputs) inputs->Echo();
    870849        else _printf_("inputs=NULL\n");
    871 
    872         if (results) results->Echo();
    873         else _printf_("results=NULL\n");
    874850}
    875851/*}}}*/
    … …  
    15491525        /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
    15501526        input->GetVectorFromInputs(vector,&vertexpidlist[0]);
    1551 }
    1552 /*}}}*/
    1553 /*FUNCTION Tria::GetVectorFromResults{{{*/
    1554 void  Tria::GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp){
    1555 
    1556         /*Get result*/
    1557         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
    1558         if(interp==P1Enum){
    1559                 int vertexpidlist[NUMVERTICES];
    1560                 int connectivity[NUMVERTICES];
    1561                 this->GetVertexSidList(&vertexpidlist[0]);
    1562                 this->GetConnectivityList(&connectivity[0]);
    1563                 elementresult->GetVectorFromResults(vector,&vertexpidlist[0],&connectivity[0],NUMVERTICES);
    1564         }
    1565         else if(interp==P0Enum){
    1566                 elementresult->GetElementVectorFromResults(vector,sid);
    1567         }
    1568         else{
    1569                 _printf_("Interpolation " << EnumToStringx(interp) << " not supported\n");
    1570         }
    15711527}
    15721528/*}}}*/
    … …  
    23472303}
    23482304/*}}}*/
    2349 /*FUNCTION Tria::ListResultsInfo{{{*/
    2350 void Tria::ListResultsInfo(int** in_resultsenums,int** in_resultssizes,IssmDouble** in_resultstimes,int** in_resultssteps,int* in_num_results){
    2351 
    2352         /*Intermediaries*/
    2353         int        *resultsenums    = NULL;
    2354         int        *resultssizes    = NULL;
    2355         IssmDouble *resultstimes    = NULL;
    2356         int        *resultssteps    = NULL;
    2357 
    2358         /*Checks*/
    2359         _assert_(in_num_results);
    2360 
    2361         /*Count number of results*/
    2362         int numberofresults = this->results->Size();
    2363 
    2364         if(numberofresults){
    2365 
    2366                 /*Allocate output*/
    2367                 resultsenums=xNew<int>(numberofresults);
    2368                 resultssizes=xNew<int>(numberofresults);
    2369                 resultstimes=xNew<IssmDouble>(numberofresults);
    2370                 resultssteps=xNew<int>(numberofresults);
    2371 
    2372                 /*populate enums*/
    2373                 for(int i=0;i<this->results->Size();i++){
    2374                         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2375                         resultsenums[i]=StringToEnumx(elementresult->GetResultName());
    2376                         resultstimes[i]=elementresult->GetTime();
    2377                         resultssteps[i]=elementresult->GetStep();
    2378                         if(elementresult->ObjectEnum()==TriaP1ElementResultEnum){
    2379                                 resultssizes[i]=P1Enum;
    2380                         }
    2381                         else{
    2382                                 resultssizes[i]=P0Enum;
    2383                         }
    2384                 }
    2385         }
    2386 
    2387         /*Assign output pointers:*/
    2388         *in_num_results=numberofresults;
    2389         *in_resultsenums=resultsenums;
    2390         *in_resultssizes=resultssizes;
    2391         *in_resultstimes=resultstimes;
    2392         *in_resultssteps=resultssteps;
    2393 
    2394 }/*}}}*/
    23952305/*FUNCTION Tria::NodalValue {{{*/
    23962306int    Tria::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){

  • TabularUnified issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r16485 r16486  
    4141                Parameters  *parameters;                  //pointer to solution parameters
    4242                Inputs      *inputs;
    43                 Results     *results;
    4443
    4544                /*Tria constructors, destructors {{{*/
    … …  
    9695                void        GetSolutionFromInputs(Vector<IssmDouble>* solution);
    9796                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum);
    98                 void        GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp);
    9997                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    10098                void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);
    10199                void        InputDuplicate(int original_enum,int new_enum);
    102100                void        InputScale(int enum_type,IssmDouble scale_factor);
    103                 void        DeleteResults(void);
    104101                void        MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
    105102                int         NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);
    106103                void        PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
    107                 void        ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
    108104                void        ResultInterpolation(int* pinterpolation,int output_enum);
    109105                void        ResultToVector(Vector<IssmPDouble>* vector,int output_enum);

  • TabularUnified issm/trunk-jpl/src/c/classes/ExternalResults/Results.cpp

    r16474 r16486  
    1515#include "../../shared/shared.h"
    1616#include "../Params/Parameters.h"
    17 #include "../ElementResults/ElementResult.h"
    1817
    1918using namespace std;
    … …  
    4948        }
    5049
    51 }
    52 /*}}}*/
    53 /*FUNCTION Results::AddResult(ElementResult* in_result){{{*/
    54 int Results::AddResult(ElementResult* in_result){
    55 
    56         /*First, go through dataset of inputs and check whether any input
    57          * with the same name is already in. If so, erase the corresponding
    58          * object before adding this new one: */
    59         vector<Object*>::iterator object;
    60 
    61         /*In debugging mode, check that the input is not a NULL pointer*/
    62         _assert_(in_result);
    63 
    64         for(object=objects.begin() ; object<objects.end(); object++){
    65 
    66                 ElementResult* result=dynamic_cast<ElementResult*>(*object);
    67 
    68                 if(result->GetStep()==in_result->GetStep()){
    69                         if(strcmp(result->GetResultName(),in_result->GetResultName())==0){
    70                                 this->DeleteObject(result);
    71                                 break;
    72                         }
    73                 }
    74         }
    75         this->AddObject(in_result);
    76 
    77         return 1;
    7850}
    7951/*}}}*/

  • TabularUnified issm/trunk-jpl/src/c/classes/ExternalResults/Results.h

    r16469 r16486  
    66/*forward declarations */
    77class Parameters;
    8 class ElementResult;
    98class ExternalResult;
    109
    … …  
    2221
    2322                /*Mehthos*/
    24                 int AddResult(ElementResult* result);
    2523                int AddResult(ExternalResult* result);
    2624                int DeleteResult(int result_enum,int result_step);

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/BoolInput.cpp

    r16382 r16486  
    101101}
    102102/*}}}*/
    103 /*FUNCTION BoolInput::SpawnResult{{{*/
    104 ElementResult* BoolInput::SpawnResult(int step, IssmDouble time){
    105 
    106         return new BoolElementResult(this->enum_type,this->value,step,time);
    107 
    108 }
    109 /*}}}*/
    110103
    111104/*Object functions*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/BoolInput.h

    r16461 r16486  
    3939                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
    4040                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    41                 ElementResult* SpawnResult(int step, IssmDouble time);
    4241                int  GetResultInterpolation(void){return P0Enum;};
    4342                void Configure(Parameters* parameters);

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/ControlInput.cpp

    r16478 r16486  
    185185
    186186}/*}}}*/
    187 /*FUNCTION ControlInput::SpawnResult{{{*/
    188 ElementResult* ControlInput::SpawnResult(int step, IssmDouble time){
    189         return savedvalues->SpawnResult(step,time);
    190 }/*}}}*/
    191187/*FUNCTION ControlInput::SpawnTriaInput{{{*/
    192188Input* ControlInput::SpawnTriaInput(int location){
    … …  
    196192Input* ControlInput::SpawnSegInput(int index1,int index2){
    197193        return values->SpawnSegInput(index1,index2);
    198 }/*}}}*/
    199 /*FUNCTION ControlInput::SpawnGradient{{{*/
    200 ElementResult* ControlInput::SpawnGradient(int step, IssmDouble time){
    201         _assert_(gradient);
    202         return gradient->SpawnResult(step,time);
    203194}/*}}}*/
    204195/*FUNCTION ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){{{*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/ControlInput.h

    r16478 r16486  
    4343                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
    4444                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    45                 ElementResult* SpawnResult(int step, IssmDouble time);
    4645                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4746                void Configure(Parameters* parameters);
    … …  
    9190                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist,const char* data);
    9291                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist);
    93                 ElementResult* SpawnGradient(int step, IssmDouble time);
    9492                int  GetResultInterpolation(void);
    9593                void GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist);

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.h

    r16461 r16486  
    4141                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
    4242                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    43                 ElementResult* SpawnResult(int step, IssmDouble time){_error_("not implemented yet");};
    4443                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4544                void Configure(Parameters* parameters);
    … …  
    8584                void VerticallyIntegrate(Input* thickness_input){_error_("not implemented yet");};
    8685                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){_error_("not implemented yet");};
    87                 ElementResult* SpawnGradient(int step, IssmDouble time){_error_("not implemented yet");};
    8886                int GetResultInterpolation(void){_error_("not implemented yet");};
    8987                void GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist){_error_("not implemented yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.cpp

    r16382 r16486  
    101101}
    102102/*}}}*/
    103 /*FUNCTION DoubleInput::SpawnResult{{{*/
    104 ElementResult* DoubleInput::SpawnResult(int step, IssmDouble time){
    105 
    106         return new DoubleElementResult(this->enum_type,this->value,step,time);
    107 
    108 }
    109 /*}}}*/
    110103
    111104/*Object functions*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.h

    r16461 r16486  
    3838                Input* PointwiseMin(Input* inputB);
    3939                Input* PointwiseMax(Input* inputB);
    40                 ElementResult* SpawnResult(int step, IssmDouble time);
    4140                int  GetResultInterpolation(void){return P0Enum;};
    4241                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/Input.h

    r16461 r16486  
    1111#include "../../shared/shared.h"
    1212class Node;
    13 class ElementResult;
    1413class GaussTria;
    1514class GaussSeg;
    … …  
    7271                virtual Input* PointwiseMax(Input* inputmax)=0;
    7372                virtual Input* PointwiseMin(Input* inputmin)=0;
    74                 virtual ElementResult* SpawnResult(int step, IssmDouble time)=0;
    7573                virtual int GetResultInterpolation(void)=0;
    7674};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/IntInput.cpp

    r16382 r16486  
    9999}
    100100/*}}}*/
    101 /*FUNCTION IntInput::SpawnResult{{{*/
    102 ElementResult* IntInput::SpawnResult(int step, IssmDouble time){
    103 
    104         _error_("not supported yet!");
    105 
    106 }
    107 /*}}}*/
    108101
    109102/*Object functions*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/IntInput.h

    r16461 r16486  
    3939                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
    4040                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    41                 ElementResult* SpawnResult(int step, IssmDouble time);
    4241                int  GetResultInterpolation(void){return P0Enum;};
    4342                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

    r16461 r16486  
    130130}
    131131/*}}}*/
    132 /*FUNCTION PentaInput::SpawnResult{{{*/
    133 ElementResult* PentaInput::SpawnResult(int step, IssmDouble time){
    134 
    135         return new PentaP1ElementResult(this->enum_type,this->values,step,time);
    136 
    137 }
    138 /*}}}*/
    139132/*FUNCTION PentaInput::GetResultInterpolation{{{*/
    140133int  PentaInput::GetResultInterpolation(void){

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/PentaInput.h

    r16461 r16486  
    3939                Input* PointwiseMin(Input* inputB);
    4040                Input* PointwiseMax(Input* inputB);
    41                 ElementResult* SpawnResult(int step, IssmDouble time);
    4241                int  GetResultInterpolation(void);
    4342                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/SegInput.h

    r16461 r16486  
    3939                Input* PointwiseMin(Input* inputB){_error_("not supported yet");};
    4040                Input* PointwiseMax(Input* inputB){_error_("not supported yet");};
    41                 ElementResult* SpawnResult(int step, IssmDouble time){_error_("not supported yet");};
    4241                int  GetResultInterpolation(void){_error_("not implemented");};
    4342                void   AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/TransientInput.cpp

    r16481 r16486  
    145145        return outinput;
    146146
    147 }
    148 /*}}}*/
    149 /*FUNCTION TransientInput::SpawnResult{{{*/
    150 ElementResult* TransientInput::SpawnResult(int step, IssmDouble time){
    151 
    152         ElementResult* elementresult=NULL;
    153 
    154         /*Ok, we want to spawn an ElementResult. We have the time, just get
    155          *the correct values: */
    156         Input* input=GetTimeInput(time);
    157 
    158         elementresult=input->SpawnResult(step,time);
    159 
    160    delete input;
    161 
    162         return elementresult;
    163147}
    164148/*}}}*/

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/TransientInput.h

    r16481 r16486  
    4343                Input* PointwiseMin(Input* forcingB){_error_("not implemented yet");};
    4444                Input* PointwiseMax(Input* forcingB){_error_("not implemented yet");};
    45                 ElementResult* SpawnResult(int step, IssmDouble time);
    4645                int  GetResultInterpolation(void);
    4746                void Configure(Parameters* parameters);

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

    r16461 r16486  
    117117}
    118118/*}}}*/
    119 /*FUNCTION TriaInput::SpawnResult{{{*/
    120 ElementResult* TriaInput::SpawnResult(int step, IssmDouble time){
    121 
    122         return new TriaP1ElementResult(this->enum_type,this->values,step,time);
    123 
    124 }
    125 /*}}}*/
    126119/*FUNCTION TriaInput::GetResultInterpolation{{{*/
    127120int  TriaInput::GetResultInterpolation(void){

  • TabularUnified issm/trunk-jpl/src/c/classes/Inputs/TriaInput.h

    r16461 r16486  
    3939                Input* PointwiseMin(Input* inputB);
    4040                Input* PointwiseMax(Input* inputB);
    41                 ElementResult* SpawnResult(int step, IssmDouble time);
    4241                int    GetResultInterpolation(void);
    4342                void   AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • TabularUnified issm/trunk-jpl/src/c/classes/classes.h

    r16470 r16486  
    6565#include "./Inputs/TransientInput.h"
    6666
    67 /*ElementResults: */
    68 #include "./ElementResults/ElementResult.h"
    69 #include "./ElementResults/DoubleElementResult.h"
    70 #include "./ElementResults/TriaP1ElementResult.h"
    71 #include "./ElementResults/PentaP1ElementResult.h"
    72 #include "./ElementResults/BoolElementResult.h"
    73 
    7467/*ExternalResults: */
    7568#include "./ExternalResults/Results.h"

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

    r16469 r16486  
    3636                return;
    3737        }
    38 
    39         /*We have results inside our elements, loads, etc ... Get them out of there, into the results dataset: */
    40         elements->ToResults(results,parameters);
    41         elements->DeleteResults();
    4238
    4339        /*Results do not include the type of solution being run . In parallel, we output results to a filename,

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r16470 r16486  
    376376        DoubleVecParamEnum,
    377377        ElementEnum,
    378         ElementResultEnum,
    379378        ExternalResultEnum,
    380379        FileParamEnum,
    … …  
    532531        /*Results{{{*/
    533532        SaveResultsEnum,
    534         BoolElementResultEnum,
    535533        BoolExternalResultEnum,
    536         DoubleElementResultEnum,
    537534        DoubleExternalResultEnum,
    538535        DoubleMatExternalResultEnum,
    539536        IntExternalResultEnum,
    540537        JEnum,
    541         PentaP1ElementResultEnum,
    542538        StringExternalResultEnum,
    543539        StepEnum,
    544540        TimeEnum,
    545         TriaP1ElementResultEnum,
    546541        WaterColumnOldEnum,
    547542        /*}}}*/

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r16470 r16486  
    376376                case DoubleVecParamEnum : return "DoubleVecParam";
    377377                case ElementEnum : return "Element";
    378                 case ElementResultEnum : return "ElementResult";
    379378                case ExternalResultEnum : return "ExternalResult";
    380379                case FileParamEnum : return "FileParam";
    … …  
    522521                case TaylorHoodEnum : return "TaylorHood";
    523522                case SaveResultsEnum : return "SaveResults";
    524                 case BoolElementResultEnum : return "BoolElementResult";
    525523                case BoolExternalResultEnum : return "BoolExternalResult";
    526                 case DoubleElementResultEnum : return "DoubleElementResult";
    527524                case DoubleExternalResultEnum : return "DoubleExternalResult";
    528525                case DoubleMatExternalResultEnum : return "DoubleMatExternalResult";
    529526                case IntExternalResultEnum : return "IntExternalResult";
    530527                case JEnum : return "J";
    531                 case PentaP1ElementResultEnum : return "PentaP1ElementResult";
    532528                case StringExternalResultEnum : return "StringExternalResult";
    533529                case StepEnum : return "Step";
    534530                case TimeEnum : return "Time";
    535                 case TriaP1ElementResultEnum : return "TriaP1ElementResult";
    536531                case WaterColumnOldEnum : return "WaterColumnOld";
    537532                case OutputdefinitionEnum : return "Outputdefinition";

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r16470 r16486  
    382382              else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum;
    383383              else if (strcmp(name,"Element")==0) return ElementEnum;
    384               else if (strcmp(name,"ElementResult")==0) return ElementResultEnum;
     384              else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
    389               else if (strcmp(name,"FileParam")==0) return FileParamEnum;
     388              if (strcmp(name,"FileParam")==0) return FileParamEnum;
    390389              else if (strcmp(name,"Input")==0) return InputEnum;
    391390              else if (strcmp(name,"IntInput")==0) return IntInputEnum;
    … …  
    506505              else if (strcmp(name,"QmuTemperature")==0) return QmuTemperatureEnum;
    507506              else if (strcmp(name,"HydrologyWaterVx")==0) return HydrologyWaterVxEnum;
     507              else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
    512               else if (strcmp(name,"StressTensor")==0) return StressTensorEnum;
     511              if (strcmp(name,"StressTensor")==0) return StressTensorEnum;
    513512              else if (strcmp(name,"StressTensorxx")==0) return StressTensorxxEnum;
    514513              else if (strcmp(name,"StressTensorxy")==0) return StressTensorxyEnum;
    … …  
    534533              else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum;
    535534              else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum;
    536               else if (strcmp(name,"BoolElementResult")==0) return BoolElementResultEnum;
    537535              else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    538               else if (strcmp(name,"DoubleElementResult")==0) return DoubleElementResultEnum;
    539536              else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum;
    540537              else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum;
    541538              else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum;
    542539              else if (strcmp(name,"J")==0) return JEnum;
    543               else if (strcmp(name,"PentaP1ElementResult")==0) return PentaP1ElementResultEnum;
    544540              else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum;
    545541              else if (strcmp(name,"Step")==0) return StepEnum;
    546542              else if (strcmp(name,"Time")==0) return TimeEnum;
    547               else if (strcmp(name,"TriaP1ElementResult")==0) return TriaP1ElementResultEnum;
    548543              else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum;
    549544              else if (strcmp(name,"Outputdefinition")==0) return OutputdefinitionEnum;
Note: See TracChangeset for help on using the changeset viewer.