Changeset 16810


Ignore:
Timestamp:
11/16/13 21:18:41 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: done with thermal shelf

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

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp

    r16782 r16810  
    7676}/*}}}*/
    7777ElementVector* MeltingAnalysis::CreatePVector(Element* element){/*{{{*/
    78 _error_("not implemented yet");
     78        return NULL;
    7979}/*}}}*/
    8080void MeltingAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/

  • issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp

    r16782 r16810  
    116116}/*}}}*/
    117117ElementVector* ThermalAnalysis::CreatePVector(Element* element){/*{{{*/
    118 _error_("not implemented yet");
     118
     119        /*compute all load vectors for this element*/
     120        ElementVector* pe1=CreatePVectorVolume(element);
     121        ElementVector* pe2=CreatePVectorSheet(element);
     122        ElementVector* pe3=CreatePVectorShelf(element);
     123        ElementVector* pe =new ElementVector(pe1,pe2,pe3);
     124
     125        /*clean-up and return*/
     126        delete pe1;
     127        delete pe2;
     128        delete pe3;
     129        return pe;
     130}/*}}}*/
     131ElementVector* ThermalAnalysis::CreatePVectorVolume(Element* element){/*{{{*/
     132
     133        /*Intermediaries*/
     134        int         stabilization;
     135        IssmDouble  Jdet,phi,dt;
     136        IssmDouble  temperature;
     137        IssmDouble  tau_parameter,diameter;
     138        IssmDouble  u,v,w;
     139        IssmDouble  scalar_def,scalar_transient;
     140        IssmDouble* xyz_list = NULL;
     141
     142        /*Fetch number of nodes and dof for this finite element*/
     143        int numnodes = element->GetNumberOfNodes();
     144
     145        /*Initialize Element vector*/
     146        ElementVector* pe     = element->NewElementVector();
     147        IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
     148        IssmDouble*    dbasis = xNew<IssmDouble>(3*numnodes);
     149
     150        /*Retrieve all inputs and parameters*/
     151        element->GetVerticesCoordinates(&xyz_list);
     152        IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
     153        IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
     154        IssmDouble  thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     155        IssmDouble  kappa = thermalconductivity/(rho_ice*heatcapacity);
     156        element->FindParam(&dt,TimesteppingTimeStepEnum);
     157        element->FindParam(&stabilization,ThermalStabilizationEnum);
     158        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
     159        Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
     160        Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     161        Input* temperature_input = NULL;
     162        if(reCast<bool,IssmDouble>(dt)){temperature_input = element->GetInput(TemperatureEnum); _assert_(temperature_input);}
     163        if(stabilization==2) diameter=element->MinEdgeLength(xyz_list);
     164
     165        /* Start  looping on the number of gaussian points: */
     166        Gauss* gauss=element->NewGauss(3);
     167        for(int ig=gauss->begin();ig<gauss->end();ig++){
     168                gauss->GaussPoint(ig);
     169
     170                element->JacobianDeterminant(&Jdet,xyz_list,gauss);
     171                element->NodalFunctions(basis,gauss);
     172                element->ViscousHeating(&phi,xyz_list,gauss,vx_input,vy_input,vz_input);
     173
     174                scalar_def=phi/(rho_ice*heatcapacity)*Jdet*gauss->weight;
     175                if(reCast<bool,IssmDouble>(dt)) scalar_def=scalar_def*dt;
     176
     177                for(int i=0;i<numnodes;i++) pe->values[i]+=scalar_def*basis[i];
     178
     179                /* Build transient now */
     180                if(reCast<bool,IssmDouble>(dt)){
     181                        temperature_input->GetInputValue(&temperature, gauss);
     182                        scalar_transient=temperature*Jdet*gauss->weight;
     183                        for(int i=0;i<numnodes;i++) pe->values[i]+=scalar_transient*basis[i];
     184                }
     185
     186                if(stabilization==2){
     187                        element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     188
     189                        vx_input->GetInputValue(&u,gauss);
     190                        vy_input->GetInputValue(&v,gauss);
     191                        vz_input->GetInputValue(&w,gauss);
     192
     193                        tau_parameter=element->StabilizationParameter(u,v,w,diameter,kappa);
     194
     195                        for(int i=0;i<numnodes;i++) pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0*3+i]+v*dbasis[1*3+i]+w*dbasis[2*3+i]);
     196                        if(reCast<bool,IssmDouble>(dt)){
     197                                for(int i=0;i<numnodes;i++) pe->values[i]+=tau_parameter*scalar_transient*(u*dbasis[0*3+i]+v*dbasis[1*3+i]+w*dbasis[2*3+i]);
     198                        }
     199                }
     200        }
     201
     202        /*Clean up and return*/
     203        xDelete<IssmDouble>(basis);
     204        xDelete<IssmDouble>(dbasis);
     205        xDelete<IssmDouble>(xyz_list);
     206        delete gauss;
     207        return pe;
     208
     209}/*}}}*/
     210ElementVector* ThermalAnalysis::CreatePVectorSheet(Element* element){/*{{{*/
     211        return NULL;
     212}/*}}}*/
     213ElementVector* ThermalAnalysis::CreatePVectorShelf(Element* element){/*{{{*/
     214
     215        IssmDouble  t_pmp,dt,Jdet,scalar_ocean,pressure;
     216        IssmDouble *xyz_list_base = NULL;
     217
     218        /*Get basal element*/
     219        if(!element->IsOnBed() || !element->IsFloating()) return NULL;
     220
     221        /*Fetch number of nodes for this finite element*/
     222        int numnodes = element->GetNumberOfNodes();
     223
     224        /*Initialize vectors*/
     225        ElementVector* pe    = element->NewElementVector();
     226        IssmDouble*    basis = xNew<IssmDouble>(numnodes);
     227
     228        /*Retrieve all inputs and parameters*/
     229        element->GetVerticesCoordinatesBase(&xyz_list_base);
     230        element->FindParam(&dt,TimesteppingTimeStepEnum);
     231        Input*      pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
     232        IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
     233        IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoWaterEnum);
     234        IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
     235        IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
     236        IssmDouble  mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
     237        IssmDouble  thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
     238
     239        /* Start  looping on the number of gaussian points: */
     240        Gauss* gauss=element->NewGaussBase(2);
     241        for(int ig=gauss->begin();ig<gauss->end();ig++){
     242                gauss->GaussPoint(ig);
     243
     244                element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss);
     245                element->NodalFunctions(basis,gauss);
     246
     247                pressure_input->GetInputValue(&pressure,gauss);
     248                t_pmp=element->TMeltingPoint(pressure);
     249
     250                scalar_ocean=gauss->weight*Jdet*rho_water*mixed_layer_capacity*thermal_exchange_vel*(t_pmp)/(heatcapacity*rho_ice);
     251                if(reCast<bool,IssmDouble>(dt)) scalar_ocean=dt*scalar_ocean;
     252
     253                for(int i=0;i<numnodes;i++) pe->values[i]+=scalar_ocean*basis[i];
     254        }
     255
     256        /*Clean up and return*/
     257        delete gauss;
     258        xDelete<IssmDouble>(basis);
     259        xDelete<IssmDouble>(xyz_list_base);
     260        return pe;
    119261}/*}}}*/
    120262void ThermalAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/

  • issm/trunk-jpl/src/c/analyses/ThermalAnalysis.h

    r16782 r16810  
    2323                ElementMatrix* CreateKMatrix(Element* element);
    2424                ElementVector* CreatePVector(Element* element);
     25                ElementVector* CreatePVectorVolume(Element* element);
     26                ElementVector* CreatePVectorSheet(Element* element);
     27                ElementVector* CreatePVectorShelf(Element* element);
    2528                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2629                void InputUpdateFromSolution(IssmDouble* solution,Element* element);

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

    r16807 r16810  
    5353                virtual int    FiniteElement(void)=0;
    5454                virtual IssmDouble GetMaterialParameter(int enum_in)=0;
     55                virtual IssmDouble MinEdgeLength(IssmDouble* xyz_list)=0;
    5556                virtual void   NodalFunctions(IssmDouble* basis,Gauss* gauss)=0;
     57                virtual void   NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss)=0;
    5658                virtual void   NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss)=0;
    5759                virtual void   NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss)=0;
    … …  
    127129                virtual void   ReduceMatrices(ElementMatrix* Ke,ElementVector* pe)=0;
    128130                virtual void   ResetCoordinateSystem()=0;
     131                virtual IssmDouble StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa)=0;
     132                virtual void   ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
    129133                virtual int    VelocityInterpolation()=0;
    130134                virtual int    PressureInterpolation()=0;

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

    r16807 r16810  
    15281528}
    15291529/*}}}*/
    1530 /*FUNCTION Penta::GetStabilizationParameter {{{*/
    1531 IssmDouble Penta::GetStabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){
     1530/*FUNCTION Penta::StabilizationParameter {{{*/
     1531IssmDouble Penta::StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){
    15321532        /*Compute stabilization parameter*/
    15331533        /*kappa=thermalconductivity/(rho_ice*hearcapacity) for thermal model*/
    … …  
    24652465/*}}}*/
    24662466/*FUNCTION Penta::MinEdgeLength{{{*/
    2467 IssmDouble Penta::MinEdgeLength(IssmDouble xyz_list[6][3]){
     2467IssmDouble Penta::MinEdgeLength(IssmDouble* xyz_list){
    24682468        /*Return the minimum lenght of the nine egdes of the penta*/
    24692469
    … …  
    24792479
    24802480                /*Compute the length of this edge and compare it to the minimal length*/
    2481                 length=sqrt(pow(xyz_list[node0][0]-xyz_list[node1][0],2)+pow(xyz_list[node0][1]-xyz_list[node1][1],2)+pow(xyz_list[node0][2]-xyz_list[node1][2],2));
     2481                length=sqrt(pow(xyz_list[node0*3+0]-xyz_list[node1*3+0],2)+pow(xyz_list[node0*3+1]-xyz_list[node1*3+1],2)+pow(xyz_list[node0*3+2]-xyz_list[node1*3+2],2));
    24822482                if(length<minlength || minlength<0) minlength=length;
    24832483        }
    … …  
    25432543        _assert_(gauss->Enum()==GaussPentaEnum);
    25442544        this->GetNodalFunctions(basis,(GaussPenta*)gauss);
     2545
     2546}
     2547/*}}}*/
     2548/*FUNCTION Penta::NodalFunctionsDerivatives{{{*/
     2549void Penta::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
     2550
     2551        _assert_(gauss->Enum()==GaussPentaEnum);
     2552        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussPenta*)gauss);
    25452553
    25462554}
    … …  
    33793387}
    33803388/*}}}*/
     3389/*FUNCTION Penta::ViscousHeating{{{*/
     3390void Penta::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){
     3391
     3392        /*Intermediaries*/
     3393        IssmDouble phi;
     3394        IssmDouble viscosity;
     3395        IssmDouble epsilon[6];
     3396
     3397        _assert_(gauss->Enum()==GaussPentaEnum);
     3398        this->GetStrainRate3d(&epsilon[0],xyz_list,(GaussPenta*)gauss,vx_input,vy_input,vz_input);
     3399        material->GetViscosity3dFS(&viscosity,&epsilon[0]);
     3400        GetPhi(&phi,&epsilon[0],viscosity);
     3401
     3402        /*Assign output pointer*/
     3403        *pphi = phi;
     3404}
     3405/*}}}*/
    33813406/*FUNCTION Penta::VelocityInterpolation{{{*/
    33823407int Penta::VelocityInterpolation(void){
    … …  
    37423767        Input* vym_input=inputs->GetInput(VyMeshEnum);             _assert_(vym_input);
    37433768        Input* vzm_input=inputs->GetInput(VzMeshEnum);             _assert_(vzm_input);
    3744         if (stabilization==2) diameter=MinEdgeLength(xyz_list);
     3769        if (stabilization==2) diameter=MinEdgeLength(&xyz_list[0][0]);
    37453770
    37463771        /* Start  looping on the number of gaussian points: */
    … …  
    38253850                else if(stabilization==2){
    38263851                        GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    3827                         tau_parameter=GetStabilizationParameter(u-um,v-vm,w-wm,diameter,kappa/rho_ice);
     3852                        tau_parameter=StabilizationParameter(u-um,v-vm,w-wm,diameter,kappa/rho_ice);
    38283853
    38293854                        for(i=0;i<numdof;i++){
    … …  
    39733998        Input* vym_input=inputs->GetInput(VyMeshEnum); _assert_(vym_input);
    39743999        Input* vzm_input=inputs->GetInput(VzMeshEnum); _assert_(vzm_input);
    3975         if (stabilization==2) diameter=MinEdgeLength(xyz_list);
     4000        if (stabilization==2) diameter=MinEdgeLength(&xyz_list[0][0]);
    39764001
    39774002        /* Start  looping on the number of gaussian points: */
    … …  
    40544079                else if(stabilization==2){
    40554080                        GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    4056                         tau_parameter=GetStabilizationParameter(u-um,v-vm,w-wm,diameter,kappa);
     4081                        tau_parameter=StabilizationParameter(u-um,v-vm,w-wm,diameter,kappa);
    40574082
    40584083                        for(i=0;i<numdof;i++){
    … …  
    41884213        }
    41894214        if (stabilization==2){
    4190                 diameter=MinEdgeLength(xyz_list);
     4215                diameter=MinEdgeLength(&xyz_list[0][0]);
    41914216        }
    41924217
    … …  
    42274252                        kappa=matpar->GetEnthalpyDiffusionParameterVolume(enthalpypicard,pressure_p);
    42284253                        kappa/=rho_ice;
    4229                         tau_parameter=GetStabilizationParameter(u,v,w,diameter,kappa);
     4254                        tau_parameter=StabilizationParameter(u,v,w,diameter,kappa);
    42304255
    42314256                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    … …  
    44594484        Input* temperature_input=NULL;
    44604485        if(reCast<bool,IssmDouble>(dt)) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
    4461         if(stabilization==2) diameter=MinEdgeLength(xyz_list);
     4486        if(stabilization==2) diameter=MinEdgeLength(&xyz_list[0][0]);
    44624487
    44634488        /* Start  looping on the number of gaussian points: */
    … …  
    44934518                        vz_input->GetInputValue(&w, gauss);
    44944519
    4495                         tau_parameter=GetStabilizationParameter(u,v,w,diameter,kappa);
     4520                        tau_parameter=StabilizationParameter(u,v,w,diameter,kappa);
    44964521
    44974522                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
    … …  
    76157640        /*Find minimal length and B*/
    76167641        rigidity=material->GetB();
    7617         diameter=MinEdgeLength(xyz_list);
     7642        diameter=MinEdgeLength(&xyz_list[0][0]);
    76187643
    76197644                gauss=new GaussPenta();
    … …  
    87568781
    87578782        /*Find minimal length*/
    8758         diameter=MinEdgeLength(xyz_list);
     8783        diameter=MinEdgeLength(&xyz_list[0][0]);
    87598784
    87608785                gauss=new GaussPenta();

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

    r16807 r16810  
    124124                IssmDouble TimeAdapt();
    125125                void   ViscousHeatingCreateInput(void);
     126                void   ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    126127
    127128                 #ifdef _HAVE_RESPONSES_
    … …  
    224225                void             GetPhi(IssmDouble* phi, IssmDouble*  epsilon, IssmDouble viscosity);
    225226                void           GetQuadNormal(IssmDouble* normal,IssmDouble xyz_list[4][3]);
    226                 IssmDouble     GetStabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa);
    227227                void           GetStrainRate3dHO(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input);
    228228                void           GetStrainRate3d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input, Input* vz_input);
    … …  
    247247                ElementVector* NewElementVector(int approximation_enum);
    248248                void           NodalFunctions(IssmDouble* basis,Gauss* gauss);
     249                void           NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);
    249250                void           NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss);
    250251                void           NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss);
    251                 IssmDouble     MinEdgeLength(IssmDouble xyz_list[6][3]);
     252                IssmDouble     MinEdgeLength(IssmDouble* xyz_list);
    252253                void             SetClone(int* minranks);
    253254                Tria*            SpawnTria(int location);
    254255                void             SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
     256                IssmDouble     StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa);
    255257                void           TransformLoadVectorCoord(ElementVector* pe,int transformenum);
    256258                void           TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list);

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

    r16807 r16810  
    110110                void        JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    111111                void        JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss){_error_("not implemented yet");};
     112                IssmDouble  MinEdgeLength(IssmDouble* xyz_list){_error_("not implemented yet");};
    112113                void        NodalFunctions(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    113114                void        NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    114115                void        NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
     116                void        NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    115117                bool        NoIceInElement(){_error_("not implemented yet");};
    116118                void        NormalBase(IssmDouble* normal,IssmDouble* xyz_list){_error_("not implemented yet");};
    … …  
    118120                int         NumberofNodesPressure(void){_error_("not implemented yet");};
    119121           Element*    SpawnBasalElement(void){_error_("not implemented yet");};
     122                IssmDouble  StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){_error_("not implemented yet");};
    120123                int         PressureInterpolation(void){_error_("not implemented yet");};
    121124                int         VelocityInterpolation(void){_error_("not implemented yet");};
    … …  
    132135                Gauss*      NewGaussBase(int order){_error_("not implemented yet");};
    133136                ElementVector* NewElementVector(int approximation_enum){_error_("not implemented yet");};
     137                void           ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not implemented yet");};
    134138                #ifdef _HAVE_THERMAL_
    135139                void UpdateBasalConstraintsEnthalpy(void){_error_("not implemented yet");};

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

    r16809 r16810  
    22132213        _assert_(gauss->Enum()==GaussTriaEnum);
    22142214        this->GetNodalFunctions(basis,(GaussTria*)gauss);
     2215
     2216}
     2217/*}}}*/
     2218/*FUNCTION Tria::NodalFunctionsDerivatives{{{*/
     2219void Tria::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
     2220
     2221        _assert_(gauss->Enum()==GaussTriaEnum);
     2222        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussTria*)gauss);
    22152223
    22162224}

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

    r16807 r16810  
    269269                void           JacobianDeterminant(IssmDouble*  pJdet, IssmDouble* xyz_list,Gauss* gauss);
    270270                void           JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss){_error_("not implemented yet");};
     271                IssmDouble     MinEdgeLength(IssmDouble* xyz_list){_error_("not implemented yet");};
    271272                Gauss*         NewGauss(void);
    272273                Gauss*         NewGauss(int order);
    … …  
    274275                ElementVector* NewElementVector(int approximation_enum);
    275276                void           NodalFunctions(IssmDouble* basis,Gauss* gauss);
     277                void           NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);
    276278                void           NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss);
    277279                void           NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss);
    278280                void             SetClone(int* minranks);
    279281                Seg*             SpawnSeg(int index1,int index2);
     282                IssmDouble     StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){_error_("not implemented yet");};
    280283                void             SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
    281284                void           TransformLoadVectorCoord(ElementVector* pe,int transformenum);
    … …  
    287290                void           TransformSolutionCoord(IssmDouble* values,int numnodes,int transformenum){_error_("not implemented yet");};
    288291                void           TransformSolutionCoord(IssmDouble* values,int numnodes,int* transformenum_list){_error_("not implemented yet");};
     292                void           ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not implemented yet");};
    289293                #ifdef _HAVE_STRESSBALANCE_
    290294                ElementMatrix* CreateKMatrixStressbalanceSSA(void);
Note: See TracChangeset for help on using the changeset viewer.