Changeset 18521


Ignore:
Timestamp:
09/15/14 16:17:28 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removed ALL dynamic casts, now change the template shared/Numerics/recast.h to change back to dynamic_casts

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

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp

    r18517 r18521  
    880880                /*Drain excess water fraction in ice column: */
    881881                for(i=0;i<femmodel->elements->Size();i++){
    882                         Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     882                        Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    883883                        DrainWaterfractionIcecolumn(element);
    884884                }
    … …  
    888888                /*Compute basal melting rates: */
    889889                for(i=0;i<femmodel->elements->Size();i++){
    890                         Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     890                        Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    891891                        ComputeBasalMeltingrate(element);
    892892                }
    … …  
    898898                if(solution_type==TransientSolutionEnum){
    899899                        for(i=0;i<femmodel->elements->Size();i++){
    900                                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     900                                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    901901                                UpdateBasalConstraints(element);
    902902                        }

  • issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp

    r18057 r18521  
    350350
    351351        for(int i=0;i<femmodel->elements->Size();i++){
    352                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     352                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    353353                this->SetConstraintsOnIce(element);
    354354        }

  • issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp

    r18074 r18521  
    377377        for(int i=0;i<femmodel->elements->Size();i++){
    378378
    379                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     379                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    380380                if(!element->IsOnBase()) continue;
    381381

  • issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp

    r18183 r18521  
    692692
    693693        for(int i=0;i<femmodel->elements->Size();i++){
    694                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     694                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    695695
    696696                int numvertices = element->GetNumberOfVertices();

  • issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp

    r18057 r18521  
    399399        /* set NaN on elements intersected by zero levelset */
    400400        for(i=0;i<femmodel->elements->Size();i++){
    401                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     401                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    402402                if(element->IsZeroLevelset(MaskIceLevelsetEnum))
    403403                        for(k=0;k<element->GetNumberOfVertices();k++)
    … …  
    407407        /* set distance on elements intersected by zero levelset */
    408408        for(i=0;i<femmodel->elements->Size();i++){
    409                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     409                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    410410                if(element->IsZeroLevelset(MaskIceLevelsetEnum)){
    411411                        SetDistanceToZeroLevelsetElement(vec_dist_zerolevelset, element);

  • issm/trunk-jpl/src/c/analyses/LsfReinitializationAnalysis.cpp

    r18057 r18521  
    369369        /* deactivate all spcs */
    370370        for(i=0;i<femmodel->elements->Size();i++){
    371                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     371                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    372372                for(k=0;k<element->GetNumberOfNodes();k++){
    373373                        node=element->GetNode(k);
    … …  
    382382        /* reactivate spcs on elements intersected by zero levelset */
    383383        for(i=0;i<femmodel->elements->Size();i++){
    384                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     384                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    385385                if(element->IsZeroLevelset(MaskIceLevelsetEnum)){
    386386                        /*iterate over nodes and set spc */
    … …  
    414414        /* set distance on elements intersected by zero levelset */
    415415        for(i=0;i<femmodel->elements->Size();i++){
    416                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     416                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    417417                if(element->IsZeroLevelset(MaskIceLevelsetEnum)){
    418418                        SetDistanceToZeroLevelsetElement(vec_dist_zerolevelset, element);

  • issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp

    r18389 r18521  
    796796        /*Create and assemble matrix*/
    797797        for(int i=0;i<femmodel->elements->Size();i++){
    798                 Element*       element = dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     798                Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    799799                ElementMatrix* MLe     = this->CreateMassMatrix(element);
    800800                if(MLe){
    … …  
    817817        /*Create and assemble matrix*/
    818818        for(int i=0;i<femmodel->elements->Size();i++){
    819                 Element*       element = dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     819                Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    820820                ElementMatrix* MLe     = this->CreateMassMatrix(element);
    821821                if(MLe){
    … …  
    880880        /*Create and assemble matrix*/
    881881        for(int i=0;i<femmodel->elements->Size();i++){
    882                 Element*       element = dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     882                Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    883883                ElementMatrix* Ke     = this->CreateFctKMatrix(element);
    884884                if(Ke) Ke->AddToGlobal(Kff,Kfs);

  • issm/trunk-jpl/src/c/analyses/SeaiceAnalysis.cpp

    r18520 r18521  
    372372        mask=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes(SeaiceAnalysisEnum));
    373373        for (int i=0;i<femmodel->elements->Size();i++){
    374                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     374                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    375375
    376376                /*Get current concentration of element and decide whether it is an active element*/
    … …  
    390390        int counter =0;
    391391        for(int i=0;i<femmodel->nodes->Size();i++){
    392                 Node* node=dynamic_cast<Node*>(femmodel->nodes->GetObjectByOffset(i));
     392                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    393393                if(node->InAnalysis(SeaiceAnalysisEnum)){
    394394                        if(serial_mask[node->Sid()]==1.){
    … …  
    552552        /*Loop over the elements of this partition and update accordingly*/
    553553        for(int i=0;i<femmodel->elements->Size();i++){
    554                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     554                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    555555
    556556                /*Get Mohr-Coulomb parameters*/
    … …  
    644644        /*Loop over the elements of this partition and update accordingly*/
    645645        for(int i=0;i<femmodel->elements->Size();i++){
    646                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     646                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    647647
    648648                /*Get some inputs needed for the update*/

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

    r18474 r18521  
    50325032
    50335033        for(int i=0;i<elements->Size();i++){
    5034                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     5034                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    50355035
    50365036                /*Get inputs and parameters*/
    … …  
    52065206
    52075207        for(int i=0;i<elements->Size();i++){
    5208                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     5208                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    52095209
    52105210                /*Get inputs and parameters*/
    … …  
    54195419
    54205420        for(int i=0;i<elements->Size();i++){
    5421                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     5421                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    54225422
    54235423                /*Get inputs and parameters*/
    … …  
    67886788        /*Cast gauss to GaussPenta*/
    67896789        _assert_(gauss_in->Enum()==GaussPentaEnum);
    6790         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     6790        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    67916791
    67926792        /*Get basis in actual coordinate system: */
    … …  
    68376837        /*Cast gauss to GaussPenta*/
    68386838        _assert_(gauss_in->Enum()==GaussPentaEnum);
    6839         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     6839        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    68406840
    68416841        /*Get basis in actual coordinate system: */
    … …  
    69366936        /*Cast gauss to GaussPenta*/
    69376937        _assert_(gauss_in->Enum()==GaussPentaEnum);
    6938         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     6938        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    69396939
    69406940        /*Get basis in actual coordinate system: */
    … …  
    69746974        /*Cast gauss to GaussPenta*/
    69756975        _assert_(gauss_in->Enum()==GaussPentaEnum);
    6976         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     6976        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    69776977
    69786978        /*Get basis in actual coordinate system: */

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

    r18237 r18521  
    4141        for ( object=objects.begin() ; object < objects.end(); object++ ){
    4242
    43                 element=dynamic_cast<Element*>((*object));
     43                element=xDynamicCast<Element*>((*object));
    4444                element->Configure(elements,loads,nodes,vertices,materials,parameters);
    4545
    … …  
    5555        for ( object=objects.begin() ; object < objects.end(); object++ ){
    5656
    57                 element=dynamic_cast<Element*>((*object));
     57                element=xDynamicCast<Element*>((*object));
    5858                element->SetCurrentConfiguration(elements,loads,nodes,materials,parameters);
    5959
    … …  
    6969        for ( object=objects.begin() ; object < objects.end(); object++ ){
    7070
    71                 element=dynamic_cast<Element*>((*object));
     71                element=xDynamicCast<Element*>((*object));
    7272                element->ResetHooks();
    7373
    … …  
    8585        for(int i=0;i<this->Size();i++){
    8686
    87                 Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(i));
     87                Element* element=xDynamicCast<Element*>(this->GetObjectByOffset(i));
    8888                numnodes=element->GetNumberOfNodes();
    8989                if(numnodes>max)max=numnodes;
    … …  
    111111
    112112        for(int i=0;i<this->Size();i++){
    113                 Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(i));
     113                Element* element=xDynamicCast<Element*>(this->GetObjectByOffset(i));
    114114                element->InputDuplicate(input_enum,output_enum);
    115115        }

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

    r18474 r18521  
    19701970        tria->parameters=this->parameters;
    19711971        tria->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
    1972         this->SpawnTriaHook(dynamic_cast<ElementHook*>(tria),index1,index2,index3);
     1972        this->SpawnTriaHook(xDynamicCast<ElementHook*>(tria),index1,index2,index3);
    19731973
    19741974        /*Spawn material*/

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

    r18474 r18521  
    4848        /*Cast gauss to GaussPenta*/
    4949        _assert_(gauss_in->Enum()==GaussPentaEnum);
    50         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     50        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    5151
    5252        /*Figure out xi,eta and zi (parametric coordinates), for this gaussian point: */
    … …  
    160160        /*Cast gauss to GaussPenta*/
    161161        _assert_(gauss_in->Enum()==GaussPentaEnum);
    162         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     162        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    163163
    164164        /*Get current coordinates in reference element*/
    … …  
    365365        /*Cast gauss to GaussPenta*/
    366366        _assert_(gauss_in->Enum()==GaussPentaEnum);
    367         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     367        GaussPenta* gauss = xDynamicCast<GaussPenta*>(gauss_in);
    368368
    369369        /*Get current coordinates in reference element*/

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

    r18239 r18521  
    824824        tria->parameters=this->parameters;
    825825        tria->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
    826         this->SpawnTriaHook(dynamic_cast<ElementHook*>(tria),index1,index2,index3);
     826        this->SpawnTriaHook(xDynamicCast<ElementHook*>(tria),index1,index2,index3);
    827827
    828828        /*Spawn material*/

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

    r18179 r18521  
    3737        /*Cast gauss to GaussTetra*/
    3838        _assert_(gauss_in->Enum()==GaussTetraEnum);
    39         GaussTetra* gauss = dynamic_cast<GaussTetra*>(gauss_in);
     39        GaussTetra* gauss = xDynamicCast<GaussTetra*>(gauss_in);
    4040
    4141        switch(finiteelement){

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

    r18476 r18521  
    17961796        seg->parameters=this->parameters;
    17971797        seg->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
    1798         this->SpawnSegHook(dynamic_cast<ElementHook*>(seg),index1,index2);
     1798        this->SpawnSegHook(xDynamicCast<ElementHook*>(seg),index1,index2);
    17991799
    18001800        /*Spawn material*/

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

    r18474 r18521  
    146146        /*Cast gauss to GaussTria*/
    147147        _assert_(gauss_in->Enum()==GaussTriaEnum);
    148         GaussTria* gauss = dynamic_cast<GaussTria*>(gauss_in);
     148        GaussTria* gauss = xDynamicCast<GaussTria*>(gauss_in);
    149149
    150150        switch(finiteelement){
    … …  
    271271        /*Cast gauss to GaussTria*/
    272272        _assert_(gauss_in->Enum()==GaussTriaEnum);
    273         GaussTria* gauss = dynamic_cast<GaussTria*>(gauss_in);
     273        GaussTria* gauss = xDynamicCast<GaussTria*>(gauss_in);
    274274
    275275        switch(finiteelement){

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

    r18064 r18521  
    4141
    4242        for(int i=0;i<this->Size();i++){
    43                 ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
     43                ExternalResult* result=xDynamicCast<ExternalResult*>(this->GetObjectByOffset(i));
    4444                result->WriteData(fid,io_gather);
    4545        }
    … …  
    5757
    5858        for(int i=0;i<this->Size();i++){
    59                 ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
     59                ExternalResult* result=xDynamicCast<ExternalResult*>(this->GetObjectByOffset(i));
    6060
    6161                if(result->GetStep()==in_result->GetStep()){
    … …  
    8181
    8282        for(int i=0;i<this->Size();i++){
    83                 ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
     83                ExternalResult* result=xDynamicCast<ExternalResult*>(this->GetObjectByOffset(i));
    8484
    8585                if(result->GetStep()==result_step){

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r18476 r18521  
    603603                                        /*Get interpolation (and compute input if necessary)*/
    604604                                        for(int j=0;j<elements->Size();j++){
    605                                                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(j));
     605                                                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
    606606                                                element->ResultInterpolation(&rank_interpolation,&rank_nodesperelement,output_enum);
    607607                                        }
    … …  
    622622                                                /*Fill-in matrix*/
    623623                                                for(int j=0;j<elements->Size();j++){
    624                                                         Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(j));
     624                                                        Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
    625625                                                        element->ResultToPatch(values,nodesperelement,output_enum);
    626626                                                }
    … …  
    739739
    740740        for (i=1;i<elements->Size();i++){
    741                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     741                element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    742742                dt=element->TimeAdapt();
    743743                if(dt<min_dt)min_dt=dt;
    … …  
    756756
    757757        for(int i=0;i<elements->Size();i++){
    758                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     758                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    759759                element->UpdateConstraintsExtrudeFromBase();
    760760        }
    … …  
    765765
    766766        for(int i=0;i<elements->Size();i++){
    767                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     767                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    768768                element->UpdateConstraintsExtrudeFromTop();
    769769        }
    … …  
    839839        maxabsvx=-INFINITY;
    840840        for(i=0;i<this->elements->Size();i++){
    841                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     841                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    842842                element_maxabsvx=element->inputs->MaxAbs(VxEnum);
    843843                if(element_maxabsvx>maxabsvx) maxabsvx=element_maxabsvx;
    … …  
    863863        maxabsvy=-INFINITY;
    864864        for(i=0;i<this->elements->Size();i++){
    865                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     865                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    866866                element_maxabsvy=element->inputs->MaxAbs(VyEnum);
    867867                if(element_maxabsvy>maxabsvy) maxabsvy=element_maxabsvy;
    … …  
    887887        maxabsvz=-INFINITY;
    888888        for(i=0;i<this->elements->Size();i++){
    889                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     889                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    890890                element_maxabsvz=element->inputs->MaxAbs(VzEnum);
    891891                if(element_maxabsvz>maxabsvz) maxabsvz=element_maxabsvz;
    … …  
    911911        maxvel=-INFINITY;
    912912        for(i=0;i<this->elements->Size();i++){
    913                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     913                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    914914                element_maxvel = element->inputs->Max(VelEnum);
    915915                if(element_maxvel>maxvel) maxvel=element_maxvel;
    … …  
    935935        maxvx=-INFINITY;
    936936        for(i=0;i<this->elements->Size();i++){
    937                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     937                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    938938                element_maxvx = element->inputs->Max(VxEnum);
    939939                if(element_maxvx>maxvx) maxvx=element_maxvx;
    … …  
    959959        maxvy=-INFINITY;
    960960        for(i=0;i<this->elements->Size();i++){
    961                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     961                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    962962                element_maxvy = element->inputs->Max(VyEnum);
    963963                if(element_maxvy>maxvy) maxvy=element_maxvy;
    … …  
    983983        maxvz=-INFINITY;
    984984        for(i=0;i<this->elements->Size();i++){
    985                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     985                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    986986                element_maxvz = element->inputs->Max(VzEnum);
    987987                if(element_maxvz>maxvz) maxvz=element_maxvz;
    … …  
    10071007        minvel=INFINITY;
    10081008        for(i=0;i<this->elements->Size();i++){
    1009                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1009                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    10101010                element_minvel = element->inputs->Min(VelEnum);
    10111011                if(element_minvel<minvel) minvel=element_minvel;
    … …  
    10311031        minvx=INFINITY;
    10321032        for(i=0;i<this->elements->Size();i++){
    1033                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1033                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    10341034                element_minvx = element->inputs->Min(VxEnum);
    10351035                if(element_minvx<minvx) minvx=element_minvx;
    … …  
    10551055        minvy=INFINITY;
    10561056        for(i=0;i<this->elements->Size();i++){
    1057                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1057                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    10581058                element_minvy = element->inputs->Min(VyEnum);
    10591059                if(element_minvy<minvy) minvy=element_minvy;
    … …  
    10791079        minvz=INFINITY;
    10801080        for(i=0;i<this->elements->Size();i++){
    1081                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1081                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    10821082                element_minvz = element->inputs->Min(VzEnum);
    10831083                if(element_minvz<minvz) minvz=element_minvz;
    … …  
    10991099
    11001100        for(int i=0;i<this->elements->Size();i++){
    1101                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1101                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    11021102                local_smb+=element->TotalSmb();
    11031103        }
    … …  
    11151115
    11161116        for(int i=0;i<this->elements->Size();i++){
    1117                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1117                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    11181118                local_divergence+=element->Divergence();
    11191119        }
    … …  
    11431143
    11441144        for(int i=0;i<this->elements->Size();i++){
    1145                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1145                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    11461146                element->GetInputLocalMinMaxOnNodes(uLmin_local,uLmax_local,ug);
    11471147        }
    … …  
    11641164
    11651165        for(int i=0;i<this->elements->Size();i++){
    1166                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1166                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    11671167                local_ice_volume+=element->IceVolume();
    11681168        }
    … …  
    11801180
    11811181        for(int i=0;i<this->elements->Size();i++){
    1182                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1182                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    11831183                local_ice_volume_af+=element->IceVolumeAboveFloatation();
    11841184        }
    … …  
    12051205        /*now, go through our elements, and retrieve the one with this id: index: */
    12061206        for(int i=0;i<this->elements->Size();i++){
    1207                 element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1207                element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    12081208                if (element->Id()==index){
    12091209                        found=1;
    … …  
    12431243        /*Compute Misfit: */
    12441244        for(int i=0;i<elements->Size();i++){
    1245                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1245                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    12461246
    12471247                /*If on water, return 0: */
    … …  
    13111311        /*Compute Misfit: */
    13121312        for(int i=0;i<elements->Size();i++){
    1313                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1313                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    13141314
    13151315                /*If on water, return 0: */
    … …  
    13411341        /*Compute Misfit: */
    13421342        for(int i=0;i<elements->Size();i++){
    1343                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1343                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    13441344
    13451345                /*If on water, return 0: */
    … …  
    15721572        /*Go through elements, and add contribution from each element to the deflection vector wg:*/
    15731573        for(int i=0;i<elements->Size();i++){
    1574                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1574                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15751575                element->GiaDeflection(wg,dwgdt, x,y);
    15761576        }
    … …  
    15901590
    15911591        for (int i=0;i<elements->Size();i++){
    1592                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1592                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15931593                effanalysis->HydrologyEPLGetMask(mask,element);
    15941594        }
    … …  
    16061606        active=new Vector<IssmDouble>(nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
    16071607        for (int i=0;i<elements->Size();i++){
    1608                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1608                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    16091609                effanalysis->HydrologyEPLGetActive(active,element);
    16101610        }
    … …  
    16181618        int counter =0;
    16191619        for (int i=0;i<nodes->Size();i++){
    1620                 Node* node=dynamic_cast<Node*>(nodes->GetObjectByOffset(i));
     1620                Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
    16211621                if(node->InAnalysis(HydrologyDCEfficientAnalysisEnum)){
    16221622                        if(serial_active[node->Sid()]==1.){
    … …  
    16511651        active=new Vector<IssmDouble>(nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
    16521652        for (int i=0;i<elements->Size();i++){
    1653                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1653                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    16541654                effanalysis->HydrologyEPLGetActive(active,element);
    16551655        }
    … …  
    16641664        int counter =0;
    16651665        for (int i=0;i<nodes->Size();i++){
    1666                 Node* node=dynamic_cast<Node*>(nodes->GetObjectByOffset(i));
     1666                Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
    16671667                if(node->InAnalysis(L2ProjectionEPLAnalysisEnum)){
    16681668                        if(serial_active[node->Sid()]==1.){

  • issm/trunk-jpl/src/c/classes/Hook.cpp

    r18237 r18521  
    168168                /*Now, for this->objects that did not get resolved, and for which we have no offset, chase them in the dataset, by id: */
    169169                if(this->objects[i]==NULL){
    170                         this->objects[i]=dynamic_cast<Object*>(dataset->GetObjectById(this->offsets+i,this->ids[i])); //remember the offset for later on.
     170                        this->objects[i]=xDynamicCast<Object*>(dataset->GetObjectById(this->offsets+i,this->ids[i])); //remember the offset for later on.
    171171                        /*check the id is correct!: */
    172172                        if (this->objects[i]->Id()!=this->ids[i]) _error_("wrong id: " << this->objects[i]->Id() << " vs " << this->ids[i] << "  in resolved pointer!");

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

    r18450 r18521  
    8787        output->control_id=this->control_id;
    8888
    89         if(values)      output->values      = dynamic_cast<Input*>(this->values->copy());
    90         if(savedvalues) output->savedvalues = dynamic_cast<Input*>(this->savedvalues->copy());
    91         if(minvalues)   output->minvalues   = dynamic_cast<Input*>(this->minvalues->copy());
    92         if(maxvalues)   output->maxvalues   = dynamic_cast<Input*>(this->maxvalues->copy());
    93         if(gradient)    output->gradient    = dynamic_cast<Input*>(this->gradient->copy());
     89        if(values)      output->values      = xDynamicCast<Input*>(this->values->copy());
     90        if(savedvalues) output->savedvalues = xDynamicCast<Input*>(this->savedvalues->copy());
     91        if(minvalues)   output->minvalues   = xDynamicCast<Input*>(this->minvalues->copy());
     92        if(maxvalues)   output->maxvalues   = xDynamicCast<Input*>(this->maxvalues->copy());
     93        if(gradient)    output->gradient    = xDynamicCast<Input*>(this->gradient->copy());
    9494
    9595        return output;
    … …  
    234234
    235235        if(savedvalues) delete this->savedvalues;
    236         this->savedvalues=dynamic_cast<Input*>(this->values->copy());
     236        this->savedvalues=xDynamicCast<Input*>(this->values->copy());
    237237}/*}}}*/
    238238void ControlInput::UpdateValue(IssmDouble scalar){/*{{{*/
    … …  
    241241
    242242        if(values) delete this->values;
    243         this->values=dynamic_cast<Input*>(this->savedvalues->copy());
     243        this->values=xDynamicCast<Input*>(this->savedvalues->copy());
    244244        this->values->AXPY(gradient,scalar);
    245245}/*}}}*/

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

    r18237 r18521  
    8181        outinput=new DatasetInput();
    8282        outinput->enum_type=this->enum_type;
    83         outinput->inputs=dynamic_cast<Inputs*>(this->inputs->SpawnTriaInputs(index1,index2,index3));
     83        outinput->inputs=xDynamicCast<Inputs*>(this->inputs->SpawnTriaInputs(index1,index2,index3));
    8484        outinput->numids=this->numids;
    8585        outinput->ids=xNew<int>(this->numids);
    … …  
    9898        outinput=new DatasetInput();
    9999        outinput->enum_type=this->enum_type;
    100         outinput->inputs=dynamic_cast<Inputs*>(this->inputs->SpawnSegInputs(index1,index2));
     100        outinput->inputs=xDynamicCast<Inputs*>(this->inputs->SpawnSegInputs(index1,index2));
    101101        outinput->numids=this->numids;
    102102        outinput->ids=xNew<int>(this->numids);
    … …  
    157157        if(offset<0) _error_("Could not find input of id "<<id );
    158158
    159         Input* input=dynamic_cast<Input*>(this->inputs->GetObjectByOffset(offset));
     159        Input* input=xDynamicCast<Input*>(this->inputs->GetObjectByOffset(offset));
    160160        input->GetInputValue(pvalue,gauss);
    161161}

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

    r18064 r18521  
    3838        for ( object=objects.begin() ; object < objects.end(); object++ ){
    3939
    40                 input=dynamic_cast<Input*>(*object);
     40                input=xDynamicCast<Input*>(*object);
    4141                if (input->InstanceEnum()==enum_type){
    4242                        found=true;
    … …  
    6565        for ( object=objects.begin() ; object < objects.end(); object++ ){
    6666
    67                 input=dynamic_cast<Input*>(*object);
     67                input=xDynamicCast<Input*>(*object);
    6868                if (input->InstanceEnum()==enum_type){
    6969                        found=true;
    … …  
    9292        for ( object=objects.begin() ; object < objects.end(); object++ ){
    9393
    94                 input=dynamic_cast<Input*>(*object);
     94                input=xDynamicCast<Input*>(*object);
    9595                if (input->InstanceEnum()==enum_type){
    9696                        found=true;
    … …  
    119119        for ( object=objects.begin() ; object < objects.end(); object++ ){
    120120
    121                 input=dynamic_cast<Input*>(*object);
     121                input=xDynamicCast<Input*>(*object);
    122122                if (input->InstanceEnum()==enum_type){
    123123                        found=true;
    … …  
    150150        for ( object=objects.begin() ; object < objects.end(); object++ ){
    151151
    152                 input=dynamic_cast<Input*>(*object);
     152                input=xDynamicCast<Input*>(*object);
    153153
    154154                if (input->InstanceEnum()==in_input->InstanceEnum()){
    … …  
    171171        /*Delete existing input of newenumtype if it exists*/
    172172        for ( object=objects.begin() ; object < objects.end(); object++ ){
    173                 input=dynamic_cast<Input*>(*object);
     173                input=xDynamicCast<Input*>(*object);
    174174
    175175                if (input->InstanceEnum()==newenumtype){
    … …  
    182182        for ( object=objects.begin() ; object < objects.end(); object++ ){
    183183
    184                 input=dynamic_cast<Input*>(*object);
     184                input=xDynamicCast<Input*>(*object);
    185185
    186186                if (input->InstanceEnum()==oldenumtype){
    … …  
    194194
    195195        /*Find x and y inputs: */
    196         Input* constrain_input=dynamic_cast<Input*>(this->GetInput(constrain_enum));
     196        Input* constrain_input=xDynamicCast<Input*>(this->GetInput(constrain_enum));
    197197
    198198        /*some checks: */
    … …  
    209209
    210210        /*Get input*/
    211         Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
     211        Input* input=xDynamicCast<Input*>(this->GetInput(enumtype));
    212212
    213213        /*Apply ContrainMin: */
    … …  
    229229
    230230        /*Get input*/
    231         Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
     231        Input* input=xDynamicCast<Input*>(this->GetInput(enumtype));
    232232
    233233        /*Apply ContrainMin: */
    … …  
    249249
    250250        /*Get input*/
    251         Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
     251        Input* input=xDynamicCast<Input*>(this->GetInput(enumtype));
    252252
    253253        /*Apply ContrainMin: */
    … …  
    269269
    270270        /*Get input*/
    271         Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
     271        Input* input=xDynamicCast<Input*>(this->GetInput(enumtype));
    272272
    273273        /*Apply ContrainMin: */
    … …  
    289289
    290290        /*Get input*/
    291         Input* input=dynamic_cast<Input*>(this->GetInput(enumtype));
     291        Input* input=xDynamicCast<Input*>(this->GetInput(enumtype));
    292292
    293293        /*Apply ContrainMin: */
    … …  
    310310        for ( object=objects.begin() ; object < objects.end(); object++ ){
    311311
    312                 input=dynamic_cast<Input*>(*object);
     312                input=xDynamicCast<Input*>(*object);
    313313
    314314                if (input->InstanceEnum()==enum_name){
    … …  
    326326        for ( object=objects.begin() ; object < objects.end(); object++ ){
    327327
    328                 input=dynamic_cast<Input*>(*object);
     328                input=xDynamicCast<Input*>(*object);
    329329
    330330                if (input->InstanceEnum()==enum_type){
    … …  
    341341
    342342        /*Make a copy of the original input: */
    343         Input* original=dynamic_cast<Input*>(this->GetInput(original_enum));
     343        Input* original=xDynamicCast<Input*>(this->GetInput(original_enum));
    344344        if(!original)_error_("could not find input with enum: " << EnumToStringx(original_enum));
    345         Input* copy=dynamic_cast<Input*>(original->copy());
     345        Input* copy=xDynamicCast<Input*>(original->copy());
    346346
    347347        /*Change copy enum to reinitialized_enum: */
    … …  
    349349
    350350        /*Add copy into inputs, it will wipe off the one already there: */
    351         this->AddInput(dynamic_cast<Input*>(copy));
     351        this->AddInput(xDynamicCast<Input*>(copy));
    352352}
    353353/*}}}*/
    … …  
    366366
    367367                /*Create new input*/
    368                 inputin=dynamic_cast<Input*>(*object);
     368                inputin=xDynamicCast<Input*>(*object);
    369369                inputout=inputin->SpawnTriaInput(index1,index2,index3);
    370370
    … …  
    391391
    392392                /*Create new input*/
    393                 inputin=dynamic_cast<Input*>(*object);
     393                inputin=xDynamicCast<Input*>(*object);
    394394                inputout=inputin->SpawnSegInput(index1,index2);
    395395
    … …  
    405405
    406406        /*Find x and y inputs: */
    407         Input* xinput=dynamic_cast<Input*>(this->GetInput(inputx_enum));
    408         Input* yinput=dynamic_cast<Input*>(this->GetInput(inputy_enum));
     407        Input* xinput=xDynamicCast<Input*>(this->GetInput(inputx_enum));
     408        Input* yinput=xDynamicCast<Input*>(this->GetInput(inputy_enum));
    409409
    410410        /*some checks: */
    … …  
    423423        for ( object=objects.begin() ; object < objects.end(); object++ ){
    424424
    425                 input=dynamic_cast<Input*>(*object);
     425                input=xDynamicCast<Input*>(*object);
    426426                input->Configure(parameters);
    427427

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r18064 r18521  
    259259
    260260        /*Find constant*/
    261         Param* param=dynamic_cast<Param*>(this->constants->FindParamObject(constant_enum));
     261        Param* param=xDynamicCast<Param*>(this->constants->FindParamObject(constant_enum));
    262262        if(!param) _error_("Constant " << EnumToStringx(constant_enum) << " not found in iomodel");
    263263
    264         return dynamic_cast<Param*>(param->copy());
     264        return xDynamicCast<Param*>(param->copy());
    265265}
    266266/*}}}*/
    … …  
    14551455
    14561456        for(int i=0;i<elements->Size();i++){
    1457                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1457                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    14581458                if(!doublearray) element->AddInput(vector_enum,&default_value,P0Enum);
    14591459                else             element->InputCreate(doublearray,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    … …  
    14851485                        this->FetchData(&boolean,vector_enum);
    14861486                        for(i=0;i<elements->Size();i++){
    1487                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1487                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    14881488                                element->InputUpdateFromConstant(boolean,vector_enum);
    14891489                        }
    … …  
    14921492                        this->FetchData(&integer,vector_enum);
    14931493                        for(i=0;i<elements->Size();i++){
    1494                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1494                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    14951495                                element->InputUpdateFromConstant(integer,vector_enum);
    14961496                        }
    … …  
    14991499                        this->FetchData(&scalar,vector_enum);
    15001500                        for(i=0;i<elements->Size();i++){
    1501                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1501                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15021502                                element->InputUpdateFromConstant(scalar,vector_enum);
    15031503                        }
    … …  
    15071507                        if(!doublearray) _error_(EnumToStringx(vector_enum)<<" not found in binary file");
    15081508                        for(i=0;i<elements->Size();i++){
    1509                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1509                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15101510                                element->InputCreate(doublearray,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    15111511                        }
    … …  
    15151515                        if(!doublearray) _error_(EnumToStringx(vector_enum)<<" not found in binary file");
    15161516                        for(i=0;i<elements->Size();i++){
    1517                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1517                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15181518                                element->InputCreate(doublearray,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    15191519                        }
    … …  
    15231523                        if(!doublearray) _error_(EnumToStringx(vector_enum)<<" not found in binary file");
    15241524                        for(i=0;i<elements->Size();i++){
    1525                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1525                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    15261526                                element->InputCreate(doublearray,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    15271527                        }

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

    r18237 r18521  
    4141        for ( object=objects.begin() ; object < objects.end(); object++ ){
    4242
    43                 load=dynamic_cast<Load*>(*object);
     43                load=xDynamicCast<Load*>(*object);
    4444                load->Configure(elements,loads,nodes,vertices,materials,parameters);
    4545
    … …  
    5555        for ( object=objects.begin() ; object < objects.end(); object++ ){
    5656
    57                 load=dynamic_cast<Load*>((*object));
     57                load=xDynamicCast<Load*>((*object));
    5858                load->ResetHooks();
    5959
    … …  
    7070        for(int i=0;i<this->Size();i++){
    7171
    72                 Load* load=dynamic_cast<Load*>(this->GetObjectByOffset(i));
     72                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    7373                if (load->InAnalysis(analysis_type)){
    7474                        if(load->IsPenalty()) ispenalty++;
    … …  
    9595        for(int i=0;i<this->Size();i++){
    9696
    97                 Load* load=dynamic_cast<Load*>(this->GetObjectByOffset(i));
     97                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    9898                if (load->InAnalysis(analysis_type)){
    9999                        numnodes=load->GetNumberOfNodes();
    … …  
    132132        for(int i=0;i<this->Size();i++){
    133133
    134                 Load* load=dynamic_cast<Load*>(this->GetObjectByOffset(i));
     134                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    135135
    136136                /*Check that this load corresponds to our analysis currently being carried out: */
    … …  
    157157        for(int i=0;i<this->Size();i++){
    158158
    159                 Load* load=dynamic_cast<Load*>(this->GetObjectByOffset(i));
     159                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    160160
    161161                /*Check that this load corresponds to our analysis currently being carried out: */
    … …  
    173173        for ( object=objects.begin() ; object < objects.end(); object++ ){
    174174
    175                 load=dynamic_cast<Load*>(*object);
     175                load=xDynamicCast<Load*>(*object);
    176176                load->SetCurrentConfiguration(elements,loads,nodes,vertices,materials,parameters);
    177177

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

    r18237 r18521  
    3737        for ( object=objects.begin() ; object < objects.end(); object++ ){
    3838
    39                 material=dynamic_cast<Material*>(*object);
     39                material=xDynamicCast<Material*>(*object);
    4040                material->Configure(elements);
    4141
    … …  
    5151        for ( object=objects.begin() ; object < objects.end(); object++ ){
    5252
    53                 material=dynamic_cast<Material*>((*object));
     53                material=xDynamicCast<Material*>((*object));
    5454                material->ResetHooks();
    5555

  • issm/trunk-jpl/src/c/classes/Nodes.cpp

    r18063 r18521  
    4949        /*Go through objects, and distribute dofs locally, from 0 to numberofdofsperobject*/
    5050        for(i=0;i<this->Size();i++){
    51                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     51                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    5252
    5353                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    7272        for(i=0;i<this->Size();i++){
    7373                /*Check that this node corresponds to our analysis currently being carried out: */
    74                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     74                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    7575                if (node->InAnalysis(analysis_type)){
    7676                        node->OffsetDofs(dofcount,setenum);
    … …  
    8989
    9090        for(i=0;i<this->Size();i++){
    91                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     91                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    9292                if (node->InAnalysis(analysis_type)){
    9393                        node->ShowTrueDofs(truedofs,maxdofspernode,setenum);//give maxdofspernode, column size, so that nodes can index into truedofs
    … …  
    9999        /* Now every cpu knows the true dofs of everyone else that is not a clone*/
    100100        for(i=0;i<this->Size();i++){
    101                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     101                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    102102                if (node->InAnalysis(analysis_type)){
    103103                        node->UpdateCloneDofs(alltruedofs,maxdofspernode,setenum);
    … …  
    107107        /*Update indexingupdateflag*/
    108108        for(i=0;i<this->Size();i++){
    109                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     109                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    110110                if (node->InAnalysis(analysis_type)){
    111111                        node->ReindexingDone();
    … …  
    148148        for(i=0;i<this->Size();i++){
    149149
    150                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     150                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    151151
    152152                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    172172        for(int i=0;i<this->Size();i++){
    173173
    174                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     174                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    175175
    176176                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    197197        if(!sorted){
    198198                for(int i=0;i<this->Size();i++){
    199                         Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     199                        Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    200200                        id=node->Id();
    201201                        if(id>max)max=id;
    … …  
    207207                }
    208208                else{
    209                         Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(this->Size()-1));
     209                        Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(this->Size()-1));
    210210                        max = node->Id();
    211211                }
    … …  
    238238        for(int i=0;i<this->Size();i++){
    239239
    240                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     240                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    241241
    242242                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    262262        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    263263        for(int i=0;i<this->Size();i++){
    264                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     264                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    265265
    266266                /*Ok, this object is a node, ask it to plug values into partition: */
    … …  
    284284        for(i=0;i<this->Size();i++){
    285285
    286                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     286                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    287287
    288288                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    316316        for(int i=0;i<this->Size();i++){
    317317
    318                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     318                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    319319
    320320                /*Check that this node corresponds to our analysis currently being carried out: */
    … …  
    335335        for(int i=0;i<this->Size();i++){
    336336
    337                 Node* node=dynamic_cast<Node*>(this->GetObjectByOffset(i));
     337                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    338338
    339339                /*Check that this node corresponds to our analysis currently being carried out: */

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

    r18487 r18521  
    5252        for(object=objects.begin();object<objects.end();object++){
    5353
    54                 option=dynamic_cast<Option*>(*object);
     54                option=xDynamicCast<Option*>(*object);
    5555                if (!strcmp(option->Name(),name)){
    5656                        _error_("Options \"" << name << "\" found multiple times");
    … …  
    7373        for ( object=objects.begin() ; object < objects.end(); object++ ){
    7474
    75                 option=dynamic_cast<Option*>(*object);
     75                option=xDynamicCast<Option*>(*object);
    7676                //option=(Option*)(*object); //C-like cast
    7777                /*There is a crash on some machines (Einar Olason) that needs to be fixed*/

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

    r15104 r18521  
    2626
    2727                        /*Get option*/
    28                         GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
     28                        GenericOption<OptionType>* genericoption=xDynamicCast<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=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
     43                        GenericOption<OptionType>* genericoption=xDynamicCast<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=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
     59                        GenericOption<OptionType>* genericoption=xDynamicCast<GenericOption<OptionType>*>(GetOption(name));
    6060
    6161                        /*If the pointer is not NULL, the option has been found*/
    … …  
    7272
    7373                        /*Get option*/
    74                         GenericOption<OptionType>* genericoption=dynamic_cast<GenericOption<OptionType>*>(GetOption(name));
     74                        GenericOption<OptionType>* genericoption=xDynamicCast<GenericOption<OptionType>*>(GetOption(name));
    7575
    7676                        /*If the pointer is not NULL, the option has been found*/
    … …  
    9292
    9393        /*Get option*/
    94         GenericOption<char*>* genericoption=dynamic_cast<GenericOption<char*>*>(GetOption(name));
     94        GenericOption<char*>* genericoption=xDynamicCast<GenericOption<char*>*>(GetOption(name));
    9595
    9696        /*If the pointer is not NULL, the option has been found*/

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r18237 r18521  
    5757
    5858        for ( object=objects.begin() ; object < objects.end(); object++ ){
    59                 param=dynamic_cast<Param*>(*object);
     59                param=xDynamicCast<Param*>(*object);
    6060                if(param->InstanceEnum()==enum_type) return true;
    6161        }
    … …  
    7070        for ( object=objects.begin() ; object < objects.end(); object++ ){
    7171
    72                 param=dynamic_cast<Param*>(*object);
     72                param=xDynamicCast<Param*>(*object);
    7373                if(param->InstanceEnum()==enum_type){
    7474                        param->GetParameterValue(pbool);
    … …  
    8686        for ( object=objects.begin() ; object < objects.end(); object++ ){
    8787
    88                 param=dynamic_cast<Param*>(*object);
     88                param=xDynamicCast<Param*>(*object);
    8989                if(param->InstanceEnum()==enum_type){
    9090                        param->GetParameterValue(pinteger);
    … …  
    102102        for ( object=objects.begin() ; object < objects.end(); object++ ){
    103103
    104                 param=dynamic_cast<Param*>(*object);
     104                param=xDynamicCast<Param*>(*object);
    105105                if(param->InstanceEnum()==enum_type){
    106106                        param->GetParameterValue(pscalar);
    … …  
    118118        for ( object=objects.begin() ; object < objects.end(); object++ ){
    119119
    120                 param=dynamic_cast<Param*>(*object);
     120                param=xDynamicCast<Param*>(*object);
    121121                if(param->InstanceEnum()==enum_type){
    122122                        param->GetParameterValue(pscalar,time);
    … …  
    134134        for ( object=objects.begin() ; object < objects.end(); object++ ){
    135135
    136                 param=dynamic_cast<Param*>(*object);
     136                param=xDynamicCast<Param*>(*object);
    137137                if(param->InstanceEnum()==enum_type){
    138138                        param->GetParameterValue(pstring);
    … …  
    151151        for ( object=objects.begin() ; object < objects.end(); object++ ){
    152152
    153                 param=dynamic_cast<Param*>(*object);
     153                param=xDynamicCast<Param*>(*object);
    154154                if(param->InstanceEnum()==enum_type){
    155155                        param->GetParameterValue(pstringarray,pM);
    … …  
    168168        for ( object=objects.begin() ; object < objects.end(); object++ ){
    169169
    170                 param=dynamic_cast<Param*>(*object);
     170                param=xDynamicCast<Param*>(*object);
    171171                if(param->InstanceEnum()==enum_type){
    172172                        param->GetParameterValue(pintarray,pM);
    … …  
    185185        for ( object=objects.begin() ; object < objects.end(); object++ ){
    186186
    187                 param=dynamic_cast<Param*>(*object);
     187                param=xDynamicCast<Param*>(*object);
    188188                if(param->InstanceEnum()==enum_type){
    189189                        param->GetParameterValue(pintarray,pM,pN);
    … …  
    202202        for ( object=objects.begin() ; object < objects.end(); object++ ){
    203203
    204                 param=dynamic_cast<Param*>(*object);
     204                param=xDynamicCast<Param*>(*object);
    205205                if(param->InstanceEnum()==enum_type){
    206206                        param->GetParameterValue(pIssmDoublearray,pM);
    … …  
    219219        for ( object=objects.begin() ; object < objects.end(); object++ ){
    220220
    221                 param=dynamic_cast<Param*>(*object);
     221                param=xDynamicCast<Param*>(*object);
    222222                if(param->InstanceEnum()==enum_type){
    223223                        param->GetParameterValue(pIssmDoublearray,pM,pN);
    … …  
    236236        for ( object=objects.begin() ; object < objects.end(); object++ ){
    237237
    238                 param=dynamic_cast<Param*>(*object);
     238                param=xDynamicCast<Param*>(*object);
    239239                if(param->InstanceEnum()==enum_type){
    240240                        param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
    … …  
    252252        for ( object=objects.begin() ; object < objects.end(); object++ ){
    253253
    254                 param=dynamic_cast<Param*>(*object);
     254                param=xDynamicCast<Param*>(*object);
    255255                if(param->InstanceEnum()==enum_type){
    256256                        param->GetParameterValue(pvec);
    … …  
    269269        for ( object=objects.begin() ; object < objects.end(); object++ ){
    270270
    271                 param=dynamic_cast<Param*>(*object);
     271                param=xDynamicCast<Param*>(*object);
    272272                if(param->InstanceEnum()==enum_type){
    273273                        param->GetParameterValue(pmat);
    … …  
    286286        for ( object=objects.begin() ; object < objects.end(); object++ ){
    287287
    288                 param=dynamic_cast<Param*>(*object);
     288                param=xDynamicCast<Param*>(*object);
    289289                if(param->InstanceEnum()==enum_type){
    290290                        param->GetParameterValue(pfid);
    … …  
    303303        for ( object=objects.begin() ; object < objects.end(); object++ ){
    304304
    305                 param=dynamic_cast<Param*>(*object);
     305                param=xDynamicCast<Param*>(*object);
    306306                if(param->InstanceEnum()==enum_type){
    307307                        param->GetParameterValue(pdataset);
    … …  
    318318
    319319        /*first, figure out if the param has already been created: */
    320         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     320        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    321321
    322322        if(param) param->SetValue(boolean); //already exists, just set it.
    … …  
    329329
    330330        /*first, figure out if the param has already been created: */
    331         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     331        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    332332
    333333        if(param) param->SetValue(integer); //already exists, just set it.
    … …  
    340340
    341341        /*first, figure out if the param has already been created: */
    342         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     342        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    343343
    344344        if(param) param->SetValue(scalar); //already exists, just set it.
    … …  
    351351
    352352        /*first, figure out if the param has already been created: */
    353         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     353        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    354354
    355355        if(param) param->SetValue(string); //already exists, just set it.
    … …  
    362362
    363363        /*first, figure out if the param has already been created: */
    364         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     364        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    365365
    366366        if(param) param->SetValue(stringarray,M); //already exists, just set it.
    … …  
    373373
    374374        /*first, figure out if the param has already been created: */
    375         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     375        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    376376
    377377        if(param) param->SetValue(IssmDoublearray,M); //already exists, just set it.
    … …  
    384384
    385385        /*first, figure out if the param has already been created: */
    386         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     386        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    387387
    388388        if(param) param->SetValue(IssmDoublearray,M,N); //already exists, just set it.
    … …  
    395395
    396396        /*first, figure out if the param has already been created: */
    397         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     397        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    398398
    399399        if(param) param->SetValue(intarray,M); //already exists, just set it.
    … …  
    406406
    407407        /*first, figure out if the param has already been created: */
    408         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     408        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    409409
    410410        if(param) param->SetValue(intarray,M,N); //already exists, just set it.
    … …  
    417417
    418418        /*first, figure out if the param has already been created: */
    419         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     419        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    420420
    421421        if(param) param->SetValue(vector); //already exists, just set it.
    … …  
    428428
    429429        /*first, figure out if the param has already been created: */
    430         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     430        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    431431
    432432        if(param) param->SetValue(matrix); //already exists, just set it.
    … …  
    439439
    440440        /*first, figure out if the param has already been created: */
    441         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     441        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    442442
    443443        if(param) param->SetValue(fid); //already exists, just set it.
    … …  
    450450
    451451        /*first, figure out if the param has already been created: */
    452         param=dynamic_cast<Param*>(this->FindParamObject(enum_type));
     452        param=xDynamicCast<Param*>(this->FindParamObject(enum_type));
    453453
    454454        if(param) param->SetValue(dataset); //already exists, just set it.
    … …  
    464464        for ( object=objects.begin() ; object < objects.end(); object++ ){
    465465
    466                 param=dynamic_cast<Param*>(*object);
     466                param=xDynamicCast<Param*>(*object);
    467467                if(param->InstanceEnum()==enum_type){
    468468                        return (*object);

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

    r18063 r18521  
    5252        /*Go through objects, and distribute pids locally, from 0 to numberofpidsperobject*/
    5353        for (i=0;i<this->Size();i++){
    54                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     54                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    5555                vertex->DistributePids(&pidcount);
    5656        }
    … …  
    7272        }
    7373        for (i=0;i<this->Size();i++){
    74                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     74                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    7575                vertex->OffsetPids(pidcount);
    7676        }
    … …  
    8282        alltruepids=xNewZeroInit<int>(numberofobjects);
    8383        for (i=0;i<this->Size();i++){
    84                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     84                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    8585                vertex->ShowTruePids(truepids);
    8686        }
    … …  
    8989        /* Now every cpu knows the true pids of everyone else that is not a clone*/
    9090        for(i=0;i<this->Size();i++){
    91                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     91                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    9292                vertex->UpdateClonePids(alltruepids);
    9393        }
    … …  
    128128        for(i=0;i<this->Size();i++){
    129129                /*For this object, decide whether it is a clone: */
    130                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     130                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    131131                vertex->SetClone(minranks);
    132132        }
    … …  
    145145
    146146        for(i=0;i<this->Size();i++){
    147                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     147                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    148148                sid=vertex->Sid();
    149149                if (sid>max_sid)max_sid=sid;
    … …  
    172172        for(int i=0;i<this->Size();i++){
    173173                /*Plug rank into ranks, according to id: */
    174                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     174                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    175175                sid=vertex->Sid();
    176176                ranks[sid]=my_rank;
    … …  
    202202
    203203                /*let vertex fill matrix: */
    204                 Vertex* vertex=dynamic_cast<Vertex*>(this->GetObjectByOffset(i));
     204                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    205205                vertex->ToXYZ(xyz);
    206206        }

  • issm/trunk-jpl/src/c/classes/gauss/GaussPenta.cpp

    r18171 r18521  
    88#include "../../shared/Exceptions/exceptions.h"
    99#include "../../shared/MemOps/MemOps.h"
     10#include "../../shared/Numerics/recast.h"
    1011#include "../../shared/Enum/Enum.h"
    1112#include "../../shared/Numerics/GaussPoints.h"
    … …  
    750751
    751752        _assert_(gauss->Enum()==GaussTriaEnum);
    752         GaussTria* gauss_tria = dynamic_cast<GaussTria*>(gauss);
     753        GaussTria* gauss_tria = xDynamicCast<GaussTria*>(gauss);
    753754
    754755        gauss_tria->coord1=this->coord1;

  • issm/trunk-jpl/src/c/classes/kriging/Observations.cpp

    r18064 r18521  
    8989                this->quadtree->ClosestObs(&index,x[i],y[i]);
    9090                if(index>=0){
    91                         observation=dynamic_cast<Observation*>(this->GetObjectByOffset(index));
     91                        observation=xDynamicCast<Observation*>(this->GetObjectByOffset(index));
    9292                        if(pow(observation->x-x[i],2)+pow(observation->y-y[i],2) < minspacing) continue;
    9393                }
    … …  
    131131        this->quadtree->ClosestObs(&index,x_interp,y_interp);
    132132        if(index>=0){
    133                 observation=dynamic_cast<Observation*>(this->GetObjectByOffset(index));
     133                observation=xDynamicCast<Observation*>(this->GetObjectByOffset(index));
    134134                hmin = sqrt((observation->x-x_interp)*(observation->x-x_interp) + (observation->y-y_interp)*(observation->y-y_interp));
    135135                if(hmin<radius) radius=hmin;
    … …  
    139139        this->quadtree->RangeSearch(&indices,&nobs,x_interp,y_interp,radius);
    140140        for (i=0;i<nobs;i++){
    141                 observation=dynamic_cast<Observation*>(this->GetObjectByOffset(indices[i]));
     141                observation=xDynamicCast<Observation*>(this->GetObjectByOffset(indices[i]));
    142142                h2 = (observation->x-x_interp)*(observation->x-x_interp) + (observation->y-y_interp)*(observation->y-y_interp);
    143143                if(i==0){
    … …  
    155155        /*Assign output pointer*/
    156156        if(nobs || hmin==radius){
    157                 observation=dynamic_cast<Observation*>(this->GetObjectByOffset(index));
     157                observation=xDynamicCast<Observation*>(this->GetObjectByOffset(index));
    158158                *px   = observation->x;
    159159                *py   = observation->y;
    … …  
    210210        nobs = 0;
    211211        for(i=0;i<tempnobs;i++){
    212                 observation=dynamic_cast<Observation*>(this->GetObjectByOffset(tempindices[i]));
     212                observation=xDynamicCast<Observation*>(this->GetObjectByOffset(tempindices[i]));
    213213                h2 = (observation->x-x_interp)*(observation->x-x_interp) + (observation->y-y_interp)*(observation->y-y_interp);
    214214
    … …  
    252252                /*Loop over all observations and fill in x, y and obs*/
    253253                for(i=0;i<nobs;i++){
    254                         observation=dynamic_cast<Observation*>(this->GetObjectByOffset(indices[i]));
     254                        observation=xDynamicCast<Observation*>(this->GetObjectByOffset(indices[i]));
    255255                        observation->WriteXYObs(&x[i],&y[i],&obs[i]);
    256256                }
    … …  
    280280                obs = xNew<IssmPDouble>(nobs);
    281281                for(int i=0;i<this->Size();i++){
    282                         observation=dynamic_cast<Observation*>(this->GetObjectByOffset(i));
     282                        observation=xDynamicCast<Observation*>(this->GetObjectByOffset(i));
    283283                        observation->WriteXYObs(&x[i],&y[i],&obs[i]);
    284284                }
    … …  
    532532
    533533        for(i=0;i<this->Size();i++){
    534                 observation1=dynamic_cast<Observation*>(this->GetObjectByOffset(i));
     534                observation1=xDynamicCast<Observation*>(this->GetObjectByOffset(i));
    535535
    536536                for(j=i+1;j<this->Size();j++){
    537                         observation2=dynamic_cast<Observation*>(this->GetObjectByOffset(j));
     537                        observation2=xDynamicCast<Observation*>(this->GetObjectByOffset(j));
    538538
    539539                        distance=sqrt(pow(observation1->x - observation2->x,2) + pow(observation1->y - observation2->y,2));

  • issm/trunk-jpl/src/c/cores/ad_core.cpp

    r16518 r18521  
    111111
    112112                        /*get the EDF pointer:*/
    113                         ext_diff_fct *anEDF_for_solverx_p=dynamic_cast<GenericParam<Adolc_edf> * >(femmodel->parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p;
     113                        ext_diff_fct *anEDF_for_solverx_p=xDynamicCast<GenericParam<Adolc_edf> * >(femmodel->parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p;
    114114
    115115                        /*Branch according to AD driver: */

  • issm/trunk-jpl/src/c/main/kriging.cpp

    r16164 r18521  
    5858                results->AddObject(new GenericExternalResult<double*>(results->Size()+1,1,error,ninterp,1,1,0));
    5959                for(int i=0;i<results->Size();i++){
    60                         ExternalResult* result=dynamic_cast<ExternalResult*>(results->GetObjectByOffset(i));
     60                        ExternalResult* result=xDynamicCast<ExternalResult*>(results->GetObjectByOffset(i));
    6161                        result->WriteData(output_fid,1);
    6262                }

  • issm/trunk-jpl/src/c/modules/AllocateSystemMatricesx/AllocateSystemMatricesx.cpp

    r16441 r18521  
    134134        k=0;
    135135        for(i=0;i<femmodel->elements->Size();i++){
    136                 element = dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     136                element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    137137                lidlist = xNew<int>(element->GetNumberOfNodes());
    138138                element->GetNodesLidList(lidlist);
    … …  
    157157        k=0;
    158158        for(i=0;i<femmodel->loads->Size();i++){
    159                 load = dynamic_cast<Load*>(femmodel->loads->GetObjectByOffset(i));
     159                load = xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    160160                if(!load->InAnalysis(configuration_type)) continue;
    161161                lidlist = xNew<int>(load->GetNumberOfNodes());
    … …  
    190190        /*Create connectivity vector*/
    191191        for(i=0;i<femmodel->nodes->Size();i++){
    192                 Node* node=dynamic_cast<Node*>(femmodel->nodes->GetObjectByOffset(i));
     192                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    193193                if(node->InAnalysis(configuration_type)){
    194194
    … …  
    214214                        for(j=head_e[node->Lid()];j!=-1;j=next_e[j]){
    215215                                offset=count2offset_e[j];
    216                                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(offset));
     216                                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(offset));
    217217                                element->SetwiseNodeConnectivity(&d_nz,&o_nz,node,flags,flagsindices,set1enum,set2enum);
    218218                                if(node->IsClone()){
    … …  
    226226                        for(j=head_l[node->Lid()];j!=-1;j=next_l[j]){
    227227                                offset=count2offset_l[j];
    228                                 load=dynamic_cast<Load*>(femmodel->loads->GetObjectByOffset(offset));
     228                                load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(offset));
    229229                                load->SetwiseNodeConnectivity(&d_nz,&o_nz,node,flags,flagsindices,set1enum,set2enum);
    230230                                if(node->IsClone()){
    … …  
    256256                o_nnz=xNew<int>(m);
    257257                for(i=0;i<femmodel->nodes->Size();i++){
    258                         Node* node=dynamic_cast<Node*>(femmodel->nodes->GetObjectByOffset(i));
     258                        Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    259259                        if(node->InAnalysis(configuration_type) && !node->IsClone()){
    260260                                for(j=0;j<node->indexing.fsize;j++){

  • issm/trunk-jpl/src/c/modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp

    r16164 r18521  
    4141        /*loop on each element, and add contribution of the element to the partition (surface weighted average): */
    4242        for(int i=0;i<elements->Size();i++){
    43                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     43                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    4444                element->AverageOntoPartition(partition_contributions,partition_areas,vertex_response,qmu_part);
    4545        }

  • issm/trunk-jpl/src/c/modules/ConfigureObjectsx/ConfigureObjectsx.cpp

    r16164 r18521  
    2424        if(VerboseMProcessor()) _printf0_("      Configuring elements...\n");
    2525        for(i=0;i<elements->Size();i++){
    26                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     26                element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    2727                element->Configure(elements,loads,nodes,vertices,materials,parameters);
    2828        }

  • issm/trunk-jpl/src/c/modules/CreateJacobianMatrixx/CreateJacobianMatrixx.cpp

    r16993 r18521  
    2929        /*Create and assemble matrix*/
    3030        for(i=0;i<femmodel->elements->Size();i++){
    31                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     31                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3232                ElementMatrix* Je = analysis->CreateJacobianMatrix(element);
    3333                if(Je) Je->AddToGlobal(Jff);

  • issm/trunk-jpl/src/c/modules/DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=DragCoefficientAbsGradient(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp

    r18093 r18521  
    3333
    3434        for(int i=0;i<femmodel->elements->Size();i++){
    35                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     35                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3636                element->LinearFloatingiceMeltingRate();
    3737        }

  • issm/trunk-jpl/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp

    r16675 r18521  
    3232        Analysis* analysis = EnumToAnalysis(analysisenum);
    3333        for(int i=0;i<femmodel->elements->Size();i++){
    34                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     34                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3535                analysis->GetSolutionFromInputs(solution,element);
    3636        }

  • issm/trunk-jpl/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp

    r17275 r18521  
    1919                /*Look up in elements*/
    2020                for(i=0;i<femmodel->elements->Size();i++){
    21                         Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     21                        Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2222                        element->GetVectorFromInputs(vector,name);
    2323                }

  • issm/trunk-jpl/src/c/modules/GroundinglineMigrationx/GroundinglineMigrationx.cpp

    r18063 r18521  
    4747        /*Migrate grounding line : */
    4848        for(int i=0;i<elements->Size();i++){
    49                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     49                element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    5050                element->MigrateGroundingLine(phi_ungrounding);
    5151        }
    … …  
    7272        /*Fill vector vertices_potentially_floating: */
    7373        for(int i=0;i<elements->Size();i++){
    74                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     74                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    7575                element->FSContactMigration(vertexgrounded,vertexfloating);
    7676        }
    … …  
    120120        /*Fill vector vertices_potentially_floating: */
    121121        for(i=0;i<elements->Size();i++){
    122                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     122                element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    123123                element->PotentialUngrounding(vec_vertices_potentially_ungrounding);
    124124        }
    … …  
    148148        vec_phi=new Vector<IssmDouble>(vertices->NumberOfVertices());
    149149        for(i=0;i<elements->Size();i++){
    150                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     150                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    151151                element->GetVectorFromInputs(vec_phi,MaskGroundediceLevelsetEnum);
    152152        }
    … …  
    162162                /*Figure out if any of the nodes of the element will be floating -> elements neighbouting the floating ice*/
    163163                for(i=0;i<elements->Size();i++){
    164                         element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     164                        element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    165165                        vec_elements_neighboring_floatingice->SetValue(element->Sid(),element->IsNodeOnShelfFromFlags(phi)?1.0:0.0,INS_VAL);
    166166                }
    … …  
    173173                local_nflipped=0;
    174174                for(i=0;i<elements->Size();i++){
    175                         element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     175                        element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    176176                        if(reCast<int,IssmDouble>(elements_neighboring_floatingce[element->Sid()])){
    177177                                local_nflipped+=element->UpdatePotentialUngrounding(vertices_potentially_ungrounding,vec_phi,phi);

  • issm/trunk-jpl/src/c/modules/InputControlUpdatex/InputControlUpdatex.cpp

    r14999 r18521  
    1212        /*Go through elemnets, and ask to carry out the operation on inputs: */
    1313        for(int i=0;i<elements->Size();i++){
    14                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     14                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1515                element->InputControlUpdate(scalar,save_parameter);
    1616        }

  • issm/trunk-jpl/src/c/modules/InputDepthAverageAtBasex/InputDepthAverageAtBasex.cpp

    r17862 r18521  
    1010void InputDepthAverageAtBasex(FemModel* femmodel,int original_enum, int new_enum){
    1111        for(int i=0;i<femmodel->elements->Size();i++){
    12                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     12                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1313                element->InputDepthAverageAtBase(original_enum,new_enum);
    1414        }

  • issm/trunk-jpl/src/c/modules/InputDuplicatex/InputDuplicatex.cpp

    r17275 r18521  
    1111        /*Go through elemnets, and ask to reinitialie the input: */
    1212        for(int i=0;i<femmodel->elements->Size();i++){
    13                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     13                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1414                element->InputDuplicate(original_enum,new_enum);
    1515        }

  • issm/trunk-jpl/src/c/modules/InputExtrudex/InputExtrudex.cpp

    r18450 r18521  
    1010void InputExtrudex(FemModel* femmodel,int input_enum,int start){
    1111        for(int i=0;i<femmodel->elements->Size();i++){
    12                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     12                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1313                element->InputExtrude(input_enum,start);
    1414        }

  • issm/trunk-jpl/src/c/modules/InputScalex/InputScalex.cpp

    r14999 r18521  
    1515        /*Go through elemnets, and ask to reinitialie the input: */
    1616        for(i=0;i<elements->Size();i++){
    17                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     17                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1818                element->InputScale(enum_type,scale_factor);
    1919        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromConstantx/InputUpdateFromConstantx.cpp

    r16218 r18521  
    1414        /*Elements and loads drive the update: */
    1515        for(i=0;i<femmodel->elements->Size();i++){
    16                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     16                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1717                element->InputUpdateFromConstant(constant,name);
    1818        }
    … …  
    3535        /*Elements and loads drive the update: */
    3636        for(i=0;i<femmodel->elements->Size();i++){
    37                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     37                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3838                element->InputUpdateFromConstant(constant,name);
    3939        }
    … …  
    5656        /*Elements and loads drive the update: */
    5757        for(i=0;i<femmodel->elements->Size();i++){
    58                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     58                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    5959                element->InputUpdateFromConstant(constant,name);
    6060        }
    … …  
    7878        /*Elements and loads drive the update: */
    7979        for(i=0;i<elements->Size();i++){
    80                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     80                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    8181                element->InputUpdateFromConstant(constant,name);
    8282        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromMatrixDakotax/InputUpdateFromMatrixDakotax.cpp

    r16125 r18521  
    2020                /*Update elements, nodes, loads and materials from inputs: */
    2121                for(i=0;i<femmodel->elements->Size();i++){
    22                         Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     22                        Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2323                        element->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    2424                }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.cpp

    r18257 r18521  
    3030        Analysis* analysis = EnumToAnalysis(analysisenum);
    3131        for(int i=0;i<femmodel->elements->Size();i++){
    32                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     32                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3333                analysis->InputUpdateFromSolution(solution,element);
    3434        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.cpp

    r16125 r18521  
    2222        /*Update elements, nodes, loads and materials from inputs: */
    2323        for(i=0;i<femmodel->elements->Size();i++){
    24                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     24                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2525                element->InputUpdateFromVectorDakota(vector,name,type);
    2626        }

  • issm/trunk-jpl/src/c/modules/InputUpdateFromVectorx/InputUpdateFromVectorx.cpp

    r16125 r18521  
    2020        /*Update elements, nodes, loads and materials from inputs: */
    2121        for(i=0;i<femmodel->elements->Size();i++){
    22                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     22                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2323                element->InputUpdateFromVector(vector,name,type);
    2424        }

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

    r16787 r18521  
    8484                                        /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
    8585                                        for(i=0;i<elements->Size();i++){
    86                                                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     86                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    8787                                                element->InputCreate(misfit_observation_s[j], iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],1,misfit_observation_enum_s[j],7);
    8888                                                element->InputCreate(misfit_weights_s[j], iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],1,misfit_weights_enum_s[j],7);

  • issm/trunk-jpl/src/c/modules/NodalValuex/NodalValuex.cpp

    r16164 r18521  
    2020         *element, figure out  if they hold the vertex, and the data. If so, return it: */
    2121        for(int i=0;i<elements->Size();i++){
    22                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     22                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    2323                found=element->NodalValue(&value,index,natureofdataenum);
    2424                if(found){

  • issm/trunk-jpl/src/c/modules/OutputDefinitionsResponsex/OutputDefinitionsResponsex.cpp

    r16794 r18521  
    2020        for(int i=0;i<output_definitions->Size();i++){
    2121               
    22                 definition=dynamic_cast<Definition*>(output_definitions->GetObjectByOffset(i));
     22                definition=xDynamicCast<Definition*>(output_definitions->GetObjectByOffset(i));
    2323
    2424                char* name = definition->Name();

  • issm/trunk-jpl/src/c/modules/ResetFSBasalBoundaryConditionx/ResetFSBasalBoundaryConditionx.cpp

    r17322 r18521  
    1212
    1313        for (int i=0;i<elements->Size();i++){
    14                 element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     14                element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1515                element->ResetFSBasalBoundaryCondition();
    1616        }

  • issm/trunk-jpl/src/c/modules/RheologyBbarAbsGradientx/RheologyBbarAbsGradientx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=RheologyBbarAbsGradient(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp

    r17700 r18521  
    2222
    2323        for(i=0;i<elements->Size();i++){
    24                 Element    *element  = dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     24                Element    *element  = xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    2525                int         numnodes = element->GetNumberOfNodes();
    2626                IssmDouble *mask     = xNew<IssmDouble>(numnodes);
    … …  
    104104        /*Fill vector with values: */
    105105        for(i=0;i<femmodel->elements->Size();i++){
    106                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     106                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    107107                SetMaskOfIceElement(vec_mask_ice, element);
    108108        }

  • issm/trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=SurfaceAbsVelMisfit(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/SurfaceAreax/SurfaceAreax.cpp

    r15849 r18521  
    2020        /*Compute gradients: */
    2121        for(int i=0;i<femmodel->elements->Size();i++){
    22                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     22                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2323                S+=element->SurfaceArea();
    2424        }

  • issm/trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp

    r17976 r18521  
    1717        /*Compute Misfit: */
    1818        for(int i=0;i<femmodel->elements->Size();i++){
    19                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     19                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    2020                J+=SurfaceAverageVelMisfit(element);
    2121        }

  • issm/trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=SurfaceLogVelMisfit(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=SurfaceLogVxVyMisfit(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp

    r18266 r18521  
    6464        /*Loop over all the elements of this partition*/
    6565        for(int i=0;i<femmodel->elements->Size();i++){
    66                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     66                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    6767
    6868                /*Allocate all arrays*/
    … …  
    113113
    114114        for(int i=0;i<femmodel->elements->Size();i++){
    115                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     115                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    116116                element->Delta18oParameterization();
    117117        }
    … …  
    204204
    205205        for(i=0;i<femmodel->elements->Size();i++){
    206                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     206                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    207207                element->PositiveDegreeDay(pdds,pds,signorm);
    208208        }
    … …  
    234234        /*Loop over all the elements of this partition*/
    235235        for(int i=0;i<femmodel->elements->Size();i++){
    236                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     236                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    237237
    238238                /*Get reference SMB (uncorrected) and allocate all arrays*/
    … …  
    292292        /*Loop over all the elements of this partition*/
    293293        for(int i=0;i<femmodel->elements->Size();i++){
    294                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     294                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    295295
    296296                /*Allocate all arrays*/
    … …  
    333333        /*Loop over all the elements of this partition*/
    334334        for(int i=0;i<femmodel->elements->Size();i++){
    335                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     335                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    336336
    337337                /*Allocate all arrays*/

  • issm/trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=SurfaceRelVelMisfit(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r17492 r18521  
    4040                /*Get complete stiffness matrix without penalties*/
    4141                for (i=0;i<femmodel->elements->Size();i++){
    42                         element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     42                        element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    4343                        ElementMatrix* Ke = analysis->CreateKMatrix(element);
    4444                        ElementVector* pe = analysis->CreatePVector(element);
    … …  
    5050
    5151                for (i=0;i<femmodel->loads->Size();i++){
    52                         load=dynamic_cast<Load*>(femmodel->loads->GetObjectByOffset(i));
     52                        load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    5353                        if(load->InAnalysis(configuration_type)) load->CreateKMatrix(Kff_temp,NULL);
    5454                }
    … …  
    7171        /*Fill stiffness matrix and load vector from elements*/
    7272        for (i=0;i<femmodel->elements->Size();i++){
    73                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     73                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    7474                ElementMatrix* Ke = analysis->CreateKMatrix(element);
    7575                ElementVector* pe = analysis->CreatePVector(element);
    … …  
    8585        /*Fill stiffness matrix and load vector from loads*/
    8686        for(i=0;i<femmodel->loads->Size();i++){
    87                 load=dynamic_cast<Load*>(femmodel->loads->GetObjectByOffset(i));
     87                load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    8888                if(load->InAnalysis(configuration_type)){
    8989                        load->CreateKMatrix(Kff,Kfs);
    … …  
    9595        if(femmodel->loads->IsPenalty(configuration_type)){
    9696                for (i=0;i<femmodel->loads->Size();i++){
    97                         load=dynamic_cast<Load*>(femmodel->loads->GetObjectByOffset(i));
     97                        load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    9898                        if(load->InAnalysis(configuration_type)){
    9999                                load->PenaltyCreateKMatrix(Kff,Kfs,kmax);
    … …  
    106106        if(pdf){
    107107                for(i=0;i<femmodel->elements->Size();i++){
    108                         element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     108                        element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    109109                        ElementVector* de=analysis->CreateDVector(element);
    110110                        if(de) de->InsertIntoGlobal(df);

  • issm/trunk-jpl/src/c/modules/ThicknessAbsMisfitx/ThicknessAbsMisfitx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=ThicknessAbsMisfit(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/ThicknessAcrossGradientx/ThicknessAcrossGradientx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=ThicknessAcrossGradient(element);
    2020        }

  • issm/trunk-jpl/src/c/modules/ThicknessAlongGradientx/ThicknessAlongGradientx.cpp

    r17976 r18521  
    1616        /*Compute Misfit: */
    1717        for(int i=0;i<elements->Size();i++){
    18                 Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     18                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1919                J+=ThicknessAlongGradient(element);
    2020        }

  • issm/trunk-jpl/src/c/shared/Numerics/recast.h

    r14975 r18521  
    4040#endif
    4141
     42/*Morlighem's change: we do not want dynamic_casts because of performance
     43 * issue, so for now, we just use C-like cast*/
     44template<class To,class From> To xDynamicCast(const From& from) {
     45
     46        /*C-like cast (fast but not safe)*/
     47        return (To) from;
     48
     49        /*C++ dynamic_cast, poor performance but safer*/
     50        //return dynamic_cast<To>(from);
     51}
     52
    4253#endif

  • issm/trunk-jpl/src/c/toolkits/gsl/DenseGslSolve.cpp

    r17343 r18521  
    235235        IssmPDouble* pdoubleEDFout=xNew<IssmPDouble>(n);           // provide space to transfer outputs during call_ext_fct
    236236        // call the wrapped solver through the registry entry we retrieve from parameters
    237         call_ext_fct(dynamic_cast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
     237        call_ext_fct(xDynamicCast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
    238238                     n*(n+1), pdoubleEDFin, adoubleEDFin,
    239239                     n, pdoubleEDFout,X);

  • issm/trunk-jpl/src/c/toolkits/mumps/MpiDenseMumpsSolve.cpp

    r16259 r18521  
    244244  IssmPDouble *passiveSol=xNew<IssmPDouble>(n);
    245245  IssmDouble *sol=xNew<IssmDouble>(n);
    246   call_ext_fct(dynamic_cast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
     246  call_ext_fct(xDynamicCast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
    247247               packedDimsSparseArrLength, packedDimsSparseArr,
    248248               local_nnz+n, passivePack_A_rhs, pack_A_rhs,

  • issm/trunk-jpl/src/c/toolkits/mumps/MumpsSolve.cpp

    r17924 r18521  
    324324  IssmPDouble *passiveSol=xNew<IssmPDouble>(n);
    325325  IssmDouble *sol=xNew<IssmDouble>(n);
    326   call_ext_fct(dynamic_cast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
     326  call_ext_fct(xDynamicCast<GenericParam<Adolc_edf> * >(parameters->FindParamObject(AdolcParamEnum))->GetParameterValue().myEDF_for_solverx_p,
    327327               packedDimsSparseArrLength, packedDimsSparseArr,
    328328               local_nnz+n, passivePack_A_rhs, pack_A_rhs,
Note: See TracChangeset for help on using the changeset viewer.