GnuPlotDeal Class Reference

#include <gnuplotdeal.h>

Inheritance diagram for GnuPlotDeal:

[legend]

Collaboration diagram for GnuPlotDeal:

[legend]

List of all members.

Public Member Functions
	GnuPlotDeal ()
void	plotDealSolution (DoFHandler< 1 > &dof, const VecDouble &sol, std::string name="", std::string strComp="")
void	plotFunction1D (Function1D &f, double dStart, double dEnd, int nPoints, std::string name="", std::string strComp="", unsigned deg=0)
void	plotDealSolution (DoFHandler< 2 > &dofs, const VecDouble &sol, std::string name, std::string strComp, unsigned deg)
void	plotDealSolution (DoFHandler< 2 > &dofs, const VecDouble &sol, const VecDouble vU0, const VecDouble vU1, std::string name, std::string strComp, unsigned deg)
void	plotDealSolution (DoFHandler< 2 > &dofs, const VecDouble &sol, std::string name="", std::string strComp="")
void	plotDealSolutionAtVertices (Triangulation< 2 > &tria, const VecDouble &vSol, std::string name="", std::string strComp="")
void	plotDealSolutionAtVertices (Triangulation< 2 > &tria, const VecDouble &vSol, const VecDouble &vU0, const VecDouble &vU1, std::string name="", std::string strComp="", bool bScattered=false)
void	plotDealGradComponent (DoFHandler< 2 > &dofs, const VecDouble &sol, unsigned gradComp, std::string name="", std::string strComp="", VecDouble cVWeights=VecDouble())
void	plotDealSolutionComponent (DoFHandler< 2 > &dofs, const VecDouble &sol, unsigned comp, std::string name="", std::string strComp="")
void	plotDealVectorFieldAtVertices (DoFHandler< 2 > &dofs, VecDouble &sol, unsigned deg1, unsigned deg2, bool bScale=true, double factor=1.0, bool bNormalize=false, std::string name="", std::string strComp="")
void	plotDealGradientField2D (DoFHandler< 2 > &dofs, VecDouble &sol, unsigned deg, bool bScale=true, double factor=1.0, bool bNormalize=false, std::string name="", std::string strComp="")
void	plotDealVectorField2D (DoFHandler< 2 > &dofs, VecDouble &sol1, VecDouble &sol2, std::string name="", bool bScale=true, std::string strComp="")
void	plotDealVectorField2DAtCentralPoints (Triangulation< 2 > &tria, VecDouble &V1, VecDouble &V2, double factor=1.0, bool bScale=true, std::string name="", std::string strComp="")
void	plotDealVectorField2DGaussPoints (DoFHandler< 2 > &dofs, VecDouble &sol1, VecDouble &sol2, std::string name="", bool bScale=true, double factor=1.0, std::string strComp="")
void	plotDealGrid2D (const Triangulation< 2 > &tri, std::string name="", std::string strComp="")
void	plotDealDeformationGrid2D (DoFHandler< 2 > &dofs, const VecDouble &sol, std::string name="", std::string strComp="")
void	plotDealBoundary (DoFHandler< 2 > &dofs, unsigned boundary_indicator, std::string name="", std::string strComp="")
void	plotDealPoints (vector< Point< 2 > > &points, string name="", string strComp="")
void	plotDealSolutionDegAtVertex (DoFHandler< 1 > &dof, VecDouble &sol, vector< int > degOfVertex, std::string name="", std::string strComp="")
void	plotDealRadDeformationPoints (DoFHandler< 2 > &dof, VecDouble &sol, double degree, double _TOLERANCE, std::string name="", std::string strComp="")
void	plotDealCentralValuesSolution (const Triangulation< 2 > &trig, const VecDouble &cSol, std::string name="", std::string strComp="")
void	plotDealCentralPointsOfFlaggedCells (const Triangulation< 2 > &tria, const VecBool &cVFlags, std::string name="")
void	plotDealFlaggedVertices (const Triangulation< 2 > &tria, const VecBool &vVFlags, std::string name="", std::string strComp="")
void	plotFunction (const Triangulation< 2 > &tria, Function2D &f, std::string name="", std::string strComp="")
void	plotDealSolutionAtY (DoFHandler< 2 > &dofs, const VecDouble &sol, std::string name, std::string strComp, unsigned deg, double dAtY)
void	plotDealSolutionAtX (DoFHandler< 2 > &dofs, const VecDouble &sol, std::string name, std::string strComp, unsigned deg, double dAtX)
void	plotDealSolutionAtVerticesAtY (Triangulation< 2 > &tria, const VecDouble &vSol, double dAtY, std::string name="", std::string strComp="")
void	plotDealSolutionAtVerticesAtX (Triangulation< 2 > &tria, const VecDouble &vSol, double dAtX, std::string name="", std::string strComp="")
void	plotDealSolutionCentralPointsAtY (Triangulation< 2 > &tria, const VecDouble &vSol, double dAtY, std::string name="", std::string strComp="")
void	plotShapeFunctionsAtCell (const FiniteElement< 2 > &fe, DoFHandler< 2 >::cell_iterator &cell, unsigned nPoints)
void	plotMapInVectors (const VecDouble &v1, const VecDouble &v2, std::string name="", std::string strComp="")
void	plotCentralValuesAtFixedZ (Triangulation< 3 > &tria, const VecDouble &cSol, string name, string strComp, double atZ)
void	plotVerticeValuesAtFixedZ (Triangulation< 3 > &tria, const VecDouble &vSol, string name, string strComp, double atZ)
void	plotVerticeValuesAtFixedZ (OrthoMesh &mesh, const VecDouble &vSol, string name, string strComp, double atZ)
void	plotLineAlongZ (OrthoMesh &mesh, const VecDouble &vSol, string name, string strComp, double X1, double Y1)
void	plotLineAlongX (OrthoMesh &mesh, const VecDouble &vSol, string name, string strComp, double X1, double Y1)
Static Public Member Functions
static void	writeDataAlongX (OrthoMesh &mesh, const VecDouble &vSol, double Y, double Z, std::ostream &fout)
static void	writeDataAlongZ (OrthoMesh &mesh, const VecDouble &vSol, double X, double Y, std::ostream &fout)
Private Attributes
int	cnt

---

Detailed Description

Definition at line 16 of file gnuplotdeal.h.

---

Constructor & Destructor Documentation

GnuPlotDeal::GnuPlotDeal

(

)

[inline]

Definition at line 23 of file gnuplotdeal.h.

{cnt = 0;}

---

Member Function Documentation

void GnuPlotDeal::plotCentralValuesAtFixedZ	(	Triangulation< 3 > &	tria,
		const VecDouble &	cSol,
		string	name,
		string	strComp,
		double	atZ
	)

Plot vertices values information as a surface plot for a fixed Z value.

Parameters:

	tria	Triangulation
	cSol	Solution at cells
	name	Title of the plot
	atZ	Fixed Z Value

Returns:

Definition at line 1544 of file gnuplotdeal.cpp.

{
  assert(cSol.size() == tria.n_active_cells());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  
  fout << "#Central Values at Z = " << atZ <<  endl;
  
  Triangulation<3>::active_cell_iterator cell = tria.begin_active(),
                                         endc = tria.end();
  for (; cell!=endc; ++cell)
  {
    if ( atZ > cell->vertex(VERTEX_000)[2] && atZ < cell->vertex(VERTEX_001)[2])
    {
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << cSol(cell->index()) << "\n";
      fout << cell->vertex(VERTEX_100)[0] << " " << cell->vertex(VERTEX_100)[1] << " " << cSol(cell->index()) << "\n";
      fout << cell->vertex(VERTEX_110)[0] << " " << cell->vertex(VERTEX_110)[1] << " " << cSol(cell->index()) << "\n";
      fout << cell->vertex(VERTEX_010)[0] << " " << cell->vertex(VERTEX_010)[1] << " " << cSol(cell->index()) << "\n";
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << cSol(cell->index()) << "\n";
      fout << endl << endl;
    }
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
  
  return;
  

  
}

void GnuPlotDeal::plotDealBoundary	(	DoFHandler< 2 > &	dofs,
		unsigned	boundary_indicator,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 653 of file gnuplotdeal.cpp.

{
  const FiniteElement<2>       &fe           = dofs.get_fe();
  std::vector<unsigned int>       face_dofs (fe.dofs_per_face,DoFHandler<2>::invalid_dof_index);
  std::vector<Point<2> >       dof_locations (face_dofs.size(), Point<2>());
  std::vector<double>            dof_values_scalar (fe.dofs_per_face);
  std::vector<Point<2-1> >     unit_support_points = fe.get_unit_face_support_points();
  assert(unit_support_points.size() !=0);   //Tem que ser os elementos que estou habituado
  assert(fe.is_primitive());
  Quadrature<2-1>              aux_quad (unit_support_points);
  FEFaceValues<2>              fe_values (fe, aux_quad, update_q_points);
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Boundary Plotted by Deal for GnuPlot. Format <X,Y> <X,Y>\n";

  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),endc=dofs.end();
  for (; cell!=endc; ++cell)
  {
    for (unsigned int face_no = 0; face_no < GeometryInfo<2>::faces_per_cell;++face_no)
    {
      DoFHandler<2>::face_iterator face = cell->face(face_no);
      if (face->boundary_indicator() == boundary_indicator)
      {
           for (unsigned i=0;i<2;i++)
           {
             fout << face->vertex(i)(0) << " " << face->vertex(i)(1) << std::endl;
           }
      }
      fout << endl;
    }
  }
  fout.close();
  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
}

void GnuPlotDeal::plotDealCentralPointsOfFlaggedCells	(	const Triangulation< 2 > &	tria,
		const VecBool &	cVFlags,
		std::string	name = ""
	)

Objetivo: Plotar os pontos centrais de todas as celulas marcadas com flag em cVFlags

Definition at line 967 of file gnuplotdeal.cpp.

{
  assert(cVFlags.size() == tria.n_active_cells());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

  fout << "#Plotted Central Points of Flagged Cells" << endl;
  
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                           endc = tria.end();
  bool bFileEmpty=true;
  for (; cell!=endc; ++cell)
  {
    if (cVFlags[cell->index()])
    {
      bFileEmpty=false;
      for (unsigned j=0;j<2;j++)
        fout << cell->barycenter()[j] << " ";
      fout << 0 << "\n";
    }
  }
  if (!bFileEmpty)
  {
    fout.close();
    if (2 == 2)
      plotPoints3d(strFileName,name,"with points");
    else
      plotPoints(strFileName,name,"with points");
  }
  return;


}

void GnuPlotDeal::plotDealCentralValuesSolution	(	const Triangulation< 2 > &	trig,
		const VecDouble &	cSol,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar solucoes que sao constantes por celulas usando um vetor de solucao indexado pelos indices da celula.

Parametros: cSol = Solucao Cenral name = Nome do grafico. strComp = Complemento.

Retorno:

Definition at line 855 of file gnuplotdeal.cpp.

{
  assert(cSol.size() == trig.n_active_cells());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

  fout << "#Plotted For Const Central Values" << endl;
  
  Triangulation<2>::active_cell_iterator cell = trig.begin_active(),
                                           endc = trig.end();
  for (; cell!=endc; ++cell)
  {
    fout << cell->vertex(0)[0] << " " << cell->vertex(0)[1] << " " << cSol(cell->index()) << "\n";
    fout << cell->vertex(1)[0] << " " << cell->vertex(1)[1] << " " << cSol(cell->index()) << "\n";
    fout << cell->vertex(2)[0] << " " << cell->vertex(2)[1] << " " << cSol(cell->index()) << "\n";
    fout << cell->vertex(3)[0] << " " << cell->vertex(3)[1] << " " << cSol(cell->index()) << "\n";
    fout << cell->vertex(0)[0] << " " << cell->vertex(0)[1] << " " << cSol(cell->index()) << "\n";
    fout << endl << endl;
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
  
  return;
  
}

void GnuPlotDeal::plotDealDeformationGrid2D	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Somar aos pontos da triangulacao um deslocamento

Parametros: dofs = DofHandler sol = Solucao contendo o deslocamento a ser adicionado em cada ponto nodal Retorno:

Pre: Grau de Liberdade da malha ser igual ao da dimensao do espaco

Definition at line 590 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Grid Plotted by Deal. Format <X,Y>\n";
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                      endc = dofs.end();
  unsigned iVertex;

  //assert(dofs.get_fe().n_dofs_per_vertex()==2);
 
  for (; cell!=endc; ++cell)
  {
    //Para todos os vertices:
    for (iVertex=0;iVertex<GeometryInfo<2>::vertices_per_cell;iVertex++)
    {
      for (unsigned deg=0;deg<2;deg++)
      {
        fout << cell->vertex(iVertex)[deg]+sol(cell->vertex_dof_index(iVertex,deg)) << " ";
      }
      
      fout << endl;
    }
    iVertex=0;
    for (unsigned deg=0;deg<2;deg++)
    {
      fout << cell->vertex(iVertex)[deg]+sol(cell->vertex_dof_index(iVertex,deg)) << " ";
    }
    fout << endl;
    fout<< endl;
  }
  fout.close();

  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
  
  return;
}

void GnuPlotDeal::plotDealFlaggedVertices	(	const Triangulation< 2 > &	tria,
		const VecBool &	vVFlags,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar todos os vertices que estejam setados como true.

Definition at line 1008 of file gnuplotdeal.cpp.

{
  assert(vVFlags.size() == tria.n_vertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  bool empty=true;
  
  fout << "#Plotted Vertice Points of Flagged Cells" << endl;
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                           endc = tria.end();
  for (; cell!=endc; ++cell)
  {
    for (unsigned i =0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      if (vVFlags[cell->vertex_index(i)])
      {
        for (unsigned j=0;j<2;j++)
            fout << cell->vertex(i)[j] << " ";
        fout << "0 \n";
        empty=false;
        
      }
    }
  }
  fout << endl;
  fout.close();
  if (empty)
    return;
  if (2 == 2)
    plotPoints3d(strFileName,name,strComp);
  else
    plotPoints(strFileName,name,strComp);
  return;



}

void GnuPlotDeal::plotDealGradComponent	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		unsigned	gradComp,
		std::string	name = "",
		std::string	strComp = "",
		VecDouble	cVWeights = VecDouble ()
	)

Objetivo: Plotar gradientes

Parametros:

Retorno:

Definition at line 1334 of file gnuplotdeal.cpp.

{
  assert(cVWeights.size() == 0 || cVWeights.size() == dofs.get_tria().n_active_cells());
  
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  double factor;
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                        endc = dofs.end();

  std::vector< Point<2> > points;
  points.push_back(Point<2>(0,0));
  points.push_back(Point<2>(1,0));
  points.push_back(Point<2>(1,1));
  points.push_back(Point<2>(0,1));
  points.push_back(Point<2>(0,0));

  
  Quadrature<2> quad(points);

  FEValues<2> fe_values (dofs.get_fe(), quad, 
                         UpdateFlags(update_gradients|update_q_points));
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    fe_values.reinit(cell);
    if (cVWeights.size() != 0)
      factor = cVWeights(cell->index());
    else
      factor = 1;
    for (unsigned qPoint=0;qPoint<quad.n_quadrature_points;qPoint++)
    {
      double result=0;
      for (unsigned i=0;i<dofs_per_cell;i++)
        result += factor*sol(local_dof_indices[i])*fe_values.shape_grad(i,qPoint)[gradComp];
      fout << fe_values.quadrature_point(qPoint)[0] << " " << fe_values.quadrature_point(qPoint)[1] << " " << result << endl;
    }
    fout << endl << endl;
  }
  fout.close();
  plotPoints3d(strFileName,name,strComp);
  
}

void GnuPlotDeal::plotDealGradientField2D	(	DoFHandler< 2 > &	dofs,
		VecDouble &	sol,
		unsigned	deg,
		bool	bScale = true,
		double	factor = 1.0,
		bool	bNormalize = false,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar o gradiente de uma solucao de elementos finitos

Parametros: sol = Vetor Solucao nos graus de liberdade bScale = Se os vetores devem ser escalonados ou se todos devem ter tamanho iguais a "factor". factor = Fator de multiplicidade a ser aplicado a todos os vetores do campo de gradiente name = Nome do grafico strCom = String de opcoes de plotagem "Ver manual do Gnuplot"

Retorno:

Definition at line 386 of file gnuplotdeal.cpp.

{
  std::vector<Point<2> > Verts(4);
  Verts.push_back(Point<2> (0,0));
  Verts.push_back(Point<2> (1,0));
  Verts.push_back(Point<2> (1,1));
  Verts.push_back(Point<2> (0,1));

  Quadrature<2> quadrature(Verts);
  FEValues<2> fe_values (dofs.get_fe(), quadrature, 
                         UpdateFlags(update_gradients|update_q_points));
  std::ofstream fout;
  std::string strFileName = newDataFile(fout);
  unsigned dofs_per_cell = dofs.get_fe().dofs_per_cell;
  unsigned n_q_points = fe_values.n_quadrature_points;
  vector<unsigned> dofIndices(dofs.get_fe().dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                        endc = dofs.end();
  Point<2> Q,QAux;
  Tensor<1,2> V,VAux;
  double maxHyp=0.0;
  for (;cell!=endc; ++cell)
  {
    fe_values.reinit(cell);
    cell->get_dof_indices(dofIndices);
    for (unsigned q=0;q<n_q_points;q++)
    {
      Q = fe_values.quadrature_point(q);
      V*=0;
      for (unsigned i=0;i<dofs_per_cell;i++)
      {
        V += sol(dofIndices[i])*fe_values.shape_grad_component(i,q,deg);
      }
      double hyp = hypot(V[0],V[1]);
      if (bNormalize)
      {
        V/=hyp;
        hyp=1.0;
      }
      if (hyp > maxHyp) maxHyp = hyp;

      fout << Q(0) << " " << Q(1) << " " << V[0] << " " << V[1] << " " << endl;
      if (q == 0)
      {
        QAux = Q;
        VAux = V;
      }
    }
    fout << QAux(0) << " " << QAux(1) << " " << VAux[0] << " " << VAux[1] << " " << endl;
    fout << endl <<endl;
  }
  fout.close();
  double rad = dofs.begin_active()->diameter()/2.0;
  
  char strAux[100];
  if (bScale)
    sprintf(strAux," using 1:2:(%g*$3):(%g*$4) with vector ",factor*rad/maxHyp,factor*rad/maxHyp);
  else
    sprintf(strAux," with vector ");
    
  std::string strWith = strAux; 
  strWith+=strComp;
  plotPoints(strFileName,name,strWith);
}

void GnuPlotDeal::plotDealGrid2D	(	const Triangulation< 2 > &	tri,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 475 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  GridOut grid_out;
  grid_out.write_gnuplot(tri, fout);
  this->plotPoints(strFileName,name,strComp);

}

void GnuPlotDeal::plotDealPoints	(	vector< Point< 2 > > &	points,
		string	name = "",
		string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 707 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Plot Points sequence by Deal for GnuPlot. Format <X,Y> <X,Y>\n";
  for (unsigned i=0;i<points.size();i++)
  {
    fout << points[i](0) << " " << points[i](1) << endl;
    
  }
  fout.close();
  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
}

void GnuPlotDeal::plotDealRadDeformationPoints	(	DoFHandler< 2 > &	dofs,
		VecDouble &	sol,
		double	degree,
		double	_TOLERANCE,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 741 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Grid Plotted by Deal. Format <Inital Raio,End Raio>\n";
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                      endc = dofs.end();
  unsigned iVertex;

  degree=degree*M_PI/180.0;
  _TOLERANCE=_TOLERANCE*M_PI/180.0;
  
  assert(dofs.get_fe().n_dofs_per_vertex()==2);
 
  for (; cell!=endc; ++cell)
  {
   

    //Para todos os vertices:
    for (iVertex=0;iVertex<GeometryInfo<2>::vertices_per_cell;iVertex++)
    {
      const Point<2> &P = cell->vertex(iVertex);
      if (fabs(atan(P[1]/P[0]) - degree) < _TOLERANCE)
      {
        fout << hypot(P[0],P[1]) << " " << hypot(sol(cell->vertex_dof_index(iVertex,0)),sol(cell->vertex_dof_index(iVertex,1))) << "\n";
      }
    }
  }
  fout.close();

  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
  
  return;

}

void GnuPlotDeal::plotDealSolution	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 104 of file gnuplotdeal.cpp.

{
  unsigned i=0,deg=0;
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y + (todos graus de liberdade) " << deg << std::endl;  
  if (m_bPlot)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
    endc = dofs.end();
  unsigned n_components = dofs.get_fe().n_components();
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    for (i=0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      fout << cell->vertex(i)[0] << " " << cell->vertex(i)[1] << " ";
      for (deg=0;deg<n_components;deg++)
        fout << sol(cell->vertex_dof_index(i,deg)) << " ";
      fout << endl;
    }
    i=0;
    fout << cell->vertex(i)[0] << " " << cell->vertex(i)[1] << " ";
    for (deg=0;deg<n_components;deg++)
      fout << sol(cell->vertex_dof_index(i,deg)) << " ";
    fout << endl<<endl<<endl;
  }

  if (!m_bPlot3D) {
    fprintf(m_file,"splot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());   
    m_bPlot3D = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
  
  return;
}

void GnuPlotDeal::plotDealSolution	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		const VecDouble	vU0,
		const VecDouble	vU1,
		std::string	name,
		std::string	strComp,
		unsigned	deg
	)

Objetivo:

Parametros:

Retorno:

Definition at line 1096 of file gnuplotdeal.cpp.

{
  assert(vU0.size() == dofs.get_tria().n_vertices());
  assert(vU1.size() == dofs.get_tria().n_vertices());
  
  unsigned i=0;
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) no grau de liberdade " << deg << std::endl;  

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

  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    for (i =0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      fout << cell->vertex(i)[0] + vU0(cell->vertex_index(i)) << " ";
      fout << cell->vertex(i)[1] + vU1(cell->vertex_index(i)) << " ";
      fout << sol(cell->vertex_dof_index(i,deg)) << "\n"; 
    }
    i=0;
    fout << cell->vertex(i)[0] + vU0(cell->vertex_index(i)) << " ";
    fout << cell->vertex(i)[1] + vU1(cell->vertex_index(i)) << " ";
    fout << sol(cell->vertex_dof_index(i,deg)) << "\n\n\n"; 
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
               
  return;

}

void GnuPlotDeal::plotDealSolution	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		std::string	name,
		std::string	strComp,
		unsigned	deg
	)

Objetivo: Plotar um determinado grau de liberdade num espaço de dimensao 2.

Parametros: dof = DofHandler. sol = Vetor de solucoes. name = Titulo do grafico. strComp = Complemento. deg = Numero do grau de liberdade a ser plotado. Retorno:

Definition at line 160 of file gnuplotdeal.cpp.

{
  unsigned i=0;
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) no grau de liberdade " << deg << std::endl;  

  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                      endc = dofs.end();
  fout.precision(10);
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    for (i=0;i<GeometryInfo<2>::vertices_per_cell;i++)
      fout << cell->vertex(i)[0] << " " << cell->vertex(i)[1] << " " << sol(cell->vertex_dof_index(i,deg)) << endl;
    i=0;
    fout << cell->vertex(i)[0] << " " << cell->vertex(i)[1] << " " << sol(cell->vertex_dof_index(i,deg)) << endl << endl << endl;
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
               
  return;
}

void GnuPlotDeal::plotDealSolution	(	DoFHandler< 1 > &	dof,
		const VecDouble &	sol,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar solucao 1D

Parametros: dof = DofHandler sol = Vetor contendo as solucoes nos graus de liberdade

Retorno:

Definition at line 21 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  DataOut<1> data_out;
  data_out.attach_dof_handler (dof);
  data_out.add_data_vector ((DealVecDouble&)sol, name);
  data_out.build_patches ();
  data_out.write_gnuplot (fout);
  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
  return;

  
}

void GnuPlotDeal::plotDealSolutionAtVertices	(	Triangulation< 2 > &	tria,
		const VecDouble &	vSol,
		const VecDouble &	vU0,
		const VecDouble &	vU1,
		std::string	name = "",
		std::string	strComp = "",
		bool	bScattered = false
	)

Definition at line 917 of file gnuplotdeal.cpp.

{
  assert(vU0.size()  == tria.n_vertices());
  assert(vU1.size()  == tria.n_vertices());
  assert(vSol.size() == tria.n_vertices());
  unsigned i;
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

  fout << "#Plotted For Vertices Values With Deformation" << endl;
  
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                           endc = tria.end();
  for (; cell!=endc; ++cell)
  {
    for (i =0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      fout << cell->vertex(i)[0] + vU0(cell->vertex_index(i)) << " ";
      fout << cell->vertex(i)[1] + vU1(cell->vertex_index(i)) << " ";
      fout << vSol(cell->vertex_index(i)) << "\n"; 
    }
    if (!bScattered)
    {
      i=0;
      fout << cell->vertex(i)[0] + vU0(cell->vertex_index(i)) << " ";
      fout << cell->vertex(i)[1] + vU1(cell->vertex_index(i)) << " ";
      fout << vSol(cell->vertex_index(i)) << "\n\n\n"; 
    }
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
  return;

}

void GnuPlotDeal::plotDealSolutionAtVertices	(	Triangulation< 2 > &	tria,
		const VecDouble &	vSol,
		std::string	name = "",
		std::string	strComp = ""
	)

Definition at line 883 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == tria.n_vertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  unsigned i;
  fout << "#Plotted For Vertices Values" << endl;
  
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                           endc = tria.end();
  for (; cell!=endc; ++cell)
  {
    for (i =0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      for (unsigned j=0;j<2;j++)
        fout << cell->vertex(i)[j] << " ";
      fout << vSol(cell->vertex_index(i)) << "\n"; 
    }
    i=0;
    for (unsigned j=0;j<2;j++)
      fout << cell->vertex(i)[j] << " ";
    fout << vSol(cell->vertex_index(i)) << "\n"; 
    

    fout << "\n\n";
  }
  fout.close();
  plotPoints3d(strFileName,name,strComp);
  return;

}

void GnuPlotDeal::plotDealSolutionAtVerticesAtX	(	Triangulation< 2 > &	tria,
		const VecDouble &	vSol,
		double	dAtX,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 1456 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) em " << dAtX << std::endl;  

  Triangulation<2>::active_cell_iterator cell = tria.begin_active();
  Triangulation<2>::active_cell_iterator endc = tria.end();

  double Tolerance = fabs(cell->vertex(BL_VERTEX)[1] - cell->vertex(UL_VERTEX)[1])/2.0;
  for (; cell!=endc; ++cell)
  {
    if ( fabs(cell->vertex(BL_VERTEX)[0]-dAtX) < Tolerance && fabs(cell->vertex(UL_VERTEX)[0]-dAtX) < Tolerance)
    {
      fout << cell->vertex(BL_VERTEX)[1] << " " << vSol(cell->vertex_index(BL_VERTEX)) << endl;
      fout << cell->vertex(UL_VERTEX)[1] << " " << vSol(cell->vertex_index(UL_VERTEX)) << endl << endl << endl;
    }
    else if ( fabs(cell->vertex(BR_VERTEX)[0]-dAtX) < Tolerance && fabs(cell->vertex(UR_VERTEX)[0]-dAtX) < Tolerance)
    {
      fout << cell->vertex(BR_VERTEX)[1] << " " << vSol(cell->vertex_index(BR_VERTEX)) << endl;
      fout << cell->vertex(UR_VERTEX)[1] << " " << vSol(cell->vertex_index(UR_VERTEX)) << endl << endl << endl;
    }

  }
  fout.close();

  plotPoints(strFileName,name,strComp);
               
  return;

}

void GnuPlotDeal::plotDealSolutionAtVerticesAtY	(	Triangulation< 2 > &	tria,
		const VecDouble &	vSol,
		double	dAtY,
		std::string	name = "",
		std::string	strComp = ""
	)

Definition at line 1192 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) nos vertices com Y == " << dAtY << std::endl;  

  
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                         endc = tria.end();

  double Tolerance = fabs(cell->vertex(BL_VERTEX)[1] - cell->vertex(UL_VERTEX)[1])/2.0;
  for (; cell!=endc; ++cell)
  {
    if ( fabs(cell->vertex(BL_VERTEX)[1]-dAtY) < Tolerance && fabs(cell->vertex(BR_VERTEX)[1]-dAtY) < Tolerance)
    {
      fout << cell->vertex(BL_VERTEX)[0] << " " << vSol(cell->vertex_index(BL_VERTEX)) << endl;
      fout << cell->vertex(BR_VERTEX)[0] << " " << vSol(cell->vertex_index(BR_VERTEX)) << endl << endl << endl;
    }
    else if ( fabs(cell->vertex(UL_VERTEX)[1]-dAtY) < Tolerance && fabs(cell->vertex(UR_VERTEX)[1]-dAtY) < Tolerance)
    {
      fout << cell->vertex(UL_VERTEX)[0] << " " << vSol(cell->vertex_index(UL_VERTEX)) << endl;
      fout << cell->vertex(UR_VERTEX)[0] << " " << vSol(cell->vertex_index(UR_VERTEX)) << endl << endl << endl;
    }

  }
  fout.close();

  plotPoints(strFileName,name,strComp);
               
  return;

}

void GnuPlotDeal::plotDealSolutionAtX	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		std::string	name,
		std::string	strComp,
		unsigned	deg,
		double	dAtX
	)

Objetivo:

Parametros:

Retorno:

Definition at line 1233 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) no grau de liberdade " << deg << std::endl;  

  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                      endc = dofs.end();

  double Tolerance = fabs(cell->vertex(BL_VERTEX)[1] - cell->vertex(UL_VERTEX)[1])/2.0;
  for (; cell!=endc; ++cell)
  {
    if ( fabs(cell->vertex(BL_VERTEX)[0]-dAtX) < Tolerance && fabs(cell->vertex(UL_VERTEX)[0]-dAtX) < Tolerance)
    {
      fout << cell->vertex(BL_VERTEX)[1] << " " << sol(cell->vertex_dof_index(BL_VERTEX,deg)) << endl;
      fout << cell->vertex(UL_VERTEX)[1] << " " << sol(cell->vertex_dof_index(UL_VERTEX,deg)) << endl << endl << endl;
    }
    else if ( fabs(cell->vertex(BR_VERTEX)[0]-dAtX) < Tolerance && fabs(cell->vertex(UR_VERTEX)[0]-dAtX) < Tolerance)
    {
      fout << cell->vertex(BR_VERTEX)[1] << " " << sol(cell->vertex_dof_index(BR_VERTEX,deg)) << endl;
      fout << cell->vertex(UR_VERTEX)[1] << " " << sol(cell->vertex_dof_index(UR_VERTEX,deg)) << endl << endl << endl;
    }

  }
  fout.close();

  plotPoints(strFileName,name,strComp);
               
  return;

}

void GnuPlotDeal::plotDealSolutionAtY	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		std::string	name,
		std::string	strComp,
		unsigned	deg,
		double	dAtY
	)

Definition at line 1135 of file gnuplotdeal.cpp.

{
  
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) no grau de liberdade " << deg << std::endl;  

  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                      endc = dofs.end();

  double Tolerance = fabs(cell->vertex(BL_VERTEX)[1] - cell->vertex(UL_VERTEX)[1])/2.0;
  for (; cell!=endc; ++cell)
  {
    if ( fabs(cell->vertex(BL_VERTEX)[1]-dAtY) < Tolerance && fabs(cell->vertex(BR_VERTEX)[1]-dAtY) < Tolerance)
    {
      fout << cell->vertex(BL_VERTEX)[0] << " " << sol(cell->vertex_dof_index(BL_VERTEX,deg)) << endl;
      fout << cell->vertex(BR_VERTEX)[0] << " " << sol(cell->vertex_dof_index(BR_VERTEX,deg)) << endl << endl << endl;
    }
    else if ( fabs(cell->vertex(UL_VERTEX)[1]-dAtY) < Tolerance && fabs(cell->vertex(UR_VERTEX)[1]-dAtY) < Tolerance)
    {
      fout << cell->vertex(UL_VERTEX)[0] << " " << sol(cell->vertex_dof_index(UL_VERTEX,deg)) << endl;
      fout << cell->vertex(UR_VERTEX)[0] << " " << sol(cell->vertex_dof_index(UR_VERTEX,deg)) << endl << endl << endl;
    }

  }
  fout.close();

  plotPoints(strFileName,name,strComp);
               
  return;

}

void GnuPlotDeal::plotDealSolutionCentralPointsAtY	(	Triangulation< 2 > &	tria,
		const VecDouble &	vSol,
		double	dAtY,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 1499 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == tria.n_active_cells());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotando x y f(x,y) nos vertices com Y == " << dAtY << std::endl;  

  
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
    endc = tria.end(),cellFront;

  double Tolerance = fabs(cell->vertex(BL_VERTEX)[1] - cell->vertex(UL_VERTEX)[1])*0.7;
  for (; cell!=endc; ++cell)
  {
    if ( fabs(cell->vertex(BL_VERTEX)[1]-dAtY) < Tolerance && fabs(cell->vertex(BR_VERTEX)[1]-dAtY) < Tolerance)
    {
      if (cell->face(LEFT_CELL)->at_boundary())
        break;
    }
  }
  assert(cell->face(LEFT_CELL)->at_boundary());
  
  while(! cell->face(RIGHT_CELL)->at_boundary())
  {
    cellFront = cell->neighbor(RIGHT_CELL);
    fout <<  cell->vertex(BR_VERTEX)[0] << " " <<  ( vSol(cell->index()) + vSol(cellFront->index()) )/2.0  << "\n";
    cell=cellFront;
  }
  fout.close();

  plotPoints(strFileName,name,strComp);
               
  return;


}

void GnuPlotDeal::plotDealSolutionComponent	(	DoFHandler< 2 > &	dofs,
		const VecDouble &	sol,
		unsigned	comp,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plota nos vertices de cada elemento a componente comp das shape_functions da solucao sol.

Definition at line 1387 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

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

  std::vector< Point<2> > points;
  points.push_back(Point<2>(0,0));
  points.push_back(Point<2>(1,0));
  points.push_back(Point<2>(1,1));
  points.push_back(Point<2>(0,1));
  points.push_back(Point<2>(0,0));

  Quadrature<2> quad(points);

  FEValues<2> fe_values (dofs.get_fe(), quad, 
                         UpdateFlags(update_values|update_q_points));
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    fe_values.reinit(cell);
    for (unsigned qPoint=0;qPoint<quad.n_quadrature_points;qPoint++)
    {
      double result=0;
      for (unsigned i=0;i<dofs_per_cell;i++)
        result += sol(local_dof_indices[i])*fe_values.shape_value_component(i,qPoint,comp);
      fout << fe_values.quadrature_point(qPoint)[0] << " " << fe_values.quadrature_point(qPoint)[1] << " " << result << endl;
    }
    fout << endl << endl;
  }
  fout.close();
  plotPoints3d(strFileName,name,strComp);

}

void GnuPlotDeal::plotDealSolutionDegAtVertex	(	DoFHandler< 1 > &	dofs,
		VecDouble &	sol,
		vector< int >	degOfVertex,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar solucao 1D

Parametros: dof = DofHandler sol = Vetor contendo as solucoes nos graus de liberdade degOfVertex = Vetor de 0 e 1, onde degOfVertex(i) retorna o grau de liberdade a ser usado no vertice i. Retorno:

Definition at line 58 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Plotted For Discontinuos Galerkin" << endl;
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<1>::active_cell_iterator cell = dofs.begin_active(),
                                        endc = dofs.end();
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    for (unsigned i=0;i<2;i++)
      fout << cell->vertex(i)[0] << " " << sol(cell->vertex_dof_index(i,degOfVertex[i])) << endl;
    fout << endl;
  }
  fout.close();
  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());    
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());        
  }
  return;

  
}

void GnuPlotDeal::plotDealVectorField2D	(	DoFHandler< 2 > &	dofs,
		VecDouble &	sol1,
		VecDouble &	sol2,
		std::string	name = "",
		bool	bScale = true,
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 286 of file gnuplotdeal.cpp.

{


  string strFileName = getDataFileName(); 
  double aux,MaxNorm = 0.0,MaxDiameter=0.0;;
  int NumPoints = 0;
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }
  fout << "#Vector Field Plotted by Deal. Format <X,Y,DX,DY>\n";
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                        endc = dofs.end();
  for (; cell!=endc; ++cell)
  {
    cell->get_dof_indices (local_dof_indices);
    Point2D p;
    double diam = cell->diameter();
    if (diam >  MaxDiameter)
    {
      MaxDiameter = diam;
    }
    for (unsigned int i=0; i<dofs_per_cell; ++i,NumPoints++)
    {
      p(0) = sol1(local_dof_indices[i]);
      p(1) = sol2(local_dof_indices[i]);
      aux = sqrt(p.square());
      if (aux > MaxNorm)
        MaxNorm = aux;
    }
  }
  FullMatrix<double> M(NumPoints,4);
  int lineCnt = 0;
  double factor = MaxDiameter/(MaxNorm*2.0);

  if (bScale)
  {
    cell = dofs.begin_active();
    for (; cell!=endc; ++cell)
    {
      cell->get_dof_indices (local_dof_indices);
      for (unsigned int i=0; i<dofs_per_cell; ++i,lineCnt++)
      {
        M(lineCnt,0) = cell->vertex(i)[0];
        M(lineCnt,1) = cell->vertex(i)[1];
        M(lineCnt,2) = sol1(local_dof_indices[i])*factor;
        M(lineCnt,3) = sol2(local_dof_indices[i])*factor;
      }
    }
  }
  else{
    cell = dofs.begin_active();
    for (; cell!=endc; ++cell)
    {
      cell->get_dof_indices (local_dof_indices);
      for (unsigned int i=0; i<dofs_per_cell; ++i,lineCnt++)
      {
        M(lineCnt,0) = cell->vertex(i)[0];
        M(lineCnt,1) = cell->vertex(i)[1];
        M(lineCnt,2) = sol1(local_dof_indices[i]);
        M(lineCnt,3) = sol2(local_dof_indices[i]);
        factor = 1.0/hypot(M(lineCnt,2),M(lineCnt,3));
        M(lineCnt,2)*=factor*MaxDiameter/2.0;
        M(lineCnt,3)*=factor*MaxDiameter/2.0;
      }
    }
  }
    
  M.print_formatted(fout,6,false,0,"0,0");
  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" with vector %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());        
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" with vector %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());    
  }
  return;
}

void GnuPlotDeal::plotDealVectorField2DAtCentralPoints	(	Triangulation< 2 > &	tria,
		VecDouble &	V1,
		VecDouble &	V2,
		double	factor = 1.0,
		bool	bScale = true,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plota um campo de velocidade nos pontos centrais das celulas.

Parametros: tria = Triangulacao. V1 = Componente 1 da velocidade nos centros das celulas. V2 = Componente 2 da velocidade nos centros das celulas. Ambos vetores indexados pelos indices das celulas. bFactor = Constante a multiplicar ambos vetores de velocidade. bScale = Se os vetores devem ser ajustados de tal forma que caibam em apenas uma celula. Retorno:

Definition at line 806 of file gnuplotdeal.cpp.

{
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                         endc = tria.end();

  std::ofstream fout;
  std::string  strFileName = newDataFile(fout);
  double MaxNorm=0,hyp;
  double rad = cell->diameter()/2.0;
  rad = sqrt(cell->measure())/2.0;  
  for (;cell!=endc; ++cell)
  {
    Point2D XM = cell->barycenter();
    fout << XM(0) << " "
         << XM(1) << " "
         << V1(cell->index())*factor  << " "
         << V2(cell->index())*factor  << "\n\n";
    hyp=hypot(V1(cell->index()),V2(cell->index())); 
    if (MaxNorm < hyp) MaxNorm=hyp;
    
  }
  fout << std::endl;
  if (MaxNorm==0)
    MaxNorm= 1.0;
  char strAux[100];
  if (bScale)
    sprintf(strAux," using 1:2:(%g*$3):(%g*$4) with vector ",rad/MaxNorm,rad/MaxNorm);
  else
    sprintf(strAux," with vector ");
    
  std::string strWith = strAux; 
  strWith+=strComp;
  plotPoints(strFileName,name,strWith);
  
}

void GnuPlotDeal::plotDealVectorField2DGaussPoints	(	DoFHandler< 2 > &	dofs,
		VecDouble &	sol1,
		VecDouble &	sol2,
		std::string	name = "",
		bool	bScale = true,
		double	factor = 1.0,
		std::string	strComp = ""
	)

Objetivo:

Parametros:

Retorno:

Definition at line 493 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  double norm,MaxNorm=0.0,MaxMeasure=0.0;
  unsigned k;
  if (m_bPlot3D)
  {
          std::cerr << "Graficos 2D e 3D na mesma cena nao pode ser feito\n";
          this->finalize();
  }

  fout << "#Plot Gradients on Gauss Points"; 
  QGauss<2>  quadrature_formula(2);
  FEValues<2> fe_values (dofs.get_fe(), quadrature_formula, 
                         UpdateFlags(update_values    |
                                     update_gradients | update_q_points |
                                     update_JxW_values));
  
  const unsigned int   dofs_per_cell = dofs.get_fe().dofs_per_cell;
  const unsigned int   n_q_points    = quadrature_formula.n_quadrature_points;
  
  FullMatrix<double> M(dofs.get_tria().n_active_quads()*4,4);
  M = 0;
  std::vector<unsigned int> local_dof_indices (dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
    endc = dofs.end();
  for (k=0; cell!=endc; ++cell)
  {
    fe_values.reinit (cell);
    cell->get_dof_indices(local_dof_indices);
    for (unsigned int q_point=0; q_point<n_q_points; ++q_point,k++)
    {
      M(k,0) = (fe_values.quadrature_point(q_point)[0]);
      M(k,1) = (fe_values.quadrature_point(q_point)[1]);
      for (unsigned int i=0; i<dofs_per_cell; ++i)
      {
        M(k,2)+= sol1(local_dof_indices[i])*fe_values.shape_value(i, q_point);
        M(k,3)+= sol2(local_dof_indices[i])*fe_values.shape_value(i, q_point);
      }
      double hyp = hypot(M(k,2),M(k,3));
      if (!bScale)
      {
        if (hyp >1.0E-08)
        {
          norm = 1.0/hyp * sqrt(fe_values.JxW (q_point))*factor;
        }
        else{
          norm = 0.0;
        }
        M(k,2)*=norm;
        M(k,3)*=norm;
      }
      else
      {
        if (hyp > MaxNorm) MaxNorm=hyp;
        if (MaxMeasure < fe_values.JxW(q_point)) MaxMeasure = fe_values.JxW(q_point);
      }
    }
  }
  if (bScale)
  {
    double c = sqrt(MaxMeasure)/(MaxNorm)*factor;
    for (k=0;k<M.size(0);k++)
    {
      M(k,2)*=c;
      M(k,3)*=c;
    }
  }
  M.print_formatted(fout,6,false,0,"0,0");

  if (!m_bPlot) {
    fprintf(m_file,"plot \"%s\" with vector %s title \"%s\" ",strFileName.c_str(),strComp.c_str(),name.c_str());        
    m_bPlot = true;
  }
  else {
    fprintf(m_file,", \"%s\" with vector %s title \"%s\"",strFileName.c_str(),strComp.c_str(),name.c_str());    
  }


  
}

void GnuPlotDeal::plotDealVectorFieldAtVertices	(	DoFHandler< 2 > &	dofs,
		VecDouble &	sol,
		unsigned	deg1,
		unsigned	deg2,
		bool	bScale = true,
		double	factor = 1.0,
		bool	bNormalize = false,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar um campo vetorial 2D.

Parametros: dof = DofHandler. sol = Vetor de solucoes. deg1 = Grau da primeira componente da velocidade. deg2 = Grau da segunda componente da velocidade. bScale = Se os vetores devem ser escalonados de tal forma que um nai interfira com o outro. factor = Constante a ser multiplicada a todos os vetores. bNormalize = Se os vetores devem ser normalizados.

name = Titulo do grafico. strComp = Complemento. Retorno:

Definition at line 207 of file gnuplotdeal.cpp.

{
  std::vector<Point<2> > Verts(4);
  Verts.push_back(Point<2> (0,0));
  Verts.push_back(Point<2> (1,0));
  Verts.push_back(Point<2> (1,1));
  Verts.push_back(Point<2> (0,1));

  Quadrature<2> quadrature(Verts);
  FEValues<2> fe_values (dofs.get_fe(), quadrature, 
                         UpdateFlags(update_values|update_q_points));
  std::ofstream fout;
  std::string strFileName = newDataFile(fout);
  unsigned dofs_per_cell = dofs.get_fe().dofs_per_cell;
  unsigned n_q_points = fe_values.n_quadrature_points;
  vector<unsigned> dofIndices(dofs.get_fe().dofs_per_cell);
  
  DoFHandler<2>::active_cell_iterator cell = dofs.begin_active(),
                                        endc = dofs.end();
  Point<2> Q,V,QAux,VAux;
  double maxHyp=0.0;
  for (;cell!=endc; ++cell)
  {
    fe_values.reinit(cell);
    cell->get_dof_indices(dofIndices);
    for (unsigned q=0;q<n_q_points;q++)
    {
      Q = fe_values.quadrature_point(q);
      V*=0;
      for (unsigned i=0;i<dofs_per_cell;i++)
      {
        V(0) += sol(dofIndices[i])*fe_values.shape_value_component(i,q,deg1);
        V(1) += sol(dofIndices[i])*fe_values.shape_value_component(i,q,deg2);
      }
      double hyp = hypot(V(0),V(1));
      if (bNormalize)
      {
        V/=hyp;
        hyp=1.0;
      }
      if (hyp > maxHyp) maxHyp = hyp;

      fout << Q(0) << " " << Q(1) << " " << V(0) << " " << V(1) << " " << endl;
      if (q == 0)
      {
        QAux = Q;
        VAux = V;
      }
    }
    fout << QAux(0) << " " << QAux(1) << " " << VAux(0) << " " << VAux(1) << " " << endl;
    fout << endl <<endl;
  }
  fout.close();
  double rad = dofs.begin_active()->diameter()/2.0;
  
  char strAux[100];
  if (bScale)
    sprintf(strAux," using 1:2:(%g*$3):(%g*$4) with vector ",factor*rad/maxHyp,factor*rad/maxHyp);
  else
    sprintf(strAux," with vector ");
    
  std::string strWith = strAux; 
  strWith+=strComp;
  plotPoints(strFileName,name,strWith);
}

void GnuPlotDeal::plotFunction	(	const Triangulation< 2 > &	tria,
		Function2D &	f,
		std::string	name = "",
		std::string	strComp = ""
	)

Definition at line 1047 of file gnuplotdeal.cpp.

{
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  Triangulation<2>::active_cell_iterator cell = tria.begin_active(),
                                           endc = tria.end();
  unsigned i;
  for (; cell!=endc; ++cell)
  {
    for (i =0;i<GeometryInfo<2>::vertices_per_cell;i++)
    {
      for (unsigned j=0;j<2;j++)
        fout << cell->vertex(i)[j] << " ";
      fout << f(cell->vertex(i)) << "\n"; 
    }
    i=0;
    
    for (unsigned j=0;j<2;j++)
      fout << cell->vertex(i)[j] << " ";
    fout << f(cell->vertex(i)) << "\n"; 
    

    fout << "\n\n";
  }
  fout.close();


  if (2 == 1)
  {
    plotPoints(strFileName,name,strComp);
  }
  if (2 == 2)
  {
    plotPoints3d(strFileName,name,strComp);
  }
    
  return;
  
}

void GnuPlotDeal::plotFunction1D	(	Function1D &	f,
		double	dStart,
		double	dEnd,
		int	nPoints,
		std::string	name = "",
		std::string	strComp = "",
		unsigned	deg = 0
	)

Definition at line 1170 of file gnuplotdeal.cpp.

{
  double dP;
  double dx = (dEnd - dStart)/nPoints;


  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  fout << "#Plotting Function1D" << std::endl;  

  for (dP = dStart;dP<=dEnd;dP+=dx)
  {
    Point1D P(dP);
    fout << dP << " " << f(P,deg) << endl;
  }
  fout.close();
  plotPoints(strFileName,name,strComp);
  return;

}

void GnuPlotDeal::plotLineAlongX	(	OrthoMesh &	mesh,
		const VecDouble &	vSol,
		string	name,
		string	strComp,
		double	X1,
		double	Y1
	)

Definition at line 1693 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == mesh.numVertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());

  
  writeDataAlongX(mesh,vSol,Y,Z,fout); 
  plotPoints(strFileName,name,strComp);
  
  return;

}

void GnuPlotDeal::plotLineAlongZ	(	OrthoMesh &	mesh,
		const VecDouble &	vSol,
		string	name,
		string	strComp,
		double	X1,
		double	Y1
	)

Definition at line 1651 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == mesh.numVertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  
  fout << "#Values along Z (" << X  <<  ", "  << Y << ", Z)\n" ;
  
  OrthoMesh::Cell_It cell = mesh.begin_cell(),
    endc = mesh.end_cell();
  bool found=false;
  for (; cell!=endc; cell++)
  {
    if ( X >= cell->vertex(VERTEX_000)[0] && X <= cell->vertex(VERTEX_110)[0] &&
         Y >= cell->vertex(VERTEX_000)[1] && Y <= cell->vertex(VERTEX_110)[1])
    {
      found=true;
      break;
    }
  }
  if (!found)
  {
    printf("GnuPlot Warning: Point %g %g does not belong to domain\n",X,Y);
    fout.close();
    return;
  }

  fout << cell->vertex(VERTEX_000)[2] << " "  << vSol(cell->vertex_index(VERTEX_000)) << std::endl;
  fout << cell->vertex(VERTEX_001)[2] << " "  << vSol(cell->vertex_index(VERTEX_001)) << std::endl;
  while (cell->advance(UP_CELL))
  {
    fout << cell->vertex(VERTEX_001)[2] << " "  << vSol(cell->vertex_index(VERTEX_001)) << std::endl;
  } 

  plotPoints(strFileName,name,strComp);
  
  return;

}

void GnuPlotDeal::plotMapInVectors	(	const VecDouble &	v1,
		const VecDouble &	v2,
		std::string	name = "",
		std::string	strComp = ""
	)

Objetivo: Plotar o mapeamento (v1(i),v2(i)),i=[0..v1.size()-1]

Definition at line 1432 of file gnuplotdeal.cpp.

{
  if (v1.size()!=v2.size()) abort();
  
  double dd[v1.size()*2];
  unsigned j=0;
  for (unsigned i=0;i<v1.size();i++)
  {
    assert(j<v1.size()*2);
    dd[j++]=v1(i);
    dd[j++]=v2(i);
  }
  this->plotPoints(dd,v1.size(),2,name,"",strComp,true,false);
}

void GnuPlotDeal::plotShapeFunctionsAtCell	(	const FiniteElement< 2 > &	fe,
		DoFHandler< 2 >::cell_iterator &	cell,
		unsigned	nPoints
	)

Definition at line 1274 of file gnuplotdeal.cpp.

{
  double dx =  1.0/nPoints;
  char str[500];
  Point<2> p(0,0);

  int n_shape_functions = fe.n_dofs_per_cell();
  std::string strFileName;
  std::ofstream fout;
  
  //Build the quadrature;
  p[0]=p[1]=0;
  std::vector<Point<2> > lstPts; 
  unsigned isoLinesCount;
  for (unsigned i=0;i<=nPoints;i++,p[0]+=dx)
  {
    for (unsigned j=0;j<=nPoints;j++,p[1]+=dx)
      lstPts.push_back(p);
    p[1]=0;
  }
  Quadrature<2> quadrature(lstPts);
  FEValues<2> fe_values (fe, quadrature, 
                         UpdateFlags(update_values|update_q_points));

  fe_values.reinit(cell);
  for (int iShape=0;iShape<n_shape_functions;iShape++)
  {
    for (unsigned component=0;component<fe.get_nonzero_components(iShape).size();component++)
    {
      
      if (fe.get_nonzero_components(iShape)[component])
      {
        sprintf(str,"Shape: %d Comp: %d",iShape,component);
        strFileName=newDataFile(fout);
        isoLinesCount = 1;
        for (unsigned qPoint=0;qPoint < fe_values.n_quadrature_points;qPoint++,isoLinesCount++)
        {
          fout << fe_values.quadrature_point(qPoint)[0] << " " << fe_values.quadrature_point(qPoint)[1] << " " <<fe_values.shape_value_component(iShape,qPoint,component) << "\n";
          if (isoLinesCount > nPoints)
          {
            isoLinesCount = 0;
            fout << "\n";
          }
        }
                    
        fout.close();
        plotPoints3d(strFileName,str,"with lines");
      }
    }
  }
}

void GnuPlotDeal::plotVerticeValuesAtFixedZ	(	OrthoMesh &	mesh,
		const VecDouble &	vSol,
		string	name,
		string	strComp,
		double	atZ
	)

Definition at line 1618 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == mesh.numVertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  
  fout << "#Central Values at Z = " << atZ <<  endl;
  
  OrthoMesh::Cell_It cell = mesh.begin_cell(),
    endc = mesh.end_cell();
  for (; cell!=endc; cell++)
  {
    if ( atZ >= cell->vertex(VERTEX_000)[2] && atZ < cell->vertex(VERTEX_001)[2])
    {
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << vSol(cell->vertex_index(VERTEX_000)) << "\n";
      fout << cell->vertex(VERTEX_100)[0] << " " << cell->vertex(VERTEX_100)[1] << " " << vSol(cell->vertex_index(VERTEX_100)) << "\n";
      fout << cell->vertex(VERTEX_110)[0] << " " << cell->vertex(VERTEX_110)[1] << " " << vSol(cell->vertex_index(VERTEX_110)) << "\n";
      fout << cell->vertex(VERTEX_010)[0] << " " << cell->vertex(VERTEX_010)[1] << " " << vSol(cell->vertex_index(VERTEX_010)) << "\n";
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << vSol(cell->vertex_index(VERTEX_000)) << "\n";
      fout << endl << endl;
    }
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
  
  return;

}

void GnuPlotDeal::plotVerticeValuesAtFixedZ	(	Triangulation< 3 > &	tria,
		const VecDouble &	vSol,
		string	name,
		string	strComp,
		double	atZ
	)

Plot vertices values information as a surface plot for a fixed Z value.

Parameters:

	tria	Triangulation
	cSol	Solution at cells
	name	Title of the plot
	atZ	Fixed Z Value

Returns:

Definition at line 1585 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == tria.n_vertices());
  string strFileName = getDataFileName(); 
  m_List.push_back(strFileName); 
  std::ofstream fout(strFileName.c_str());
  
  fout << "#Central Values at Z = " << atZ <<  endl;
  
  Triangulation<3>::active_cell_iterator cell = tria.begin_active(),
                                         endc = tria.end();
  for (; cell!=endc; ++cell)
  {
    if ( atZ > cell->vertex(VERTEX_000)[2] && atZ < cell->vertex(VERTEX_001)[2])
    {
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << vSol(cell->vertex_index(VERTEX_000)) << "\n";
      fout << cell->vertex(VERTEX_100)[0] << " " << cell->vertex(VERTEX_100)[1] << " " << vSol(cell->vertex_index(VERTEX_100)) << "\n";
      fout << cell->vertex(VERTEX_110)[0] << " " << cell->vertex(VERTEX_110)[1] << " " << vSol(cell->vertex_index(VERTEX_110)) << "\n";
      fout << cell->vertex(VERTEX_010)[0] << " " << cell->vertex(VERTEX_010)[1] << " " << vSol(cell->vertex_index(VERTEX_010)) << "\n";
      fout << cell->vertex(VERTEX_000)[0] << " " << cell->vertex(VERTEX_000)[1] << " " << vSol(cell->vertex_index(VERTEX_000)) << "\n";
      fout << endl << endl;
    }
  }
  fout.close();

  plotPoints3d(strFileName,name,strComp);
  
  return;

}

void GnuPlotDeal::writeDataAlongX	(	OrthoMesh &	mesh,
		const VecDouble &	vSol,
		double	Y,
		double	Z,
		std::ostream &	fout
	)			[static]

Definition at line 1709 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == mesh.numVertices());
  fout << "#Values along X (" << "X"  <<  ", "  << Y << ", " <<  Z << " )\n" ;
  
  OrthoMesh::Cell_It cell = mesh.begin_cell(),
    endc = mesh.end_cell();
  bool found=false;
  for (; cell!=endc; cell++)
  {
    if ( Y >= cell->vertex(VERTEX_000)[1] && Y <= cell->vertex(VERTEX_111)[1] &&
         Z >= cell->vertex(VERTEX_000)[2] && Y <= cell->vertex(VERTEX_111)[2])
    {
      found=true;
      break;
    }
  }
  if (!found)
  {
    printf("GnuPlot Warning: Point %g %g does not belong to domain\n",Y,Z);
    fout.flush();
    return;
  }

  fout << cell->vertex(VERTEX_000)[0] << " "  << vSol(cell->vertex_index(VERTEX_000)) << std::endl;
  fout << cell->vertex(VERTEX_100)[0] << " "  << vSol(cell->vertex_index(VERTEX_100)) << std::endl;
  while (cell->advance(RIGHT_CELL))
  {
    fout << cell->vertex(VERTEX_100)[0] << " "  << vSol(cell->vertex_index(VERTEX_100)) << std::endl;
  } 

  return;


}

void GnuPlotDeal::writeDataAlongZ	(	OrthoMesh &	mesh,
		const VecDouble &	vSol,
		double	X,
		double	Y,
		std::ostream &	fout
	)			[static]

Definition at line 1746 of file gnuplotdeal.cpp.

{
  assert(vSol.size() == mesh.numVertices());
  
  fout << "#Values along Z (" <<  X  <<  ", "  << Y << ", " <<  "Z" << " )\n" ;
  
  OrthoMesh::Cell_It cell = mesh.begin_cell(),
    endc = mesh.end_cell();
  bool found=false;
  for (; cell!=endc; cell++)
  {
    if ( X >= cell->vertex(VERTEX_000)[0] && X <= cell->vertex(VERTEX_111)[0] &&
         Y >= cell->vertex(VERTEX_000)[1] && Y <= cell->vertex(VERTEX_111)[1])
    {
      found=true;
      break;
    }
  }
  if (!found)
  {
    printf("GnuPlot Warning: Point %g %g does not belong to domain\n",X,Y);
    fout.flush();
    return;
  }

  fout << cell->vertex(VERTEX_000)[2] << " "  << vSol(cell->vertex_index(VERTEX_000)) << std::endl;
  fout << cell->vertex(VERTEX_001)[2] << " "  << vSol(cell->vertex_index(VERTEX_001)) << std::endl;
  while (cell->advance(UP_CELL))
  {
    fout << cell->vertex(VERTEX_001)[2] << " "  << vSol(cell->vertex_index(VERTEX_001)) << std::endl;
  } 

  return;



}

---

Member Data Documentation

int GnuPlotDeal::cnt [private]

Definition at line 19 of file gnuplotdeal.h.

---

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

• gnuplotdeal.h
• gnuplotdeal.cpp