Ignore:
Timestamp:
12/03/13 10:36:26 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: moving all Stiffness matrices and Jacobian matrices to analyses

File:
1 edited

Legend:

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

    r16982 r16993  
    138138}
    139139/*}}}*/
    140 /*FUNCTION Seg::CreateKMatrixFreeSurfaceTop {{{*/
    141 ElementMatrix* Seg::CreateKMatrixFreeSurfaceTop(void){
    142 
    143         /*Intermediaries */
    144         int        stabilization;
    145         IssmDouble Jdet,D_scalar,dt,h;
    146         IssmDouble vx,vel;
    147         IssmDouble xyz_list[NUMVERTICES][3];
    148 
    149         /*Fetch number of nodes for this finite element*/
    150         int numnodes = this->NumberofNodes();
    151 
    152         /*Initialize Element matrix and vectors*/
    153         ElementMatrix* Ke     = new ElementMatrix(nodes,numnodes,this->parameters,NoneApproximationEnum);
    154         IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
    155         IssmDouble*    B      = xNew<IssmDouble>(1*numnodes);
    156         IssmDouble*    Bprime = xNew<IssmDouble>(1*numnodes);
    157 
    158         /*Retrieve all inputs and parameters*/
    159         ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    160         this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    161         this->parameters->FindParam(&stabilization,MasstransportStabilizationEnum);
    162         Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    163         h=this->GetSize();
    164 
    165         /* Start  looping on the number of gaussian points: */
    166         GaussSeg *gauss=new GaussSeg(2);
    167         for(int ig=gauss->begin();ig<gauss->end();ig++){
    168 
    169                 gauss->GaussPoint(ig);
    170 
    171                 GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
    172                 GetNodalFunctions(basis,gauss);
    173 
    174                 vx_input->GetInputValue(&vx,gauss);
    175 
    176                 D_scalar=gauss->weight*Jdet;
    177 
    178                 TripleMultiply(basis,1,numnodes,1,
    179                                         &D_scalar,1,1,0,
    180                                         basis,1,numnodes,0,
    181                                         &Ke->values[0],1);
    182 
    183                 GetNodalFunctions(B,gauss);
    184                 GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss);
    185 
    186                 D_scalar=dt*gauss->weight*Jdet*vx;
    187                 TripleMultiply(B,1,numnodes,1,
    188                                         &D_scalar,1,1,0,
    189                                         Bprime,1,numnodes,0,
    190                                         &Ke->values[0],1);
    191 
    192                 if(stabilization==2){
    193                         /*Streamline upwinding*/
    194                         vel=fabs(vx)+1.e-8;
    195                         D_scalar=dt*gauss->weight*Jdet*h/(2.*vel)*vx;
    196                 }
    197                 else if(stabilization==1){
    198                         /*SSA*/
    199                         vx_input->GetInputAverage(&vx);
    200                         D_scalar=dt*gauss->weight*Jdet*h/2.*fabs(vx);
    201                 }
    202                 if(stabilization==1 || stabilization==2){
    203                         TripleMultiply(Bprime,1,numnodes,1,
    204                                                 &D_scalar,1,1,0,
    205                                                 Bprime,1,numnodes,0,
    206                                                 &Ke->values[0],1);
    207                 }
    208         }
    209 
    210         /*Clean up and return*/
    211         xDelete<IssmDouble>(basis);
    212         xDelete<IssmDouble>(B);
    213         xDelete<IssmDouble>(Bprime);
    214         delete gauss;
    215         return Ke;
    216 }
    217 /*}}}*/
    218 /*FUNCTION Seg::CreateKMatrixFreeSurfaceBase {{{*/
    219 ElementMatrix* Seg::CreateKMatrixFreeSurfaceBase(void){
    220 
    221         /*Intermediaries */
    222         int        stabilization;
    223         IssmDouble Jdet,D_scalar,dt,h;
    224         IssmDouble vx,vel;
    225         IssmDouble xyz_list[NUMVERTICES][3];
    226 
    227         /*Fetch number of nodes for this finite element*/
    228         int numnodes = this->NumberofNodes();
    229 
    230         /*Initialize Element matrix and vectors*/
    231         ElementMatrix* Ke     = new ElementMatrix(nodes,numnodes,this->parameters,NoneApproximationEnum);
    232         IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
    233         IssmDouble*    B      = xNew<IssmDouble>(1*numnodes);
    234         IssmDouble*    Bprime = xNew<IssmDouble>(1*numnodes);
    235 
    236         /*Retrieve all inputs and parameters*/
    237         ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    238         this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    239         this->parameters->FindParam(&stabilization,MasstransportStabilizationEnum);
    240         Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    241         h=this->GetSize();
    242 
    243         /* Start  looping on the number of gaussian points: */
    244         GaussSeg *gauss=new GaussSeg(2);
    245         for(int ig=gauss->begin();ig<gauss->end();ig++){
    246 
    247                 gauss->GaussPoint(ig);
    248 
    249                 GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
    250                 GetNodalFunctions(basis,gauss);
    251 
    252                 vx_input->GetInputValue(&vx,gauss);
    253 
    254                 D_scalar=gauss->weight*Jdet;
    255 
    256                 TripleMultiply(basis,1,numnodes,1,
    257                                         &D_scalar,1,1,0,
    258                                         basis,1,numnodes,0,
    259                                         &Ke->values[0],1);
    260 
    261                 GetNodalFunctions(B,gauss);
    262                 GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss);
    263 
    264                 D_scalar=dt*gauss->weight*Jdet*vx;
    265                 TripleMultiply(B,1,numnodes,1,
    266                                         &D_scalar,1,1,0,
    267                                         Bprime,1,numnodes,0,
    268                                         &Ke->values[0],1);
    269 
    270                 if(stabilization==2){
    271                         /*Streamline upwinding*/
    272                         vel=fabs(vx)+1.e-8;
    273                         D_scalar=dt*gauss->weight*Jdet*h/(2.*vel)*vx;
    274                 }
    275                 else if(stabilization==1){
    276                         /*SSA*/
    277                         vx_input->GetInputAverage(&vx);
    278                         D_scalar=dt*gauss->weight*Jdet*h/2.*fabs(vx);
    279                 }
    280                 if(stabilization==1 || stabilization==2){
    281                         TripleMultiply(Bprime,1,numnodes,1,
    282                                                 &D_scalar,1,1,0,
    283                                                 Bprime,1,numnodes,0,
    284                                                 &Ke->values[0],1);
    285                 }
    286         }
    287 
    288         /*Clean up and return*/
    289         xDelete<IssmDouble>(basis);
    290         xDelete<IssmDouble>(B);
    291         xDelete<IssmDouble>(Bprime);
    292         delete gauss;
    293         return Ke;
    294 }
    295 /*}}}*/
    296 /*FUNCTION Seg::CreateMassMatrix {{{*/
    297 ElementMatrix* Seg::CreateMassMatrix(void){
    298 
    299         /* Intermediaries */
    300         IssmDouble  D,Jdet;
    301         IssmDouble  xyz_list[NUMVERTICES][3];
    302 
    303         /*Fetch number of nodes and dof for this finite element*/
    304         int numnodes = this->NumberofNodes();
    305 
    306         /*Initialize Element matrix and vectors*/
    307         ElementMatrix* Ke    = new ElementMatrix(nodes,numnodes,this->parameters,NoneApproximationEnum);
    308         IssmDouble*    basis = xNew<IssmDouble>(numnodes);
    309 
    310         /*Retrieve all inputs and parameters*/
    311         ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    312 
    313         /* Start looping on the number of gaussian points: */
    314         GaussSeg* gauss=new GaussSeg(2);
    315         for(int ig=gauss->begin();ig<gauss->end();ig++){
    316 
    317                 gauss->GaussPoint(ig);
    318 
    319                 GetNodalFunctions(basis,gauss);
    320                 GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
    321                 D=gauss->weight*Jdet;
    322 
    323                 TripleMultiply(basis,1,numnodes,1,
    324                                         &D,1,1,0,
    325                                         basis,1,numnodes,0,
    326                                         &Ke->values[0],1);
    327         }
    328 
    329         /*Clean up and return*/
    330         delete gauss;
    331         xDelete<IssmDouble>(basis);
    332         return Ke;
    333 }
    334 /*}}}*/
    335140/*FUNCTION Seg::GetNumberOfNodes;{{{*/
    336141int Seg::GetNumberOfNodes(void){
Note: See TracChangeset for help on using the changeset viewer.