file: include/Pyr.h


#ifndef Pyr_H
#define Pyr_H

class Pyr: public Element{
private:
public:
  // Constructors
  Pyr();                                             // default constructor        //OVERLOAD CALL: Pyr: Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr)
  Pyr(Element *);                                    // constructor        //OVERLOAD CALL: Pyr: Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr)
  Pyr(int i_d, char ty, int *qsize, int *jsize, Coord *X);        //OVERLOAD CALL: Pyr: Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr); Coord: nekstruct.h(?), hotel.h(?)
  Pyr(int i_d, char ty, int L, int Qa, int Qb, int Qc, Coord *X);        //OVERLOAD CALL: Pyr: Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr); Coord: nekstruct.h(?), hotel.h(?)

  // Memory routines
  void Mem_J(int *list, char Pyrp);        //OVERLOAD CALL: Mem_J: Memory.c(Tri), Memory.c(Quad), Memory.c(Tet), Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element)
  void Mem_Q();        //OVERLOAD CALL: Mem_Q: Memory.c(Tri), Memory.c(Quad), Memory.c(Tet), Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element)

  void Mem_shift(double *, double *, char);  // updates storage pters        //OVERLOAD CALL: Mem_shift: Element_List.c(Element_List), Memory.c(Tri), Memory.c(Quad), Memory.c(Tet), Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element)
  void Mem_free();                           // frees existing storage        //OVERLOAD CALL: Mem_free: Memory.c(Tri), Memory.c(Quad), Memory.c(Tet), Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element)

  // Operators
  Pyr& operator=(Pyr&);                              // assignement operator
  Pyr& operator*=(Pyr&);                             // mulitplying operator
  Pyr& operator*=(double&);                          // mulitplying operator
  Pyr& operator+=(Pyr&);                             // addition operator

  // Local MaPyrx builders
  void MassMat (LocMat *);                           // return mass-maPyr(ces)        //OVERLOAD CALL: MassMat: Matrix.c(Tri), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex); Pyr: Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr), Pyr.c(Pyr)
  void MassMatC(LocMat *);        //OVERLOAD CALL: MassMatC: Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element)
  void HelmMatC(LocMat *, Metric *lambda);                   // return Helmholtz op.        //OVERLOAD CALL: HelmMatC: Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element)
  void LapMat  (LocMat *);                           // return Laplacian op.        //OVERLOAD CALL: LapMat: Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex)
  void mat_free(LocMat *m);        //OVERLOAD CALL: mat_free: Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element), Memory.c(Tri), Memory.c(Quad), Memory.c(Tet)
  LocMat *mat_mem();        //OVERLOAD CALL: mat_mem: Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element), Memory.c(Tri), Memory.c(Quad), Memory.c(Tet)
  void fill_diag_massmat();              // fill modes with mass diagonal        //OVERLOAD CALL: fill_diag_massmat: Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element)
  void fill_diag_helmmat(Metric *lambda);          // fill modes with helm diagonal        //OVERLOAD CALL: fill_diag_helmmat: Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet), Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element)

  // Transforms and inner-products
  void   Jbwd(Element*, Basis*);        //OVERLOAD CALL: Jbwd: Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element)
  void   Jfwd(Element*);        //OVERLOAD CALL: Jfwd: Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element)
  double iprod(Mode *x, Mode *y);        //OVERLOAD CALL: iprod: InnerProd.c(Hex), InnerProd.c(Element), InnerProd.c(Tri), InnerProd.c(Quad), InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism)
  double iprodlap(Mode *x, Mode *y, Mode *fac);        //OVERLOAD CALL: iprodlap: InnerProd.c(Quad), InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex), InnerProd.c(Element), InnerProd.c(Tri)

  void HelmHoltz(Metric *lambda);        //OVERLOAD CALL: HelmHoltz: InnerProd.c(Quad), InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex), InnerProd.c(Element), Element_List.c(Element_List), InnerProd.c(Tri)
  void form_diprod(double *u1, double *u2, double *u3, Mode *m);        //OVERLOAD CALL: form_diprod: InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex), InnerProd.c(Element), InnerProd.c(Tri), InnerProd.c(Quad), InnerProd.c(Tet)

  // orthogonal transform routines
  void Obwd  (double *, double *, int);        //OVERLOAD CALL: Obwd: Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element)
  void Ofwd  (double *, double *, int);        //OVERLOAD CALL: Ofwd: Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element)
  void Add_Surface_Contrib(Element *, double *in, char dir);        //OVERLOAD CALL: Add_Surface_Contrib: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void fill_edges(double *ux, double *uy, double *uz);        //OVERLOAD CALL: fill_edges: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)

  // Global maPyrx routines
  void condense(LocMat *m, Bsystem *Ubsys);        //OVERLOAD CALL: condense: Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element), Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet)
  void  project(LocMat *m, Bsystem *Ubsys);        //OVERLOAD CALL: project: Matrix.c(Pyr), Matrix.c(Prism), Matrix.c(Hex), Matrix.c(Element), Matrix.c(Tri), Matrix.c(Quad), Matrix.c(Tet)

  void Sign_Change();        //OVERLOAD CALL: Sign_Change: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)

  // Bndry routines
  Bndry *gen_bndry(char bc, int face, ...);        //OVERLOAD CALL: gen_bndry: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void  update_bndry(Bndry *Ubc);        //OVERLOAD CALL: update_bndry: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void   MemBndry(Bndry *B, int face, int Je);        //OVERLOAD CALL: MemBndry: Memory.c(Tri), Memory.c(Quad), Memory.c(Tet), Memory.c(Pyr), Memory.c(Prism), Memory.c(Hex), Memory.c(Element)
  void JtransEdge(Bndry *B, int id, int loc, double *f);        //OVERLOAD CALL: JtransEdge: Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element)
  void JtransFace(Bndry *B, double *f);        //OVERLOAD CALL: JtransFace: Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex), Transforms.c(Element), Transforms.c(Tri)
  void MakeFlux(Bndry *B, int iface, double *f);        //OVERLOAD CALL: MakeFlux: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)

  // Element Identifier
  Nek_Facet_Type identify(){ return Nek_Pyr;}         // identify

  // Transformation routines
  void Trans(Element *, Nek_Trans_Type);              // Transform to Pyr        //OVERLOAD CALL: Trans: Element_List.c(Element_List), Transforms.c(Element), Transforms.c(Tri), Transforms.c(Quad), Transforms.c(Tet), Transforms.c(Pyr), Transforms.c(Prism), Transforms.c(Hex)
  void Iprod(Element *);                              // Inner product to Pyr        //OVERLOAD CALL: Iprod: InnerProd.c(Element), Element_List.c(Element_List), InnerProd.c(Tri), InnerProd.c(Quad), InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex)
  void Iprod_d (Element *,Basis *, Basis *);          // Inner product to Pyr        //OVERLOAD CALL: Iprod_d: InnerProd.c(Tri), InnerProd.c(Quad), InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex)
  void Iprod_3d(Element *,Basis *, Basis *, Basis *); // Inner product to Pyr        //OVERLOAD CALL: Iprod_3d: InnerProd.c(Tet), InnerProd.c(Pyr), InnerProd.c(Prism), InnerProd.c(Hex)

  // Derivatives routines
  void Grad (Element *, Element *, Element *, char Pyrp);        //OVERLOAD CALL: Grad: Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex), Element_List.c(Element_List), Gradient.c(Tri), Gradient.c(Quad)
  void Grad_d(double *, double *, double *, char Pyrp);          //OVERLOAD CALL: Grad_d: Element_List.c(Element_List), Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex)
  void Grad_h(double *, double *, double *, double *, char Pyrp);         //OVERLOAD CALL: Grad_h: Element_List.c(Element_List), Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex)
  void getD(double ***da, double ***dat,double ***db,double ***dbt,        //OVERLOAD CALL: getD: Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex), Gradient.c(Element)
	    double ***dc, double ***dct);

  void fillElmt(Mode *v);        //OVERLOAD CALL: fillElmt: Basis.c(Tri), Basis.c(Quad), Basis.c(Tet), Basis.c(Pyr), Basis.c(Prism), Basis.c(Hex), Basis.c(Element)
  void fill_gradbase(Mode *gb, Mode *m, Mode *mb, Mode *fac);        //OVERLOAD CALL: fill_gradbase: Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex), Gradient.c(Element)
  Basis *getbasis();        //OVERLOAD CALL: getbasis: Basis.c(Tri), Basis.c(Quad), Basis.c(Tet), Basis.c(Pyr), Basis.c(Prism), Basis.c(Hex), Basis.c(Element)
  Basis *derbasis();        //OVERLOAD CALL: derbasis: Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex), Gradient.c(Element)

  // Co-ordinate functions
  void set_curved(Curve*){;}                         // fix curve sides
  void coord(Coord *X);                              // get quadrature coords        //OVERLOAD CALL: coord: Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element), Coords.c(Tri), Coords.c(Quad); Coord: nekstruct.h(?), hotel.h(?)
  void fillvec(Mode *v, double *f);                  //        //OVERLOAD CALL: fillvec: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
  void straight_elmt(Coord *X);                      //        //OVERLOAD CALL: straight_elmt: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element); Coord: nekstruct.h(?), hotel.h(?)
  void curved_elmt(Coord *X);                        //        //OVERLOAD CALL: curved_elmt: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element); Coord: nekstruct.h(?), hotel.h(?)
  void straight_edge(Coord *X, int edge);            //         //OVERLOAD CALL: straight_edge: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element); Coord: nekstruct.h(?), hotel.h(?)
  void straight_face(Coord *X, int face,int trip);   //         //OVERLOAD CALL: straight_face: Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex); Coord: nekstruct.h(?), hotel.h(?)
  void GetFaceCoord(int face, Coord *X);             //        //OVERLOAD CALL: GetFaceCoord: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element); Coord: nekstruct.h(?), hotel.h(?)

  // Error functions
  void Set_field(char *sPyrng);                      // set field to function        //OVERLOAD CALL: Set_field: Element_List.c(Element_List), Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
  void Error(char *sPyrng);                          // compare with function        //OVERLOAD CALL: Error: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double L2_error_elmt(char *sPyrng);        //OVERLOAD CALL: L2_error_elmt: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double H1_error_elmt(char *sPyrng);        //OVERLOAD CALL: H1_error_elmt: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  void Verror(double *u, char *sPyrng);        //OVERLOAD CALL: Verror: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double Int_error( char *sPyrng);        //OVERLOAD CALL: Int_error: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double Norm_li();        //OVERLOAD CALL: Norm_li: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double Norm_l2();        //OVERLOAD CALL: Norm_l2: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  void Norm_l2m(double *l2, double *area);        //OVERLOAD CALL: Norm_l2m: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  double Norm_h1();        //OVERLOAD CALL: Norm_h1: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)
  void Norm_h1m(double *h1, double  *area);        //OVERLOAD CALL: Norm_h1m: Norms.c(Tri), Norms.c(Quad), Norms.c(Tet), Norms.c(Pyr), Norms.c(Prism), Norms.c(Hex), Norms.c(Element)

  // Curved sides
  void set_curved_elmt(Element_List*);        //OVERLOAD CALL: set_curved_elmt: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element)
  void genArc(double *x, double *y);        //OVERLOAD CALL: genArc: Coords.c(Tri), Coords.c(Quad)
  void genNaca4(double *x, double *y);        //OVERLOAD CALL: genNaca4: Coords.c(Tri), Coords.c(Quad)
  void genFile(double *x, double *y);        //OVERLOAD CALL: genFile: Coords.c(?), Coords.c(?)

  void CoordTransEdge(double *f, double *fhat, int edge);        //OVERLOAD CALL: CoordTransEdge: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element)
  void get_mmat1d(double **mat, int L);        //OVERLOAD CALL: get_mmat1d: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  
  // Geomec factors 
  void set_geofac();        //OVERLOAD CALL: set_geofac: Geofac.c(Tri), Geofac.c(Quad), Geofac.c(Tet), Geofac.c(Pyr), Geofac.c(Prism), Geofac.c(Hex), Geofac.c(Element)
  void free_geofac();        //OVERLOAD CALL: free_geofac: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element)

  void Surface_geofac(Bndry *B);        //OVERLOAD CALL: Surface_geofac: Coords.c(Tri), Coords.c(Quad), Coords.c(Tet), Coords.c(Pyr), Coords.c(Prism), Coords.c(Hex), Coords.c(Element)
  void InterpToFace1(int from_face, double *f, double *fi);        //OVERLOAD CALL: InterpToFace1: Interp.c(Tri), Interp.c(Quad), Interp.c(Tet), Interp.c(Pyr), Interp.c(Prism), Interp.c(Hex), Interp.c(Element)
  void InterpToGaussFace(int from_face, double *f,         //OVERLOAD CALL: InterpToGaussFace: Interp.c(Pyr), Interp.c(Prism), Interp.c(Hex), Interp.c(Element), Interp.c(Tri), Interp.c(Quad), Interp.c(Tet)
				 int qaf, int qbf, double *fi);

  void set_solve(int fac, int mask);        //OVERLOAD CALL: set_solve: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void Add_flux_terms(Bndry *Ebc);        //OVERLOAD CALL: Add_flux_terms: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void setbcs(Bndry *Ubc, double *bc);        //OVERLOAD CALL: setbcs: Boundary.c(Tri), Boundary.c(Quad), Boundary.c(Tet), Boundary.c(Pyr), Boundary.c(Prism), Boundary.c(Hex), Boundary.c(Element)
  void GetFace(double*, int, double *);        //OVERLOAD CALL: GetFace: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)

  void dump_mesh(FILE*);          //OVERLOAD CALL: dump_mesh: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
    
  int  Nfmodes();        //OVERLOAD CALL: Nfmodes: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)
  int  vnum (int,int);        //OVERLOAD CALL: vnum: Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element), Nums.c(Tri)
  int  fnum (int,int);        //OVERLOAD CALL: fnum: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)
  int  fnum1(int,int);        //OVERLOAD CALL: fnum1: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)
  int  ednum (int,int);        //OVERLOAD CALL: ednum: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)
  int  ednum1(int,int);        //OVERLOAD CALL: ednum1: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)

  int dim(){return 3;}
  int Nfverts(int);        //OVERLOAD CALL: Nfverts: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)

  void fill_column(double **Mat, int loc, Bsystem *B, int nm, int offset);        //OVERLOAD CALL: fill_column: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
  void WeakDiff(Mode *m, double *ux, double *uy,double *uz, int con);        //OVERLOAD CALL: WeakDiff: Gradient.c(Tri), Gradient.c(Quad), Gradient.c(Tet), Gradient.c(Pyr), Gradient.c(Prism), Gradient.c(Hex), Gradient.c(Element)

  int  data_len(int *size);
  void Copy_field(double *, int *);        //OVERLOAD CALL: Copy_field: Fieldfiles.c(Tri), Fieldfiles.c(Quad), Fieldfiles.c(Tet), Fieldfiles.c(Pyr), Fieldfiles.c(Prism), Fieldfiles.c(Hex), Fieldfiles.c(Element)

  void close_split(Element_List *EL, Bndry **Ubc, int nfields, int *&flag);        //OVERLOAD CALL: close_split: Refine.c(Tri), Refine.c(Quad), Refine.c(Tet), Refine.c(Pyr), Refine.c(Prism), Refine.c(Hex)
  void split_element(Element_List *EL, Bndry **Ubc, int nfields, int *&flag);        //OVERLOAD CALL: split_element: Refine.c(Tri), Refine.c(Quad), Refine.c(Tet), Refine.c(Pyr), Refine.c(Prism), Refine.c(Hex), Refine.c(Element)
  void split_edge(int edg, Element_List *EL, Bndry **Ubc, int nfields,int *flag);        //OVERLOAD CALL: split_edge: Refine.c(Tri), Refine.c(Quad), Refine.c(Tet), Refine.c(Pyr), Refine.c(Prism), Refine.c(Hex), Refine.c(Element)
  void delete_element(Element_List *EL, Bndry **, int, int *flag);        //OVERLOAD CALL: delete_element: Refine.c(Tri), Refine.c(Quad), Refine.c(Tet), Refine.c(Pyr), Refine.c(Prism), Refine.c(Hex), Refine.c(Element)

  void set_edge_geofac();        //OVERLOAD CALL: set_edge_geofac: Geofac.c(Tri), Geofac.c(Quad), Geofac.c(Tet), Geofac.c(Pyr), Geofac.c(Prism), Geofac.c(Hex), Geofac.c(Element)
  void PutFace(double*, int);        //OVERLOAD CALL: PutFace: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
  void GetZW(double **za, double **wa, double **zb, double **wb, double **zc, double **wc);        //OVERLOAD CALL: GetZW: Misc.c(Tri), Misc.c(Quad), Misc.c(Tet), Misc.c(Pyr), Misc.c(Prism), Misc.c(Hex), Misc.c(Element)
  int edvnum(int,int);        //OVERLOAD CALL: edvnum: Nums.c(Tri), Nums.c(Quad), Nums.c(Tet), Nums.c(Pyr), Nums.c(Prism), Nums.c(Hex), Nums.c(Element)
};


#endif







Back to Source File Index


C++ to HTML Conversion by ctoohtml