Changeset 23587


Ignore:
Timestamp:
01/02/19 20:33:39 (6 years ago)
Author:
Mathieu Morlighem
Message:

CHG: simplifying some functions now that nodes and loads are for one single analysis

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

Legend:

Unmodified
Added
Removed

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

    r23585 r23587  
    792792void           DamageEvolutionAnalysis::LumpedMassMatrix(Vector<IssmDouble>** pMlff,FemModel* femmodel){/*{{{*/
    793793
    794         /*Intermediaries*/
    795         int  configuration_type;
    796 
    797794        /*Initialize Lumped mass matrix (actually we just save its diagonal)*/
    798         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    799         int fsize      = femmodel->nodes->NumberOfDofs(configuration_type,FsetEnum);
    800         int flocalsize = femmodel->nodes->NumberOfDofsLocal(configuration_type,FsetEnum);
     795        int fsize      = femmodel->nodes->NumberOfDofs(FsetEnum);
     796        int flocalsize = femmodel->nodes->NumberOfDofsLocal(FsetEnum);
    801797        Vector<IssmDouble>* Mlff = new Vector<IssmDouble>(flocalsize,fsize);
    802798

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

    r23585 r23587  
    16361636        IssmDouble*         serial_spc    = NULL;
    16371637
    1638         spc=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes(EnthalpyAnalysisEnum));
     1638        spc=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes());
    16391639        /*First create a vector to figure out what elements should be constrained*/
    16401640        for(int i=0;i<femmodel->elements->Size();i++){

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

    r23585 r23587  
    760760
    761761                /*Vector of size number of nodes*/
    762                 vec_constraint_nodes=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes(LevelsetAnalysisEnum));
     762                vec_constraint_nodes=new Vector<IssmDouble>(femmodel->nodes->NumberOfNodes());
    763763
    764764                for(int i=0;i<femmodel->elements->Size();i++){

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

    r23585 r23587  
    930930void           MasstransportAnalysis::LumpedMassMatrix(Vector<IssmDouble>** pMlff,FemModel* femmodel){/*{{{*/
    931931
    932         /*Intermediaries*/
    933         int  configuration_type;
    934 
    935932        /*Initialize Lumped mass matrix (actually we just save its diagonal)*/
    936         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    937         int fsize      = femmodel->nodes->NumberOfDofs(configuration_type,FsetEnum);
    938         int flocalsize = femmodel->nodes->NumberOfDofsLocal(configuration_type,FsetEnum);
     933        int fsize      = femmodel->nodes->NumberOfDofs(FsetEnum);
     934        int flocalsize = femmodel->nodes->NumberOfDofsLocal(FsetEnum);
    939935        Vector<IssmDouble>* Mlff = new Vector<IssmDouble>(flocalsize,fsize);
    940936

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

    r23586 r23587  
    352352                analysis_type=output->analysis_type_list[i];
    353353                output->SetCurrentConfiguration(analysis_type);
    354                 SpcNodesx(output->nodes_list[i],output->constraints_list[i],output->parameters,analysis_type);
    355                 NodesDofx(output->nodes_list[i],output->parameters,analysis_type);
     354                SpcNodesx(output->nodes_list[i],output->constraints_list[i],output->parameters);
     355                NodesDofx(output->nodes_list[i],output->parameters);
    356356                ConfigureObjectsx(output->elements,output->loads_list[i],output->nodes_list[i],output->vertices,output->materials,output->parameters);
    357357        }
    … …  
    445445
    446446                if(VerboseMProcessor()) _printf0_("      resolving node constraints\n");
    447                 SpcNodesx(nodes,this->constraints,parameters,analysis_type_list[i]);
     447                SpcNodesx(nodes,this->constraints,parameters);
    448448
    449449                if(VerboseMProcessor()) _printf0_("      creating nodal degrees of freedom\n");
    450                 NodesDofx(nodes,parameters,analysis_type_list[i]);
     450                NodesDofx(nodes,parameters);
    451451        }
    452452
    … …  
    525525                        analysis_type=this->analysis_type_list[i];
    526526                        SetCurrentConfiguration(analysis_type);
    527                         SpcNodesx(this->nodes_list[i],this->constraints_list[i],this->parameters,analysis_type);
    528                         NodesDofx(this->nodes_list[i],this->parameters,analysis_type);
     527                        SpcNodesx(this->nodes_list[i],this->constraints_list[i],this->parameters);
     528                        NodesDofx(this->nodes_list[i],this->parameters);
    529529                        ConfigureObjectsx(this->elements,this->loads_list[i],this->nodes_list[i],this->vertices,this->materials,this->parameters);
    530530                }
    … …  
    12791279void FemModel::GetInputLocalMinMaxOnNodesx(IssmDouble** pmin,IssmDouble** pmax,IssmDouble* ug){/*{{{*/
    12801280
    1281         /*Get vector sizes for current configuration*/
    1282         int configuration_type;
    1283         this->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    1284         int numnodes = this->nodes->NumberOfNodes(configuration_type);
    1285 
    12861281        /*Initialize output vectors*/
     1282        int numnodes = this->nodes->NumberOfNodes();
    12871283        IssmDouble* uLmin_local = xNew<IssmDouble>(numnodes);
    12881284        IssmDouble* uLmax_local = xNew<IssmDouble>(numnodes);
    … …  
    25432539
    25442540        /*Second, constraints might be time dependent: */
    2545         SpcNodesx(nodes,constraints,parameters,config_type);
     2541        SpcNodesx(nodes,constraints,parameters);
    25462542
    25472543        /*Now, update degrees of freedoms: */
    2548         NodesDofx(nodes,parameters,config_type);
     2544        NodesDofx(nodes,parameters);
    25492545
    25502546}
    … …  
    27252721
    27262722                ConfigureObjectsx(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters);
    2727                 SpcNodesx(new_nodes_list[i],new_constraints_list[i],this->parameters,analysis_type);
    2728                 NodesDofx(new_nodes_list[i],this->parameters,analysis_type);
     2723                SpcNodesx(new_nodes_list[i],new_constraints_list[i],this->parameters);
     2724                NodesDofx(new_nodes_list[i],this->parameters);
    27292725        }
    27302726
    … …  
    44804476void FemModel::HydrologyEPLupdateDomainx(IssmDouble* pEplcount){ /*{{{*/
    44814477
    4482         Vector<IssmDouble>* mask                                                        = NULL;
    4483         Vector<IssmDouble>* recurence                           = NULL;
    4484         Vector<IssmDouble>* active                                              = NULL;
    4485         IssmDouble*         serial_mask                         = NULL;
    4486         IssmDouble*         serial_rec                          = NULL;
    4487         IssmDouble*         serial_active                       = NULL;
    4488         IssmDouble*         old_active        = NULL;
    4489         int*                eplzigzag_counter = NULL;
     4478        Vector<IssmDouble> *mask = NULL;
     4479        Vector<IssmDouble> *recurence = NULL;
     4480        Vector<IssmDouble> *active = NULL;
     4481        IssmDouble         *serial_mask       = NULL;
     4482        IssmDouble         *serial_rec        = NULL;
     4483        IssmDouble         *serial_active     = NULL;
     4484        IssmDouble         *old_active        = NULL;
     4485        int                *eplzigzag_counter = NULL;
    44904486        int                 eplflip_lock;
    44914487
    4492         HydrologyDCEfficientAnalysis* effanalysis = new HydrologyDCEfficientAnalysis();
    4493         HydrologyDCInefficientAnalysis* inefanalysis = new HydrologyDCInefficientAnalysis();
     4488        HydrologyDCEfficientAnalysis   *effanalysis  = new HydrologyDCEfficientAnalysis();
     4489        HydrologyDCInefficientAnalysis *inefanalysis = new HydrologyDCInefficientAnalysis();
    44944490
    44954491        /*Step 1: update mask, the mask might be extended by residual and/or using downstream sediment head*/
    4496         mask=new Vector<IssmDouble>(this->nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
    4497         recurence=new Vector<IssmDouble>(this->nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
     4492        int numnodes = this->nodes->NumberOfNodes();
     4493        mask=new Vector<IssmDouble>(numnodes);
     4494        recurence=new Vector<IssmDouble>(numnodes);
    44984495        this->parameters->FindParam(&eplzigzag_counter,NULL,EplZigZagCounterEnum);
    44994496        this->parameters->FindParam(&eplflip_lock,HydrologydcEplflipLockEnum);
    … …  
    45044501                effanalysis->HydrologyEPLGetMask(mask,recurence,element);
    45054502        }
     4503
    45064504        /*check for changes and increment zigzag counter, change the mask if necessary*/
    45074505        recurence->Assemble();
    … …  
    45304528        inefanalysis->ElementizeEplMask(this);
    45314529        /*Step 2: update node activity. If one element is connected to mask=1, all nodes are active*/
    4532         active=new Vector<IssmDouble>(nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
     4530        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    45334531        for (int i=0;i<elements->Size();i++){
    45344532                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    … …  
    45664564        /*Update dof indexings*/
    45674565        this->UpdateConstraintsx();
    4568 
    45694566}
    45704567/*}}}*/
    … …  
    45834580        if(isthermal){
    45844581                /*Step 1: update mask, the mask correspond to thawed nodes (that have a meltingrate)*/
    4585                 mask=new Vector<IssmDouble>(this->nodes->NumberOfNodes(HydrologyDCInefficientAnalysisEnum));
     4582                mask=new Vector<IssmDouble>(this->nodes->NumberOfNodes());
    45864583
    45874584                for (int i=0;i<elements->Size();i++){
    … …  
    46044601
    46054602        /*get node mask coherent with element mask*/
    4606         active=new Vector<IssmDouble>(nodes->NumberOfNodes(HydrologyDCInefficientAnalysisEnum));
     4603        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    46074604        for (int i=0;i<elements->Size();i++){
    46084605                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    … …  
    46514648        /*update node activity. If one element is connected to mask=1, all nodes are active*/
    46524649        this->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
    4653         active=new Vector<IssmDouble>(nodes->NumberOfNodes(HydrologyDCEfficientAnalysisEnum));
     4650        active=new Vector<IssmDouble>(nodes->NumberOfNodes());
    46544651        for (int i=0;i<elements->Size();i++){
    46554652                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));

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

    r23524 r23587  
    5151}
    5252/*}}}*/
    53 bool Loads::IsPenalty(int analysis_type){/*{{{*/
     53bool Loads::IsPenalty(){/*{{{*/
    5454
    5555        int ispenalty=0;
    … …  
    5959        for(int i=0;i<this->Size();i++){
    6060                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    61                 _assert_(load->InAnalysis(analysis_type));
    6261                if(load->IsPenalty()) ispenalty++;
    6362        }
    … …  
    7372}
    7473/*}}}*/
    75 int  Loads::MaxNumNodes(int analysis_type){/*{{{*/
     74int  Loads::MaxNumNodes(){/*{{{*/
    7675
    7776        int max=0;
    7877        int allmax;
    79         int numnodes=0;
    8078
    8179        /*Now go through all loads, and get how many nodes they own, unless they are clone nodes: */
    8280        for(int i=0;i<this->Size();i++){
    83 
    8481                Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    85                 _assert_(load->InAnalysis(analysis_type));
    86                 numnodes=load->GetNumberOfNodes();
     82                int numnodes=load->GetNumberOfNodes();
    8783                if(numnodes>max)max=numnodes;
    8884        }
    … …  
    9086        /*Grab max of all cpus: */
    9187        ISSM_MPI_Allreduce((void*)&max,(void*)&allmax,1,ISSM_MPI_INT,ISSM_MPI_MAX,IssmComm::GetComm());
    92         max=allmax;
    93 
    94         return max;
     88        return allmax;
    9589}
    9690/*}}}*/
    … …  
    10296        /*Get number of local loads*/
    10397        localloads=this->Size();
    104 
    105         /*figure out total number of loads combining all the cpus (no clones here)*/
    106         ISSM_MPI_Reduce(&localloads,&numberofloads,1,ISSM_MPI_INT,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    107         ISSM_MPI_Bcast(&numberofloads,1,ISSM_MPI_INT,0,IssmComm::GetComm());
    108 
    109         return numberofloads;
    110 }
    111 /*}}}*/
    112 int  Loads::NumberOfLoads(int analysis_type){/*{{{*/
    113 
    114         int localloads = 0;
    115         int numberofloads;
    116 
    117         /*Get number of local loads*/
    118         for(int i=0;i<this->Size();i++){
    119 
    120                 Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    121 
    122                 /*Check that this load corresponds to our analysis currently being carried out: */
    123                 _assert_(load->InAnalysis(analysis_type));
    124                 localloads++;
    125         }
    12698
    12799        /*figure out total number of loads combining all the cpus (no clones here)*/
    … …  
    152124
    153125        for ( object=objects.begin() ; object < objects.end(); object++ ){
    154 
    155126                load=xDynamicCast<Load*>(*object);
    156127                load->SetCurrentConfiguration(elements,loads,nodes,vertices,materials,parameters);
    157 
    158128        }
    159 
    160129}
    161130/*}}}*/
    162 int  Loads::Size(void){/*{{{*/
    163 
    164         return this->DataSet::Size();
    165 }
    166 /*}}}*/
    167 int  Loads::Size(int analysis_type){/*{{{*/
    168 
    169         int localloads = 0;
    170 
    171         /*Get number of local loads*/
    172         for(int i=0;i<this->Size();i++){
    173 
    174                 Load* load=xDynamicCast<Load*>(this->GetObjectByOffset(i));
    175 
    176                 /*Check that this load corresponds to our analysis currently being carried out: */
    177                 _assert_(load->InAnalysis(analysis_type));
    178                 localloads++;
    179         }
    180 
    181         return localloads;
    182 }
    183 /*}}}*/

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

    r18926 r23587  
    2424                /*numerics*/
    2525                void  Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    26                 bool  IsPenalty(int analysis);
    27                 int   MaxNumNodes(int analysis);
    28                 int   NumberOfLoads(void);
    29                 int   NumberOfLoads(int analysis);
     26                bool  IsPenalty();
     27                int   MaxNumNodes();
     28                int   NumberOfLoads();
    3029                void  ResetHooks();
    3130                void  SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    32                 int   Size(int analysis);
    33                 int   Size(void);
    34 
    3531};
    3632

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

    r23586 r23587  
    123123}
    124124/*}}}*/
    125 void  Nodes::DistributeDofs(int analysis_type,int setenum){/*{{{*/
     125void  Nodes::DistributeDofs(int setenum){/*{{{*/
    126126
    127127        int  i;
    … …  
    143143        for(i=0;i<this->Size();i++){
    144144                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    145 
    146                 /*Check that this node corresponds to our analysis currently being carried out: */
    147                 _assert_(node->InAnalysis(analysis_type));
    148145                node->DistributeDofs(&dofcount,setenum);
    149146        }
    … …  
    165162                /*Check that this node corresponds to our analysis currently being carried out: */
    166163                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    167                 _assert_(node->InAnalysis(analysis_type));
    168164                node->OffsetDofs(dofcount,setenum);
    169165        }
    … …  
    172168         * object that is not a clone, tell them to show their dofs, so that later on, they can get picked
    173169         * up by their clones: */
    174         maxdofspernode=this->MaxNumDofs(analysis_type,setenum);
    175         numnodes=this->NumberOfNodes(analysis_type);
     170        maxdofspernode=this->MaxNumDofs(setenum);
     171        numnodes=this->NumberOfNodes();
    176172        if(numnodes*maxdofspernode){
    177173                truedofs=   xNewZeroInit<int>(numnodes*maxdofspernode); //initialize to 0, so that we can pick up the max
    … …  
    181177        for(i=0;i<this->Size();i++){
    182178                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    183                 _assert_(node->InAnalysis(analysis_type));
    184179                node->ShowTrueDofs(truedofs,maxdofspernode,setenum);//give maxdofspernode, column size, so that nodes can index into truedofs
    185180        }
    … …  
    190185        for(i=0;i<this->Size();i++){
    191186                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    192                 _assert_(node->InAnalysis(analysis_type));
    193187                node->UpdateCloneDofs(alltruedofs,maxdofspernode,setenum);
    194188        }
    … …  
    197191        for(i=0;i<this->Size();i++){
    198192                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    199                 _assert_(node->InAnalysis(analysis_type));
    200193                node->ReindexingDone();
    201194        }
    … …  
    207200}
    208201/*}}}*/
    209 int   Nodes::MaximumId(){/*{{{*/
    210 
    211         int max=-1;
    212         int id,allmax;
    213 
    214         /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    215         if(!sorted){
    216                 for(int i=0;i<this->Size();i++){
    217                         Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    218                         id=node->Id();
    219                         if(id>max)max=id;
    220                 }
    221         }
    222         else{
    223                 if(this->Size()==0){
    224                         max = 0;
    225                 }
    226                 else{
    227                         Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(this->Size()-1));
    228                         max = node->Id();
    229                 }
     202int   Nodes::MaxNumDofs(int setenum){/*{{{*/
     203
     204        int max=0;
     205        int allmax;
     206
     207        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
     208        for(int i=0;i<this->Size();i++){
     209                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     210
     211                int numdofs=node->GetNumberOfDofs(NoneApproximationEnum,setenum);
     212                if(numdofs>max) max=numdofs;
    230213        }
    231214
    … …  
    237220}
    238221/*}}}*/
    239 int   Nodes::MaxNumDofs(int analysis_type,int setenum){/*{{{*/
    240 
    241         int max=0;
    242         int allmax,numdofs;
    243 
    244         /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    245         for(int i=0;i<this->Size();i++){
    246 
    247                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    248                 _assert_(node->InAnalysis(analysis_type));
    249 
    250                 numdofs=node->GetNumberOfDofs(NoneApproximationEnum,setenum);
    251                 if(numdofs>max)max=numdofs;
    252         }
    253 
    254         /*Grab max of all cpus: */
    255         ISSM_MPI_Allreduce((void*)&max,(void*)&allmax,1,ISSM_MPI_INT,ISSM_MPI_MAX,IssmComm::GetComm());
    256         max=allmax;
    257 
    258         return max;
    259 }
    260 /*}}}*/
    261 int   Nodes::NumberOfDofs(int analysis_type,int setenum){/*{{{*/
     222int   Nodes::NumberOfDofs(int setenum){/*{{{*/
    262223
    263224        int   allnumdofs;
    264225
    265226        /*Get number of dofs on current cpu (excluding clones)*/
    266         int numdofs=this->NumberOfDofsLocal(analysis_type,setenum);
     227        int numdofs=this->NumberOfDofsLocal(setenum);
    267228
    268229        /*Gather from all cpus: */
    … …  
    271232}
    272233/*}}}*/
    273 int   Nodes::NumberOfDofsLocal(int analysis_type,int setenum){/*{{{*/
     234int   Nodes::NumberOfDofsLocal(int setenum){/*{{{*/
    274235
    275236        int   numdofs=0;
    … …  
    277238        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    278239        for(int i=0;i<this->Size();i++){
    279 
    280                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    281                 _assert_(node->InAnalysis(analysis_type));
     240                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    282241
    283242                /*Ok, this object is a node, ask it to plug values into partition: */
    … …  
    311270}
    312271/*}}}*/
    313 int   Nodes::NumberOfNodes(int analysis_type){/*{{{*/
    314 
    315         int i;
    316 
    317         int max_sid=-1;
    318         int sid;
    319         int node_max_sid;
    320 
    321         for(i=0;i<this->Size();i++){
    322 
    323                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    324                 _assert_(node->InAnalysis(analysis_type));
    325 
    326                 sid=node->Sid();
    327                 if(sid>max_sid)max_sid=sid;
    328         }
    329 
    330         ISSM_MPI_Reduce (&max_sid,&node_max_sid,1,ISSM_MPI_INT,ISSM_MPI_MAX,0,IssmComm::GetComm() );
    331         ISSM_MPI_Bcast(&node_max_sid,1,ISSM_MPI_INT,0,IssmComm::GetComm());
    332         max_sid=node_max_sid;
    333 
    334         /*sid starts at 0*/
    335         max_sid++;
    336 
    337         /*return*/
    338         return max_sid;
    339 }
    340 /*}}}*/
    341 void  Nodes::Ranks(int* ranks,int analysis_type){/*{{{*/
    342 
    343         int my_rank;
    344         int sid;
    345 
    346         /*recover my_rank:*/
    347         my_rank=IssmComm::GetRank();
    348 
    349         /*Go through nodes, and for each object, report it cpu: */
    350         for(int i=0;i<this->Size();i++){
    351 
    352                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    353                 _assert_(node->InAnalysis(analysis_type));
    354 
    355                 /*Plug rank into ranks, according to sid: */
    356                 sid=node->Sid();
    357                 ranks[sid]=my_rank;
    358         }
    359 }
    360 /*}}}*/
    361 bool Nodes::RequiresDofReindexing(int analysis_type){/*{{{*/
     272bool Nodes::RequiresDofReindexing(void){/*{{{*/
    362273
    363274        int flag = 0;
    … …  
    366277        /*Now go through all nodes, and get how many dofs they own, unless they are clone nodes: */
    367278        for(int i=0;i<this->Size();i++){
    368 
    369                 Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    370                 _assert_(node->InAnalysis(analysis_type));
    371 
     279                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
    372280                if(node->RequiresDofReindexing()){
    373281                        flag = 1;

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

    r23586 r23587  
    3333
    3434                /*numerics*/
    35                 void  DistributeDofs(int analysis_type,int SETENUM);
    36                 int   MaximumId(void);
    37                 int   MaxNumDofs(int analysis_type,int setenum);
    38                 int   NumberOfDofs(int analysis_type,int setenum);
    39                 int   NumberOfDofsLocal(int analysis_type,int setenum);
    40                 int   NumberOfNodes(int analysis_type);
     35                void  DistributeDofs(int SETENUM);
     36                int   MaxNumDofs(int setenum);
     37                int   NumberOfDofs(int setenum);
     38                int   NumberOfDofsLocal(int setenum);
    4139                int   NumberOfNodes(void);
    42                 void  Ranks(int* ranks,int analysis_type);
    43                 bool  RequiresDofReindexing(int analysis_type);
    44 
     40                bool  RequiresDofReindexing(void);
    4541};
    4642

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

    r23232 r23587  
    2121        Vector<IssmDouble> *U_y    = NULL;
    2222        bool save_results,isesa,iscoupler;
    23         int configuration_type;
    2423        int domaintype;
    2524        int solution_type;
    … …  
    3938        /*Recover some parameters: */
    4039        femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
    41         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    4240        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    4341        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    … …  
    5048
    5149        /*Figure out size of g-set deflection vector and allocate solution vector: */
    52         gsize      = femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     50        gsize      = femmodel->nodes->NumberOfDofs(GsetEnum);
    5351
    5452        /*several cases here, depending on value of iscoupler and isesa:

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

    r23232 r23587  
    8282        bool iscoupler;
    8383        int  solution_type;
    84         int  configuration_type;
    8584        int  modelid,earthid;
    8685        bool istransientmasstransport;
    … …  
    10099        femmodel->parameters->FindParam(&frequency,SealevelriseGeodeticRunFrequencyEnum);
    101100        femmodel->parameters->FindParam(&count,SealevelriseRunCountEnum);
    102         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    103101        femmodel->parameters->FindParam(&horiz,SealevelriseHorizEnum);
    104102        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    301299
    302300        /*parameters: */
    303         int  configuration_type;
    304301        int  gsize;
    305302        bool spherical=true;
    … …  
    313310
    314311        /*recover parameters:*/
    315         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    316312        femmodel->parameters->FindParam(&loop,SealevelriseLoopIncrementEnum);
    317313
    … …  
    320316
    321317        /*Figure out size of g-set deflection vector and allocate solution vector: */
    322         gsize = femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     318        gsize = femmodel->nodes->NumberOfDofs(GsetEnum);
    323319
    324320        /*Initialize:*/
    … …  
    360356        bool save_results;
    361357        int  gsize;
    362         int  configuration_type;
    363358        bool spherical=true;
    364359        bool converged=true;
    … …  
    379374        femmodel->parameters->FindParam(&eps_rel,SealevelriseReltolEnum);
    380375        femmodel->parameters->FindParam(&eps_abs,SealevelriseAbstolEnum);
    381         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    382376        femmodel->parameters->FindParam(&loop,SealevelriseLoopIncrementEnum);
    383377
    … …  
    389383
    390384        /*Figure out size of g-set deflection vector and allocate solution vector: */
    391         gsize = femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     385        gsize = femmodel->nodes->NumberOfDofs(GsetEnum);
    392386
    393387        /*Initialize:*/
    … …  
    477471
    478472        /*parameters: */
    479         int configuration_type;
    480473        int  gsize;
    481474        bool spherical=true;
    … …  
    491484
    492485        /*retrieve some parameters:*/
    493         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    494486        femmodel->parameters->FindParam(&loop,SealevelriseLoopIncrementEnum);
    495487        femmodel->parameters->FindParam(&horiz,SealevelriseHorizEnum);
    496488
    497489        /*find size of vectors:*/
    498         gsize      = femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     490        gsize      = femmodel->nodes->NumberOfDofs(GsetEnum);
    499491
    500492        /*intialize vectors:*/

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

    r23499 r23587  
    1212        int  fsize,ssize,flocalsize,slocalsize;
    1313        int  connectivity, numberofdofspernode;
    14         int  configuration_type;
    1514        int  m,n,M,N;
    1615        int *d_nnz = NULL;
    … …  
    2726
    2827        /*retrieve parameters: */
    29         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3028        femmodel->parameters->FindParam(&connectivity,MeshAverageVertexConnectivityEnum);
    3129
    3230        /*retrieve node info*/
    33         fsize      = femmodel->nodes->NumberOfDofs(configuration_type,FsetEnum);
    34         ssize      = femmodel->nodes->NumberOfDofs(configuration_type,SsetEnum);
    35         flocalsize = femmodel->nodes->NumberOfDofsLocal(configuration_type,FsetEnum);
    36         slocalsize = femmodel->nodes->NumberOfDofsLocal(configuration_type,SsetEnum);
    37 
    38         numberofdofspernode=femmodel->nodes->MaxNumDofs(configuration_type,GsetEnum);
     31        fsize      = femmodel->nodes->NumberOfDofs(FsetEnum);
     32        ssize      = femmodel->nodes->NumberOfDofs(SsetEnum);
     33        flocalsize = femmodel->nodes->NumberOfDofsLocal(FsetEnum);
     34        slocalsize = femmodel->nodes->NumberOfDofsLocal(SsetEnum);
     35
     36        numberofdofspernode=femmodel->nodes->MaxNumDofs(GsetEnum);
    3937
    4038        /*if our matrices are coming from issm, we don't do dynamic allocation like Petsc
    … …  
    9391        /*Intermediary*/
    9492        int      i,j,k,index,offset,count;
    95         int      configuration_type;
    9693        int      d_nz,o_nz;
    9794        Element *element            = NULL;
    … …  
    109106        int *o_nnz = NULL;
    110107
    111         /*retrive parameters: */
    112         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    113 
    114108        /*Get vector size and number of nodes*/
    115         int numnodes            = femmodel->nodes->NumberOfNodes(configuration_type);
     109        int numnodes            = femmodel->nodes->NumberOfNodes();
    116110        int localnumnodes       = femmodel->nodes->Size();
    117         int numberofdofspernode = femmodel->nodes->MaxNumDofs(configuration_type,GsetEnum);
    118         int M                   = femmodel->nodes->NumberOfDofs(configuration_type,set1enum);
    119         int N                   = femmodel->nodes->NumberOfDofs(configuration_type,set2enum);
    120         int m                   = femmodel->nodes->NumberOfDofsLocal(configuration_type,set1enum);
    121         int n                   = femmodel->nodes->NumberOfDofsLocal(configuration_type,set2enum);
     111        int numberofdofspernode = femmodel->nodes->MaxNumDofs(GsetEnum);
     112        int M                   = femmodel->nodes->NumberOfDofs(set1enum);
     113        int N                   = femmodel->nodes->NumberOfDofs(set2enum);
     114        int m                   = femmodel->nodes->NumberOfDofsLocal(set1enum);
     115        int n                   = femmodel->nodes->NumberOfDofsLocal(set2enum);
    122116        int numnodesperelement  = femmodel->elements->MaxNumNodes();
    123         int numnodesperload     = femmodel->loads->MaxNumNodes(configuration_type);
     117        int numnodesperload     = femmodel->loads->MaxNumNodes();
    124118
    125119        /*First, we are building chaining vectors so that we know what nodes are
    … …  
    153147        /*Chain for loads*/
    154148        head_l         = xNew<int>(localnumnodes); for(i=0;i<localnumnodes;i++) head_l[i]=-1;
    155         next_l         = xNew<int>(femmodel->loads->Size(configuration_type)*numnodesperload);
    156         count2offset_l = xNew<int>(femmodel->loads->Size(configuration_type)*numnodesperload);
     149        next_l         = xNew<int>(femmodel->loads->Size()*numnodesperload);
     150        count2offset_l = xNew<int>(femmodel->loads->Size()*numnodesperload);
    157151        k=0;
    158152        for(i=0;i<femmodel->loads->Size();i++){
    159153                load = xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    160                 _assert_(load->InAnalysis(configuration_type));
    161154                lidlist = xNew<int>(load->GetNumberOfNodes());
    162155                load->GetNodesLidList(lidlist);
    … …  
    191184        for(i=0;i<femmodel->nodes->Size();i++){
    192185                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    193                 _assert_(node->InAnalysis(configuration_type));
    194186
    195187                /*Reinitialize flags to false*/
    … …  
    257249                        Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    258250                        if(!node->IsClone()){
    259                                 _assert_(node->InAnalysis(configuration_type));
    260251                                for(j=0;j<node->indexing.fsize;j++){
    261252                                        _assert_(count<m);

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

    r23499 r23587  
    88#include "../../toolkits/toolkits.h"
    99
    10 void CreateNodalConstraintsx( Vector<IssmDouble>** pys, Nodes* nodes,int configuration_type){
     10void CreateNodalConstraintsx( Vector<IssmDouble>** pys, Nodes* nodes){
    1111
    1212        bool  oldalloc  = false;
    … …  
    2020
    2121        /*figure out how many dofs we have: */
    22         ssize=nodes->NumberOfDofs(configuration_type,SsetEnum);
    23         slocalsize = nodes->NumberOfDofsLocal(configuration_type,SsetEnum);
     22        ssize=nodes->NumberOfDofs(SsetEnum);
     23        slocalsize = nodes->NumberOfDofsLocal(SsetEnum);
    2424
    2525        /*allocate:*/
    … …  
    3333        for(int i=0;i<nodes->Size();i++){
    3434                Node* node=(Node*)nodes->GetObjectByOffset(i);
    35                 _assert_(node->InAnalysis(configuration_type));
    3635                node->CreateNodalConstraints(ys);
    3736        }

  • issm/trunk-jpl/src/c/modules/CreateNodalConstraintsx/CreateNodalConstraintsx.h

    r15000 r23587  
    88
    99/* local prototypes: */
    10 void CreateNodalConstraintsx( Vector<IssmDouble>** pys, Nodes* nodes,int configuration_type);
     10void CreateNodalConstraintsx( Vector<IssmDouble>** pys, Nodes* nodes);
    1111
    1212#endif  /* _CREATENODALCONSTRAINTSX_H */

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

    r18521 r23587  
    1010
    1111        /*intermediary: */
    12         int      gsize;
    13         int      configuration,analysisenum;
     12        int gsize;
     13        int analysisenum;
    1414
    1515        /*output: */
    … …  
    1919
    2020        /*retrive parameters: */
    21         femmodel->parameters->FindParam(&configuration,ConfigurationTypeEnum);
    2221        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    2322
    2423        /*Get size of vector: */
    25         gsize=femmodel->nodes->NumberOfDofs(configuration,GsetEnum);
    26         if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration "<<EnumToStringx(configuration));
     24        gsize=femmodel->nodes->NumberOfDofs(GsetEnum);
     25        if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 ");
    2726
    2827        /*Initialize solution: */

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

    r15104 r23587  
    1313
    1414        /*intermediary: */
    15         int configuration_type;
    1615        int gsize,fsize,ssize;
    1716
    … …  
    2019
    2120        /*first, get gsize, fsize and ssize: */
    22         parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    23         gsize=nodes->NumberOfDofs(configuration_type,GsetEnum);
    24         fsize=nodes->NumberOfDofs(configuration_type,FsetEnum);
    25         ssize=nodes->NumberOfDofs(configuration_type,SsetEnum);
     21        gsize=nodes->NumberOfDofs(GsetEnum);
     22        fsize=nodes->NumberOfDofs(FsetEnum);
     23        ssize=nodes->NumberOfDofs(SsetEnum);
    2624
    2725        /*serialize uf and ys: those two vectors will be indexed by the nodes, who are the only ones

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

    r23586 r23587  
    88#include "../../toolkits/toolkits.h"
    99
    10 void NodesDofx(Nodes* nodes, Parameters* parameters,int configuration_type){
     10void NodesDofx(Nodes* nodes, Parameters* parameters){
    1111
    1212        /*Do we have any nodes for this analysis type? :*/
    13         if(!nodes->NumberOfNodes(configuration_type)) return;
     13        if(!nodes->NumberOfNodes()) return;
    1414
    1515        /*Do we really need to update dof indexings*/
    16         if(!nodes->RequiresDofReindexing(configuration_type)) return;
     16        if(!nodes->RequiresDofReindexing()) return;
    1717
    1818        if(VerboseModule()) _printf0_("   Renumbering degrees of freedom\n");
    … …  
    2121         *a  node has already been distributed dofs on one cpu, all other cpus with the same node cannot distribute it
    2222         *anymore. Use clone field to be sure of that: */
    23         nodes->DistributeDofs(configuration_type,GsetEnum);
    24         nodes->DistributeDofs(configuration_type,FsetEnum);
    25         nodes->DistributeDofs(configuration_type,SsetEnum);
     23        nodes->DistributeDofs(GsetEnum);
     24        nodes->DistributeDofs(FsetEnum);
     25        nodes->DistributeDofs(SsetEnum);
    2626
    2727}

  • issm/trunk-jpl/src/c/modules/NodesDofx/NodesDofx.h

    r15000 r23587  
    99
    1010/* local prototypes: */
    11 void NodesDofx(Nodes* nodes, Parameters* parameters,int analysis_type);
     11void NodesDofx(Nodes* nodes, Parameters* parameters);
    1212
    1313#endif  /* _NODESDOFX_H */

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

    r23499 r23587  
    1212
    1313        /*variables: */
    14         int         configuration_type;
    15         int         fsize;
    1614        IssmDouble *ug_serial = NULL;
    1715        bool        oldalloc  = false;
    … …  
    2018
    2119        /*first figure out fsize: */
    22         parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    23         fsize=nodes->NumberOfDofs(configuration_type,FsetEnum);
    24 
    25         int    analysis_type;
    26         parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    27         int flocalsize = nodes->NumberOfDofsLocal(analysis_type,FsetEnum);
     20        int fsize=nodes->NumberOfDofs(FsetEnum);
     21        int flocalsize = nodes->NumberOfDofsLocal(FsetEnum);
    2822
    2923        if(fsize==0){
    … …  
    3731                 uf=new Vector<IssmDouble>(flocalsize,fsize);
    3832
    39                 if(nodes->NumberOfNodes(configuration_type)){
     33                if(nodes->NumberOfNodes()){
    4034
    4135                        /*serialize ug, so nodes can index into it: */
    … …  
    4539                        for(int i=0;i<nodes->Size();i++){
    4640                                Node* node=(Node*)nodes->GetObjectByOffset(i);
    47                                 _assert_(node->InAnalysis(configuration_type));
    4841
    4942                                /*For this object, reduce values for enum set Fset: */

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

    r23524 r23587  
    8585
    8686        /*Create vector on gset*/
    87         int configuration_type;
    88         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    89         int gsize=femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
     87        int gsize=femmodel->nodes->NumberOfDofs(GsetEnum);
    9088        if(gsize==0)  return;
    9189        Vector<IssmDouble>* vec_mask_ice=new Vector<IssmDouble>(gsize);

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

    r23583 r23587  
    88#include "../../toolkits/toolkits.h"
    99
    10 void SpcNodesx(Nodes* nodes,Constraints* constraints,Parameters* parameters, int analysis_type){
     10void SpcNodesx(Nodes* nodes,Constraints* constraints,Parameters* parameters){
    1111
    1212        for(int i=0;i<constraints->Size();i++){
    13 
    1413                Constraint* constraint=(Constraint*)constraints->GetObjectByOffset(i);
    15 
    16                 _assert_(constraint->InAnalysis(analysis_type));
    1714                constraint->ConstrainNode(nodes,parameters);
    1815        }

  • issm/trunk-jpl/src/c/modules/SpcNodesx/SpcNodesx.h

    r15000 r23587  
    1010
    1111/* local prototypes: */
    12 void SpcNodesx(Nodes* nodes, Constraints* constraints,Parameters* parameters,int analysis_type);
     12void SpcNodesx(Nodes* nodes, Constraints* constraints,Parameters* parameters);
    1313
    1414#endif  /* _SPCNODESX_H */

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

    r23490 r23587  
    1212        /*intermediary: */
    1313        int      i,M,N;
    14         int      configuration_type,analysisenum;
     14        int      analysisenum;
    1515        Element *element = NULL;
    1616        Load    *load    = NULL;
    … …  
    2727
    2828        /*retrieve parameters: */
    29         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3029        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    3130        Analysis* analysis = EnumToAnalysis(analysisenum);
    3231
    3332        /*Check if there are penalties*/
    34         bool ispenalty = femmodel->loads->IsPenalty(configuration_type);
     33        bool ispenalty = femmodel->loads->IsPenalty();
    3534
    3635        /*First, we might need to do a dry run to get kmax if penalties are employed*/
    … …  
    5453                for (i=0;i<femmodel->loads->Size();i++){
    5554                        load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    56                         _assert_(load->InAnalysis(configuration_type));
    5755                        load->CreateKMatrix(Kff_temp,NULL);
    5856                }
    … …  
    9088        for(i=0;i<femmodel->loads->Size();i++){
    9189                load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    92                 _assert_(load->InAnalysis(configuration_type));
    9390                load->CreateKMatrix(Kff,Kfs);
    9491                load->CreatePVector(pf);
    … …  
    9996                for (i=0;i<femmodel->loads->Size();i++){
    10097                        load=xDynamicCast<Load*>(femmodel->loads->GetObjectByOffset(i));
    101                         _assert_(load->InAnalysis(configuration_type));
    10298                        load->PenaltyCreateKMatrix(Kff,Kfs,kmax);
    10399                        load->PenaltyCreatePVector(pf,kmax);

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

    r23499 r23587  
    99void VecMergex(Vector<IssmDouble>* ug, Vector<IssmDouble>* uf, Nodes* nodes, Parameters* parameters, int SetEnum){
    1010
    11         /*variables: */
    12         int i;
    13         int configuration_type;
    14         IssmDouble* uf_serial=NULL;
    15 
    16         /*retrieve parameters: */
    17         parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    18 
    1911        /*serialize uf: */
    20         uf_serial=uf->ToMPISerial();
     12        IssmDouble* uf_serial=uf->ToMPISerial();
    2113
    2214        /*Do we have any nodes for this configuration? :*/
    23         if(nodes->NumberOfNodes(configuration_type)){
     15        if(nodes->NumberOfNodes()){
    2416
    2517                /*yes. Go through all nodes, and ask them to retrieve values from uf, and plug them into ug: */
    26                 for(i=0;i<nodes->Size();i++){
    27 
     18                for(int i=0;i<nodes->Size();i++){
    2819                        Node* node=(Node*)nodes->GetObjectByOffset(i);
    29                         _assert_(node->InAnalysis(configuration_type));
    3020
    3121                        /*For this object, merge values for enum set SetEnum: */
    … …  
    3323                }
    3424        }
     25
    3526        /*Free ressources:*/
    3627        xDelete<IssmDouble>(uf_serial);

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_adjoint_linear.cpp

    r22551 r23587  
    2020        Vector<IssmDouble>*  df  = NULL;
    2121        Vector<IssmDouble>*  ys  = NULL;
    22         int  configuration_type;
    2322
    2423        /*Recover parameters: */
    25         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2624        femmodel->UpdateConstraintsx();
    2725
    2826        SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL,femmodel);
    29         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     27        CreateNodalConstraintsx(&ys,femmodel->nodes);
    3028        Reduceloadx(pf, Kfs, ys,true); delete Kfs; //true means spc = 0
    3129

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

    r23524 r23587  
    101101                                if(VerboseSolution()) _printf0_("Building Sediment Matrix...\n");
    102102                                SystemMatricesx(&Kff,&Kfs,&pf,&df,&sediment_kmax,femmodel);
    103                                 CreateNodalConstraintsx(&ys,femmodel->nodes,HydrologyDCInefficientAnalysisEnum);
     103                                CreateNodalConstraintsx(&ys,femmodel->nodes);
    104104                                Reduceloadx(pf,Kfs,ys); delete Kfs;
    105105                                delete uf_sed;
    … …  
    187187                                if(VerboseSolution()) _printf0_("Building EPL Matrix...\n");
    188188                                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    189                                 CreateNodalConstraintsx(&ys,femmodel->nodes,HydrologyDCEfficientAnalysisEnum);
     189                                CreateNodalConstraintsx(&ys,femmodel->nodes);
    190190                                Reduceloadx(pf,Kfs,ys); delete Kfs;
    191191                                delete uf_epl;

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_la.cpp

    r22551 r23587  
    2121        Vector<IssmDouble>*  pug_old = NULL;
    2222        IssmDouble           eps_rel,r,theta; // 0<theta<.5   -> .15<theta<.45
    23         int                  configuration_type,max_nonlinear_iterations;
     23        int                  max_nonlinear_iterations;
    2424        bool                 vel_converged      = false;
    2525        bool                 pressure_converged = false;
    … …  
    3131
    3232        /*Recover parameters: */
    33         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3433        femmodel->parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
    3534        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    … …  
    6059                        /*Solve KU=F*/
    6160                        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    62                         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    6361                        SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    64                         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     62                        CreateNodalConstraintsx(&ys,femmodel->nodes);
    6563                        Reduceloadx(pf, Kfs, ys); delete Kfs;
    6664
    … …  
    9593
    9694                femmodel->SetCurrentConfiguration(UzawaPressureAnalysisEnum);
    97                 femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    9895                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    99                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     96                CreateNodalConstraintsx(&ys,femmodel->nodes);
    10097                Reduceloadx(pf, Kfs, ys); delete Kfs;
    10198

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_la_theta.cpp

    r22551 r23587  
    2020        Vector<IssmDouble>*  ys     = NULL;
    2121        IssmDouble           eps_rel,r,theta; // 0<theta<.5   -> .15<theta<.45
    22         int                  configuration_type,max_nonlinear_iterations;
     22        int                  max_nonlinear_iterations;
    2323
    2424        /*Create analysis*/
    … …  
    2626
    2727        /*Recover parameters: */
    28         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2928        femmodel->parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
    3029        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    … …  
    5756                /*Solve KU=F*/
    5857                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    59                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     58                CreateNodalConstraintsx(&ys,femmodel->nodes);
    6059                Reduceloadx(pf, Kfs, ys); delete Kfs;
    6160

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_linear.cpp

    r23066 r23587  
    1818        Vector<IssmDouble>*  df  = NULL;
    1919        Vector<IssmDouble>*  ys  = NULL;
    20         int  configuration_type;
    2120        IssmDouble solver_residue_threshold;
    2221
    … …  
    2928
    3029        /*Recover parameters: */
    31         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3230        femmodel->parameters->FindParam(&solver_residue_threshold,SettingsSolverResidueThresholdEnum);
    3331        femmodel->UpdateConstraintsx();
    3432        SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    35         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     33        CreateNodalConstraintsx(&ys,femmodel->nodes);
    3634        Reduceloadx(pf, Kfs, ys); delete Kfs;
    3735

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp

    r22551 r23587  
    3030        /*parameters:*/
    3131        int max_nonlinear_iterations;
    32         int configuration_type;
    3332        IssmDouble eps_res,eps_rel,eps_abs;
    3433
    3534        /*Recover parameters: */
    3635        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    37         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3836        femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
    3937        femmodel->parameters->FindParam(&eps_res,StressbalanceRestolEnum);
    … …  
    6159                if(count==1 || newton==2){
    6260                        SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    63                         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     61                        CreateNodalConstraintsx(&ys,femmodel->nodes);
    6462                        Reduceloadx(pf,Kfs,ys);delete Kfs;
    6563                        femmodel->profiler->Start(SOLVER);
    … …  
    7573                /*Prepare next iteration using Newton's method*/
    7674                SystemMatricesx(&Kff,&Kfs,&pf,&df,&kmax,femmodel);delete df;
    77                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     75                CreateNodalConstraintsx(&ys,femmodel->nodes);
    7876                Reduceloadx(pf,Kfs,ys);delete Kfs;
    7977

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp

    r23488 r23587  
    6565
    6666                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    67                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     67                CreateNodalConstraintsx(&ys,femmodel->nodes);
    6868                Reduceloadx(pf, Kfs, ys); delete Kfs;
    6969                femmodel->profiler->Start(SOLVER);

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

    r23220 r23587  
    495495        /*parameters:*/
    496496        int max_nonlinear_iterations;
    497         int configuration_type;
    498497        IssmDouble eps_res,eps_rel,eps_abs;
    499498
    … …  
    503502        femmodel->parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
    504503        femmodel->parameters->FindParam(&eps_abs,StressbalanceAbstolEnum);
    505         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    506504        femmodel->UpdateConstraintsx();
    507505        int size;
    … …  
    525523                /*Get stiffness matrix and Load vector*/
    526524                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    527                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     525                CreateNodalConstraintsx(&ys,femmodel->nodes);
    528526                Reduceloadx(pf, Kfs, ys); delete Kfs;
    529527

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_shakti_nonlinear.cpp

    r22551 r23587  
    2323        /*parameters:*/
    2424        int max_nonlinear_iterations;
    25         int configuration_type;
    2625        IssmDouble eps_res,eps_rel,eps_abs;
    2726
    … …  
    3130        femmodel->parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
    3231        femmodel->parameters->FindParam(&eps_abs,StressbalanceAbstolEnum);
    33         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3432        femmodel->UpdateConstraintsx();
    3533
    … …  
    5048
    5149                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
    52                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     50                CreateNodalConstraintsx(&ys,femmodel->nodes);
    5351                Reduceloadx(pf, Kfs, ys); delete Kfs;
    5452                femmodel->profiler->Start(SOLVER);

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp

    r22551 r23587  
    3232        int  min_mechanical_constraints;
    3333        int  max_nonlinear_iterations;
    34         int  configuration_type;
    3534        IssmDouble eps_res,eps_rel,eps_abs;
    3635
    … …  
    5554                /*First stressbalance horiz:*/
    5655                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    57                 femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    5856
    5957                //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    … …  
    6664                /*solve: */
    6765                SystemMatricesx(&Kff_horiz, &Kfs_horiz, &pf_horiz, &df_horiz, NULL,femmodel);
    68                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     66                CreateNodalConstraintsx(&ys,femmodel->nodes);
    6967                Reduceloadx(pf_horiz, Kfs_horiz, ys); delete Kfs_horiz;
    7068                femmodel->profiler->Start(SOLVER);
    … …  
    7876                /*Second compute vertical velocity: */
    7977                femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum);
    80                 femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    8178
    8279                /*solve: */
    8380                SystemMatricesx(&Kff_vert, &Kfs_vert, &pf_vert, &df_vert,NULL,femmodel);
    84                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     81                CreateNodalConstraintsx(&ys,femmodel->nodes);
    8582                Reduceloadx(pf_vert, Kfs_vert, ys); delete Kfs_vert;
    8683                femmodel->profiler->Start(SOLVER);

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_thermal_nonlinear.cpp

    r23524 r23587  
    3333
    3434        /*parameters:*/
    35         int  configuration_type;
    3635        IssmDouble eps_rel;
    3736
    3837        /*Recover parameters: */
    3938        femmodel->parameters->FindParam(&isenthalpy,ThermalIsenthalpyEnum);
    40         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    4139        femmodel->parameters->FindParam(&thermal_maxiter,ThermalMaxiterEnum);
    4240
    … …  
    7573                else SystemMatricesx(&Kff, &Kfs, &pf,&df, &melting_offset,femmodel);
    7674                delete tg;
    77                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
     75                CreateNodalConstraintsx(&ys,femmodel->nodes);
    7876                Reduceloadx(pf, Kfs, ys); delete Kfs;
    7977                femmodel->profiler->Start(SOLVER);
Note: See TracChangeset for help on using the changeset viewer.