Diffpack Documentation

---

              Search  

---

FieldFE.h

Go to the documentation of this file.

class FieldFE : public FieldWithPtValues

{
  friend class FieldsFE;

protected:
  Handle(GridFE)         mesh;
  Handle(Vec(NUMT))      nodal_values;
  Handle(FiniteElement)  globfe;
  Handle(BasisFuncGrid)  bfnodes;

  Handle(ArrayGen(NUMT)) lattice_indexing; 
  bool                   internal_basis_func_grid;

  
  int init4e;                  
  Vec(NUMT) loc_nodal_values;  
  bool different_bfgrid;       
  bool different_geomgrid;     
  int  nbf;                    
  void precompute4interpolation (const FiniteElement& fe);
  int  ncalls_valuePt;         

  bool renumbered;             

  Handle(MxMapping) map;       

  bool reallocate
    (
     const GridFE&        grid,
     const Vec(NUMT)*     coeff,
     const BasisFuncGrid* sfg,
     const char*          fieldname
    );

public:
  FieldFE (); 
  FieldFE (const GridFE& grid, const char* fieldname);
  FieldFE (const GridFE& grid, const Vec(NUMT)& coefficients,
           const char* fieldname);
  FieldFE (const BasisFuncGrid& bfnodes_grid, const char* fieldname);
  FieldFE (const BasisFuncGrid& bfnodes_grid, const Vec(NUMT)& coefficients,
           const char* fieldname);

 ~FieldFE ();

  bool update ();  
  bool compatible (const GridFE& g);

  bool updateNodalNumbering ();  

  bool redim (const FieldFE& f, const char* fieldname);
  bool redim (const GridFE& grid, const char* fieldname);
  bool redim (const BasisFuncGrid& bfnodes_grid,
              const char* fieldname);
  bool redim (const GridFE& grid, const Vec(NUMT)& coefficients,
              const char* fieldname);
  bool redim (const BasisFuncGrid& bfnodes_grid,
              const Vec(NUMT)& coefficients, const char* fieldname);

        GridFE& grid ()                        { return mesh.getRef(); }
  const GridFE& grid () const                  { return mesh.getRef(); }

        BasisFuncGrid& grid4basisFunc ()       { return bfnodes.getRef(); }
  const BasisFuncGrid& grid4basisFunc () const { return bfnodes.getRef(); }

        Vec(NUMT)& values ()                   { return nodal_values.getRef();}
  const Vec(NUMT)& values () const             { return nodal_values.getRef();}
  void  localValues (VecSimple(NUMT)& local_values, int elm_no) const;

  void  fill (const Vector(NUMT)& new_values);
  int   getNoNodes () const;

  bool valueNodeRepresentation() const;
  bool simpleTopology() const;

  bool isLattice (int nsd) const;
  const ArrayGen(NUMT)& latticeIndex () const { return lattice_indexing(); }
        ArrayGen(NUMT)& latticeIndex ()       { return lattice_indexing(); }

  void exchangeValues (FieldFE& f);  

  virtual bool ok () const;
          bool empty () const;
  virtual void minmax (NUMT& min, NUMT& max, GridWithPts* grid =NULL) const;

  NUMT  valueElm (int elm_no, const Ptv(real)& local_pt, real t = DUMMY);
  NUMT  valueElm (int elm_no, const Ptv(real)& local_pt, real t = DUMMY) const
  { return CAST_CONST_AWAY(FieldFE)->valueElm(elm_no, local_pt,t); }


  virtual NUMT  valueFEM (const FiniteElement& fe, real t = DUMMY);

  virtual NUMT  valuePt (const Ptv(real)& x, real t = DUMMY);
          NUMT  valuePt (int& element, Ptv(real)& loc_pt,
                         const Ptv(real)& x, real t = DUMMY);

          NUMT& valueNode  (int node, real t = DUMMY);
  virtual NUMT  valueNode  (int node, real t = DUMMY) const;

  virtual Ptv(NUMT) derivativePt (const Ptv(real)& x, real t = DUMMY);
  Ptv(NUMT) derivativePt (const Ptv(real)& x, real t = DUMMY) const
  { return CAST_CONST_AWAY(FieldFE)->derivativePt(x,t); }

  virtual void derivativeNode (Ptv(NUMT)& gradient, int node,
                               real t = DUMMY);

  virtual void derivativeFEM  (Ptv(NUMT)& gradient, const FiniteElement& fe,
                               real t = DUMMY);

  void derivativeFEM
    (Ptv(NUMT)& gradient, const FiniteElement& fe, real t = DUMMY) const
    { CAST_CONST_AWAY(FieldFE)->derivativeFEM (gradient, fe, t); }

  void derivativeElm (Ptv(NUMT)& gradient, int elm_no,
                      const Ptv(real)& local_pt, real t = DUMMY);

  void derivativeElm (Ptv(NUMT)& gradient, int elm_no,
                      const Ptv(real)& local_pt, real t = DUMMY) const
  { CAST_CONST_AWAY(FieldFE)->derivativeElm (gradient, elm_no, local_pt, t); }

  virtual void hessianPt  (Ptv(NUMT)&, const Ptv(real)& x, real = DUMMY);
  virtual void hessianFEM (Ptv(NUMT)&, const FiniteElement& fe, real = DUMMY);
          void hessianElm (Ptv(NUMT)&, int, const Ptv(real)&, real = DUMMY);

  
  void interpolate (const FieldFE& fefield);
  void interpolate (const FieldLattice& fdfield);

  
  
  void operator = (const FieldFE& fefield);
  void operator = (const FieldLattice& fdfield);
  void operator = (const FieldFunc& func);
  void fill       (const FieldFunc& func, real time);

  virtual void fill  (NUMT value);
  virtual void add   (NUMT value);
  virtual void mult  (NUMT value);
  virtual void apply (Func(NUMT) f);
  virtual void add   (Field& field, int power, NUMT front_factor);
          void add   (const FieldFE& f);  

  virtual Field&   scale ();
  virtual Field& unscale ();

  virtual void  unloadData (Os os) const;
  virtual void    loadData (Is is);
  virtual void  attach (Grid& grid);
  virtual Grid* getGridBase();

  

  virtual int   getNoPoints () const;
  virtual int   getNoValues () const;

  virtual NUMT& valuePoint (int point_no)
    { return nodal_values( (point_no);) }  

  virtual NUMT  valuePoint (int point_no) const
   { return nodal_values( (point_no);) }

  virtual Ptv(real) getPt (int point_no) const
   { return bfnodes->getCoor(point_no); }

  virtual GridWithPts& getGridWithPts ()
    { return mesh.getRef(); }

  virtual const GridWithPts& getGridWithPts () const
    { return mesh.getRef(); }

  virtual Vec(NUMT)& valuesVec ()
    { return nodal_values.getRef(); }

  virtual const Vec(NUMT)& valuesVec () const
    { return nodal_values.getRef(); }

  CLASS_INFO
  VIRTUAL_CAST(FieldFE);
  
  COPY_CONSTRUCTOR(FieldFE);

  virtual void print (Os os) const;
          void scan  (Is is);
};

---