Changeset 18560


Ignore:
Timestamp:
10/01/14 10:41:32 (10 years ago)
Author:
seroussi
Message:

CHG: merged augmentation of TH and CR

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

Legend:

Unmodified
Added
Removed

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

    r18521 r18560  
    29422942        if(fe_FS==XTaylorHoodEnum)
    29432943         Ke1=CreateKMatrixFSViscousXTH(element);
    2944         else if(fe_FS==LATaylorHoodEnum)
    2945          Ke1=CreateKMatrixFSViscousLATH(element);
    2946         else if(fe_FS==LACrouzeixRaviartEnum)
    2947          Ke1=CreateKMatrixFSViscousLACR(element);
     2944        else if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum)
     2945         Ke1=CreateKMatrixFSViscousLA(element);
    29482946        else
    29492947         Ke1=CreateKMatrixFSViscous(element);
    … …  
    29592957        return Ke;
    29602958}/*}}}*/
    2961 ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSViscousLATH(Element* element){/*{{{*/
     2959ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSViscousLA(Element* element){/*{{{*/
    29622960
    29632961        /*Intermediaries*/
    … …  
    29772975        int vnumnodes = element->NumberofNodesVelocity();
    29782976        int pnumnodes = element->GetNumberOfNodes(P1Enum);
    2979         int lnumnodes = element->GetNumberOfNodes(P2Enum);
    2980         int numdof    = vnumnodes*dim;
    2981         int pnumdof   = pnumnodes;
    2982         int lnumdof   = lnumnodes;
    2983 
    2984         /*Prepare coordinate system list*/
    2985         int* cs_list = xNew<int>(vnumnodes);
    2986         if(dim==2) for(i=0;i<vnumnodes;i++) cs_list[i] = XYEnum;
    2987         else       for(i=0;i<vnumnodes;i++) cs_list[i] = XYZEnum;
    2988 
    2989         /*Initialize Element matrix and vectors*/
    2990         ElementMatrix* Ke       = element->NewElementMatrix(FSvelocityEnum);
    2991         IssmDouble*    B        = xNew<IssmDouble>(epssize*numdof);
    2992         IssmDouble*    Bprime   = xNew<IssmDouble>(epssize*numdof);
    2993         IssmDouble*    BtBUzawa = xNewZeroInit<IssmDouble>(numdof*pnumdof);
    2994         IssmDouble*    BU       = xNew<IssmDouble>(pnumdof);
    2995         IssmDouble*    BprimeU  = xNew<IssmDouble>(numdof);
    2996         IssmDouble*    D        = xNewZeroInit<IssmDouble>(epssize*epssize);
    2997 
    2998         /*Retrieve all inputs and parameters*/
    2999         element->GetVerticesCoordinates(&xyz_list);
    3000         Input* vx_input = element->GetInput(VxEnum);     _assert_(vx_input);
    3001         Input* vy_input = element->GetInput(VyEnum);     _assert_(vy_input);
    3002         Input* vz_input = NULL;
    3003         if(dim==3){vz_input = element->GetInput(VzEnum); _assert_(vz_input);}
    3004 
    3005         /* Start  looping on the number of gaussian points: */
    3006         Gauss* gauss = element->NewGauss(5);
    3007         for(int ig=gauss->begin();ig<gauss->end();ig++){
    3008                 gauss->GaussPoint(ig);
    3009 
    3010                 element->JacobianDeterminant(&Jdet,xyz_list,gauss);
    3011                 this->GetBFSvel(B,element,dim,xyz_list,gauss);
    3012                 this->GetBFSprimevel(Bprime,element,dim,xyz_list,gauss);
    3013 
    3014                 element->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input);
    3015                 for(i=0;i<epssize;i++)   D[i*epssize+i] = 2*viscosity*gauss->weight*Jdet;
    3016 
    3017                 TripleMultiply(B,epssize,numdof,1,
    3018                                         D,epssize,epssize,0,
    3019                                         Bprime,epssize,numdof,0,
    3020                                         &Ke->values[0],1);
    3021 
    3022                 this->GetBFSUzawa(BU,element,dim,xyz_list,gauss);
    3023                 this->GetBFSprimeUzawa(BprimeU,element,dim,xyz_list,gauss);
    3024 
    3025                 DU = gauss->weight*Jdet*sqrt(r);
    3026 
    3027                 TripleMultiply(BU,1,pnumdof,1,
    3028                                         &DU,1,1,0,
    3029                                         BprimeU,1,numdof,0,
    3030                                         BtBUzawa,1);
    3031         }
    3032 
    3033         if(element->IsOnBase()){
    3034                 element->FindParam(&rl,AugmentedLagrangianRlambdaEnum);
    3035                 element->GetVerticesCoordinatesBase(&xyz_list_base);
    3036                 element->NormalBase(&normal[0],xyz_list_base);
    3037 
    3038                 IssmDouble* Dlambda  = xNewZeroInit<IssmDouble>(dim*dim);
    3039                 IssmDouble* C        = xNewZeroInit<IssmDouble>(dim*lnumdof);
    3040                 IssmDouble* Cprime   = xNewZeroInit<IssmDouble>(dim*numdof);
    3041                 IssmDouble* CtCUzawa = xNewZeroInit<IssmDouble>(numdof*lnumdof);
    3042 
    3043                 delete gauss;
    3044                 gauss = element->NewGaussBase(5);
    3045                 for(int ig=gauss->begin();ig<gauss->end();ig++){
    3046                         gauss->GaussPoint(ig);
    3047 
    3048                         element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
    3049                         this->GetCFS(C,element,dim,xyz_list,gauss);
    3050                         this->GetCFSprime(Cprime,element,dim,xyz_list,gauss);
    3051                         for(i=0;i<dim;i++) Dlambda[i*dim+i] = gauss->weight*Jdet*sqrt(normal[i]*normal[i])*sqrt(rl);
    3052                         TripleMultiply(C,dim,lnumdof,1,
    3053                                                 Dlambda,dim,dim,0,
    3054                                                 Cprime,dim,numdof,0,
    3055                                                 CtCUzawa,1);
    3056                 }
    3057 
    3058                 /*The sigma naugmentation should not be transformed*/
    3059                 MatrixMultiply(CtCUzawa,lnumdof,numdof,1,
    3060                                         CtCUzawa,lnumdof,numdof,0,
    3061                                         &Ke->values[0],1);
    3062 
    3063                 /*Delete base part*/
    3064                 xDelete<IssmDouble>(Dlambda);
    3065                 xDelete<IssmDouble>(C);
    3066                 xDelete<IssmDouble>(Cprime);
    3067                 xDelete<IssmDouble>(CtCUzawa);
    3068                 xDelete<IssmDouble>(xyz_list_base);
    3069         }
    3070 
    3071         /*Transform Coordinate System*/
    3072         element->TransformStiffnessMatrixCoord(Ke,cs_list);
    3073 
    3074         /*The pressure augmentation should not be transformed*/
    3075         MatrixMultiply(BtBUzawa,pnumdof,numdof,1,
    3076                                 BtBUzawa,pnumdof,numdof,0,
    3077                                 &Ke->values[0],1);
    3078 
    3079         /*Clean up and return*/
    3080         delete gauss;
    3081         xDelete<IssmDouble>(xyz_list);
    3082         xDelete<IssmDouble>(D);
    3083         xDelete<IssmDouble>(Bprime);
    3084         xDelete<IssmDouble>(B);
    3085         xDelete<IssmDouble>(BprimeU);
    3086         xDelete<IssmDouble>(BU);
    3087         xDelete<IssmDouble>(BtBUzawa);
    3088         xDelete<int>(cs_list);
    3089         return Ke;
    3090 }/*}}}*/
    3091 ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSViscousLACR(Element* element){/*{{{*/
    3092 
    3093         /*Intermediaries*/
    3094         int         i,dim,epssize;
    3095         IssmDouble  r,rl,Jdet,viscosity,DU,DUl;
    3096         IssmDouble      normal[3];
    3097         IssmDouble *xyz_list = NULL;
    3098         IssmDouble *xyz_list_base = NULL;
    3099 
    3100         /*Get problem dimension*/
    3101         element->FindParam(&dim,DomainDimensionEnum);
    3102         element->FindParam(&r,AugmentedLagrangianREnum);
    3103         if(dim==2) epssize = 3;
    3104         else       epssize = 6;
    3105 
    3106         /*Fetch number of nodes and dof for this finite element*/
    3107         int vnumnodes = element->NumberofNodesVelocity();
    3108         int pnumnodes = element->GetNumberOfNodes(P1DGEnum);
    31092977        int lnumnodes = element->GetNumberOfNodes(P2Enum);
    31102978        int numdof    = vnumnodes*dim;
    … …  
    38083676                delete pe4;
    38093677        }
    3810         else if(fe_FS==LATaylorHoodEnum){
     3678        else if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
    38113679                ElementVector* pe1=CreatePVectorFSViscous(element);
    38123680                ElementVector* pe2=CreatePVectorFSShelf(element);
    38133681                ElementVector* pe3=CreatePVectorFSFront(element);
    38143682                ElementVector* petemp =new ElementVector(pe1,pe2,pe3);
    3815                 ElementVector* pe4=CreatePVectorFSViscousLATH(element);
    3816                 pe = new ElementVector(petemp,pe4);
    3817                 delete pe1;
    3818                 delete pe2;
    3819                 delete pe3;
    3820                 delete petemp;
    3821                 delete pe4;
    3822         }
    3823         else if(fe_FS==LACrouzeixRaviartEnum){
    3824                 ElementVector* pe1=CreatePVectorFSViscous(element);
    3825                 ElementVector* pe2=CreatePVectorFSShelf(element);
    3826                 ElementVector* pe3=CreatePVectorFSFront(element);
    3827                 ElementVector* petemp =new ElementVector(pe1,pe2,pe3);
    3828                 ElementVector* pe4=CreatePVectorFSViscousLACR(element);
     3683                ElementVector* pe4=CreatePVectorFSViscousLA(element);
    38293684                pe = new ElementVector(petemp,pe4);
    38303685                delete pe1;
    … …  
    39173772}/*}}}*/
    39183773#endif
     3774ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousLA(Element* element){/*{{{*/
     3775
     3776        int         i,dim;
     3777        IssmDouble  Jdet,r,pressure;
     3778        IssmDouble  bed_normal[3];
     3779        IssmDouble *xyz_list      = NULL;
     3780        IssmDouble *xyz_list_base = NULL;
     3781        Gauss*      gauss         = NULL;
     3782
     3783        /*Get problem dimension*/
     3784        element->FindParam(&dim,DomainDimensionEnum);
     3785
     3786        /*Fetch number of nodes and dof for this finite element*/
     3787        int numnodes = element->GetNumberOfNodes();
     3788
     3789        /*Prepare coordinate system list*/
     3790        int* cs_list = xNew<int>(numnodes);
     3791        if(dim==2) for(i=0;i<numnodes;i++) cs_list[i] = XYEnum;
     3792        else       for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
     3793
     3794        /*Initialize vectors*/
     3795        ElementVector* pe      = element->NewElementVector(FSvelocityEnum);
     3796        IssmDouble*    dbasis  = xNew<IssmDouble>(3*numnodes);
     3797
     3798        /*Retrieve all inputs and parameters*/
     3799        element->FindParam(&r,AugmentedLagrangianREnum);
     3800        element->GetVerticesCoordinates(&xyz_list);
     3801
     3802        /*Get pressure and sigmann*/
     3803        Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
     3804        Input* sigmann_input =element->GetInput(SigmaNNEnum);  _assert_(sigmann_input);
     3805
     3806        gauss=element->NewGauss(5);
     3807        for(int ig=gauss->begin();ig<gauss->end();ig++){
     3808                gauss->GaussPoint(ig);
     3809                element->JacobianDeterminant(&Jdet,xyz_list,gauss);
     3810               
     3811                pressure_input->GetInputValue(&pressure, gauss);
     3812                element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss);
     3813
     3814                for(i=0;i<numnodes;i++){
     3815                        pe->values[i*dim+0] += pressure*gauss->weight*Jdet*dbasis[0*numnodes+i];
     3816                        pe->values[i*dim+1] += pressure*gauss->weight*Jdet*dbasis[1*numnodes+i];
     3817                        if(dim==3) pe->values[i*dim+2]+= pressure*gauss->weight*Jdet*dbasis[2*numnodes+i];
     3818                }
     3819        }
     3820
     3821        if(element->IsOnBase()){
     3822                IssmDouble   sigmann;
     3823                IssmDouble*  vbasis = xNew<IssmDouble>(numnodes);
     3824
     3825                element->GetVerticesCoordinatesBase(&xyz_list_base);
     3826                element->NormalBase(&bed_normal[0],xyz_list_base);
     3827
     3828                delete gauss;
     3829                gauss=element->NewGaussBase(5);
     3830                for(int ig=gauss->begin();ig<gauss->end();ig++){
     3831                        gauss->GaussPoint(ig);
     3832
     3833                        element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
     3834                        element->NodalFunctionsVelocity(vbasis,gauss);
     3835                        sigmann_input->GetInputValue(&sigmann, gauss);
     3836
     3837                        for(i=0;i<numnodes;i++){
     3838                                pe->values[i*dim+0] += + sigmann*bed_normal[0]*gauss->weight*Jdet*vbasis[i];
     3839                                pe->values[i*dim+1] += + sigmann*bed_normal[1]*gauss->weight*Jdet*vbasis[i];
     3840                                if(dim==3) pe->values[i*dim+2] += + sigmann*bed_normal[2]*gauss->weight*Jdet*vbasis[i];
     3841                        }
     3842                }
     3843                xDelete<IssmDouble>(xyz_list_base);
     3844                xDelete<IssmDouble>(vbasis);
     3845        }
     3846
     3847        /*Transform coordinate system*/
     3848        //element->TransformLoadVectorCoord(pe,cs_list); Do not transform augmentation
     3849
     3850        /*Clean up and return*/
     3851        delete gauss;
     3852        xDelete<int>(cs_list);
     3853        xDelete<IssmDouble>(xyz_list);
     3854        xDelete<IssmDouble>(dbasis);
     3855        return pe;
     3856}/*}}}*/
    39193857ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousXTH(Element* element){/*{{{*/
    39203858
    … …  
    40874025        xDelete<IssmDouble>(vdbasis);
    40884026        xDelete<IssmDouble>(tbasis);
    4089         return pe;
    4090 }/*}}}*/
    4091 ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousLATH(Element* element){/*{{{*/
    4092 
    4093         int         i,dim;
    4094         IssmDouble  Jdet,r,pressure;
    4095         IssmDouble  bed_normal[3];
    4096         IssmDouble *xyz_list      = NULL;
    4097         IssmDouble *xyz_list_base = NULL;
    4098         Gauss*      gauss         = NULL;
    4099 
    4100         /*Get problem dimension*/
    4101         element->FindParam(&dim,DomainDimensionEnum);
    4102 
    4103         /*Fetch number of nodes and dof for this finite element*/
    4104         int numnodes = element->GetNumberOfNodes();
    4105 
    4106         /*Prepare coordinate system list*/
    4107         int* cs_list = xNew<int>(numnodes);
    4108         if(dim==2) for(i=0;i<numnodes;i++) cs_list[i] = XYEnum;
    4109         else       for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
    4110 
    4111         /*Initialize vectors*/
    4112         ElementVector* pe      = element->NewElementVector(FSvelocityEnum);
    4113         IssmDouble*    dbasis  = xNew<IssmDouble>(3*numnodes);
    4114 
    4115         /*Retrieve all inputs and parameters*/
    4116         element->FindParam(&r,AugmentedLagrangianREnum);
    4117         element->GetVerticesCoordinates(&xyz_list);
    4118 
    4119         /*Get pressure and sigmann*/
    4120         Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    4121         Input* sigmann_input =element->GetInput(SigmaNNEnum);  _assert_(sigmann_input);
    4122 
    4123         gauss=element->NewGauss(5);
    4124         for(int ig=gauss->begin();ig<gauss->end();ig++){
    4125                 gauss->GaussPoint(ig);
    4126                 element->JacobianDeterminant(&Jdet,xyz_list,gauss);
    4127                
    4128                 pressure_input->GetInputValue(&pressure, gauss);
    4129                 element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss);
    4130 
    4131                 for(i=0;i<numnodes;i++){
    4132                         pe->values[i*dim+0] += pressure*gauss->weight*Jdet*dbasis[0*numnodes+i];
    4133                         pe->values[i*dim+1] += pressure*gauss->weight*Jdet*dbasis[1*numnodes+i];
    4134                         if(dim==3) pe->values[i*dim+2]+= pressure*gauss->weight*Jdet*dbasis[2*numnodes+i];
    4135                 }
    4136         }
    4137 
    4138         if(element->IsOnBase()){
    4139                 IssmDouble   sigmann;
    4140                 IssmDouble*  vbasis = xNew<IssmDouble>(numnodes);
    4141 
    4142                 element->GetVerticesCoordinatesBase(&xyz_list_base);
    4143                 element->NormalBase(&bed_normal[0],xyz_list_base);
    4144 
    4145                 delete gauss;
    4146                 gauss=element->NewGaussBase(5);
    4147                 for(int ig=gauss->begin();ig<gauss->end();ig++){
    4148                         gauss->GaussPoint(ig);
    4149 
    4150                         element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
    4151                         element->NodalFunctionsVelocity(vbasis,gauss);
    4152                         sigmann_input->GetInputValue(&sigmann, gauss);
    4153 
    4154                         for(i=0;i<numnodes;i++){
    4155                                 pe->values[i*dim+0] += + sigmann*bed_normal[0]*gauss->weight*Jdet*vbasis[i];
    4156                                 pe->values[i*dim+1] += + sigmann*bed_normal[1]*gauss->weight*Jdet*vbasis[i];
    4157                                 if(dim==3) pe->values[i*dim+2] += + sigmann*bed_normal[2]*gauss->weight*Jdet*vbasis[i];
    4158                         }
    4159                 }
    4160                 xDelete<IssmDouble>(xyz_list_base);
    4161                 xDelete<IssmDouble>(vbasis);
    4162         }
    4163 
    4164         /*Transform coordinate system*/
    4165         //element->TransformLoadVectorCoord(pe,cs_list); Do not transform augmentation
    4166 
    4167         /*Clean up and return*/
    4168         delete gauss;
    4169         xDelete<int>(cs_list);
    4170         xDelete<IssmDouble>(xyz_list);
    4171         xDelete<IssmDouble>(dbasis);
    4172         return pe;
    4173 }/*}}}*/
    4174 ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousLACR(Element* element){/*{{{*/
    4175 
    4176         int         i,dim;
    4177         IssmDouble  Jdet,r,pressure;
    4178         IssmDouble  bed_normal[3];
    4179         IssmDouble *xyz_list      = NULL;
    4180         IssmDouble *xyz_list_base = NULL;
    4181         Gauss*      gauss         = NULL;
    4182 
    4183         /*Get problem dimension*/
    4184         element->FindParam(&dim,DomainDimensionEnum);
    4185 
    4186         /*Fetch number of nodes and dof for this finite element*/
    4187         int numnodes = element->GetNumberOfNodes();
    4188 
    4189         /*Prepare coordinate system list*/
    4190         int* cs_list = xNew<int>(numnodes);
    4191         if(dim==2) for(i=0;i<numnodes;i++) cs_list[i] = XYEnum;
    4192         else       for(i=0;i<numnodes;i++) cs_list[i] = XYZEnum;
    4193 
    4194         /*Initialize vectors*/
    4195         ElementVector* pe      = element->NewElementVector(FSvelocityEnum);
    4196         IssmDouble*    dbasis  = xNew<IssmDouble>(3*numnodes);
    4197 
    4198         /*Retrieve all inputs and parameters*/
    4199         element->FindParam(&r,AugmentedLagrangianREnum);
    4200         element->GetVerticesCoordinates(&xyz_list);
    4201 
    4202         /*Get pressure and sigmann*/
    4203         Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    4204         Input* sigmann_input =element->GetInput(SigmaNNEnum);  _assert_(sigmann_input);
    4205 
    4206         gauss=element->NewGauss(5);
    4207         for(int ig=gauss->begin();ig<gauss->end();ig++){
    4208                 gauss->GaussPoint(ig);
    4209                 element->JacobianDeterminant(&Jdet,xyz_list,gauss);
    4210                
    4211                 pressure_input->GetInputValue(&pressure, gauss);
    4212                 element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss);
    4213 
    4214                 for(i=0;i<numnodes;i++){
    4215                         pe->values[i*dim+0] += pressure*gauss->weight*Jdet*dbasis[0*numnodes+i];
    4216                         pe->values[i*dim+1] += pressure*gauss->weight*Jdet*dbasis[1*numnodes+i];
    4217                         if(dim==3) pe->values[i*dim+2]+= pressure*gauss->weight*Jdet*dbasis[2*numnodes+i];
    4218                 }
    4219         }
    4220 
    4221         if(element->IsOnBase()){
    4222                 IssmDouble   sigmann;
    4223                 IssmDouble*  vbasis = xNew<IssmDouble>(numnodes);
    4224 
    4225                 element->GetVerticesCoordinatesBase(&xyz_list_base);
    4226                 element->NormalBase(&bed_normal[0],xyz_list_base);
    4227 
    4228                 delete gauss;
    4229                 gauss=element->NewGaussBase(5);
    4230                 for(int ig=gauss->begin();ig<gauss->end();ig++){
    4231                         gauss->GaussPoint(ig);
    4232 
    4233                         element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
    4234                         element->NodalFunctionsVelocity(vbasis,gauss);
    4235                         sigmann_input->GetInputValue(&sigmann, gauss);
    4236 
    4237                         for(i=0;i<numnodes;i++){
    4238                                 pe->values[i*dim+0] += + sigmann*bed_normal[0]*gauss->weight*Jdet*vbasis[i];
    4239                                 pe->values[i*dim+1] += + sigmann*bed_normal[1]*gauss->weight*Jdet*vbasis[i];
    4240                                 if(dim==3) pe->values[i*dim+2] += + sigmann*bed_normal[2]*gauss->weight*Jdet*vbasis[i];
    4241                         }
    4242                 }
    4243                 xDelete<IssmDouble>(xyz_list_base);
    4244                 xDelete<IssmDouble>(vbasis);
    4245         }
    4246 
    4247         /*Transform coordinate system*/
    4248         //element->TransformLoadVectorCoord(pe,cs_list); Do not transform augmentation
    4249 
    4250         /*Clean up and return*/
    4251         delete gauss;
    4252         xDelete<int>(cs_list);
    4253         xDelete<IssmDouble>(xyz_list);
    4254         xDelete<IssmDouble>(dbasis);
    42554027        return pe;
    42564028}/*}}}*/

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

    r18474 r18560  
    6969                ElementMatrix* CreateJacobianMatrixFS(Element* element);
    7070                ElementMatrix* CreateKMatrixFS(Element* element);
    71                 ElementMatrix* CreateKMatrixFSViscousLATH(Element* element);
    72                 ElementMatrix* CreateKMatrixFSViscousLACR(Element* element);
     71                ElementMatrix* CreateKMatrixFSViscousLA(Element* element);
    7372                ElementMatrix* CreateKMatrixFSViscousXTH(Element* element);
    7473                ElementMatrix* CreateKMatrixFSViscous(Element* element);
    … …  
    7776                ElementVector* CreatePVectorFS(Element* element);
    7877                ElementVector* CreatePVectorFSViscous(Element* element);
    79                 ElementVector* CreatePVectorFSViscousLATH(Element* element);
    80                 ElementVector* CreatePVectorFSViscousLACR(Element* element);
     78                ElementVector* CreatePVectorFSViscousLA(Element* element);
    8179                ElementVector* CreatePVectorFSViscousXTH(Element* element);
    8280                ElementVector* CreatePVectorFSShelf(Element* element);
Note: See TracChangeset for help on using the changeset viewer.