source: issm/trunk-jpl/src/c/classes/Inputs/TetraInput.h@ 18078

/*! \file TetraInput.h 
 *  \brief: header file for TetraInput object
 */

#ifndef _TETRAINPUT_H_
#define _TETRAINPUT_H_

/*Headers:*/
/*{{{*/
#include "./Input.h"
#include "../Elements/TetraRef.h"
class Gauss;
class Gauss;
/*}}}*/

class TetraInput: public Input,public TetraRef{

        public:
                int         enum_type;
                int         interpolation_type;
                IssmDouble* values;

                /*TetraInput constructors, destructors*/
                TetraInput();
                TetraInput(int enum_type,IssmDouble* values,int element_type_in);
                ~TetraInput();

                /*Object virtual functions definitions*/
                void    Echo();
                void    DeepEcho();
                int     Id();
                int     ObjectEnum();
                Object *copy();

                /*TetraInput management:*/
                int    InstanceEnum();
                Input* SpawnTriaInput(int index1,int index2,int index3);
                Input* SpawnSegInput(int index1,int index2){_error_("not supported yet");};
                Input* PointwiseDivide(Input* inputB);
                Input* PointwiseMin(Input* inputB);
                Input* PointwiseMax(Input* inputB);
                int    GetResultInterpolation(void);
                int    GetResultNumberOfNodes(void);
                void   ResultToPatch(IssmDouble* values,int nodesperelement,int sid);
                void   AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                void   Configure(Parameters* parameters);

                /*numerics*/
                void GetInputValue(bool* pvalue){_error_("not implemented yet");}
                void GetInputValue(int* pvalue){_error_("not implemented yet");}
                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");}
                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,int index){_error_("not implemented yet");};
                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
                void GetInputAverage(IssmDouble* pvalue);
                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes);
                void GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime);
                void ChangeEnum(int newenumtype);
                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
                void ConstrainMin(IssmDouble minimum);
                void Set(IssmDouble setvalue);
                void Scale(IssmDouble scale_factor);
                void AXPY(Input* xinput,IssmDouble scalar);
                void Constrain(IssmDouble cm_min, IssmDouble cm_max);
                IssmDouble InfinityNorm(void);
                IssmDouble Max(void);
                IssmDouble MaxAbs(void);
                IssmDouble Min(void);
                IssmDouble MinAbs(void);
                void Extrude(void){_error_("not supported yet");};
                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist);

};
#endif  /* _TETRAINPUT_H */