Changeset 25539


Ignore:
Timestamp:
09/07/20 03:12:14 (5 years ago)
Author:
bdef
Message:

CHG:Modifying loop on elements towards for on iterator

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

Legend:

Unmodified
Added
Removed

  • TabularUnified issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp

    r25439 r25539  
    6666
    6767   /*First, reset all F to 0 */
    68         for(int i=0;i<elements->Size();i++){
    69                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     68        for(Object* & object : elements->objects){
     69                Element*       element = xDynamicCast<Element*>(object);
    7070                element->SetElementInput(inputs,DamageFEnum,0.);
    7171        }
    … …  
    150150        IssmDouble principalDevStress1, principalDevStress2;
    151151        IssmDouble tensileStress, compressiveStress;
    152        
     152
    153153        int equivstress, domaintype, dim;
    154154
    … …  
    197197        for (int i=0;i<numnodes;i++){
    198198                f[i] = 0;
    199                
     199
    200200                gauss->GaussNode(element->GetElementType(),i);
    201201
    … …  
    566566                                                Ke->values[i*numnodes+j] += (
    567567                                                                        dbasis[0*numnodes+i] *(D[0*dim+0]*dbasis[0*numnodes+j] + D[0*dim+1]*dbasis[1*numnodes+j]) +
    568                                                                         dbasis[1*numnodes+i] *(D[1*dim+0]*dbasis[0*numnodes+j] + D[1*dim+1]*dbasis[1*numnodes+j]) 
     568                                                                        dbasis[1*numnodes+i] *(D[1*dim+0]*dbasis[0*numnodes+j] + D[1*dim+1]*dbasis[1*numnodes+j])
    569569                                                                        );
    570570                                        }
    … …  
    586586                                                                        dbasis[0*numnodes+i] *(D[0*dim+0]*dbasis[0*numnodes+j] + D[0*dim+1]*dbasis[1*numnodes+j] + D[0*dim+2]*dbasis[2*numnodes+j]) +
    587587                                                                        dbasis[1*numnodes+i] *(D[1*dim+0]*dbasis[0*numnodes+j] + D[1*dim+1]*dbasis[1*numnodes+j] + D[1*dim+2]*dbasis[2*numnodes+j]) +
    588                                                                         dbasis[2*numnodes+i] *(D[2*dim+0]*dbasis[0*numnodes+j] + D[2*dim+1]*dbasis[1*numnodes+j] + D[2*dim+2]*dbasis[2*numnodes+j]) 
     588                                                                        dbasis[2*numnodes+i] *(D[2*dim+0]*dbasis[0*numnodes+j] + D[2*dim+1]*dbasis[1*numnodes+j] + D[2*dim+2]*dbasis[2*numnodes+j])
    589589                                                                        );
    590590                                        }
    … …  
    816816
    817817        /*Create and assemble matrix*/
    818         for(int i=0;i<femmodel->elements->Size();i++){
    819                 Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     818        for(Object* & object : femmodel->elements->objects){
     819                Element*       element = xDynamicCast<Element*>(object);
    820820                ElementMatrix* Ke     = this->CreateFctKMatrix(element);
    821821                if(Ke) Ke->AddToGlobal(Kff,Kfs);
    … …  
    841841
    842842        /*Create and assemble matrix*/
    843         for(int i=0;i<femmodel->elements->Size();i++){
    844                 Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     843        for(Object* & object : femmodel->elements->objects){
     844                Element*       element = xDynamicCast<Element*>(object);
    845845                ElementMatrix* MLe     = this->CreateMassMatrix(element);
    846846                if(MLe){

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

    r25437 r25539  
    301301        if(frictionlaw==9){
    302302                parameters->AddObject(iomodel->CopyConstantObject("md.friction.gamma",FrictionGammaEnum));
    303                 parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));         
     303                parameters->AddObject(iomodel->CopyConstantObject("md.friction.effective_pressure_limit",FrictionEffectivePressureLimitEnum));
    304304                parameters->AddObject(new IntParam(FrictionCouplingEnum,0));
    305305        }
    … …  
    355355void           EnthalpyAnalysis::ComputeBasalMeltingrate(FemModel* femmodel){/*{{{*/
    356356        /*Compute basal melting rates: */
    357         for(int i=0;i<femmodel->elements->Size();i++){
    358                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     357        for(Object* & object : femmodel->elements->objects){
     358                Element* element=xDynamicCast<Element*>(object);
    359359                ComputeBasalMeltingrate(element);
    360360        }
    … …  
    434434
    435435        IssmDouble watercolumnupperlimit = element->FindParam(ThermalWatercolumnUpperlimitEnum);
    436        
     436
    437437        Gauss* gauss=element->NewGauss();
    438438        for(is=0;is<numsegments;is++){
    … …  
    580580        IssmDouble  h,hx,hy,hz,vx,vy,vz;
    581581        IssmDouble  tau_parameter,diameter;
    582         IssmDouble  tau_parameter_anisotropic[2],tau_parameter_hor,tau_parameter_ver;   
     582        IssmDouble  tau_parameter_anisotropic[2],tau_parameter_hor,tau_parameter_ver;
    583583        IssmDouble  D_scalar;
    584584        IssmDouble* xyz_list = NULL;
    … …  
    670670                                                                dbasis[0*numnodes+i] *(K[0][0]*dbasis[0*numnodes+j] + K[0][1]*dbasis[1*numnodes+j]+ K[0][2]*dbasis[2*numnodes+j]) +
    671671                                                                dbasis[1*numnodes+i] *(K[1][0]*dbasis[0*numnodes+j] + K[1][1]*dbasis[1*numnodes+j]+ K[1][2]*dbasis[2*numnodes+j]) +
    672                                                                 dbasis[2*numnodes+i] *(K[2][0]*dbasis[0*numnodes+j] + K[2][1]*dbasis[1*numnodes+j]+ K[2][2]*dbasis[2*numnodes+j]) 
     672                                                                dbasis[2*numnodes+i] *(K[2][0]*dbasis[0*numnodes+j] + K[2][1]*dbasis[1*numnodes+j]+ K[2][2]*dbasis[2*numnodes+j])
    673673                                                                );
    674674                                }
    … …  
    678678                else if(stabilization==2){
    679679                        element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    680                         diameter=element->MinEdgeLength(xyz_list);                     
     680                        diameter=element->MinEdgeLength(xyz_list);
    681681                        tau_parameter=element->StabilizationParameter(u-um,v-vm,w-wm,diameter,kappa/rho_ice);
    682682                        for(int i=0;i<numnodes;i++){
    … …  
    699699                else if(stabilization==3){
    700700                        element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    701                         element->ElementSizes(&hx,&hy,&hz);                     
     701                        element->ElementSizes(&hx,&hy,&hz);
    702702                        element->StabilizationParameterAnisotropic(&tau_parameter_anisotropic[0],u-um,v-vm,w-wm,hx,hy,hz,kappa/rho_ice);
    703703                        tau_parameter_hor=tau_parameter_anisotropic[0];
    … …  
    873873                        for(i=0;i<numnodes;i++) pe->values[i]+=scalar_transient*basis[i];
    874874                }
    875                
     875
    876876                /* SUPG */
    877877                if(stabilization==2){
    … …  
    10741074void                            EnthalpyAnalysis::ComputeWaterfractionDrainage(FemModel* femmodel){/*{{{*/
    10751075
    1076         int i,k,numnodes;
     1076        int k,numnodes;
    10771077        IssmDouble dt;
    10781078        Element* element= NULL;
    … …  
    10801080        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    10811081
    1082         for(i=0;i<femmodel->elements->Size();i++){
    1083                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1082        for(Object* & object : femmodel->elements->objects){
     1083                element=xDynamicCast<Element*>(object);
    10841084                numnodes=element->GetNumberOfNodes();
    10851085                IssmDouble* waterfractions= xNew<IssmDouble>(numnodes);
    … …  
    10991099void                            EnthalpyAnalysis::DrainageUpdateWatercolumn(FemModel* femmodel){/*{{{*/
    11001100
    1101         int i,k,numnodes, numbasalnodes;
     1101        int k,numnodes, numbasalnodes;
    11021102        IssmDouble dt;
    11031103        int* basalnodeindices=NULL;
    … …  
    11131113        extrudefrombase_core(femmodel);
    11141114        /*multiply depth-average by ice thickness*/
    1115         for(i=0;i<femmodel->elements->Size();i++){
    1116                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1115        for(Object* & object : femmodel->elements->objects){
     1116                element=xDynamicCast<Element*>(object);
    11171117                numnodes=element->GetNumberOfNodes();
    11181118                IssmDouble* drainage_int= xNew<IssmDouble>(numnodes);
    … …  
    11321132
    11331133        /*update water column*/
    1134         for(i=0;i<femmodel->elements->Size();i++){
    1135                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1134        for(Object* & object : femmodel->elements->objects){
     1135                element=xDynamicCast<Element*>(object);
    11361136                /* Check if ice in element */
    11371137                if(!element->IsIceInElement()) continue;
    … …  
    11581158void                            EnthalpyAnalysis::DrainageUpdateEnthalpy(FemModel* femmodel){/*{{{*/
    11591159
    1160         int i,k,numnodes;
     1160        int k,numnodes;
    11611161        IssmDouble dt;
    11621162        Element* element= NULL;
    11631163        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    11641164
    1165         for(i=0;i<femmodel->elements->Size();i++){
    1166                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1165        for(Object* & object : femmodel->elements->objects){
     1166                element=xDynamicCast<Element*>(object);
    11671167                numnodes=element->GetNumberOfNodes();
    11681168                IssmDouble* enthalpies= xNew<IssmDouble>(numnodes);
    … …  
    11821182                        else
    11831183                                waterfractions[k]-=dt*drainage[k];
    1184                        
     1184
    11851185                        element->ThermalToEnthalpy(&enthalpies[k], temperatures[k], waterfractions[k], pressures[k]);
    11861186                }
    … …  
    16081608                                }
    16091609                        case LliboutryDuvalEnum:{
    1610                                 for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n[i],element->FindParam(MaterialsBetaEnum),element->FindParam(ConstantsReferencetemperatureEnum),element->FindParam(MaterialsHeatcapacityEnum),element->FindParam(MaterialsLatentheatEnum)); 
    1611                                 element->AddInput(MaterialsRheologyBEnum,&B[0],finite_element); 
    1612                                 break; 
     1610                                for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n[i],element->FindParam(MaterialsBetaEnum),element->FindParam(ConstantsReferencetemperatureEnum),element->FindParam(MaterialsHeatcapacityEnum),element->FindParam(MaterialsLatentheatEnum));
     1611                                element->AddInput(MaterialsRheologyBEnum,&B[0],finite_element);
     1612                                break;
    16131613                                }
    16141614                        default: _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
    … …  
    16701670        spc=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes());
    16711671        /*First create a vector to figure out what elements should be constrained*/
    1672         for(int i=0;i<femmodel->elements->Size();i++){
    1673                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1672        for(Object* & object : femmodel->elements->objects){
     1673                Element* element=xDynamicCast<Element*>(object);
    16741674                GetBasalConstraints(spc,element);
    16751675        }
    … …  
    16811681
    16821682        /*Then update basal constraints nodes accordingly*/
    1683         for(int i=0;i<femmodel->elements->Size();i++){
    1684                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1683        for(Object* & object : femmodel->elements->objects){
     1684                Element* element=xDynamicCast<Element*>(object);
    16851685                ApplyBasalConstraints(serial_spc,element);
    16861686        }

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

    r25439 r25539  
    291291void           ExtrapolationAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    292292
    293         for(int i=0;i<femmodel->elements->Size();i++){
    294                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     293        for(Object* & object : femmodel->elements->objects){
     294                Element* element=xDynamicCast<Element*>(object);
    295295                this->SetConstraintsOnIce(element);
    296296        }

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

    r25439 r25539  
    357357        IssmDouble phi,isonbase,base;
    358358
    359         for(int i=0;i<femmodel->elements->Size();i++){
    360 
    361                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     359        for(Object* & object : femmodel->elements->objects){
     360
     361                Element* element=xDynamicCast<Element*>(object);
    362362                if(!element->IsOnBase()) continue;
    363363

  • TabularUnified issm/trunk-jpl/src/c/analyses/GLheightadvectionAnalysis.cpp

    r25439 r25539  
    208208
    209209        /*Constrain all nodes that are grounded and unconstrain the ones that float*/
    210         for(int i=0;i<femmodel->elements->Size();i++){
    211                 Element    *element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     210        for(Object* & object : femmodel->elements->objects){
     211                Element    *element  = xDynamicCast<Element*>(object);
    212212                int         numnodes  = element->GetNumberOfNodes();
    213213                IssmDouble *mask      = xNew<IssmDouble>(numnodes);

  • TabularUnified issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp

    r25491 r25539  
    536536void HydrologyDCEfficientAnalysis::ComputeEPLThickness(FemModel* femmodel){/*{{{*/
    537537
    538         bool        active_element;
    539         int         iseplthickcomp;
    540         int         domaintype;
    541 
    542         femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
     538        int iseplthickcomp;
     539
     540
     541        /*Skip if we don't want to compute thicknesses*/
    543542        femmodel->parameters->FindParam(&iseplthickcomp,HydrologydcEplThickCompEnum);
    544543        if(iseplthickcomp==0) return;
    545544
    546         for(int j=0;j<femmodel->elements->Size();j++){
    547 
    548                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     545        /*Get Parameters*/
     546        int        domaintype;
     547        IssmDouble max_thick;
     548        IssmDouble epl_conductivity;
     549        IssmDouble latentheat;
     550        IssmDouble rho_ice;
     551        IssmDouble rho_water;
     552        IssmDouble gravity;
     553        IssmDouble dt;
     554
     555        femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
     556        femmodel->parameters->FindParam(&max_thick,HydrologydcEplMaxThicknessEnum);
     557        femmodel->parameters->FindParam(&epl_conductivity,HydrologydcEplConductivityEnum);
     558        femmodel->parameters->FindParam(&latentheat,MaterialsLatentheatEnum);
     559        femmodel->parameters->FindParam(&rho_ice,MaterialsRhoIceEnum);
     560        femmodel->parameters->FindParam(&rho_water,MaterialsRhoFreshwaterEnum);
     561        femmodel->parameters->FindParam(&gravity,ConstantsGEnum);
     562        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
     563
     564
     565        for(Object* & object : femmodel->elements->objects){
     566      Element* element = xDynamicCast<Element*>(object);
    549567
    550568                /*skip element if 3d and not on base*/
    … …  
    562580                IssmDouble* bed           = xNew<IssmDouble>(numnodes);
    563581
     582                bool       active_element;
     583                IssmDouble init_thick;
    564584                element->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    565 
    566                 /*parameters*/
    567                 IssmDouble gravity;
    568                 IssmDouble rho_water;
    569                 IssmDouble rho_ice;
    570                 IssmDouble latentheat;
    571                 IssmDouble epl_conductivity;
    572                 IssmDouble init_thick;
    573                 IssmDouble max_thick;
    574                 IssmDouble dt;
    575585
    576586                /* Intermiedaries */
    … …  
    593603                                default: _error_("not Implemented Yet");
    594604                        }
    595 
    596                         element->FindParam(&max_thick,HydrologydcEplMaxThicknessEnum);
    597                         element->FindParam(&epl_conductivity,HydrologydcEplConductivityEnum);
    598                         element->FindParam(&latentheat,MaterialsLatentheatEnum);
    599                         element->FindParam(&rho_ice,MaterialsRhoIceEnum);
    600                         element->FindParam(&rho_water,MaterialsRhoFreshwaterEnum);
    601                         element->FindParam(&gravity,ConstantsGEnum);
    602                         element->FindParam(&dt,TimesteppingTimeStepEnum);
    603 
    604605                        element->GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
    605606                        element->GetInputListOnVertices(&epl_slopeX[0],EplHeadSlopeXEnum);

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

    r25489 r25539  
    451451void HydrologyDCInefficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    452452
    453         /*Intermediaries*/
     453        /*Intermediaries*/
     454        bool     converged;
     455        int*     doflist = NULL;
    454456        int      domaintype;
    455457        Element* basalelement=NULL;
    456         bool     converged;
    457         int*     doflist = NULL;
    458458
    459459        /*Get basal element*/
    … …  
    482482                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
    483483                if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in solution vector");
    484 
    485484        }
    486485
    … …  
    689688        Element* element=NULL;
    690689        int      elementssize=femmodel->elements->Size();
    691         for(int i=0;i<elementssize;i++){
    692                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    693 
     690        for(Object* & object : femmodel->elements->objects){
     691                element = xDynamicCast<Element*>(object);
    694692                Input* input=element->GetInput(HydrologydcMaskEplactiveNodeEnum); _assert_(input);
    695693                if(input->GetInputMax()>0.){
    … …  
    749747        Element* element=NULL;
    750748        int elementssize = femmodel->elements->Size();
    751         for(int i=0;i<elementssize;i++){
    752                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     749        for(Object* & object : femmodel->elements->objects){
     750                element = xDynamicCast<Element*>(object);
    753751
    754752                Input* input=element->GetInput(HydrologydcMaskThawedNodeEnum); _assert_(input);

  • TabularUnified issm/trunk-jpl/src/c/analyses/HydrologyGlaDSAnalysis.cpp

    r25437 r25539  
    456456void HydrologyGlaDSAnalysis::UpdateSheetThickness(FemModel* femmodel){/*{{{*/
    457457
    458         for(int j=0;j<femmodel->elements->Size();j++){
    459                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     458        for(Object* & object : femmodel->elements->objects){
     459                Element* element=xDynamicCast<Element*>(object);
    460460                UpdateSheetThickness(element);
    461461        }
    … …  
    545545void HydrologyGlaDSAnalysis::UpdateEffectivePressure(FemModel* femmodel){/*{{{*/
    546546
    547         for(int j=0;j<femmodel->elements->Size();j++){
    548                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     547        for(Object* & object : femmodel->elements->objects){
     548                Element* element=xDynamicCast<Element*>(object);
    549549                UpdateEffectivePressure(element);
    550550        }

  • TabularUnified issm/trunk-jpl/src/c/analyses/HydrologyPismAnalysis.cpp

    r25379 r25539  
    9292void HydrologyPismAnalysis::UpdateWaterColumn(FemModel* femmodel){/*{{{*/
    9393
    94         for(int j=0;j<femmodel->elements->Size();j++){
    95                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     94        for(Object* & object : femmodel->elements->objects){
     95                Element* element=xDynamicCast<Element*>(object);
    9696                this->UpdateWaterColumn(element);
    9797        }

  • TabularUnified issm/trunk-jpl/src/c/analyses/HydrologyShaktiAnalysis.cpp

    r25437 r25539  
    455455void HydrologyShaktiAnalysis::UpdateGapHeight(FemModel* femmodel){/*{{{*/
    456456
    457         for(int j=0;j<femmodel->elements->Size();j++){
    458                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     457        for(Object* & object : femmodel->elements->objects){
     458                Element* element=xDynamicCast<Element*>(object);
    459459                UpdateGapHeight(element);
    460460        }

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

    r25439 r25539  
    653653
    654654                /*Loop over all elements of this partition*/
    655                 for(int i=0;i<femmodel->elements->Size();i++){
    656                         Element* element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     655                for(Object* & object : femmodel->elements->objects){
     656                        Element* element  = xDynamicCast<Element*>(object);
    657657
    658658                        int      numnodes = element->GetNumberOfNodes();
    … …  
    690690
    691691                /*Loop over all elements of this partition*/
    692                 for(int i=0;i<femmodel->elements->Size();i++){
    693                         Element* element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     692                for(Object* & object : femmodel->elements->objects){
     693                        Element* element  = xDynamicCast<Element*>(object);
    694694
    695695                        rho_ice = element->FindParam(MaterialsRhoIceEnum);
    … …  
    739739                vec_constraint_nodes=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes());
    740740
    741                 for(int i=0;i<femmodel->elements->Size();i++){
    742                         Element* element               = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     741                for(Object* & object : femmodel->elements->objects){
     742                        Element* element               = xDynamicCast<Element*>(object);
    743743                        int      numnodes              = element->GetNumberOfNodes();
    744744                        Gauss*   gauss                 = element->NewGauss();
    … …  
    777777                while(nflipped){
    778778                        local_nflipped=0;
    779                         for(int i=0;i<femmodel->elements->Size();i++){
    780                                 Element* element                = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     779                        for(Object* & object : femmodel->elements->objects){
     780                                Element* element                = xDynamicCast<Element*>(object);
    781781                                int      numnodes               = element->GetNumberOfNodes();
    782782                                Gauss*   gauss                  = element->NewGauss();
    … …  
    831831
    832832                /*Contrain the nodes that will be calved*/
    833                 for(int i=0;i<femmodel->elements->Size();i++){
    834                         Element* element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     833                for(Object* & object : femmodel->elements->objects){
     834                        Element* element  = xDynamicCast<Element*>(object);
    835835                        int      numnodes = element->GetNumberOfNodes();
    836836                        Gauss*   gauss    = element->NewGauss();

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

    r25439 r25539  
    189189                        iomodel->FetchData(&array3d,&Ms,&Ns,&K,"md.basalforcings.tf");
    190190                        if(!array3d) _error_("md.basalforcings.tf not found in binary file");
    191                         for(int i=0;i<elements->Size();i++){
    192                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     191                        for(Object* & object : elements->objects){
     192                                Element*       element = xDynamicCast<Element*>(object);
    193193                                if(iomodel->domaintype!=Domain2DhorizontalEnum && !element->IsOnBase()) continue;
    194194                                for(int kk=0;kk<K;kk++){
    … …  
    418418                                                Ke->values[i*numnodes+j] += (
    419419                                                                        dbasis[0*numnodes+i] *(D[0*dim+0]*dbasis[0*numnodes+j] + D[0*dim+1]*dbasis[1*numnodes+j]) +
    420                                                                         dbasis[1*numnodes+i] *(D[1*dim+0]*dbasis[0*numnodes+j] + D[1*dim+1]*dbasis[1*numnodes+j]) 
     420                                                                        dbasis[1*numnodes+i] *(D[1*dim+0]*dbasis[0*numnodes+j] + D[1*dim+1]*dbasis[1*numnodes+j])
    421421                                                                        );
    422422                                        }
    … …  
    444444                        for(int i=0;i<numnodes;i++){
    445445                                for(int j=0;j<numnodes;j++){
    446                                         Ke->values[i*numnodes+j]+=gauss->weight*Jdet*tau*basis[j]*(vx*dbasis[0*numnodes+i]+vy*dbasis[1*numnodes+i]);   
     446                                        Ke->values[i*numnodes+j]+=gauss->weight*Jdet*tau*basis[j]*(vx*dbasis[0*numnodes+i]+vy*dbasis[1*numnodes+i]);
    447447                                }
    448448                        }
    … …  
    450450                        for(int i=0;i<numnodes;i++){
    451451                                for(int j=0;j<numnodes;j++){
    452                                         Ke->values[i*numnodes+j]+=gauss->weight*Jdet*tau*basis[j]*(basis[i]*dvxdx+basis[i]*dvydy);     
    453                                 }
    454                         }
    455                        
     452                                        Ke->values[i*numnodes+j]+=gauss->weight*Jdet*tau*basis[j]*(basis[i]*dvxdx+basis[i]*dvydy);
     453                                }
     454                        }
     455
    456456                        /*Advection matrix - part 2, A*/
    457457                        for(int i=0;i<numnodes;i++){
    … …  
    476476                        for(int i=0;i<numnodes;i++){
    477477            for(int j=0;j<numnodes;j++){
    478                                         Ke->values[i*numnodes+j]+=dt*gauss->weight*Jdet*tau*(basis[j]*dvxdx+basis[j]*dvydy)*(basis[i]*dvxdx+basis[i]*dvydy);   
     478                                        Ke->values[i*numnodes+j]+=dt*gauss->weight*Jdet*tau*(basis[j]*dvxdx+basis[j]*dvydy)*(basis[i]*dvxdx+basis[i]*dvydy);
    479479                                }
    480480                        }
    … …  
    600600                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    601601        }
    602          
     602
    603603        /*Fetch number of nodes and dof for this finite element*/
    604604        int numnodes = element->GetNumberOfNodes();
    … …  
    626626//              _error_("S");
    627627//      }
    628        
     628
    629629        h=element->CharacteristicLength();
    630        
     630
    631631        /*Recover portion of element that is grounded*/
    632632        phi=element->GetGroundedPortion(xyz_list);
    … …  
    670670
    671671                for(int i=0;i<numnodes;i++) pe->values[i]+=Jdet*gauss->weight*(thickness+dt*(ms-mb))*basis[i];
    672        
     672
    673673                if(stabilization==5){ //SUPG
    674674                        element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    … …  
    683683                        xi=1;
    684684                        tau=xi*h/(2*vel);
    685                        
     685
    686686                        /*Force vector - part 2*/
    687687                        for(int i=0;i<numnodes;i++){
    … …  
    693693                        }
    694694                }
    695        
     695
    696696        }
    697697
    … …  
    806806        for(int i=0;i<numnodes;i++){
    807807                newthickness[i]=solution[doflist[i]];
    808                 thicknessresidual[i]=0.;       
     808                thicknessresidual[i]=0.;
    809809                /*Check solution*/
    810810                if(xIsNan<IssmDouble>(newthickness[i])) _error_("NaN found in solution vector");
    … …  
    817817        element->AddBasalInput(ThicknessEnum,newthickness,element->GetElementType());
    818818        element->AddBasalInput(ThicknessResidualEnum,thicknessresidual,element->GetElementType());
    819        
     819
    820820        xDelete<int>(doflist);
    821821        xDelete<IssmDouble>(newthickness);
    … …  
    10421042                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    10431043        }
    1044          
     1044
    10451045        /*Fetch number of nodes and dof for this finite element*/
    10461046        int numnodes = element->GetNumberOfNodes();
    … …  
    10611061        Input* vxaverage_input  = element->GetInput(VxAverageEnum);                                                                             _assert_(vxaverage_input);
    10621062        Input* vyaverage_input  = element->GetInput(VyAverageEnum);                                                                             _assert_(vyaverage_input);
    1063        
     1063
    10641064        /*Recover portion of element that is grounded*/
    10651065        phi=element->GetGroundedPortion(xyz_list);
    … …  
    11021102
    11031103                for(int i=0;i<numnodes;i++) pe->values[i]+=Jdet*gauss->weight*(ms-mb)*basis[i];
    1104        
     1104
    11051105        }
    11061106
    … …  
    11221122
    11231123        /*Create and assemble matrix*/
    1124         for(int i=0;i<femmodel->elements->Size();i++){
    1125                 Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1124        for(Object* & object : femmodel->elements->objects){
     1125                Element*       element = xDynamicCast<Element*>(object);
    11261126                ElementMatrix* Ke     = this->CreateFctKMatrix(element);
    11271127                if(Ke) Ke->AddToGlobal(Kff,Kfs);
    … …  
    11491149
    11501150        /*Create and assemble matrix*/
    1151         for(int i=0;i<femmodel->elements->Size();i++){
    1152                 Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1151        for(Object* & object : femmodel->elements->objects){
     1152                Element*       element = xDynamicCast<Element*>(object);
    11531153                ElementVector* pe      = this->CreateFctPVector(element);
    11541154                if(pe) pe->AddToGlobal(pf);
    … …  
    11671167
    11681168        /*Create and assemble matrix*/
    1169         for(int i=0;i<femmodel->elements->Size();i++){
    1170                 Element*       element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     1169        for(Object* & object : femmodel->elements->objects){
     1170                Element*       element = xDynamicCast<Element*>(object);
    11711171                ElementMatrix* MLe     = this->CreateMassMatrix(element);
    11721172                if(MLe){

  • TabularUnified issm/trunk-jpl/src/c/analyses/SealevelriseAnalysis.cpp

    r25379 r25539  
    6565               
    6666                       
    67                 for(int i=0;i<elements->Size();i++){
    68                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     67                for(Object* & object : elements->objects){
     68                        Element* element=xDynamicCast<Element*>(object);
    6969
    7070                        for(int t=0;t<N;t++){
    … …  
    113113                        TransientInput* transientinput=inputs->SetDatasetTransientInput(DslGlobalAverageThermostericSeaLevelChangeEnum,i, times,N);
    114114                       
    115                         for(int j=0;j<elements->Size();j++){
    116                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     115                        for(Object* & object : elements->objects){
     116                                Element* element=xDynamicCast<Element*>(object);
    117117
    118118                                for(int t=0;t<N;t++){

  • TabularUnified issm/trunk-jpl/src/c/analyses/SmbAnalysis.cpp

    r25379 r25539  
    129129                                        int* ids = xNew<int>(N); for(int i=0;i<N;i++) ids[i] = i;
    130130
    131                                         for(int i=0;i<elements->Size();i++){
    132                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     131                                        for(Object* & object : elements->objects){
     132                                                Element* element=xDynamicCast<Element*>(object);
    133133                                                element->DatasetInputCreate(doublearray,M-1,N,ids,N,inputs,iomodel,SmbTemperaturesReconstructedEnum);
    134134                                        }
    … …  
    147147                                        int* ids = xNew<int>(N); for(int i=0;i<N;i++) ids[i] = i;
    148148
    149                                         for(int i=0;i<elements->Size();i++){
    150                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     149                                        for(Object* & object : elements->objects){
     150                                                Element* element=xDynamicCast<Element*>(object);
    151151                                                element->DatasetInputCreate(doublearray,M-1,N,ids,N,inputs,iomodel,SmbPrecipitationsReconstructedEnum);
    152152                                        }

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

    r25514 r25539  
    58925892        parameters->FindParam(&dim,DomainDimensionEnum);
    58935893
    5894         for(int i=0;i<elements->Size();i++){
    5895                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5894        for(Object* & object : elements->objects){
     5895                Element* element=xDynamicCast<Element*>(object);
    58965896
    58975897                /*Get inputs and parameters*/
    … …  
    60646064        else       tausize = 6;
    60656065
    6066         for(int i=0;i<elements->Size();i++){
    6067                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     6066        for(Object* & object : elements->objects){
     6067                Element* element=xDynamicCast<Element*>(object);
    60686068
    60696069                /*Get inputs and parameters*/
    … …  
    62766276        else       tausize = 6;
    62776277
    6278         for(int i=0;i<elements->Size();i++){
    6279                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     6278        for(Object* & object : elements->objects){
     6279                Element* element=xDynamicCast<Element*>(object);
    62806280
    62816281                /*Get inputs and parameters*/

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

    r25508 r25539  
    9999        IssmDouble J_sum=0.;
    100100
    101         for(int i=0;i<femmodel->elements->Size();i++){
    102                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     101        for(Object* & object : femmodel->elements->objects){
     102                Element* element=xDynamicCast<Element*>(object);
    103103                J+=this->Cfdragcoeffabsgrad_Calculation(element,weights_enum);
    104104        }

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

    r25508 r25539  
    104104        IssmDouble J_sum=0.;
    105105        if(this->datatime<=time && !timepassedflag){
    106                 for(int i=0;i<femmodel->elements->Size();i++){
    107                         Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     106                for(Object* & object : femmodel->elements->objects){
     107                        Element* element=xDynamicCast<Element*>(object);
    108108                        J+=this->Cfsurfacelogvel_Calculation(element,definitionenum);
    109109                }

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

    r25508 r25539  
    113113
    114114         if(datatime<=time && !timepassedflag){
    115                  for(int i=0;i<femmodel->elements->Size();i++){
    116                          Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     115                 for(Object* & object : femmodel->elements->objects){
     116                         Element* element=xDynamicCast<Element*>(object);
    117117                         J+=this->Cfsurfacesquare_Calculation(element,model_enum,observation_enum,weights_enum);
    118118                 }

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

    r25507 r25539  
    34003400        /*Intermediaries*/
    34013401        const int numnodes = this->GetNumberOfNodes();
    3402 
    34033402        /*Output */
    34043403        int d_nz = 0;

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

    r25533 r25539  
    110110                for(int i=0;i<this->nummodels;i++) if(this->analysis_type_list[i]==StressbalanceAnalysisEnum){analysis_counter=i;break;}
    111111                if(analysis_counter==-1) _error_("Could not find alias for analysis_type StressbalanceAnalysisEnum in list of FemModel analyses\n");
    112                 for(int i=0;i<this->elements->Size();i++){
    113                         Element* element        = xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     112                for(Object* & object : this->elements->objects){
     113                        Element* element = xDynamicCast<Element*>(object);
    114114                        element_type            = element->element_type_list[analysis_counter];
    115115                        if(element_type!=P1Enum) _error_("Element type "<<EnumToStringx(element_type)<<" not supported with AMR yet!\n");
    … …  
    980980                if(profiler->Used(MPISERIAL)) _printf0_("   "<<setw(40)<<left<<"MPISERIAL elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(MPISERIAL) << " sec\n");
    981981
     982                if(profiler->Used(SEDLOOP)) _printf0_("   "<<setw(40)<<left<<"SedimentLoop elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(SEDLOOP) << " sec\n");
     983                if(profiler->Used(SEDMatrix)) _printf0_("   "<<setw(40)<<left<<"SedimentMatrix elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(SEDMatrix) << " sec\n");
     984                if(profiler->Used(SEDUpdate)) _printf0_("   "<<setw(40)<<left<<"SedimentUpdate elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(SEDUpdate) << " sec\n");
     985                if(profiler->Used(EPLLOOP)) _printf0_("   "<<setw(40)<<left<<"EplLoop elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(EPLLOOP) << " sec\n");
     986                if(profiler->Used(EPLMasking)) _printf0_("   "<<setw(40)<<left<<"EPL masking elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(EPLMasking) << " sec\n");
     987                if(profiler->Used(EPLMatrices)) _printf0_("   "<<setw(40)<<left<<"EPLMatrices elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(EPLMatrices) << " sec\n");
     988                if(profiler->Used(EPLUpdate)) _printf0_("   "<<setw(40)<<left<<"EPLUpdate elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(EPLUpdate) << " sec\n");
     989
    982990                /*Add to results: */
    983991                results->AddObject(new GenericExternalResult<IssmDouble>(results->Size()+1, ProfilingSolutionTimeEnum,  solution_time));
    … …  
    10131021
    10141022        /*Compute Misfit: */
    1015         for(int i=0;i<elements->Size();i++){
    1016                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1023        for(Object* & object : this->elements->objects){
     1024      Element* element = xDynamicCast<Element*>(object);
    10171025
    10181026                /*If on water, return 0: */
    … …  
    10691077void FemModel::CalvingRateVonmisesx(){/*{{{*/
    10701078
    1071         for(int i=0;i<elements->Size();i++){
    1072                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1079        for(Object* & object : this->elements->objects){
     1080      Element* element = xDynamicCast<Element*>(object);
    10731081                element->CalvingRateVonmises();
    10741082        }
    … …  
    10771085void FemModel::CalvingRateLevermannx(){/*{{{*/
    10781086
    1079         for(int i=0;i<elements->Size();i++){
    1080                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1087        for(Object* & object : this->elements->objects){
     1088      Element* element = xDynamicCast<Element*>(object);
    10811089                element->CalvingRateLevermann();
    10821090        }
    … …  
    10851093void FemModel::CalvingFluxLevelsetx(){/*{{{*/
    10861094
    1087         for(int i=0;i<elements->Size();i++){
    1088                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1095        for(Object* & object : this->elements->objects){
     1096      Element* element = xDynamicCast<Element*>(object);
    10891097                element->CalvingFluxLevelset();
    10901098        }
    … …  
    10931101void FemModel::CalvingMeltingFluxLevelsetx(){/*{{{*/
    10941102
    1095         for(int i=0;i<elements->Size();i++){
    1096                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1103        for(Object* & object : this->elements->objects){
     1104      Element* element = xDynamicCast<Element*>(object);
    10971105                element->CalvingMeltingFluxLevelset();
    10981106        }
    … …  
    11341142void FemModel::DeviatoricStressx(){/*{{{*/
    11351143
    1136         for(int i=0;i<elements->Size();i++){
    1137                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1144        for(Object* & object : this->elements->objects){
     1145      Element* element = xDynamicCast<Element*>(object);
    11381146                element->ComputeDeviatoricStressTensor();
    11391147        }
    … …  
    11531161         * segments we have (corresopnding to field = value)*/
    11541162        DataSet* segments=new DataSet();
    1155         for(int i=0;i<elements->Size();i++){
    1156                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1163        for(Object* & object : this->elements->objects){
     1164      Element* element = xDynamicCast<Element*>(object);
    11571165                if(!element->IsOnBase()) continue;
    11581166                Element* basalelement = element->SpawnBasalElement();
    … …  
    11921200        IssmDouble  d,xn,yn,dmin;
    11931201        int         last = -1;
    1194         for(int v=0;v<vertices->Size();v++){
    1195 
    1196                 Vertex* vertex=dynamic_cast<Vertex*>(this->vertices->GetObjectByOffset(v));
     1202        for(Object* & object : this->vertices->objects){
     1203      Vertex* vertex= xDynamicCast<Vertex*>(object);
    11971204                IssmDouble x = vertex->x;
    11981205                IssmDouble y = vertex->y;
    … …  
    12541261        }
    12551262
    1256         for(int i=0;i<this->elements->Size();i++){
    1257                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1263        for(Object* & object : this->elements->objects){
     1264      Element* element= xDynamicCast<Element*>(object);
    12581265                element->CreateDistanceInputFromSegmentlist(distances,distanceenum);
    12591266        }
    … …  
    12691276        IssmDouble total_divergence;
    12701277
    1271         for(int i=0;i<this->elements->Size();i++){
    1272                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1278        for(Object* & object : this->elements->objects){
     1279      Element* element= xDynamicCast<Element*>(object);
    12731280                local_divergence+=element->Divergence();
    12741281        }
    … …  
    12821289void FemModel::ElementOperationx(void (Element::*function)(void)){ /*{{{*/
    12831290
    1284         for(int i=0;i<elements->Size();i++){
    1285                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1291        for(Object* & object : this->elements->objects){
     1292      Element* element= xDynamicCast<Element*>(object);
    12861293                (element->*function)();
    12871294        }
    … …  
    13031310
    13041311        /*now, go through our elements, and retrieve the one with this id: index: */
    1305         for(int i=0;i<this->elements->Size();i++){
    1306                 element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1312        for(Object* & object : this->elements->objects){
     1313      element= xDynamicCast<Element*>(object);
    13071314                if (element->Id()==index){
    13081315                        found=1;
    … …  
    13341341        IssmDouble total_floating_area;
    13351342
    1336         for(int i=0;i<this->elements->Size();i++){
    1337                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1343        for(Object* & object : this->elements->objects){
     1344      Element* element= xDynamicCast<Element*>(object);
    13381345                local_floating_area+=element->FloatingArea(scaled);
    13391346        }
    … …  
    13581365        }
    13591366
    1360         for(int i=0;i<this->elements->Size();i++){
    1361                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1367        for(Object* & object : this->elements->objects){
     1368      Element* element= xDynamicCast<Element*>(object);
    13621369                element->GetInputLocalMinMaxOnNodes(uLmin_local,uLmax_local,ug);
    13631370        }
    … …  
    15721579        IssmDouble total_grounded_area;
    15731580
    1574         for(int i=0;i<this->elements->Size();i++){
    1575                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1581        for(Object* & object : this->elements->objects){
     1582      Element* element= xDynamicCast<Element*>(object);
    15761583                local_grounded_area+=element->GroundedArea(scaled);
    15771584        }
    … …  
    15951602                IssmDouble total_icefront_area;
    15961603
    1597                 for(int i=0;i<this->elements->Size();i++){
    1598                         Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1604                for(Object* & object : this->elements->objects){
     1605                        Element* element= xDynamicCast<Element*>(object);
    15991606                        element->GetInputListOnVertices(BasinId,FrontalForcingsBasinIdEnum);
    16001607                        for(int j=0;j<numvertices;j++){
    … …  
    16211628        IssmDouble total_mass_flux;
    16221629
    1623         for(int i=0;i<this->elements->Size();i++){
    1624                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1630        for(Object* & object : this->elements->objects){
     1631                Element* element= xDynamicCast<Element*>(object);
    16251632                local_mass_flux+=element->IcefrontMassFlux(scaled);
    16261633        }
    … …  
    16371644        IssmDouble total_mass_flux;
    16381645
    1639         for(int i=0;i<this->elements->Size();i++){
    1640                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1646        for(Object* & object : this->elements->objects){
     1647                Element* element= xDynamicCast<Element*>(object);
    16411648                local_mass_flux+=element->IcefrontMassFluxLevelset(scaled);
    16421649        }
    … …  
    16531660        IssmDouble* P1DGlist = xNew<IssmDouble>(numvertices);
    16541661
    1655         for(int i=0;i<this->elements->Size();i++){
    1656                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1662        for(Object* & object : this->elements->objects){
     1663                Element* element= xDynamicCast<Element*>(object);
    16571664                element->GetInputListOnVertices(P1DGlist,enum_in);
    16581665                element->AddInput(DummyEnum,P1DGlist,P1DGEnum);
    … …  
    16811688        IssmDouble total_mass_flux;
    16821689
    1683         for(int i=0;i<this->elements->Size();i++){
    1684                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1690        for(Object* & object : this->elements->objects){
     1691                Element* element= xDynamicCast<Element*>(object);
    16851692                local_mass_flux+=element->GroundinglineMassFlux(scaled);
    16861693        }
    … …  
    16971704        IssmDouble total_ice_mass;
    16981705
    1699         for(int i=0;i<this->elements->Size();i++){
    1700                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1706        for(Object* & object : this->elements->objects){
     1707                Element* element= xDynamicCast<Element*>(object);
    17011708                local_ice_mass+=element->IceMass(scaled);
    17021709        }
    … …  
    17131720        IssmDouble total_ice_volume_af;
    17141721
    1715         for(int i=0;i<this->elements->Size();i++){
    1716                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1722        for(Object* & object : this->elements->objects){
     1723                Element* element= xDynamicCast<Element*>(object);
    17171724                local_ice_volume_af+=element->IceVolumeAboveFloatation(scaled);
    17181725        }
    … …  
    17291736        IssmDouble total_ice_volume;
    17301737
    1731         for(int i=0;i<this->elements->Size();i++){
    1732                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1738        for(Object* & object : this->elements->objects){
     1739                Element* element= xDynamicCast<Element*>(object);
    17331740                local_ice_volume+=element->IceVolume(scaled);
    17341741        }
    … …  
    17721779        for(i=0;i<num_segments;i++){
    17731780                element_id=reCast<int,IssmDouble>(*(segments+5*i+4));
    1774                 for(j=0;j<elements->Size();j++){
    1775                         element=(Element*)this->elements->GetObjectByOffset(j);
     1781                for(Object* & object : this->elements->objects){
     1782                        element = xDynamicCast<Element*>(object);
    17761783                        if (element->Id()==element_id){
    17771784                                /*We found the element which owns this segment, use it to compute the mass flux: */
    … …  
    18071814        /*Go through elements, and request velocity: */
    18081815        maxabsvx=-INFINITY;
    1809         for(i=0;i<this->elements->Size();i++){
    1810                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1816        for(Object* & object : this->elements->objects){
     1817                Element* element = xDynamicCast<Element*>(object);
    18111818                Input*  input = element->GetInput(VxEnum);
    18121819                element_maxabsvx=input->GetInputMaxAbs();
    … …  
    18321839        /*Go through elements, and request velocity: */
    18331840        maxabsvy=-INFINITY;
    1834         for(i=0;i<this->elements->Size();i++){
    1835                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1841        for(Object* & object : this->elements->objects){
     1842                Element* element = xDynamicCast<Element*>(object);
    18361843                Input*  input = element->GetInput(VyEnum);
    18371844                element_maxabsvy=input->GetInputMaxAbs();
    … …  
    18571864        /*Go through elements, and request velocity: */
    18581865        maxabsvz=-INFINITY;
    1859         for(i=0;i<this->elements->Size();i++){
    1860                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1866        for(Object* & object : this->elements->objects){
     1867                Element* element = xDynamicCast<Element*>(object);
    18611868                Input*  input = element->GetInput(VzEnum);
    18621869                element_maxabsvz=input->GetInputMaxAbs();
    … …  
    18791886        IssmDouble max_divergence = -INFINITY;
    18801887
    1881         for(int i=0;i<this->elements->Size();i++){
    1882                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1888        for(Object* & object : this->elements->objects){
     1889                Element* element = xDynamicCast<Element*>(object);
    18831890                local_divergence=element->Divergence();
    18841891                if(fabs(local_divergence)>max_divergence) max_divergence=fabs(local_divergence);
    … …  
    19011908        /*Go through elements, and request velocity: */
    19021909        maxvel=-INFINITY;
    1903         for(i=0;i<this->elements->Size();i++){
    1904                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1910        for(Object* & object : this->elements->objects){
     1911                Element* element = xDynamicCast<Element*>(object);
    19051912                Input* vel_input = element->GetInput(VelEnum); _assert_(vel_input);
    19061913                element_maxvel = vel_input->GetInputMax();
    … …  
    19261933        /*Go through elements, and request velocity: */
    19271934        maxvx=-INFINITY;
    1928         for(i=0;i<this->elements->Size();i++){
    1929                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1935        for(Object* & object : this->elements->objects){
     1936                Element* element = xDynamicCast<Element*>(object);
    19301937                Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    19311938                element_maxvx = vx_input->GetInputMax();
    … …  
    19511958        /*Go through elements, and request velocity: */
    19521959        maxvy=-INFINITY;
    1953         for(i=0;i<this->elements->Size();i++){
    1954                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1960        for(Object* & object : this->elements->objects){
     1961                Element* element = xDynamicCast<Element*>(object);
    19551962                Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
    19561963                element_maxvy = vy_input->GetInputMax();
    … …  
    19761983        /*Go through elements, and request velocity: */
    19771984        maxvz=-INFINITY;
    1978         for(i=0;i<this->elements->Size();i++){
    1979                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1985        for(Object* & object : this->elements->objects){
     1986                Element* element = xDynamicCast<Element*>(object);
    19801987                Input* vz_input = element->GetInput(VzEnum); _assert_(vz_input);
    19811988                element_maxvz = vz_input->GetInputMax();
    … …  
    20012008        /*Go through elements, and request velocity: */
    20022009        minvel=INFINITY;
    2003         for(i=0;i<this->elements->Size();i++){
    2004                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2010        for(Object* & object : this->elements->objects){
     2011                Element* element = xDynamicCast<Element*>(object);
    20052012                Input*  input = element->GetInput(VelEnum);
    20062013                element_minvel =input->GetInputMin();
    … …  
    20262033        /*Go through elements, and request velocity: */
    20272034        minvx=INFINITY;
    2028         for(i=0;i<this->elements->Size();i++){
    2029                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2035        for(Object* & object : this->elements->objects){
     2036                Element* element = xDynamicCast<Element*>(object);
    20302037                Input*  input = element->GetInput(VxEnum);
    20312038                element_minvx =input->GetInputMin();
    … …  
    20512058        /*Go through elements, and request velocity: */
    20522059        minvy=INFINITY;
    2053         for(i=0;i<this->elements->Size();i++){
    2054                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2060        for(Object* & object : this->elements->objects){
     2061                Element* element = xDynamicCast<Element*>(object);
    20552062                Input*  input = element->GetInput(VyEnum);
    20562063                element_minvy =input->GetInputMin();
    … …  
    20762083        /*Go through elements, and request velocity: */
    20772084        minvz=INFINITY;
    2078         for(i=0;i<this->elements->Size();i++){
    2079                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2085        for(Object* & object : this->elements->objects){
     2086                Element* element = xDynamicCast<Element*>(object);
    20802087                Input*  input = element->GetInput(VzEnum);
    20812088                element_minvz =input->GetInputMin();
    … …  
    21042111
    21052112        /*Compute Misfit: */
    2106         for(int i=0;i<elements->Size();i++){
    2107                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2113        for(Object* & object : this->elements->objects){
     2114                Element* element = xDynamicCast<Element*>(object);
    21082115
    21092116                /*If on water, return 0: */
    … …  
    21592166
    21602167        /*Compute Misfit: */
    2161         for(int i=0;i<elements->Size();i++){
    2162                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2168        for(Object* & object : this->elements->objects){
     2169                Element* element = xDynamicCast<Element*>(object);
    21632170
    21642171                /*If on water, return 0: */
    … …  
    22452252
    22462253                /*Fill in vector*/
    2247                 for(int j=0;j<elements->Size();j++){
    2248                         Element* element=(Element*)elements->GetObjectByOffset(j);
     2254                for(Object* & object : this->elements->objects){
     2255                        Element* element = xDynamicCast<Element*>(object);
    22492256                        element->ControlToVectors(vector_control,vector_gradient,control_enum,control_interp[i]);
    22502257                }
    … …  
    24662473
    24672474                                                /*Get interpolation (and compute input if necessary)*/
    2468                                                 for(int j=0;j<elements->Size();j++){
    2469                                                         Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
     2475                                                for(Object* & object : this->elements->objects){
     2476                                                        Element* element = xDynamicCast<Element*>(object);
    24702477                                                        element->ResultInterpolation(&rank_interpolation,&rank_nodesperelement,&rank_arraysize,output_enum);
    24712478                                                        if(rank_arraysize>max_rank_arraysize)max_rank_arraysize=rank_arraysize;
    … …  
    24952502
    24962503                                                        /*Fill-in matrix*/
    2497                                                         for(int j=0;j<elements->Size();j++){
    2498                                                                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
     2504                                                        for(Object* & object : this->elements->objects){
     2505                                                                Element* element = xDynamicCast<Element*>(object);
    24992506                                                                element->ResultToPatch(values,nodesperelement,output_enum);
    25002507                                                        }
    … …  
    25222529
    25232530                                                                /*Fill in vector*/
    2524                                                                 for(int j=0;j<elements->Size();j++){
    2525                                                                         Element* element=(Element*)elements->GetObjectByOffset(j);
     2531                                                                for(Object* & object : this->elements->objects){
     2532                                                                        Element* element = xDynamicCast<Element*>(object);
    25262533                                                                        element->ResultToVector(vector_result,output_enum);
    25272534                                                                }
    … …  
    25412548
    25422549                                                                /*Fill-in matrix*/
    2543                                                                 for(int j=0;j<elements->Size();j++){
    2544                                                                         Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
     2550                                                                for(Object* & object : this->elements->objects){
     2551                                                                        Element* element = xDynamicCast<Element*>(object);
    25452552                                                                        element->ResultToMatrix(values,ncols,output_enum);
    25462553                                                                }
    … …  
    26672674void FemModel::RignotMeltParameterizationx(){/*{{{*/
    26682675
    2669         for(int i=0;i<elements->Size();i++){
    2670                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     2676        for(Object* & object : this->elements->objects){
     2677                Element* element = xDynamicCast<Element*>(object);
    26712678                element->RignotMeltParameterization();
    26722679        }
    … …  
    26752682void FemModel::StrainRateparallelx(){/*{{{*/
    26762683
    2677         for(int i=0;i<elements->Size();i++){
    2678                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     2684        for(Object* & object : this->elements->objects){
     2685                Element* element = xDynamicCast<Element*>(object);
    26792686                element->StrainRateparallel();
    26802687        }
    … …  
    26832690void FemModel::StrainRateperpendicularx(){/*{{{*/
    26842691
    2685         for(int i=0;i<elements->Size();i++){
    2686                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     2692        for(Object* & object : this->elements->objects){
     2693                Element* element = xDynamicCast<Element*>(object);
    26872694                element->StrainRateperpendicular();
    26882695        }
    … …  
    26912698void FemModel::StrainRateeffectivex(){/*{{{*/
    26922699
    2693         for(int i=0;i<elements->Size();i++){
    2694                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     2700        for(Object* & object : this->elements->objects){
     2701                Element* element = xDynamicCast<Element*>(object);
    26952702                element->ComputeStrainRate();
    26962703        }
    … …  
    27002707
    27012708        /*Update input for basal element only*/
    2702         for(int i=0;i<elements->Size();i++){
    2703                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     2709        for(Object* & object : this->elements->objects){
     2710                Element* element = xDynamicCast<Element*>(object);
    27042711                element->StressIntensityFactor();
    27052712        }
    … …  
    27172724
    27182725        /*Compute Misfit: */
    2719         for(int i=0;i<elements->Size();i++){
    2720                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2726        for(Object* & object : this->elements->objects){
     2727                Element* element = xDynamicCast<Element*>(object);
    27212728
    27222729                /*If on water, return 0: */
    … …  
    27712778
    27722779        /*Compute Misfit: */
    2773         for(int i=0;i<elements->Size();i++){
    2774                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2780        for(Object* & object : this->elements->objects){
     2781                Element* element = xDynamicCast<Element*>(object);
    27752782
    27762783                /*If on water, return 0: */
    … …  
    28252832   Vector<IssmDouble>* vectotalweight  = new Vector<IssmDouble>(numberofvertices);
    28262833
    2827    for(int i=0;i<this->elements->Size();i++){
    2828       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2834        for(Object* & object : this->elements->objects){
     2835                Element* element = xDynamicCast<Element*>(object);
    28292836
    28302837                /*check if there is ice in this element*/
    … …  
    28602867
    28612868   /*Set element inputs*/
    2862    for(int i=0;i<this->elements->Size();i++){
    2863       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2869        for(Object* & object : this->elements->objects){
     2870                Element* element = xDynamicCast<Element*>(object);
    28642871                H[0]=Hserial[element->vertices[0]->Sid()];
    28652872                H[1]=Hserial[element->vertices[1]->Sid()];
    … …  
    28882895
    28892896        /*Compute Misfit: */
    2890         for(int i=0;i<elements->Size();i++){
    2891                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2897        for(Object* & object : this->elements->objects){
     2898                Element* element = xDynamicCast<Element*>(object);
    28922899
    28932900                /*If on water, return 0: */
    … …  
    29442951        Element* element=(Element*)elements->GetObjectByOffset(0); min_dt=element->TimeAdapt();
    29452952
    2946         for(int i=1;i<elements->Size();i++){
    2947                 element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     2953        for(Object* & object : this->elements->objects){
     2954                element = xDynamicCast<Element*>(object);
    29482955                dt=element->TimeAdapt();
    29492956                if(dt<min_dt)min_dt=dt;
    … …  
    29712978        IssmDouble total_calving_flux;
    29722979
    2973         for(int i=0;i<this->elements->Size();i++){
    2974                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2980        for(Object* & object : this->elements->objects){
     2981                Element* element = xDynamicCast<Element*>(object);
    29752982                local_calving_flux+=element->TotalCalvingFluxLevelset(scaled);
    29762983        }
    … …  
    29872994        IssmDouble total_calving_flux;
    29882995
    2989         for(int i=0;i<this->elements->Size();i++){
    2990                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     2996        for(Object* & object : this->elements->objects){
     2997                Element* element = xDynamicCast<Element*>(object);
    29912998                local_calving_flux+=element->TotalCalvingMeltingFluxLevelset(scaled);
    29922999        }
    … …  
    30033010        IssmDouble total_fbmb;
    30043011
    3005         for(int i=0;i<this->elements->Size();i++){
    3006                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     3012        for(Object* & object : this->elements->objects){
     3013                Element* element = xDynamicCast<Element*>(object);
    30073014                local_fbmb+=element->TotalFloatingBmb(scaled);
    30083015        }
    … …  
    30193026        IssmDouble total_gbmb;
    30203027
    3021         for(int i=0;i<this->elements->Size();i++){
    3022                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     3028        for(Object* & object : this->elements->objects){
     3029                Element* element = xDynamicCast<Element*>(object);
    30233030                local_gbmb+=element->TotalGroundedBmb(scaled);
    30243031        }
    … …  
    30353042        IssmDouble total_smb;
    30363043
    3037         for(int i=0;i<this->elements->Size();i++){
    3038                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     3044        for(Object* & object : this->elements->objects){
     3045                Element* element = xDynamicCast<Element*>(object);
    30393046                local_smb+=element->TotalSmb(scaled);
    30403047        }
    … …  
    30483055void FemModel::UpdateConstraintsExtrudeFromBasex(void){ /*{{{*/
    30493056
    3050         for(int i=0;i<elements->Size();i++){
    3051                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     3057        for(Object* & object : this->elements->objects){
     3058                Element* element = xDynamicCast<Element*>(object);
    30523059                element->UpdateConstraintsExtrudeFromBase();
    30533060        }
    … …  
    30573064void FemModel::UpdateConstraintsExtrudeFromTopx(void){ /*{{{*/
    30583065
    3059         for(int i=0;i<elements->Size();i++){
    3060                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     3066        for(Object* & object : this->elements->objects){
     3067                Element* element = xDynamicCast<Element*>(object);
    30613068                element->UpdateConstraintsExtrudeFromTop();
    30623069        }
    … …  
    31113118
    31123119        /*Update verices new geometry: */
    3113         for(int i=0;i<vertices->Size();i++){
    3114                 Vertex* vertex=(Vertex*)vertices->GetObjectByOffset(i);
     3120        for(Object* & object : this->vertices->objects){
     3121                Vertex* vertex = xDynamicCast<Vertex*>(object);
    31153122                vertex->UpdatePosition(vx,vy,vz,parameters,surface,bed);
    31163123        }
    … …  
    33323339   IssmDouble* r        = xNew<IssmDouble>(numvertices);
    33333340
    3334         for(int el=0;el<this->elements->Size();el++){
    3335       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(el));
     3341        for(Object* & object : this->elements->objects){
     3342      Element* element = xDynamicCast<Element*>(object);
    33363343                element->GetVerticesCoordinates(&xyz_list);
    33373344                for(int i=0;i<numvertices;i++){
    … …  
    33643371   IssmDouble* sl      = xNew<IssmDouble>(numvertices);
    33653372
    3366         for(int el=0;el<this->elements->Size();el++){
    3367                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(el));
     3373        for(Object* & object : this->elements->objects){
     3374      Element* element = xDynamicCast<Element*>(object);
    33683375
    33693376                element->GetInputListOnVertices(&s[0],SurfaceEnum);
    … …  
    34693476        vP0inputs= new Vector<IssmDouble>(numberofelements*numP0inputs);
    34703477        vP1inputs= new Vector<IssmDouble>(numberofvertices*numP1inputs);
    3471         for(int i=0;i<this->elements->Size();i++){
    3472                 Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     3478        for(Object* & object : this->elements->objects){
     3479                Element* element = xDynamicCast<Element*>(object);
    34733480
    34743481                /*Get P0 inputs*/
    … …  
    40774084
    40784085   /*Calculate the Smoothed Deviatoric Stress tensor*/
    4079         for(int i=0;i<this->elements->Size();i++){
    4080       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4086        for(Object* & object : this->elements->objects){
     4087                Element* element = xDynamicCast<Element*>(object);
    40814088      element->GetInputListOnVertices(deviatoricstressxx,DeviatoricStressxxEnum);
    40824089      element->GetInputListOnVertices(deviatoricstressyy,DeviatoricStressyyEnum);
    … …  
    41674174
    41684175        /*Integrate the error over elements*/
    4169    for(int i=0;i<this->elements->Size();i++){
    4170       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4176        for(Object* & object : this->elements->objects){
     4177                Element* element = xDynamicCast<Element*>(object);
    41714178                element->GetInputListOnVertices(tauxx,DeviatoricStressxxEnum);
    41724179      element->GetInputListOnVertices(tauyy,DeviatoricStressyyEnum);
    … …  
    42334240   Vector<IssmDouble>* vectotalweight  = new Vector<IssmDouble>(numberofvertices);
    42344241
    4235    for(int i=0;i<this->elements->Size();i++){
    4236       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4242        for(Object* & object : this->elements->objects){
     4243                Element* element = xDynamicCast<Element*>(object);
    42374244      element->GetInputListOnVertices(H,ThicknessEnum);
    42384245      element->GetVerticesSidList(elem_vertices);
    … …  
    43174324
    43184325        /*Integrate the error over elements*/
    4319    for(int i=0;i<this->elements->Size();i++){
    4320       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4326        for(Object* & object : this->elements->objects){
     4327                Element* element = xDynamicCast<Element*>(object);
    43214328      element->GetInputListOnVertices(H,ThicknessEnum);
    43224329      element->GetVerticesSidList(elem_vertices);
    … …  
    43724379   Vector<IssmDouble>* vmasklevelset   = new Vector<IssmDouble>(numberofelements);
    43734380
    4374    for(int i=0;i<this->elements->Size();i++){
    4375       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4381        for(Object* & object : this->elements->objects){
     4382                Element* element = xDynamicCast<Element*>(object);
    43764383      element->GetInputListOnVertices(elementlevelset,MaskOceanLevelsetEnum);
    43774384      int sid = element->Sid();
    … …  
    44054412
    44064413        /*Insert the element center coordinates*/
    4407    for(int i=0;i<this->elements->Size();i++){
    4408       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4414        for(Object* & object : this->elements->objects){
     4415                Element* element = xDynamicCast<Element*>(object);
    44094416      //element->GetVerticesSidList(elem_vertices);
    44104417      int sid = element->Sid();
    … …  
    44614468
    44624469        /*Use the element center coordinate if level set is zero (grounding line or ice front), otherwise set NAN*/
    4463    for(int i=0;i<this->elements->Size();i++){
    4464       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     4470        for(Object* & object : this->elements->objects){
     4471                Element* element = xDynamicCast<Element*>(object);
    44654472      element->GetInputListOnVertices(levelset,levelset_type);
    44664473                element->GetVerticesSidList(elem_vertices);
    … …  
    46454652
    46464653        /*Go through elements, and add contribution from each element to the deflection vector wg:*/
    4647         for(int i=0;i<elements->Size();i++){
    4648                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4654        for(Object* & object : this->elements->objects){
     4655                Element* element = xDynamicCast<Element*>(object);
    46494656                element->GiaDeflection(wg,dwgdt, x,y);
    46504657        }
    … …  
    47494756
    47504757        /*First, figure out the area of the ocean, which is needed to compute the eustatic component: */
    4751         for(int i=0;i<elements->Size();i++){
    4752                 Element*   element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4758        int i = -1;
     4759        for(Object* & object : this->elements->objects){
     4760                i +=1;
     4761                Element* element = xDynamicCast<Element*>(object);
    47534762                element->GetInputValue(&area,AreaEnum);
    47544763                if (masks->isoceanin[i]) oceanarea_cpu += area;
    … …  
    47594768
    47604769        /*Call the sea level rise core: */
    4761         for(int i=0;i<elements->Size();i++){
    4762                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4770        for(Object* & object : this->elements->objects){
     4771                Element* element = xDynamicCast<Element*>(object);
    47634772                element->SealevelriseEustatic(RSLgi,&eustatic_cpu_e,masks, oceanarea);
    47644773                eustatic_cpu+=eustatic_cpu_e;
    … …  
    48114820        /*Call the sea level rise non-eustatic core only if required: */
    48124821        if(computerigid | computeelastic){
    4813                 for(int i=0;i<elements->Size();i++){
    4814                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4822                for(Object* & object : this->elements->objects){
     4823                        Element* element = xDynamicCast<Element*>(object);
    48154824                        element->SealevelriseNonEustatic(RSLgo,RSLg_old,masks);
    48164825                }
    … …  
    48474856        IssmDouble moi_list[3]={0,0,0};
    48484857        IssmDouble moi_list_cpu[3]={0,0,0};
    4849         for(int i=0;i<elements->Size();i++){
    4850                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4858        for(Object* & object : this->elements->objects){
     4859                Element* element = xDynamicCast<Element*>(object);
    48514860                element->SealevelriseMomentOfInertia(&moi_list[0],RSLg_old,masks );
    48524861                moi_list_cpu[0] += moi_list[0];
    … …  
    49494958
    49504959        /*Call the sea level rise core: */
    4951         for(int i=0;i<elements->Size();i++){
    4952                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4960        for(Object* & object : this->elements->objects){
     4961                Element* element = xDynamicCast<Element*>(object);
    49534962                element->SealevelriseGeodetic(Up,North,East,RSLg,masks);
    49544963        }
    … …  
    49854994
    49864995        /*Go through elements, and add contribution from each element and divide by overall ocean area:*/
    4987         for(int i=0;i<elements->Size();i++){
    4988                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4996        for(Object* & object : this->elements->objects){
     4997                Element* element = xDynamicCast<Element*>(object);
    49894998                oceanvalue_cpu += element->OceanAverage(RSLg_serial,masks);
    49904999        }
    … …  
    50235032        GetVectoronBaseFromInputsx(&old_active,this,HydrologydcMaskEplactiveNodeEnum,NodeSIdEnum);
    50245033
    5025         for (int i=0;i<elements->Size();i++){
    5026                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5034        for(Object* & object : this->elements->objects){
     5035                Element* element = xDynamicCast<Element*>(object);
    50275036                effanalysis->HydrologyEPLGetMask(mask,recurence,element);
    50285037        }
    … …  
    50315040        recurence->Assemble();
    50325041        serial_rec=recurence->ToMPISerial();
    5033         for (int i=0;i<nodes->Size();i++){
    5034                 Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
     5042        for(Object* & object : this->nodes->objects){
     5043                Node* node = xDynamicCast<Node*>(object);
    50355044                if(serial_rec[node->Sid()]==1.)eplzigzag_counter[node->Lid()] ++;
    50365045                if(eplzigzag_counter[node->Lid()]>eplflip_lock && eplflip_lock!=0){
    … …  
    50555064        /*Step 2: update node activity. If one element is connected to mask=1, all nodes are active*/
    50565065        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    5057         for (int i=0;i<elements->Size();i++){
    5058                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5066        for(Object* & object : this->elements->objects){
     5067                Element* element = xDynamicCast<Element*>(object);
    50595068                effanalysis->HydrologyEPLGetActive(active,element);
    50605069        }
    … …  
    50725081        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    50735082
    5074         for(int i=0;i<elements->Size();i++){
    5075                 Element    *element  = xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5083        for(Object* & object : this->elements->objects){
     5084                Element* element = xDynamicCast<Element*>(object);
    50765085                switch(domaintype){
    50775086                        case Domain2DhorizontalEnum:
    … …  
    51425151                mask=new Vector<IssmDouble>(this->nodes->NumberOfNodes());
    51435152
    5144                 for (int i=0;i<elements->Size();i++){
    5145                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5153                for(Object* & object : this->elements->objects){
     5154                        Element* element = xDynamicCast<Element*>(object);
    51465155                        inefanalysis->HydrologyIDSGetMask(mask,element);
    51475156                }
    … …  
    51625171        /*get node mask coherent with element mask*/
    51635172        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    5164         for (int i=0;i<elements->Size();i++){
    5165                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5173        for(Object* & object : this->elements->objects){
     5174                Element* element = xDynamicCast<Element*>(object);
    51665175                inefanalysis->HydrologyIdsGetActive(active,element);
    51675176        }
    … …  
    51745183        /*Update node activation accordingly*/
    51755184        int         counter  = 0; //this is probably not acurate but we are only interested in positivity
    5176         for(int i=0;i<elements->Size();i++){
    5177                 Element    *element  = xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5185        for(Object* & object : this->elements->objects){
     5186                Element* element = xDynamicCast<Element*>(object);
    51785187                int         numnodes = element->GetNumberOfNodes();
    51795188                IssmDouble *base     = xNew<IssmDouble>(numnodes);
    … …  
    52235232        this->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    52245233        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    5225         for (int i=0;i<elements->Size();i++){
    5226                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     5234        for(Object* & object : this->elements->objects){
     5235                Element* element = xDynamicCast<Element*>(object);
    52275236                effanalysis->HydrologyEPLGetActive(active,element);
    52285237        }
    … …  
    52375246        int counter =0;
    52385247        this->SetCurrentConfiguration(L2ProjectionEPLAnalysisEnum);
    5239         for (int i=0;i<nodes->Size();i++){
    5240                 Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
     5248        for(Object* & object : this->nodes->objects){
     5249                Node* node = xDynamicCast<Node*>(object);
    52415250                if(serial_active[node->Sid()]==1.){
    52425251                        node->Activate();
    … …  
    52745283                }
    52755284                else{
    5276                         for(int j=0;j<elements->Size();j++){
     5285                        for(Object* & object : this->elements->objects){
    52775286                                /*Get the right transient input*/
    5278                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     5287                                Element* element = xDynamicCast<Element*>(object);
    52795288                                TransientInput* transientinput = this->inputs->GetTransientInput(transientinput_enum[i]);
    52805289
    … …  
    53105319                }
    53115320                else{
    5312                         for(int j=0;j<elements->Size();j++){
     5321                        int j=-1;
     5322                        for(Object* & object : this->elements->objects){
    53135323                                /*Get the right transient input*/
    5314                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     5324                                Element* element = xDynamicCast<Element*>(object);
     5325                                j+=1;
    53155326                                /*Get basal element*/
    53165327                                switch(domaintype){
    … …  
    53575368
    53585369        for(int i=0;i<numoutputs;i++){
    5359                 for(int j=0;j<this->elements->Size();j++){
    5360                         Element* element = xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     5370                for(Object* & object : this->elements->objects){
     5371                        Element* element = xDynamicCast<Element*>(object);
    53615372                        element->CreateInputTimeAverage(transientinput_enum[i],averagedinput_enum[i],init_time,end_time,averaging_method);
    53625373                }
    … …  
    53695380
    53705381        for(int i=0;i<numoutputs;i++){
    5371                 for(int j=0;j<this->elements->Size();j++){
    5372                         Element* element = xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     5382                for(Object* & object : this->elements->objects){
     5383                        Element* element = xDynamicCast<Element*>(object);
    53735384                        /*Get basal element*/
    53745385                        switch(domaintype){
    … …  
    56465657   this->GetZeroLevelSetPoints(&levelset_points,numberofpoints,levelset_type);//levelset_points is serial (global)
    56475658
    5648         for(int i=0;i<this->vertices->Size();i++){//only on this partition
    5649                 Vertex* vertex=(Vertex*)this->vertices->GetObjectByOffset(i);
     5659        for(Object* & object : this->vertices->objects){
     5660                Vertex* vertex = xDynamicCast<Vertex*>(object);
    56505661      /*Attention: no spherical coordinates*/
    56515662      x = vertex->GetX();
    … …  
    59775988        this->GetZeroLevelSetPoints(&levelset_points,numberofpoints,levelset_type);
    59785989
    5979         for(int i=0;i<this->elements->Size();i++){//parallel
    5980       Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     5990        for(Object* & object : this->elements->objects){
     5991                Element* element = xDynamicCast<Element*>(object);
    59815992      int sid = element->Sid();
    59825993                element->GetVerticesCoordinates(&xyz_list);

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

    r25425 r25539  
    17001700                if(strcmp(iodata->name,vector_name)==0){
    17011701                        _assert_(iodata->code==7);
    1702                         for(int i=0;i<elements->Size();i++){
    1703                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1702                        for(Object* & object : elements->objects){
     1703                                Element* element=xDynamicCast<Element*>(object);
    17041704                                element->InputCreate(iodata->data,inputs,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
    17051705                        }
    … …  
    17211721        this->FetchData(&doublearray,&M,&N,vector_name);
    17221722
    1723         for(int i=0;i<elements->Size();i++){
    1724                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1723        for(Object* & object : elements->objects){
     1724                Element* element=xDynamicCast<Element*>(object);
    17251725                if(!doublearray){
    17261726                        element->SetElementInput(inputs,input_enum,default_value);
    … …  
    17421742                IoData* iodata=*iter;
    17431743                if(strcmp(iodata->name,vector_name)==0){
    1744                         for(int i=0;i<elements->Size();i++){
    1745                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1744                        for(Object* & object : elements->objects){
     1745                                Element* element=xDynamicCast<Element*>(object);
    17461746                                element->InputCreate(iodata->data,inputs,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
    17471747                        }
    … …  
    17671767                case 1: //boolean constant
    17681768                        this->FetchData(&boolean,vector_name);
    1769                         for(i=0;i<elements->Size();i++){
    1770                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1769                        for(Object* & object : elements->objects){
     1770                                Element* element=xDynamicCast<Element*>(object);
    17711771                                element->SetBoolInput(inputs,input_enum,boolean);
    17721772                        }
    … …  
    17741774                case 2: //integer constant
    17751775                        this->FetchData(&integer,vector_name);
    1776                         for(i=0;i<elements->Size();i++){
    1777                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1776                        for(Object* & object : elements->objects){
     1777                                Element* element=xDynamicCast<Element*>(object);
    17781778                                element->SetIntInput(inputs,input_enum,integer);
    17791779                        }
    … …  
    17811781                case 3: //IssmDouble constant
    17821782                        this->FetchData(&scalar,vector_name);
    1783                         for(i=0;i<elements->Size();i++){
    1784                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1783                        for(Object* & object : elements->objects){
     1784                                Element* element=xDynamicCast<Element*>(object);
    17851785                                element->SetElementInput(inputs,input_enum,scalar);
    17861786                        }
    … …  
    17891789                        this->FetchData(&doublearray,&M,&N,vector_name); //we still have a doublearray, because it might include times in transient mode
    17901790                        if(!doublearray) _error_("\""<<vector_name<<"\" not found in binary file");
    1791                         for(i=0;i<elements->Size();i++){
    1792                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1791                        for(Object* & object : elements->objects){
     1792                                Element* element=xDynamicCast<Element*>(object);
    17931793                                element->InputCreate(doublearray,inputs,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    17941794                        }
    … …  
    17971797                        this->FetchData(&doublearray,&M,&N,vector_name); //we still have a doublearray, because it might include times in transient mode
    17981798                        if(!doublearray) _error_("\""<<vector_name<<"\" not found in binary file");
    1799                         for(i=0;i<elements->Size();i++){
    1800                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1799                        for(Object* & object : elements->objects){
     1800                                Element* element=xDynamicCast<Element*>(object);
    18011801                                element->InputCreate(doublearray,inputs,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    18021802                        }
    … …  
    18281828                                //initialize transient input dataset:
    18291829                                TransientInput* transientinput=inputs->SetDatasetTransientInput(input_enum,i, times,N);
    1830                                 for(int j=0;j<elements->Size();j++){
     1830                                for(Object* & object : elements->objects){
    18311831
    18321832                                        /*Get the right transient input*/
    1833                                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     1833                                        Element* element=xDynamicCast<Element*>(object);
    18341834
    18351835                                        /*Get values and lid list*/
    … …  
    18991899                        this->FetchData(&doublearray,&M,&N,vector_name);
    19001900                        if(!doublearray) _error_("\""<<vector_name<<"\" not found in binary file");
    1901                         for(i=0;i<elements->Size();i++){
    1902                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1901                        for(Object* & object : elements->objects){
     1902                                Element* element=xDynamicCast<Element*>(object);
    19031903                                element->InputCreate(doublearray,inputs,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    19041904                        }
    … …  
    19191919                IoData* iodata=*iter;
    19201920                if(strcmp(iodata->name,vector_name)==0){
    1921                         for(int i=0;i<elements->Size();i++){
    1922                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1921                        for(Object* & object : elements->objects){
     1922                                Element* element=xDynamicCast<Element*>(object);
    19231923                                _error_("to be implemented...");
    19241924                                //element->InputCreate(iodata->data,inputs,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
    … …  
    19601960                        for(int i=0;i<N;i++) ids[i] = i;
    19611961
    1962                         for(int i=0;i<elements->Size();i++){
    1963                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1962                        for(Object* & object : elements->objects){
     1963                                Element* element=xDynamicCast<Element*>(object);
    19641964                                element->DatasetInputCreate(doublearray,M,N,ids,N,inputs,this,input_enum);
    19651965                        }
    … …  
    19751975                        for(int i=0;i<N;i++) ids[i] = i;
    19761976
    1977                         for(int i=0;i<elements->Size();i++){
    1978                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     1977                        for(Object* & object : elements->objects){
     1978                                Element* element=xDynamicCast<Element*>(object);
    19791979                                element->DatasetInputCreate(doublearray,M,N,ids,N,inputs,this,input_enum);
    19801980                        }

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

    r25508 r25539  
    5757        output->id_offsets=NULL;
    5858        output->sorted_ids=NULL;
    59         if(this->sorted && objsize>0 && this->id_offsets){     
     59        if(this->sorted && objsize>0 && this->id_offsets){
    6060                output->id_offsets=xNew<int>(objsize);
    6161                xMemCpy<int>(output->id_offsets,this->id_offsets,objsize);
    … …  
    102102
    103103        /*Now go through all loads, and get how many nodes they own, unless they are clone nodes: */
    104         for(int i=0;i<this->Size();i++){
    105                 Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
     104        for(Object* & object : this->objects){
     105      Load* load = xDynamicCast<Load*>(object);
    106106                if(load->IsPenalty()){
    107107                        ispenalty++;
    … …  
    135135
    136136        /*Now go through all loads, and get how many nodes they own, unless they are clone nodes: */
    137         for(int i=0;i<this->Size();i++){
    138                 Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
     137        for(Object* & object : this->objects){
     138      Load* load = xDynamicCast<Load*>(object);
    139139                int numnodes=load->GetNumberOfNodes();
    140140                if(numnodes>max)max=numnodes;

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

    r25508 r25539  
    9090/*}}}*/
    9191void Misfit::Marshall(MarshallHandle* marshallhandle){/*{{{*/
    92         _error_("not implemented yet!"); 
    93 } 
     92        _error_("not implemented yet!");
     93}
    9494/*}}}*/
    9595int Misfit::ObjectEnum(void){/*{{{*/
    … …  
    123123         if (this->local==1){ /*area integration using elements: {{{*/
    124124
    125                  int i;
    126125                 IssmDouble misfit_t=0.;
    127126                 IssmDouble all_misfit_t=0.;
    … …  
    132131                 if(this->lock)return misfit/(time-starttime);
    133132
    134                  for(i=0;i<femmodel->elements->Size();i++){
    135                          Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     133                 for(Object* & object : femmodel->elements->objects){
     134                         Element* element=xDynamicCast<Element*>(object);
    136135                         misfit_t+=element->Misfit(model_enum,observation_enum,weights_enum);
    137136                         area_t+=element->MisfitArea(weights_enum);
    … …  
    153152
    154153                 /*What we return is the value of misfit / time if transient*/
    155                  if(time!=0.) return misfit/(time-starttime); 
     154                 if(time!=0.) return misfit/(time-starttime);
    156155                 return misfit;
    157156         } /*}}}*/

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

    r25508 r25539  
    6363        output->id_offsets=NULL;
    6464        output->sorted_ids=NULL;
    65         if(this->sorted && objsize>0 && this->id_offsets){     
     65        if(this->sorted && objsize>0 && this->id_offsets){
    6666                output->id_offsets=xNew<int>(objsize);
    6767                xMemCpy<int>(output->id_offsets,this->id_offsets,objsize);
    … …  
    148148
    149149        /*First, allocate dof lists based on fset and sset*/
    150         for(int i=0;i<this->Size();i++){
    151                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     150        for(Object* & object : this->objects){
     151      Node* node = xDynamicCast<Node*>(object);
    152152                node->AllocateDofLists(setenum);
    153153        }
    … …  
    155155        /*Now, Build local dofs for masters first*/
    156156        int  dofcount=0;
    157         for(int i=0;i<this->Size();i++){
    158                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     157        for(Object* & object : this->objects){
     158      Node* node = xDynamicCast<Node*>(object);
    159159                if(!node->IsClone()) node->DistributeLocalDofs(&dofcount,setenum);
    160160        }
    161161        /*Build local dofs for clones, they always will be at the end*/
    162162        int dofcount_local = dofcount;
    163         for(int i=0;i<this->Size();i++){
    164                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     163        for(Object* & object : this->objects){
     164                Node* node = xDynamicCast<Node*>(object);
    165165                if(node->IsClone()) node->DistributeLocalDofs(&dofcount_local,setenum);
    166166        }
    167167
    168         /* Now every object has distributed dofs, but locally, and with a dof count starting from 
     168        /* Now every object has distributed dofs, but locally, and with a dof count starting from
    169169         * 0. This means the dofs between all the cpus are not unique. We now offset the dofs of each
    170170         * cpus by the total last (master) dofs of the previus cpu, starting from 0.
    … …  
    179179        xDelete<int>(alldofcount);
    180180
    181         for(int i=0;i<this->Size();i++){
    182                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     181        for(Object* & object : this->objects){
     182                Node* node = xDynamicCast<Node*>(object);
    183183                node->DistributeGlobalDofsMasters(offset,setenum);
    184184        }
    185185
    186         /* Finally, remember that cpus may have skipped some objects, because they were clones. For every 
    187          * object that is not a clone, tell them to show their dofs, so that later on, they can get picked 
     186        /* Finally, remember that cpus may have skipped some objects, because they were clones. For every
     187         * object that is not a clone, tell them to show their dofs, so that later on, they can get picked
    188188         * up by their clones: */
    189189        int  maxdofspernode = this->MaxNumDofs(setenum);
    … …  
    212212
    213213        /*Update indexingupdateflag*/
    214         for(int i=0;i<this->Size();i++){
    215                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     214        for(Object* & object : this->objects){
     215                Node* node = xDynamicCast<Node*>(object);
    216216                node->ReindexingDone();
    217217        }
    … …  
    236236        this->numberofnodes_local=this->Size();
    237237        this->numberofmasters_local=0;
    238         for(int i=0;i<this->Size();i++){
    239                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     238        for(Object* & object : this->objects){
     239                Node* node = xDynamicCast<Node*>(object);
    240240                if(!node->clone) this->numberofmasters_local++;
    241241        }
    … …  
    244244        /*2. Distribute lids (First: masters, then clones)*/
    245245        int lid = 0;
    246         for(int i=0;i<this->Size();i++){
    247                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     246        for(Object* & object : this->objects){
     247                Node* node = xDynamicCast<Node*>(object);
    248248                if(!node->clone) node->lid=lid++;
    249249        }
    250         for(int i=0;i<this->Size();i++){
    251                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     250        for(Object* & object : this->objects){
     251                Node* node = xDynamicCast<Node*>(object);
    252252                if(node->clone) node->lid=lid++;
    253253        }
    … …  
    261261        xDelete<int>(all_num_masters);
    262262
    263         for(int i=0;i<this->Size();i++){
    264                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     263        for(Object* & object : this->objects){
     264                Node* node = xDynamicCast<Node*>(object);
    265265                node->pid = node->lid+offset;
    266266        }
    … …  
    301301
    302302        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    303         for(int i=0;i<this->Size();i++){
    304                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     303        for(Object* & object : this->objects){
     304                Node* node = xDynamicCast<Node*>(object);
    305305
    306306                int numdofs=node->GetNumberOfDofs(NoneApproximationEnum,setenum);
    … …  
    332332
    333333        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    334         for(int i=0;i<this->Size();i++){
    335                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     334        for(Object* & object : this->objects){
     335                Node* node = xDynamicCast<Node*>(object);
    336336
    337337                /*Ok, this object is a node, ask it to plug values into partition: */
    … …  
    348348        /*go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    349349        int numdofs=0;
    350         for(int i=0;i<this->Size();i++){
    351                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     350        for(Object* & object : this->objects){
     351                Node* node = xDynamicCast<Node*>(object);
    352352                numdofs+=node->GetNumberOfDofs(NoneApproximationEnum,setenum);
    353353        }
    … …  
    376376
    377377        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    378         for(int i=0;i<this->Size();i++){
    379                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     378        for(Object* & object : this->objects){
     379                Node* node = xDynamicCast<Node*>(object);
    380380                if(node->RequiresDofReindexing()){
    381381                        flag = 1;
    … …  
    408408
    409409        /*First, go over all nodes, and masters can write their f dof and -1 for s-set*/
    410         for(int i=0;i<this->Size();i++){
    411                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     410        for(Object* & object : this->objects){
     411                Node* node = xDynamicCast<Node*>(object);
    412412
    413413                /*Skip if clone (will check later)*/
    … …  
    436436
    437437        /*Second, go over all nodes, and check that we still have what's expected...*/
    438         for(int i=0;i<this->Size();i++){
    439                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     438        for(Object* & object : this->objects){
     439                Node* node = xDynamicCast<Node*>(object);
    440440
    441441                /*Write degree of freedom if active*/

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

    r25508 r25539  
    2828#define SLRCORE                         15 /*Profiling SLR */
    2929#define MPISERIAL                               16 /*Profiling MPISerial */
    30 #define MAXPROFSIZE                     17 /*Used to initialize static arrays*/
     30#define SEDLOOP                         17 /*Profiling MPISerial */
     31#define SEDMatrix                               18 /*Profiling MPISerial */
     32#define SEDUpdate                               19 /*Profiling MPISerial */
     33#define EPLLOOP                         20 /*Profiling MPISerial */
     34#define EPLMasking                      21 /*Profiling MPISerial */
     35#define EPLMatrices                     22 /*Profiling MPISerial */
     36#define EPLUpdate                               23 /*Profiling MPISerial */
     37#define MAXPROFSIZE                     24 /*Used to initialize static arrays*/
    3138
    3239
    3340class Profiler: public Object{
    3441
    35         public: 
     42        public:
    3643                IssmPDouble flops[MAXPROFSIZE];
    3744                IssmPDouble flops_start[MAXPROFSIZE];

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

    r25508 r25539  
    3030}
    3131/*}}}*/
    32 Radar::Radar(char* in_name, int in_definitionenum){/*{{{*/     
     32Radar::Radar(char* in_name, int in_definitionenum){/*{{{*/
    3333        this->definitionenum=in_definitionenum;
    3434        this->name              = xNew<char>(strlen(in_name)+1);
    … …  
    5959/*}}}*/
    6060void Radar::Marshall(MarshallHandle* marshallhandle){/*{{{*/
    61         _error_("not implemented yet!"); 
    62 } 
     61        _error_("not implemented yet!");
     62}
    6363/*}}}*/
    6464int Radar::ObjectEnum(void){/*{{{*/
    … …  
    7777}
    7878/*}}}*/
    79 IssmDouble Radar::Response(FemModel* femmodel){/*{{{*/ 
    80         int i;
    81         for(i=0;i<femmodel->elements->Size();i++){
    82                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     79IssmDouble Radar::Response(FemModel* femmodel){/*{{{*/
     80        for(Object* & object : femmodel->elements->objects){
     81                Element* element=xDynamicCast<Element*>(object);
    8382                this->ComputeRadarAttenuation(element);
    84                 this->ComputeRadarPower(element); 
     83                this->ComputeRadarPower(element);
    8584        }
    8685        return 0.;
    … …  
    112111        IssmDouble  E_Cl_W97=3.6800e-20;
    113112        IssmDouble  E_NH=3.6800e-20;
    114         IssmDouble  mol_H_hol=1.6; 
    115         IssmDouble  mol_H_lgp=0.2; 
    116         IssmDouble  mol_Cl_hol=0.4; 
    117         IssmDouble  mol_Cl_lgp=1.8; 
     113        IssmDouble  mol_H_hol=1.6;
     114        IssmDouble  mol_H_lgp=0.2;
     115        IssmDouble  mol_Cl_hol=0.4;
     116        IssmDouble  mol_Cl_lgp=1.8;
    118117        IssmDouble  mol_NH_hol=0.5;
    119         IssmDouble  mol_NH_lgp=0.4; 
     118        IssmDouble  mol_NH_lgp=0.4;
    120119        IssmDouble  mol_H, mol_Cl, mol_NH;
    121120        IssmDouble  attenuation_rate_macgregor[NUMVERTICES];
    … …  
    129128        /*Retrieve all inputs we will be needing: */
    130129        Input* temp_input=element->GetInput(TemperatureEnum); _assert_(temp_input);
    131         Input* ice_period_input=element->GetInput(RadarIcePeriodEnum); _assert_(ice_period_input); 
     130        Input* ice_period_input=element->GetInput(RadarIcePeriodEnum); _assert_(ice_period_input);
    132131
    133132        /* Start looping on the number of vertices: */
    … …  
    136135        for (int iv=0;iv<NUMVERTICES;iv++){
    137136                gauss->GaussVertex(iv);
    138    
     137
    139138                /*Get ice temperature: */
    140139                temp_input->GetInputValue(&temperature,gauss);
    141140                ice_period_input->GetInputValue(&ice_period,gauss);
    142141
    143                 if(ice_period>0){; 
     142                if(ice_period>0){;
    144143                        mol_H=mol_H_hol;
    145144                        mol_Cl=mol_Cl_hol;
    146145                        mol_NH=mol_NH_hol;
    147146                        }
    148                 else{ 
     147                else{
    149148                        mol_H=mol_H_lgp;
    150                         mol_Cl=mol_Cl_lgp; 
     149                        mol_Cl=mol_Cl_lgp;
    151150                        mol_NH=mol_NH_lgp;
    152151                }
    … …  
    209208        IssmDouble  rho_ice, gravity, pressure, pressure_melting_pt, frozen_temp, basal_temp, basal_pmp;
    210209        GaussPenta* gauss=NULL;
    211        
     210
    212211        /* Get node coordinates*/
    213212        element->GetVerticesCoordinates(&xyz_list);
    … …  
    253252                                pressure=rho_ice*gravity*thickness;
    254253                                pressure_melting_pt=t_tp-gamma*(pressure-p_tp);
    255                                
     254
    256255                                if((temperature-pressure_melting_pt)<=-1){
    257256                                        reflectivity=-40;

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

    r25508 r25539  
    3636/*}}}*/
    3737Regionaloutput::~Regionaloutput(){/*{{{*/
    38         if(this->name)xDelete(this->name); 
     38        if(this->name)xDelete(this->name);
    3939        if(this->outputname)xDelete(this->outputname);
    4040        if(this->mask)xDelete(this->mask);
    … …  
    6464/*}}}*/
    6565void Regionaloutput::Marshall(MarshallHandle* marshallhandle){/*{{{*/
    66         _error_("not implemented yet!"); 
    67 } 
     66        _error_("not implemented yet!");
     67}
    6868/*}}}*/
    6969int Regionaloutput::ObjectEnum(void){/*{{{*/
    … …  
    8888IssmDouble Regionaloutput::Response(FemModel* femmodel){/*{{{*/
    8989
    90         int i;
    9190        IssmDouble val_t=0.;
    9291        IssmDouble all_val_t=0.;
    9392        int outputenum = StringToEnumx(this->outputname);
    9493
    95         for(i=0;i<femmodel->elements->Size();i++){
    96                 Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
     94        for(Object* & object : femmodel->elements->objects){
     95                Element* element=xDynamicCast<Element*>(object);
    9796                switch(outputenum){
    9897                        case GroundedAreaEnum:

  • TabularUnified issm/trunk-jpl/src/c/cores/sealevelchange_core.cpp

    r25474 r25539  
    336336
    337337        /*go through elements and fill the masks: */
    338         for (int i=0;i<femmodel->elements->Size();i++){
    339                 Element*   element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     338        for(Object* & object : femmodel->elements->objects){
     339                Element*   element=xDynamicCast<Element*>(object);
    340340                element->SetSealevelMasks(masks);
    341341        }
    … …  
    377377
    378378        /*Run sealevelrie geometry routine in elements:*/
    379         for(int i=0;i<femmodel->elements->Size();i++){
    380                 Element*   element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     379        for(Object* & object : femmodel->elements->objects){
     380                Element*   element=xDynamicCast<Element*>(object);
    381381                element->SealevelriseGeometry(latitude,longitude,radius,xx,yy,zz);
    382382        }

  • TabularUnified issm/trunk-jpl/src/c/main/esmfbinders.cpp

    r25379 r25539  
    2828
    2929                elementsonlocalrank=xNewZeroInit<int>(numberofelements);
    30                 for (int i=0;i<femmodel->elements->Size();i++){
    31                         Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     30                for(Object* & object : femmodel->elements->objects){
     31                        Element* element=dynamic_cast<Element*>(object);
    3232                        elementsonlocalrank[element->Sid()]=1;
    3333                }
    … …  
    6363                        int forcing_type=GCMForcingTerms[f];
    6464
    65                         for (int i=0;i<femmodel->elements->Size();i++){
    66                                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     65                        for(Object* & object : femmodel->elements->objects){
     66                                Element* element=dynamic_cast<Element*>(object);
    6767
    6868                                switch(forcing_type){
    … …  
    103103                        int output_type=ISSMOutputTerms[f];
    104104
    105                         for (int i=0;i<femmodel->elements->Size();i++){
    106                                 Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     105                        for(Object* & object : femmodel->elements->objects){
     106                                Element* element=dynamic_cast<Element*>(object);
    107107
    108108                                switch(output_type){

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

    r25486 r25539  
    120120        int elementssize        = femmodel->elements->Size();
    121121        int loadssize           = femmodel->loads->Size();
     122
    122123        /*First, we are building chaining vectors so that we know what nodes are
    123124         * connected to what elements. These vectors are such that:
    … …  
    128129        next_e         = xNew<int>(elementssize*numnodesperelement);
    129130        count2offset_e = xNew<int>(elementssize*numnodesperelement);
    130 
    131131        k=0;
    132         for(i=0;i<elementssize;i++){
    133                 element = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     132        i=-1;
     133        for(Object* & object : femmodel->elements->objects){
     134      element = xDynamicCast<Element*>(object);
     135                i+=1;
    134136                int elementnumnodes = element->GetNumberOfNodes();
    135137                lidlist = xNew<int>(elementnumnodes);
    … …  
    148150                xDelete<int>(lidlist);
    149151        }
    150 
    151152        /*Chain for loads*/
    152153        head_l         = xNew<int>(localnumnodes); for(i=0;i<localnumnodes;i++) head_l[i]=-1;
    … …  
    154155        count2offset_l = xNew<int>(loadssize*numnodesperload);
    155156        k=0;
    156         for(i=0;i<loadssize;i++){
    157                 load = xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
     157        i=-1;
     158        for(Object* & object : femmodel->loads->objects){
     159      load = xDynamicCast<Load*>(object);
     160                i+=1;
    158161                int loadnumnodes = load->GetNumberOfNodes();
    159162                lidlist = xNew<int>(loadnumnodes);
    … …  
    182185
    183186        Vector<IssmDouble> *connectivity_clone= new Vector<IssmDouble>(localmasters,numnodes);
    184 
    185187        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    186188        /*Resetting flags to false at each iteration takes a lot of time, so we keep track of the flags
    … …  
    190192
    191193        /*Create connectivity vector*/
    192         for(i=0;i<femmodel->nodes->Size();i++){
    193                 Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
     194        for(Object* & object : femmodel->nodes->objects){
     195      Node* node = xDynamicCast<Node*>(object);
    194196                int   lid = node->Lid();
    195197                int   pid = node->Pid();
    … …  
    207209                }
    208210                flagsindices_counter = 0;
    209 
    210211                for(j=head_e[lid];j!=-1;j=next_e[j]){
    211212                        offset=count2offset_e[j];
    … …  
    252253                d_nnz=xNew<int>(m);
    253254                o_nnz=xNew<int>(m);
    254                 for(i=0;i<femmodel->nodes->Size();i++){
    255                         Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
     255                for(Object* & object : femmodel->nodes->objects){
     256                        Node* node = xDynamicCast<Node*>(object);
    256257                        int   lid = node->Lid();
    257258                        if(!node->IsClone()){

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

    r24998 r25539  
    3030
    3131        /*loop on each element, and add contribution of the element to the partition (surface weighted average): */
    32         for(int i=0;i<elements->Size();i++){
    33                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     32        for(Object* & object : elements->objects){
     33                Element* element = xDynamicCast<Element*>(object);
    3434                element->AverageOntoPartition(partition_contributions,partition_areas,vertex_response,qmu_part);
    3535        }

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

    r25379 r25539  
    1616
    1717        if(VerboseMProcessor()) _printf0_("      Configuring elements...\n");
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                element->Configure(elements,loads,nodes,vertices,materials,parameters,inputs);
    2121        }

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

    r25317 r25539  
    2525        int offset = 0;
    2626        for(int i=0;i<num_controls;i++){
    27                 for(int j=0;j<elements->Size();j++){
    28                         Element* element=(Element*)elements->GetObjectByOffset(j);
     27                for(Object* & object : elements->objects){
     28                        Element* element=xDynamicCast<Element*>(object);
    2929                        element->ControlInputSetGradient(gradient,control_type[i],i,offset,M_all[i],N_all[i],interp_all[i]);
    3030                }

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

    r23588 r25539  
    1010void CreateJacobianMatrixx(Matrix<IssmDouble>** pJff,FemModel* femmodel,IssmDouble kmax){
    1111
    12         int      i;
    1312        int      configuration_type,analysisenum;
    1413        Element *element = NULL;
    … …  
    2827
    2928        /*Create and assemble matrix*/
    30         for(i=0;i<femmodel->elements->Size();i++){
    31                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     29        for(Object* & object : femmodel->elements->objects){
     30                element=xDynamicCast<Element*>(object);
    3231                ElementMatrix* Je = analysis->CreateJacobianMatrix(element);
    3332                if(Je) Je->AddToGlobal(Jff);
    3433                delete Je;
    3534        }
    36         for (i=0;i<femmodel->loads->Size();i++){
     35        for (int i=0;i<femmodel->loads->Size();i++){
    3736                load=(Load*)femmodel->loads->GetObjectByOffset(i);
    3837                load->CreateJacobianMatrix(Jff);

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=DragCoefficientAbsGradient(element);
    2121        }

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

    r25379 r25539  
    1414
    1515        /*First, reset all melt to 0 */
    16         for(int i=0;i<femmodel->elements->Size();i++){
    17                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     16        for(Object* & object : femmodel->elements->objects){
     17                Element* element=xDynamicCast<Element*>(object);
    1818                int numvertices = element->GetNumberOfVertices();
    1919                IssmDouble* values = xNewZeroInit<IssmDouble>(numvertices);
    … …  
    5555        IssmDouble maxdist_cpu=-1.;
    5656        for(int i=0;i<num_basins;i++){dmax_basin_cpu[i]=-1;}
    57         for(int i=0;i<femmodel->elements->Size();i++){
    58                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     57        for(Object* & object : femmodel->elements->objects){
     58                Element* element=xDynamicCast<Element*>(object);
    5959                if(!element->IsIceInElement() || !element->IsFloating()) continue;
    6060                numvertices = element->GetNumberOfVertices();
    … …  
    9191
    9292        /*Assign box numbers*/
    93         for(int i=0;i<femmodel->elements->Size();i++){
    94                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     93        for(Object* & object : femmodel->elements->objects){
     94                Element* element=xDynamicCast<Element*>(object);
    9595                element->PicoUpdateBoxid(nd);
    9696        }
    … …  
    112112        IssmDouble* boxareas=xNewZeroInit<IssmDouble>(num_basins*maxbox);
    113113
    114         for(int i=0;i<femmodel->elements->Size();i++){
    115                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     114        for(Object* & object : femmodel->elements->objects){
     115                Element* element=xDynamicCast<Element*>(object);
    116116                if(!element->IsOnBase()) continue;
    117117                Element* basalelement = element->SpawnBasalElement();
    … …  
    138138}/*}}}*/
    139139void UpdateBoxPico(FemModel* femmodel, int loopboxid){/*{{{*/
    140         for(int i=0;i<femmodel->elements->Size();i++){
    141                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     140        for(Object* & object : femmodel->elements->objects){
     141                Element* element=xDynamicCast<Element*>(object);
    142142                element->PicoUpdateBox(loopboxid);
    143143        }
    … …  
    160160
    161161        /* Compute Toc and Soc weighted avg (boxes 0 to n-1) */
    162         for(int i=0;i<femmodel->elements->Size();i++){
    163                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     162        for(Object* & object : femmodel->elements->objects){
     163                Element* element=xDynamicCast<Element*>(object);
    164164                if(!element->IsOnBase()) continue;
    165165                Element* basalelement = element->SpawnBasalElement();
    … …  
    201201        if(boxid==0){
    202202                overturning_weighted_avg=xNewZeroInit<IssmDouble>(num_basins);
    203                 for(int i=0;i<femmodel->elements->Size();i++){
    204                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     203                for(Object* & object : femmodel->elements->objects){
     204                        Element* element=xDynamicCast<Element*>(object);
    205205                        if(!element->IsOnBase()) continue;
    206206                        Element* basalelement = element->SpawnBasalElement();
    … …  
    243243}/*}}}*/
    244244void ComputeBasalMeltPlume(FemModel* femmodel){/*{{{*/
    245         for(int i=0;i<femmodel->elements->Size();i++){
    246                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     245        for(Object* & object : femmodel->elements->objects){
     246                Element* element=xDynamicCast<Element*>(object);
    247247                element->PicoComputeBasalMelt();
    248248        }

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

    r25379 r25539  
    5454void LinearFloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
    5555
    56         for(int i=0;i<femmodel->elements->Size();i++){
    57                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     56        for(Object* & object : femmodel->elements->objects){
     57      Element* element = xDynamicCast<Element*>(object);
    5858                element->LinearFloatingiceMeltingRate();
    5959        }
    … …  
    6262void SpatialLinearFloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
    6363
    64         for(int i=0;i<femmodel->elements->Size();i++){
    65                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     64        for(Object* & object : femmodel->elements->objects){
     65      Element* element = xDynamicCast<Element*>(object);
    6666                element->SpatialLinearFloatingiceMeltingRate();
    6767        }
    … …  
    7070void MismipFloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
    7171
    72         for(int i=0;i<femmodel->elements->Size();i++){
    73                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     72        for(Object* & object : femmodel->elements->objects){
     73      Element* element = xDynamicCast<Element*>(object);
    7474                element->MismipFloatingiceMeltingRate();
    7575        }
    … …  
    8484
    8585        femmodel->parameters->FindParam(&num_basins,BasalforcingsIsmip6NumBasinsEnum);
    86         femmodel->parameters->FindParam(&tf_depths,&num_depths,BasalforcingsIsmip6TfDepthsEnum); _assert_(tf_depths); 
     86        femmodel->parameters->FindParam(&tf_depths,&num_depths,BasalforcingsIsmip6TfDepthsEnum); _assert_(tf_depths);
    8787        femmodel->parameters->FindParam(&islocal,BasalforcingsIsmip6IsLocalEnum);
    8888
    … …  
    9696
    9797        /*Get TF at each ice shelf point - linearly intepolate in depth and time*/
    98         for(int i=0;i<femmodel->elements->Size();i++){
    99                 Element* element     = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     98        for(Object* & object : femmodel->elements->objects){
     99      Element* element = xDynamicCast<Element*>(object);
    100100                int      numvertices = element->GetNumberOfVertices();
    101101
    … …  
    123123                        IssmDouble depth = -depth_vertices[iv]; /*NOTE: make sure we are dealing with depth>0*/
    124124                        int offset;
    125                         int found=binary_search(&offset,depth,tf_depths,num_depths); 
     125                        int found=binary_search(&offset,depth,tf_depths,num_depths);
    126126                        if(!found) _error_("depth not found");
    127127
    … …  
    157157        if(!islocal) {
    158158                /*Compute sums of tf*area and shelf-area per cpu*/
    159                 for(int i=0;i<femmodel->elements->Size();i++){
    160                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     159                for(Object* & object : femmodel->elements->objects){
     160                        Element* element = xDynamicCast<Element*>(object);
    161161                        if(!element->IsOnBase() || !element->IsIceInElement() || !element->IsFloating()) continue;
    162162                        /*Spawn basal element if on base to compute element area*/
    … …  
    169169                        area=basalelement->GetHorizontalSurfaceArea();
    170170                        tf_weighted_avg[basinid]+=tf*area;
    171                         areas_summed[basinid]   +=area; 
     171                        areas_summed[basinid]   +=area;
    172172                        /*Delete spawned element if we are in 3D*/
    173173                        basalelement->FindParam(&domaintype,DomainTypeEnum);
    … …  
    185185
    186186   /*Compute meltrates*/
    187         for(int i=0;i<femmodel->elements->Size();i++){
    188                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     187        for(Object* & object : femmodel->elements->objects){
     188      Element* element = xDynamicCast<Element*>(object);
    189189                element->Ismip6FloatingiceMeltingRate();
    190190        }
    … …  
    200200void BeckmannGoosseFloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
    201201
    202         for(int i=0;i<femmodel->elements->Size();i++){
    203                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     202        for(Object* & object : femmodel->elements->objects){
     203      Element* element = xDynamicCast<Element*>(object);
    204204                element->BeckmannGoosseFloatingiceMeltingRate();
    205205        }

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

    r24145 r25539  
    3939void MantlePlumeGeothermalFluxx(FemModel* femmodel){/*{{{*/
    4040
    41         for(int i=0;i<femmodel->elements->Size();i++){
    42                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     41        for(Object* & object : femmodel->elements->objects){
     42                Element* element=xDynamicCast<Element*>(object);
    4343                element->MantlePlumeGeothermalFlux();
    4444        }

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

    r23612 r25539  
    77#include "../../toolkits/toolkits.h"
    88
    9 void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel){
     9void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel){/*{{{*/
    1010
    1111        if(VerboseModule()) _printf0_("   Get solution from inputs\n");
    … …  
    2525        /*Go through elements and plug solution: */
    2626        Analysis* analysis = EnumToAnalysis(analysisenum);
    27         for(int i=0;i<femmodel->elements->Size();i++){
    28                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     27        for(Object* & object : femmodel->elements->objects){
     28                Element* element=xDynamicCast<Element*>(object);
    2929                analysis->GetSolutionFromInputs(solution,element);
    3030        }
    … …  
    3636        /*Assign output pointers:*/
    3737        *psolution=solution;
    38 }
     38}/*}}}*/
     39
     40void GetBasalSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel){ /*{{{*/
     41
     42        if(VerboseModule()) _printf0_("   Get solution from inputs\n");
     43
     44        /*retrieve parameters: */
     45        int analysisenum;
     46        int domaintype;
     47        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
     48        femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
     49        /*Get size of vector: */
     50        int gsize       = femmodel->nodes->NumberOfDofs(GsetEnum);
     51        int gsize_local = femmodel->nodes->NumberOfDofsLocal(GsetEnum);
     52        if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 ");
     53
     54        /*Initialize solution: */
     55        Vector<IssmDouble>* solution=new Vector<IssmDouble>(gsize_local,gsize);
     56
     57        /*Go through elements and plug solution: */
     58        Analysis* analysis = EnumToAnalysis(analysisenum);
     59        for(Object* & object : femmodel->elements->objects){
     60                Element* element=xDynamicCast<Element*>(object);
     61                switch(domaintype){
     62                        case Domain2DhorizontalEnum:
     63                                analysis->GetSolutionFromInputs(solution,element);
     64                        break;
     65                case Domain3DEnum:
     66                        if(!element->IsOnBase()) continue;
     67                        analysis->GetSolutionFromInputs(solution,element);
     68                        break;
     69                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
     70                }
     71        }
     72        delete analysis;
     73
     74        /*Assemble vector: */
     75        solution->Assemble();
     76
     77        /*Assign output pointers:*/
     78        *psolution=solution;
     79}/*}}}*/

  • TabularUnified issm/trunk-jpl/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.h

    r16675 r25539  
    11/*!\file:  GetSolutionFromInputsx.h
    22 * \brief header file for updating datasets from inputs
    3  */ 
     3 */
    44
    55#ifndef _GETSOLUTIONFROMINPUTSXX_H
    … …  
    1111/* local prototypes: */
    1212void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel);
     13void GetBasalSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel);
    1314
    1415#endif  /* _GETSOLUTIONFROMINPUTSXX_H */

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

    r25406 r25539  
    3030        int offset = 0;
    3131        for(int i=0;i<num_controls;i++){
    32                 for(int j=0;j<elements->Size();j++){
    33                         Element* element=(Element*)elements->GetObjectByOffset(j);
     32                for(Object* & object : elements->objects){
     33                        Element* element=xDynamicCast<Element*>(object);
    3434                        element->GetVectorFromControlInputs(vector,control_type[i],i,N[i],data,offset);
    3535                }

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

    r25489 r25539  
    99void GetVectorFromInputsx(Vector<IssmDouble>** pvector,FemModel* femmodel,int name,int type){ /*{{{*/
    1010
    11         int i;
    1211        Vector<IssmDouble>* vector=NULL;
    1312
    … …  
    2625        }
    2726        /*Look up in elements*/
    28         for(i=0;i<femmodel->elements->Size();i++){
    29                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     27        for(Object* & object : femmodel->elements->objects){
     28                Element* element=xDynamicCast<Element*>(object);
    3029                element->GetVectorFromInputs(vector,name,type);
    3130        }
    … …  
    3837void GetVectoronBaseFromInputsx(Vector<IssmDouble>** pvector,FemModel* femmodel,int name,int type){ /*{{{*/
    3938
    40         int i, domaintype;
     39        int domaintype;
    4140        Vector<IssmDouble>* vector=NULL;
    4241
    … …  
    5655
    5756        /*Look up in elements*/
    58         for(i=0;i<femmodel->elements->Size();i++){
    59                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     57        for(Object* & object : femmodel->elements->objects){
     58                Element* element=xDynamicCast<Element*>(object);
    6059                element->FindParam(&domaintype,DomainTypeEnum);
    6160                switch(domaintype){
    … …  
    7675void GetVectorFromInputsx(Vector<IssmDouble>** pvector,FemModel* femmodel,int name,int type,IssmDouble time){/*{{{*/
    7776
    78         int i;
    7977        Vector<IssmDouble>* vector=NULL;
    8078
    … …  
    9088        }
    9189        /*Look up in elements*/
    92         for(i=0;i<femmodel->elements->Size();i++){
    93                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     90        for(Object* & object : femmodel->elements->objects){
     91                Element* element=xDynamicCast<Element*>(object);
    9492                element->GetVectorFromInputs(vector,name,type,time);
    9593        }

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

    r25317 r25539  
    4444        /*Compute all gradient_list*/
    4545        for(int i=0;i<num_controls;i++){
    46                 for(int j=0;j<elements->Size();j++){
    47                         Element* element=(Element*)elements->GetObjectByOffset(j);
     46                for(Object* & object : elements->objects){
     47                        Element* element=xDynamicCast<Element*>(object);
    4848                        analysis->GradientJ(gradient_list[i],element,control_type[i],control_interp[i],i);
    4949                }

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

    r25465 r25539  
    4343
    4444        /*Migrate grounding line : */
    45         for(int i=0;i<elements->Size();i++){
    46                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     45        for(Object* & object : elements->objects){
     46                Element* element=xDynamicCast<Element*>(object);
    4747                element->MigrateGroundingLine(phi_ungrounding);
    4848        }
    … …  
    6868
    6969        /*Fill vector vertices_potentially_floating: */
    70         for(int i=0;i<elements->Size();i++){
    71                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     70        for(Object* & object : elements->objects){
     71                Element* element=xDynamicCast<Element*>(object);
    7272                element->FSContactMigration(vertex_sigmann,vertex_waterpressure);
    7373        }
    … …  
    104104
    105105        /*Fill vector vertices_potentially_floating: */
    106         for(i=0;i<elements->Size();i++){
    107                 element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     106        for(Object* & object : elements->objects){
     107                element=xDynamicCast<Element*>(object);
    108108                element->PotentialUngrounding(vec_vertices_potentially_ungrounding);
    109109        }
    … …  
    132132        /*recover vec_phi*/
    133133        vec_phi=new Vector<IssmDouble>(vertices->NumberOfVertices());
    134         for(i=0;i<elements->Size();i++){
    135                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     134        for(Object* & object : elements->objects){
     135                Element* element=xDynamicCast<Element*>(object);
    136136                element->GetVectorFromInputs(vec_phi,MaskOceanLevelsetEnum,VertexPIdEnum);
    137137        }
    … …  
    146146
    147147                /*Figure out if any of the nodes of the element will be floating -> elements neighbouting the floating ice*/
    148                 for(i=0;i<elements->Size();i++){
    149                         element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     148                for(Object* & object : elements->objects){
     149                        element=xDynamicCast<Element*>(object);
    150150                        vec_elements_neighboring_floatingice->SetValue(element->Sid(),element->IsNodeOnShelfFromFlags(phi)?1.0:0.0,INS_VAL);
    151151                }
    … …  
    157157                /*Go through elements_neighboring_floatingce, and update vector of the nodes that will start floating*/
    158158                local_nflipped=0;
    159                 for(i=0;i<elements->Size();i++){
    160                         element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     159                for(Object* & object : elements->objects){
     160                        element=xDynamicCast<Element*>(object);
    161161                        if(reCast<int,IssmDouble>(elements_neighboring_floatingce[element->Sid()])){
    162162                                local_nflipped+=element->UpdatePotentialUngrounding(vertices_potentially_ungrounding,vec_phi,phi);

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

    r18521 r25539  
    99
    1010void InputDepthAverageAtBasex(FemModel* femmodel,int original_enum, int new_enum){
    11         for(int i=0;i<femmodel->elements->Size();i++){
    12                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     11        for(Object* & object : femmodel->elements->objects){
     12                Element* element=xDynamicCast<Element*>(object);
    1313                element->InputDepthAverageAtBase(original_enum,new_enum);
    1414        }

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

    r18521 r25539  
    99
    1010void InputExtrudex(FemModel* femmodel,int input_enum,int start){
    11         for(int i=0;i<femmodel->elements->Size();i++){
    12                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     11        for(Object* & object : femmodel->elements->objects){
     12                Element* element=xDynamicCast<Element*>(object);
    1313                element->InputExtrude(input_enum,start);
    1414        }

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

    r25379 r25539  
    1212
    1313        /*Elements and loads drive the update: */
    14         for(int i=0;i<femmodel->elements->Size();i++){
    15                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     14        for(Object* & object : femmodel->elements->objects){
     15                Element* element = xDynamicCast<Element*>(object);
    1616                element->InputUpdateFromConstant(constant,name);
    1717        }
    … …  
    2222
    2323        /*Elements and loads drive the update: */
    24         for(int i=0;i<femmodel->elements->Size();i++){
    25                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     24        for(Object* & object : femmodel->elements->objects){
     25                Element* element = xDynamicCast<Element*>(object);
    2626                element->InputUpdateFromConstant(constant,name);
    2727        }
    … …  
    3333        /*Elements and loads drive the update: */
    3434        if(IsInputEnum(name)){
    35                 for(int i=0;i<femmodel->elements->Size();i++){
    36                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     35                for(Object* & object : femmodel->elements->objects){
     36                        Element* element = xDynamicCast<Element*>(object);
    3737                        element->InputUpdateFromConstant(constant,name);
    3838                }
    … …  
    5555
    5656        /*Elements and loads drive the update: */
    57         for(int i=0;i<elements->Size();i++){
    58                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     57        for(Object* & object : elements->objects){
     58                Element* element=xDynamicCast<Element*>(object);
    5959                element->SetElementInput(inputs,name,constant);
    6060        }
    … …  
    6565
    6666        /*Elements and loads drive the update: */
    67         for(int i=0;i<elements->Size();i++){
    68                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     67        for(Object* & object : elements->objects){
     68                Element* element=xDynamicCast<Element*>(object);
    6969                element->SetBoolInput(inputs,name,constant);
    7070        }
    … …  
    7979
    8080        /*Elements and loads drive the update: */
    81         for(int i=0;i<elements->Size();i++){
    82                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     81        for(Object* & object : elements->objects){
     82                Element* element=xDynamicCast<Element*>(object);
    8383                element->SetElementInput(inputs,name,constant2);
    8484        }

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

    r25379 r25539  
    1212#include "../InputUpdateFromConstantx/InputUpdateFromConstantx.h"
    1313#include "../InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h"
    14                        
     14
    1515void  InputUpdateFromDakotax(FemModel* femmodel,double* variables,char* *variables_descriptors,int numdakotavariables){ /*{{{*/
    1616
    … …  
    3434
    3535        /*retrieve parameters: */
    36         femmodel->parameters->FindParam(&variable_partitions,&variable_partitions_num,NULL,NULL,QmuVariablePartitionsEnum); 
    37         femmodel->parameters->FindParam(&variable_partitions_npart,NULL,NULL,QmuVariablePartitionsNpartEnum); 
    38         femmodel->parameters->FindParam(&variable_partitions_nt,NULL,NULL,QmuVariablePartitionsNtEnum); 
    39        
    40 
    41         /*Go through all dakota descriptors, ex: "rho_ice","thermal_conductivity","thickness1","thickness2", etc ..., and 
    42          * for each descriptor, take the variable value and plug it into the inputs (more or less :)): 
    43          * We also start with distributed and standard values , as they tend to be used to pluck data from a multi-modle ensemble (mme) 
    44          * which can then be scaled. Doing the scaling first would be impractical, as the entire mme would have to be scaled, 
     36        femmodel->parameters->FindParam(&variable_partitions,&variable_partitions_num,NULL,NULL,QmuVariablePartitionsEnum);
     37        femmodel->parameters->FindParam(&variable_partitions_npart,NULL,NULL,QmuVariablePartitionsNpartEnum);
     38        femmodel->parameters->FindParam(&variable_partitions_nt,NULL,NULL,QmuVariablePartitionsNtEnum);
     39
     40
     41        /*Go through all dakota descriptors, ex: "rho_ice","thermal_conductivity","thickness1","thickness2", etc ..., and
     42         * for each descriptor, take the variable value and plug it into the inputs (more or less :)):
     43         * We also start with distributed and standard values , as they tend to be used to pluck data from a multi-modle ensemble (mme)
     44         * which can then be scaled. Doing the scaling first would be impractical, as the entire mme would have to be scaled,
    4545         * which is a waste of time:*/
    4646
    4747        variablecount=0;
    48         for(i=0;i<numdakotavariables;i++){ //these are the dakota variables, for all partitions. 
     48        for(i=0;i<numdakotavariables;i++){ //these are the dakota variables, for all partitions.
    4949
    5050                descriptor=variables_descriptors[i];
    51        
     51
    5252
    5353                /*From descriptor, figure out if the variable is scaled, indexed, distributed or just a simple variable: */
    54                 if (strncmp(descriptor,"scaled_",7)==0){ 
     54                if (strncmp(descriptor,"scaled_",7)==0){
    5555                        /*we are skipping these for now.*/
    5656                        npart=variable_partitions_npart[variablecount];
    5757                        nt=variable_partitions_nt[variablecount];
    58                                
     58
    5959                        /*increment i to skip the distributed values just collected: */
    6060                        i+=npart*nt-1; //careful, the for loop will add 1.
    … …  
    6666                        /*we are skipping these for now.*/
    6767                }
    68                
     68
    6969                else if (strncmp(descriptor,"distributed_",12)==0){
    7070                        if (VerboseQmu())_printf0_("   updating variable " << descriptor << "\n");
    71                        
     71
    7272                        /*recover partition vector: */
    7373                        variable_partition=variable_partitions[variablecount];
    7474                        npart=variable_partitions_npart[variablecount];
    7575
    76                         /*Variable is distributed. Determine root name of variable (ex: distributed_DragCoefficient_1 -> DragCoefficient). 
     76                        /*Variable is distributed. Determine root name of variable (ex: distributed_DragCoefficient_1 -> DragCoefficient).
    7777                         * Allocate distributed_values and fill the distributed_values with the next npart variables: */
    7878
    … …  
    8686
    8787                        //for (int j=0;j<npart;j++)_printf_(j << ":" << distributed_values[j] << "\n");
    88                        
     88
    8989                        //Call specialty code:
    9090                        InputUpdateSpecialtyCode(femmodel,distributed_values,variable_partition,npart,root);
    91                        
     91
    9292                        /*increment i to skip the distributed values just collected: */
    9393                        i+=npart-1; //careful, the for loop will add 1.
    94                        
     94
    9595                        /*Free allocations: */
    9696                        xDelete<double>(parameter);
    … …  
    104104                variablecount++;
    105105        }
    106        
     106
    107107        variablecount=0;
    108108        /*now deal with scaled variabes:*/
    109         for(i=0;i<numdakotavariables;i++){ //these are the dakota variables, for all partitions. 
     109        for(i=0;i<numdakotavariables;i++){ //these are the dakota variables, for all partitions.
    110110
    111111                descriptor=variables_descriptors[i];
    112        
     112
    113113                /*From descriptor, figure out if the variable is scaled, indexed, distributed or just a simple variable: */
    114114                if (strncmp(descriptor,"scaled_",7)==0){
    115                
     115
    116116                        if (VerboseQmu())_printf0_("   updating variable " << descriptor << "\n");
    117                
     117
    118118                        /*recover partition vector: */
    119119                        variable_partition=variable_partitions[variablecount];
    … …  
    121121                        nt=variable_partitions_nt[variablecount];
    122122
    123                         /* Variable is scaled, determine its root name (ex: scaled_DragCoefficient_1 -> DragCoefficient). Allocate distributed_values and fill the 
     123                        /* Variable is scaled, determine its root name (ex: scaled_DragCoefficient_1 -> DragCoefficient). Allocate distributed_values and fill the
    124124                         * distributed_values with the next npart variables coming from Dakota: */
    125125                        memcpy(root,strstr(descriptor,"_")+1,(strlen(strstr(descriptor,"_")+1)+1)*sizeof(char));
    … …  
    136136                        /*increment i to skip the distributed values just collected: */
    137137                        i+=npart*nt-1; //careful, the for loop will add 1.
    138                        
     138
    139139                        /*Free allocations: */
    140140                        xDelete<double>(parameter);
    … …  
    201201        femmodel->inputs->SetTransientInput(DummyEnum,times,N);
    202202        transientinput2 = femmodel->inputs->GetTransientInput(DummyEnum);
    203                
    204         for (int i=0;i<femmodel->elements->Size();i++){
    205 
    206                 Tria*   element=xDynamicCast<Tria*>(femmodel->elements->GetObjectByOffset(i));
     203
     204        for(Object* & object : femmodel->elements->objects){
     205                Tria*   element=xDynamicCast<Tria*>(object);
    207206
    208207                if((int)variable_partition[element->Sid()]==-1)id=0; //grab background field
    … …  
    218217                        if(interpolationenum==P0Enum){
    219218                                value=tria_input->element_values[0];
    220                                 transientinput2->AddTriaTimeInput( j,1,&(element->lid),&value,P0Enum); 
     219                                transientinput2->AddTriaTimeInput( j,1,&(element->lid),&value,P0Enum);
    221220                        }
    222221                        else if(interpolationenum==P1Enum){
    … …  
    231230                                element->GetVerticesSidList(&vertexsids[0]);
    232231                                values=tria_input->element_values;
    233                                 transientinput2->AddTriaTimeInput( j,numvertices,vertexlids,values,P1Enum); 
     232                                transientinput2->AddTriaTimeInput( j,numvertices,vertexlids,values,P1Enum);
    234233                        }
    235234                }
    … …  
    248247
    249248        /*Go through elements, copy input name to dummy, and scale it using the distributed_values and the partition vector:*/
    250         for(int i=0;i<femmodel->elements->Size();i++){
    251                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     249        for(Object* & object : femmodel->elements->objects){
     250                Element* element=xDynamicCast<Element*>(object);
    252251                element->InputScaleFromDakota(distributed_values,partition,npart,nt,name);
    253252        }
    254253
    255         /*We created a dummy input, which was a scaled copy of the name input. Now wipe 
     254        /*We created a dummy input, which was a scaled copy of the name input. Now wipe
    256255         * out the name input with the new input:*/
    257256        femmodel->inputs->ChangeEnum(DummyEnum,name);

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

    r24175 r25539  
    1010void InputUpdateFromMatrixDakotax(FemModel* femmodel,double* matrix,int nrows,int ncols, int name, int type){
    1111
    12         int i;
    1312        int numberofvertices,numberofelements;
    1413
    … …  
    2019
    2120                /*Update elements, nodes, loads and materials from inputs: */
    22                 for(i=0;i<femmodel->elements->Size();i++){
    23                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     21                for(Object* & object : femmodel->elements->objects){
     22                        Element* element=xDynamicCast<Element*>(object);
    2423                        element->InputUpdateFromMatrixDakota(matrix,nrows,ncols,name,type);
    2524                }

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

    r25024 r25539  
    2222
    2323        /*Now update inputs (analysis specific)*/
    24         for(int i=0;i<femmodel->elements->Size();i++){
    25                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     24        for(Object* & object : femmodel->elements->objects){
     25      Element* element = xDynamicCast<Element*>(object);
    2626                analysis->InputUpdateFromSolution(local_ug,element);
    2727        }

  • TabularUnified issm/trunk-jpl/src/c/modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.h

    r23629 r25539  
    11/*!\file:  InputUpdateFromSolutionx.h
    22 * \brief header file for updating datasets from inputs
    3  */ 
     3 */
    44
    55#ifndef _UPDATEINPUTSFROMSOLUTIONXX_H

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

    r23524 r25539  
    1919
    2020        /*Update elements, nodes, loads and materials from inputs: */
    21         for(int i=0;i<femmodel->elements->Size();i++){
    22                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     21        for(Object* & object : femmodel->elements->objects){
     22                Element* element=xDynamicCast<Element*>(object);
    2323                element->InputUpdateFromVectorDakota(vector,name,type);
    2424        }

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

    r23638 r25539  
    2525
    2626        /*Update elements, nodes, loads and materials from inputs: */
    27         for(int i=0;i<femmodel->elements->Size();i++){
    28                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     27        for(Object* & object : femmodel->elements->objects){
     28                Element* element=xDynamicCast<Element*>(object);
    2929                element->InputUpdateFromVector(vector,name,type);
    3030        }

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

    r25379 r25539  
    9696
    9797        /*OK, now deactivate iceberg and count the number of deactivated vertices*/
    98         for(int i=0;i<femmodel->elements->Size();i++){
    99                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     98        for(Object* & object : femmodel->elements->objects){
     99                Element* element = xDynamicCast<Element*>(object);
    100100
    101101                if(element->IsIceInElement()){

  • TabularUnified issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

    r25379 r25539  
    8383                        if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(inputs,elements,"md.inversion.vy_obs",InversionVyObsEnum);
    8484                }
    85                 for(int j=0;j<elements->Size();j++){
    86                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     85                for(Object* & object : elements->objects){
     86                        Element* element=xDynamicCast<Element*>(object);
    8787                        element->DatasetInputAdd(InversionCostFunctionsCoefficientsEnum,&weights[i*iomodel->numberofvertices],inputs,iomodel,M,1,1,cost_function,7,cost_function);
    8888                }
    … …  
    160160                }
    161161
    162                 for(int j=0;j<elements->Size();j++){
    163                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     162                for(Object* & object : elements->objects){
     163                        Element* element=xDynamicCast<Element*>(object);
    164164                        element->ControlInputCreate(independent,&independents_min[offset],&independents_max[offset],inputs,iomodel,M,N,scale,control,i+1);
    165165                }
    … …  
    290290
    291291
    292                         for(int j=0;j<elements->Size();j++){
    293                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     292                        for(Object* & object : elements->objects){
     293                                Element* element=xDynamicCast<Element*>(object);
    294294                                element->ControlInputCreate(independent,independents_min,independents_max,inputs,iomodel,M,N,1.,input_enum,i+1);
    295295                        }

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

    r25379 r25539  
    216216                                                        if (!isice){
    217217                                                                /*go through elements, and zero the hmaterials pointers: */
    218                                                                 for(int j=0;j<elements->Size();j++){
    219                                                                         Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     218                                                                for(Object* & object : elements->objects){
     219                                                                        Element* element=xDynamicCast<Element*>(object);
    220220                                                                        switch(element->ObjectEnum()){
    221221                                                                                case TriaEnum:

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

    r25379 r25539  
    118118
    119119                                        /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
    120                                         for(int k=0;k<elements->Size();k++){
    121                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
     120                                        for(Object* & object : elements->objects){
     121                                                Element* element=xDynamicCast<Element*>(object);
    122122                                                element->InputCreate(misfit_observation_s[j],inputs,iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],obs_vector_type,StringToEnumx(misfit_observation_string_s[j]),7);
    123123                                                element->InputCreate(misfit_weights_s[j],inputs,iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],weight_vector_type,StringToEnumx(misfit_weights_string_s[j]),7);
    … …  
    208208
    209209                                        /*Now, for this particular cfsurfacesquare object, make sure we plug into the elements: the observation, and the weights.*/
    210                                         for(int k=0;k<elements->Size();k++){
    211                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
     210                                        for(Object* & object : elements->objects){
     211                                                Element* element=xDynamicCast<Element*>(object);
    212212                                                element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_observation_s[j],inputs,iomodel,cfsurfacesquare_observation_M_s[j],cfsurfacesquare_observation_N_s[j],obs_vector_type,StringToEnumx(cfsurfacesquare_observation_string_s[j]),7,SurfaceObservationEnum);
    213213                                                element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_weights_s[j],inputs,iomodel,cfsurfacesquare_weights_M_s[j],cfsurfacesquare_weights_N_s[j],weight_vector_type,StringToEnumx(cfsurfacesquare_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
    … …  
    278278
    279279                                        /*Now, for this particular cfdragcoeffabsgrad object, make sure we plug into the elements: the observation, and the weights.*/
    280                                         for(int k=0;k<elements->Size();k++){
    281 
    282                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
     280                                        for(Object* & object : elements->objects){
     281
     282                                                Element* element=xDynamicCast<Element*>(object);
    283283
    284284                                                element->DatasetInputAdd(StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),cfdragcoeffabsgrad_weights_s[j],inputs,iomodel,cfdragcoeffabsgrad_weights_M_s[j],cfdragcoeffabsgrad_weights_N_s[j],weight_vector_type,StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
    … …  
    361361
    362362                                        /*Now, for this particular cfsurfacelogvel object, make sure we plug into the elements: the observation, and the weights.*/
    363                                         for(int k=0;k<elements->Size();k++){
    364 
    365                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
     363                                        for(Object* & object : elements->objects){
     364
     365                                                Element* element=xDynamicCast<Element*>(object);
    366366
    367367                                                element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vxobs[j],inputs,iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vxobs_string[j]),7,VxObsEnum);
    … …  
    606606
    607607                                        /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
    608                                         for(int k=0;k<elements->Size();k++){
    609                                                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
     608                                        for(Object* & object : elements->objects){
     609                                                Element* element=xDynamicCast<Element*>(object);
    610610                                                element->DatasetInputCreate(cost_functions_weights[j],cost_functions_weights_M[j],cost_functions_weights_N[j],cost_function_enums,num_cost_functions,inputs,iomodel,InversionCostFunctionsCoefficientsEnum);
    611611                                        }

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

    r23066 r25539  
    2222        found=0;
    2323
    24         for(int i=0;i<elements->Size();i++){
    25                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     24        for(Object* & object : elements->objects){
     25                Element* element=xDynamicCast<Element*>(object);
    2626                found=element->NodalValue(&value,index,natureofdataenum);
    2727                if(found){

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

    r18521 r25539  
    1111        Element *element = NULL;
    1212
    13         for (int i=0;i<elements->Size();i++){
    14                 element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     13for(Object* & object : elements->objects){
     14      element = xDynamicCast<Element*>(object);
    1515                element->ResetFSBasalBoundaryCondition();
    1616        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=RheologyBAbsGradient(element);
    2121        }
    … …  
    8585
    8686        /*Compute Misfit: */
    87         for(int i=0;i<elements->Size();i++){
    88                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     87        for(Object* & object : elements->objects){
     88                Element* element=xDynamicCast<Element*>(object);
    8989                J+=RheologyBInitialguessMisfit(element);
    9090        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=RheologyBbarAbsGradient(element);
    2121        }

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

    r25514 r25539  
    1717        femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
    1818
    19         for(int i=0;i<femmodel->elements->Size();i++){
    20                 Element    *element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     19        for(Object* & object : femmodel->elements->objects){
     20                Element    *element  = xDynamicCast<Element*>(object);
    2121                int         numnodes = element->GetNumberOfNodes();
    2222                IssmDouble *mask     = xNew<IssmDouble>(numnodes);
    … …  
    6666
    6767        /*Fill vector with values: */
    68         for(int i=0;i<femmodel->elements->Size();i++){
    69                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     68        for(Object* & object : femmodel->elements->objects){
     69                Element* element=xDynamicCast<Element*>(object);
    7070                if(element->IsIceInElement()){
    7171                        int nbv = element->GetNumberOfVertices();
    … …  
    9292
    9393        /*Fill vector with values: */
    94         for(int i=0;i<femmodel->elements->Size();i++){
    95                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     94        for(Object* & object : femmodel->elements->objects){
     95                Element* element=xDynamicCast<Element*>(object);
    9696
    9797                if(element->IsIceInElement()){
    … …  
    116116
    117117        /*Now update inputs (analysis specific)*/
    118         for(int i=0;i<femmodel->elements->Size();i++){
    119                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     118        for(Object* & object : femmodel->elements->objects){
     119                Element* element=xDynamicCast<Element*>(object);
    120120                element->InputUpdateFromSolutionOneDof(local_ug,IceMaskNodeActivationEnum);
    121121        }

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

    r25317 r25539  
    2222        int offset = 0;
    2323        for(int i=0;i<num_controls;i++){
    24                 for(int j=0;j<femmodel->elements->Size();j++){
    25                         Element* element=(Element*)femmodel->elements->GetObjectByOffset(j);
     24                for(Object* & object : femmodel->elements->objects){
     25                        Element* element=xDynamicCast<Element*>(object);
    2626                        element->SetControlInputsFromVector(vector,control_type[i],i,offset,M[i],N[i]);
    2727                }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=SurfaceAbsVelMisfit(element);
    2121        }

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

    r18521 r25539  
    1919
    2020        /*Compute gradients: */
    21         for(int i=0;i<femmodel->elements->Size();i++){
    22                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     21        for(Object* & object : femmodel->elements->objects){
     22                element=xDynamicCast<Element*>(object);
    2323                S+=element->SurfaceArea();
    2424        }

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

    r25446 r25539  
    1717
    1818        /*Compute Misfit: */
    19         for(int i=0;i<femmodel->elements->Size();i++){
    20                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     19        for(Object* & object : femmodel->elements->objects){
     20                Element* element=xDynamicCast<Element*>(object);
    2121                J+=SurfaceAverageVelMisfit(element);
    2222        }

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

    r25446 r25539  
    1515
    1616        /*Compute Misfit: */
    17         for(int i=0;i<elements->Size();i++){
    18                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     17        for(Object* & object : elements->objects){
     18                Element* element=xDynamicCast<Element*>(object);
    1919                J+=SurfaceLogVelMisfit(element);
    2020        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19      Element* element = xDynamicCast<Element*>(object);
    2020                J+=SurfaceLogVxVyMisfit(element);
    2121        }
    … …  
    9191                 *
    9292                 *      1            [        |u| + eps     2          |v| + eps     2  ]
    93                  * J = --- \bar{v}^2 | log ( -----------  )   +  log ( -----------  )   | 
     93                 * J = --- \bar{v}^2 | log ( -----------  )   +  log ( -----------  )   |
    9494                 *      2            [       |u    |+ eps              |v    |+ eps     ]
    9595                 *                              obs                       obs

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

    r25437 r25539  
    5959        for (t=time;t<=time+dt-smb_dt;t=t+smb_dt){
    6060
    61                 for(int i=0;i<femmodel->elements->Size();i++){
    62                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     61                for(Object* & object : femmodel->elements->objects){
     62                        Element* element=xDynamicCast<Element*>(object);
    6363
    6464                        timeclim=time;

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

    r25379 r25539  
    2121                /*Get time parameters*/
    2222                IssmDouble time,dt,starttime,finaltime;
    23                 femmodel->parameters->FindParam(&time,TimeEnum); 
     23                femmodel->parameters->FindParam(&time,TimeEnum);
    2424                femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    2525                femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    2626                femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    27                
     27
    2828                if(time<=starttime+dt){
    2929                        /*FIXME: this is wrong, should be done at the ElementUpdate step of analysis, not here!*/
    … …  
    5454
    5555                /*Loop over all the elements of this partition*/
    56                 for(int i=0;i<femmodel->elements->Size();i++){
    57                         Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     56                for(Object* & object : femmodel->elements->objects){
     57                        Element* element=xDynamicCast<Element*>(object);
    5858
    5959                        int         numvertices = element->GetNumberOfVertices();
    … …  
    8080
    8181        /*Loop over all the elements of this partition*/
    82         for(int i=0;i<femmodel->elements->Size();i++){
    83                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     82        for(Object* & object : femmodel->elements->objects){
     83                Element* element=xDynamicCast<Element*>(object);
    8484
    8585                /*Allocate all arrays*/
    … …  
    140140
    141141        /*Loop over all the elements of this partition*/
    142         for(int i=0;i<femmodel->elements->Size();i++){
    143                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     142        for(Object* & object : femmodel->elements->objects){
     143                Element* element=xDynamicCast<Element*>(object);
    144144
    145145                /*Allocate all arrays*/
    … …  
    199199void Delta18oParameterizationx(FemModel* femmodel){/*{{{*/
    200200
    201         for(int i=0;i<femmodel->elements->Size();i++){
    202                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     201        for(Object* & object : femmodel->elements->objects){
     202                Element* element=xDynamicCast<Element*>(object);
    203203                element->Delta18oParameterization();
    204204        }
    … …  
    207207void MungsmtpParameterizationx(FemModel* femmodel){/*{{{*/
    208208
    209         for(int i=0;i<femmodel->elements->Size();i++){
    210                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     209        for(Object* & object : femmodel->elements->objects){
     210                Element* element=xDynamicCast<Element*>(object);
    211211                element->MungsmtpParameterization();
    212212        }
    … …  
    215215void Delta18opdParameterizationx(FemModel* femmodel){/*{{{*/
    216216
    217         for(int i=0;i<femmodel->elements->Size();i++){
    218                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     217        for(Object* & object : femmodel->elements->objects){
     218                Element* element=xDynamicCast<Element*>(object);
    219219                element->Delta18opdParameterization();
    220220        }
    … …  
    233233        //    mean annual surface temperature (degrees C): Tsurf(NA)
    234234
    235         int    i, it, jj, itm;
     235        int    it, jj, itm;
    236236        IssmDouble DT = 0.02, sigfac, snormfac;
    237237        IssmDouble signorm = 5.5;      // signorm : sigma of the temperature distribution for a normal day
    … …  
    315315        //     *******END initialize PDD
    316316
    317         for(i=0;i<femmodel->elements->Size();i++){
    318                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     317        for(Object* & object : femmodel->elements->objects){
     318                element=xDynamicCast<Element*>(object);
    319319                element->PositiveDegreeDay(pdds,pds,signorm,ismungsm,issetpddfac);
    320320        }
    … …  
    328328        femmodel->parameters->FindParam(&isfirnwarming,SmbIsfirnwarmingEnum);
    329329
    330         for(int i=0;i<femmodel->elements->Size();i++){
    331                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     330        for(Object* & object : femmodel->elements->objects){
     331                Element* element=xDynamicCast<Element*>(object);
    332332                element->PositiveDegreeDaySicopolis(isfirnwarming);
    333333        }
    … …  
    355355
    356356        /*Loop over all the elements of this partition*/
    357         for(int i=0;i<femmodel->elements->Size();i++){
    358                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     357        for(Object* & object : femmodel->elements->objects){
     358                Element* element=xDynamicCast<Element*>(object);
    359359
    360360                /*Get reference SMB (uncorrected) and allocate all arrays*/
    … …  
    414414
    415415        /*Loop over all the elements of this partition*/
    416         for(int i=0;i<femmodel->elements->Size();i++){
    417                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     416        for(Object* & object : femmodel->elements->objects){
     417                Element* element=xDynamicCast<Element*>(object);
    418418
    419419                /*Allocate all arrays*/
    … …  
    432432
    433433                        /*Get time parameters*/
    434                         femmodel->parameters->FindParam(&time,TimeEnum); 
     434                        femmodel->parameters->FindParam(&time,TimeEnum);
    435435                        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    436436                        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    … …  
    514514
    515515        /*Loop over all the elements of this partition*/
    516         for(int i=0;i<femmodel->elements->Size();i++){
    517                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     516        for(Object* & object : femmodel->elements->objects){
     517                Element* element=xDynamicCast<Element*>(object);
    518518
    519519                /*Allocate all arrays*/
    … …  
    620620void SmbGradientsComponentsx(FemModel* femmodel){/*{{{*/
    621621
    622         for(int i=0;i<femmodel->elements->Size();i++){
    623                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     622        for(Object* & object : femmodel->elements->objects){
     623                Element* element=xDynamicCast<Element*>(object);
    624624                element->SmbGradCompParameterization();
    625625        }
    … …  
    629629void SmbSemicx(FemModel* femmodel){/*{{{*/
    630630
    631         for(int i=0;i<femmodel->elements->Size();i++){
    632                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     631        for(Object* & object : femmodel->elements->objects){
     632                Element* element=xDynamicCast<Element*>(object);
    633633                element->SmbSemic();
    634634        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19      Element* element = xDynamicCast<Element*>(object);
    2020                J+=SurfaceRelVelMisfit(element);
    2121        }
    … …  
    8989
    9090                /*Compute SurfaceRelVelMisfit:
    91                  *                       
     91                 *
    9292                 *      1  [     \bar{v}^2             2   \bar{v}^2              2 ]
    9393                 * J = --- | -------------  (u - u   ) + -------------  (v - v   )  |
    9494                 *      2  [  (u   + eps)^2       obs    (v   + eps)^2       obs    ]
    95                  *              obs                        obs                     
     95                 *              obs                        obs
    9696                 */
    9797

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

    r24679 r25539  
    4141
    4242                /*Get complete stiffness matrix without penalties*/
    43                 for (i=0;i<femmodel->elements->Size();i++){
    44                         element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     43                for(Object* & object : femmodel->elements->objects){
     44                        element = xDynamicCast<Element*>(object);
    4545                        if(!element->AnyFSet() && analysisenum!=StressbalanceAnalysisEnum) continue;
    4646                        ElementMatrix* Ke = analysis->CreateKMatrix(element);
    … …  
    5252                }
    5353
    54                 for (i=0;i<femmodel->loads->Size();i++){
    55                         load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
     54                for(Object* & object : femmodel->loads->objects){
     55                        load = xDynamicCast<Load*>(object);
    5656                        load->CreateKMatrix(Kff_temp,NULL);
    5757                }
    … …  
    8383
    8484        /*Fill stiffness matrix and load vector from elements*/
    85         for (i=0;i<femmodel->elements->Size();i++){
    86                 element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     85        for(Object* & object : femmodel->elements->objects){
     86      element = xDynamicCast<Element*>(object);
    8787                if(!element->AnyFSet() && analysisenum!=StressbalanceAnalysisEnum) continue;
    8888                ElementMatrix* Ke = analysis->CreateKMatrix(element);
    … …  
    9898
    9999        /*Fill stiffness matrix and load vector from loads*/
    100         for(i=0;i<femmodel->loads->Size();i++){
    101                 load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
     100        for(Object* & object : femmodel->loads->objects){
     101      load = xDynamicCast<Load*>(object);
    102102                load->CreateKMatrix(Kff,Kfs);
    103103                load->CreatePVector(pf);
    … …  
    106106        /*Now deal with penalties (only in loads)*/
    107107        if(ispenalty){
    108                 for (i=0;i<femmodel->loads->Size();i++){
    109                         load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
     108                for(Object* & object : femmodel->loads->objects){
     109                        load = xDynamicCast<Load*>(object);
    110110                        load->PenaltyCreateKMatrix(Kff,Kfs,kmax);
    111111                        load->PenaltyCreatePVector(pf,kmax);
    … …  
    115115        /*Create dof vector for stiffness matrix preconditioning*/
    116116        if(pdf){
    117                 for(i=0;i<femmodel->elements->Size();i++){
    118                         element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    119                         ElementVector* de=analysis->CreateDVector(element);
    120                         if(de) de->InsertIntoGlobal(df);
    121                         delete de;
     117        for(Object* & object : femmodel->elements->objects){
     118      element = xDynamicCast<Element*>(object);
     119                ElementVector* de=analysis->CreateDVector(element);
     120                if(de) de->InsertIntoGlobal(df);
     121                delete de;
    122122                }
    123123        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=ThicknessAbsMisfit(element);
    2121        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19      Element* element = xDynamicCast<Element*>(object);
    2020                J+=ThicknessAcrossGradient(element);
    2121        }

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

    r25446 r25539  
    1616
    1717        /*Compute Misfit: */
    18         for(int i=0;i<elements->Size();i++){
    19                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     18        for(Object* & object : elements->objects){
     19                Element* element=xDynamicCast<Element*>(object);
    2020                J+=ThicknessAlongGradient(element);
    2121        }

  • TabularUnified issm/trunk-jpl/src/c/solutionsequences/solutionsequence_hydro_nonlinear.cpp

    r23661 r25539  
    5858
    5959        /*{{{*//*Retrieve inputs as the initial state for the non linear iteration*/
    60         GetSolutionFromInputsx(&ug_sed,femmodel);
     60        GetBasalSolutionFromInputsx(&ug_sed,femmodel);
    6161        Reducevectorgtofx(&uf_sed, ug_sed, femmodel->nodes,femmodel->parameters);
    6262        if(isefficientlayer) {
    … …  
    6464                effanalysis = new HydrologyDCEfficientAnalysis();
    6565                femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    66                 GetSolutionFromInputsx(&ug_epl,femmodel);
     66                GetBasalSolutionFromInputsx(&ug_epl,femmodel);
    6767                /*Initialize the EPL element mask*/
    6868                inefanalysis->ElementizeEplMask(femmodel);
    … …  
    9696
    9797                /*{{{*//*Treating the sediment*/
     98                femmodel->profiler->Start(SEDLOOP);
    9899                for(;;){
    99100                        sedconverged=false;
    … …  
    104105                                /*{{{*//*Core of the computation*/
    105106                                if(VerboseSolution()) _printf0_("Building Sediment Matrix...\n");
     107                                femmodel->profiler->Start(SEDMatrix);
    106108                                SystemMatricesx(&Kff,&Kfs,&pf,&df,&sediment_kmax,femmodel);
    107109                                CreateNodalConstraintsx(&ys,femmodel->nodes);
    108110                                Reduceloadx(pf,Kfs,ys); delete Kfs;
    109111                                delete uf_sed;
     112                                femmodel->profiler->Stop(SEDMatrix);
    110113
    111114                                femmodel->profiler->Start(SOLVER);
    … …  
    115118                                delete Kff; delete pf; delete df;
    116119                                delete ug_sed;
     120                                femmodel->profiler->Start(SEDUpdate);
    117121                                Mergesolutionfromftogx(&ug_sed,uf_sed,ys,femmodel->nodes,femmodel->parameters); delete ys;
    118122                                InputUpdateFromSolutionx(femmodel,ug_sed);
    119123                                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
     124                                femmodel->profiler->Stop(SEDUpdate);
    120125                                /*}}}*/
    121126                                if (!sedconverged){
    … …  
    157162                        }
    158163                }
     164                femmodel->profiler->Stop(SEDLOOP);
    159165                /*}}}*//*End of the global sediment loop*/
    160166                /*{{{*//*Now dealing with the EPL in the same way*/
     167                femmodel->profiler->Start(EPLLOOP);
    161168                if(isefficientlayer){
    162169                        femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    … …  
    173180                                /*{{{*//*Retrieve the EPL head slopes and compute EPL Thickness*/
    174181                                if(VerboseSolution()) _printf0_("computing EPL Head slope...\n");
     182                                femmodel->profiler->Start(EPLMasking);
    175183                                femmodel->SetCurrentConfiguration(L2ProjectionEPLAnalysisEnum);
    176184                                femmodel->UpdateConstraintsL2ProjectionEPLx(&L2Count);
    … …  
    185193                                femmodel->HydrologyEPLupdateDomainx(&ThickCount);
    186194                                /*}}}*/
    187 
     195                                femmodel->profiler->Stop(EPLMasking);
    188196                                if(VerboseSolution()) _printf0_("Building EPL Matrix...\n");
     197                                femmodel->profiler->Start(EPLMatrices);
    189198                                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    190199                                CreateNodalConstraintsx(&ys,femmodel->nodes);
    191200                                Reduceloadx(pf,Kfs,ys); delete Kfs;
    192201                                delete uf_epl;
    193 
     202                                femmodel->profiler->Stop(EPLMatrices);
    194203                                femmodel->profiler->Start(SOLVER);
    195204                                Solverx(&uf_epl,Kff,pf,uf_epl_sub_iter,df,femmodel->parameters);
    … …  
    201210                                uf_epl->Copy(uf_epl_sub_iter);
    202211                                delete ug_epl;
     212                                femmodel->profiler->Start(EPLUpdate);
    203213                                Mergesolutionfromftogx(&ug_epl,uf_epl,ys,femmodel->nodes,femmodel->parameters); delete ys;
    204214                                InputUpdateFromSolutionx(femmodel,ug_epl);
    205215                                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
     216                                femmodel->profiler->Stop(EPLUpdate);
    206217
    207218                                dug=ug_epl_sub_iter->Duplicate();_assert_(dug);
    … …  
    230241                        }
    231242                }
     243                femmodel->profiler->Stop(EPLLOOP);
    232244                /*}}}*//*End of the global EPL loop*/
    233245                /*{{{*//*Now dealing with the convergence of the whole system*/

  • TabularUnified issm/trunk-jpl/src/c/solutionsequences/solutionsequence_schurcg.cpp

    r24527 r25539  
    753753                if(precond)
    754754                {
    755                         for(int i=0;i<femmodel->elements->Size();i++){
    756                                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     755                        for(Object* & object : femmodel->elements->objects){
     756                                Element* element=xDynamicCast<Element*>(object);
    757757                                ElementMatrix* Ie = analysis->CreateSchurPrecondMatrix(element);
    758758                                if(Ie) Ie->AddToGlobal(Kff,NULL);
    … …  
    761761                }else{
    762762                       
    763                         for(int i=0;i<femmodel->elements->Size();i++){
    764                                 Element* element2=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     763                        for(Object* & object : femmodel->elements->objects){
     764                                Element* element2=xDynamicCast<Element*>(object);
    765765                                ElementMatrix* Ie2 = analysis->CreatePressureMassMatrix(element2);
    766766                                if(Ie2) Ie2->AddToGlobal(Kff,NULL);
Note: See TracChangeset for help on using the changeset viewer.