Changeset 17094


Ignore:
Timestamp:
01/10/14 13:35:08 (11 years ago)
Author:
Mathieu Morlighem
Message:

DEL: cleaning up Strain rate computation

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

Legend:

Unmodified
Added
Removed

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

    r17093 r17094  
    328328         * A X^3 + A |rho g (s-z) grad(s)|^2 X - |eps_b|_// = 0     */
    329329
    330         int        i;
    331330        IssmDouble z,s,viscosity,p,q,delta;
    332331        IssmDouble tau_perp,tau_par,eps_b,A;
    333         IssmDouble epsilonvx[5]; /*exx eyy exy exz eyz*/
    334         IssmDouble epsilonvy[5]; /*exx eyy exy exz eyz*/
    335332        IssmDouble epsilon[5];   /*exx eyy exy exz eyz*/
    336333        IssmDouble slope[3];
    … …  
    346343
    347344        /* Get eps_b*/
    348         vx_input->GetVxStrainRate3dHO(epsilonvx,xyz_list,gauss);
    349         vy_input->GetVyStrainRate3dHO(epsilonvy,xyz_list,gauss);
    350         for(i=0;i<5;i++) epsilon[i]=epsilonvx[i]+epsilonvy[i];
     345        this->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
    351346        eps_b = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[0]*epsilon[1] + epsilon[2]*epsilon[2]);
    352347        if(eps_b==0.){

  • issm/trunk-jpl/src/c/classes/Inputs/BoolInput.h

    r16818 r17094  
    5050                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5151                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    52                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    53                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    54                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    55                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    56                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    57                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    58                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    5952                void ChangeEnum(int newenumtype);
    6053                void SquareMin(IssmDouble* psquaremin, Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/ControlInput.h

    r16818 r17094  
    5959                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    6060                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    61                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    63                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    64                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    65                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    66                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    67                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6861                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
    6962                void SquareMin(IssmDouble* psquaremin,Parameters* parameters){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.h

    r16818 r17094  
    5555                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5656                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    57                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    58                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    59                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    60                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    61                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    63                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6457                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
    6558                void SquareMin(IssmDouble* psquaremin,Parameters* parameters){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.cpp

    r16818 r17094  
    123123void DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){*pvalue=this->value;}
    124124/*}}}*/
    125 /*FUNCTION DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){{{*/
    126 void DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    127         /*Epsilon is zero as vx is constant over the element*/
    128         for(int i=0;i<3;i++) epsilonvx[i]=0;
    129 }
    130 /*}}}*/
    131 /*FUNCTION DoubleInput::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){{{*/
    132 void DoubleInput::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){
    133         /*Epsilon is zero as vy is constant over the element*/
    134         for(int i=0;i<3;i++) epsilonvy[i]=0;
    135 }
    136 /*}}}*/
    137 /*FUNCTION DoubleInput::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){{{*/
    138 void DoubleInput::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    139         /*Epsilon is zero as vx is constant over the element*/
    140         for(int i=0;i<6;i++) epsilonvx[i]=0;
    141 }
    142 /*}}}*/
    143 /*FUNCTION DoubleInput::GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){{{*/
    144 void DoubleInput::GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){
    145         /*Epsilon is zero as vy is constant over the element*/
    146         for(int i=0;i<6;i++) epsilonvy[i]=0;
    147 }
    148 /*}}}*/
    149 /*FUNCTION DoubleInput::GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){{{*/
    150 void DoubleInput::GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){
    151         /*Epsilon is zero as vz is constant over the element*/
    152         for(int i=0;i<6;i++) epsilonvz[i]=0;
    153 }
    154 /*}}}*/
    155 /*FUNCTION DoubleInput::GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){{{*/
    156 void DoubleInput::GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    157         /*Epsilon is zero as vx is constant over the element*/
    158         for(int i=0;i<5;i++) epsilonvx[i]=0;
    159 }
    160 /*}}}*/
    161 /*FUNCTION DoubleInput::GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){{{*/
    162 void DoubleInput::GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){
    163         /*Epsilon is zero as vy is constant over the element*/
    164         for(int i=0;i<5;i++) epsilonvy[i]=0;
    165 }
    166 /*}}}*/
    167125/*FUNCTION DoubleInput::ChangeEnum{{{*/
    168126void DoubleInput::ChangeEnum(int newenumtype){

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.h

    r16818 r17094  
    5353                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5454                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    55                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    56                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    57                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    58                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    59                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss);
    60                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    61                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    6255                void ChangeEnum(int newenumtype);
    6356                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/Input.h

    r16818 r17094  
    3636                virtual void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes)=0;
    3737                virtual void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime)=0;
    38                 virtual void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss)=0;
    39                 virtual void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss)=0;
    40                 virtual void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss)=0;
    41                 virtual void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss)=0;
    42                 virtual void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss)=0;
    43                 virtual void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss)=0;
    44                 virtual void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss)=0;
    4538                virtual void ChangeEnum(int newenumtype)=0;
    4639                virtual void Configure(Parameters* parameters)=0;

  • issm/trunk-jpl/src/c/classes/Inputs/IntInput.h

    r16818 r17094  
    5454                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5555                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    56 
    57                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    58                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    59                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    60                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    61                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    63                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6456                void ChangeEnum(int newenumtype);
    6557                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

    r16818 r17094  
    154154}
    155155/*}}}*/
    156 /*FUNCTION PentaInput::GetVxStrainRate3d{{{*/
    157 void PentaInput::GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    158 
    159         /*Intermediary*/
    160         int         numnodes=this->NumberofNodes();
    161         IssmDouble* B=xNew<IssmDouble>(numnodes*(NDOF3*numnodes));
    162         IssmDouble* velocity=xNew<IssmDouble>(numnodes*NDOF3);
    163 
    164         /*Get B matrix: */
    165         GetBFSstrainrate(B,xyz_list,gauss);
    166 
    167         /*Here, we are computing the strain rate of (vx,0,0)*/
    168         for(int i=0;i<numnodes;i++){
    169                 velocity[NDOF3*i+0]=this->values[i];
    170                 velocity[NDOF3*i+1]=0.;
    171                 velocity[NDOF3*i+2]=0.;
    172         }
    173         /*Multiply B by velocity, to get strain rate: */
    174         MatrixMultiply(B,numnodes,NDOF3*numnodes,0,velocity,NDOF3*numnodes,1,0,epsilonvx,0);
    175 
    176         /*Clean-up*/
    177         xDelete<IssmDouble>(B);
    178         xDelete<IssmDouble>(velocity);
    179 
    180 }
    181 /*}}}*/
    182 /*FUNCTION PentaInput::GetVyStrainRate3d{{{*/
    183 void PentaInput::GetVyStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    184 
    185         /*Intermediary*/
    186         int         numnodes=this->NumberofNodes();
    187         IssmDouble* B=xNew<IssmDouble>(numnodes*(NDOF3*numnodes));
    188         IssmDouble* velocity=xNew<IssmDouble>(numnodes*NDOF3);
    189 
    190         /*Get B matrix: */
    191         GetBFSstrainrate(B,xyz_list,gauss);
    192 
    193         /*Here, we are computing the strain rate of (0,vy,0)*/
    194         for(int i=0;i<numnodes;i++){
    195                 velocity[NDOF3*i+0]=0.;
    196                 velocity[NDOF3*i+1]=this->values[i];
    197                 velocity[NDOF3*i+2]=0.;
    198         }
    199         /*Multiply B by velocity, to get strain rate: */
    200         MatrixMultiply(B,numnodes,NDOF3*numnodes,0,velocity,NDOF3*numnodes,1,0,epsilonvx,0);
    201 
    202         /*Clean-up*/
    203         xDelete<IssmDouble>(B);
    204         xDelete<IssmDouble>(velocity);
    205 }
    206 /*}}}*/
    207 /*FUNCTION PentaInput::GetVzStrainRate3d{{{*/
    208 void PentaInput::GetVzStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    209 
    210         /*Intermediary*/
    211         int         numnodes=this->NumberofNodes();
    212         IssmDouble* B=xNew<IssmDouble>(numnodes*(NDOF3*numnodes));
    213         IssmDouble* velocity=xNew<IssmDouble>(numnodes*NDOF3);
    214 
    215         /*Get B matrix: */
    216         GetBFSstrainrate(B,xyz_list,gauss);
    217 
    218         /*Here, we are computing the strain rate of (0,0,vz)*/
    219         for(int i=0;i<numnodes;i++){
    220                 velocity[NDOF3*i+0]=0.;
    221                 velocity[NDOF3*i+1]=0.;
    222                 velocity[NDOF3*i+2]=this->values[i];
    223         }
    224         /*Multiply B by velocity, to get strain rate: */
    225         MatrixMultiply(B,numnodes,NDOF3*numnodes,0,velocity,NDOF3*numnodes,1,0,epsilonvx,0);
    226 
    227         /*Clean-up*/
    228         xDelete<IssmDouble>(B);
    229         xDelete<IssmDouble>(velocity);
    230 }
    231 /*}}}*/
    232 /*FUNCTION PentaInput::GetVxStrainRate3dHO{{{*/
    233 void PentaInput::GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    234 
    235         int i;
    236         const int numnodes=6;
    237         IssmDouble B[5][NDOF2*numnodes];
    238         IssmDouble velocity[numnodes][NDOF2];
    239 
    240         /*Get B matrix: */
    241         GetBHO(&B[0][0], xyz_list, gauss);
    242 
    243         _assert_(this->NumberofNodes()==6); //Check Tria too
    244 
    245         /*Here, we are computing the strain rate of (vx,0)*/
    246         for(i=0;i<numnodes;i++){
    247                 velocity[i][0]=this->values[i];
    248                 velocity[i][1]=0.0;
    249         }
    250 
    251         /*Multiply B by velocity, to get strain rate: */
    252         MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0,
    253                                 &velocity[0][0],NDOF2*numnodes,1,0,
    254                                 epsilonvx,0);
    255 
    256 }
    257 /*}}}*/
    258 /*FUNCTION PentaInput::GetVyStrainRate3dHO{{{*/
    259 void PentaInput::GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){
    260 
    261         int i;
    262         const int numnodes=6;
    263         IssmDouble B[5][NDOF2*numnodes];
    264         IssmDouble velocity[numnodes][NDOF2];
    265 
    266         /*Get B matrix: */
    267         GetBHO(&B[0][0], xyz_list, gauss);
    268         _assert_(this->NumberofNodes()==6); //Check Tria too
    269 
    270         /*Here, we are computing the strain rate of (0,vy)*/
    271         for(i=0;i<numnodes;i++){
    272                 velocity[i][0]=0.0;
    273                 velocity[i][1]=this->values[i];
    274         }
    275 
    276         /*Multiply B by velocity, to get strain rate: */
    277         MatrixMultiply( &B[0][0],5,NDOF2*numnodes,0,
    278                                 &velocity[0][0],NDOF2*numnodes,1,0,
    279                                 epsilonvy,0);
    280 
    281 }
    282 /*}}}*/
    283156/*FUNCTION PentaInput::ChangeEnum{{{*/
    284157void PentaInput::ChangeEnum(int newenumtype){

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.h

    r16818 r17094  
    5353                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5454                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    55 
    56                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    57                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    58                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    59                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    60                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss);
    61                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    62                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    6355                void ChangeEnum(int newenumtype);
    64 
    6556                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    6657                void ConstrainMin(IssmDouble minimum);

  • issm/trunk-jpl/src/c/classes/Inputs/SegInput.h

    r16818 r17094  
    5454                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};
    5555                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){_error_("not implemented yet");};
    56                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    57                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    58                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    59                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    60                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    61                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6356                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
    64 
    6557                void SquareMin(IssmDouble* psquaremin,Parameters* parameters){_error_("not implemented yet");};
    6658                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.h

    r16818 r17094  
    5959                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes);
    6060                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime);
    61                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    63                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    64                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    65                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    66                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    67                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6861                void ChangeEnum(int newenumtype);
    69 
    7062                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    7163                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

    r16818 r17094  
    141141}
    142142/*}}}*/
    143 /*FUNCTION TriaInput::GetVxStrainRate2d{{{*/
    144 void TriaInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){
    145 
    146         /*Intermediary*/
    147         int numnodes=this->NumberofNodes();
    148         IssmDouble* B=xNew<IssmDouble>(numnodes*(NDOF2*numnodes));
    149         IssmDouble* velocity=xNew<IssmDouble>(numnodes*NDOF2);
    150 
    151         /*Get B matrix: */
    152         GetBSSA(&B[0],xyz_list,gauss);
    153 
    154         /*Here, we are computing the strain rate of (vx,0)*/
    155         for(int i=0;i<numnodes;i++){
    156                 velocity[2*i+0]=this->values[i];
    157                 velocity[2*i+1]=0.;
    158         }
    159         /*Get epsilon(vx) = B*velocity*/
    160         MatrixMultiply(&B[0],numnodes,NDOF2*numnodes,0,
    161                                 &velocity[0],NDOF2*numnodes,1,0,
    162                                 epsilonvx,0);
    163 
    164         /*clean up*/
    165         xDelete<IssmDouble>(B);
    166         xDelete<IssmDouble>(velocity);
    167 }
    168 /*}}}*/
    169 /*FUNCTION TriaInput::GetVyStrainRate2d{{{*/
    170 void TriaInput::GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){
    171 
    172         /*Intermediary*/
    173         int numnodes=this->NumberofNodes();
    174         IssmDouble* B=xNew<IssmDouble>(numnodes*(NDOF2*numnodes));
    175         IssmDouble* velocity=xNew<IssmDouble>(numnodes*NDOF2);
    176 
    177         /*Get B matrix: */
    178         GetBSSA(&B[0],xyz_list,gauss);
    179 
    180         /*Here, we are computing the strain rate of (0,vy)*/
    181         for(int i=0;i<numnodes;i++){
    182                 velocity[2*i+0]=0.;
    183                 velocity[2*i+1]=this->values[i];
    184         }
    185         /*Get epsilon(vy) = B*velocity*/
    186         MatrixMultiply(&B[0],numnodes,NDOF2*numnodes,0,
    187                                 &velocity[0],NDOF2*numnodes,1,0,
    188                                 epsilonvy,0);
    189 
    190         /*clean up*/
    191         xDelete<IssmDouble>(B);
    192         xDelete<IssmDouble>(velocity);
    193 }
    194 /*}}}*/
    195143/*FUNCTION TriaInput::ChangeEnum{{{*/
    196144void TriaInput::ChangeEnum(int newenumtype){

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.h

    r16818 r17094  
    5454                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes);
    5555                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime);
    56                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss);
    57                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss);
    58                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    59                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    60                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    61                 void GetVxStrainRate3dHO(IssmDouble* epsilonvx,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    62                 void GetVyStrainRate3dHO(IssmDouble* epsilonvy,IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    6356                void ChangeEnum(int newenumtype);
    64 
    6557                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    6658                void ConstrainMin(IssmDouble minimum);
Note: See TracChangeset for help on using the changeset viewer.