Changeset 6987


Ignore:
Timestamp:
01/07/11 10:51:49 (14 years ago)
Author:
seroussi
Message:

added coupling matrices for macayealstokes viscous

Location:
issm/trunk/src/c/objects/Elements
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r6969 r6987  
    703703
    704704        /*compute all stiffness matrices for this element*/
    705         ElementMatrix* Ke1=new ElementMatrix(this->nodes,NUMVERTICES,this->parameters,MacAyealApproximationEnum);
    706         ElementMatrix* Ke2=new ElementMatrix(this->nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    707         ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
    708         delete Ke1;
    709         delete Ke2;
    710         Ke1=CreateKMatrixDiagnosticMacAyeal3d();
    711         Ke2=CreateKMatrixDiagnosticStokes();
    712 
    713         _error_("KMatrix coupling MacAyealStokes not terminated yet");
    714 
    715         /*Constants*/
    716         const int    numdofm=NDOF2*NUMVERTICES;
    717         const int    numdofs=NDOF4*NUMVERTICES;
    718         const int    numdoftotal=(NDOF2+NDOF4)*NUMVERTICES;
    719         int          i,j;
    720 
    721         for(i=0;i<numdofs;i++) for(j=0;j<NUMVERTICES;j++){
    722                 Ke->values[(i+numdofm)*numdoftotal+NDOF2*j+0]+=Ke2->values[i*numdofs+NDOF4*j+0];
    723                 Ke->values[(i+numdofm)*numdoftotal+NDOF2*j+1]+=Ke2->values[i*numdofs+NDOF4*j+1];
    724         }
    725         for(i=0;i<numdofm;i++) for(j=0;j<NUMVERTICES;j++){
    726                 Ke->values[i*numdoftotal+numdofm+NDOF4*j+0]+=Ke1->values[i*numdofm+NDOF2*j+0];
    727                 Ke->values[i*numdoftotal+numdofm+NDOF4*j+1]+=Ke1->values[i*numdofm+NDOF2*j+1];
    728         }
     705        ElementMatrix* Ke1=CreateKMatrixCouplingMacAyealPattynViscous();
     706        ElementMatrix* Ke2=CreateKMatrixCouplingMacAyealPattynFriction();
     707        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    729708
    730709        /*clean-up and return*/
    731710        delete Ke1;
    732711        delete Ke2;
     712        return Ke;
     713}
     714/*}}}*/
     715/*FUNCTION Penta::CreateKMatrixCouplingMacAyealStokesViscous{{{1*/
     716ElementMatrix* Penta::CreateKMatrixCouplingMacAyealStokesViscous(void){
     717
     718        /*Constants*/
     719        const int    numdofm=NDOF2*NUMVERTICES2D;
     720        const int    numdofs=NDOF4*NUMVERTICES;
     721        const int    numdoftotal=numdofm+numdofs;
     722
     723        /*Intermediaries */
     724        int         i,j,ig;
     725        double      Jdet;
     726        double      viscosity; //viscosity
     727        double      epsilon[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
     728        double      xyz_list[NUMVERTICES][3];
     729        double      B[4][numdofs];
     730        double      Bprime[4][numdofm];
     731        double      B2[3][numdofm];
     732        double      Bprime2[3][numdofs];
     733        double      D[4][4]={0.0};            // material matrix, simple scalar matrix.
     734        double      D2[3][3]={0.0};            // material matrix, simple scalar matrix.
     735        double      D_scalar;
     736        double      Ke_gg[numdofs][numdofm]={0.0}; //local element stiffness matrix
     737        double      Ke_gg2[numdofm][numdofs]={0.0}; //local element stiffness matrix
     738        double      Ke_gg_gaussian[numdofs][numdofm]; //stiffness matrix evaluated at the gaussian point.
     739        double      Ke_gg_gaussian2[numdofm][numdofs]; //stiffness matrix evaluated at the gaussian point.
     740        GaussPenta *gauss=NULL;
     741        GaussTria  *gauss_tria=NULL;
     742
     743        /*Find penta on bed as stokes must be coupled to the dofs on the bed: */
     744        Penta* pentabase=GetBasalElement();
     745        Tria* tria=pentabase->SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
     746
     747        /*Initialize Element matrix and return if necessary*/
     748        if(IsOnWater()) return NULL;
     749        ElementMatrix* Ke1=new ElementMatrix(pentabase->nodes,NUMVERTICES,this->parameters,MacAyealApproximationEnum);
     750        ElementMatrix* Ke2=new ElementMatrix(this->nodes     ,NUMVERTICES,this->parameters,StokesApproximationEnum);
     751        ElementMatrix* Ke=new ElementMatrix(Ke1,Ke2);
     752        delete Ke1; delete Ke2;
     753
     754        /* Get node coordinates and dof list: */
     755        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
     756        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
     757        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
     758        Input* vz_input=inputs->GetInput(VzEnum);       _assert_(vz_input);
     759
     760        /* Start  looping on the number of gaussian points: */
     761        gauss=new GaussPenta(5,5);
     762        gauss_tria=new GaussTria();
     763        for (ig=gauss->begin();ig<gauss->end();ig++){
     764
     765                gauss->GaussPoint(ig);
     766                gauss->SynchronizeGaussTria(gauss_tria);
     767
     768                GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
     769                GetBMacAyealStokes(&B[0][0], &xyz_list[0][0], gauss);
     770                tria->GetBprimeMacAyealStokes(&Bprime[0][0], &xyz_list[0][0], gauss_tria);
     771                tria->GetBMacAyealStokes(&B2[0][0], &xyz_list[0][0], gauss_tria);
     772                GetBprimeMacAyealStokes(&Bprime2[0][0], &xyz_list[0][0], gauss);
     773
     774                this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
     775                matice->GetViscosity3dStokes(&viscosity, &epsilon[0]);
     776
     777                D_scalar=2*viscosity*gauss->weight*Jdet;
     778                for (i=0;i<3;i++) D[i][i]=D_scalar;
     779                D[4][4]=(-1)*gauss->weight*Jdet;
     780                for (i=0;i<3;i++) D2[i][i]=D_scalar;
     781
     782                TripleMultiply( &B[0][0],4,numdofs,1,
     783                                        &D[0][0],4,4,0,
     784                                        &Bprime[0][0],4,numdofm,0,
     785                                        &Ke_gg_gaussian[0][0],0);
     786
     787                TripleMultiply( &B2[0][0],3,numdofm,1,
     788                                        &D2[0][0],3,3,0,
     789                                        &Bprime2[0][0],3,numdofs,0,
     790                                        &Ke_gg_gaussian2[0][0],0);
     791
     792                for( i=0; i<numdofs; i++) for(j=0;j<numdofm; j++) Ke_gg[i][j]+=Ke_gg_gaussian[i][j];
     793                for( i=0; i<numdofm; i++) for(j=0;j<numdofs; j++) Ke_gg2[i][j]+=Ke_gg_gaussian2[i][j];
     794        }
     795        for(i=0;i<numdofs;i++) for(j=0;j<numdofm;j++) Ke->values[(i+2*numdofm)*numdoftotal+j]+=Ke_gg[i][j];
     796        for(i=0;i<numdofm;i++) for(j=0;j<numdofs;j++) Ke->values[i*numdoftotal+(j+2*numdofm)]+=Ke_gg2[j][i];
     797        _error_("coupling not finished yet");
     798
     799        /*Clean-up and return*/
     800        delete tria->matice; delete tria;
     801        delete gauss;
     802        delete gauss_tria;
     803        return Ke;
     804}
     805/*}}}*/
     806/*FUNCTION Penta::CreateKMatrixCouplingMacAyealStokesFriction{{{1*/
     807ElementMatrix* Penta::CreateKMatrixCouplingMacAyealStokesFriction(void){
     808
     809        /*Initialize Element matrix and return if necessary*/
     810        if(IsOnWater() || IsOnShelf() || !IsOnBed()) return NULL;
     811
     812        Tria* tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
     813        ElementMatrix* Ke=tria->CreateKMatrixCouplingMacAyealPattynFriction();
     814        delete tria->matice; delete tria;
     815
    733816        return Ke;
    734817}
    … …  
    903986
    904987        /*Intermediaries */
    905         int         i,j,ig;
     988        int         i,j,ig,approximation;
    906989        double      Jdet;
    907990        double      viscosity, oldviscosity, newviscosity, viscosity_overshoot;
    … …  
    9251008        if(IsOnWater()) return NULL;
    9261009        ElementMatrix* Ke=new ElementMatrix(tria->nodes,NUMVERTICES2D,this->parameters,MacAyealApproximationEnum);
     1010        inputs->GetParameterValue(&approximation,ApproximationEnum);
    9271011
    9281012        /*Retrieve all inputs and parameters*/
    … …  
    9331017        Input* vxold_input=inputs->GetInput(VxOldEnum); _assert_(vxold_input);
    9341018        Input* vyold_input=inputs->GetInput(VyOldEnum); _assert_(vyold_input);
     1019        Input* vz_input=inputs->GetInput(VzEnum);       _assert_(vz_input);
    9351020
    9361021        /* Start  looping on the number of gaussian points: */
    … …  
    9461031                tria->GetBprimeMacAyeal(&Bprime[0][0], &xyz_list[0][0], gauss_tria);
    9471032
    948                 this->GetStrainRate3dPattyn(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
    949                 this->GetStrainRate3dPattyn(&oldepsilon[0],&xyz_list[0][0],gauss,vxold_input,vyold_input);
    950                 matice->GetViscosity3d(&viscosity, &epsilon[0]);
    951                 matice->GetViscosity3d(&oldviscosity, &oldepsilon[0]);
    952 
    953                 newviscosity=viscosity+viscosity_overshoot*(viscosity-oldviscosity);
     1033                if(approximation==MacAyealPattynApproximationEnum){
     1034                        this->GetStrainRate3dPattyn(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
     1035                        this->GetStrainRate3dPattyn(&oldepsilon[0],&xyz_list[0][0],gauss,vxold_input,vyold_input);
     1036                        matice->GetViscosity3d(&viscosity, &epsilon[0]);
     1037                        matice->GetViscosity3d(&oldviscosity, &oldepsilon[0]);
     1038
     1039                        newviscosity=viscosity+viscosity_overshoot*(viscosity-oldviscosity);
     1040                }
     1041                else if (approximation==MacAyealStokesApproximationEnum){
     1042                        this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
     1043                        matice->GetViscosity3dStokes(&newviscosity,&epsilon[0]);
     1044                }
     1045                else _error_("approximation %i (%s) not supported yet",approximation,EnumToString(approximation));
     1046
    9541047                D_scalar=2*newviscosity*gauss->weight*Jdet;
    9551048                for (i=0;i<3;i++) D[i][i]=D_scalar;

  • issm/trunk/src/c/objects/Elements/Penta.h

    r6953 r6987  
    131131                ElementMatrix* CreateKMatrixCouplingMacAyealPattynFriction(void);
    132132                ElementMatrix* CreateKMatrixCouplingMacAyealStokes(void);
     133                ElementMatrix* CreateKMatrixCouplingMacAyealStokesViscous(void);
     134                ElementMatrix* CreateKMatrixCouplingMacAyealStokesFriction(void);
    133135                ElementMatrix* CreateKMatrixCouplingPattynStokes(void);
    134136                ElementMatrix* CreateKMatrixDiagnosticHoriz(void);

  • issm/trunk/src/c/objects/Elements/PentaRef.cpp

    r6413 r6987  
    8686                *(B+NDOF2*NUMNODESP1*2+NDOF2*i+1)=(float).5*dh1dh6[0][i];
    8787
     88        }
     89
     90}
     91/*}}}*/
     92/*FUNCTION PentaRef::GetBMacAyealStokes{{{1*/
     93void PentaRef::GetBMacAyealStokes(double* B, double* xyz_list, GaussPenta* gauss){
     94        /*Compute B  matrix. B=[B1 B2 B3 B4 B5 B6] where Bi is of size 5*NDOF2.
     95         * For grid i, Bi can be expressed in the actual coordinate system
     96         * by:
     97         *       Bi=[ dh/dx          0       0   0 ]
     98         *          [   0           dh/dy    0   0 ]
     99         *          [ 1/2*dh/dy  1/2*dh/dx   0   0 ]
     100         *          [   0            0       0   h ]
     101         * where h is the interpolation function for grid i.
     102         *
     103         * We assume B has been allocated already, of size: 5x(NDOF2*NUMNODESP1)
     104         */
     105
     106        int    i;
     107        double dh1dh7[3][NUMNODESMINI];
     108        double l1l6[NUMNODESP1];
     109
     110        /*Get dh1dh6 in actual coordinate system: */
     111        GetNodalFunctionsMINIDerivatives(&dh1dh7[0][0],xyz_list, gauss);
     112        GetNodalFunctionsP1(l1l6, gauss);
     113
     114        /*Build B: */
     115        for (i=0;i<NUMNODESMINI;i++){
     116                *(B+(NDOF4*NUMNODESP1+3)*0+NDOF4*i)=dh1dh7[0][i]; //B[0][NDOF4*i]=dh1dh6[0][i];
     117                *(B+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+1)=0;
     118                *(B+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+2)=0;
     119                *(B+(NDOF4*NUMNODESP1+3)*1+NDOF4*i)=0;
     120                *(B+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+1)=dh1dh7[1][i];
     121                *(B+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+2)=0;
     122                *(B+(NDOF4*NUMNODESP1+3)*2+NDOF4*i)=0.5*dh1dh7[1][i];
     123                *(B+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+1)=0.5*dh1dh7[0][i];
     124                *(B+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+2)=0;
     125                *(B+(NDOF4*NUMNODESP1+3)*3+NDOF4*i)=0;
     126                *(B+(NDOF4*NUMNODESP1+3)*3+NDOF4*i+1)=0;
     127                *(B+(NDOF4*NUMNODESP1+3)*3+NDOF4*i+2)=0;
     128        }
     129
     130        for (i=0;i<NUMNODESP1;i++){ //last column not for the bubble function
     131                *(B+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+3)=0;
     132                *(B+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+3)=0;
     133                *(B+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+3)=0;
     134                *(B+(NDOF4*NUMNODESP1+3)*3+NDOF4*i+3)=l1l6[i];
    88135        }
    89136
    … …  
    166213                *(B+NDOF2*NUMNODESP1*4+NDOF2*i+1)=dh1dh6[2][i];
    167214        }
     215}
     216/*}}}*/
     217/*FUNCTION PentaRef::GetBprimeMacAyealStokes{{{1*/
     218void PentaRef::GetBprimeMacAyealStokes(double* Bprime, double* xyz_list, GaussPenta* gauss){
     219        /*Compute Bprime  matrix. Bprime=[Bprime1 Bprime2 Bprime3 Bprime4 Bprime5 Bprime6] where Bprimei is of size 5*NDOF2.
     220         * For grid i, Bprimei can be expressed in the actual coordinate system
     221         * by:
     222         *       Bprimei=[ 2*dh/dx    dh/dy   0   0 ]
     223         *               [  dh/dx    2*dh/dy  0   0 ]
     224         *               [  dh/dy     dh/dx   0   0 ]
     225         * where h is the interpolation function for grid i.
     226         *
     227         * We assume Bprime has been allocated already, of size: 5x(NDOF2*NUMNODESP1)
     228         */
     229
     230        int    i;
     231        double dh1dh7[3][NUMNODESMINI];
     232
     233        /*Get dh1dh6 in actual coordinate system: */
     234        GetNodalFunctionsMINIDerivatives(&dh1dh7[0][0],xyz_list, gauss);
     235
     236        /*Build Bprime: */
     237        for (i=0;i<NUMNODESMINI;i++){
     238                *(Bprime+(NDOF4*NUMNODESP1+3)*0+NDOF4*i)=2*dh1dh7[0][i]; //Bprime[0][NDOF4*i]=dh1dh6[0][i];
     239                *(Bprime+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+1)=dh1dh7[1][i];
     240                *(Bprime+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+2)=0;
     241                *(Bprime+(NDOF4*NUMNODESP1+3)*1+NDOF4*i)=dh1dh7[0][i];
     242                *(Bprime+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+1)=2*dh1dh7[1][i];
     243                *(Bprime+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+2)=0;
     244                *(Bprime+(NDOF4*NUMNODESP1+3)*2+NDOF4*i)=dh1dh7[1][i];
     245                *(Bprime+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+1)=dh1dh7[0][i];
     246                *(Bprime+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+2)=0;
     247                *(Bprime+(NDOF4*NUMNODESP1+3)*3+NDOF4*i)=0;
     248                *(Bprime+(NDOF4*NUMNODESP1+3)*3+NDOF4*i+1)=0;
     249                *(Bprime+(NDOF4*NUMNODESP1+3)*3+NDOF4*i+2)=0;
     250        }
     251
     252        for (i=0;i<NUMNODESP1;i++){ //last column not for the bubble function
     253                *(Bprime+(NDOF4*NUMNODESP1+3)*0+NDOF4*i+3)=0;
     254                *(Bprime+(NDOF4*NUMNODESP1+3)*1+NDOF4*i+3)=0;
     255                *(Bprime+(NDOF4*NUMNODESP1+3)*2+NDOF4*i+3)=0;
     256        }
     257
    168258}
    169259/*}}}*/
    … …  
    189279        double dh1dh7[3][NUMNODESMINI];
    190280        double l1l6[NUMNODESP1];
    191 
    192281
    193282        /*Get dh1dh7 in actual coordinate system: */

  • issm/trunk/src/c/objects/Elements/PentaRef.h

    r6412 r6987  
    3737                void GetJacobianInvert(double*  Jinv, double* xyz_list,GaussPenta* gauss);
    3838                void GetBMacAyealPattyn(double* B, double* xyz_list, GaussPenta* gauss);
     39                void GetBMacAyealStokes(double* B, double* xyz_list, GaussPenta* gauss);
    3940                void GetBPattyn(double* B, double* xyz_list, GaussPenta* gauss);
     41                void GetBStokes(double* B, double* xyz_list, GaussPenta* gauss);
     42                void GetBprimeMacAyealStokes(double* Bprime, double* xyz_list, GaussPenta* gauss);
    4043                void GetBprimePattyn(double* B, double* xyz_list, GaussPenta* gauss);
    41                 void GetBStokes(double* B, double* xyz_list, GaussPenta* gauss);
    4244                void GetBprimeStokes(double* B_prime, double* xyz_list, GaussPenta* gauss);
    4345                void GetBprimeVert(double* B, double* xyz_list, GaussPenta* gauss);

  • issm/trunk/src/c/objects/Elements/TriaRef.cpp

    r6413 r6987  
    8686}
    8787/*}}}*/
     88/*FUNCTION TriaRef::GetBMacAyealStokes {{{1*/
     89void TriaRef::GetBMacAyealStokes(double* B, double* xyz_list, GaussTria* gauss){
     90
     91        /*Compute B  matrix. B=[B1 B2 B3] where Bi is of size 3*NDOF2.
     92         * For grid i, Bi can be expressed in the actual coordinate system
     93         * by:
     94         *       Bi=[   dh/dx         0     ]
     95         *          [       0       dh/dy   ]
     96         *          [  1/2*dh/dy  1/2*dh/dx ]
     97         * where h is the interpolation function for grid i.
     98         *
     99         * We assume B has been allocated already, of size: 3x(NDOF2*NUMNODES)
     100         */
     101
     102        /*Same thing in the actual coordinate system: */
     103        double dh1dh3[NDOF2][NUMNODES];
     104
     105        /*Get dh1dh2dh3 in actual coordinates system : */
     106        GetNodalFunctionsDerivatives(&dh1dh3[0][0],xyz_list,gauss);
     107
     108        /*Build B': */
     109        for (int i=0;i<NUMNODES;i++){
     110                *(B+NDOF2*NUMNODES*0+NDOF2*i)=dh1dh3[0][i];
     111                *(B+NDOF2*NUMNODES*0+NDOF2*i+1)=0;
     112                *(B+NDOF2*NUMNODES*1+NDOF2*i)=0;
     113                *(B+NDOF2*NUMNODES*1+NDOF2*i+1)=dh1dh3[1][i];
     114                *(B+NDOF2*NUMNODES*2+NDOF2*i)=0.5*dh1dh3[1][i];
     115                *(B+NDOF2*NUMNODES*2+NDOF2*i+1)=0.5*dh1dh3[0][i];
     116        }
     117}
     118/*}}}*/
    88119/*FUNCTION TriaRef::GetSegmentBFlux{{{1*/
    89120void TriaRef::GetSegmentBFlux(double* B,GaussTria* gauss, int index1,int index2){
    … …  
    176207                *(Bprime+NDOF2*NUMNODES*2+NDOF2*i)=dh1dh3[1][i];
    177208                *(Bprime+NDOF2*NUMNODES*2+NDOF2*i+1)=dh1dh3[0][i];
     209        }
     210}
     211/*}}}*/
     212/*FUNCTION TriaRef::GetBprimeMacAyealStokes {{{1*/
     213void TriaRef::GetBprimeMacAyealStokes(double* Bprime, double* xyz_list, GaussTria* gauss){
     214
     215        /*Compute Bprime  matrix. Bprime=[Bprime1 Bprime2 Bprime3] where Bprimei is of size 3*NDOF2.
     216         * For grid i, Bprimei can be expressed in the actual coordinate system
     217         * by:
     218         *       Bprimei=[  dh/dx    0   ]
     219         *               [    0    dh/dy ]
     220         *               [  dh/dy  dh/dx ]
     221         *               [  dh/dx  dh/dy ]
     222         * where h is the interpolation function for grid i.
     223         *
     224         * We assume Bprime has been allocated already, of size: 3x(NDOF2*NUMNODES)
     225         */
     226
     227        /*Same thing in the actual coordinate system: */
     228        double dh1dh3[NDOF2][NUMNODES];
     229
     230        /*Get dh1dh2dh3 in actual coordinates system : */
     231        GetNodalFunctionsDerivatives(&dh1dh3[0][0],xyz_list,gauss);
     232
     233        /*Build Bprime: */
     234        for (int i=0;i<NUMNODES;i++){
     235                *(Bprime+NDOF2*NUMNODES*0+NDOF2*i)=dh1dh3[0][i];
     236                *(Bprime+NDOF2*NUMNODES*0+NDOF2*i+1)=0;
     237                *(Bprime+NDOF2*NUMNODES*1+NDOF2*i)=0;
     238                *(Bprime+NDOF2*NUMNODES*1+NDOF2*i+1)=dh1dh3[1][i];
     239                *(Bprime+NDOF2*NUMNODES*2+NDOF2*i)=dh1dh3[1][i];
     240                *(Bprime+NDOF2*NUMNODES*2+NDOF2*i+1)=dh1dh3[0][i];
     241                *(Bprime+NDOF2*NUMNODES*3+NDOF2*i)=dh1dh3[0][i];
     242                *(Bprime+NDOF2*NUMNODES*3+NDOF2*i+1)=dh1dh3[1][i];
    178243        }
    179244}

  • issm/trunk/src/c/objects/Elements/TriaRef.h

    r5808 r6987  
    2626                /*Numerics*/
    2727                void GetBMacAyeal(double* B, double* xyz_list, GaussTria* gauss);
     28                void GetBMacAyealStokes(double* B , double* xyz_list, GaussTria* gauss);
    2829                void GetBprimeMacAyeal(double* Bprime, double* xyz_list, GaussTria* gauss);
     30                void GetBprimeMacAyealStokes(double* Bprime, double* xyz_list, GaussTria* gauss);
    2931                void GetBprimePrognostic(double* Bprime_prog, double* xyz_list, GaussTria* gauss);
    3032                void GetBPrognostic(double* B_prog, double* xyz_list, GaussTria* gauss);
Note: See TracChangeset for help on using the changeset viewer.