doxygen/chtml/Tria_8h_source.html

#ifndef _TRIA_H_

#define _TRIA_H_


/*Headers:*/

/*{{{*/

#include "./Element.h"

#include "./ElementHook.h"

#include "./TriaRef.h"

class Parameters;

class Inputs;

class IoModel;

class Results;

class Node;

class Material;

class Seg;

class ElementMatrix;

class ElementVector;

class Vertex;

class GaussTria;


#include "../../shared/Exceptions/exceptions.h"

#include "../../shared/Enum/Enum.h"

/*}}}*/


class Tria: public Element,public ElementHook,public TriaRef{


   public:

      int iscollapsed;


      /*Tria constructors, destructors {{{*/

      Tria(){};

      Tria(int tria_id,int tria_sid,int tria_lid,IoModel* iomodel,int nummodels);

      ~Tria();

      /*}}}*/

      /*Object virtual functions definitions:{{{ */

      Object *copy();

      void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);

      int     ObjectEnum();

      /*}}}*/

      /*Update virtual functions resolution: {{{*/

      #ifdef _HAVE_DAKOTA_

      void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type);

      void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);

      #endif

      void  InputUpdateFromIoModel(int index, IoModel* iomodel);

      void  InputUpdateFromVector(IssmDouble* vector, int name, int type);

      /*}}}*/

      /*Element virtual functions definitions: {{{*/

      void        AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);

      void        CalvingRateVonmises();

      void        CalvingCrevasseDepth();

      void        CalvingRateLevermann();

      void        CalvingFluxLevelset();

      void        CalvingMeltingFluxLevelset();

      IssmDouble  CharacteristicLength(void);

      void        ComputeBasalStress(void);

      void        ComputeDeviatoricStressTensor();

      void        ComputeEsaStrainAndVorticity();

      void        ComputeSigmaNN();

      void        ComputeStressTensor();

      void        ComputeSurfaceNormalVelocity();

      void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters,Inputs2* inputs2in);

      void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N, int M);

      void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);

      void        ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum);

      void        CreateDistanceInputFromSegmentlist(IssmDouble* distances,int distanceenum);

      int         EdgeOnBaseIndex();

      void        EdgeOnBaseIndices(int* pindex1,int* pindex);

      int         EdgeOnSurfaceIndex();

      void        EdgeOnSurfaceIndices(int* pindex1,int* pindex);

      void        ElementResponse(IssmDouble* presponse,int response_enum);

      void        ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);

      int         FiniteElement(void);

      IssmDouble  FloatingArea(bool scaled);

      void        FSContactMigration(Vector<IssmDouble>* vertex_sigmann,Vector<IssmDouble>* vertex_waterpressure);

      Element*    GetBasalElement(void){_error_("not implemented yet");};

      void        GetLevelsetPositivePart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlynegative,IssmDouble* levelsetvalues);

      void        GetGroundedPart(int* point1,IssmDouble* fraction1, IssmDouble* fraction2,bool* mainlyfloating);

      IssmDouble  GetGroundedPortion(IssmDouble* xyz_list);

      IssmDouble  GetIcefrontArea();

      void        GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);

      void        GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value);

      void        GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value);

      void        GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level);

      int         GetVertexIndex(Vertex* vertex);

      int         GetNumberOfNodes(void);

      int         GetNumberOfNodes(int enum_type);

      int         GetNumberOfVertices(void);

      void        GetVectorFromControlInputs(Vector<IssmDouble>* gradient,int control_enum,int control_index,const char* data,int offset);

      void        GetVectorFromControlInputs(Vector<IssmDouble>* gradient,int control_enum,int control_index,const char* data);

      void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);

      void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);

      IssmDouble  GroundedArea(bool scaled);

      bool        HasEdgeOnBase();

      bool        HasEdgeOnSurface();

      IssmDouble  IceVolume(bool scaled);

      IssmDouble  IceVolumeAboveFloatation(bool scaled);

      IssmDouble  IcefrontMassFlux(bool scaled);

      IssmDouble  IcefrontMassFluxLevelset(bool scaled);

      IssmDouble  GroundinglineMassFlux(bool scaled);

      void        InputDepthAverageAtBase(int enum_type,int average_enum_type);

      void        InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/};

      void        ControlInputExtrude(int enum_type,int start){/*For penta only*/};

      bool        IsFaceOnBoundary(void);

      bool        IsIcefront(void);

      bool        IsNodeOnShelfFromFlags(IssmDouble* flags);

      bool        IsZeroLevelset(int levelset_enum);

      IssmDouble  Masscon(IssmDouble* levelset);

      IssmDouble  MassFlux(IssmDouble* segment);

      IssmDouble  MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id);

      void        MaterialUpdateFromTemperature(void){_error_("not implemented yet");};

      IssmDouble  Misfit(int modelenum,int observationenum,int weightsenum);

      IssmDouble  MisfitArea(int weightsenum);

      int         NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);

      int         NumberofNodesPressure(void);

      int         NumberofNodesVelocity(void);

      void        PotentialUngrounding(Vector<IssmDouble>* potential_sheet_ungrounding);

      int         PressureInterpolation();

      void        ReduceMatrices(ElementMatrix* Ke,ElementVector* pe);

      void        ResetFSBasalBoundaryCondition(void);

      void        ResetHooks();

      void        ResetLevelsetFromSegmentlist(IssmDouble* segments,int numsegments);

      void        RignotMeltParameterization();

      void        SetElementInput(int enum_in,IssmDouble values);

      void        SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble values);

      void        SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in);

      void        SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index,int offset,int N,int M);

      void        SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);

      void        SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);

      Element*    SpawnBasalElement(void);

      Element*    SpawnTopElement(void);

      void        StrainRateparallel();

      void        StrainRateperpendicular();

      void        StressIntensityFactor(void){_error_("not implemented yet");};

      IssmDouble  SurfaceArea(void);

      int         TensorInterpolation();

      IssmDouble  TimeAdapt();

      IssmDouble  TotalCalvingFluxLevelset(bool scaled);

      IssmDouble  TotalCalvingMeltingFluxLevelset(bool scaled);

      IssmDouble  TotalFloatingBmb(bool scaled);

      IssmDouble  TotalGroundedBmb(bool scaled);

      IssmDouble  TotalSmb(bool scaled);

      void        Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);

      int         UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf);

      void        ValueP1DerivativesOnGauss(IssmDouble* dvalue,IssmDouble* values,IssmDouble* xyz_list,Gauss* gauss);

      void        ValueP1OnGauss(IssmDouble* pvalue,IssmDouble* values,Gauss* gauss);

      int         VelocityInterpolation();

      int         VertexConnectivity(int vertexindex);

      void        VerticalSegmentIndices(int** pindices,int* pnumseg){_error_("not implemented yet");};

      void        VerticalSegmentIndicesBase(int** pindices,int* pnumseg){_error_("not implemented yet");};

      void        WriteFieldIsovalueSegment(DataSet* segments,int fieldenum,IssmDouble fieldvalue);


      #ifdef _HAVE_GIA_

      void   GiaDeflection(Vector<IssmDouble>* wg,Vector<IssmDouble>* dwgdt,IssmDouble* x,IssmDouble* y);

      #endif

      #ifdef _HAVE_ESA_

      void    EsaGeodetic2D(Vector<IssmDouble>* pUp,Vector<IssmDouble>* pNorth,Vector<IssmDouble>* pEast,  Vector<IssmDouble>* pX,Vector<IssmDouble>* pY,IssmDouble* xx,IssmDouble* yy);

      void    EsaGeodetic3D(Vector<IssmDouble>* pUp,Vector<IssmDouble>* pNorth,Vector<IssmDouble>* pEast,IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx,IssmDouble* yy,IssmDouble* zz);

      #endif

      #ifdef _HAVE_SEALEVELRISE_

      IssmDouble OceanAverage(IssmDouble* Sg, SealevelMasks* masks);

      void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old,SealevelMasks* masks);

      void    SetSealevelMasks(SealevelMasks* masks);

      void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz);

      void    SealevelriseEustatic(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);

      void    SealevelriseEustaticIce(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);

      void    SealevelriseEustaticHydro(IssmDouble* Sgi, IssmDouble* peustatic,SealevelMasks* masks, IssmDouble oceanarea);

      void    SealevelriseBottomPressure(IssmDouble* Sgi,SealevelMasks* masks);

      void    SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old,SealevelMasks* masks);

      void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks);

      #endif

      /*}}}*/

      /*Tria specific routines:{{{*/

      void           AddBasalInput2(int input_enum, IssmDouble* values, int interpolation_enum);

      void           AddInput2(int input_enum, IssmDouble* values, int interpolation_enum);

      void           AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id);

      void           DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum);

      void           CreateInputTimeAverage(int transientinput_enum,int averagedinput_enum,IssmDouble init_time,IssmDouble end_time,int averaging_method);

      void           GetInputAveragesUpToCurrentTime(int input_enum,IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime);

      IssmDouble     GetArea(void);

      IssmDouble     GetHorizontalSurfaceArea(void);

      IssmDouble     GetArea3D(void);

      IssmDouble     GetAreaIce(void);

      IssmDouble     GetAreaSpherical(void);

      void           GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble* xyz_zero,IssmDouble* xyz_list,int numpoints);

      int            GetElementType(void);

      Input2*        GetInput2(int enumtype);

      Input2*        GetInput2(int enumtype,IssmDouble time);

      Input2*        GetInput2(int inputenum,IssmDouble start_time,IssmDouble end_time,int averaging_method);

      DatasetInput2* GetDatasetInput2(int inputenum);

      void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);

      void           GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype);

      void           GetLevelsetIntersection(int** pindices, int* pnumiceverts, IssmDouble* fraction, int levelset_enum, IssmDouble level);

      void           GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype);

      void           InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type);

      void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int enum_type){_error_("not implemented yet");};

      void           JacobianDeterminant(IssmDouble*  pJdet, IssmDouble* xyz_list,Gauss* gauss);

      void           JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss);

      void           JacobianDeterminantLine(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};

      void           JacobianDeterminantSurface(IssmDouble*  pJdet, IssmDouble* xyz_list,Gauss* gauss);

      void           JacobianDeterminantTop(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss);

      IssmDouble     MinEdgeLength(IssmDouble* xyz_list){_error_("not implemented yet");};

      Gauss*         NewGauss(void);

      Gauss*         NewGauss(int order);

      Gauss*         NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order);

      Gauss*         NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,bool mainlyfloating,int order);

      Gauss*         NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,int order);

      Gauss*         NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert);

      Gauss*         NewGaussBase(int order);

      Gauss*         NewGaussLine(int vertex1,int vertex2,int order){_error_("not implemented yet");};

      Gauss*         NewGaussTop(int order);

      void           NodalFunctions(IssmDouble* basis,Gauss* gauss);

      void           NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);

      void           NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);

      void           NodalFunctionsMINIDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};

      void           NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss);

      void           NodalFunctionsP1(IssmDouble* basis,Gauss* gauss);

      void           NodalFunctionsP1Derivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);

      void           NodalFunctionsP2(IssmDouble* basis,Gauss* gauss);

      void           NodalFunctionsTensor(IssmDouble* basis,Gauss* gauss);

      void           NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss);

      void           NormalBase(IssmDouble* normal,IssmDouble* xyz_list);

      void           NormalSection(IssmDouble* normal,IssmDouble* xyz_list);

      void           NormalTop(IssmDouble* normal,IssmDouble* xyz_list);

      void           SetTemporaryElementType(int element_type_in){_error_("not implemented yet");};

      void           InputServe(Input2* input_in);

      Seg*           SpawnSeg(int index1,int index2);

      IssmDouble     StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){_error_("not implemented yet");};

      void           StabilizationParameterAnisotropic(IssmDouble* tau_parameter_ansiotropic, IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble hx, IssmDouble hy, IssmDouble hz, IssmDouble kappa){_error_("not implemented yet");};

      void           UpdateConstraintsExtrudeFromBase(void);

      void           UpdateConstraintsExtrudeFromTop(void);

      /*}}}*/


};

#endif  /* _TRIA_H */