Changeset 23612


Ignore:
Timestamp:
01/08/19 21:31:29 (6 years ago)
Author:
Mathieu Morlighem
Message:

CHG: merging Dofindexing and node

Location:
issm/trunk-jpl/src/c
Files:
2 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/Makefile.am

    r23602 r23612  
    7777                                        ./classes/Constraints/SpcTransient.cpp\
    7878                                        ./classes/DependentObject.cpp\
    79                                         ./classes/DofIndexing.cpp\
    8079                                        ./classes/Contours.cpp\
    8180                                        ./classes/Vertices.cpp\

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

    r23540 r23612  
    29702970                        switch(set2_enum){
    29712971                                case FsetEnum:
    2972                                         if(nodes[i]->indexing.fsize){
     2972                                        if(nodes[i]->fsize){
    29732973                                                if(this->nodes[i]->IsClone())
    29742974                                                 o_nz += 1;
    … …  
    29782978                                        break;
    29792979                                case GsetEnum:
    2980                                         if(nodes[i]->indexing.gsize){
     2980                                        if(nodes[i]->gsize){
    29812981                                                if(this->nodes[i]->IsClone())
    29822982                                                 o_nz += 1;
    … …  
    29862986                                        break;
    29872987                                case SsetEnum:
    2988                                         if(nodes[i]->indexing.ssize){
     2988                                        if(nodes[i]->ssize){
    29892989                                                if(this->nodes[i]->IsClone())
    29902990                                                 o_nz += 1;

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

    r23588 r23612  
    272272                switch(set2_enum){
    273273                        case FsetEnum:
    274                                 if(node->indexing.fsize){
     274                                if(node->fsize){
    275275                                        if(this->node->IsClone())
    276276                                         o_nz += 1;
    … …  
    280280                                break;
    281281                        case GsetEnum:
    282                                 if(node->indexing.gsize){
     282                                if(node->gsize){
    283283                                        if(this->node->IsClone())
    284284                                         o_nz += 1;
    … …  
    288288                                break;
    289289                        case SsetEnum:
    290                                 if(node->indexing.ssize){
     290                                if(node->ssize){
    291291                                        if(this->node->IsClone())
    292292                                         o_nz += 1;

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

    r23588 r23612  
    305305                        switch(set2_enum){
    306306                                case FsetEnum:
    307                                         if(nodes[i]->indexing.fsize){
     307                                        if(nodes[i]->fsize){
    308308                                                if(this->nodes[i]->IsClone())
    309309                                                 o_nz += 1;
    … …  
    313313                                        break;
    314314                                case GsetEnum:
    315                                         if(nodes[i]->indexing.gsize){
     315                                        if(nodes[i]->gsize){
    316316                                                if(this->nodes[i]->IsClone())
    317317                                                 o_nz += 1;
    … …  
    321321                                        break;
    322322                                case SsetEnum:
    323                                         if(nodes[i]->indexing.ssize){
     323                                        if(nodes[i]->ssize){
    324324                                                if(this->nodes[i]->IsClone())
    325325                                                 o_nz += 1;

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

    r23588 r23612  
    404404                        switch(set2_enum){
    405405                                case FsetEnum:
    406                                         if(nodes[i]->indexing.fsize){
     406                                        if(nodes[i]->fsize){
    407407                                                if(this->nodes[i]->IsClone())
    408408                                                 o_nz += 1;
    … …  
    412412                                        break;
    413413                                case GsetEnum:
    414                                         if(nodes[i]->indexing.gsize){
     414                                        if(nodes[i]->gsize){
    415415                                                if(this->nodes[i]->IsClone())
    416416                                                 o_nz += 1;
    … …  
    420420                                        break;
    421421                                case SsetEnum:
    422                                         if(nodes[i]->indexing.ssize){
     422                                        if(nodes[i]->ssize){
    423423                                                if(this->nodes[i]->IsClone())
    424424                                                 o_nz += 1;

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

    r23588 r23612  
    317317                switch(set2_enum){
    318318                        case FsetEnum:
    319                                 if(node->indexing.fsize){
     319                                if(node->fsize){
    320320                                        if(this->node->IsClone())
    321321                                         o_nz += 1;
    … …  
    325325                                break;
    326326                        case GsetEnum:
    327                                 if(node->indexing.gsize){
     327                                if(node->gsize){
    328328                                        if(this->node->IsClone())
    329329                                         o_nz += 1;
    … …  
    333333                                break;
    334334                        case SsetEnum:
    335                                 if(node->indexing.ssize){
     335                                if(node->ssize){
    336336                                        if(this->node->IsClone())
    337337                                         o_nz += 1;

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

    r23588 r23612  
    240240                        switch(set2_enum){
    241241                                case FsetEnum:
    242                                         if(nodes[i]->indexing.fsize){
     242                                        if(nodes[i]->fsize){
    243243                                                if(this->nodes[i]->IsClone())
    244244                                                 o_nz += 1;
    … …  
    248248                                        break;
    249249                                case GsetEnum:
    250                                         if(nodes[i]->indexing.gsize){
     250                                        if(nodes[i]->gsize){
    251251                                                if(this->nodes[i]->IsClone())
    252252                                                 o_nz += 1;
    … …  
    256256                                        break;
    257257                                case SsetEnum:
    258                                         if(nodes[i]->indexing.ssize){
     258                                        if(nodes[i]->ssize){
    259259                                                if(this->nodes[i]->IsClone())
    260260                                                 o_nz += 1;

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

    r23588 r23612  
    401401                        switch(set2_enum){
    402402                                case FsetEnum:
    403                                         if(nodes[i]->indexing.fsize){
     403                                        if(nodes[i]->fsize){
    404404                                                if(this->nodes[i]->IsClone())
    405405                                                 o_nz += 1;
    … …  
    409409                                        break;
    410410                                case GsetEnum:
    411                                         if(nodes[i]->indexing.gsize){
     411                                        if(nodes[i]->gsize){
    412412                                                if(this->nodes[i]->IsClone())
    413413                                                 o_nz += 1;
    … …  
    417417                                        break;
    418418                                case SsetEnum:
    419                                         if(nodes[i]->indexing.ssize){
     419                                        if(nodes[i]->ssize){
    420420                                                if(this->nodes[i]->IsClone())
    421421                                                 o_nz += 1;

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

    r23602 r23612  
    1919Node::Node(){/*{{{*/
    2020        this->approximation=0;
    21 }
    22 /*}}}*/
    23 Node::Node(int node_id,int node_sid,int node_lid,int node_pid,int io_index,bool isclone,IoModel* iomodel,int analysis_enum,int in_approximation,bool isamr){/*{{{*/
    24 
    25         /*Intermediary*/
    26         int k,l;
    27         int *doftypes = NULL;
     21
     22        this->gsize    = -1;
     23        this->fsize    = -1;
     24        this->ssize    = -1;
     25        this->clone    = false;
     26        this->active   = true;
     27        this->freeze   = false;
     28        this->f_set    = NULL;
     29        this->s_set    = NULL;
     30        this->svalues  = NULL;
     31        this->doftype  = NULL;
     32        this->gdoflist = NULL;
     33        this->fdoflist = NULL;
     34        this->sdoflist = NULL;
     35}
     36/*}}}*/
     37Node::Node(int node_id,int node_sid,int node_lid,int node_pid,int io_index,bool node_clone,IoModel* iomodel,int node_analysis,int in_approximation,bool isamr){/*{{{*/
    2838
    2939        /*id: */
    … …  
    3242        this->lid           = node_lid;
    3343        this->pid           = node_pid;
    34         this->analysis_enum = analysis_enum;
     44        this->analysis_enum = node_analysis;
     45        this->clone         = node_clone;
    3546
    3647        /*Initialize coord_system: Identity matrix by default*/
    37         for(k=0;k<3;k++) for(l=0;l<3;l++) this->coord_system[k][l]=0.0;
    38         for(k=0;k<3;k++) this->coord_system[k][k]=1.0;
     48        for(int k=0;k<3;k++) for(int l=0;l<3;l++) this->coord_system[k][l]=0.0;
     49        for(int k=0;k<3;k++) this->coord_system[k][k]=1.0;
     50
     51        this->gsize    = -1;
     52        this->fsize    = -1;
     53        this->ssize    = -1;
     54        this->active   = true;
     55        this->freeze   = false;
     56        this->f_set    = NULL;
     57        this->s_set    = NULL;
     58        this->svalues  = NULL;
     59        this->doftype  = NULL;
     60        this->gdoflist = NULL;
     61        this->fdoflist = NULL;
     62        this->sdoflist = NULL;
    3963
    4064        /*indexing:*/
    4165        this->indexingupdate = true;
    42 
    43         Analysis* analysis = EnumToAnalysis(analysis_enum);
    44         int numdofs        = analysis->DofsPerNode(&doftypes,iomodel->domaintype,in_approximation);
    45         indexing.Init(numdofs,isclone,doftypes);
    46         xDelete<int>(doftypes);
     66        Analysis *analysis = EnumToAnalysis(analysis_enum);
     67        int      *doftypes = NULL;
     68        this->gsize = analysis->DofsPerNode(&this->doftype,iomodel->domaintype,in_approximation);
     69        if(this->gsize>0){
     70                this->f_set    = xNew<bool>(this->gsize);
     71                this->s_set    = xNew<bool>(this->gsize);
     72                this->svalues  = xNew<IssmDouble>(this->gsize);
     73                this->gdoflist = xNew<int>(this->gsize);
     74        }
     75
     76        /*Assign values assuming no Dirichlet at this point*/
     77        for(int i=0;i<this->gsize;i++){
     78                this->f_set[i]    = true;
     79                this->s_set[i]    = false;
     80                this->svalues[i]  = 0.;
     81                this->gdoflist[i] = -1;
     82        }
    4783        delete analysis;
    4884
    … …  
    80116                        if(in_approximation==SSAFSApproximationEnum && reCast<int>(iomodel->Data("md.flowequation.borderSSA")[io_index])){
    81117                                if(!reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
    82                                         for(k=0;k<=1;k++) this->FreezeDof(k);
     118                                        for(int k=0;k<=1;k++) this->FreezeDof(k);
    83119                                }
    84120                        }
    … …  
    124160/*}}}*/
    125161Node::~Node(){/*{{{*/
     162
     163        if(this->f_set) xDelete<bool>(f_set);
     164        if(this->s_set) xDelete<bool>(s_set);
     165        if(this->svalues) xDelete<IssmDouble>(svalues);
     166        if(this->doftype) xDelete<int>(doftype);
     167        if(this->gdoflist) xDelete<int>(gdoflist);
     168        if(this->fdoflist) xDelete<int>(fdoflist);
     169        if(this->sdoflist) xDelete<int>(sdoflist);
    126170        return;
    127171}
    128172/*}}}*/
    129173Object* Node::copy(void){/*{{{*/
    130 
    131         int k,l;
    132174
    133175        /*output: */
    … …  
    146188
    147189        /*Initialize coord_system: */
    148         for(k=0;k<3;k++) for(l=0;l<3;l++) output->coord_system[k][l]=this->coord_system[k][l];
     190        for(int k=0;k<3;k++) for(int l=0;l<3;l++) output->coord_system[k][l]=this->coord_system[k][l];
    149191
    150192        /*indexing:*/
    151193        output->indexingupdate = this->indexingupdate;
    152         output->indexing.copy(this->indexing);
     194        output->gsize  = this->gsize;
     195        output->fsize  = this->fsize;
     196        output->ssize  = this->ssize;
     197        output->clone  = this->clone;
     198        output->active = this->active;
     199        output->freeze = this->freeze;
     200        if(output->gsize>0){
     201                output->f_set=xNew<bool>(output->gsize);
     202                output->s_set=xNew<bool>(output->gsize);
     203                output->svalues=xNew<IssmDouble>(output->gsize);
     204                if(this->doftype) output->doftype=xNew<int>(output->gsize);
     205                output->gdoflist=xNew<int>(output->gsize);
     206        }
     207        if(output->fsize>0)output->fdoflist=xNew<int>(output->fsize);
     208        if(output->ssize>0)output->sdoflist=xNew<int>(output->ssize);
     209
     210        if(output->gsize>0){
     211                memcpy(output->f_set,this->f_set,output->gsize*sizeof(bool));
     212                memcpy(output->s_set,this->s_set,output->gsize*sizeof(bool));
     213                xMemCpy<IssmDouble>(output->svalues,this->svalues,output->gsize);
     214                if(output->doftype)memcpy(output->doftype,this->doftype,output->gsize*sizeof(int));
     215                memcpy(output->gdoflist,this->gdoflist,output->gsize*sizeof(int));
     216        }
     217        if(output->fsize>0)memcpy(output->fdoflist,this->fdoflist,output->fsize*sizeof(int));
     218        if(output->ssize>0)memcpy(output->sdoflist,this->sdoflist,output->ssize*sizeof(int));
    153219
    154220        return (Object*)output;
    … …  
    163229        MARSHALLING(pid);
    164230        MARSHALLING(indexingupdate);
    165         indexing.Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     231        Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    166232        MARSHALLING(analysis_enum);
    167233        MARSHALLING_ARRAY(coord_system,IssmDouble,9);
    168234
    169 }
    170 /*}}}*/
     235        MARSHALLING(gsize);
     236        MARSHALLING(fsize);
     237        MARSHALLING(ssize);
     238        MARSHALLING(clone);
     239        MARSHALLING(active);
     240        MARSHALLING(freeze);
     241        MARSHALLING_DYNAMIC(f_set,bool,gsize);
     242        MARSHALLING_DYNAMIC(s_set,bool,gsize);
     243        MARSHALLING_DYNAMIC(svalues,IssmDouble,gsize);
     244        MARSHALLING_DYNAMIC(doftype,int,gsize);
     245        MARSHALLING_DYNAMIC(gdoflist,int,gsize);
     246        MARSHALLING_DYNAMIC(fdoflist,int,fsize);
     247        MARSHALLING_DYNAMIC(sdoflist,int,ssize);
     248} /*}}}*/
    171249
    172250/*Object virtual functions definitions:*/
    173251void Node::DeepEcho(void){/*{{{*/
    174252
     253        int i;
    175254        _printf_("Node:\n");
    176255        _printf_("   id: " << id << "\n");
    … …  
    179258        _printf_("   approximation: " << EnumToStringx(approximation) << "\n");
    180259        _printf_("   indexingupdate: " << indexingupdate << "\n");
    181         indexing.DeepEcho();
     260        _printf_("   gsize:  " << gsize << "\n");
     261        _printf_("   fsize:  " << fsize << "\n");
     262        _printf_("   ssize:  " << ssize << "\n");
     263        _printf_("   clone:  " << clone << "\n");
     264        _printf_("   active: " << active << "\n");
     265        _printf_("   freeze: " << freeze << "\n");
     266        _printf_("   f_set = [ ");
     267        for(i=0;i<gsize;i++) _printf_((f_set[i]?1:0)<< " ");
     268        _printf_("]\n");
     269        _printf_("   s_set = [ ");
     270        for(i=0;i<gsize;i++) _printf_((s_set[i]?1:0)<< " ");
     271        _printf_("]\n");
     272        _printf_("   svalues (" << this->ssize << "): |");
     273        for(i=0;i<this->gsize;i++){
     274                if(this->s_set[i])_printf_(" " << svalues[i] << " |");
     275        }
     276        _printf_("\n");
     277        if(doftype){
     278                _printf_("   doftype: |");
     279                for(i=0;i<gsize;i++){
     280                        _printf_(" " << doftype[i] << " |");
     281                }
     282                _printf_("\n");
     283        }
     284        else _printf_("   doftype: NULL\n");
     285
     286        _printf_("   g_doflist (" << this->gsize << "): |");
     287        for(i=0;i<this->gsize;i++){
     288                _printf_(" " << gdoflist[i] << " |");
     289        }
     290        _printf_("\n");
     291
     292        _printf_("   f_doflist (" << this->fsize << "): |");
     293        for(i=0;i<this->fsize;i++){
     294                _printf_(" " << fdoflist[i] << " |");
     295        }
     296        _printf_("\n");
     297
     298        _printf_("   s_doflist (" << this->ssize << "): |");
     299        for(i=0;i<this->ssize;i++){
     300                _printf_(" " << sdoflist[i] << " |");
     301        }
     302        _printf_("\n");
    182303
    183304}
    … …  
    193314        _printf_("   approximation: " << EnumToStringx(approximation) << "\n");
    194315        _printf_("   indexingupdate: " << indexingupdate << "\n");
    195         indexing.Echo();
    196 
     316        _printf_("   gsize:  " << gsize << "\n");
     317        _printf_("   fsize:  " << fsize << "\n");
     318        _printf_("   ssize:  " << ssize << "\n");
     319        _printf_("   clone:  " << clone << "\n");
     320        _printf_("   active: " << active << "\n");
     321        _printf_("   freeze: " << freeze << "\n");
    197322}
    198323/*}}}*/
    … …  
    218343        _assert_(!this->indexingupdate);
    219344        if(setenum==GsetEnum){
    220                 _assert_(dofindex>=0 && dofindex<indexing.gsize);
    221                 return indexing.gdoflist[dofindex];
     345                _assert_(dofindex>=0 && dofindex<gsize);
     346                return gdoflist[dofindex];
    222347        }
    223348        else if(setenum==FsetEnum){
    224                 _assert_(dofindex>=0 && dofindex<indexing.fsize);
    225                 return indexing.fdoflist[dofindex];
     349                _assert_(dofindex>=0 && dofindex<fsize);
     350                return fdoflist[dofindex];
    226351        }
    227352        else if(setenum==SsetEnum){
    228                 _assert_(dofindex>=0 && dofindex<indexing.ssize);
    229                 return indexing.sdoflist[dofindex];
     353                _assert_(dofindex>=0 && dofindex<ssize);
     354                return sdoflist[dofindex];
    230355        }
    231356        else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    … …  
    240365
    241366        if(approximation_enum==NoneApproximationEnum){
    242                 if(setenum==GsetEnum)for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=indexing.gdoflist[i];
    243                 if(setenum==FsetEnum)for(i=0;i<this->indexing.fsize;i++) outdoflist[i]=indexing.fdoflist[i];
    244                 if(setenum==SsetEnum)for(i=0;i<this->indexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i];
     367                if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist[i];
     368                if(setenum==FsetEnum)for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist[i];
     369                if(setenum==SsetEnum)for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist[i];
    245370        }
    246371        else{
    247372
    248373                if(setenum==GsetEnum){
    249                         if(indexing.doftype){
     374                        if(doftype){
    250375                                count=0;
    251                                 for(i=0;i<this->indexing.gsize;i++){
    252                                         if(indexing.doftype[i]==approximation_enum){
    253                                                 outdoflist[count]=indexing.gdoflist[i];
     376                                for(i=0;i<this->gsize;i++){
     377                                        if(doftype[i]==approximation_enum){
     378                                                outdoflist[count]=gdoflist[i];
    254379                                                count++;
    255380                                        }
    … …  
    257382                                _assert_(count); //at least one dof should be the approximation requested
    258383                        }
    259                         else for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=indexing.gdoflist[i];
     384                        else for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist[i];
    260385                }
    261386                else if(setenum==FsetEnum){
    262                         if(indexing.doftype){
     387                        if(doftype){
    263388                                count=0;
    264389                                count2=0;
    265                                 for(i=0;i<this->indexing.gsize;i++){
    266                                         if(indexing.f_set[i]){
    267                                                 if(indexing.doftype[i]==approximation_enum){
    268                                                         outdoflist[count]=indexing.fdoflist[count2];
     390                                for(i=0;i<this->gsize;i++){
     391                                        if(f_set[i]){
     392                                                if(doftype[i]==approximation_enum){
     393                                                        outdoflist[count]=fdoflist[count2];
    269394                                                        count++;
    270395                                                }
    … …  
    273398                                }
    274399                        }
    275                         else for(i=0;i<this->indexing.fsize;i++) outdoflist[i]=indexing.fdoflist[i];
     400                        else for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist[i];
    276401                }
    277402                else if(setenum==SsetEnum){
    278                         if(indexing.doftype){
     403                        if(doftype){
    279404                                count=0;
    280405                                count2=0;
    281                                 for(i=0;i<this->indexing.gsize;i++){
    282                                         if(indexing.s_set[i]){
    283                                                 if(indexing.doftype[i]==approximation_enum){
    284                                                         outdoflist[count]=indexing.sdoflist[count2];
     406                                for(i=0;i<this->gsize;i++){
     407                                        if(s_set[i]){
     408                                                if(doftype[i]==approximation_enum){
     409                                                        outdoflist[count]=sdoflist[count2];
    285410                                                        count++;
    286411                                                }
    … …  
    289414                                }
    290415                        }
    291                         else for(i=0;i<this->indexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i];
     416                        else for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist[i];
    292417                }
    293418                else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    … …  
    303428
    304429        if(approximation_enum==NoneApproximationEnum){
    305                 if(setenum==GsetEnum)for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=i;
     430                if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=i;
    306431                else if(setenum==FsetEnum){
    307432                        count=0;
    308                         for(i=0;i<this->indexing.gsize;i++){
    309                                 if(indexing.f_set[i]){
     433                        for(i=0;i<this->gsize;i++){
     434                                if(f_set[i]){
    310435                                        outdoflist[count]=i;
    311436                                        count++;
    … …  
    315440                else if(setenum==SsetEnum){
    316441                        count=0;
    317                         for(i=0;i<this->indexing.gsize;i++){
    318                                 if(indexing.s_set[i]){
     442                        for(i=0;i<this->gsize;i++){
     443                                if(s_set[i]){
    319444                                        outdoflist[count]=i;
    320445                                        count++;
    … …  
    327452
    328453                if(setenum==GsetEnum){
    329                         if(indexing.doftype){
     454                        if(doftype){
    330455                                count=0;
    331                                 for(i=0;i<this->indexing.gsize;i++){
    332                                         if(indexing.doftype[i]==approximation_enum){
     456                                for(i=0;i<this->gsize;i++){
     457                                        if(doftype[i]==approximation_enum){
    333458                                                outdoflist[count]=count;
    334459                                                count++;
    … …  
    337462                                _assert_(count);
    338463                        }
    339                         else for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=i;
     464                        else for(i=0;i<this->gsize;i++) outdoflist[i]=i;
    340465                }
    341466                else if(setenum==FsetEnum){
    342467
    343                         if(indexing.doftype){
     468                        if(doftype){
    344469                                count=0;
    345470                                count2=0;
    346                                 for(i=0;i<this->indexing.gsize;i++){
    347                                         if(indexing.doftype[i]==approximation_enum){
    348                                                 if(indexing.f_set[i]){
     471                                for(i=0;i<this->gsize;i++){
     472                                        if(doftype[i]==approximation_enum){
     473                                                if(f_set[i]){
    349474                                                        outdoflist[count]=count2;
    350475                                                        count++;
    … …  
    358483
    359484                                count=0;
    360                                 for(i=0;i<this->indexing.gsize;i++){
    361                                         if(indexing.f_set[i]){
     485                                for(i=0;i<this->gsize;i++){
     486                                        if(f_set[i]){
    362487                                                outdoflist[count]=i;
    363488                                                count++;
    … …  
    367492                }
    368493                else if(setenum==SsetEnum){
    369                         if(indexing.doftype){
     494                        if(doftype){
    370495                                count=0;
    371496                                count2=0;
    372                                 for(i=0;i<this->indexing.gsize;i++){
    373                                         if(indexing.doftype[i]==approximation_enum){
    374                                                 if(indexing.s_set[i]){
     497                                for(i=0;i<this->gsize;i++){
     498                                        if(doftype[i]==approximation_enum){
     499                                                if(s_set[i]){
    375500                                                        outdoflist[count]=count2;
    376501                                                        count++;
    … …  
    383508                        else{
    384509                                count=0;
    385                                 for(i=0;i<this->indexing.gsize;i++){
    386                                         if(indexing.s_set[i]){
     510                                for(i=0;i<this->gsize;i++){
     511                                        if(s_set[i]){
    387512                                                outdoflist[count]=i;
    388513                                                count++;
    … …  
    407532void Node::Activate(void){/*{{{*/
    408533
    409         if(!IsActive() && !this->indexing.freeze){
     534        if(!IsActive() && !this->freeze){
    410535                this->indexingupdate = true;
    411                 indexing.Activate();
     536                this->active = true;
     537                for(int i=0;i<this->gsize;i++){
     538                        this->f_set[i]    = true;
     539                        this->s_set[i]    = false;
     540                        this->svalues[i]  = 0.;
     541                }
    412542        }
    413543
    … …  
    419549         * dofs are constrained to a certain value (dirichlet boundary condition*/
    420550        DofInSSet(dof);
    421         this->indexing.svalues[dof]=value;
     551        this->svalues[dof]=value;
    422552}
    423553/*}}}*/
    … …  
    429559
    430560        /*Recover values for s set and plug them in constraints vector: */
    431         if(this->indexing.ssize){
    432                 values=xNew<IssmDouble>(this->indexing.ssize);
     561        if(this->ssize){
     562                values=xNew<IssmDouble>(this->ssize);
    433563                count=0;
    434                 for(i=0;i<this->indexing.gsize;i++){
    435                         if(this->indexing.s_set[i]){
    436                                 values[count]=this->indexing.svalues[i];
     564                for(i=0;i<this->gsize;i++){
     565                        if(this->s_set[i]){
     566                                values[count]=this->svalues[i];
    437567                                _assert_(!xIsNan<IssmDouble>(values[count]));
    438568                                count++;
    … …  
    441571
    442572                /*Add values into constraint vector: */
    443                 ys->SetValues(this->indexing.ssize,this->indexing.sdoflist,values,INS_VAL);
     573                ys->SetValues(this->ssize,this->sdoflist,values,INS_VAL);
    444574        }
    445575
    … …  
    451581void Node::Deactivate(void){/*{{{*/
    452582
    453         if(IsActive() && !this->indexing.freeze){
     583        if(IsActive() && !this->freeze){
    454584                this->indexingupdate = true;
    455                 indexing.Deactivate();
    456         }
    457 
    458 }
    459 /*}}}*/
     585                this->active = false;
     586                /*Constrain to 0. at this point*/
     587                for(int i=0;i<this->gsize;i++){
     588                        this->f_set[i]    = false;
     589                        this->s_set[i]    = true;
     590                        this->svalues[i]  = 0.;
     591                }
     592        }
     593} /*}}}*/
    460594void Node::DofInFSet(int dof){/*{{{*/
    461595
    462596        /*Put dof for this node into the f set (ie, this dof will NOT be constrained
    463597         * to a fixed value during computations. Only do this for active nodes. */
    464         _assert_(dof<this->indexing.gsize);
    465         _assert_(this->indexing.active);
    466 
    467         if(this->indexing.f_set[dof] == 0){
    468                 if(this->indexing.freeze) _error_("Cannot change dof of frozen node");
     598        _assert_(dof<this->gsize);
     599        _assert_(this->active);
     600
     601        if(this->f_set[dof] == 0){
     602                if(this->freeze) _error_("Cannot change dof of frozen node");
    469603                this->indexingupdate = true;
    470                 this->indexing.f_set[dof]=1;
    471                 this->indexing.s_set[dof]=0;
     604                this->f_set[dof]=1;
     605                this->s_set[dof]=0;
    472606        }
    473607}
    … …  
    477611        /*Put dof for this node into the s set (ie, this dof will be constrained
    478612         * to a fixed value during computations. */
    479         _assert_(dof<this->indexing.gsize);
    480 
    481         if(this->indexing.f_set[dof] == 1){
    482                 //if(this->indexing.freeze) _error_("Cannot change dof of frozen node");
     613        _assert_(dof<this->gsize);
     614
     615        if(this->f_set[dof] == 1){
     616                //if(this->freeze) _error_("Cannot change dof of frozen node");
    483617                this->indexingupdate = true;
    484                 this->indexing.f_set[dof]=0; //n splits into f (for which we solve) and s (single point constraints)
    485                 this->indexing.s_set[dof]=1;
     618                this->f_set[dof]=0; //n splits into f (for which we solve) and s (single point constraints)
     619                this->s_set[dof]=1;
    486620        }
    487621}
    … …  
    491625        DofInSSet(dof); //with 0 displacement for this dof.
    492626        //FIXME: for now we don't want this element to change so we use freeze
    493         this->indexing.freeze =true;
     627        this->freeze =true;
    494628
    495629}
    … …  
    514648
    515649        if(approximation_enum==NoneApproximationEnum){
    516                 if      (setenum==GsetEnum) numdofs=this->indexing.gsize;
    517                 else if (setenum==FsetEnum) numdofs=this->indexing.fsize;
    518                 else if (setenum==SsetEnum) numdofs=this->indexing.ssize;
     650                if      (setenum==GsetEnum) numdofs=this->gsize;
     651                else if (setenum==FsetEnum) numdofs=this->fsize;
     652                else if (setenum==SsetEnum) numdofs=this->ssize;
    519653                else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    520654        }
    521655        else{
    522656                if(setenum==GsetEnum){
    523                         if(this->indexing.doftype){
     657                        if(this->doftype){
    524658                                numdofs=0;
    525                                 for(i=0;i<this->indexing.gsize;i++){
    526                                         if(this->indexing.doftype[i]==approximation_enum) numdofs++;
    527                                 }
    528                         }
    529                         else numdofs=this->indexing.gsize;
     659                                for(i=0;i<this->gsize;i++){
     660                                        if(this->doftype[i]==approximation_enum) numdofs++;
     661                                }
     662                        }
     663                        else numdofs=this->gsize;
    530664                }
    531665                else if (setenum==FsetEnum){
    532                         if(this->indexing.doftype){
     666                        if(this->doftype){
    533667                                numdofs=0;
    534                                 for(i=0;i<this->indexing.gsize;i++){
    535                                         if((this->indexing.doftype[i]==approximation_enum) && (this->indexing.f_set[i])) numdofs++;
    536                                 }
    537                         }
    538                         else numdofs=this->indexing.fsize;
     668                                for(i=0;i<this->gsize;i++){
     669                                        if((this->doftype[i]==approximation_enum) && (this->f_set[i])) numdofs++;
     670                                }
     671                        }
     672                        else numdofs=this->fsize;
    539673                }
    540674                else if (setenum==SsetEnum){
    541                         if(this->indexing.doftype){
     675                        if(this->doftype){
    542676                        numdofs=0;
    543                                 for(i=0;i<this->indexing.gsize;i++){
    544                                         if((this->indexing.doftype[i]==approximation_enum) && (this->indexing.s_set[i])) numdofs++;
    545                                 }
    546                         }
    547                         else numdofs=this->indexing.ssize;
     677                                for(i=0;i<this->gsize;i++){
     678                                        if((this->doftype[i]==approximation_enum) && (this->s_set[i])) numdofs++;
     679                                }
     680                        }
     681                        else numdofs=this->ssize;
    548682                }
    549683                else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    … …  
    554688void Node::HardDeactivate(void){/*{{{*/
    555689
    556         this->indexing.Deactivate();
    557         this->indexing.freeze =true;
     690        this->Deactivate();
     691        this->freeze =true;
    558692
    559693}
    … …  
    561695bool Node::IsActive(void){/*{{{*/
    562696
    563         return indexing.active;
     697        return active;
    564698
    565699}
    … …  
    567701int  Node::IsClone(){/*{{{*/
    568702
    569         return indexing.clone;
     703        return clone;
    570704
    571705}
    … …  
    581715        /*Dof should be added to the f-set, and taken out of the s-set:*/
    582716        DofInFSet(dof);
    583         this->indexing.svalues[dof]=0.;
     717        this->svalues[dof]=0.;
    584718}
    585719/*}}}*/
    … …  
    599733        int ind_ys = *pindex_ys;
    600734
    601         if(this->indexing.fsize){
    602                 int*        indices = xNew<int>(this->indexing.fsize);
    603                 IssmDouble* values  = xNew<IssmDouble>(this->indexing.fsize);
     735        if(this->fsize){
     736                int*        indices = xNew<int>(this->fsize);
     737                IssmDouble* values  = xNew<IssmDouble>(this->fsize);
    604738
    605739                int count = 0;
    606                 for(int i=0;i<this->indexing.gsize;i++){
    607                         if(this->indexing.f_set[i]){
     740                for(int i=0;i<this->gsize;i++){
     741                        if(this->f_set[i]){
    608742                                _assert_(local_uf);
    609                                 _assert_(this->indexing.fdoflist[count]==indices_uf[ind_uf]);
     743                                _assert_(this->fdoflist[count]==indices_uf[ind_uf]);
    610744
    611745                                values[count]=local_uf[ind_uf];
    612                                 indices[count]=this->indexing.gdoflist[i];
     746                                indices[count]=this->gdoflist[i];
    613747                                count++;
    614748                                ind_uf++;
    615749                        }
    616750                }
    617                 ug->SetValues(this->indexing.fsize,indices,values,INS_VAL);
     751                ug->SetValues(this->fsize,indices,values,INS_VAL);
    618752                /*Free ressources:*/
    619753                xDelete<IssmDouble>(values);
    620754                xDelete<int>(indices);
    621755        }
    622         if(this->indexing.ssize){
    623                 int*        indices = xNew<int>(this->indexing.ssize);
    624                 IssmDouble* values  = xNew<IssmDouble>(this->indexing.ssize);
     756        if(this->ssize){
     757                int*        indices = xNew<int>(this->ssize);
     758                IssmDouble* values  = xNew<IssmDouble>(this->ssize);
    625759
    626760                int count = 0;
    627                 for(int i=0;i<this->indexing.gsize;i++){
    628                         if(this->indexing.s_set[i]){
     761                for(int i=0;i<this->gsize;i++){
     762                        if(this->s_set[i]){
    629763                                _assert_(local_ys);
    630                                 _assert_(this->indexing.sdoflist[count]==indices_ys[ind_ys]);
     764                                _assert_(this->sdoflist[count]==indices_ys[ind_ys]);
    631765
    632766                                values[count]=local_ys[ind_ys];
    633                                 indices[count]=this->indexing.gdoflist[i];
     767                                indices[count]=this->gdoflist[i];
    634768                                count++;
    635769                                ind_ys++;
    636770                        }
    637771                }
    638                 ug->SetValues(this->indexing.ssize,indices,values,INS_VAL);
     772                ug->SetValues(this->ssize,indices,values,INS_VAL);
    639773                /*Free ressources:*/
    640774                xDelete<IssmDouble>(values);
    … …  
    654788
    655789        if(setenum==FsetEnum){
    656                 if(this->indexing.fsize){
    657                         values=xNew<IssmDouble>(this->indexing.fsize);
    658 
    659                         for(i=0;i<this->indexing.gsize;i++){
    660                                 if(this->indexing.f_set[i]){
     790                if(this->fsize){
     791                        values=xNew<IssmDouble>(this->fsize);
     792
     793                        for(i=0;i<this->gsize;i++){
     794                                if(this->f_set[i]){
    661795                                        _assert_(ug_serial);
    662                                         values[count]=ug_serial[this->indexing.gdoflist[i]];
     796                                        values[count]=ug_serial[this->gdoflist[i]];
    663797                                        count++;
    664798                                }
    … …  
    666800
    667801                        /*Add values into ug: */
    668                         vector->SetValues(this->indexing.fsize,this->indexing.fdoflist,values,INS_VAL);
     802                        vector->SetValues(this->fsize,this->fdoflist,values,INS_VAL);
    669803                }
    670804        }
    671805        else if(setenum==SsetEnum){
    672                 if(this->indexing.ssize){
    673                         values=xNew<IssmDouble>(this->indexing.ssize);
    674 
    675                         for(i=0;i<this->indexing.gsize;i++){
    676                                 if(this->indexing.s_set[i]){
     806                if(this->ssize){
     807                        values=xNew<IssmDouble>(this->ssize);
     808
     809                        for(i=0;i<this->gsize;i++){
     810                                if(this->s_set[i]){
    677811                                        _assert_(ug_serial);
    678                                         values[count]=ug_serial[this->indexing.gdoflist[i]];
     812                                        values[count]=ug_serial[this->gdoflist[i]];
    679813                                        count++;
    680814                                }
    … …  
    682816
    683817                        /*Add values into ug: */
    684                         vector->SetValues(this->indexing.ssize,this->indexing.sdoflist,values,INS_VAL);
     818                        vector->SetValues(this->ssize,this->sdoflist,values,INS_VAL);
    685819                }
    686820        }
    … …  
    701835
    702836        /*Initialize: */
    703         if(setenum==FsetEnum) this->indexing.InitSet(setenum);
    704         if(setenum==SsetEnum) this->indexing.InitSet(setenum);
     837        int size=0;
     838        if(setenum==FsetEnum){
     839                for(i=0;i<this->gsize;i++) if(f_set[i])size++;
     840                this->fsize=size;
     841                xDelete<int>(this->fdoflist);
     842
     843                if(this->fsize)
     844                 this->fdoflist=xNew<int>(size);
     845                else
     846                 this->fdoflist=NULL;
     847        }
     848        if(setenum==SsetEnum){
     849                for(i=0;i<this->gsize;i++) if(s_set[i])size++;
     850                this->ssize=size;
     851                xDelete<int>(this->sdoflist);
     852
     853                if(this->ssize)
     854                 this->sdoflist=xNew<int>(size);
     855                else
     856                 this->sdoflist=NULL;
     857        }
    705858
    706859        /*For clone nodfs, don't distribute dofs, we will get them from another cpu in UpdateCloneDofs!*/
    707         if(indexing.clone){
    708                 return;
    709         }
     860        if(clone) return;
    710861
    711862        /*This node should distribute dofs for setenum set (eg, f_set or s_set), go ahead: */
    712863        if(setenum==GsetEnum){
    713                 for(i=0;i<this->indexing.gsize;i++){
    714                         indexing.gdoflist[i]=dofcount+i;
    715                 }
    716                 dofcount+=this->indexing.gsize;
     864                for(i=0;i<this->gsize;i++){
     865                        gdoflist[i]=dofcount+i;
     866                }
     867                dofcount+=this->gsize;
    717868        }
    718869        else if(setenum==FsetEnum){
    719                 for(i=0;i<this->indexing.fsize;i++){
    720                         indexing.fdoflist[i]=dofcount+i;
    721                 }
    722                 dofcount+=this->indexing.fsize;
     870                for(i=0;i<this->fsize;i++){
     871                        fdoflist[i]=dofcount+i;
     872                }
     873                dofcount+=this->fsize;
    723874        }
    724875        else if(setenum==SsetEnum){
    725                 for(i=0;i<this->indexing.ssize;i++){
    726                         indexing.sdoflist[i]=dofcount+i;
    727                 }
    728                 dofcount+=this->indexing.ssize;
     876                for(i=0;i<this->ssize;i++){
     877                        sdoflist[i]=dofcount+i;
     878                }
     879                dofcount+=this->ssize;
    729880        }
    730881        else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    … …  
    738889        int i;
    739890
    740         if(indexing.clone){
     891        if(clone){
    741892                /*This node is a clone, don't off_set the dofs!: */
    742893                return;
    … …  
    745896        /*This node should off_set the dofs, go ahead: */
    746897        if(setenum==GsetEnum){
    747                 for(i=0;i<this->indexing.gsize;i++) indexing.gdoflist[i]+=dofcount;
     898                for(i=0;i<this->gsize;i++) gdoflist[i]+=dofcount;
    748899        }
    749900        else if(setenum==FsetEnum){
    750                 for(i=0;i<this->indexing.fsize;i++) indexing.fdoflist[i]+=dofcount;
     901                for(i=0;i<this->fsize;i++) fdoflist[i]+=dofcount;
    751902        }
    752903        else if(setenum==SsetEnum){
    753                 for(i=0;i<this->indexing.ssize;i++) indexing.sdoflist[i]+=dofcount;
     904                for(i=0;i<this->ssize;i++) sdoflist[i]+=dofcount;
    754905        }
    755906        else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
    … …  
    758909void Node::ShowTrueDofs(int* truedofs,int setenum){/*{{{*/
    759910
    760         _assert_(!this->indexing.clone);
     911        _assert_(!this->clone);
    761912
    762913        /*Ok, we are not a clone, just plug our dofs into truedofs: */
    763914        switch(setenum){
    764915                case GsetEnum:
    765                         for(int j=0;j<this->indexing.gsize;j++) truedofs[j]=indexing.gdoflist[j];
     916                        for(int j=0;j<this->gsize;j++) truedofs[j]=gdoflist[j];
    766917                        break;
    767918                case FsetEnum:
    768                         for(int j=0;j<this->indexing.fsize;j++) truedofs[j]=indexing.fdoflist[j];
     919                        for(int j=0;j<this->fsize;j++) truedofs[j]=fdoflist[j];
    769920                        break;
    770921                case SsetEnum:
    771                         for(int j=0;j<this->indexing.ssize;j++) truedofs[j]=indexing.sdoflist[j];
     922                        for(int j=0;j<this->ssize;j++) truedofs[j]=sdoflist[j];
    772923                        break;
    773924                default:
    … …  
    779930void Node::UpdateCloneDofs(int* alltruedofs,int setenum){/*{{{*/
    780931
    781         _assert_(this->indexing.clone);
     932        _assert_(this->clone);
    782933
    783934        /*Ok, we are a clone node, but we did not create the dofs for this node.
    … …  
    785936        switch(setenum){
    786937                case GsetEnum:
    787                         for(int j=0;j<this->indexing.gsize;j++) indexing.gdoflist[j]=alltruedofs[j];
     938                        for(int j=0;j<this->gsize;j++) gdoflist[j]=alltruedofs[j];
    788939                        break;
    789940                case FsetEnum:
    790                         for(int j=0;j<this->indexing.fsize;j++) indexing.fdoflist[j]=alltruedofs[j];
     941                        for(int j=0;j<this->fsize;j++) fdoflist[j]=alltruedofs[j];
    791942                        break;
    792943                case SsetEnum:
    793                         for(int j=0;j<this->indexing.ssize;j++) indexing.sdoflist[j]=alltruedofs[j];
     944                        for(int j=0;j<this->ssize;j++) sdoflist[j]=alltruedofs[j];
    794945                        break;
    795946                default:

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

    r23602 r23612  
    1010#include "../datastructures/datastructures.h"
    1111#include "../shared/shared.h"
    12 #include "./DofIndexing.h"
    1312class  Inputs;
    1413class  Hook;
    … …  
    1615class  DataSet;
    1716class  Vertices;
    18 template <class doubletype> class  Vector;
    19 template <class doubletype> class  Matrix;
     17template <class doubletype> class Vector;
     18template <class doubletype> class Matrix;
    2019class ElementVector;
    2120class ElementMatrix;
    … …  
    3433                int pid;   // parallel id (specific to this partition)
    3534
    36                 int          analysis_enum;
     35                bool clone;  //this node is replicated from another one
     36                int  analysis_enum;
    3737                IssmDouble   coord_system[3][3];
    3838                bool         indexingupdate;
    39                 DofIndexing  indexing;
     39
     40                /*sizes: */
     41                int gsize;   //number of dofs for a node
     42                int fsize;   //number of dofs solver for
     43                int ssize;   //number of constrained dofs
     44
     45                /*Activation*/
     46                bool active; //Is this node active or inactive (all dofs are constrained)
     47                bool freeze; //this is required for 2d solutions, we never activate nodes that are not on base
     48
     49                /*boundary conditions sets: */
     50                bool       *f_set;     //is dof on f-set (on which we solve)
     51                bool       *s_set;     //is dof on s-set (on which boundary conditions -dirichlet- are applied)
     52                IssmDouble *svalues;   //list of constraint values. size g_size, for ease of use.
     53
     54                /*types of dofs: */
     55                int        *doftype;   //approximation type of the dofs (used only for coupling), size g_size
     56
     57                /*list of degrees of freedom: */
     58                int *gdoflist;   //dof list in g_set
     59                int *fdoflist;   //dof list in f_set
     60                int *sdoflist;   //dof list in s_set
    4061
    4162                /*Node constructors, destructors*/

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

    r23524 r23612  
    129129/*diverse: */
    130130#include "./Hook.h"
    131 #include "./DofIndexing.h"
    132131#include "./IoModel.h"
    133132#include "./FemModel.h"

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

    r23587 r23612  
    249249                        Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    250250                        if(!node->IsClone()){
    251                                 for(j=0;j<node->indexing.fsize;j++){
     251                                for(j=0;j<node->fsize;j++){
    252252                                        _assert_(count<m);
    253253                                        d_nnz[count]=numberofdofspernode*(d_connectivity[node->Sid()] + all_connectivity_clone[node->Sid()]);

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

    r23587 r23612  
    99void GetSolutionFromInputsx(Vector<IssmDouble>** psolution,FemModel* femmodel){
    1010
    11         /*intermediary: */
    12         int gsize;
    13         int analysisenum;
    14 
    15         /*output: */
    16         Vector<IssmDouble>* solution=NULL;
    17 
    1811        if(VerboseModule()) _printf0_("   Get solution from inputs\n");
    1912
    20         /*retrive parameters: */
     13        /*retrieve parameters: */
     14        int analysisenum;
    2115        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    2216
    2317        /*Get size of vector: */
    24         gsize=femmodel->nodes->NumberOfDofs(GsetEnum);
     18        int gsize       = femmodel->nodes->NumberOfDofs(GsetEnum);
     19        int gsize_local = femmodel->nodes->NumberOfDofsLocal(GsetEnum);
    2520        if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 ");
    2621
    2722        /*Initialize solution: */
    28         solution=new Vector<IssmDouble>(gsize);
     23        Vector<IssmDouble>* solution=new Vector<IssmDouble>(gsize_local,gsize);
    2924
    3025        /*Go through elements and plug solution: */
Note: See TracChangeset for help on using the changeset viewer.