Changeset 16474


Ignore:
Timestamp:
10/21/13 09:02:04 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: fixing test101, we cannot rely on result enum anymore, need to use string only

Location:
issm/trunk-jpl/src/c
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/ElementResults/BoolElementResult.cpp

    r16470 r16474  
    6868
    6969/*ElementResult management*/
    70 /*FUNCTION BoolElementResult::InstanceEnum{{{*/
    71 int BoolElementResult::InstanceEnum(void){
     70/*FUNCTION BoolElementResult::GetResultName{{{*/
     71char* BoolElementResult::GetResultName(void){
    7272
    73         return this->enum_type;
     73        char* output = NULL;
     74        EnumToStringx(&output,this->enum_type);
     75        return output;
    7476
    7577}

  • issm/trunk-jpl/src/c/classes/ElementResults/BoolElementResult.h

    r16470 r16474  
    3939                /*}}}*/
    4040                /*BoolElementResult management: {{{*/
    41                 int   InstanceEnum();
    42                 void GetVectorFromResults(Vector<IssmDouble>* vector,int* doflist,int* connectivitylist,int numdofs);
    43                 void GetElementVectorFromResults(Vector<IssmDouble>* vector,int dof);
     41                char* GetResultName();
     42                void  GetVectorFromResults(Vector<IssmDouble>* vector,int* doflist,int* connectivitylist,int numdofs);
     43                void  GetElementVectorFromResults(Vector<IssmDouble>* vector,int dof);
    4444                /*}}}*/
    4545};

  • issm/trunk-jpl/src/c/classes/ElementResults/DoubleElementResult.cpp

    r16470 r16474  
    6868
    6969/*ElementResult management*/
    70 /*FUNCTION DoubleElementResult::InstanceEnum{{{*/
    71 int DoubleElementResult::InstanceEnum(void){
     70/*FUNCTION DoubleElementResult::GetResultName{{{*/
     71char* DoubleElementResult::GetResultName(void){
    7272
    73         return this->enum_type;
     73        char* output = NULL;
     74        EnumToStringx(&output,this->enum_type);
     75        return output;
    7476
    7577}

  • issm/trunk-jpl/src/c/classes/ElementResults/DoubleElementResult.h

    r16470 r16474  
    3939
    4040                /*DoubleElementResult management*/
    41                 int  InstanceEnum();
     41                char* GetResultName();
    4242                void GetVectorFromResults(Vector<IssmDouble>* vector,int* doflist,int* connectivitylist,int numdofs);
    4343                void GetElementVectorFromResults(Vector<IssmDouble>* vector,int dof);

  • issm/trunk-jpl/src/c/classes/ElementResults/ElementResult.h

    r16470 r16474  
    1818                virtual int        GetStep(void) = 0;
    1919                virtual int        NumberOfNodalValues(void) = 0;
    20                 virtual int        InstanceEnum() = 0;
     20                virtual char*      GetResultName() = 0;
    2121                virtual void       GetVectorFromResults(Vector <IssmDouble> *vector,int*doflist,int*connectivitylist,int numdof)=0;
    2222                virtual void       GetElementVectorFromResults(Vector <IssmDouble> *vector,int dof)=0;

  • issm/trunk-jpl/src/c/classes/ElementResults/PentaP1ElementResult.cpp

    r16470 r16474  
    7171
    7272/*ElementResult management*/
    73 /*FUNCTION PentaP1ElementResult::InstanceEnum{{{*/
    74 int PentaP1ElementResult::InstanceEnum(void){
     73/*FUNCTION PentaP1ElementResult::GetResultName{{{*/
     74char* PentaP1ElementResult::GetResultName(void){
    7575
    76         return this->enum_type;
     76        char* output = NULL;
     77        EnumToStringx(&output,this->enum_type);
     78        return output;
    7779
    7880}

  • issm/trunk-jpl/src/c/classes/ElementResults/PentaP1ElementResult.h

    r16470 r16474  
    3838                /*}}}*/
    3939                /*PentaP1ElementResult management: {{{*/
    40                 int   InstanceEnum();
     40                char* GetResultName();
    4141                void GetVectorFromResults(Vector<IssmDouble>* vector,int* doflist,int* connectivitylist,int numdofs);
    4242                void GetElementVectorFromResults(Vector<IssmDouble>* vector,int dof);

  • issm/trunk-jpl/src/c/classes/ElementResults/TriaP1ElementResult.cpp

    r16470 r16474  
    7070
    7171/*ElementResult management*/
    72 /*FUNCTION TriaP1ElementResult::InstanceEnum{{{*/
    73 int TriaP1ElementResult::InstanceEnum(void){
     72/*FUNCTION TriaP1ElementResult::GetResultName{{{*/
     73char* TriaP1ElementResult::GetResultName(void){
    7474
    75         return this->enum_type;
     75        char* output = NULL;
     76        EnumToStringx(&output,this->enum_type);
     77        return output;
    7678
    7779}

  • issm/trunk-jpl/src/c/classes/ElementResults/TriaP1ElementResult.h

    r16470 r16474  
    3737                /*}}}*/
    3838                /*TriaP1ElementResult management: {{{*/
    39                 int   InstanceEnum();
     39                char* GetResultName();
    4040                void GetVectorFromResults(Vector<IssmDouble>* vector,int* doflist,int* connectivitylist,int numdofs);
    4141                void GetElementVectorFromResults(Vector<IssmDouble>* vector,int dof);

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

    r16470 r16474  
    16611661        /*Get result*/
    16621662        ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
    1663         if(elementresult->InstanceEnum()!=enum_in){
    1664                 _error_("Results of offset "<<offset<<" is "<<EnumToStringx(elementresult->InstanceEnum())<<" when "<<EnumToStringx(enum_in)<<" was expected");
    1665         } 
    16661663        if(interp==P1Enum){
    16671664                int vertexpidlist[NUMVERTICES];
    … …  
    28082805                for(int i=0;i<this->results->Size();i++){
    28092806                        ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2810                         resultsenums[i]=elementresult->InstanceEnum();
     2807                        resultsenums[i]=StringToEnumx(elementresult->GetResultName());
    28112808                        resultstimes[i]=elementresult->GetTime();
    28122809                        resultssteps[i]=elementresult->GetStep();

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

    r16470 r16474  
    15541554        /*Get result*/
    15551555        ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
    1556         if(elementresult->InstanceEnum()!=enum_in){
    1557                 _error_("Results of offset "<<offset<<" is "<<EnumToStringx(elementresult->InstanceEnum())<<" when "<<EnumToStringx(enum_in)<<" was expected");
    1558         }
    15591556        if(interp==P1Enum){
    15601557                int vertexpidlist[NUMVERTICES];
    … …  
    23982395                for(int i=0;i<this->results->Size();i++){
    23992396                        ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2400                         resultsenums[i]=elementresult->InstanceEnum();
     2397                        resultsenums[i]=StringToEnumx(elementresult->GetResultName());
    24012398                        resultstimes[i]=elementresult->GetTime();
    24022399                        resultssteps[i]=elementresult->GetStep();

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

    r15067 r16474  
    2525                virtual        ~ExternalResult(){};
    2626                /*Virtual functions:{{{*/
    27                 virtual int   InstanceEnum()=0;
    2827                virtual void  WriteData(FILE* fid,bool io_gather)=0;
    29                 virtual void  GetResultName(char**)=0;
     28                virtual char* GetResultName(void)=0;
    3029                virtual int   GetStep(void)=0;
    3130                /*}}}*/

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

    r16470 r16474  
    2323        private:
    2424                int        id;
    25                 int        enum_type; //in case we have an identifiable enum for this result
    26                 char*      enum_string;  //in case this result is only identifiable by a unique string, though arbitrary.
     25                char*      result_name;
    2726                ResultType value;
    2827                int        M;
    … …  
    3433                /*Diverse: must be in front, as it is used in what follows*/
    3534                void GenericEcho(void){/*{{{*/
    36                         _printf_("   id: " << this->id << "\n");
    37                         if(this->enum_type!=-1)_printf_("   enum:  " << this->enum_type << " (" << EnumToStringx(this->enum_type) << ")\n");
    38                         else _printf_("   string identified:  " << this->enum_string );
    39                         _printf_("   step: " << this->step << "\n");
    40                         _printf_("   time: " << this->time << "\n");
     35                        _printf_("   id          : " << this->id << "\n");
     36                        _printf_("   result_name : " << this->result_name<< "\n");
     37                        _printf_("   step        : " << this->step << "\n");
     38                        _printf_("   time        : " << this->time << "\n");
    4139                }
    4240                /*}}}*/
    4341                void GenericWriteData(FILE* fid){/*{{{*/
    4442
    45                         int     length;
    4643                        IssmPDouble  passiveDouble;
    47                         char*   name = NULL;
    48 
    49                         /*First write enum: */
    50                         if(this->enum_type!=-1)EnumToStringx(&name,this->enum_type);
    51                         else{
    52                                 name=xNew<char>(strlen(this->enum_string)+1); xMemCpy<char>(name,enum_string,strlen(this->enum_string)+1);
    53                         }
    54                         length=(strlen(name)+1)*sizeof(char);
     44
     45                        /*First write name: */
     46                        int length=(strlen(this->result_name)+1)*sizeof(char);
    5547                        fwrite(&length,sizeof(int),1,fid);
    56                         fwrite(name,length,1,fid);
    57                         xDelete<char>(name);
     48                        fwrite(this->result_name,length,1,fid);
    5849
    5950                        /*Now write time and step: */
    … …  
    6556                /*GenericExternalResult constructors and  destructors*/
    6657                GenericExternalResult(){ /*{{{*/
    67                         id        = 0;
    68                         enum_type = -1;
    69                         enum_string= NULL;
    70                         M         = 0;
    71                         N         = 0;
    72                         step      = 0;
    73                         time      = 0;
     58                        id          = 0;
     59                        result_name = NULL;
     60                        M           = 0;
     61                        N           = 0;
     62                        step        = 0;
     63                        time        = 0;
    7464                } /*}}}*/
    7565                GenericExternalResult(int in_id, int in_enum_type,ResultType in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
    76                         id        = 0;
    77                         enum_type = -1;
    78                         enum_string=NULL;
    79                         M         = 0;
    80                         N         = 0;
    81                         step      = 0;
    82                         time      = 0;
     66                        id          = 0;
     67                        result_name = NULL;
     68                        M           = 0;
     69                        N           = 0;
     70                        step        = 0;
     71                        time        = 0;
    8372                        _error_("template GenericExternalResult(int in_id, int in_enum_type,double* in_values, int in_M,int in_N,int in_step,IssmDouble in_time) not implemented for this ResultType\n");
    8473                }
    … …  
    8675                GenericExternalResult(int in_id, int in_enum_type,ResultType in_value,int in_step, IssmDouble in_time){ /*{{{*/
    8776                        id        = in_id;
    88                         enum_type = in_enum_type;
    89                         enum_string = NULL;
    9077                        value     = in_value;
    9178                        step      = in_step;
    9279                        time      = in_time;
     80
     81                        /*Convert enum to name*/
     82                        EnumToStringx(&this->result_name,in_enum_type);
    9383                }
    9484                /*}}}*/
    95                 GenericExternalResult(int in_id,const char* in_enum_string,ResultType in_value,int in_step, IssmDouble in_time){ /*{{{*/
     85                GenericExternalResult(int in_id,const char* in_result_name,ResultType in_value,int in_step, IssmDouble in_time){ /*{{{*/
    9686                        id        = in_id;
    97                         enum_type = -1;
    98                         enum_string = xNew<char>(strlen(in_enum_string)+1); xMemCpy<char>(enum_string,in_enum_string,strlen(in_enum_string)+1);
    9987                        value     = in_value;
    10088                        step      = in_step;
    10189                        time      = in_time;
     90
     91                        /*Copy name*/
     92                        this->result_name = xNew<char>(strlen(in_result_name)+1);
     93                        xMemCpy<char>(this->result_name,in_result_name,strlen(in_result_name)+1);
    10294                }
    10395                /*}}}*/
    10496                ~GenericExternalResult(){ /*{{{*/
    105                         if(enum_string)xDelete<char>(enum_string);
     97                        xDelete<char>(result_name);
    10698                } /*}}}*/
    10799
    … …  
    122114                } /*}}}*/
    123115                Object* copy(void) { /*{{{*/
    124                         if(enum_type!=-1) return new GenericExternalResult<ResultType>(this->id,this->enum_type,this->value,this->step,this->time);
    125                         else              return new GenericExternalResult<ResultType>(this->id,this->enum_string,this->value,this->step,this->time);
     116                        return new GenericExternalResult<ResultType>(this->id,this->result_name,this->value,this->step,this->time);
    126117                } /*}}}*/
    127118
    … …  
    154145
    155146} /*}}}*/
    156 void GetResultName(char** pname){ /*{{{*/
    157         if(this->enum_type!=-1)EnumToStringx(pname,this->enum_type);
    158         else{
    159                 char* name=xNew<char>(strlen(enum_string)+1); xMemCpy<char>(name,enum_string,strlen(enum_string)+1);
    160                 *pname=name;
    161         }
     147char* GetResultName(void){ /*{{{*/
     148                char* name = xNew<char>(strlen(this->result_name)+1);
     149                xMemCpy<char>(name,this->result_name,strlen(this->result_name)+1);
     150                return name;
    162151} /*}}}*/
    163152int GetStep(void){ /*{{{*/
    164153        return this->step;
    165154} /*}}}*/
    166 int InstanceEnum(void){ /*{{{*/
    167         return this->enum_type;
    168 } /*}}}*/
    169155};
    170156
    … …  
    208194template <> inline GenericExternalResult<char*>::GenericExternalResult(int in_id, int in_enum_type,char* in_value,int in_step, IssmDouble in_time){ /*{{{*/
    209195
    210         id=in_id;
    211         enum_type=in_enum_type;
    212         value=xNew<char>(strlen(in_value)+1);
     196        id = in_id;
     197        value = xNew<char>(strlen(in_value)+1);
    213198        xMemCpy<char>(value,in_value,(strlen(in_value)+1));
    214         step=in_step;
    215         time=in_time;
     199        step  = in_step;
     200        time  = in_time;
     201
     202        /*Convert enum to name*/
     203        EnumToStringx(&this->result_name,in_enum_type);
    216204
    217205} /*}}}*/
    218206template <> inline GenericExternalResult<char*>::~GenericExternalResult(){ /*{{{*/
     207        xDelete<char>(result_name);
    219208        xDelete<char>(value);
    220209} /*}}}*/
    … …  
    257246template <> inline GenericExternalResult<IssmPDouble*>::GenericExternalResult(int in_id, int in_enum_type,IssmPDouble* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
    258247
    259         id=in_id;
    260         enum_type=in_enum_type;
    261         M=in_M;
    262         N=in_N;
    263 
    264         step=in_step;
    265         time=in_time;
     248        id = in_id;
     249        M  = in_M;
     250        N  = in_N;
     251
     252        EnumToStringx(&this->result_name,in_enum_type);
     253
     254        step = in_step;
     255        time = in_time;
    266256
    267257        /*Copy result in values*/
    … …  
    277267} /*}}}*/
    278268template <> inline GenericExternalResult<IssmPDouble*>::~GenericExternalResult(){ /*{{{*/
     269        xDelete<char>(result_name);
    279270        xDelete<IssmPDouble>(value);
    280271} /*}}}*/
    … …  
    304295} /*}}}*/
    305296template <> inline Object* GenericExternalResult<IssmPDouble*>::copy(void){ /*{{{*/
    306         return new GenericExternalResult<IssmPDouble*>(this->id,this->enum_type,this->value,this->M,this->N,this->step,this->time);
     297        return new GenericExternalResult<IssmPDouble*>(this->id,StringToEnumx(this->result_name),this->value,this->M,this->N,this->step,this->time);
    307298} /*}}}*/
    308299template <> inline void GenericExternalResult<IssmPDouble*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
    309300
    310301        int     my_rank;
    311         int     length;
    312302        int     type;
    313303        int     rows,cols;
    … …  
    324314
    325315        /*First write enum: */
    326         EnumToStringx(&name,this->enum_type);
    327         length=(strlen(name)+1)*sizeof(char);
     316        int length=(strlen(this->result_name)+1)*sizeof(char);
    328317        fwrite(&length,sizeof(int),1,fid);
    329         fwrite(name,length,1,fid);
    330         xDelete<char>(name);
     318        fwrite(this->result_name,length,1,fid);
    331319
    332320        /*Now write time and step: */
    … …  
    356344/*}}}*/
    357345template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_value,int in_step, IssmDouble in_time){ /*{{{*/
    358         id=in_id;
    359         enum_type=in_enum_type;
    360         M=0;
    361         N=0;
    362 
    363         step=in_step;
    364         time=in_time;
     346        id = in_id;
     347        M  = 0;
     348        N  = 0;
     349
     350        /*Convert enum to name*/
     351        EnumToStringx(&this->result_name,in_enum_type);
     352
     353        step = in_step;
     354        time = in_time;
    365355
    366356        value = in_value;
    367357} /*}}}*/
    368358template <> inline GenericExternalResult<Vector<IssmPDouble>*>::~GenericExternalResult(){ /*{{{*/
     359        xDelete<char>(this->result_name);
    369360        delete value;
    370361} /*}}}*/
    … …  
    382373} /*}}}*/
    383374template <> inline Object* GenericExternalResult<Vector<IssmPDouble>*>::copy(void){ /*{{{*/
    384         return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,this->enum_type,this->value,this->step,this->time);
     375        return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,StringToEnumx(this->result_name),this->value,this->step,this->time);
    385376} /*}}}*/
    386377template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
    … …  
    398389
    399390        if(IssmComm::GetRank()==0){
    400                 /*First write enum: */
    401                 EnumToStringx(&name,this->enum_type);
    402                 length=(strlen(name)+1)*sizeof(char);
     391                /*First write name: */
     392                length=(strlen(this->result_name)+1)*sizeof(char);
    403393                fwrite(&length,sizeof(int),1,fid);
    404                 fwrite(name,length,1,fid);
    405                 xDelete<char>(name);
     394                fwrite(this->result_name,length,1,fid);
    406395
    407396                /*Now write time and step: */

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

    r16469 r16474  
    6666                ElementResult* result=dynamic_cast<ElementResult*>(*object);
    6767
    68                 if(result->InstanceEnum()==in_result->InstanceEnum()){
    69                         if(result->GetStep()==in_result->GetStep()){
     68                if(result->GetStep()==in_result->GetStep()){
     69                        if(strcmp(result->GetResultName(),in_result->GetResultName())==0){
    7070                                this->DeleteObject(result);
    7171                                break;
    … …  
    9191                ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
    9292
    93                 if(result->InstanceEnum()==in_result->InstanceEnum()){
    94                         if(result->GetStep()==in_result->GetStep()){
     93                if(result->GetStep()==in_result->GetStep()){
     94                        if(strcmp(result->GetResultName(),in_result->GetResultName())==0){
    9595                                this->DeleteObject(result);
    9696                                break;
    … …  
    109109                ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
    110110
    111                 if(result->InstanceEnum()==result_enum){
    112                         if(result->GetStep()==result_step){
     111                if(result->GetStep()==result_step){
     112                        if(strcmp(result->GetResultName(),EnumToStringx(result_enum))==0){
    113113                                this->DeleteObject(result);
    114114                                break;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp

    r16408 r16474  
    1212        int i,j;
    1313       
    14         Parameters *parameters = NULL;
    15         DataSet* output_definitions=NULL;
    16         int*     output_definition_enums;
    17         int      num_output_definitions;
    18         int      numgates;
    19         char**   gatenames=NULL;
    20         IssmDouble** gatesegments=NULL;
    21         int*         gatesegments_M=NULL;
     14        Parameters  *parameters              = NULL;
     15        DataSet     *output_definitions      = NULL;
     16        int         *output_definition_enums = NULL;
     17        int          num_output_definitions;
     18        int          numgates;
     19        char       **gatenames               = NULL;
     20        IssmDouble **gatesegments            = NULL;
     21        int         *gatesegments_M          = NULL;
    2222
    2323        /*Get parameters: */
    … …  
    4343                                /*Free ressources:*/
    4444                                for(j=0;j<numgates;j++){
    45                                         char* string=gatenames[j]; xDelete<char>(string);
    46                                         IssmDouble* gate=gatesegments[j]; xDelete<IssmDouble>(gate);
     45                                        char*       string = gatenames[j];    xDelete<char>(string);
     46                                        IssmDouble* gate   = gatesegments[j]; xDelete<IssmDouble>(gate);
    4747                                }
    4848                                xDelete<char*>(gatenames);
Note: See TracChangeset for help on using the changeset viewer.