Changeset 17296


Ignore:
Timestamp:
02/18/14 15:38:59 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: moved some functions from each element to Element.cpp

Location:
issm/trunk-jpl/src/c/classes/Elements
Files:
7 edited

Legend:

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

    r17294 r17296  
    142142        this->parameters->FindParam(pvalues,psize,paramenum);
    143143}/*}}}*/
     144void Element::GetDofList(int** pdoflist,int approximation_enum,int setenum){/*{{{*/
     145
     146        /*Fetch number of nodes and dof for this finite element*/
     147        int numnodes = this->GetNumberOfNodes();
     148
     149        /*First, figure out size of doflist and create it: */
     150        int numberofdofs=0;
     151        for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
     152
     153        /*Allocate output*/
     154        int* doflist=xNew<int>(numberofdofs);
     155
     156        /*Populate: */
     157        int count=0;
     158        for(int i=0;i<numnodes;i++){
     159                nodes[i]->GetDofList(doflist+count,approximation_enum,setenum);
     160                count+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
     161        }
     162
     163        /*Assign output pointers:*/
     164        *pdoflist=doflist;
     165}
     166/*}}}*/
     167void Element::GetDofListVelocity(int** pdoflist,int setenum){/*{{{*/
     168
     169        /*Fetch number of nodes and dof for this finite element*/
     170        int numnodes = this->GetNumberOfNodesVelocity();
     171
     172        /*First, figure out size of doflist and create it: */
     173        int numberofdofs=0;
     174        for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
     175
     176        /*Allocate output*/
     177        int* doflist=xNew<int>(numberofdofs);
     178
     179        /*Populate: */
     180        int count=0;
     181        for(int i=0;i<numnodes;i++){
     182                nodes[i]->GetDofList(doflist+count,FSvelocityEnum,setenum);
     183                count+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
     184        }
     185
     186        /*Assign output pointers:*/
     187        *pdoflist=doflist;
     188}
     189/*}}}*/
     190void Element::GetDofListPressure(int** pdoflist,int setenum){/*{{{*/
     191
     192        /*Fetch number of nodes and dof for this finite element*/
     193        int vnumnodes = this->GetNumberOfNodesVelocity();
     194        int pnumnodes = this->GetNumberOfNodesPressure();
     195
     196        /*First, figure out size of doflist and create it: */
     197        int numberofdofs=0;
     198        for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
     199
     200        /*Allocate output*/
     201        int* doflist=xNew<int>(numberofdofs);
     202
     203        /*Populate: */
     204        int count=0;
     205        for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++){
     206                nodes[i]->GetDofList(doflist+count,FSApproximationEnum,setenum);
     207                count+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
     208        }
     209
     210        /*Assign output pointers:*/
     211        *pdoflist=doflist;
     212}
     213/*}}}*/
    144214IssmDouble Element::GetMaterialParameter(int enum_in){/*{{{*/
    145215
     
    556626        *pviscosity=viscosity;
    557627}/*}}}*/
    558 void Element::ViscositySSA(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     628void Element::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    559629
    560630        /*Intermediaries*/
    561631        IssmDouble viscosity;
    562         IssmDouble epsilon[3];/* epsilon=[exx,eyy,exy];    */
     632        IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy];    */
     633        IssmDouble epsilon1d;   /* epsilon=[exx];    */
    563634        IssmDouble eps_eff;
    564635
    565         /*Get effective strain rate
    566          * eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy+*/
    567         this->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
    568         eps_eff = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[2]*epsilon[2] + epsilon[0]*epsilon[1]);
     636         if(dim==2){
     637                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy+*/
     638                 this->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     639                 eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
     640         }
     641         else{
     642                 /* eps_eff^2 = exx^2*/
     643                 this->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
     644                 eps_eff = sqrt(epsilon1d*epsilon1d);
     645         }
    569646
    570647        /*Get viscosity*/
     
    684761
    685762}/*}}}*/
     763void Element::StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input){/*{{{*/
     764
     765        /*Intermediaries*/
     766        IssmDouble dvx[3];
     767
     768        /*Check that both inputs have been found*/
     769        if (!vx_input){
     770                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << "\n");
     771        }
     772
     773        /*Get strain rate assuming that epsilon has been allocated*/
     774        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     775        *epsilon = dvx[0];
     776
     777}/*}}}*/
    686778void Element::TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,int transformenum){/*{{{*/
    687779
  • issm/trunk-jpl/src/c/classes/Elements/Element.h

    r17275 r17296  
    6060                void       FindParam(IssmDouble* pvalue,int paramenum);
    6161                void       FindParam(int** pvalues,int* psize,int paramenum);
     62                void         GetDofList(int** pdoflist,int approximation_enum,int setenum);
     63                void         GetDofListVelocity(int** pdoflist,int setenum);
     64                void         GetDofListPressure(int** pdoflist,int setenum);
    6265                Input*     GetInput(int inputenum);
    6366                IssmDouble GetMaterialParameter(int enum_in);
     
    7174                void       ResultToPatch(IssmDouble* values,int nodesperelement,int output_enum);
    7275                void       StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
     76                void       StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input);
    7377                void       StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    7478                void       StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
     
    96100                void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    97101                void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
    98                 void       ViscositySSA(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
     102                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    99103                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
    100104                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
     
    135139                virtual Element* GetSurfaceElement(void)=0;
    136140                virtual Element* GetBasalElement(void)=0;
    137                 virtual void    GetDofList(int** pdoflist,int approximation_enum,int setenum)=0;
    138                 virtual void    GetDofListVelocity(int** pdoflist,int setenum)=0;
    139                 virtual void    GetDofListPressure(int** pdoflist,int setenum)=0;
     141
    140142                virtual void   JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
    141143                virtual void   JacobianDeterminantLine(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
  • issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r17294 r17296  
    631631        Element* element=this->GetBasalPenta();
    632632        return element;
    633 }
    634 /*}}}*/
    635 /*FUNCTION Penta::GetDofList {{{*/
    636 void  Penta::GetDofList(int** pdoflist,int approximation_enum,int setenum){
    637 
    638         /*Fetch number of nodes and dof for this finite element*/
    639         int numnodes = this->NumberofNodes();
    640 
    641         /*First, figure out size of doflist and create it: */
    642         int numberofdofs=0;
    643         for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
    644 
    645         /*Allocate output*/
    646         int* doflist=xNew<int>(numberofdofs);
    647 
    648         /*Populate: */
    649         int count=0;
    650         for(int i=0;i<numnodes;i++){
    651                 nodes[i]->GetDofList(doflist+count,approximation_enum,setenum);
    652                 count+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
    653         }
    654 
    655         /*Assign output pointers:*/
    656         *pdoflist=doflist;
    657 }
    658 /*}}}*/
    659 /*FUNCTION Penta::GetDofListVelocity{{{*/
    660 void  Penta::GetDofListVelocity(int** pdoflist,int setenum){
    661 
    662         /*Fetch number of nodes and dof for this finite element*/
    663         int numnodes = this->NumberofNodesVelocity();
    664 
    665         /*First, figure out size of doflist and create it: */
    666         int numberofdofs=0;
    667         for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
    668 
    669         /*Allocate output*/
    670         int* doflist=xNew<int>(numberofdofs);
    671 
    672         /*Populate: */
    673         int count=0;
    674         for(int i=0;i<numnodes;i++){
    675                 nodes[i]->GetDofList(doflist+count,FSvelocityEnum,setenum);
    676                 count+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
    677         }
    678 
    679         /*Assign output pointers:*/
    680         *pdoflist=doflist;
    681 }
    682 /*}}}*/
    683 /*FUNCTION Penta::GetDofListPressure{{{*/
    684 void  Penta::GetDofListPressure(int** pdoflist,int setenum){
    685 
    686         /*Fetch number of nodes and dof for this finite element*/
    687         int vnumnodes = this->NumberofNodesVelocity();
    688         int pnumnodes = this->NumberofNodesPressure();
    689 
    690         /*First, figure out size of doflist and create it: */
    691         int numberofdofs=0;
    692         for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
    693 
    694         /*Allocate output*/
    695         int* doflist=xNew<int>(numberofdofs);
    696 
    697         /*Populate: */
    698         int count=0;
    699         for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++){
    700                 nodes[i]->GetDofList(doflist+count,FSApproximationEnum,setenum);
    701                 count+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
    702         }
    703 
    704         /*Assign output pointers:*/
    705         *pdoflist=doflist;
    706633}
    707634/*}}}*/
  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r17275 r17296  
    8282                Element* GetSurfaceElement(void);
    8383                Element* GetBasalElement(void);
    84                 void     GetDofList(int** pdoflist,int approximation_enum,int setenum);
    85                 void     GetDofListVelocity(int** pdoflist,int setenum);
    86                 void     GetDofListPressure(int** pdoflist,int setenum);
    8784                void   GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);
    8885                IssmDouble GetGroundedPortion(IssmDouble* xyz_list);
  • issm/trunk-jpl/src/c/classes/Elements/Seg.h

    r17275 r17296  
    7979                Element*    GetSurfaceElement(void){_error_("not implemented yet");};
    8080                Element*    GetBasalElement(void){_error_("not implemented yet");};
    81                 void        GetDofList(int** pdoflist,int approximation_enum,int setenum){_error_("not implemented yet");};
    82                 void        GetDofListVelocity(int** pdoflist,int setenum){_error_("not implemented yet");};
    83                 void        GetDofListPressure(int** pdoflist,int setenum){_error_("not implemented yet");};
    8481                void        GetInputListOnNodes(IssmDouble* pvalue,int enumtype){_error_("not implemented yet");};
    8582                void        GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){_error_("not implemented yet");};
  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r17288 r17296  
    223223                /*Compute strain rate viscosity and pressure: */
    224224                this->StrainRateSSA(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
    225                 this->ViscositySSA(&viscosity,&xyz_list[0][0],gauss,vx_input,vy_input);
     225                this->ViscositySSA(&viscosity,2,&xyz_list[0][0],gauss,vx_input,vy_input);
    226226                pressure_input->GetInputValue(&pressure,gauss);
    227227
     
    488488                }
    489489        }
    490 }
    491 /*}}}*/
    492 /*FUNCTION Tria::GetDofList {{{*/
    493 void  Tria::GetDofList(int** pdoflist, int approximation_enum,int setenum){
    494 
    495         /*Fetch number of nodes and dof for this finite element*/
    496         int numnodes = this->NumberofNodes();
    497 
    498         /*First, figure out size of doflist and create it: */
    499         int numberofdofs=0;
    500         for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
    501 
    502         /*Allocate output*/
    503         int* doflist=xNew<int>(numberofdofs);
    504 
    505         /*Populate: */
    506         int count=0;
    507         for(int i=0;i<numnodes;i++){
    508                 nodes[i]->GetDofList(doflist+count,approximation_enum,setenum);
    509                 count+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
    510         }
    511 
    512         /*Assign output pointers:*/
    513         *pdoflist=doflist;
    514 }
    515 /*}}}*/
    516 /*FUNCTION Tria::GetDofListVelocity{{{*/
    517 void  Tria::GetDofListVelocity(int** pdoflist,int setenum){
    518 
    519         /*Fetch number of nodes and dof for this finite element*/
    520         int numnodes = this->NumberofNodesVelocity();
    521 
    522         /*First, figure out size of doflist and create it: */
    523         int numberofdofs=0;
    524         for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
    525 
    526         /*Allocate output*/
    527         int* doflist=xNew<int>(numberofdofs);
    528 
    529         /*Populate: */
    530         int count=0;
    531         for(int i=0;i<numnodes;i++){
    532                 nodes[i]->GetDofList(doflist+count,FSvelocityEnum,setenum);
    533                 count+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
    534         }
    535 
    536         /*Assign output pointers:*/
    537         *pdoflist=doflist;
    538 }
    539 /*}}}*/
    540 /*FUNCTION Tria::GetDofListPressure{{{*/
    541 void  Tria::GetDofListPressure(int** pdoflist,int setenum){
    542 
    543         /*Fetch number of nodes and dof for this finite element*/
    544         int vnumnodes = this->NumberofNodesVelocity();
    545         int pnumnodes = this->NumberofNodesPressure();
    546 
    547         /*First, figure out size of doflist and create it: */
    548         int numberofdofs=0;
    549         for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
    550 
    551         /*Allocate output*/
    552         int* doflist=xNew<int>(numberofdofs);
    553 
    554         /*Populate: */
    555         int count=0;
    556         for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++){
    557                 nodes[i]->GetDofList(doflist+count,FSApproximationEnum,setenum);
    558                 count+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
    559         }
    560 
    561         /*Assign output pointers:*/
    562         *pdoflist=doflist;
    563490}
    564491/*}}}*/
  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r17288 r17296  
    7676                Element*    GetSurfaceElement(void){_error_("not implemented yet");};
    7777                Element*    GetBasalElement(void){_error_("not implemented yet");};
    78                 void          GetDofList(int** pdoflist,int approximation_enum,int setenum);
    79                 void          GetDofListVelocity(int** pdoflist,int setenum);
    80                 void          GetDofListPressure(int** pdoflist,int setenum);
    8178                void        GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);
    8279                IssmDouble  GetGroundedPortion(IssmDouble* xyz_list);
Note: See TracChangeset for help on using the changeset viewer.