Changeset 22105

Timestamp:

09/18/17 15:06:27 (8 years ago)

Author:

Mathieu Morlighem

Message:

CHG: passing gauss as argument so that B is not necessarily averaged

Location:

issm/trunk-jpl/src/c

Files:

• analyses/AdjointHorizAnalysis.cpp (modified) (3 diffs)
• analyses/StressbalanceAnalysis.cpp (modified) (3 diffs)
• classes/Elements/Element.cpp (modified) (5 diffs)
• classes/Elements/Penta.cpp (modified) (1 diff)
• classes/Elements/Tria.cpp (modified) (1 diff)
• classes/Materials/Material.h (modified) (2 diffs)
• classes/Materials/Matestar.cpp (modified) (20 diffs)
• classes/Materials/Matestar.h (modified) (2 diffs)
• classes/Materials/Matice.cpp (modified) (31 diffs)
• classes/Materials/Matice.h (modified) (2 diffs)
• classes/Materials/Matlitho.h (modified) (2 diffs)
• classes/Materials/Matpar.h (modified) (2 diffs)

issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp

@@ -105 +105 @@
 
                 element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
-                element->material->ViscosityFSDerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                element->material->ViscosityFSDerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
                 eps1[0]=epsilon[0];   eps2[0]=epsilon[2];   eps3[0]=epsilon[3];
                 eps1[1]=epsilon[2];   eps2[1]=epsilon[1];   eps3[1]=epsilon[4];
@@ -179 +179 @@
 
                 element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
-                element->material->ViscosityHODerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                element->material->ViscosityHODerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
                 eps1[0]=2.*epsilon[0]+epsilon[1];   eps2[0]=epsilon[2];
                 eps1[1]=epsilon[2];                 eps2[1]=epsilon[0]+2.*epsilon[1];
@@ -286 +286 @@
                 thickness_input->GetInputValue(&thickness, gauss);
                 basalelement->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
-                basalelement->material->ViscositySSADerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                basalelement->material->ViscositySSADerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
                 eps1[0]=2.*epsilon[0]+epsilon[1]; eps2[0]=epsilon[2];
                 eps1[1]=epsilon[2];               eps2[1]=epsilon[0]+2*epsilon[1];

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

@@ -1207 +1207 @@
                 thickness_input->GetInputValue(&thickness, gauss);
                 basalelement->StrainRateSSA(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
-                basalelement->material->ViscositySSADerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                basalelement->material->ViscositySSADerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
                 eps1[0]=2*epsilon[0]+epsilon[1];   eps2[0]=epsilon[2];
                 eps1[1]=epsilon[2];                eps2[1]=epsilon[0]+2*epsilon[1];
@@ -2268 +2268 @@
 
                 element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
-                element->material->ViscosityHODerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                element->material->ViscosityHODerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
                 eps1[0]=2*epsilon[0]+epsilon[1];   eps2[0]=epsilon[2];
                 eps1[1]=epsilon[2];                eps2[1]=epsilon[0]+2*epsilon[1];
@@ -2958 +2958 @@
                 eps1[1]=epsilon[2];   eps2[1]=epsilon[1];   eps3[1]=epsilon[4];
                 eps1[2]=epsilon[3];   eps2[2]=epsilon[4];   eps3[2]= -epsilon[0] -epsilon[1];
-                element->material->ViscosityFSDerivativeEpsSquare(&mu_prime,&epsilon[0]);
+                element->material->ViscosityFSDerivativeEpsSquare(&mu_prime,&epsilon[0],gauss);
 
                 for(i=0;i<vnumnodes;i++){

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

@@ -693 +693 @@
         switch(materialstype){
                 case MaticeEnum:
-                        material->GetViscosity_B(&dmudB,eps_eff);
+                        material->GetViscosity_B(&dmudB,eps_eff,gauss);
                         break;
                 case MatestarEnum:
@@ -730 +730 @@
         switch(materialstype){
                 case MaticeEnum:
-                        material->GetViscosity_B(&dmudB,eps_eff);
+                        material->GetViscosity_B(&dmudB,eps_eff,gauss);
                         break;
                 case MatestarEnum:
@@ -767 +767 @@
         switch(materialstype){
                 case MaticeEnum:
-                        material->GetViscosity_B(&dmudB,eps_eff);
+                        material->GetViscosity_B(&dmudB,eps_eff,gauss);
                         break;
                 case MatestarEnum:
@@ -800 +800 @@
 
         /*Get viscosity*/
-        material->GetViscosity_D(&dmudB,eps_eff);
+        material->GetViscosity_D(&dmudB,eps_eff,gauss);
 
         /*Assign output pointer*/
@@ -1133 +1133 @@
 
         _assert_(this->matpar);
-        switch(enum_in){ // FIXME: change this to material
+        switch(enum_in){ // FIXME: change this to material and replace NULL by gauss
                 case MaterialsRheologyNEnum:
                         return this->material->GetN();
                 case MaterialsRheologyBEnum:
-                        return this->material->GetB();
+                        return this->material->GetB(NULL);
                 case MaterialsRheologyBbarEnum:
-                        return this->material->GetBbar();
+                        return this->material->GetBbar(NULL);
                 default:
                         return this->matpar->GetMaterialParameter(enum_in);

issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

@@ -622 +622 @@
         switch(response_enum){
                 case MaterialsRheologyBbarEnum:
-                        *presponse=this->material->GetBbar();
+                        *presponse=this->material->GetBbar(NULL);
                         break;
                 case DamageDbarEnum:
-                        *presponse=this->material->GetDbar();
+                        *presponse=this->material->GetDbar(NULL);
                         break;
                 case VelEnum:

issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

@@ -734 +734 @@
         switch(response_enum){
                 case MaterialsRheologyBbarEnum:
-                        *presponse=this->material->GetBbar();
+                        *presponse=this->material->GetBbar(NULL);
                         break;
 

issm/trunk-jpl/src/c/classes/Materials/Material.h

@@ -27 +27 @@
                 virtual void       Configure(Elements* elements)=0;
                 virtual Material*  copy2(Element* element)=0;
-                virtual IssmDouble GetA()=0;
-                virtual IssmDouble GetAbar()=0;
-                virtual IssmDouble GetB()=0;
-                virtual IssmDouble GetBbar()=0;
-                virtual IssmDouble GetD()=0;
-                virtual IssmDouble GetDbar()=0;
+                virtual IssmDouble GetA(Gauss* gauss)=0;
+                virtual IssmDouble GetAbar(Gauss* gauss)=0;
+                virtual IssmDouble GetB(Gauss* gauss)=0;
+                virtual IssmDouble GetBbar(Gauss* gauss)=0;
+                virtual IssmDouble GetD(Gauss* gauss)=0;
+                virtual IssmDouble GetDbar(Gauss* gauss)=0;
                 virtual IssmDouble GetN()=0;
-                virtual void       GetViscosity(IssmDouble* pviscosity,IssmDouble epseff)=0;
-                virtual void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble epseff)=0;
-                virtual void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon)=0;
-                virtual void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon)=0;
-                virtual void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon)=0;
-                virtual void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble epseff)=0;
-                virtual void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble epseff)=0;
-                virtual void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon)=0;
+                virtual void       GetViscosity(IssmDouble* pviscosity,IssmDouble epseff,Gauss* gauss)=0;
+                virtual void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble epseff,Gauss* gauss)=0;
+                virtual void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss)=0;
+                virtual void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss)=0;
+                virtual void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss)=0;
+                virtual void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble epseff,Gauss* gauss)=0;
+                virtual void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble epseff,Gauss* gauss)=0;
+                virtual void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss)=0;
                 virtual bool       IsDamage()=0;
                 virtual bool       IsEnhanced()=0;
@@ -47 +47 @@
 
                 virtual void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
-                virtual void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon)=0;
+                virtual void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
                 virtual void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
-                virtual void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon)=0;
+                virtual void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
                 virtual void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf)=0;
                 virtual void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
-                virtual void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon)=0;
+                virtual void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
                 virtual void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble epseff)=0;
                 virtual void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff)=0;

issm/trunk-jpl/src/c/classes/Materials/Matestar.cpp

@@ -133 +133 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetA(){/*{{{*/
+IssmDouble Matestar::GetA(Gauss* gauss){/*{{{*/
         /*
          * A = 1/B^n
@@ -146 +146 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetAbar(){/*{{{*/
+IssmDouble Matestar::GetAbar(Gauss* gauss){/*{{{*/
         /*
          * A = 1/B^n
@@ -159 +159 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetB(){/*{{{*/
+IssmDouble Matestar::GetB(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -168 +168 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetBbar(){/*{{{*/
+IssmDouble Matestar::GetBbar(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -177 +177 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetD(){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-IssmDouble Matestar::GetDbar(){/*{{{*/
-
-        _error_("not implemented yet");
-}
-/*}}}*/
-IssmDouble Matestar::GetEc(){/*{{{*/
+IssmDouble Matestar::GetD(Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+IssmDouble Matestar::GetDbar(Gauss* gauss){/*{{{*/
+
+        _error_("not implemented yet");
+}
+/*}}}*/
+IssmDouble Matestar::GetEc(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -195 +195 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetEcbar(){/*{{{*/
+IssmDouble Matestar::GetEcbar(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -204 +204 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetEs(){/*{{{*/
+IssmDouble Matestar::GetEs(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -213 +213 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetEsbar(){/*{{{*/
+IssmDouble Matestar::GetEsbar(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -229 +229 @@
 }
 /*}}}*/
-void  Matestar::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-void  Matestar::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-void  Matestar::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-void  Matestar::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-void  Matestar::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
-        _error_("not implemented yet");
-}
-/*}}}*/
-IssmDouble Matestar::GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged){/*{{{*/
+void  Matestar::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+void  Matestar::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+void  Matestar::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+void  Matestar::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+void  Matestar::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}
+/*}}}*/
+IssmDouble Matestar::GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged,Gauss* gauss){/*{{{*/
 
         /*output: */
@@ -279 +279 @@
         n=GetN(); _assert_(n>0.);
         if (isdepthaveraged==0.){
-                B=GetB(); _assert_(B>0.);
-                Ec=GetEc(); _assert_(Ec>=0.);
-                Es=GetEs(); _assert_(Es>=0.);
-        }
-        else{
-                B=GetBbar(); _assert_(B>0.);
-                Ec=GetEcbar(); _assert_(Ec>=0.);
-                Es=GetEsbar(); _assert_(Es>=0.);
+                B=GetB(gauss);   _assert_(B>0.);
+                Ec=GetEc(gauss); _assert_(Ec>=0.); Es=GetEs(gauss); _assert_(Es>=0.);
+        }
+        else{
+                B=GetBbar(gauss);   _assert_(B>0.);
+                Ec=GetEcbar(gauss); _assert_(Ec>=0.);
+                Es=GetEsbar(gauss); _assert_(Es>=0.);
         }
 
@@ -310 +309 @@
 }
 /*}}}*/
-IssmDouble Matestar::GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged){/*{{{*/
+IssmDouble Matestar::GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged,Gauss* gauss){/*{{{*/
 
         /*Intermediaries*/
@@ -337 +336 @@
         /*Get enhancement*/
         if (isdepthaveraged==0.){
-                Ec=GetEc(); _assert_(Ec>=0.);
-                Es=GetEs(); _assert_(Es>=0.);
-        }
-        else{
-                Ec=GetEcbar(); _assert_(Ec>=0.);
-                Es=GetEsbar(); _assert_(Es>=0.);
+                Ec=GetEc(gauss); _assert_(Ec>=0.);
+                Es=GetEs(gauss); _assert_(Es>=0.);
+        }
+        else{
+                Ec=GetEcbar(gauss); _assert_(Ec>=0.);
+                Es=GetEsbar(gauss); _assert_(Es>=0.);
         }
 
@@ -350 +349 @@
         /*Compute dmudB*/
         if(eps_eff==0.) dmudB = 0.;
-        else           dmudB = 1./(2.*pow(E,1./3.)*pow(eps_eff,2./3.));
+        else            dmudB = 1./(2.*pow(E,1./3.)*pow(eps_eff,2./3.));
 
         /*Assign output*/
@@ -357 +356 @@
 }
 /*}}}*/
-void  Matestar::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
+void  Matestar::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
          _error_("not implemented yet");
 }
 /*}}}*/
-void  Matestar::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/
+void  Matestar::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
          _error_("not implemented yet");
 }
 /*}}}*/
-void  Matestar::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
+void  Matestar::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
         _error_("not implemented yet");
 }
@@ -437 +436 @@
 
         /*Compute dmudB*/
-        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
+        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
 }
 /*}}}*/
@@ -466 +465 @@
 
         /*Compute viscosity*/
-        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
+        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
 }/*}}}*/
 void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){/*{{{*/
@@ -496 +495 @@
 
         /*Compute viscosity*/
-        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
+        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
 }/*}}}*/
 void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
@@ -538 +537 @@
 
         /*Compute viscosity*/
-        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
-}
-/*}}}*/
-void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
-        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
+        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
+}
+/*}}}*/
+void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
 }/*}}}*/
 void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
@@ -584 +583 @@
 
         /*Compute viscosity*/
-        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
-}/*}}}*/
-void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
+        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
+}/*}}}*/
+void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
         _error_("not implemented yet");
 }/*}}}*/
@@ -635 +634 @@
 
         /*Compute viscosity*/
-        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged);
-}/*}}}*/
-void  Matestar::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
-        _error_("not implemented yet");
-}/*}}}*/
+        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
+}/*}}}*/
+void  Matestar::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        _error_("not implemented yet");
+}/*}}}*/

issm/trunk-jpl/src/c/classes/Materials/Matestar.h

@@ -56 +56 @@
                 void   Configure(Elements* elements);
                 Material*  copy2(Element* element);
-                void       GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon);
-                void       GetViscosityDComplement(IssmDouble*, IssmDouble*);
-                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
-                void       GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
-                IssmDouble GetA();
-                IssmDouble GetAbar();
-                IssmDouble GetB();
-                IssmDouble GetBbar();
-                IssmDouble GetD();
-                IssmDouble GetDbar();
-                IssmDouble GetEc();
-                IssmDouble GetEcbar();
-                IssmDouble GetEs();
-                IssmDouble GetEsbar();
+                void       GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss);
+                void       GetViscosityDComplement(IssmDouble*, IssmDouble*,Gauss* gauss);
+                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss);
+                void       GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss);
+                IssmDouble GetA(Gauss* gauss);
+                IssmDouble GetAbar(Gauss* gauss);
+                IssmDouble GetB(Gauss* gauss);
+                IssmDouble GetBbar(Gauss* gauss);
+                IssmDouble GetD(Gauss* gauss);
+                IssmDouble GetDbar(Gauss* gauss);
+                IssmDouble GetEc(Gauss* gauss);
+                IssmDouble GetEcbar(Gauss* gauss);
+                IssmDouble GetEs(Gauss* gauss);
+                IssmDouble GetEsbar(Gauss* gauss);
                 IssmDouble GetN();
                 bool       IsDamage();
@@ -81 +81 @@
 
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
-                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff);
                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
                 void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
                 /*}}}*/
-                IssmDouble GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged);
-                IssmDouble GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged);
+                IssmDouble GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged,Gauss* gauss);
+                IssmDouble GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged,Gauss* gauss);
 };
 

issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

@@ -193 +193 @@
 }
 /*}}}*/
-IssmDouble Matice::GetA(){/*{{{*/
+IssmDouble Matice::GetA(Gauss* gauss){/*{{{*/
         /*
          * A = 1/B^n
@@ -206 +206 @@
 }
 /*}}}*/
-IssmDouble Matice::GetAbar(){/*{{{*/
+IssmDouble Matice::GetAbar(Gauss* gauss){/*{{{*/
         /*
          * A = 1/B^n
@@ -219 +219 @@
 }
 /*}}}*/
-IssmDouble Matice::GetB(){/*{{{*/
+IssmDouble Matice::GetB(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -228 +228 @@
 }
 /*}}}*/
-IssmDouble Matice::GetBbar(){/*{{{*/
+IssmDouble Matice::GetBbar(Gauss* gauss){/*{{{*/
 
         /*Output*/
@@ -237 +237 @@
 }
 /*}}}*/
-IssmDouble Matice::GetD(){/*{{{*/
+IssmDouble Matice::GetD(Gauss* gauss){/*{{{*/
 
         _assert_(this->isdamaged);
@@ -246 +246 @@
 }
 /*}}}*/
-IssmDouble Matice::GetDbar(){/*{{{*/
+IssmDouble Matice::GetDbar(Gauss* gauss){/*{{{*/
 
         _assert_(this->isdamaged);
@@ -255 +255 @@
 }
 /*}}}*/
-IssmDouble Matice::GetE(){/*{{{*/
+IssmDouble Matice::GetE(Gauss* gauss){/*{{{*/
 
         _assert_(this->isenhanced);
@@ -264 +264 @@
 }
 /*}}}*/
-IssmDouble Matice::GetEbar(){/*{{{*/
+IssmDouble Matice::GetEbar(Gauss* gauss){/*{{{*/
 
         _assert_(this->isenhanced);
@@ -292 +292 @@
 }
 /*}}}*/
-void  Matice::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
+void  Matice::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
         /*From a string tensor and a material object, return viscosity, using Glen's flow law.
                                                                 (1-D) B
@@ -312 +312 @@
 
         /*Get B and n*/
-        B=GetB(); _assert_(B>0.);
+        B=GetB(gauss); _assert_(B>0.);
         n=GetN(); _assert_(n>0.);
         if(this->isdamaged){
-                D=GetD();
+                D=GetD(gauss);
                 _assert_(D>=0. && D<1.);
         }
         if(this->isenhanced){
-                E=GetE();
+                E=GetE(gauss);
                 _assert_(E>0.);
         }
@@ -348 +348 @@
 }
 /*}}}*/
-void  Matice::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
+void  Matice::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
         /*From a string tensor and a material object, return viscosity, using Glen's flow law.
                                                                 (1-D) B
@@ -368 +368 @@
 
         /*Get B and n*/
-        B=GetBbar(); _assert_(B>0.);
+        B=GetBbar(gauss); _assert_(B>0.);
         n=GetN();    _assert_(n>0.);
         if(this->isdamaged){
-                D=GetDbar();
+                D=GetDbar(gauss);
                 _assert_(D>=0. && D<1.);
         }
         if(this->isenhanced){
-                E=GetEbar();
+                E=GetEbar(gauss);
                 _assert_(E>0.);
         }
@@ -403 +403 @@
 }
 /*}}}*/
-void  Matice::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
+void  Matice::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
         /*Return viscosity accounting for steady state power law creep [Thomas and SSA, 1982]: 
          *
@@ -426 +426 @@
         /*Get D and n*/
         if(this->isdamaged){
-                D=GetDbar(); /* GetD()? */
+                D=GetDbar(gauss); /* GetD()? */
                 _assert_(D>=0. && D<1.);
         }
@@ -461 +461 @@
 }
 /*}}}*/
-void  Matice::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
+void  Matice::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
         /*Return viscosity derivative for control method d(mu)/dD: 
          *
@@ -483 +483 @@
 
         /*Get B and n*/
-        B=GetBbar();
+        B=GetBbar(gauss);
         n=GetN();
 
@@ -516 +516 @@
 }
 /*}}}*/
-void  Matice::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
+void  Matice::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
 
         /*output: */
@@ -532 +532 @@
         else{
 
-                /*Retrive strain rate components: */
+                /*Retrieve strain rate components: */
                 exx=epsilon[0];
                 eyy=epsilon[1];
@@ -540 +540 @@
                 eff2 = exx*exx + eyy*eyy + exx*eyy + exy*exy + exz*exz + eyz*eyz;
 
-                GetViscosity(&mu,sqrt(eff2));
+                GetViscosity(&mu,sqrt(eff2),gauss);
                 n=GetN();
                 mu_prime=(1.-n)/(2.*n) * mu/eff2;
@@ -549 +549 @@
 }
 /*}}}*/
-void  Matice::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
+void  Matice::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
 
         /*output: */
@@ -560 +560 @@
         n=GetN(); _assert_(n>0.);
         if(this->isdamaged){
-                D=GetD();
+                D=GetD(gauss);
                 _assert_(D>=0. && D<1.);
         }
         if(this->isenhanced){
-                E=GetE();
+                E=GetE(gauss);
                 _assert_(E>0.);
         }
@@ -581 +581 @@
 }
 /*}}}*/
-void  Matice::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/
+void  Matice::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff,Gauss* gauss){/*{{{*/
 
         /*output: */
@@ -591 +591 @@
         /*Get B and n*/
         n=GetN(); _assert_(n>0.);
-        B=GetBbar();
+        B=GetBbar(gauss);
         _assert_(this->isdamaged);
         if(this->isenhanced){
-                E=GetE();
+                E=GetE(gauss);
                 _assert_(E>0.);
         }
@@ -611 +611 @@
 }
 /*}}}*/
-void  Matice::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
+void  Matice::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon,Gauss* gauss){/*{{{*/
 
         /*output: */
@@ -630 +630 @@
                 eff2 = exx*exx + eyy*eyy + exx*eyy + exy*exy ;
 
-                GetViscosityBar(&mu,sqrt(eff2));
+                GetViscosityBar(&mu,sqrt(eff2),gauss);
                 n=GetN();
                 mu_prime=(1.-n)/(2.*n)*mu/eff2;
@@ -709 +709 @@
 
         /*Get viscosity*/
-        this->GetViscosity(&viscosity,eps_eff);
+        this->GetViscosity(&viscosity,eps_eff,gauss);
 
         /*Assign output pointer*/
@@ -715 +715 @@
 }
 /*}}}*/
-void  Matice::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
-        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
+void  Matice::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
 }/*}}}*/
 void  Matice::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
@@ -738 +738 @@
 
         /*Get viscosity*/
-        this->GetViscosity(&viscosity,eps_eff);
+        this->GetViscosity(&viscosity,eps_eff,gauss);
         _assert_(!xIsNan<IssmDouble>(viscosity));
 
@@ -744 +744 @@
         *pviscosity=viscosity;
 }/*}}}*/
-void  Matice::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
-        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
+void  Matice::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
 }/*}}}*/
 void  Matice::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
@@ -789 +789 @@
         /*Get A*/
         _assert_(this->GetN()==3.0);
-        A=this->GetA();
+        A=this->GetA(gauss);
 
         /*Solve for tau_perp (http://fr.wikipedia.org/wiki/Méthode_de_Cardan)*/
@@ -826 +826 @@
 
         /*Get viscosity*/
-        this->GetViscosityBar(&viscosity,eps_eff);
+        this->GetViscosityBar(&viscosity,eps_eff,gauss);
 
         /*Assign output pointer*/
         *pviscosity=viscosity;
 }/*}}}*/
-void  Matice::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
-        this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon);
+void  Matice::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
+        this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon,gauss);
 }/*}}}*/

issm/trunk-jpl/src/c/classes/Materials/Matice.h

@@ -60 +60 @@
                 void   Configure(Elements* elements);
                 Material*  copy2(Element* element);
-                void       GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon);
-                void       GetViscosityDComplement(IssmDouble*, IssmDouble*);
-                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
-                void       GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff);
-                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
-                IssmDouble GetA();
-                IssmDouble GetAbar();
-                IssmDouble GetB();
-                IssmDouble GetBbar();
-                IssmDouble GetD();
-                IssmDouble GetDbar();
-                IssmDouble GetE();
-                IssmDouble GetEbar();
+                void       GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss);
+                void       GetViscosityDComplement(IssmDouble*, IssmDouble*,Gauss* gauss);
+                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss);
+                void       GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff,Gauss* gauss);
+                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss);
+                IssmDouble GetA(Gauss* gauss);
+                IssmDouble GetAbar(Gauss* gauss);
+                IssmDouble GetB(Gauss* gauss);
+                IssmDouble GetBbar(Gauss* gauss);
+                IssmDouble GetD(Gauss* gauss);
+                IssmDouble GetDbar(Gauss* gauss);
+                IssmDouble GetE(Gauss* gauss);
+                IssmDouble GetEbar(Gauss* gauss);
                 IssmDouble GetN();
                 bool       IsDamage();
@@ -83 +83 @@
 
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
-                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
+                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
                 void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff){_error_("not supported");};
                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};

issm/trunk-jpl/src/c/classes/Materials/Matlitho.h

@@ -52 +52 @@
                 Material*  copy2(Element* element){_error_("not implemented");};
                 void       Configure(Elements* elements);
-                void       GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
-                IssmDouble GetA(){_error_("not supported");};
-                IssmDouble GetAbar(){_error_("not supported");};
-                IssmDouble GetB(){_error_("not supported");};
-                IssmDouble GetBbar(){_error_("not supported");};
-                IssmDouble GetD(){_error_("not supported");};
-                IssmDouble GetDbar(){_error_("not supported");};
+                void       GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                IssmDouble GetA(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetAbar(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetB(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetBbar(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetD(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetDbar(Gauss* gauss){_error_("not supported");};
                 IssmDouble GetN(){_error_("not supported");};
                 bool       IsDamage(){_error_("not supported");};
@@ -72 +72 @@
 
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
-                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
-                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf){_error_("not supported");};
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
-                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble epseff){_error_("not supported");};
                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff){_error_("not supported");};

issm/trunk-jpl/src/c/classes/Materials/Matpar.h

@@ -89 +89 @@
                 Material*  copy2(Element* element){_error_("not implemented");};
                 void       Configure(Elements* elements);
-                void       GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
-                void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble eps_eff){_error_("not supported");};
-                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
-                IssmDouble GetA(){_error_("not supported");};
-                IssmDouble GetAbar(){_error_("not supported");};
-                IssmDouble GetB(){_error_("not supported");};
-                IssmDouble GetBbar(){_error_("not supported");};
-                IssmDouble GetD(){_error_("not supported");};
-                IssmDouble GetDbar(){_error_("not supported");};
+                void       GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity_B(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity_D(IssmDouble* pviscosity,IssmDouble eps_eff,Gauss* gauss){_error_("not supported");};
+                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon,Gauss* gauss){_error_("not supported");};
+                IssmDouble GetA(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetAbar(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetB(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetBbar(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetD(Gauss* gauss){_error_("not supported");};
+                IssmDouble GetDbar(Gauss* gauss){_error_("not supported");};
                 IssmDouble GetN(){_error_("not supported");};
                 bool       IsDamage(){_error_("not supported");};
@@ -109 +109 @@
 
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
-                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
-                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf){_error_("not supported");};
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
-                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
+                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
                 void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff){_error_("not supported");};
                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};