DealBaseDoFs Class Reference

#include <dealbasedofs.h>

List of all members.

Public Member Functions
	DealBaseDoFs ()
	~DealBaseDoFs ()
void	projectDofSolutionAtVertice (const DoFHandler< 3 > &dofs, int deg, const VecDouble &vDofSol, VecDouble &vSol)
void	printCellDofsInformation (const DoFHandler< 2 > &dofs, std::ostream &out)
void	printCellDofsInformation (const DoFHandler< 3 > &dofs)
void	getCentralValuesFromDofs (DoFHandler< 3 > &dof, const VecDouble &sol, VecDouble &cValues, unsigned component)
void	printFE (FiniteElement< 3 > &fe)
void	getValuesAtCells (DoFHandler< 3 > &dofs, const VecDouble &sol, VecDouble cValues)
template<class Vetor >
void	getValuesAtFaces (DoFHandler< 3 > &dof, const Vetor &sol, Matrix &Mvalues, const std::vector< unsigned > &components, const bool homMesh)
Static Public Member Functions
static DoFCell	getDoFCellAtPoint (const DoFHandler< 3 > &dof, const Point< 3 > &p)
static DoFCell	getAdjDoFCell (DoFCell cell, CellDirection3D dir)
static double	getDoFVerticeValue (DoFCell cell, VertexDirection3D dir, unsigned deg, const VecDouble &vSol)
static void	getVerticeValuesFromDofs (DoFHandler< 3 > &dofs, const VecDouble &vSol, VecDouble &vVerticesValues, unsigned deg)

---

Detailed Description

Definition at line 9 of file dealbasedofs.h.

---

Constructor & Destructor Documentation

DealBaseDoFs::DealBaseDoFs

(

)

[inline]

Definition at line 16 of file dealbasedofs.h.

{}

DealBaseDoFs::~DealBaseDoFs

(

)

[inline]

Definition at line 17 of file dealbasedofs.h.

{}

---

Member Function Documentation

DoFCell DealBaseDoFs::getAdjDoFCell	(	DoFCell	cell,
		CellDirection3D	dir
	)			[static]

Objetivo: Get the DoFCell adjacent to the current cell.

Parametros: dir = Direction of the cell adjacent in relation of the current cell cell = Cell in the neighbour. Retorno:

Definition at line 30 of file dealbasedofs.cpp.

{
  if (cell->face(dir)->at_boundary())
    return DoFCell();
  else
    return cell->neighbor(dir);
}

void DealBaseDoFs::getCentralValuesFromDofs	(	DoFHandler< 3 > &	dof,
		const VecDouble &	sol,
		VecDouble &	cValues,
		unsigned	component
	)

This function retrives the value of a component solution of a finite element problem for each center point of the mesh cells putting the values in the vector cValues.

Parameters:

	dofs	The DOF Handler used in the problem.
	sol	Vector containing the values of degree of freedom.
	cValues	(Output) Vector indexed by the cells numbers to contain the Central values of the finite element solution

Definition at line 227 of file dealbasedofs.cpp.

{
  assert(sol.size() == dof.n_dofs());
  assert(cValues.size() == dof.get_tria().n_active_cells());
  assert(component < dof.get_fe().n_components());

  QMidpoint<DIM> qMidPoint;
  FEValues<DIM> fe_values(dof.get_fe(),qMidPoint,update_values);

  const unsigned int   dofs_per_cell = dof.get_fe().dofs_per_cell;
 
 std::vector<unsigned int> local_dof_indices (dofs_per_cell);
 
 DoFHandler<3>::active_cell_iterator cell = dof.begin_active(),
   endc = dof.end();

 double acum;
 for (; cell!=endc; ++cell)
 {
   fe_values.reinit (cell);
   acum =0.0;
   cell->get_dof_indices(local_dof_indices);
   for (unsigned int i=0; i<dofs_per_cell; ++i)
   {
     acum+= sol(local_dof_indices[i])*fe_values.shape_value_component(i,0,component);
   }
   cValues(cell->index())=acum;
 }
  
}

static DoFCell DealBaseDoFs::getDoFCellAtPoint	(	const DoFHandler< 3 > &	dof,
		const Point< 3 > &	p
	)			[static]

double DealBaseDoFs::getDoFVerticeValue	(	DoFCell	cell,
		VertexDirection3D	dir,
		unsigned	deg,
		const VecDouble &	vSol
	)			[static]

Objetivo: Obter o valor do grau de liberdade (deg), no vertice (dir) da celula (cell) da solucao (vSol).

Definition at line 43 of file dealbasedofs.cpp.

{
  assert(cell->vertex_dof_index(dir,deg) < vSol.size());
  return vSol(cell->vertex_dof_index(dir,deg));
}

void DealBaseDoFs::getValuesAtCells	(	DoFHandler< 3 > &	dofs,
		const VecDouble &	sol,
		VecDouble	cValues
	)

template<class Vetor >

void DealBaseDoFs::getValuesAtFaces	(	DoFHandler< 3 > &	dof,
		const Vetor &	sol,
		Matrix &	Mvalues,
		const std::vector< unsigned > &	components,
		const bool	homMesh
	)			[inline]

Get the values of the solution given in the vector sol in each face midpoint. The values are returned in the Matrix Mvalues that has dimensions of ( number of faces x number of components). The components of the solution we want to be copied to the Mvalues is set by the parameter vector "components". In the the position (i,j) in the matrix Mvalues is the value of the component with number (components[j]) belonging to the face [i]

Parameters:

	dofs
	sol	Solution of the problem
	Mvalues	Matrix to contain the components values of the faces
	components	The components we want from the solution. Remeber that each component is a primary variable in the finite element system. Boolean indicating if the mesh is homogeneous (i.e all elements has the same shape and dimensions). This boolean exists for optimization purposes. If the mesh is homogeneous we dont need to always use the function fe_values.reinit(cell) to update fe_values with the values of the cells since all cells have the same geometry and identical shape functions. If the user set homMesh, and the mesh is not homogeneous THE METHOD RETURNS WRONG RESULTS.

Returns:

Definition at line 65 of file dealbasedofs.h.

{
  assert(Mvalues.n() == components.size());
  assert(Mvalues.m() == dof.get_tria().n_active_faces());
  std::vector<Point<3> > points;
  points.push_back(Point<3>(0,0.5,0.5)); // MidPoint of the left face
  points.push_back(Point<3>(1,0.5,0.5)); // MidPoint of the right face
  points.push_back(Point<3>(0.5,0,0.5)); // MidPoint of the front face
  points.push_back(Point<3>(0.5,1,0.5)); // MidPoint of the back face
  points.push_back(Point<3>(0.5,0.5,0)); // MidPoint of the bottom face
  points.push_back(Point<3>(0.5,0.5,1)); // MidPoint of the up face
  std::vector<double> weights(6,1);
  unsigned n_quadrature_points = points.size();
  
  Quadrature<3> quad(points,weights);

  FEValues<DIM> fe_values(dof.get_fe(),quad,update_values);

  const unsigned int   dofs_per_cell = dof.get_fe().dofs_per_cell;
  const unsigned int n_components = components.size();
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);

  
 DoFHandler<3>::active_cell_iterator cell = dof.begin_active(),
   endc = dof.end();


 if (homMesh)
   fe_values.reinit (cell);
 for (; cell!=endc; ++cell)
 {
   if (!homMesh)
     fe_values.reinit (cell);

   cell->get_dof_indices(local_dof_indices);

   //For each quadratue point
   for (unsigned q_point=0;q_point < n_quadrature_points;q_point++)
   {
     //The quadrature points are organized such that each qpoint
     //indice correspond to the indice of its face.
     //values points to the beginning of the line belonging to the current face 
     double *values = &(Mvalues(cell->face_index(q_point),0));

     //Now for each component
     for (unsigned j=0;j < n_components;j++)
     {
       double acum = 0.0;
       //For each shape function
       for (unsigned int i=0; i<dofs_per_cell; ++i)
       {
         acum += sol(local_dof_indices[i])*fe_values.shape_value_component(i,q_point,components[j]);
       }
       values[j]=acum;

     }
   }
 }
}

static void DealBaseDoFs::getVerticeValuesFromDofs	(	DoFHandler< 3 > &	dofs,
		const VecDouble &	vSol,
		VecDouble &	vVerticesValues,
		unsigned	deg
	)			[static]

void DealBaseDoFs::printCellDofsInformation

(

const DoFHandler< 3 > &

dofs

)

Definition at line 73 of file dealbasedofs.cpp.

 {
  const  DoFHandler<DIM> &dof = dofs;
  DoFHandler<DIM>::active_cell_iterator cell = dof.begin_active(),
                                      endc = dof.end();
  int dofs_per_face = dof.get_fe().n_dofs_per_face();
  vector<unsigned> dofs_face(dofs_per_face);
  
  for (;cell!=endc; ++cell)
    {
      printf("\n==================\nCell %d at <%3g,%3g,%3g>\n",cell->index(),
             cell->barycenter()[0],
             cell->barycenter()[1],
             cell->barycenter()[2]);
      if (dofs_per_face > 0)
      {
        printf("Dof at Faces:\n");
        
        for (unsigned i=0;i<GeometryInfo<DIM>::faces_per_cell;i++)
        {
          
          printf("%d)  Index: %d Dofs:",i,cell->face(i)->index());
          cell->face(i)->get_dof_indices(dofs_face);
          for (int j=0;j<dofs_per_face;j++)
          {
            printf("%d ",dofs_face[j]);
          }
          printf("\n");
        }
      }
    }
}

void DealBaseDoFs::printCellDofsInformation	(	const DoFHandler< 2 > &	dofs,
		std::ostream &	out
	)

Definition at line 51 of file dealbasedofs.cpp.

 {
  const  DoFHandler<2> &dof = dofs;
  DoFHandler<2>::active_cell_iterator cell = dof.begin_active(),
                                      endc = dof.end();
  char strOut[500];
  
  for (;cell!=endc; ++cell)
    {
      sprintf(strOut,"\n==================\nCell %d:\nDoFs: %d\n\nVertices:\n",cell->index(),dof.get_fe().dofs_per_cell);
      out << strOut;
      for (unsigned i=0;i<GeometryInfo<DIM>::vertices_per_cell;i++)
      {
        sprintf(strOut,"\n%d) Pt: <%6g,%6g>, Index: %d, Dofs Index:",i,cell->vertex(i)(0),cell->vertex(i)(1),cell->vertex_index(i));
        out << strOut;
        for (unsigned j=0;j<dof.get_fe().dofs_per_vertex;j++)
        {
          out << cell->vertex_dof_index(i,j) << " ";
        }  
      }
    }
}

void DealBaseDoFs::printFE

(

FiniteElement< 3 > &

fe

)

This is just a debug function for printing information about a finite element

Parameters:

fe

The finite element whose data is to be printed.

Returns:

Definition at line 136 of file dealbasedofs.cpp.

{
  cout << "Finite Element Name: " << fe.get_name() << std::endl;
  cout << "Is primitive: " << fe.is_primitive() << std::endl;
  cout << "Num Base Elements: " << fe.n_base_elements() << std::endl;
  cout << "Num components: " << fe.n_components() << std::endl;
  //  cout << "Num DOFS per object: " << fe.n_dofs_per_object() << std::endl;
  cout << "DOFS per vertex: " << fe.n_dofs_per_vertex() << std::endl;
  cout << "DOFS per line: " << fe.n_dofs_per_line() << std::endl;
  cout << "DOFS per quad: " << fe.n_dofs_per_quad() << std::endl;
  cout << "DOFS per hex: " << fe.n_dofs_per_hex() << std::endl;
  cout << "DOFS per face: " << fe.n_dofs_per_face() << std::endl;
  cout << "DOFS per cell: " << fe.n_dofs_per_cell() << std::endl;
  
  cout << "Unit Support Points: " <<  std::endl;

  const std::vector<Point<3> > &vPts = fe.get_unit_support_points();
  for (unsigned i =0; i < vPts.size(); i++)
    printf("%d) %g, %g, %g\n", i, vPts[i](0), vPts[i](1) , vPts[i](2));
  if (vPts.size() == 0)
    printf("None\n");




  //Now to see the values of the shape functions we need a triangulation
  //with one element in it.
  Triangulation<3> tria;
  Point<3> P1(0,0,0);
  Point<3> P2(1,1,1);
  std::vector<unsigned> v(3);
  v[0]=2;
  v[1]=2;
  v[2]=2;
  GridGenerator::subdivided_hyper_rectangle(tria,v,P1,P2);


  //We need a dofHandler too
  DoFHandler<3> dof(tria);
  dof.distribute_dofs(fe);
  DoFHandler<3>::active_cell_iterator cell = dof.begin_active();

  //Define the points where we will extract the values of the shape function.
  //These points are stored in the vector v and passed as argumento to the Quadrature class
  //who is responsible for the gaussian integration.
  std::vector<Point<3> > vQuad;
  vQuad.push_back(Point<3>(0,0,0));
  vQuad.push_back(Point<3>(1,0,0));
  vQuad.push_back(Point<3>(0,1,0));
  vQuad.push_back(Point<3>(1,1,0));
  vQuad.push_back(Point<3>(0,0,1));
  vQuad.push_back(Point<3>(1,0,1));
  vQuad.push_back(Point<3>(0,1,1));
  vQuad.push_back(Point<3>(1,1,1));

  std::vector<double> vWeights(8,1);
  Quadrature<3> quad(vQuad,vWeights);
  FEValues<3> feValues(fe,quad,UpdateFlags(update_values | update_JxW_values));
  feValues.reinit(cell);


  cout << "Shape Values At Vertex: " <<std::endl;
  for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
  {
    cout << "Shape Value: " << i <<"\n";
    for (unsigned int q_point=0; q_point < quad.size(); ++q_point)
    {
      cout << vQuad[q_point] << ":\t";
      for (unsigned int component=0; component < fe.n_components(); component++)
      {
        //cout << fe.shape_value_component(i, quad.point(q_point), component) << "\t";
        cout << feValues.shape_value_component(i,q_point,component);
        //cout << feValues.shape_value(i,q_point);

      }
      cout << std::endl;
    }
  }
  
  //  for (unsigned i=0;i<


}

void DealBaseDoFs::projectDofSolutionAtVertice	(	const DoFHandler< 3 > &	dofs,
		int	deg,
		const VecDouble &	vDofSol,
		VecDouble &	vSol
	)

---

The documentation for this class was generated from the following files:

• dealbasedofs.h
• dealbasedofs.cpp