Ignore:
Timestamp:
11/16/12 08:10:16 (12 years ago)
Author:
Mathieu Morlighem
Message:

merged trunk-jpl and trunk for revision 13974

Location:
issm/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk

  • issm/trunk/src

  • issm/trunk/src/c/classes/objects/Loads/Riftfront.cpp

    r13395 r13975  
    9797        //intialize inputs, and add as many inputs per element as requested:
    9898        this->inputs=new Inputs();
    99                
     99
    100100        riftfront_type=SegmentRiftfrontEnum;
    101101        riftfront_fill = reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+7));
    … …  
    109109        this->inputs->AddInput(new DoubleInput(FractionIncrementEnum,riftfront_fractionincrement));
    110110        this->inputs->AddInput(new BoolInput(SegmentOnIceShelfEnum,riftfront_shelf));
    111        
     111
    112112        //parameters and hooked fields: we still can't point to them, they may not even exist. Configure will handle this.
    113113        this->parameters=NULL;
    … …  
    115115        this->elements= NULL;
    116116        this->matpar= NULL;
    117                
     117
    118118}
    119119/*}}}*/
    … …  
    137137        IssmDouble friction,fractionincrement;
    138138
    139        
    140139        /*recover some inputs first: */
    141140        input=(Input*)this->inputs->GetInput(FillEnum); input->GetInputValue(&fill);
    … …  
    165164        _printLine_("   state: " << state);
    166165        _printLine_("   frozen: " << (frozen ? "true":"false"));
    167                
     166
    168167}
    169168/*}}}*/
    … …  
    186185int    Riftfront::Id(void){ return id; }
    187186/*}}}*/
    188 /*FUNCTION Riftfront::MyRank {{{*/
    189 int    Riftfront::MyRank(void){
    190         extern int my_rank;
    191         return my_rank;
    192 }
    193 /*}}}*/
    194187/*FUNCTION Riftfront::ObjectEnum{{{*/
    195188int Riftfront::ObjectEnum(void){
    … …  
    201194/*FUNCTION Riftfront::copy {{{*/
    202195Object* Riftfront::copy() {
    203        
     196
    204197        Riftfront* riftfront=NULL;
    205198
    … …  
    240233        riftfront->length=this->length;
    241234        riftfront->fraction=this->fraction;
    242        
     235
    243236        return riftfront;
    244237
    245238}
    246239/*}}}*/
    247                
     240
    248241/*Update virtual functions definitions:*/
    249242/*FUNCTION Riftfront::InputUpdateFromConstant(bool constant,int name) {{{*/
    … …  
    281274}
    282275/*}}}*/
    283 
    284276
    285277/*Load virtual functions definitions:*/
    … …  
    301293        this->parameters=parametersin;
    302294
     295}
     296/*}}}*/
     297/*FUNCTION Riftfront::IsPenalty{{{*/
     298bool Riftfront::IsPenalty(void){
     299        return true;
    303300}
    304301/*}}}*/
    … …  
    372369}
    373370/*}}}*/
     371/*FUNCTION Riftfront::GetNodesSidList{{{*/
     372void Riftfront::GetNodesSidList(int* sidlist){
     373
     374        _assert_(sidlist);
     375        _assert_(nodes);
     376
     377        for(int i=0;i<NUMVERTICES;i++) sidlist[i]=nodes[i]->Sid();
     378}
     379/*}}}*/
     380/*FUNCTION Riftfront::GetNumberOfNodes{{{*/
     381int Riftfront::GetNumberOfNodes(void){
     382
     383        return NUMVERTICES;
     384}
     385/*}}}*/
    374386/*FUNCTION Riftfront::InAnalysis{{{*/
    375387bool Riftfront::InAnalysis(int in_analysis_type){
    … …  
    378390}
    379391/*}}}*/
     392/*FUNCTION Riftfront::SetwiseNodeConnectivity{{{*/
     393void Riftfront::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int set1_enum,int set2_enum){
     394
     395        /*Output */
     396        int d_nz = 0;
     397        int o_nz = 0;
     398
     399        /*Loop over all nodes*/
     400        for(int i=0;i<NUMVERTICES;i++){
     401
     402                if(!flags[this->nodes[i]->Sid()]){
     403
     404                        /*flag current node so that no other element processes it*/
     405                        flags[this->nodes[i]->Sid()]=true;
     406
     407                        /*if node is clone, we have an off-diagonal non-zero, else it is a diagonal non-zero*/
     408                        switch(set2_enum){
     409                                case FsetEnum:
     410                                        if(nodes[i]->indexing.fsize){
     411                                                if(this->nodes[i]->IsClone())
     412                                                 o_nz += 1;
     413                                                else
     414                                                 d_nz += 1;
     415                                        }
     416                                        break;
     417                                case GsetEnum:
     418                                        if(nodes[i]->indexing.gsize){
     419                                                if(this->nodes[i]->IsClone())
     420                                                 o_nz += 1;
     421                                                else
     422                                                 d_nz += 1;
     423                                        }
     424                                        break;
     425                                case SsetEnum:
     426                                        if(nodes[i]->indexing.ssize){
     427                                                if(this->nodes[i]->IsClone())
     428                                                 o_nz += 1;
     429                                                else
     430                                                 d_nz += 1;
     431                                        }
     432                                        break;
     433                                default: _error_("not supported");
     434                        }
     435                }
     436        }
     437
     438        /*Assign output pointers: */
     439        *pd_nz=d_nz;
     440        *po_nz=o_nz;
     441}
     442/*}}}*/
    380443
    381444/*Riftfront numerics*/
    … …  
    384447
    385448        const int   numdof = NDOF2*NUMVERTICES;
    386         int         i,j;
    387449        int         dofs[1]             = {0};
    388         IssmDouble      Ke_gg[4][4];
    389         IssmDouble      thickness;
    390         IssmDouble      h[2];
    391         IssmDouble      penalty_offset;
    392         IssmDouble      friction;
     450        IssmDouble  thickness;
     451        IssmDouble  h[2];
     452        IssmDouble  penalty_offset;
     453        IssmDouble  friction;
    393454
    394455        /*Objects: */
    … …  
    466527ElementVector* Riftfront::PenaltyCreatePVectorDiagnosticHoriz(IssmDouble kmax){
    467528
    468         const int   numdof = NDOF2*NUMVERTICES;
    469         int         i,j;
    470         IssmDouble      rho_ice;
    471         IssmDouble      rho_water;
    472         IssmDouble      gravity;
    473         IssmDouble      thickness;
    474         IssmDouble      h[2];
    475         IssmDouble      bed;
    476         IssmDouble      b[2];
    477         IssmDouble      pressure;
    478         IssmDouble      pressure_litho;
    479         IssmDouble      pressure_air;
    480         IssmDouble      pressure_melange;
    481         IssmDouble      pressure_water;
    482         int         fill;
    483         bool        shelf;
     529        const int  numdof = NDOF2*NUMVERTICES;
     530        int        j;
     531        IssmDouble rho_ice;
     532        IssmDouble rho_water;
     533        IssmDouble gravity;
     534        IssmDouble thickness;
     535        IssmDouble h[2];
     536        IssmDouble bed;
     537        IssmDouble b[2];
     538        IssmDouble pressure;
     539        IssmDouble pressure_litho;
     540        IssmDouble pressure_air;
     541        IssmDouble pressure_melange;
     542        IssmDouble pressure_water;
     543        int        fill;
     544        bool       shelf;
    484545
    485546        /*Objects: */
    486         Tria       *tria1              = NULL;
    487         Tria       *tria2              = NULL;
     547        Tria *tria1 = NULL;
     548        Tria *tria2 = NULL;
    488549
    489550        /*enum of element? */
    … …  
    569630
    570631        const int   numnodes        = 2;
    571         IssmDouble      max_penetration;
    572632        IssmDouble      penetration;
    573633        int         activate;
    574         int         found;
    575634        int         unstable;
    576635        IssmDouble      vx1;
    … …  
    602661                if(this->state==OpenEnum)this->active=0;
    603662                if(this->state==ClosedEnum)this->active=1;
    604                
     663
    605664                /*this segment is like frozen, no instability here: */
    606665                *punstable=0;
    607666                return 1;
    608667        }
    609 
    610668
    611669        /*recover parameters: */
    … …  
    674732int   Riftfront::IsMaterialStable(void){
    675733
    676         int found=0;
    677734        IssmDouble converged=0;
    678735
    … …  
    693750
    694751        const int     numnodes=2;
    695         IssmDouble        max_penetration;
    696752        IssmDouble        penetration=0;
    697         int           found;
    698753        IssmDouble      vx1;
    699754        IssmDouble      vy1;
    … …  
    729784        /*If we are zigzag locked, same thing: */
    730785        if(this->counter>this->penalty_lock)penetration=-1;
    731        
     786
    732787        /*assign output pointer: */
    733788        *ppenetration=penetration;
    … …  
    744799
    745800        IssmDouble    penetration;
    746         int       found;
    747801
    748802        /*Objects: */
    … …  
    768822        /*Now, we return penetration only if we are active!: */
    769823        if(this->active==0)penetration=0;
    770        
     824
    771825        /*assign output pointer: */
    772826        *ppenetration=penetration;
    … …  
    777831int   Riftfront::PotentialUnstableConstraint(int* punstable){
    778832
    779 
    780833        const int   numnodes        = 2;
    781         IssmDouble      max_penetration;
    782         IssmDouble      penetration;
    783         int         activate;
     834        IssmDouble  penetration;
    784835        int         unstable;
    785         int         found;
    786         IssmDouble      vx1;
    787         IssmDouble      vy1;
    788         IssmDouble      vx2;
    789         IssmDouble      vy2;
     836        IssmDouble  vx1;
     837        IssmDouble  vy1;
     838        IssmDouble  vx2;
     839        IssmDouble  vy2;
    790840
    791841        /*Objects: */
    792         Tria       *tria1           = NULL;
    793         Tria       *tria2           = NULL;
     842        Tria       *tria1 = NULL;
     843        Tria       *tria2 = NULL;
    794844
    795845        /*enum of element? */
    … …  
    833883        IssmDouble      penetration;
    834884        int         unstable;
    835         int         found;
    836885        IssmDouble      vx1;
    837886        IssmDouble      vy1;
Note: See TracChangeset for help on using the changeset viewer.