Changeset 17926


Ignore:
Timestamp:
05/04/14 21:04:34 (11 years ago)
Author:
Mathieu Morlighem
Message:

DEL: cleaning up unused functions according to cppcheck

Location:
issm/trunk-jpl/src/c
Files:
3 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/Makefile.am

    r17907 r17926  
    319319                                        ./modules/ConfigureObjectsx/ConfigureObjectsx.h\
    320320                                        ./modules/ConfigureObjectsx/ConfigureObjectsx.cpp\
    321                                         ./modules/ComputeBasalStressx/ComputeBasalStressx.h\
    322                                         ./modules/ComputeBasalStressx/ComputeBasalStressx.cpp\
    323                                         ./modules/ComputeStrainRatex/ComputeStrainRatex.h\
    324                                         ./modules/ComputeStrainRatex/ComputeStrainRatex.cpp\
    325321                                        ./modules/SpcNodesx/SpcNodesx.h\
    326322                                        ./modules/SpcNodesx/SpcNodesx.cpp\
    … …  
    839835                        ./modules/ContourToNodesx/ContourToNodesx.cpp\
    840836                        ./modules/ContourToNodesx/ContourToNodesx.h\
    841                         ./modules/Reducevectorgtosx/Reducevectorgtosx.cpp\
    842                         ./modules/Reducevectorgtosx/Reducevectorgtosx.h\
    843837                        ./modules/NodeConnectivityx/NodeConnectivityx.cpp\
    844838                        ./modules/NodeConnectivityx/NodeConnectivityx.h\

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

    r17925 r17926  
    174174
    175175                virtual Element* GetUpperElement(void)=0;
    176                 virtual Element* GetLowerElement(void)=0;
    177                 virtual Element* GetSurfaceElement(void)=0;
    178176                virtual Element* GetBasalElement(void)=0;
    179177
    … …  
    249247                virtual void   ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum)=0;
    250248                virtual void   GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum)=0;
    251                 virtual void   GetNormalFromLSF(IssmDouble *pnormal)=0;
    252249
    253250                virtual void   AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part)=0;

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

    r17925 r17926  
    139139                else _error_("not implemented yet");
    140140        }
    141 }
    142 /*}}}*/
    143 /*FUNCTION Penta::BasalFrictionCreateInput {{{*/
    144 void Penta::BasalFrictionCreateInput(void){
    145 
    146         /*Intermediaries */
    147         int         count;
    148         IssmDouble  basalfriction[NUMVERTICES];
    149         IssmDouble  alpha2                       ,vx,vy;
    150         Friction   *friction                   = NULL;
    151         GaussPenta *gauss                      = NULL;
    152 
    153         /* Basal friction can only be found at the base of an ice sheet: */
    154         if (!IsOnBase() || IsFloating()){
    155                 //empty friction:
    156                 this->inputs->AddInput(new PentaInput(BasalFrictionEnum,&basalfriction[0],P1Enum));
    157                 return;
    158         }
    159 
    160         /*Retrieve all inputs and parameters*/
    161         Input* vx_input=inputs->GetInput(VxEnum);                         _assert_(vx_input);
    162         Input* vy_input=inputs->GetInput(VyEnum);                         _assert_(vy_input);
    163         Input* vz_input=inputs->GetInput(VzEnum);                         _assert_(vz_input);
    164 
    165         /*Build friction element, needed later: */
    166         friction=new Friction(this,3);
    167 
    168         /* Start looping on the number of gauss 2d (nodes on the bedrock) */
    169         gauss=new GaussPenta(0,1,2,2);
    170         count=0;
    171         for(int ig=gauss->begin();ig<gauss->end();ig++){
    172 
    173                 gauss->GaussPoint(ig);
    174 
    175                 friction->GetAlpha2(&alpha2,gauss,vx_input,vy_input,vz_input);
    176                 vx_input->GetInputValue(&vx,gauss);
    177                 vy_input->GetInputValue(&vy,gauss);
    178                 basalfriction[count]=alpha2*(pow(vx,2.0)+pow(vy,2.0));
    179                 count++;
    180         }
    181 
    182         /*Create PentaVertex input, which will hold the basal friction:*/
    183         this->inputs->AddInput(new PentaInput(BasalFrictionEnum,&basalfriction[0],P1Enum));
    184 
    185         /*Clean up and return*/
    186         delete gauss;
    187         delete friction;
    188141}
    189142/*}}}*/
    … …  
    738691        Element* upper_element=this->GetUpperPenta();
    739692        return upper_element;
    740 }
    741 /*}}}*/
    742 /*FUNCTION Penta::GetLowerElement{{{*/
    743 Element* Penta::GetLowerElement(void){
    744 
    745         /*Output*/
    746         Element* lower_element=this->GetLowerPenta();
    747         return lower_element;
    748 }
    749 /*}}}*/
    750 /*FUNCTION Penta::GetSurfaceElement{{{*/
    751 Element* Penta::GetSurfaceElement(void){
    752 
    753         /*Output*/
    754         Element* element=this->GetSurfacePenta();
    755         return element;
    756693}
    757694/*}}}*/

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

    r17925 r17926  
    5252                /*}}}*/
    5353                /*Element virtual functions definitions: {{{*/
    54                 void   BasalFrictionCreateInput(void);
    5554                IssmDouble CharacteristicLength(void){_error_("not implemented yet");};
    5655                void   ComputeBasalStress(Vector<IssmDouble>* sigma_b);
    … …  
    7170                Penta* GetBasalPenta(void);
    7271                Element* GetUpperElement(void);
    73                 Element* GetLowerElement(void);
    74                 Element* GetSurfaceElement(void);
    7572                Element* GetBasalElement(void);
    7673                void   GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);
    … …  
    9592                void   ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum);
    9693                void   GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented yet");};
    97                 void   GetNormalFromLSF(IssmDouble *pnormal){_error_("not implemented yet");};
    9894                void   PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
    9995                void   ReduceMatrices(ElementMatrix* Ke,ElementVector* pe);

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

    r17875 r17926  
    799799}
    800800/*}}}*/
    801 /*FUNCTION PentaRef::GetNodalFunctionsMINI{{{*/
    802 void PentaRef::GetNodalFunctionsMINI(IssmDouble* l1l7, Gauss* gauss_in){
    803         /*This routine returns the values of the nodal functions  at the gaussian point.*/
    804 
    805         /*Cast gauss to GaussPenta*/
    806         _assert_(gauss_in->Enum()==GaussPentaEnum);
    807         GaussPenta* gauss = dynamic_cast<GaussPenta*>(gauss_in);
    808 
    809         l1l7[0]=gauss->coord1*(1.0-gauss->coord4)/2.0;
    810         l1l7[1]=gauss->coord2*(1.0-gauss->coord4)/2.0;
    811         l1l7[2]=gauss->coord3*(1.0-gauss->coord4)/2.0;
    812         l1l7[3]=gauss->coord1*(1.0+gauss->coord4)/2.0;
    813         l1l7[4]=gauss->coord2*(1.0+gauss->coord4)/2.0;
    814         l1l7[5]=gauss->coord3*(1.0+gauss->coord4)/2.0;
    815         l1l7[6]=27*gauss->coord1*gauss->coord2*gauss->coord3*(1.0+gauss->coord4)*(1.0-gauss->coord4);
    816 
    817 }
    818 /*}}}*/
    819801/*FUNCTION PentaRef::GetNodalFunctionsMINIDerivatives{{{*/
    820802void PentaRef::GetNodalFunctionsMINIDerivatives(IssmDouble* dbasismini,IssmDouble* xyz_list, Gauss* gauss){

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

    r17875 r17926  
    2929                void GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,Gauss* gauss,int finiteelement);
    3030                void GetNodalFunctionsP1(IssmDouble* l1l6, Gauss* gauss);
    31                 void GetNodalFunctionsMINI(IssmDouble* l1l7, Gauss* gauss);
    3231                void GetNodalFunctionsP1Derivatives(IssmDouble* dh1dh6,IssmDouble* xyz_list, Gauss* gauss);
    3332                void GetNodalFunctionsMINIDerivatives(IssmDouble* dh1dh7,IssmDouble* xyz_list, Gauss* gauss);

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

    r17925 r17926  
    6666                int         FiniteElement(void);
    6767                Element*    GetUpperElement(void){_error_("not implemented yet");};
    68                 Element*    GetLowerElement(void){_error_("not implemented yet");};
    69                 Element*    GetSurfaceElement(void){_error_("not implemented yet");};
    7068                Element*    GetBasalElement(void){_error_("not implemented yet");};
    7169                int         GetNodeIndex(Node* node){_error_("not implemented yet");};
    … …  
    127125                void        ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented");};
    128126                void               GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
    129                 void        GetNormalFromLSF(IssmDouble *pnormal){_error_("not implemented yet");};
    130127
    131128                void        GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type){_error_("not implemented yet");};

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

    r17874 r17926  
    4949
    5050/*Reference Element numerics*/
    51 /*FUNCTION SegRef::GetBprimeMasstransport{{{*/
    52 void SegRef::GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussSeg* gauss){
    53         /*Compute B'  matrix. B'=[B1' B2' B3'] where Bi' is of size 3*NDOF2.
    54          * For node i, Bi' can be expressed in the actual coordinate system
    55          * by:
    56          *       Bi_prime=[ dN/dx ]
    57          * where N is the finiteelement function for node i.
    58          *
    59          * We assume B' has been allocated already, of size: 3x(NDOF2*numnodes)
    60          */
    61 
    62         /*Fetch number of nodes for this finite element*/
    63         int numnodes = this->NumberofNodes();
    64 
    65         /*Get nodal functions derivatives*/
    66         IssmDouble* dbasis=xNew<IssmDouble>(2*numnodes);
    67         GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    68 
    69         /*Build B': */
    70         for(int i=0;i<numnodes;i++){
    71                 Bprime[i] = dbasis[i];
    72         }
    73 
    74         /*Clean-up*/
    75         xDelete<IssmDouble>(dbasis);
    76 }
    77 /*}}}*/
    7851/*FUNCTION SegRef::GetNodalFunctions(IssmDouble* basis,GaussSeg* gauss){{{*/
    7952void SegRef::GetNodalFunctions(IssmDouble* basis,GaussSeg* gauss){

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

    r16434 r17926  
    2222                /*Management*/
    2323                void SetElementType(int type,int type_counter);
    24                 void GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussSeg* gauss);
    2524                void GetJacobian(IssmDouble* J, IssmDouble* xyz_list,GaussSeg* gauss);
    2625                void GetJacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,GaussSeg* gauss);

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

    r17925 r17926  
    6969                int         FiniteElement(void);
    7070                Element*    GetUpperElement(void){_error_("not implemented yet");};
    71                 Element*    GetLowerElement(void){_error_("not implemented yet");};
    72                 Element*    GetSurfaceElement(void){_error_("not implemented yet");};
    7371                Element*    GetBasalElement(void){_error_("not implemented yet");};
    7472                int         GetNodeIndex(Node* node);
    … …  
    132130                void        ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum);
    133131                void               GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented yet");};
    134                 void        GetNormalFromLSF(IssmDouble *pnormal){_error_("not implemented yet");};
    135 
    136132                void        GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type){_error_("not implemented yet");};
    137133                void        InputDepthAverageAtBase(int enum_type,int average_enum_type){_error_("not implemented yet");};

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

    r17875 r17926  
    2222                /*Management*/
    2323                void SetElementType(int type,int type_counter);
    24                 void GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTetra* gauss);
    2524                void GetJacobian(IssmDouble* J, IssmDouble* xyz_list,GaussTetra* gauss);
    2625                void GetJacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,GaussTetra* gauss);

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

    r17925 r17926  
    913913
    914914        xDelete<int>(indicesfront);
    915 }/*}}}*/
    916 void  Tria::GetNormalFromLSF(IssmDouble *pnormal){/*{{{*/
    917 
    918         /* Intermediaries */
    919         int         i;
    920         const int   dim=2;
    921         IssmDouble* xyz_list = NULL;
    922         IssmDouble  dlevelset[dim], norm_dlevelset;
    923         IssmDouble  normal[dim]={0.};
    924 
    925         /*Retrieve all inputs and parameters*/
    926         Input* levelset_input=this->GetInput(MaskIceLevelsetEnum); _assert_(levelset_input);
    927         this->GetVerticesCoordinates(&xyz_list);
    928        
    929         IssmDouble counter=0.;
    930         Gauss* gauss = this->NewGauss(2);
    931         for(int ig=gauss->begin();ig<gauss->end();ig++){
    932                 /* Get normal on node */
    933                 levelset_input->GetInputDerivativeValue(&dlevelset[0],xyz_list,gauss);
    934                 norm_dlevelset=0.;
    935                 for(i=0;i<dim;i++) norm_dlevelset+=dlevelset[i]*dlevelset[i];
    936                 norm_dlevelset=sqrt(norm_dlevelset)+1.e-14;
    937                 for(i=0;i<dim;i++) normal[i]+=dlevelset[i]/norm_dlevelset;
    938                 counter++;
    939         }
    940         _assert_(counter>0.);
    941         for(i=0;i<dim;i++) normal[i] = normal[i]/counter;
    942        
    943         pnormal=&normal[0];
    944 
    945         delete gauss;
    946         xDelete<IssmDouble>(xyz_list);
    947915}/*}}}*/
    948916/*FUNCTION Tria::GetNodeIndex {{{*/

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

    r17925 r17926  
    6565                int         FiniteElement(void);
    6666                Element*    GetUpperElement(void){_error_("not implemented yet");};
    67                 Element*    GetLowerElement(void){_error_("not implemented yet");};
    68                 Element*    GetSurfaceElement(void){_error_("not implemented yet");};
    6967                Element*    GetBasalElement(void){_error_("not implemented yet");};
    7068                void        GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);
    … …  
    110108                void        ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum);
    111109                void        GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
    112             void        GetNormalFromLSF(IssmDouble *pnormal);
    113110                bool        IsZeroLevelset(int levelset_enum);
    114111                bool            IsIcefront(void);

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

    r17759 r17926  
    3030                virtual void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon)=0;
    3131                virtual void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon)=0;
    32                 virtual void       GetViscosityDerivativeEpsSquareFS(IssmDouble* pmu_prime, IssmDouble* pepsilon)=0;
    3332                virtual void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon)=0;
    3433                virtual IssmDouble GetA()=0;

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

    r17833 r17926  
    485485}
    486486/*}}}*/
    487 /*FUNCTION Matice::GetViscosityDerivativeEpsSquareFS{{{*/
    488 void  Matice::GetViscosityDerivativeEpsSquareFS(IssmDouble* pmu_prime, IssmDouble* epsilon){
    489 
    490         /*output: */
    491         IssmDouble mu_prime;
    492         IssmDouble mu,n,eff2;
    493 
    494         /*input strain rate: */
    495         IssmDouble exx,eyy,exy,exz,eyz,ezz;
    496 
    497         if((epsilon[0]==0) && (epsilon[1]==0) && (epsilon[2]==0) &&
    498                                 (epsilon[3]==0) && (epsilon[4]==0) && (epsilon[5]==0)){
    499                 mu_prime=0.5*pow(10.,14);
    500         }
    501         else{
    502                 /*Retrive strain rate components: */
    503                 exx=epsilon[0];
    504                 eyy=epsilon[1];
    505                 ezz=epsilon[2];
    506                 exy=epsilon[3];
    507                 exz=epsilon[4];
    508                 eyz=epsilon[5];
    509                 eff2 = exx*exx + eyy*eyy + exx*eyy + exy*exy + exz*exz + eyz*eyz;
    510 
    511                 GetViscosity(&mu,sqrt(eff2));
    512                 n=GetN();
    513                 mu_prime=(1-n)/(2*n) * mu/eff2;
    514         }
    515 
    516         /*Assign output pointers:*/
    517         *pmu_prime=mu_prime;
    518 }
    519 /*}}}*/
    520487/*FUNCTION Matice::GetViscosity2dDerivativeEpsSquare{{{*/
    521488void  Matice::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){

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

    r17759 r17926  
    5959                void       GetViscosityDComplement(IssmDouble*, IssmDouble*);
    6060                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
    61                 void       GetViscosityDerivativeEpsSquareFS(IssmDouble* pmu_prime, IssmDouble* pepsilon);
    6261                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
    6362                IssmDouble GetA();

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

    r17924 r17926  
    276276}
    277277/*}}}*/
    278 /*FUNCTION Matpar::GetHeatCapacity {{{*/
    279 IssmDouble Matpar::GetHeatCapacity(){
    280         return heatcapacity;
    281 }
    282 /*}}}*/
    283 /*FUNCTION Matpar::GetLatentHeat {{{*/
    284 IssmDouble Matpar::GetLatentHeat(){
    285         return latentheat;
    286 }
    287 /*}}}*/
    288278/*FUNCTION Matpar::GetMeltingPoint {{{*/
    289279IssmDouble Matpar::GetMeltingPoint(){
    … …  
    291281}
    292282/*}}}*/
    293 /*FUNCTION Matpar::GetReferenceTemperature {{{*/
    294 IssmDouble Matpar::GetReferenceTemperature(){
    295         return referencetemperature;
    296 }
    297 /*}}}*/
    298 /*FUNCTION Matpar::GetMixedLayerCapacity {{{*/
    299 IssmDouble Matpar::GetMixedLayerCapacity(){
    300         return mixed_layer_capacity;
    301 }
    302 /*}}}*/
    303283/*FUNCTION Matpar::GetRhoIce {{{*/
    304284IssmDouble Matpar::GetRhoIce(){
    … …  
    317297}
    318298/*}}}*/
    319 /*FUNCTION Matpar::GetMuWater {{{*/
    320 IssmDouble Matpar::GetMuWater(){
    321         return mu_water;
    322 }
    323 /*}}}*/
    324299/*FUNCTION Matpar::GetDesFac {{{*/
    325300IssmDouble Matpar::GetDesFac(){
    … …  
    332307}
    333308/*}}}*/
    334 /*FUNCTION Matpar::GetThermalConductivity {{{*/
    335 IssmDouble Matpar::GetThermalConductivity(){
    336         return thermalconductivity;
    337 }
    338 /*}}}*/
    339 /*FUNCTION Matpar::GetTemperateIceConductivity {{{*/
    340 IssmDouble Matpar::GetTemperateIceConductivity(){
    341         return temperateiceconductivity;
    342 }
    343 /*}}}*/
    344 /*FUNCTION Matpar::GetThermalExchangeVelocity {{{*/
    345 IssmDouble Matpar::GetThermalExchangeVelocity(){
    346         return thermal_exchange_velocity;
    347 }
    348 /*}}}*/
    349 /*FUNCTION Matpar::GetSedimentStoring {{{*/
    350 IssmDouble Matpar::GetSedimentStoring(){
    351         return this->rho_freshwater * this->g * this->sediment_porosity * this->sediment_thickness *
    352     (this->water_compressibility + (this->sediment_compressibility / this->sediment_porosity));         
    353 }               
    354 /*}}}*/
    355 /*FUNCTION Matpar::GetEplSpecificStoring {{{*/
    356 IssmDouble Matpar::GetEplSpecificStoring(){
    357         return this->rho_freshwater * this->g * this->epl_porosity *
    358     (this->water_compressibility + (this->epl_compressibility / this->epl_porosity));           
    359 }                       
    360 /*}}}*/
    361 /*FUNCTION Matpar::GetSedimentThickness {{{*/
    362 IssmDouble Matpar::GetSedimentThickness(){
    363         return sediment_thickness;               
    364 }               
    365 /*}}}*/
    366 /*FUNCTION Matpar::GetEplInitialThickness {{{*/
    367 IssmDouble Matpar::GetEplInitialThickness(){
    368         return epl_init_thickness;               
    369 }               
    370 /*}}}*/
    371 /*FUNCTION Matpar::GetEplMaxThickness {{{*/
    372 IssmDouble Matpar::GetEplMaxThickness(){
    373         return epl_max_thickness;               
    374 }               
    375 /*}}}*/
    376 /*FUNCTION Matpar::GetEplConductivity {{{*/
    377 IssmDouble Matpar::GetEplConductivity(){
    378         return epl_conductivity;                 
    379 }               
    380 /*}}}*/                 
    381309/*FUNCTION Matpar::TMeltingPoint {{{*/
    382310IssmDouble Matpar::TMeltingPoint(IssmDouble pressure){

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

    r17884 r17926  
    8080                void       GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon){_error_("not supported");};
    8181                void       GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
    82                 void       GetViscosityDerivativeEpsSquareFS(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
    8382                void       GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon){_error_("not supported");};
    8483                IssmDouble GetA(){_error_("not supported");};
    … …  
    9695                IssmDouble GetRhoWater();
    9796                IssmDouble GetRhoFreshwater();
    98                 IssmDouble GetMuWater();
    99                 IssmDouble GetMixedLayerCapacity();
    100                 IssmDouble GetThermalExchangeVelocity();
    101                 IssmDouble GetHeatCapacity();
    102                 IssmDouble GetThermalConductivity();
    103                 IssmDouble GetTemperateIceConductivity();
    104                 IssmDouble GetLatentHeat();
    10597                IssmDouble GetBeta();
    10698                IssmDouble GetMeltingPoint();
    107                 IssmDouble GetReferenceTemperature();
    108                 IssmDouble GetSedimentStoring();
    109                 IssmDouble GetEplSpecificStoring();
    110                 IssmDouble GetSedimentThickness();
    111                 IssmDouble GetEplConductivity();
    112                 IssmDouble GetEplInitialThickness();
    113                 IssmDouble GetEplMaxThickness();
    11499                IssmDouble TMeltingPoint(IssmDouble pressure);
    115100                IssmDouble PureIceEnthalpy(IssmDouble pressure);

  • issm/trunk-jpl/src/c/modules/modules.h

    r17862 r17926  
    1414#include "./BamgTriangulatex/BamgTriangulatex.h"
    1515#include "./Chacox/Chacox.h"
    16 #include "./ComputeBasalStressx/ComputeBasalStressx.h"
    17 #include "./ComputeStrainRatex/ComputeStrainRatex.h"
    1816#include "./ConfigureObjectsx/ConfigureObjectsx.h"
    1917#include "./ContourToMeshx/ContourToMeshx.h"
    … …  
    7977#include "./PropagateFlagsFromConnectivityx/PropagateFlagsFromConnectivityx.h"
    8078#include "./Reduceloadx/Reduceloadx.h"
    81 #include "./Reducevectorgtosx/Reducevectorgtosx.h"
    8279#include "./Reducevectorgtofx/Reducevectorgtofx.h"
    8380#include "./ResetConstraintsx/ResetConstraintsx.h"
Note: See TracChangeset for help on using the changeset viewer.