Changeset 16951


Ignore:
Timestamp:
11/26/13 11:31:24 (11 years ago)
Author:
seroussi
Message:

CHG: starting friction SSAFS

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

Legend:

Unmodified
Added
Removed

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

    r16950 r16951  
    30863086
    30873087        return NULL;
     3088        /*Initialize Element matrix and return if necessary*/
     3089        if(element->IsFloating() || !element->IsOnBed()) return NULL;
     3090
     3091        /*Build a tria element using the 3 nodes of the base of the penta. Then use
     3092         * the tria functionality to build a friction stiffness matrix on these 3
     3093         * nodes: */
     3094        Element* basalelement = element->SpawnBasalElement();
     3095        ElementMatrix* Ke=CreateKMatrixSSAFriction(element);
     3096        basalelement->DeleteMaterials(); delete basalelement;
     3097
     3098        /*clean-up and return*/
     3099        return Ke;
    30883100}/*}}}*/
    30893101ElementMatrix* StressbalanceAnalysis::CreateKMatrixSSA3dViscous(Element* element){/*{{{*/
    … …  
    34763488}/*}}}*/
    34773489ElementMatrix* StressbalanceAnalysis::CreateKMatrixCouplingSSAFSFriction(Element* element){/*{{{*/
    3478         return NULL;
    3479 
     3490
     3491        /*Constants*/
     3492        const int numdofs   = (6+1)*3 + 6*1;
     3493        const int numdofm   = 6 *2;
     3494        const int numdof2d  = 3 *3;
     3495        const int numdof2dm = 3 *2;
     3496        const int numdoftot = 6*2 + (6+1)*3 +6; // HO + FS vel + FS Pressure
     3497
     3498        /*Intermediaries */
     3499        int        i,j,approximation;
     3500        int        dim=3;
     3501        IssmDouble FSreconditioning,viscosity,alpha2_gauss,Jdet2d;
     3502        IssmDouble bed_normal[3];
     3503        IssmDouble LSSAFS[8][numdof2dm];
     3504        IssmDouble LprimeSSAFS[8][numdofs];
     3505        IssmDouble DLSSAFS[8][8]={0.0};
     3506        IssmDouble LFSSSA[4][numdof2d];
     3507        IssmDouble LprimeFSSSA[4][numdof2dm];
     3508        IssmDouble DLFSSSA[4][4]={0.0};
     3509        IssmDouble Ke_drag_gaussian[numdof2dm][numdofs];
     3510        IssmDouble Ke_drag_gaussian2[numdof2d][numdof2dm];
     3511        IssmDouble *xyz_list      = NULL;
     3512        IssmDouble *xyz_list_tria = NULL;
     3513
     3514        /*If on water or not FS, skip stiffness: */
     3515        element->GetInputValue(&approximation,ApproximationEnum);
     3516        if(element->IsFloating() || !element->IsOnBed()) return NULL;
     3517
     3518        int vnumnodes = element->GetNumberOfNodesVelocity();
     3519        int pnumnodes = element->GetNumberOfNodesPressure();
     3520        int numnodes  = 2*vnumnodes-1+pnumnodes;
     3521
     3522        /*Prepare node list*/
     3523        int* cs_list = xNew<int>(2*vnumnodes+pnumnodes);
     3524        Node **node_list = xNew<Node*>(2*vnumnodes+pnumnodes);
     3525        for(i=0;i<vnumnodes-1;i++){
     3526                node_list[i] = element->GetNode(i);
     3527                cs_list[i]   = XYEnum;
     3528        }
     3529        for(i=0;i<vnumnodes;i++){
     3530                node_list[i+vnumnodes-1] = element->GetNode(i);
     3531                cs_list[i+vnumnodes-1]   = XYZEnum;
     3532        }
     3533        for(i=0;i<pnumnodes;i++){
     3534                node_list[2*vnumnodes-1+i] = element->GetNode(vnumnodes+i);
     3535                cs_list[2*vnumnodes-1+i]   = PressureEnum;
     3536        }
     3537
     3538        ElementMatrix* Ke1=element->NewElementMatrix(SSAApproximationEnum);
     3539        ElementMatrix* Ke2=element->NewElementMatrix(FSvelocityEnum);
     3540        ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
     3541        delete Ke1; delete Ke2;
     3542
     3543        /*Retrieve all inputs and parameters*/
     3544        element->GetVerticesCoordinates(&xyz_list);
     3545        element->GetVerticesCoordinatesBase(&xyz_list_tria);
     3546        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
     3547        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
     3548        Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
     3549        Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     3550
     3551        /*build friction object, used later on: */
     3552        Friction* friction=new Friction(element,3);
     3553
     3554        /* Start  looping on the number of gaussian points: */
     3555        Gauss* gauss=element->NewGaussBase(2);
     3556        for(int ig=gauss->begin();ig<gauss->end();ig++){
     3557
     3558                gauss->GaussPoint(ig);
     3559
     3560                element->JacobianDeterminantBase(&Jdet2d,xyz_list_tria,gauss);
     3561                this->GetLSSAFS(&LSSAFS[0][0], element,gauss);
     3562                this->GetLprimeSSAFS(&LprimeSSAFS[0][0], element,xyz_list, gauss);
     3563                this->GetLFSSSA(&LFSSSA[0][0],element, gauss);
     3564                this->GetLprimeFSSSA(&LprimeFSSSA[0][0], element,xyz_list, gauss);
     3565
     3566                element->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
     3567
     3568                element->NormalBase(&bed_normal[0],xyz_list_tria);
     3569                friction->GetAlpha2(&alpha2_gauss, gauss,vx_input,vy_input,vz_input);
     3570
     3571                DLSSAFS[0][0]=alpha2_gauss*gauss->weight*Jdet2d;
     3572                DLSSAFS[1][1]=alpha2_gauss*gauss->weight*Jdet2d;
     3573                DLSSAFS[2][2]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[0]*bed_normal[2];
     3574                DLSSAFS[3][3]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[1]*bed_normal[2];
     3575                DLSSAFS[4][4]=-2*viscosity*gauss->weight*Jdet2d*bed_normal[0];
     3576                DLSSAFS[5][5]=-2*viscosity*gauss->weight*Jdet2d*bed_normal[1];
     3577                DLSSAFS[6][6]=FSreconditioning*gauss->weight*Jdet2d*bed_normal[0];
     3578                DLSSAFS[7][7]=FSreconditioning*gauss->weight*Jdet2d*bed_normal[1];
     3579
     3580                DLFSSSA[0][0]=alpha2_gauss*gauss->weight*Jdet2d;
     3581                DLFSSSA[1][1]=alpha2_gauss*gauss->weight*Jdet2d;
     3582                DLFSSSA[2][2]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[0]*bed_normal[2];
     3583                DLFSSSA[3][3]=-alpha2_gauss*gauss->weight*Jdet2d*bed_normal[1]*bed_normal[2];
     3584
     3585                TripleMultiply( &LSSAFS[0][0],8,numdof2dm,1,
     3586                                        &DLSSAFS[0][0],8,8,0,
     3587                                        &LprimeSSAFS[0][0],8,numdofs,0,
     3588                                        &Ke_drag_gaussian[0][0],0);
     3589
     3590                TripleMultiply( &LFSSSA[0][0],4,numdof2d,1,
     3591                                        &DLFSSSA[0][0],4,4,0,
     3592                                        &LprimeFSSSA[0][0],4,numdof2dm,0,
     3593                                        &Ke_drag_gaussian2[0][0],0);
     3594                for(i=0;i<numdof2dm;i++) for(j=0;j<numdofs;j++) Ke->values[i*numdoftot+j+numdofm]+=Ke_drag_gaussian[i][j];
     3595                for(i=0;i<numdof2d;i++) for(j=0;j<numdof2dm;j++) Ke->values[(i+numdofm)*numdoftot+j]+=Ke_drag_gaussian2[i][j];
     3596        }
     3597
     3598        /*Transform Coordinate System*/
     3599        element->TransformStiffnessMatrixCoord(Ke,node_list,numnodes,cs_list);
     3600
     3601        /*Clean up and return*/
     3602        xDelete<int>(cs_list);
     3603        xDelete<Node*>(node_list);
     3604        xDelete<IssmDouble>(xyz_list);
     3605        xDelete<IssmDouble>(xyz_list_tria);
     3606        delete gauss;
     3607        delete friction;
     3608        return Ke;
    34803609}/*}}}*/
    34813610ElementMatrix* StressbalanceAnalysis::CreateKMatrixCouplingSSAFSViscous(Element* element){/*{{{*/
    34823611
     3612        printf("CouplingSSAFSviscous\n");
    34833613        /*Constants*/
    34843614        const int numdofm     = 2 *3;
    … …  
    41684298        xDelete<IssmDouble>(dbasis);
    41694299}/*}}}*/
     4300void StressbalanceAnalysis::GetLSSAFS(IssmDouble* LFS,Element* element,Gauss* gauss_in){/*{{{*/
     4301        /*
     4302         * Compute L  matrix. L=[L1 L2 L3] where Li is square and of size numdof.
     4303         * For node i, Li can be expressed in the actual coordinate system
     4304         * by:
     4305         *       Li=[ h    0 ]
     4306         *                    [ 0    h ]
     4307         *                    [ h    0 ]
     4308         *                    [ 0    h ]
     4309         *                    [ h    0 ]
     4310         *                    [ 0    h ]
     4311         *                    [ h    0 ]
     4312         *                    [ 0    h ]
     4313         * where h is the interpolation function for node i.
     4314         */
     4315
     4316        int num_dof=2;
     4317        IssmDouble L1L2l3[3];
     4318
     4319        /*Cast gauss to GaussPenta*/
     4320        _assert_(gauss_in->Enum()==GaussPentaEnum);
     4321        GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     4322
     4323        /*Get L1L2l3 in actual coordinate system: */
     4324        L1L2l3[0]=gauss->coord1*(1-gauss->coord4)/2.0;
     4325        L1L2l3[1]=gauss->coord2*(1-gauss->coord4)/2.0;
     4326        L1L2l3[2]=gauss->coord3*(1-gauss->coord4)/2.0;
     4327
     4328        /*Build LFS: */
     4329        for(int i=0;i<3;i++){
     4330                LFS[num_dof*3*0+num_dof*i+0] = L1L2l3[i];
     4331                LFS[num_dof*3*0+num_dof*i+1] = 0;
     4332                LFS[num_dof*3*1+num_dof*i+0] = 0;
     4333                LFS[num_dof*3*1+num_dof*i+1] = L1L2l3[i];
     4334                LFS[num_dof*3*2+num_dof*i+0] = L1L2l3[i];
     4335                LFS[num_dof*3*2+num_dof*i+1] = 0;
     4336                LFS[num_dof*3*3+num_dof*i+0] = 0;
     4337                LFS[num_dof*3*3+num_dof*i+1] = L1L2l3[i];
     4338                LFS[num_dof*3*4+num_dof*i+0] = L1L2l3[i];
     4339                LFS[num_dof*3*4+num_dof*i+1] = 0;
     4340                LFS[num_dof*3*5+num_dof*i+0] = 0;
     4341                LFS[num_dof*3*5+num_dof*i+1] = L1L2l3[i];
     4342                LFS[num_dof*3*6+num_dof*i+0] = L1L2l3[i];
     4343                LFS[num_dof*3*6+num_dof*i+1] = 0;
     4344                LFS[num_dof*3*7+num_dof*i+0] = 0;
     4345                LFS[num_dof*3*7+num_dof*i+1] = L1L2l3[i];
     4346        }
     4347}/*}}}*/
     4348void StressbalanceAnalysis::GetLprimeSSAFS(IssmDouble* LprimeFS,Element* element,IssmDouble* xyz_list,Gauss* gauss_in){/*{{{*/
     4349        /* Compute Lprime  matrix. Lprime=[Lp1 Lp2 Lp3] where Lpi is square and of size numdof.
     4350         * For node i, Lpi can be expressed in the actual coordinate system
     4351         * by:
     4352         *       Lpi=[ h    0    0   0]
     4353         *                     [ 0    h    0   0]
     4354         *                     [ 0    0    h   0]
     4355         *                     [ 0    0    h   0]
     4356         *                     [ 0    0  dh/dz 0]
     4357         *                     [ 0    0  dh/dz 0]
     4358         *           [ 0    0    0   h]
     4359         *           [ 0    0    0   h]
     4360         * where h is the interpolation function for node i.
     4361         */
     4362        int num_dof=3;
     4363        int num_dof_vel=3*7;
     4364        int num_dof_total=3*7+1*6;
     4365        IssmDouble L1L2l3[3];
     4366        IssmDouble dbasis[3][6];
     4367
     4368        /*Cast gauss to GaussPenta*/
     4369        _assert_(gauss_in->Enum()==GaussPentaEnum);
     4370        GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     4371
     4372        /*Get L1L2l3 in actual coordinate system: */
     4373        L1L2l3[0]=gauss->coord1*(1-gauss->coord4)/2.0;
     4374        L1L2l3[1]=gauss->coord2*(1-gauss->coord4)/2.0;
     4375        L1L2l3[2]=gauss->coord3*(1-gauss->coord4)/2.0;
     4376
     4377        element->NodalFunctionsP1Derivatives(&dbasis[0][0],xyz_list,gauss);
     4378
     4379        /*Build LprimeFS: */
     4380        for(int i=0;i<3;i++){
     4381                LprimeFS[num_dof_total*0+num_dof*i+0] = L1L2l3[i];
     4382                LprimeFS[num_dof_total*0+num_dof*i+1] = 0.;
     4383                LprimeFS[num_dof_total*0+num_dof*i+2] = 0.;
     4384                LprimeFS[num_dof_total*1+num_dof*i+0] = 0.;
     4385                LprimeFS[num_dof_total*1+num_dof*i+1] = L1L2l3[i];
     4386                LprimeFS[num_dof_total*1+num_dof*i+2] = 0.;
     4387                LprimeFS[num_dof_total*2+num_dof*i+0] = 0.;
     4388                LprimeFS[num_dof_total*2+num_dof*i+1] = 0.;
     4389                LprimeFS[num_dof_total*2+num_dof*i+2] = L1L2l3[i];
     4390                LprimeFS[num_dof_total*3+num_dof*i+0] = 0.;
     4391                LprimeFS[num_dof_total*3+num_dof*i+1] = 0.;
     4392                LprimeFS[num_dof_total*3+num_dof*i+2] = L1L2l3[i];
     4393                LprimeFS[num_dof_total*4+num_dof*i+0] = 0.;
     4394                LprimeFS[num_dof_total*4+num_dof*i+1] = 0.;
     4395                LprimeFS[num_dof_total*4+num_dof*i+2] = dbasis[2][i];
     4396                LprimeFS[num_dof_total*5+num_dof*i+0] = 0.;
     4397                LprimeFS[num_dof_total*5+num_dof*i+1] = 0.;
     4398                LprimeFS[num_dof_total*5+num_dof*i+2] = dbasis[2][i];
     4399                LprimeFS[num_dof_total*6+num_dof*i+0] = 0.;
     4400                LprimeFS[num_dof_total*6+num_dof*i+1] = 0.;
     4401                LprimeFS[num_dof_total*6+num_dof*i+2] = 0.;
     4402                LprimeFS[num_dof_total*7+num_dof*i+0] = 0.;
     4403                LprimeFS[num_dof_total*7+num_dof*i+1] = 0.;
     4404                LprimeFS[num_dof_total*7+num_dof*i+2] = 0.;
     4405        }
     4406        for(int i=3;i<7;i++){
     4407                LprimeFS[num_dof_total*0+num_dof*i+0] = 0.;
     4408                LprimeFS[num_dof_total*0+num_dof*i+1] = 0.;
     4409                LprimeFS[num_dof_total*0+num_dof*i+2] = 0.;
     4410                LprimeFS[num_dof_total*1+num_dof*i+0] = 0.;
     4411                LprimeFS[num_dof_total*1+num_dof*i+1] = 0.;
     4412                LprimeFS[num_dof_total*1+num_dof*i+2] = 0.;
     4413                LprimeFS[num_dof_total*2+num_dof*i+0] = 0.;
     4414                LprimeFS[num_dof_total*2+num_dof*i+1] = 0.;
     4415                LprimeFS[num_dof_total*2+num_dof*i+2] = 0.;
     4416                LprimeFS[num_dof_total*3+num_dof*i+0] = 0.;
     4417                LprimeFS[num_dof_total*3+num_dof*i+1] = 0.;
     4418                LprimeFS[num_dof_total*3+num_dof*i+2] = 0.;
     4419                LprimeFS[num_dof_total*4+num_dof*i+0] = 0.;
     4420                LprimeFS[num_dof_total*4+num_dof*i+1] = 0.;
     4421                LprimeFS[num_dof_total*4+num_dof*i+2] = 0.;
     4422                LprimeFS[num_dof_total*5+num_dof*i+0] = 0.;
     4423                LprimeFS[num_dof_total*5+num_dof*i+1] = 0.;
     4424                LprimeFS[num_dof_total*5+num_dof*i+2] = 0.;
     4425                LprimeFS[num_dof_total*6+num_dof*i+0] = 0.;
     4426                LprimeFS[num_dof_total*6+num_dof*i+1] = 0.;
     4427                LprimeFS[num_dof_total*6+num_dof*i+2] = 0.;
     4428                LprimeFS[num_dof_total*7+num_dof*i+0] = 0.;
     4429                LprimeFS[num_dof_total*7+num_dof*i+1] = 0.;
     4430                LprimeFS[num_dof_total*7+num_dof*i+2] = 0.;
     4431        }
     4432        for(int i=0;i<3;i++){
     4433                LprimeFS[num_dof_total*0+num_dof_vel+i] = 0.;
     4434                LprimeFS[num_dof_total*1+num_dof_vel+i] = 0.;
     4435                LprimeFS[num_dof_total*2+num_dof_vel+i] = 0.;
     4436                LprimeFS[num_dof_total*3+num_dof_vel+i] = 0.;
     4437                LprimeFS[num_dof_total*4+num_dof_vel+i] = 0.;
     4438                LprimeFS[num_dof_total*5+num_dof_vel+i] = 0.;
     4439                LprimeFS[num_dof_total*6+num_dof_vel+i] = L1L2l3[i];
     4440                LprimeFS[num_dof_total*7+num_dof_vel+i] = L1L2l3[i];
     4441        }
     4442        for(int i=3;i<6;i++){
     4443                LprimeFS[num_dof_total*0+num_dof_vel+i] = 0.;
     4444                LprimeFS[num_dof_total*1+num_dof_vel+i] = 0.;
     4445                LprimeFS[num_dof_total*2+num_dof_vel+i] = 0.;
     4446                LprimeFS[num_dof_total*3+num_dof_vel+i] = 0.;
     4447                LprimeFS[num_dof_total*4+num_dof_vel+i] = 0.;
     4448                LprimeFS[num_dof_total*5+num_dof_vel+i] = 0.;
     4449                LprimeFS[num_dof_total*6+num_dof_vel+i] = 0.;
     4450                LprimeFS[num_dof_total*7+num_dof_vel+i] = 0.;
     4451        }
     4452}/*}}}*/
     4453void StressbalanceAnalysis::GetLFSSSA(IssmDouble* LFS,Element* element,Gauss* gauss_in){/*{{{*/
     4454        /* Compute L  matrix. L=[L1 L2 L3] where Li is square and of size numdof.
     4455         * For node i, Li can be expressed in the actual coordinate system
     4456         * by:
     4457         *       Li=[ h    0    0 ]
     4458         *                    [ 0    h    0 ]
     4459         *                    [ 0    0    h ]
     4460         *                    [ 0    0    h ]
     4461         * where h is the interpolation function for node i.
     4462         */
     4463
     4464        int num_dof=3;
     4465        IssmDouble L1L2l3[3];
     4466
     4467        /*Cast gauss to GaussPenta*/
     4468        _assert_(gauss_in->Enum()==GaussPentaEnum);
     4469        GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     4470
     4471        /*Get L1L2l3 in actual coordinate system: */
     4472        L1L2l3[0]=gauss->coord1*(1-gauss->coord4)/2.0;
     4473        L1L2l3[1]=gauss->coord2*(1-gauss->coord4)/2.0;
     4474        L1L2l3[2]=gauss->coord3*(1-gauss->coord4)/2.0;
     4475
     4476        /*Build LFS: */
     4477        for(int i=0;i<3;i++){
     4478                LFS[num_dof*3*0+num_dof*i+0] = L1L2l3[i];
     4479                LFS[num_dof*3*0+num_dof*i+1] = 0.;
     4480                LFS[num_dof*3*0+num_dof*i+2] = 0.;
     4481                LFS[num_dof*3*1+num_dof*i+0] = 0.;
     4482                LFS[num_dof*3*1+num_dof*i+1] = L1L2l3[i];
     4483                LFS[num_dof*3*1+num_dof*i+2] = 0.;
     4484                LFS[num_dof*3*2+num_dof*i+0] = 0.;
     4485                LFS[num_dof*3*2+num_dof*i+1] = 0.;
     4486                LFS[num_dof*3*2+num_dof*i+2] = L1L2l3[i];
     4487                LFS[num_dof*3*3+num_dof*i+0] = 0.;
     4488                LFS[num_dof*3*3+num_dof*i+1] = 0.;
     4489                LFS[num_dof*3*3+num_dof*i+2] = L1L2l3[i];
     4490        }
     4491}/*}}}*/
     4492void StressbalanceAnalysis::GetLprimeFSSSA(IssmDouble* LprimeFS,Element* element,IssmDouble* xyz_list,Gauss* gauss_in){/*{{{*/
     4493        /* Compute Lprime  matrix. Lprime=[Lp1 Lp2 Lp3] where Lpi is square and of size numdof.
     4494         * For node i, Lpi can be expressed in the actual coordinate system
     4495         * by:
     4496         *       Lpi=[ h    0 ]
     4497         *                     [ 0    h ]
     4498         *                     [ h    0 ]
     4499         *                     [ 0    h ]
     4500         * where h is the interpolation function for node i.
     4501         */
     4502        int num_dof=2;
     4503        IssmDouble L1L2l3[3];
     4504
     4505        /*Cast gauss to GaussPenta*/
     4506        _assert_(gauss_in->Enum()==GaussPentaEnum);
     4507        GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
     4508
     4509        /*Get L1L2l3 in actual coordinate system: */
     4510        L1L2l3[0]=gauss->coord1*(1-gauss->coord4)/2.0;
     4511        L1L2l3[1]=gauss->coord2*(1-gauss->coord4)/2.0;
     4512        L1L2l3[2]=gauss->coord3*(1-gauss->coord4)/2.0;
     4513
     4514        /*Build LprimeFS: */
     4515        for(int i=0;i<3;i++){
     4516                LprimeFS[num_dof*3*0+num_dof*i+0] = L1L2l3[i];
     4517                LprimeFS[num_dof*3*0+num_dof*i+1] = 0.;
     4518                LprimeFS[num_dof*3*1+num_dof*i+0] = 0.;
     4519                LprimeFS[num_dof*3*1+num_dof*i+1] = L1L2l3[i];
     4520                LprimeFS[num_dof*3*2+num_dof*i+0] = L1L2l3[i];
     4521                LprimeFS[num_dof*3*2+num_dof*i+1] = 0.;
     4522                LprimeFS[num_dof*3*3+num_dof*i+0] = 0.;
     4523                LprimeFS[num_dof*3*3+num_dof*i+1] = L1L2l3[i];
     4524        }
     4525}/*}}}*/
    41704526void StressbalanceAnalysis::InputUpdateFromSolutionHOFS(IssmDouble* solution,Element* element){/*{{{*/
    41714527

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h

    r16949 r16951  
    9898                void GetBSSAFSTria(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
    9999                void GetBprimeSSAFSTria(IssmDouble* Bprime,Element* element,IssmDouble* xyz_list,Gauss* gauss);
     100                void GetLFSSSA(IssmDouble* L,Element* element,Gauss* gauss);
     101                void GetLSSAFS(IssmDouble* L,Element* element,Gauss* gauss);
     102                void GetLprimeFSSSA(IssmDouble* Lprime,Element* element,IssmDouble* xyz_list,Gauss* gauss);
     103                void GetLprimeSSAFS(IssmDouble* Lprime,Element* element,IssmDouble* xyz_list,Gauss* gauss);
    100104                void InputUpdateFromSolutionHOFS(IssmDouble* solution,Element* element);
    101105                void InputUpdateFromSolutionSSAFS(IssmDouble* solution,Element* element);
Note: See TracChangeset for help on using the changeset viewer.