Changeset 13797


Ignore:
Timestamp:
10/22/12 14:33:45 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: use dynamic_cast instead of C-style casting

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

Legend:

Unmodified
Added
Removed

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

    r13623 r13797  
    2020        public:
    2121
    22                 /*constructors, destructors: {{{*/
     22                /*constructors, destructors*/
    2323                Constraints();
    2424                ~Constraints();
    25                 /*}}}*/
    26                 /*numerics: {{{*/
     25
     26                /*numerics*/
    2727                int   NumberOfConstraints(void);
    28                 /*}}}*/
    2928
    3029};

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

    r13623 r13797  
    3838                int*            id_offsets;
    3939
    40                 /*constructors, destructors: {{{*/
     40                /*constructors, destructors*/
    4141                DataSet();
    4242                DataSet(int enum_type);
    4343                ~DataSet();
    44                 /*}}}*/
    45                 /*management: {{{*/
    46                 int   GetEnum();
    47                 int   GetEnum(int offset);
    48                 void  Echo();
    49                 void  DeepEcho();
    50                 int   AddObject(Object* object);
    51                 int   DeleteObject(int id);
    52                 int   Size();
    53                 void  clear();
    54                 Object* GetObjectByOffset(int offset);
    55                 Object* GetObjectById(int* poffset,int eid);
    56                 void  Presort();
    57                 void  SetSorting(int* in_sorted_ids,int* in_id_offsets);
    58                 void  Sort();
    59                 DataSet* Copy(void);
    60                 int   DeleteObject(Object* object);
    61                 Results* SpawnTriaResults(int* indices);
    62                 /*}}}*/
     44
     45                /*management*/
     46                int      GetEnum();
     47                int      GetEnum(int offset);
     48                void     Echo();
     49                void     DeepEcho();
     50                int      AddObject(Object *object);
     51                int      DeleteObject(int id);
     52                int      Size();
     53                void     clear();
     54                Object  *GetObjectByOffset(int  offset);
     55                Object  *GetObjectById(int *poffset,int eid);
     56                void     Presort();
     57                void     SetSorting(int *in_sorted_ids,int*in_id_offsets);
     58                void     Sort();
     59                DataSet *Copy(void);
     60                int      DeleteObject(Object *object);
     61                Results *SpawnTriaResults(int *indices);
    6362
    6463};

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

    r12419 r13797  
    2020        public:
    2121
    22                 /*constructors, destructors: {{{*/
     22                /*constructors, destructors*/
    2323                Elements();
    2424                ~Elements();
    25                 /*}}}*/
    26                 /*numerics: {{{*/
    27                 void Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    28                 void DeleteResults(void);
    29                 void ProcessResultsUnits(void);
    30                 void SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    31                 void ToResults(Results* results,Parameters* parameters);
     25
     26                /*numerics*/
     27                void   Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
     28                void   DeleteResults(void);
     29                void   ProcessResultsUnits(void);
     30                void   SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
     31                void   ToResults(Results* results,Parameters* parameters);
    3232                Patch* ResultsToPatch(void);
    33                 int   NumberOfElements(void);
    34                 void InputDuplicate(int input_enum,int output_enum);
    35                 /*}}}*/
     33                int    NumberOfElements(void);
     34                void   InputDuplicate(int input_enum,int output_enum);
    3635
    3736};

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

    r13622 r13797  
    4747        for ( object=objects.begin() ; object < objects.end(); object++ ){
    4848
    49                 input=(Input*)(*object);
     49                input=dynamic_cast<Input*>(*object);
    5050                if (input->InstanceEnum()==enum_type){
    5151                        found=true;
    … …  
    7575        for ( object=objects.begin() ; object < objects.end(); object++ ){
    7676
    77                 input=(Input*)(*object);
     77                input=dynamic_cast<Input*>(*object);
    7878                if (input->InstanceEnum()==enum_type){
    7979                        found=true;
    … …  
    103103        for ( object=objects.begin() ; object < objects.end(); object++ ){
    104104
    105                 input=(Input*)(*object);
     105                input=dynamic_cast<Input*>(*object);
    106106                if (input->InstanceEnum()==enum_type){
    107107                        found=true;
    … …  
    131131        for ( object=objects.begin() ; object < objects.end(); object++ ){
    132132
    133                 input=(Input*)(*object);
     133                input=dynamic_cast<Input*>(*object);
    134134                if (input->InstanceEnum()==enum_type){
    135135                        found=true;
    … …  
    163163        for ( object=objects.begin() ; object < objects.end(); object++ ){
    164164
    165                 input=(Input*)(*object);
     165                input=dynamic_cast<Input*>(*object);
    166166
    167167                if (input->InstanceEnum()==in_input->InstanceEnum()){
    … …  
    185185        /*Delete existing input of newenumtype if it exists*/
    186186        for ( object=objects.begin() ; object < objects.end(); object++ ){
    187                 input=(Input*)(*object);
     187                input=dynamic_cast<Input*>(*object);
    188188
    189189                if (input->InstanceEnum()==newenumtype){
    … …  
    196196        for ( object=objects.begin() ; object < objects.end(); object++ ){
    197197
    198                 input=(Input*)(*object);
     198                input=dynamic_cast<Input*>(*object);
    199199
    200200                if (input->InstanceEnum()==oldenumtype){
    … …  
    210210        Input* constrain_input=NULL;
    211211        /*Find x and y inputs: */
    212         constrain_input=(Input*)this->GetInput(constrain_enum);
     212        constrain_input=dynamic_cast<Input*>(this->GetInput(constrain_enum));
    213213
    214214        /*some checks: */
    … …  
    226226
    227227        /*Get input*/
    228         Input* input=(Input*)this->GetInput(enumtype);
     228        Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
    229229
    230230        /*Apply ContrainMin: */
    … …  
    247247
    248248        /*Get input*/
    249         Input* input=(Input*)this->GetInput(enumtype);
     249        Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
    250250
    251251        /*Apply ContrainMin: */
    … …  
    268268
    269269        /*Get input*/
    270         Input* input=(Input*)this->GetInput(enumtype);
     270        Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
    271271
    272272        /*Apply ContrainMin: */
    … …  
    289289
    290290        /*Get input*/
    291         Input* input=(Input*)this->GetInput(enumtype);
     291        Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
    292292
    293293        /*Apply ContrainMin: */
    … …  
    310310
    311311        /*Get input*/
    312         Input* input=(Input*)this->GetInput(enumtype);
     312        Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
    313313
    314314        /*Apply ContrainMin: */
    … …  
    332332        for ( object=objects.begin() ; object < objects.end(); object++ ){
    333333
    334                 input=(Input*)(*object);
     334                input=dynamic_cast<Input*>(*object);
    335335
    336336                if (input->InstanceEnum()==enum_name){
    … …  
    349349        for ( object=objects.begin() ; object < objects.end(); object++ ){
    350350
    351                 input=(Input*)(*object);
     351                input=dynamic_cast<Input*>(*object);
    352352
    353353                if (input->InstanceEnum()==enum_type){
    … …  
    368368
    369369        /*Make a copy of the original input: */
    370         original=(Input*)this->GetInput(original_enum);
     370        original=dynamic_cast<Input*>(this->GetInput(original_enum));
    371371        if(!original)_error_("could not find input with enum: " << EnumToStringx(original_enum));
    372         copy=(Input*)original->copy();
     372        copy=dynamic_cast<Input*>(original->copy());
    373373
    374374        /*Change copy enum to reinitialized_enum: */
    … …  
    376376
    377377        /*Add copy into inputs, it will wipe off the one already there: */
    378         this->AddInput((Input*)copy);
     378        this->AddInput(dynamic_cast<Input*>(copy));
    379379}
    380380/*}}}*/
    … …  
    394394
    395395                /*Create new input*/
    396                 inputin=(Input*)(*object);
     396                inputin=dynamic_cast<Input*>(*object);
    397397                inputout=inputin->SpawnTriaInput(indices);
    398398
    … …  
    412412
    413413        /*Find x and y inputs: */
    414         xinput=(Input*)this->GetInput(MeshXEnum);
    415         yinput=(Input*)this->GetInput(MeshYEnum);
     414        xinput=dynamic_cast<Input*>(this->GetInput(MeshXEnum));
     415        yinput=dynamic_cast<Input*>(this->GetInput(MeshYEnum));
    416416
    417417        /*some checks: */
    … …  
    431431        for ( object=objects.begin() ; object < objects.end(); object++ ){
    432432
    433                 input=(Input*)(*object);
     433                input=dynamic_cast<Input*>(*object);
    434434                input->Configure(parameters);
    435435

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

    r13623 r13797  
    2323        public:
    2424
    25                 /*constructors, destructors: {{{*/
     25                /*constructors, destructors*/
    2626                Inputs();
    2727                ~Inputs();
    2828
    29                 /*}}}*/
    30                 /*numerics: {{{*/
    31                 int     AddInput(Input* in_input);
    32                 void    ChangeEnum(int enumtype,int new_enumtype);
    33                 void    ConstrainMin(int constrain_enum, IssmDouble minimum);
    34                 int     DeleteInput(int enum_type);
    35                 void    DuplicateInput(int original_enum,int new_enum);
    36                 Input*  GetInput(int enum_name);
    37                 Inputs* SpawnTriaInputs(int* indices);
    38                 void    AXPY(int MeshYEnum, IssmDouble scalar, int MeshXEnum);
     29                /*numerics*/
     30                int        AddInput(Input* in_input);
     31                void       ChangeEnum(int enumtype,int new_enumtype);
     32                void       ConstrainMin(int constrain_enum, IssmDouble minimum);
     33                int        DeleteInput(int enum_type);
     34                void       DuplicateInput(int original_enum,int new_enum);
     35                Input*     GetInput(int enum_name);
     36                Inputs*    SpawnTriaInputs(int* indices);
     37                void       AXPY(int MeshYEnum, IssmDouble scalar, int MeshXEnum);
    3938                IssmDouble  InfinityNorm(int enumtype);
    4039                IssmDouble  Max(int enumtype);
    … …  
    4241                IssmDouble  Min(int enumtype);
    4342                IssmDouble  MinAbs(int enumtype);
    44 
    4543                void GetInputAverage(IssmDouble* pvalue, int enum_type);
    4644                void GetInputValue(bool* pvalue,int enum_type);
    4745                void GetInputValue(int* pvalue,int enum_type);
    4846                void GetInputValue(IssmDouble* pvalue,int enum_type);
    49 
    5047                void Configure(Parameters* parameters);
    51                 /*}}}*/
    5248
    5349};

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

    r13780 r13797  
    4646        for ( object=objects.begin() ; object < objects.end(); object++ ){
    4747
    48                 load=(Load*)(*object);
     48                load=dynamic_cast<Load*>(*object);
    4949                load->Configure(elements,loads,nodes,vertices,materials,parameters);
    5050
    … …  
    8181        for ( object=objects.begin() ; object < objects.end(); object++ ){
    8282
    83                 load=(Load*)(*object);
     83                load=dynamic_cast<Load*>(*object);
    8484                load->SetCurrentConfiguration(elements,loads,nodes,vertices,materials,parameters);
    8585

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

    r12365 r13797  
    2020        public:
    2121
    22                 /*constructors, destructors: {{{*/
     22                /*constructors, destructors*/
    2323                Loads();
    2424                ~Loads();
    25                 /*}}}*/
    26                 /*numerics: {{{*/
     25
     26                /*numerics*/
    2727                void  Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    2828                int   NumberOfLoads(void);
    2929                void  SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    30                 /*}}}*/
    3130
    3231};

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

    r12365 r13797  
    4646        for ( object=objects.begin() ; object < objects.end(); object++ ){
    4747
    48                 material=(Material*)(*object);
     48                material=dynamic_cast<Material*>(*object);
    4949                material->Configure(elements);
    5050

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

    r12365 r13797  
    1919        public:
    2020
    21                 /*constructors, destructors: {{{*/
     21                /*constructors, destructors*/
    2222                Materials();
    2323                ~Materials();
    24                 /*}}}*/
    25                 /*numerics: {{{*/
     24
     25                /*numerics*/
    2626                void  Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    27                 /*}}}*/
    2827
    2928};

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

    r12365 r13797  
    1313        public:
    1414
    15                 /*constructors, destructors: {{{*/
     15                /*constructors, destructors*/
    1616                Nodes();
    1717                ~Nodes();
    18                 /*}}}*/
    19                 /*numerics: {{{*/
     18
     19                /*numerics*/
    2020                void  Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    2121                void  DistributeDofs(int analysis_type,int SETENUM);
    … …  
    2727                void  Ranks(int* ranks,int analysis_type);
    2828                void  SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    29                 /*}}}*/
    3029
    3130};

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

    r13780 r13797  
    8888                this->quadtree->ClosestObs(&index,x[i],y[i]);
    8989                if(index>=0){
    90                         observation=(Observation*)this->GetObjectByOffset(index);
     90                        observation=dynamic_cast<Observation*>(this->GetObjectByOffset(index));
    9191                        if(pow(observation->x-x[i],2)+pow(observation->y-y[i],2) < minspacing) continue;
    9292                }
    … …  
    135135        this->quadtree->RangeSearch(&indices,&nobs,x_interp,y_interp,radius);
    136136        for (i=0;i<nobs;i++){
    137                 observation=(Observation*)this->GetObjectByOffset(indices[i]);
     137                observation=dynamic_cast<Observation*>(this->GetObjectByOffset(indices[i]));
    138138                h2 = (observation->x-x_interp)*(observation->x-x_interp) + (observation->y-y_interp)*(observation->y-y_interp);
    139139
    … …  
    157157        }
    158158        else{
    159                 observation=(Observation*)this->GetObjectByOffset(indices[index]);
     159                observation=dynamic_cast<Observation*>(this->GetObjectByOffset(indices[index]));
    160160                *px=observation->x;
    161161                *py=observation->y;
    … …  
    194194        nobs = 0;
    195195        for (i=0;i<tempnobs;i++){
    196                 observation=(Observation*)this->GetObjectByOffset(tempindices[i]);
     196                observation=dynamic_cast<Observation*>(this->GetObjectByOffset(tempindices[i]));
    197197                h2 = (observation->x-x_interp)*(observation->x-x_interp) + (observation->y-y_interp)*(observation->y-y_interp);
    198198
    … …  
    236236                /*Loop over all observations and fill in x, y and obs*/
    237237                for (i=0;i<nobs;i++){
    238                         observation=(Observation*)this->GetObjectByOffset(indices[i]);
     238                        observation=dynamic_cast<Observation*>(this->GetObjectByOffset(indices[i]));
    239239                        observation->WriteXYObs(&x[i],&y[i],&obs[i]);
    240240                }
    … …  
    265265                obs = xNew<IssmPDouble>(nobs);
    266266                for(int i=0;i<this->Size();i++){
    267                         observation=(Observation*)this->GetObjectByOffset(i);
     267                        observation=dynamic_cast<Observation*>(this->GetObjectByOffset(i));
    268268                        observation->WriteXYObs(&x[i],&y[i],&obs[i]);
    269269                }
    … …  
    450450
    451451        for(i=0;i<this->Size();i++){
    452                 observation1=(Observation*)this->GetObjectByOffset(i);
     452                observation1=dynamic_cast<Observation*>(this->GetObjectByOffset(i));
    453453
    454454                for(j=i+1;j<this->Size();j++){
    455                         observation2=(Observation*)this->GetObjectByOffset(j);
     455                        observation2=dynamic_cast<Observation*>(this->GetObjectByOffset(j));
    456456
    457457                        distance=sqrt(pow(observation1->x - observation2->x,2.) + pow(observation1->y - observation2->y,2.));

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

    r13622 r13797  
    6060        for(object=objects.begin();object<objects.end();object++){
    6161
    62                 option=(Option*)(*object);
     62                option=dynamic_cast<Option*>(*object);
    6363                if (!strcmp(option->Name(),name)){
    6464                        _error_("Options \"" << name << "\" found multiple times");
    … …  
    8282        for ( object=objects.begin() ; object < objects.end(); object++ ){
    8383
    84                 option=(Option*)(*object);
     84                option=dynamic_cast<Option*>(*object);
    8585                if (!strncmp(name,option->Name(),strlen(option->Name()))){
    8686

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

    r13790 r13797  
    2626
    2727                        /*Get option*/
    28                         GenericOption<OptionType>* genericoption=(GenericOption<OptionType>*)GetOption(name);
     28                        GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
    2929
    3030                        /*If the pointer is not NULL, the option has been found*/
    … …  
    4141
    4242                        /*Get option*/
    43                         GenericOption<OptionType>* genericoption=(GenericOption<OptionType>*)GetOption(name);
     43                        GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
    4444
    4545                        /*If the pointer is not NULL, the option has been found*/
    … …  
    5757
    5858                        /*Get option*/
    59                         GenericOption<OptionType>* genericoption=(GenericOption<OptionType>*)GetOption(name);
     59                        GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
    6060
    6161                        /*If the pointer is not NULL, the option has been found*/
    … …  
    7171
    7272                        /*Get option*/
    73                         GenericOption<OptionType>* genericoption=(GenericOption<OptionType>*)GetOption(name);
     73                        GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
    7474
    7575                        /*If the pointer is not NULL, the option has been found*/
    … …  
    9191
    9292        /*Get option*/
    93         GenericOption<char*>* genericoption=(GenericOption<char*>*)GetOption(name);
     93        GenericOption<char*>* genericoption=dynamic_cast<GenericOption<char*>*>(GetOption(name));
    9494
    9595        /*If the pointer is not NULL, the option has been found*/

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

    r13622 r13797  
    4545
    4646        for ( object=objects.begin() ; object < objects.end(); object++ ){
    47                 param=(Param*)(*object);
     47                param=dynamic_cast<Param*>(*object);
    4848                if(param->InstanceEnum()==enum_type) return true;
    4949        }
    … …  
    5959        for ( object=objects.begin() ; object < objects.end(); object++ ){
    6060
    61                 param=(Param*)(*object);
     61                param=dynamic_cast<Param*>(*object);
    6262                if(param->InstanceEnum()==enum_type){
    6363                        param->GetParameterValue(pbool);
    … …  
    7676        for ( object=objects.begin() ; object < objects.end(); object++ ){
    7777
    78                 param=(Param*)(*object);
     78                param=dynamic_cast<Param*>(*object);
    7979                if(param->InstanceEnum()==enum_type){
    8080                        param->GetParameterValue(pinteger);
    … …  
    9393        for ( object=objects.begin() ; object < objects.end(); object++ ){
    9494
    95                 param=(Param*)(*object);
     95                param=dynamic_cast<Param*>(*object);
    9696                if(param->InstanceEnum()==enum_type){
    9797                        param->GetParameterValue(pscalar);
    … …  
    110110        for ( object=objects.begin() ; object < objects.end(); object++ ){
    111111
    112                 param=(Param*)(*object);
     112                param=dynamic_cast<Param*>(*object);
    113113                if(param->InstanceEnum()==enum_type){
    114114                        param->GetParameterValue(pscalar,time);
    … …  
    127127        for ( object=objects.begin() ; object < objects.end(); object++ ){
    128128
    129                 param=(Param*)(*object);
     129                param=dynamic_cast<Param*>(*object);
    130130                if(param->InstanceEnum()==enum_type){
    131131                        param->GetParameterValue(pstring);
    … …  
    145145        for ( object=objects.begin() ; object < objects.end(); object++ ){
    146146
    147                 param=(Param*)(*object);
     147                param=dynamic_cast<Param*>(*object);
    148148                if(param->InstanceEnum()==enum_type){
    149149                        param->GetParameterValue(pstringarray,pM);
    … …  
    163163        for ( object=objects.begin() ; object < objects.end(); object++ ){
    164164
    165                 param=(Param*)(*object);
     165                param=dynamic_cast<Param*>(*object);
    166166                if(param->InstanceEnum()==enum_type){
    167167                        param->GetParameterValue(pintarray,pM);
    … …  
    181181        for ( object=objects.begin() ; object < objects.end(); object++ ){
    182182
    183                 param=(Param*)(*object);
     183                param=dynamic_cast<Param*>(*object);
    184184                if(param->InstanceEnum()==enum_type){
    185185                        param->GetParameterValue(pintarray,pM,pN);
    … …  
    199199        for ( object=objects.begin() ; object < objects.end(); object++ ){
    200200
    201                 param=(Param*)(*object);
     201                param=dynamic_cast<Param*>(*object);
    202202                if(param->InstanceEnum()==enum_type){
    203203                        param->GetParameterValue(pIssmDoublearray,pM);
    … …  
    217217        for ( object=objects.begin() ; object < objects.end(); object++ ){
    218218
    219                 param=(Param*)(*object);
     219                param=dynamic_cast<Param*>(*object);
    220220                if(param->InstanceEnum()==enum_type){
    221221                        param->GetParameterValue(pIssmDoublearray,pM,pN);
    … …  
    235235        for ( object=objects.begin() ; object < objects.end(); object++ ){
    236236
    237                 param=(Param*)(*object);
     237                param=dynamic_cast<Param*>(*object);
    238238                if(param->InstanceEnum()==enum_type){
    239239                        param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
    … …  
    252252        for ( object=objects.begin() ; object < objects.end(); object++ ){
    253253
    254                 param=(Param*)(*object);
     254                param=dynamic_cast<Param*>(*object);
    255255                if(param->InstanceEnum()==enum_type){
    256256                        param->GetParameterValue(pvec);
    … …  
    270270        for ( object=objects.begin() ; object < objects.end(); object++ ){
    271271
    272                 param=(Param*)(*object);
     272                param=dynamic_cast<Param*>(*object);
    273273                if(param->InstanceEnum()==enum_type){
    274274                        param->GetParameterValue(pmat);
    … …  
    288288        for ( object=objects.begin() ; object < objects.end(); object++ ){
    289289
    290                 param=(Param*)(*object);
     290                param=dynamic_cast<Param*>(*object);
    291291                if(param->InstanceEnum()==enum_type){
    292292                        param->GetParameterValue(pfid);
    … …  
    306306        for ( object=objects.begin() ; object < objects.end(); object++ ){
    307307
    308                 param=(Param*)(*object);
     308                param=dynamic_cast<Param*>(*object);
    309309                if(param->InstanceEnum()==enum_type){
    310310                        param->GetParameterValue(pdataset);
    … …  
    322322
    323323        /*first, figure out if the param has already been created: */
    324         param=(Param*)this->FindParamObject(enum_type);
     324        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    325325
    326326        if(param) param->SetValue(boolean); //already exists, just set it.
    … …  
    334334
    335335        /*first, figure out if the param has already been created: */
    336         param=(Param*)this->FindParamObject(enum_type);
     336        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    337337
    338338        if(param) param->SetValue(integer); //already exists, just set it.
    … …  
    346346
    347347        /*first, figure out if the param has already been created: */
    348         param=(Param*)this->FindParamObject(enum_type);
     348        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    349349
    350350        if(param) param->SetValue(scalar); //already exists, just set it.
    … …  
    358358
    359359        /*first, figure out if the param has already been created: */
    360         param=(Param*)this->FindParamObject(enum_type);
     360        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    361361
    362362        if(param) param->SetValue(string); //already exists, just set it.
    … …  
    370370
    371371        /*first, figure out if the param has already been created: */
    372         param=(Param*)this->FindParamObject(enum_type);
     372        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    373373
    374374        if(param) param->SetValue(stringarray,M); //already exists, just set it.
    … …  
    382382
    383383        /*first, figure out if the param has already been created: */
    384         param=(Param*)this->FindParamObject(enum_type);
     384        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    385385
    386386        if(param) param->SetValue(IssmDoublearray,M); //already exists, just set it.
    … …  
    394394
    395395        /*first, figure out if the param has already been created: */
    396         param=(Param*)this->FindParamObject(enum_type);
     396        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    397397
    398398        if(param) param->SetValue(IssmDoublearray,M,N); //already exists, just set it.
    … …  
    406406
    407407        /*first, figure out if the param has already been created: */
    408         param=(Param*)this->FindParamObject(enum_type);
     408        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    409409
    410410        if(param) param->SetValue(intarray,M); //already exists, just set it.
    … …  
    418418
    419419        /*first, figure out if the param has already been created: */
    420         param=(Param*)this->FindParamObject(enum_type);
     420        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    421421
    422422        if(param) param->SetValue(intarray,M,N); //already exists, just set it.
    … …  
    430430
    431431        /*first, figure out if the param has already been created: */
    432         param=(Param*)this->FindParamObject(enum_type);
     432        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    433433
    434434        if(param) param->SetValue(vector); //already exists, just set it.
    … …  
    442442
    443443        /*first, figure out if the param has already been created: */
    444         param=(Param*)this->FindParamObject(enum_type);
     444        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    445445
    446446        if(param) param->SetValue(matrix); //already exists, just set it.
    … …  
    454454
    455455        /*first, figure out if the param has already been created: */
    456         param=(Param*)this->FindParamObject(enum_type);
     456        param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
    457457
    458458        if(param) param->SetValue(fid); //already exists, just set it.
    … …  
    467467
    468468        for ( object=objects.begin() ; object < objects.end(); object++ ){
    469                 param=(Param*)(*object);
     469                param=dynamic_cast<Param*>(*object);
    470470                param->UnitConversion(direction_enum);
    471471        }
    … …  
    482482        for ( object=objects.begin() ; object < objects.end(); object++ ){
    483483
    484                 param=(Param*)(*object);
     484                param=dynamic_cast<Param*>(*object);
    485485                if(param->InstanceEnum()==enum_type){
    486486                        return (*object);

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

    r13622 r13797  
    7676
    7777        for(i=0;i<this->Size();i++){
    78                 ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
     78                ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
    7979
    8080                /*write result to disk: */

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

    r13623 r13797  
    2020        public:
    2121
    22                 /*constructors, destructors: {{{*/
     22                /*constructors, destructors*/
    2323                Results();
    2424                ~Results();
    25                 /*}}}*/
    26                 /*numerics: {{{*/
     25
     26                /*numerics*/
    2727                Results* SpawnTriaResults(int* indices);
    28                 void Write(Parameters* parameters);
    29                 /*}}}*/
     28                void     Write(Parameters* parameters);
    3029};
    3130#endif //ifndef _RESULTS_H_

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

    r13622 r13797  
    5656        /*Go through objects, and distribute pids locally, from 0 to numberofpidsperobject*/
    5757        for (i=0;i<this->Size();i++){
    58                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     58                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    5959                vertex->DistributePids(&pidcount);
    6060        }
    … …  
    8080        }
    8181        for (i=0;i<this->Size();i++){
    82                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     82                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    8383                vertex->OffsetPids(pidcount);
    8484        }
    … …  
    9090        alltruepids=xNewZeroInit<int>(numberofobjects);
    9191        for (i=0;i<this->Size();i++){
    92                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     92                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    9393                vertex->ShowTruePids(truepids);
    9494        }
    … …  
    101101        /* Now every cpu knows the true pids of everyone else that is not a clone*/
    102102        for(i=0;i<this->Size();i++){
    103                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     103                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    104104                vertex->UpdateClonePids(alltruepids);
    105105        }
    … …  
    145145        for(i=0;i<this->Size();i++){
    146146                /*For this object, decide whether it is a clone: */
    147                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     147                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    148148                vertex->SetClone(minranks);
    149149        }
    … …  
    163163
    164164        for(i=0;i<this->Size();i++){
    165                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     165                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    166166                sid=vertex->Sid();
    167167                if (sid>max_sid)max_sid=sid;
    … …  
    193193        for(int i=0;i<this->Size();i++){
    194194                /*Plug rank into ranks, according to id: */
    195                 Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
     195                Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
    196196                sid=vertex->Sid();
    197197                ranks[sid]=my_rank;

  • issm/trunk-jpl/src/c/solutions/EnvironmentFinalize.cpp

    r13736 r13797  
    1313void EnvironmentFinalize(void){
    1414
    15         int my_rank=0;
    1615        #ifdef _HAVE_MPI_
    17         /*Make sure we are all here!)*/
     16
     17        /*Make sure we are all here*/
    1818        MPI_Barrier(MPI_COMM_WORLD);
    1919       
    20         /*Print closing statement: */
    21         #ifdef _HAVE_MPI_
     20        /*Print closing statement*/
     21        int my_rank;
    2222        MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
    23         #endif
    2423        if(!my_rank) printf("closing MPI\n");
    2524
    2625        /*Finalize: */
    2726        MPI_Finalize();
     27
    2828        #endif
    2929}
Note: See TracChangeset for help on using the changeset viewer.