eqvart.h

Go to the documentation of this file.

#ifndef  _MY_EqVarT_
#define _MY_EqVarT_
#include <fe/fe_q.h>
#include <dofs/dof_tools.h>
#include <fe/fe_values.h>
#include <base/quadrature_lib.h>
#include <lac/vector.h>
#include <lac/full_matrix.h>
#include "globals.h"
#include <base/tensor.h>
#include "vecdouble.h"


/*----------------- CLASS EqVarT --------------
  ----------------------------------------*/
class EqVarTAccessor;

class EqVarT 
{
  friend class EqVarTAccessor;
 
 private:
  bool m_validFeValues;
  bool m_validFeFaceValues;

 protected:

 public:

 private:
    UpdateFlags m_upFlags;
    DoFHandler<DIM>::active_cell_iterator *m_pCell; 
    FEValues<DIM> *m_fev;
    FEFaceValues<DIM> *m_face_values;
    std::vector<unsigned int> m_dofIndices;
    unsigned m_qPoint;
    unsigned m_qPointFace;



    void setCell(DoFHandler<DIM>::active_cell_iterator &cell){m_pCell = &cell;}
    void setQPoint(unsigned qpoint){m_qPoint = qpoint;}

    
 protected:

 public:
  EqVarT(UpdateFlags up){m_upFlags = up;m_fev=NULL;m_face_values=NULL;}
  virtual ~EqVarT(){}
  void setFeValue(FEValues<DIM> *fe);
  bool validFeValues(){return m_validFeValues;}
  void setFaceValues(FEFaceValues<DIM> *face_values);
  bool validFeFaceValues(){return m_validFeFaceValues;}

  std::vector<unsigned int>&  getDofIndices(){return m_dofIndices;}
  void                    addNeumannBoundary(unsigned boundary_value);
  UpdateFlags             getUpdateFlags(){return m_upFlags;}
  DoFHandler<DIM>::active_cell_iterator& getCell(){return *m_pCell;} 
  double                  getSolValue(Vector<double> &sol);
  double                  getCoefSolValue(unsigned index,VecDouble &sol); 
  double                  getSolGradComponent(Vector<double> &sol,int component);
  double                  getValueByCellIndex(const VecDouble &sol);
  Tensor<1,DIM>           getSolGrad(VecDouble &sol);
  const FEValues<DIM>&    getFEValues(){assert(validFeValues());return *m_fev;} 
  unsigned                getQPoint(){assert(validFeValues());return m_qPoint;}
  unsigned                getQPointAtFace(){assert(validFeFaceValues());return m_qPointFace;}
 
  double                  measure(){return getCell()->measure();}
  double                  localNeumannBoundary(unsigned i);
  double                  localEqVar(unsigned i,unsigned j);
  double                  localRhs(unsigned i);
 

  //Nao use esse metodo dentro de addNeummanCondition.
  unsigned component(unsigned i);

  //component_face eh usado apenas dentro de addNeummanCondition.
  unsigned component_face(unsigned i)   {assert(m_face_values);return m_face_values->get_fe().system_to_component_index(i).first;}

  unsigned base_function(unsigned i) { assert(validFeValues());return m_fev->get_fe().system_to_component_index(i).second;}
  unsigned base_element_mult(unsigned i){assert(validFeValues());return m_fev->get_fe().system_to_base_index(i).first.second;}

  //Informacoes
  bool changedCell(unsigned i,unsigned j)         {return (i ==0 && j==0 && m_qPoint == 0);}

  //Valores nos pontos de integracao do elemento
  const Point<DIM>&       getPoint()              {assert(validFeValues());return m_fev->quadrature_point(m_qPoint);}
  double                  shape_value(unsigned i) {assert(validFeValues());return m_fev->shape_value(i,m_qPoint);}
  const  Tensor<1,DIM>&   shape_grad(unsigned i)  {assert(validFeValues());return m_fev->shape_grad(i,m_qPoint);}
  double                  shape_value(unsigned i,unsigned component) {assert(validFeValues());return m_fev->shape_value_component(i,getQPoint(),component);}
  Tensor<1,DIM>           shape_grad (unsigned i,unsigned component) {assert(validFeValues());return m_fev->shape_grad_component(i,getQPoint(),component);}
  double                  shape_div(unsigned i);
  double                  JxW()                      {assert(validFeValues());return m_fev->JxW(m_qPoint);}

  //Valores na face
  double                  JFace()                      {assert(validFeFaceValues());return m_face_values->JxW(m_qPointFace);}
  double                  JxWFace()                    {assert(validFeFaceValues());return m_face_values->JxW(m_qPointFace);}
  FEFaceValues<DIM>&      getFEFaceValues()            {assert(validFeFaceValues());return *m_face_values;}

  const Point<DIM>&       getPointAtFace()               {assert(validFeFaceValues());return m_face_values->quadrature_point(m_qPointFace);}
  const Tensor<1,DIM>&    normal_vector()              {assert(validFeFaceValues());return m_face_values->normal_vector(m_qPointFace);}
  const  Tensor<1,DIM>&   shape_grad_face (unsigned i) {assert(validFeFaceValues());return m_face_values->shape_grad(i,m_qPointFace);}
  double                  shape_value_face(unsigned i) {assert(validFeFaceValues());return m_face_values->shape_value(i,m_qPointFace);}

  
  void changedCellEvent(){} //Sempre que trocamos de celula.
  void changedQPointEvent(){}    //Sempre que se troca um ponto de integracao durante a montagem da matriz global..  
  void changedCellRHSEvent(){changedCellEvent();} //Sempre que trocamos de celula ao construir RHS.
                                                  //Por Default chame o evento changedCellEvent;
  void changedQPointRHSEvent(){}  //Ponto de integracao trocou durante a montagem do RHS

  void changedQPointFaceEvent(){} //Ponto da face trocou durante adicao de condicao de Neumman. 



};

#endif

---