Converter from fld to dat. More...

#include <OutputTecplot.h>

Inheritance diagram for Nektar::Utilities::OutputTecplot:

Collaboration diagram for Nektar::Utilities::OutputTecplot:

Public Member Functions
	OutputTecplot (FieldSharedPtr f)

virtual	~OutputTecplot ()

virtual void	Process (po::variables_map &vm)
	Write fld to output file. More...

Public Member Functions inherited from Nektar::Utilities::OutputModule
	OutputModule (FieldSharedPtr p_f)

void	OpenStream ()
	Open a file for output. More...

	OutputModule (MeshSharedPtr p_m)

void	OpenStream ()

Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)

void	RegisterConfig (string key, string value)
	Register a configuration option with a module. More...

void	PrintConfig ()
	Print out all configuration options for a module. More...

void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

bool	GetRequireEquiSpaced (void)

void	SetRequireEquiSpaced (bool pVal)

void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

	Module (MeshSharedPtr p_m)

virtual void	Process ()=0

void	RegisterConfig (string key, string value)

void	PrintConfig ()

void	SetDefaults ()

MeshSharedPtr	GetMesh ()

virtual void	ProcessVertices ()
	Extract element vertices. More...

Static Public Member Functions
static boost::shared_ptr< Module >	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	m_className

Private Member Functions
void	WriteTecplotHeader (std::ofstream &outfile, std::string var)

void	WriteTecplotZone (std::ofstream &outfile)

int	GetNumTecplotBlocks (void)

void	WriteTecplotField (const int field, std::ofstream &outfile)

void	WriteTecplotConnectivity (std::ofstream &outfile)

Private Attributes
bool	m_doError

TecOutType	m_outputType

Additional Inherited Members
Protected Member Functions inherited from Nektar::Utilities::Module
	Module ()

virtual void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...

virtual void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...

virtual void	ProcessElements ()
	Generate element IDs. More...

virtual void	ProcessComposites ()
	Generate composites. More...

void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...

void	PrismLines (int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)

Protected Attributes inherited from Nektar::Utilities::OutputModule
ofstream	m_fldFile
	Output stream. More...

std::ofstream	m_mshFile
	Output stream. More...

Protected Attributes inherited from Nektar::Utilities::Module
FieldSharedPtr	m_f
	Field object. More...

map< string, ConfigOption >	m_config
	List of configuration values. More...

bool	m_requireEquiSpaced

MeshSharedPtr	m_mesh
	Mesh object. More...

Detailed Description

Converter from fld to dat.

Definition at line 55 of file OutputTecplot.h.

Constructor & Destructor Documentation

Nektar::Utilities::OutputTecplot::OutputTecplot ( FieldSharedPtr f )

Definition at line 56 of file OutputTecplot.cpp.

References Nektar::Utilities::eFullBlockZone, Nektar::Utilities::eFullBlockZoneEquiSpaced, m_outputType, and Nektar::Utilities::Module::m_requireEquiSpaced.

                                              : OutputModule(f)
 {
     if(f->m_setUpEquiSpacedFields)
     {
         m_outputType = eFullBlockZoneEquiSpaced;
     }
     else
     {
         m_requireEquiSpaced = true;
         m_outputType = eFullBlockZone;
     }
 }

Nektar::Utilities::OutputTecplot::~OutputTecplot ( )

virtual

Definition at line 69 of file OutputTecplot.cpp.

70 {

71 }

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::OutputTecplot::create ( FieldSharedPtr f )

inlinestatic

Creates an instance of this class.

Definition at line 59 of file OutputTecplot.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

                                                                 {
             return MemoryManager<OutputTecplot>::AllocateSharedPtr(f);
         }

int Nektar::Utilities::OutputTecplot::GetNumTecplotBlocks ( void )

private

Definition at line 420 of file OutputTecplot.cpp.

References Nektar::Utilities::Module::m_f.

Referenced by WriteTecplotZone().

 {
     int returnval = 0;
 
     if(m_f->m_exp[0]->GetExp(0)->GetNumBases() == 1)
     {
         for(int i = 0; i < m_f->m_exp[0]->GetNumElmts(); ++i)
         {
             returnval += (m_f->m_exp[0]->GetExp(i)->GetNumPoints(0)-1);
         }
     }
     else  if(m_f->m_exp[0]->GetExp(0)->GetNumBases() == 2)
     {
         for(int i = 0; i < m_f->m_exp[0]->GetNumElmts(); ++i)
         {
             returnval += (m_f->m_exp[0]->GetExp(i)->GetNumPoints(0)-1)*
                 (m_f->m_exp[0]->GetExp(i)->GetNumPoints(1)-1);
         }
     }
     else
     {
         for(int i = 0; i < m_f->m_exp[0]->GetNumElmts(); ++i)
         {
             returnval += (m_f->m_exp[0]->GetExp(i)->GetNumPoints(0)-1)*
                 (m_f->m_exp[0]->GetExp(i)->GetNumPoints(1)-1)*
                 (m_f->m_exp[0]->GetExp(i)->GetNumPoints(2)-1);
         }
     }
 
     return returnval;
 }

void Nektar::Utilities::OutputTecplot::Process ( po::variables_map & vm )

virtual

Write fld to output file.

Implements Nektar::Utilities::Module.

Definition at line 73 of file OutputTecplot.cpp.

References ASSERTL0, Nektar::LibUtilities::ePtsFile, Nektar::LibUtilities::ePtsLine, Nektar::LibUtilities::ePtsPlane, Nektar::LibUtilities::ePtsTetBlock, Nektar::LibUtilities::ePtsTriBlock, Nektar::Utilities::Module::m_config, m_doError, Nektar::Utilities::Module::m_f, Nektar::LibUtilities::NullPtsField, WriteTecplotConnectivity(), WriteTecplotField(), WriteTecplotHeader(), and WriteTecplotZone().

 {
     LibUtilities::PtsFieldSharedPtr fPts = m_f->m_fieldPts;
 
     m_doError = (vm.count("error") == 1)?  true: false;
 
     if (m_f->m_verbose)
     {
         cout << "OutputTecplot: Writing file..." << endl;
     }
     // Do nothing if no expansion defined
     if (fPts == LibUtilities::NullPtsField && !m_f->m_exp.size())
     {
         return;
     }
 
 
     // Extract the output filename and extension
     string filename = m_config["outfile"].as<string>();
 
     // Amend for parallel output if required
     if(m_f->m_session->GetComm()->GetSize() != 1)
     {
         int    dot = filename.find_last_of('.');
         string ext = filename.substr(dot,filename.length()-dot);
         string procId = "_P" + boost::lexical_cast<std::string>(
                                  m_f->m_session->GetComm()->GetRank());
         string start = filename.substr(0,dot);
         filename = start + procId + ext;
     }
 
     if(fPts != LibUtilities::NullPtsField)
     {
         int i   = 0;
         int j   = 0;
         int dim = fPts->GetDim();
 
         if(fPts->GetNpoints() == 0)
         {
             return;
         }
 
         // Write solution.
         ofstream outfile(filename.c_str());
 
         switch(dim)
         {
         case 1:
             outfile << "VARIABLES = x";
             break;
         case 2:
             outfile << "VARIABLES = x,y";
             break;
         case 3:
             outfile << "VARIABLES = x,y,z";
             break;
         }
 
         vector<Array<OneD, int> > ptsConn;
         fPts->GetConnectivity(ptsConn);
 
         for(i = 0; i < fPts->GetNFields(); ++i)
         {
             outfile << "," << fPts->GetFieldName(i);
         }
         outfile << endl;
         bool DumpAsFEPoint = true;
         switch(fPts->GetPtsType())
         {
             case LibUtilities::ePtsFile:
             case LibUtilities::ePtsLine:
             {
                 outfile << " ZONE I="
                         << fPts->GetNpoints()
                         << " F=POINT" << endl;
                 break;
             }
             case LibUtilities::ePtsPlane:
             {
                 outfile << " ZONE I=" << fPts->GetPointsPerEdge(0)
                         <<      " J=" << fPts->GetPointsPerEdge(1)
                         << " F=POINT" << endl;
                 break;
             }
             case LibUtilities::ePtsTriBlock:
             {
                 int numBlocks = 0;
                 for(i = 0; i < ptsConn.size(); ++i)
                 {
                     numBlocks +=
                         ptsConn[i].num_elements()/3;
                 }
                 outfile << "Zone, N="
                         << fPts->GetNpoints()
                         << ", E=" << numBlocks
                         << ", F=FEBlock" << ", ET=TRIANGLE"
                         << std::endl;
                 DumpAsFEPoint = false;
                 break;
             }
             case LibUtilities::ePtsTetBlock:
             {
                 int numBlocks = 0;
                 for(i = 0; i < ptsConn.size(); ++i)
                 {
                     numBlocks +=
                         ptsConn[i].num_elements()/4;
                 }
                 outfile << "Zone, N="
                         << fPts->GetNpoints()
                         << ", E=" << numBlocks
                         << ", F=FEBlock" << ", ET=TETRAHEDRON"
                         << std::endl;
                 DumpAsFEPoint = false;
                 break;
             }
             default:
                 ASSERTL0(false, "ptsType not supported yet.");
         }
 
         if(DumpAsFEPoint) // dump in point format
         {
             for(i = 0; i < fPts->GetNpoints(); ++i)
             {
                 for(j = 0; j < dim; ++j)
                 {
                     outfile << std::setw(12)
                             << fPts->GetPointVal(j, i) << " ";
                 }
 
                 for(j = 0; j < fPts->GetNFields(); ++j)
                 {
                     outfile << std::setw(12)
                             << m_f->m_data[j][i] << " ";
                 }
                 outfile << endl;
             }
         }
         else // dump in block format
         {
             for(j = 0; j < dim + fPts->GetNFields(); ++j)
             {
                 for(i = 0; i < fPts->GetNpoints(); ++i)
                 {
                     outfile <<  fPts->GetPointVal(j, i) << " ";
                     if((!(i % 1000))&&i)
                     {
                         outfile << std::endl;
                     }
                 }
                 outfile << endl;
             }
 
             // dump connectivity data if it exists
             for(i = 0; i < ptsConn.size();++i)
             {
                 for(j = 0; j < ptsConn[i].num_elements(); ++j)
                 {
                     outfile << ptsConn[i][j] +1 << " ";
                     if( ( !(j % 10 * dim) ) && j )
                     {
                         outfile << std::endl;
                     }
                 }
             }
         }
     }
     else
     {
 
         // Write solution.
         ofstream outfile(filename.c_str());
         std::string var;
         std::vector<LibUtilities::FieldDefinitionsSharedPtr> fDef =
                                                         m_f->m_fielddef;
         if (fDef.size())
         {
             var = fDef[0]->m_fields[0];
 
             for (int j = 1; j < fDef[0]->m_fields.size(); ++j)
             {
                 var = var + ", " + fDef[0]->m_fields[j];
             }
         }
 
         WriteTecplotHeader(outfile,var);
         WriteTecplotZone(outfile);
         if(var.length()) // see if any variables are defined
         {
             for(int j = 0; j < m_f->m_exp.size(); ++j)
             {
                 WriteTecplotField(j,outfile);
             }
         }
 
         WriteTecplotConnectivity(outfile);
     }
 
     cout << "Written file: " << filename << endl;
 }

void Nektar::Utilities::OutputTecplot::WriteTecplotConnectivity ( std::ofstream & outfile )

private

Definition at line 505 of file OutputTecplot.cpp.

References ASSERTL0, Nektar::MultiRegions::e3DH1D, and Nektar::Utilities::Module::m_f.

Referenced by Process().

 {
     int i,j,k,l;
     int nbase = m_f->m_exp[0]->GetExp(0)->GetNumBases();
     int cnt = 0;
 
     for(i = 0; i < m_f->m_exp[0]->GetNumElmts(); ++i)
     {
         if(nbase == 1)
         {
             int np0 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(0);
 
             for(k = 1; k < np0; ++k)
             {
                 outfile << cnt + k +1 << " ";
                 outfile << cnt + k    << endl;
             }
 
             cnt += np0;
         }
         else if(nbase == 2)
         {
             int np0 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(0);
             int np1 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(1);
             int totPoints = m_f->m_exp[0]->GetTotPoints();
             int nPlanes = 1;
 
             if (m_f->m_exp[0]->GetExpType() == MultiRegions::e3DH1D)
             {
                 nPlanes = m_f->m_exp[0]->GetZIDs().num_elements();
                 totPoints = m_f->m_exp[0]->GetPlane(0)->GetTotPoints();
 
 
                 for(int n = 1; n < nPlanes; ++n)
                 {
                     for(j = 1; j < np1; ++j)
                     {
                         for(k = 1; k < np0; ++k)
                         {
                             outfile << cnt + (n-1)*totPoints + (j-1)*np0 + k
                                     << " ";
                             outfile << cnt + (n-1)*totPoints + (j-1)*np0 + k + 1
                                     << " ";
                             outfile << cnt + (n-1)*totPoints + j*np0 + k + 1
                                     << " ";
                             outfile << cnt + (n-1)*totPoints + j*np0 + k
                                     << " ";
 
                             outfile << cnt + n*totPoints + (j-1)*np0 + k
                                     << " ";
                             outfile << cnt + n*totPoints + (j-1)*np0 + k + 1
                                     << " ";
                             outfile << cnt + n*totPoints + j*np0 + k + 1
                                     << " ";
                             outfile << cnt + n*totPoints + j*np0 + k    << endl;
                         }
                     }
                 }
                 cnt += np0*np1;
             }
             else
             {
                 for(j = 1; j < np1; ++j)
                 {
                     for(k = 1; k < np0; ++k)
                     {
                         outfile << cnt + (j-1)*np0 + k  << " ";
                         outfile << cnt + (j-1)*np0 + k +1 << " ";
                         outfile << cnt + j*np0 + k +1 << " ";
                         outfile << cnt + j*np0 + k    << endl;
                     }
                 }
                 cnt += np0*np1;
             }
         }
         else if(nbase == 3)
         {
             int np0 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(0);
             int np1 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(1);
             int np2 = m_f->m_exp[0]->GetExp(i)->GetNumPoints(2);
 
             for(j = 1; j < np2; ++j)
             {
                 for(k = 1; k < np1; ++k)
                 {
                     for(l = 1; l < np0; ++l)
                     {
                         outfile << cnt + (j-1)*np0*np1 + (k-1)*np0 + l  << " ";
                         outfile << cnt + (j-1)*np0*np1 + (k-1)*np0 + l +1 << " ";
                         outfile << cnt + (j-1)*np0*np1 +  k*np0 + l +1 << " ";
                         outfile << cnt + (j-1)*np0*np1 +  k*np0 + l  << " ";
 
                         outfile << cnt + j*np0*np1 + (k-1)*np0 + l  << " ";
                         outfile << cnt + j*np0*np1 + (k-1)*np0 + l +1 << " ";
                         outfile << cnt + j*np0*np1 +  k*np0 + l +1 << " ";
                         outfile << cnt + j*np0*np1 +  k*np0 + l  << endl;
                     }
                 }
             }
             cnt += np0*np1*np2;
         }
         else
         {
             ASSERTL0(false,"Not set up for this dimension");
         }
 
     }
 }

void Nektar::Utilities::OutputTecplot::WriteTecplotField	(	const int	field,
		std::ofstream &	outfile
	)

private

Write Tecplot Files Field

Parameters

outfile	Output file name.
expansion	Expansion that is considered

Definition at line 458 of file OutputTecplot.cpp.

References Nektar::Utilities::eFullBlockZone, m_doError, Nektar::Utilities::Module::m_f, and m_outputType.

Referenced by Process().

 {
 
     if(m_outputType == eFullBlockZone) //write as full block zone
     {
         int totpoints = m_f->m_exp[0]->GetTotPoints();
 
         if(m_f->m_exp[field]->GetPhysState() == false)
         {
             m_f->m_exp[field]->BwdTrans(m_f->m_exp[field]->GetCoeffs(),
                                         m_f->m_exp[field]->UpdatePhys());
         }
 
         if (m_doError)
         {
             NekDouble l2err = m_f->m_exp[0]->L2(m_f->m_exp[field]->UpdatePhys());
 
             if(m_f->m_session->GetComm()->GetRank() == 0)
             {
                 cout << "L 2 error (variable "
                      << m_f->m_fielddef[0]->m_fields[field]  << ") : "
                      << l2err  << endl;
             }
         }
         else
         {
             for(int i = 0; i < totpoints; ++i)
             {
                 outfile << m_f->m_exp[field]->GetPhys()[i] << " ";
                 if((!(i % 1000))&&i)
                 {
                     outfile << std::endl;
                 }
             }
         }
         outfile << std::endl;
     }
     else
     {
         for(int e = 0; e < m_f->m_exp[field]->GetExpSize(); ++e)
         {
             m_f->m_exp[field]->WriteTecplotField(outfile,e);
         }
     }
 }

void Nektar::Utilities::OutputTecplot::WriteTecplotHeader	(	std::ofstream &	outfile,
		std::string	var
	)

private

Write Tecplot Files Header

Parameters

outfile	Output file name.
var	variables names

Definition at line 279 of file OutputTecplot.cpp.

References Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, and Nektar::Utilities::Module::m_f.

Referenced by Process().

 {
     int coordim  = m_f->m_exp[0]->GetExp(0)->GetCoordim();
     MultiRegions::ExpansionType HomoExpType = m_f->m_exp[0]->GetExpType();
 
     if(HomoExpType == MultiRegions::e3DH1D)
     {
         coordim +=1;
     }
     else if (HomoExpType == MultiRegions::e3DH2D)
     {
         coordim += 2;
     }
 
     outfile << "Variables = x";
 
     if(coordim == 2)
     {
         outfile << ", y";
     }
     else if (coordim == 3)
     {
         outfile << ", y, z";
     }
 
     if(var.length())
     {
         outfile << ", "<< var << std::endl << std::endl;
     }
     else
     {
         outfile << std::endl << std::endl;
     }
 }

void Nektar::Utilities::OutputTecplot::WriteTecplotZone ( std::ofstream & outfile )

private

Write Tecplot Files Zone

Parameters

outfile	Output file name.
expansion	Expansion that is considered

Definition at line 321 of file OutputTecplot.cpp.

References ASSERTL0, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, Nektar::Utilities::eFullBlockZone, Nektar::Utilities::eFullBlockZoneEquiSpaced, Nektar::Utilities::eSeperateZones, GetNumTecplotBlocks(), m_doError, Nektar::Utilities::Module::m_f, and m_outputType.

Referenced by Process().

 {
     switch(m_outputType)
     {
         case eFullBlockZone: //write as full block zone
         {
             int i,j;
             int coordim   = m_f->m_exp[0]->GetCoordim(0);
             int totpoints = m_f->m_exp[0]->GetTotPoints();
             MultiRegions::ExpansionType HomoExpType = m_f->m_exp[0]->GetExpType();
 
             Array<OneD,NekDouble> coords[3];
 
             coords[0] = Array<OneD,NekDouble>(totpoints);
             coords[1] = Array<OneD,NekDouble>(totpoints);
             coords[2] = Array<OneD,NekDouble>(totpoints);
 
             m_f->m_exp[0]->GetCoords(coords[0],coords[1],coords[2]);
 
             if (m_doError)
             {
                 NekDouble l2err;
                 std::string coordval[] = {"x","y","z"};
                 int rank = m_f->m_session->GetComm()->GetRank();
 
                 for(int i = 0; i < coordim; ++i)
                 {
                     l2err = m_f->m_exp[0]->L2(coords[i]);
                     if(rank == 0)
                     {
                         cout << "L 2 error (variable "
                              << coordval[i]  << ") : " << l2err  << endl;
                     }
                 }
             }
 
             int numBlocks = GetNumTecplotBlocks();
             int nBases = m_f->m_exp[0]->GetExp(0)->GetNumBases();
 
             if (HomoExpType == MultiRegions::e3DH1D)
             {
                 nBases  += 1;
                 coordim += 1;
                 int nPlanes = m_f->m_exp[0]->GetZIDs().num_elements();
                 NekDouble tmp = numBlocks * (nPlanes-1);
                 numBlocks = (int)tmp;
             }
             else if (HomoExpType == MultiRegions::e3DH2D)
             {
                 nBases  += 2;
                 coordim += 1;
             }
 
             outfile << "Zone, N=" << totpoints << ", E="<<
                 numBlocks << ", F=FEBlock" ;
 
             switch(nBases)
             {
             case 1:
                 outfile << ", ET=LINESEG" << std::endl;
                 break;
             case 2:
                 outfile << ", ET=QUADRILATERAL" << std::endl;
                 break;
             case 3:
                 outfile << ", ET=BRICK" << std::endl;
                 break;
             }
 
             // write out coordinates in block format
             for(j = 0; j < coordim; ++j)
             {
                 for(i = 0; i < totpoints; ++i)
                 {
                     outfile << coords[j][i] << " ";
                     if((!(i % 1000))&&i)
                     {
                         outfile << std::endl;
                     }
                 }
                 outfile << std::endl;
             }
             break;
         }
         case eSeperateZones:
         {
             for(int i = 0; i < m_f->m_exp[0]->GetExpSize(); ++i)
             {
                 m_f->m_exp[0]->WriteTecplotZone(outfile,i);
             }
             break;
         }
         case eFullBlockZoneEquiSpaced:
             ASSERTL0(false,
                      "Should not have this option in this method");
             break;
     }
 }

Member Data Documentation

ModuleKey Nektar::Utilities::OutputTecplot::m_className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eOutputModule, "dat"), OutputTecplot::create,
        "Writes a Tecplot file.")

Definition at line 62 of file OutputTecplot.h.

bool Nektar::Utilities::OutputTecplot::m_doError

private

Definition at line 70 of file OutputTecplot.h.

Referenced by Process(), WriteTecplotField(), and WriteTecplotZone().

TecOutType Nektar::Utilities::OutputTecplot::m_outputType

private

Definition at line 71 of file OutputTecplot.h.

Referenced by OutputTecplot(), WriteTecplotField(), and WriteTecplotZone().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation