Changeset 24377


Ignore:
Timestamp:
11/21/19 14:16:34 (5 years ago)
Author:
Mathieu Morlighem
Message:

CHG: cleaning up old inputs

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

Legend:

Unmodified
Added
Removed

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

    r24376 r24377  
    11061106}
    11071107/*}}}*/
    1108 Input*     Element::GetInput(int inputenum){/*{{{*/
    1109         return inputs->GetInput(inputenum);
    1110 }/*}}}*/
    11111108void       Element::GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){/*{{{*/
    11121109
    … …  
    40324029}
    40334030/*}}}*/
    4034 void       Element::StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    4035 
    4036         /*Intermediaries*/
    4037         IssmDouble dvx[3];
    4038         IssmDouble dvy[3];
    4039 
    4040         /*Check that both inputs have been found*/
    4041         if(!vx_input || !vy_input){
    4042                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
    4043         }
    4044 
    4045         /*Get strain rate assuming that epsilon has been allocated*/
    4046         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4047         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    4048         epsilon[0] = dvx[0];    // normal strain rate x-direction
    4049         epsilon[1] = dvy[1]; // normal strain rate y-direction
    4050         epsilon[2] = 0.5*(dvx[1] + dvy[0]); // shear strain rate
    4051         epsilon[3] = 0.5*(dvx[1] - dvy[0]); // rotation rate
    4052 
    4053 }/*}}}*/
    4054 void       Element::StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
    4055         /*Compute the 3d Strain Rate (6 components):
    4056          *
    4057          * epsilon=[exx eyy ezz exy exz eyz]
    4058          */
    4059 
    4060         /*Intermediaries*/
    4061         IssmDouble dvx[3];
    4062         IssmDouble dvy[3];
    4063         IssmDouble dvz[3];
    4064 
    4065         /*Check that both inputs have been found*/
    4066         if (!vx_input || !vy_input || !vz_input){
    4067                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << ", vz: " << vz_input << "\n");
    4068         }
    4069 
    4070         /*Get strain rate assuming that epsilon has been allocated*/
    4071         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4072         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    4073         vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
    4074         epsilon[0] = dvx[0];
    4075         epsilon[1] = dvy[1];
    4076         epsilon[2] = dvz[2];
    4077         epsilon[3] = 0.5*(dvx[1] + dvy[0]);
    4078         epsilon[4] = 0.5*(dvx[2] + dvz[0]);
    4079         epsilon[5] = 0.5*(dvy[2] + dvz[1]);
    4080 
    4081 }/*}}}*/
    4082 void       Element::StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    4083         /*Compute the 3d Blatter/HOStrain Rate (5 components):
    4084          *
    4085          * epsilon=[exx eyy exy exz eyz]
    4086          *
    4087          * with exz=1/2 du/dz
    4088          *      eyz=1/2 dv/dz
    4089          *
    4090          * the contribution of vz is neglected
    4091          */
    4092 
    4093         /*Intermediaries*/
    4094         IssmDouble dvx[3];
    4095         IssmDouble dvy[3];
    4096 
    4097         /*Check that both inputs have been found*/
    4098         if (!vx_input || !vy_input){
    4099                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
    4100         }
    4101 
    4102         /*Get strain rate assuming that epsilon has been allocated*/
    4103         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4104         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    4105         epsilon[0] = dvx[0];
    4106         epsilon[1] = dvy[1];
    4107         epsilon[2] = 0.5*(dvx[1] + dvy[0]);
    4108         epsilon[3] = 0.5*dvx[2];
    4109         epsilon[4] = 0.5*dvy[2];
    4110 
    4111 }/*}}}*/
    4112 void       Element::StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    4113         /*Compute the 2d Blatter/HOStrain Rate (2 components):
    4114          *
    4115          * epsilon=[exx exz]
    4116          *
    4117          * with exz=1/2 du/dz
    4118          *
    4119          * the contribution of vz is neglected
    4120          */
    4121 
    4122         /*Intermediaries*/
    4123         IssmDouble dvx[3];
    4124 
    4125         /*Check that both inputs have been found*/
    4126         if (!vx_input){
    4127                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input <<"\n");
    4128         }
    4129 
    4130         /*Get strain rate assuming that epsilon has been allocated*/
    4131         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4132         epsilon[0] = dvx[0];
    4133         epsilon[1] = 0.5*dvx[1];
    4134 
    4135 }/*}}}*/
    4136 void       Element::StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    4137 
    4138         /*Intermediaries*/
    4139         IssmDouble dvx[3];
    4140         IssmDouble dvy[3];
    4141 
    4142         /*Check that both inputs have been found*/
    4143         if(!vx_input || !vy_input){
    4144                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
    4145         }
    4146 
    4147         /*Get strain rate assuming that epsilon has been allocated*/
    4148         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4149         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    4150         epsilon[0] = dvx[0];
    4151         epsilon[1] = dvy[1];
    4152         epsilon[2] = 0.5*(dvx[1] + dvy[0]);
    4153 
    4154 }/*}}}*/
    4155 void       Element::StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input){/*{{{*/
    4156 
    4157         /*Intermediaries*/
    4158         IssmDouble dvx[3];
    4159 
    4160         /*Check that both inputs have been found*/
    4161         if (!vx_input){
    4162                 _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << "\n");
    4163         }
    4164 
    4165         /*Get strain rate assuming that epsilon has been allocated*/
    4166         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    4167         *epsilon = dvx[0];
    4168 
    4169 }/*}}}*/
    41704031void       Element::StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    41714032

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

    r24376 r24377  
    9292                void                 GetDofListLocalPressure(int** pdoflist,int setenum);
    9393                void                 GetDofListLocalVelocity(int** pdoflist,int setenum);
    94                 Input*             GetInput(int inputenum);
    9594                void               GetInputListOnNodes(IssmDouble* pvalue,int enumtype);
    9695                void               GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    … …  
    175174                int                Sid();
    176175                void               SmbGemb();
    177                 void               StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    178                 void               StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    179                 void               StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    180                 void               StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    181                 void               StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    182                 void               StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input);
    183176                void               StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
    184177                void               StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);

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

    r24335 r24377  
    4646                virtual void       ResetHooks()=0;
    4747
    48                 virtual void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
    4948                virtual void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
    50                 virtual void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
    5149                virtual void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
    52                 virtual void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf)=0;
    53                 virtual void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
    5450                virtual void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss)=0;
    55                 virtual void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble epseff)=0;
    56                 virtual void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff)=0;
    57                 virtual void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff)=0;
    58 
    5951                virtual void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input)=0;
    6052                virtual void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input)=0;

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

    r24335 r24377  
    388388}
    389389/*}}}*/
    390 void  Matestar::ViscosityBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff){/*{{{*/
     390void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     391        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
     392}/*}}}*/
     393void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     394        _error_("not implemented yet");
     395}/*}}}*/
     396void  Matestar::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     397        _error_("not implemented yet");
     398}/*}}}*/
     399
     400void  Matestar::ViscosityBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble eps_eff){/*{{{*/
    391401
    392402        /*Intermediaries*/
    … …  
    417427}
    418428/*}}}*/
    419 void  Matestar::ViscosityBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){/*{{{*/
     429void  Matestar::ViscosityBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
    420430
    421431        /*Intermediaries*/
    … …  
    445455        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    446456}/*}}}*/
    447 void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){/*{{{*/
     457void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
    448458        /*Intermediaries*/
    449459        IssmDouble vx,vy,vz;
    … …  
    475485        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    476486}/*}}}*/
    477 void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     487void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    478488
    479489        /*Intermediaries*/
    … …  
    518528}
    519529/*}}}*/
    520 void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    521         this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
    522 }/*}}}*/
    523 void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     530void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    524531
    525532        /*Intermediaries*/
    … …  
    563570        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    564571}/*}}}*/
    565 void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    566         _error_("not implemented yet");
    567 }/*}}}*/
    568 void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
    569         _error_("not implemented yet");
    570 }/*}}}*/
    571 void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     572void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
     573        _error_("not implemented yet");
     574}/*}}}*/
     575void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    572576
    573577        /*Intermediaries*/
    … …  
    614618        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    615619}/*}}}*/
    616 void  Matestar::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    617         _error_("not implemented yet");
    618 }/*}}}*/
    619 
    620 void  Matestar::ViscosityBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble eps_eff){/*{{{*/
    621 
    622         /*Intermediaries*/
    623         IssmDouble vx,vy,vz;
    624         IssmDouble dvx[3],dvy[3],dvz[3];
    625         bool isdepthaveraged=0.;
    626 
    627         /*Get velocity derivatives in all directions*/
    628         _assert_(dim>1);
    629         _assert_(vx_input);
    630         vx_input->GetInputValue(&vx,gauss);
    631         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    632         _assert_(vy_input);
    633         vy_input->GetInputValue(&vy,gauss);
    634         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    635         if(dim==3){
    636                 _assert_(vz_input);
    637                 vz_input->GetInputValue(&vz,gauss);
    638                 vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
    639         }
    640         else{
    641                 vz = 0.;
    642                 dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.;
    643         }
    644 
    645         /*Compute dmudB*/
    646         *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    647 }
    648 /*}}}*/
    649 void  Matestar::ViscosityBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
    650 
    651         /*Intermediaries*/
    652         IssmDouble vx,vy,vz;
    653         IssmDouble dvx[3],dvy[3],dvz[3];
    654         bool isdepthaveraged=0.;
    655 
    656         /*Get velocity derivatives in all directions*/
    657         _assert_(dim==2 || dim==3);
    658         _assert_(vx_input);
    659         vx_input->GetInputValue(&vx,gauss);
    660         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    661         if(dim==3){
    662                 _assert_(vy_input);
    663                 vy_input->GetInputValue(&vy,gauss);
    664                 vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    665         }
    666         else{
    667                 dvx[2] = 0.;
    668                 vy = 0.;
    669                 dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
    670         }
    671         vz = 0.;
    672         dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
    673 
    674         /*Compute viscosity*/
    675         *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    676 }/*}}}*/
    677 void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
    678         /*Intermediaries*/
    679         IssmDouble vx,vy,vz;
    680         IssmDouble dvx[3],dvy[3],dvz[3];
    681         bool isdepthaveraged=1.;
    682 
    683         /*Get velocity derivatives in all directions*/
    684         _assert_(dim==1 || dim==2);
    685         _assert_(vx_input);
    686         vx_input->GetInputValue(&vx,gauss);
    687         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    688         if(dim==2){
    689                 _assert_(vy_input);
    690                 vy_input->GetInputValue(&vy,gauss);
    691                 vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    692         }
    693         else{
    694                 dvx[1] = 0.;
    695                 dvx[2] = 0.;
    696                 vy = 0.;
    697                 dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
    698         }
    699         dvx[2] = 0.;
    700         dvy[2] = 0.;
    701         vz = 0.;
    702         dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
    703 
    704         /*Compute viscosity*/
    705         *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    706 }/*}}}*/
    707 void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    708 
    709         /*Intermediaries*/
    710         IssmDouble vx,vy,vz;
    711         IssmDouble dvx[3],dvy[3],dvz[3];
    712         IssmDouble epsilon3d[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
    713         IssmDouble epsilon2d[3]; /* epsilon=[exx,eyy,exy];*/
    714         IssmDouble eps_eff,eps0=1.e-27;
    715         bool isdepthaveraged=0.;
    716 
    717         /*Get velocity derivatives in all directions*/
    718         _assert_(dim>1);
    719         _assert_(vx_input);
    720         vx_input->GetInputValue(&vx,gauss);
    721         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    722         _assert_(vy_input);
    723         vy_input->GetInputValue(&vy,gauss);
    724         vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    725         if(dim==3){
    726                 _assert_(vz_input);
    727                 vz_input->GetInputValue(&vz,gauss);
    728                 vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
    729         }
    730         else{
    731                 vz = 0.;
    732                 dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.;
    733         }
    734 
    735         if(dim==3){
    736       /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
    737                 element->StrainRateFS(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input,vz_input);
    738                 eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[3]*epsilon3d[3] +  epsilon3d[4]*epsilon3d[4] + epsilon3d[5]*epsilon3d[5] + epsilon3d[0]*epsilon3d[1]+eps0*eps0);
    739         }
    740         else{
    741                 /* eps_eff^2 = 1/2 ( exx^2 + eyy^2 + 2*exy^2 )*/
    742                 element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    743                 eps_eff = 1./sqrt(2.)*sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + 2.*epsilon2d[2]*epsilon2d[2]);
    744         }
    745 
    746         /*Compute viscosity*/
    747         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    748 }
    749 /*}}}*/
    750 void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    751 
    752         /*Intermediaries*/
    753         IssmDouble vx,vy,vz;
    754         IssmDouble dvx[3],dvy[3],dvz[3];
    755         IssmDouble epsilon3d[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
    756         IssmDouble epsilon2d[5]; /* epsilon=[exx,exy];*/
    757         IssmDouble eps_eff;
    758         bool isdepthaveraged=0.;
    759 
    760    if(dim==3){
    761                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
    762                 element->StrainRateHO(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input);
    763                 eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[2]*epsilon3d[2] +  epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[0]*epsilon3d[1]);
    764         }
    765         else{
    766                 /* eps_eff^2 = 1/2 (2*exx^2 + 2*exy^2 ) (since eps_zz = - eps_xx)*/
    767                 element->StrainRateHO2dvertical(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    768                 eps_eff = 1./sqrt(2.)*sqrt(2*epsilon2d[0]*epsilon2d[0] + 2*epsilon2d[1]*epsilon2d[1]);
    769         }
    770 
    771         /*Get velocity derivatives in all directions*/
    772         _assert_(dim==2 || dim==3);
    773         _assert_(vx_input);
    774         vx_input->GetInputValue(&vx,gauss);
    775         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    776         if(dim==3){
    777                 _assert_(vy_input);
    778                 vy_input->GetInputValue(&vy,gauss);
    779                 vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    780         }
    781         else{
    782                 dvx[2] = 0.;
    783                 vy = 0.;
    784                 dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
    785         }
    786         vz = 0.;
    787         dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
    788 
    789         /*Compute viscosity*/
    790         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    791 }/*}}}*/
    792 void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
    793         _error_("not implemented yet");
    794 }/*}}}*/
    795 void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    796 
    797         /*Intermediaries*/
    798         IssmDouble vx,vy,vz;
    799         IssmDouble dvx[3],dvy[3],dvz[3];
    800         IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy]; */
    801         IssmDouble epsilon1d;   /* epsilon=[exx];         */
    802         IssmDouble eps_eff;
    803         bool isdepthaveraged=1.;
    804 
    805         /*Get velocity derivatives in all directions*/
    806         _assert_(dim==1 || dim==2);
    807         _assert_(vx_input);
    808         vx_input->GetInputValue(&vx,gauss);
    809         vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
    810         if(dim==2){
    811                 _assert_(vy_input);
    812                 vy_input->GetInputValue(&vy,gauss);
    813                 vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
    814         }
    815         else{
    816                 dvx[1] = 0.;
    817                 dvx[2] = 0.;
    818                 vy = 0.;
    819                 dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
    820         }
    821         dvx[2] = 0.;
    822         dvy[2] = 0.;
    823         vz = 0.;
    824         dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
    825 
    826    if(dim==2){
    827                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy*/
    828                 element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    829                 eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
    830         }
    831         else{
    832                 /* eps_eff^2 = exx^2*/
    833                 element->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
    834                 eps_eff = fabs(epsilon1d);
    835         }
    836 
    837         /*Compute viscosity*/
    838         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
    839 }/*}}}*/

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

    r24335 r24377  
    7171                void       SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
    7272
    73                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    7473                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    75                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    7674                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    77                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
    78                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    7975                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    80                 void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff);
    81                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
    82                 void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
    8376
    8477                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);

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

    r24335 r24377  
    666666}
    667667/*}}}*/
    668 void  Matice::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     668void  Matice::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     669        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
     670}/*}}}*/
     671void  Matice::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     672        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
     673}/*}}}*/
     674void  Matice::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
     675        this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon,gauss);
     676}/*}}}*/
     677
     678void  Matice::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    669679        /*The effective strain rate is defined in Paterson 3d Ed p 91 eq 9,
    670680         * and Cuffey p 303 eq 8.18:
    … …  
    705715}
    706716/*}}}*/
    707 void  Matice::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    708         this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
    709 }/*}}}*/
    710 void  Matice::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     717void  Matice::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    711718
    712719        /*Intermediaries*/
    … …  
    734741        *pviscosity=viscosity;
    735742}/*}}}*/
    736 void  Matice::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    737         this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
    738 }/*}}}*/
    739 void  Matice::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
     743void  Matice::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
    740744        /*Compute the L1L2 viscosity
    741745         *
    … …  
    796800        *pviscosity = viscosity;
    797801}/*}}}*/
    798 void  Matice::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     802void  Matice::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    799803
    800804        /*Intermediaries*/
    … …  
    821825        *pviscosity=viscosity;
    822826}/*}}}*/
    823 void  Matice::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){/*{{{*/
    824         this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon,gauss);
    825 }/*}}}*/
    826 
    827 void  Matice::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    828         /*The effective strain rate is defined in Paterson 3d Ed p 91 eq 9,
    829          * and Cuffey p 303 eq 8.18:
    830          *
    831          *  2 eps_eff^2 = eps_xx^2 + eps_yy^2 + eps_zz^2 + 2(eps_xy^2 + eps_xz^2 + eps_yz^2)
    832          *
    833          *  or
    834          *
    835          *  eps_eff = 1/sqrt(2) sqrt( \sum_ij eps_ij^2 )
    836          *
    837          *          = 1/sqrt(2) ||eps||_F
    838          *
    839          *  where ||.||_F is the Frobenius norm */
    840 
    841         /*Intermediaries*/
    842         IssmDouble viscosity;
    843         IssmDouble epsilon3d[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
    844         IssmDouble epsilon2d[3]; /* epsilon=[exx,eyy,exy];            */
    845         IssmDouble eps_eff;
    846         IssmDouble eps0=1.e-27;
    847 
    848         if(dim==3){
    849                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
    850                 element->StrainRateFS(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input,vz_input);
    851                 eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[3]*epsilon3d[3] +  epsilon3d[4]*epsilon3d[4] + epsilon3d[5]*epsilon3d[5] + epsilon3d[0]*epsilon3d[1]+eps0*eps0);
    852         }
    853         else{
    854                 /* eps_eff^2 = 1/2 ( exx^2 + eyy^2 + 2*exy^2 )*/
    855                 element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    856                 eps_eff = 1./sqrt(2.)*sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + 2.*epsilon2d[2]*epsilon2d[2]);
    857         }
    858 
    859         /*Get viscosity*/
    860         this->GetViscosity(&viscosity,eps_eff,gauss);
    861 
    862         /*Assign output pointer*/
    863         *pviscosity=viscosity;
    864 }
    865 /*}}}*/
    866 void  Matice::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    867 
    868         /*Intermediaries*/
    869         IssmDouble viscosity;
    870         IssmDouble epsilon3d[5];/* epsilon=[exx,eyy,exy,exz,eyz];*/
    871         IssmDouble epsilon2d[2];/* epsilon=[exx,exy];            */
    872         IssmDouble eps_eff;
    873 
    874         if(dim==3){
    875                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
    876                 element->StrainRateHO(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input);
    877                 eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[2]*epsilon3d[2] +  epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[0]*epsilon3d[1]);
    878         }
    879         else{
    880                 /* eps_eff^2 = 1/2 (2*exx^2 + 2*exy^2 ) (since eps_zz = - eps_xx)*/
    881                 element->StrainRateHO2dvertical(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    882                 eps_eff = 1./sqrt(2.)*sqrt(2*epsilon2d[0]*epsilon2d[0] + 2*epsilon2d[1]*epsilon2d[1]);
    883         }
    884 
    885         /*Get viscosity*/
    886         this->GetViscosity(&viscosity,eps_eff,gauss);
    887         _assert_(!xIsNan<IssmDouble>(viscosity));
    888 
    889         /*Assign output pointer*/
    890         *pviscosity=viscosity;
    891 }/*}}}*/
    892 void  Matice::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
    893         /*Compute the L1L2 viscosity
    894          *
    895          *      1
    896          * mu = - A^-1 (sigma'_e)^(1-n)
    897          *      2
    898          *
    899          * sigma'_e^2 = |sigma'_//|^2 + |sigma'_perp|^2 (see Perego 2012 eq. 17,18)
    900          *
    901          * L1L2 assumptions:
    902          *
    903          * (1) |eps_b|_// = A (|sigma'_//|^2 + |sigma'_perp|^2)^((n-1)/2) |sigma'_//|
    904          * (2) |sigma'_perp|^2 = |rho g (s-z) grad(s)|^2
    905          *
    906          * Assuming that n = 3, we have a polynom of degree 3 to solve (the only unkown is X=|sigma'_//|)
    907          *
    908          * A X^3 + A |rho g (s-z) grad(s)|^2 X - |eps_b|_// = 0     */
    909 
    910         IssmDouble z,s,viscosity,p,q,delta;
    911         IssmDouble tau_perp,tau_par,eps_b,A;
    912         IssmDouble epsilon[5];   /*exx eyy exy exz eyz*/
    913         IssmDouble slope[3];
    914 
    915         /*Check that both inputs have been found*/
    916         if (!vx_input || !vy_input || !surface_input) _error_("Input missing");
    917 
    918         /*Get tau_perp*/
    919         surface_input->GetInputValue(&s,gauss);
    920         surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
    921         z=this->element->GetZcoord(xyz_list,gauss);
    922         tau_perp = element->FindParam(MaterialsRhoIceEnum) * element->FindParam(ConstantsGEnum) * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
    923 
    924         /* Get eps_b*/
    925         element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
    926         eps_b = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[0]*epsilon[1] + epsilon[2]*epsilon[2]);
    927         if(eps_b==0.){
    928                 *pviscosity = 2.5e+17;
    929                 return;
    930         }
    931 
    932         /*Get A*/
    933         _assert_(this->GetN()==3.0);
    934         A=this->GetA(gauss);
    935 
    936         /*Solve for tau_perp (http://fr.wikipedia.org/wiki/Méthode_de_Cardan)*/
    937         p     = tau_perp *tau_perp;
    938         q     = - eps_b/A;
    939         delta = q *q + p*p*p*4./27.;
    940         _assert_(delta>0);
    941         tau_par = pow(0.5*(-q+sqrt(delta)),1./3.) - pow(0.5*(q+sqrt(delta)),1./3.);
    942 
    943         /*Viscosity*/
    944         viscosity = 1./(2.*A*(tau_par*tau_par + tau_perp*tau_perp));
    945         _assert_(!xIsNan(viscosity));
    946         _assert_(viscosity > 0.);
    947 
    948         /*Assign output pointer*/
    949         *pviscosity = viscosity;
    950 }/*}}}*/
    951 void  Matice::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    952 
    953         /*Intermediaries*/
    954         IssmDouble viscosity;
    955         IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy];    */
    956         IssmDouble epsilon1d;   /* epsilon=[exx];    */
    957         IssmDouble eps_eff;
    958 
    959         if(dim==2){
    960                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy*/
    961                 element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
    962                 eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
    963         }
    964         else{
    965                 /* eps_eff^2 = exx^2*/
    966                 element->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
    967                 eps_eff = fabs(epsilon1d);
    968         }
    969 
    970         /*Get viscosity*/
    971         this->GetViscosityBar(&viscosity,eps_eff,gauss);
    972 
    973         /*Assign output pointer*/
    974         *pviscosity=viscosity;
    975 }/*}}}*/

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

    r24335 r24377  
    7373                void       SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
    7474
    75                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    7675                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    77                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    7876                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    79                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
    80                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    8177                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss);
    82                 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");};
    83                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};
    84                 void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};
    8578
    8679                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);

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

    r24335 r24377  
    6262                void       ResetHooks();
    6363
    64                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
    6564                void       ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
    66                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
    6765                void       ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
    68                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf){_error_("not supported");};
    69                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
    7066                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon,Gauss* gauss){_error_("not supported");};
    71                 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");};
    72                 void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff){_error_("not supported");};
    73                 void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff){_error_("not supported");};
    74 
    7567
    7668                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){_error_("not supported");};

  • issm/trunk-jpl/src/c/classes/Radar.cpp

    r24376 r24377  
    129129
    130130        /*Retrieve all inputs we will be needing: */
    131         Input* temp_input=element->GetInput(TemperatureEnum); _assert_(temp_input);
    132         Input* ice_period_input=element->GetInput(RadarIcePeriodEnum); _assert_(ice_period_input);
     131        Input2* temp_input=element->GetInput2(TemperatureEnum); _assert_(temp_input);
     132        Input2* ice_period_input=element->GetInput2(RadarIcePeriodEnum); _assert_(ice_period_input);
    133133
    134134        /* Start looping on the number of vertices: */
    … …  
    213213        /* Get node coordinates*/
    214214        element->GetVerticesCoordinates(&xyz_list);
    215         Input* atten_input_M07=element->GetInput(RadarAttenuationMacGregorEnum); _assert_(atten_input_M07);
    216         Input* atten_input_W97=element->GetInput(RadarAttenuationWolffEnum); _assert_(atten_input_W97);
    217         Input* surf_input=element->GetInput(SurfaceEnum); _assert_(surf_input);
    218         Input* thick_input=element->GetInput(ThicknessEnum); _assert_(thick_input);
    219         Input* temp_input=element->GetInput(TemperatureEnum); _assert_(temp_input);
     215        Input2 *atten_input_M07 = element->GetInput2(RadarAttenuationMacGregorEnum); _assert_(atten_input_M07);
     216        Input2 *atten_input_W97 = element->GetInput2(RadarAttenuationWolffEnum);    _assert_(atten_input_W97);
     217        Input2 *surf_input      = element->GetInput2(SurfaceEnum);                  _assert_(surf_input);
     218        Input2 *thick_input     = element->GetInput2(ThicknessEnum);                _assert_(thick_input);
     219        Input2 *temp_input      = element->GetInput2(TemperatureEnum);              _assert_(temp_input);
    220220
    221221        /* Start looping on the number of vertices: */
Note: See TracChangeset for help on using the changeset viewer.