Tecplot output class. More...

#include <OutputTecplot.h>

Inheritance diagram for Nektar::FieldUtils::OutputTecplot:

Collaboration diagram for Nektar::FieldUtils::OutputTecplot:

Public Member Functions
	OutputTecplot (FieldSharedPtr f)

virtual	~OutputTecplot ()

virtual void	Process (po::variables_map &vm)
	Set up member variables to dump Tecplot format output. More...

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

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

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

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

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

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

FIELD_UTILS_EXPORT bool	GetRequireEquiSpaced (void)

FIELD_UTILS_EXPORT void	SetRequireEquiSpaced (bool pVal)

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

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

Protected Member Functions
virtual void	WriteTecplotHeader (std::ofstream &outfile, std::vector< std::string > &var)
	Write Tecplot files header. More...

virtual void	WriteTecplotZone (std::ofstream &outfile)

virtual void	WriteTecplotConnectivity (std::ofstream &outfile)
	Write Tecplot connectivity information (ASCII) More...

int	GetNumTecplotBlocks ()
	Calculate number of Tecplot blocks. More...

void	CalculateConnectivity ()
	Calculate connectivity information for each expansion dimension. More...

virtual std::string	GetModuleName ()
	Returns this module's name. More...

Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()

Protected Attributes
bool	m_binary
	True if writing binary field output. More...

bool	m_oneOutputFile
	True if writing a single output file. More...

TecplotZoneType	m_zoneType
	Tecplot zone type of output. More...

vector< int >	m_numPoints
	Number of points per block in Tecplot file. More...

int	m_numBlocks
	Number of blocks in Tecplot file. More...

int	m_coordim
	Coordinate dimension of output. More...

int	m_totConn
	Total number of connectivity entries. More...

vector< Array< OneD, int > >	m_conn
	Connectivty for each block: one per element. More...

Array< OneD, int >	m_rankFieldSizes
	Each rank's field sizes. More...

Array< OneD, int >	m_rankConnSizes
	Each rank's connectivity sizes. More...

Array< OneD, Array< OneD, NekDouble > >	m_fields
	Field data to output. More...

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

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

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

bool	m_requireEquiSpaced

Detailed Description

Tecplot output class.

Definition at line 61 of file OutputTecplot.h.

Constructor & Destructor Documentation

Nektar::FieldUtils::OutputTecplot::OutputTecplot ( FieldSharedPtr f )

Definition at line 73 of file OutputTecplot.cpp.

References Nektar::FieldUtils::Module::m_config, and Nektar::FieldUtils::Module::m_requireEquiSpaced.

                                              : OutputModule(f),
                                                  m_binary(false),
                                                  m_oneOutputFile(false)
 {
     if (!f->m_setUpEquiSpacedFields)
     {
         m_requireEquiSpaced = true;
     }
     m_config["writemultiplefiles"] =
         ConfigOption(true,"0","Write multiple files in parallel");
 }

Nektar::FieldUtils::OutputTecplot::~OutputTecplot ( )

virtual

Definition at line 85 of file OutputTecplot.cpp.

86 {

87 }

Member Function Documentation

void Nektar::FieldUtils::OutputTecplot::CalculateConnectivity ( )

protected

Calculate connectivity information for each expansion dimension.

Parameters

outfile Output file

Definition at line 920 of file OutputTecplot.cpp.

References ASSERTL0, Nektar::MultiRegions::e3DH1D, m_conn, and Nektar::FieldUtils::Module::m_f.

Referenced by Process().

 {
     int i, j, k, l;
     int nbase = m_f->m_exp[0]->GetExp(0)->GetNumBases();
     int cnt   = 0;
 
     m_conn.resize(m_f->m_exp[0]->GetNumElmts());
 
     for (i = 0; i < m_f->m_exp[0]->GetNumElmts(); ++i)
     {
         cnt = m_f->m_exp[0]->GetPhys_Offset(i);
 
         if (nbase == 1)
         {
             int cnt2 = 0;
             int np0  = m_f->m_exp[0]->GetExp(i)->GetNumPoints(0);
 
             Array<OneD, int> conn(2 * (np0 - 1));
 
             for (k = 1; k < np0; ++k)
             {
                 conn[cnt2++] = cnt + k;
                 conn[cnt2++] = cnt + k - 1;
             }
 
             m_conn[i] = conn;
         }
         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;
             int cnt2      = 0;
 
             if (m_f->m_exp[0]->GetExpType() == MultiRegions::e3DH1D)
             {
                 nPlanes = m_f->m_exp[0]->GetZIDs().num_elements();
 
                 // default to 2D case for HalfMode when nPlanes = 1
                 if (nPlanes > 1)
                 {
                     totPoints = m_f->m_exp[0]->GetPlane(0)->GetTotPoints();
 
                     Array<OneD, int> conn(8 * (np1 - 1) * (np0 - 1) * (nPlanes - 1));
 
                     for (int n = 1; n < nPlanes; ++n)
                     {
                         for (j = 1; j < np1; ++j)
                         {
                             for (k = 1; k < np0; ++k)
                             {
                                 conn[cnt2++] = cnt + (n - 1) * totPoints +
                                     (j - 1) * np0 + k - 1;
                                 conn[cnt2++] = cnt + (n - 1) * totPoints +
                                     (j - 1) * np0 + k;
                                 conn[cnt2++] = cnt + (n - 1) * totPoints +
                                     j * np0 + k;
                                 conn[cnt2++] = cnt + (n - 1) * totPoints +
                                     j * np0 + k - 1;
                                 conn[cnt2++] = cnt + n * totPoints +
                                     (j - 1) * np0 + k - 1;
                                 conn[cnt2++] = cnt + n * totPoints +
                                     (j - 1) * np0 + k;
                                 conn[cnt2++] = cnt + n * totPoints +
                                     j * np0 + k;
                                 conn[cnt2++] = cnt + n * totPoints +
                                     j * np0 + k - 1;
                             }
                         }
                     }
                     m_conn[i] = conn;
                 }
             }
 
             if (nPlanes == 1)
             {
                 Array<OneD, int> conn(4 * (np0 - 1) * (np1 - 1));
                 for (j = 1; j < np1; ++j)
                 {
                     for (k = 1; k < np0; ++k)
                     {
                         conn[cnt2++] = cnt + (j - 1) * np0 + k - 1;
                         conn[cnt2++] = cnt + (j - 1) * np0 + k;
                         conn[cnt2++] = cnt + j * np0 + k;
                         conn[cnt2++] = cnt + j * np0 + k - 1;
                     }
                 }
                 m_conn[i] = conn;
             }
         }
         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);
             int cnt2 = 0;
 
             Array<OneD, int> conn(8 * (np0 - 1) * (np1 - 1) * (np2 - 1));
 
             for (j = 1; j < np2; ++j)
             {
                 for (k = 1; k < np1; ++k)
                 {
                     for (l = 1; l < np0; ++l)
                     {
                         conn[cnt2++] =
                             cnt + (j - 1) * np0 * np1 + (k - 1) * np0 + l - 1;
                         conn[cnt2++] =
                             cnt + (j - 1) * np0 * np1 + (k - 1) * np0 + l;
                         conn[cnt2++] =
                             cnt + (j - 1) * np0 * np1 + k * np0 + l;
                         conn[cnt2++] =
                             cnt + (j - 1) * np0 * np1 + k * np0 + l - 1;
                         conn[cnt2++] =
                             cnt + j * np0 * np1 + (k - 1) * np0 + l - 1;
                         conn[cnt2++] =
                             cnt + j * np0 * np1 + (k - 1) * np0 + l;
                         conn[cnt2++] =
                             cnt + j * np0 * np1 + k * np0 + l;
                         conn[cnt2++] =
                             cnt + j * np0 * np1 + k * np0 + l - 1;
                     }
                 }
             }
 
             m_conn[i] = conn;
         }
         else
         {
             ASSERTL0(false, "Not set up for this dimension");
         }
 
     }
 }

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

inlinestatic

Creates an instance of this class.

Definition at line 65 of file OutputTecplot.h.

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

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

virtual std::string Nektar::FieldUtils::OutputTecplot::GetModuleName ( )

inlineprotectedvirtual

Returns this module's name.

Implements Nektar::FieldUtils::Module.

Definition at line 109 of file OutputTecplot.h.

     {
         return "OutputTecplot";
     }

int Nektar::FieldUtils::OutputTecplot::GetNumTecplotBlocks ( )

protected

Calculate number of Tecplot blocks.

Parameters

outfile Output file

Definition at line 883 of file OutputTecplot.cpp.

References Nektar::FieldUtils::Module::m_f.

Referenced by Process().

 {
     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::FieldUtils::OutputTecplot::Process ( po::variables_map & vm )

virtual

Set up member variables to dump Tecplot format output.

Implements Nektar::FieldUtils::Module.

Definition at line 143 of file OutputTecplot.cpp.

 {
     LibUtilities::PtsFieldSharedPtr fPts = m_f->m_fieldPts;
 
     m_numBlocks = 0;
 
     // Do nothing if no expansion defined
     if (fPts == LibUtilities::NullPtsField && !m_f->m_exp.size())
     {
         return;
     }
 
 
     if (m_f->m_verbose)
     {
         if (m_f->m_comm->TreatAsRankZero())
         {
             cout << "OutputTecplot: Writing file..." << endl;
         }
     }
 
     // Extract the output filename and extension
     string filename = m_config["outfile"].as<string>();
 
     int nprocs = m_f->m_comm->GetSize();
     int rank   = m_f->m_comm->GetRank();
 
     if(m_config["writemultiplefiles"].as<bool>())
     {
         m_oneOutputFile = false;
     }
     else
     {
         m_oneOutputFile = nprocs > 1;
     }
 
     // Amend for parallel output if required
     if (nprocs != 1 && !m_oneOutputFile)
     {
         int dot       = filename.find_last_of('.');
         string ext    = filename.substr(dot, filename.length() - dot);
         string procId = "_P" + boost::lexical_cast<std::string>(rank);
         string start  = filename.substr(0, dot);
         filename      = start + procId + ext;
     }
 
     std::string coordVars[] = { "x", "y", "z" };
     bool doError = (vm.count("error") == 1) ? true : false;
 
     // Open output file
     ofstream outfile;
 
     if ((m_oneOutputFile && rank == 0) || !m_oneOutputFile)
     {
         outfile.open(filename.c_str(), m_binary ? ios::binary : ios::out);
     }
 
     std::vector<std::string> var;
     bool writeHeader = true;
 
     if (fPts == LibUtilities::NullPtsField)
     {
         // Standard tensor-product element setup.
         std::vector<LibUtilities::FieldDefinitionsSharedPtr> fDef =
             m_f->m_fielddef;
 
         if (fDef.size())
         {
             var = fDef[0]->m_fields;
         }
 
         // Calculate number of FE blocks
         m_numBlocks = GetNumTecplotBlocks();
 
         // Calculate coordinate dimension
         int nBases = m_f->m_exp[0]->GetExp(0)->GetNumBases();
         MultiRegions::ExpansionType HomoExpType = m_f->m_exp[0]->GetExpType();
 
         m_coordim = m_f->m_exp[0]->GetExp(0)->GetCoordim();
 
         if (HomoExpType == MultiRegions::e3DH1D)
         {
             int nPlanes = m_f->m_exp[0]->GetZIDs().num_elements();
             if (nPlanes == 1) // halfMode case
             {
                 // do nothing
             }
             else
             {
                 nBases += 1;
                 m_coordim += 1;
                 NekDouble tmp = m_numBlocks * (nPlanes - 1);
                 m_numBlocks   = (int)tmp;
             }
         }
         else if (HomoExpType == MultiRegions::e3DH2D)
         {
             nBases += 2;
             m_coordim += 2;
         }
 
         var.insert(var.begin(), coordVars, coordVars + m_coordim);
 
         m_zoneType = (TecplotZoneType)(2*(nBases-1) + 1);
 
         // Calculate connectivity
         CalculateConnectivity();
 
         // Set up storage for output fields
         m_fields = Array<OneD, Array<OneD, NekDouble> >(var.size());
 
         // Get coordinates
         int totpoints = m_f->m_exp[0]->GetTotPoints();
 
         for (int i = 0; i < m_coordim; ++i)
         {
             m_fields[i] = Array<OneD, NekDouble>(totpoints);
         }
 
         if (m_coordim == 1)
         {
             m_f->m_exp[0]->GetCoords(m_fields[0]);
         }
         else if (m_coordim == 2)
         {
             m_f->m_exp[0]->GetCoords(m_fields[0], m_fields[1]);
         }
         else
         {
             m_f->m_exp[0]->GetCoords(m_fields[0], m_fields[1], m_fields[2]);
         }
 
         if (var.size() > m_coordim)
         {
             // Backward transform all data
             for (int i = 0; i < m_f->m_exp.size(); ++i)
             {
                 if (m_f->m_exp[i]->GetPhysState() == false)
                 {
                     m_f->m_exp[i]->BwdTrans(m_f->m_exp[i]->GetCoeffs(),
                                             m_f->m_exp[i]->UpdatePhys());
                 }
             }
 
             // Add references to m_fields
             for (int i = 0; i < m_f->m_exp.size(); ++i)
             {
                 m_fields[i + m_coordim] = m_f->m_exp[i]->UpdatePhys();
             }
         }
 
         // Dump L2 errors of fields.
         if (doError)
         {
             for (int i = 0; i < m_fields.num_elements(); ++i)
             {
                 NekDouble l2err = m_f->m_exp[0]->L2(m_fields[i]);
                 if (rank == 0)
                 {
                     cout << "L 2 error (variable " << var[i] << ") : "
                          << l2err << endl;
                 }
             }
         }
     }
     else
     {
         m_coordim = fPts->GetDim();
 
         if (fPts->GetNpoints() == 0)
         {
             return;
         }
 
         // Grab connectivity information.
         fPts->GetConnectivity(m_conn);
 
         // Get field names
         var = fPts->GetFieldNames();
         var.insert(var.begin(), coordVars, coordVars + m_coordim);
 
         switch (fPts->GetPtsType())
         {
             case LibUtilities::ePtsFile:
             case LibUtilities::ePtsLine:
                 m_numPoints.resize(1);
                 m_numPoints[0] = fPts->GetNpoints();
                 m_zoneType     = eOrdered;
                 break;
             case LibUtilities::ePtsPlane:
                 m_numPoints.resize(2);
                 m_numPoints[0] = fPts->GetPointsPerEdge(0);
                 m_numPoints[1] = fPts->GetPointsPerEdge(1);
                 m_zoneType     = eOrdered;
                 break;
             case LibUtilities::ePtsBox:
                 m_numPoints.resize(3);
                 m_numPoints[0] = fPts->GetPointsPerEdge(0);
                 m_numPoints[1] = fPts->GetPointsPerEdge(1);
                 m_numPoints[2] = fPts->GetPointsPerEdge(2);
                 m_zoneType     = eOrdered;
                 break;
             case LibUtilities::ePtsTriBlock:
             {
                 m_zoneType = eFETriangle;
                 for (int i = 0; i < m_conn.size(); ++i)
                 {
                     m_numBlocks += m_conn[i].num_elements() / 3;
                 }
                 break;
             }
             case LibUtilities::ePtsTetBlock:
             {
                 m_zoneType = eFETetrahedron;
                 for (int i = 0; i < m_conn.size(); ++i)
                 {
                     m_numBlocks += m_conn[i].num_elements() / 4;
                 }
                 break;
             }
             default:
                 ASSERTL0(false, "This points type is not supported yet.");
         }
 
         // Get fields and coordinates
         m_fields = Array<OneD, Array<OneD, NekDouble> >(var.size());
 
         // We can just grab everything from points. This should be a
         // reference, not a copy.
         fPts->GetPts(m_fields);
 
         // Only write header if we're root or FE block; binary files always
         // write header
         writeHeader = (m_zoneType != eOrdered || rank == 0) || m_binary;
 
         if (doError)
         {
             NekDouble l2err;
             for (int i = 0; i < m_fields.num_elements(); ++i)
             {
                 // calculate rms value
                 int npts = m_fields[i].num_elements();
 
                 l2err = 0.0;
                 for (int j = 0; j < npts; ++j)
                 {
                     l2err += m_fields[i][j] * m_fields[i][j];
                 }
 
                 m_f->m_comm->AllReduce(l2err, LibUtilities::ReduceSum);
                 m_f->m_comm->AllReduce(npts, LibUtilities::ReduceSum);
 
                 l2err /= npts;
                 l2err = sqrt(l2err);
 
                 if (rank == 0)
                 {
                     cout << "L 2 error (variable " << var[i] << ") : "
                          << l2err << endl;
                 }
             }
         }
     }
 
     if (m_oneOutputFile)
     {
         // Reduce on number of blocks and number of points.
         m_f->m_comm->AllReduce(m_numBlocks, LibUtilities::ReduceSum);
         for (int i = 0; i < m_numPoints.size(); ++i)
         {
             m_f->m_comm->AllReduce(m_numPoints[i], LibUtilities::ReduceSum);
         }
 
         // Root process needs to know how much data everyone else has for
         // writing in parallel.
         m_rankFieldSizes       = Array<OneD, int>(nprocs, 0);
         m_rankConnSizes        = Array<OneD, int>(nprocs, 0);
         m_rankFieldSizes[rank] = m_fields[0].num_elements();
 
         m_totConn = 0;
         for (int i = 0; i < m_conn.size(); ++i)
         {
             m_totConn += m_conn[i].num_elements();
         }
 
         m_rankConnSizes[rank] = m_totConn;
 
         m_f->m_comm->AllReduce(m_rankFieldSizes, LibUtilities::ReduceSum);
         m_f->m_comm->AllReduce(m_rankConnSizes, LibUtilities::ReduceSum);
     }
 
     if (writeHeader)
     {
         WriteTecplotHeader(outfile, var);
     }
 
     // Write zone data.
     WriteTecplotZone(outfile);
 
     // If we're a FE block format, write connectivity (m_conn will be empty for
     // point data).
     WriteTecplotConnectivity(outfile);
 
     if ((m_oneOutputFile && rank == 0) || !m_oneOutputFile)
     {
         cout << "Written file: " << filename << endl;
     }
 }

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

protectedvirtual

Write Tecplot connectivity information (ASCII)

Parameters

outfile Output file

Reimplemented in Nektar::FieldUtils::OutputTecplotBinary.

Definition at line 777 of file OutputTecplot.cpp.

References Nektar::FieldUtils::eOrdered, m_conn, Nektar::FieldUtils::Module::m_f, m_oneOutputFile, m_rankConnSizes, m_rankFieldSizes, m_totConn, m_zoneType, and Vmath::Vcopy().

Referenced by Process().

 {
     // Ordered data have no connectivity information.
     if (m_zoneType == eOrdered)
     {
         return;
     }
 
     if (m_oneOutputFile && m_f->m_comm->GetRank() > 0)
     {
         // Need to amalgamate connectivity information
         Array<OneD, int> conn(m_totConn);
         for (int i = 0, cnt = 0; i < m_conn.size(); ++i)
         {
             Vmath::Vcopy(m_conn[i].num_elements(), &m_conn[i][0], 1,
                          &conn[cnt], 1);
             cnt += m_conn[i].num_elements();
         }
         m_f->m_comm->Send(0, conn);
     }
     else
     {
         int cnt = 1; 
         for (int i = 0; i < m_conn.size(); ++i)
         {
             const int nConn = m_conn[i].num_elements();
             for (int j = 0; j < nConn; ++j,++cnt)
             {
                 outfile << m_conn[i][j] + 1 << " ";
                 if (!(cnt % 1000))
                 {
                     outfile << std::endl;
                 }
             }
         }
         outfile << endl;
 
         if (m_oneOutputFile && m_f->m_comm->GetRank() == 0)
         {
             int offset = m_rankFieldSizes[0];
 
             for (int n = 1; n < m_f->m_comm->GetSize(); ++n)
             {
                 Array<OneD, int> conn(m_rankConnSizes[n]);
                 m_f->m_comm->Recv(n, conn);
                 for (int j = 0; j < conn.num_elements(); ++j)
                 {
                     outfile << conn[j] + offset + 1 << " ";
                     if ((!(j % 1000)) && j)
                     {
                         outfile << std::endl;
                     }
                 }
                 offset += m_rankFieldSizes[n];
             }
         }
     }
 }

void Nektar::FieldUtils::OutputTecplot::WriteTecplotHeader	(	std::ofstream &	outfile,
		std::vector< std::string > &	var
	)

protectedvirtual

Write Tecplot files header.

Parameters

outfile	Output file name
var	Variables names

Reimplemented in Nektar::FieldUtils::OutputTecplotBinary.

Definition at line 458 of file OutputTecplot.cpp.

Referenced by Process().

 {
     outfile << "Variables = " << var[0];
 
     for (int i = 1; i < var.size(); ++i)
     {
         outfile << ", " << var[i];
     }
 
     outfile << std::endl << std::endl;
 }

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

protectedvirtual

Write Tecplot zone output in ASCII

Parameters

outfile	Output file name.
expansion	Expansion that is considered

Reimplemented in Nektar::FieldUtils::OutputTecplotBinary.

Definition at line 514 of file OutputTecplot.cpp.

References Nektar::FieldUtils::eOrdered, Nektar::FieldUtils::Module::m_f, m_fields, m_numBlocks, m_numPoints, m_oneOutputFile, m_rankFieldSizes, m_zoneType, and Vmath::Vsum().

Referenced by Process().

 {
     // Write either points or finite element block
     if (m_zoneType != eOrdered)
     {
         if ((m_oneOutputFile && m_f->m_comm->GetRank() == 0) || !m_oneOutputFile)
         {
             // Number of points in zone
             int nPoints = m_oneOutputFile ?
                 Vmath::Vsum(m_f->m_comm->GetSize(), m_rankFieldSizes, 1) :
                 m_fields[0].num_elements();
 
             outfile << "Zone, N=" << nPoints << ", E="
                     << m_numBlocks << ", F=FEBlock, ET="
                     << TecplotZoneTypeMap[m_zoneType] << std::endl;
         }
 
 
         if (m_oneOutputFile && m_f->m_comm->GetRank() == 0)
         {
             for (int j = 0; j < m_fields.num_elements(); ++j)
             {
                 for (int i = 0; i < m_fields[j].num_elements(); ++i)
                 {
                     if ((!(i % 1000)) && i)
                     {
                         outfile << std::endl;
                     }
                     outfile << m_fields[j][i] << " ";
                 }
 
                 for (int n = 1; n < m_f->m_comm->GetSize(); ++n)
                 {
                     Array<OneD, NekDouble> tmp(m_rankFieldSizes[n]);
                     m_f->m_comm->Recv(n, tmp);
 
                     for (int i = 0; i < m_rankFieldSizes[n]; ++i)
                     {
                         if ((!(i % 1000)) && i)
                         {
                             outfile << std::endl;
                         }
                         outfile << tmp[i] << " ";
                     }
                 }
                 outfile << std::endl;
             }
         }
         else if (m_oneOutputFile && m_f->m_comm->GetRank() > 0)
         {
             for (int i = 0; i < m_fields.num_elements(); ++i)
             {
                 m_f->m_comm->Send(0, m_fields[i]);
             }
         }
         else
         {
             // Write out coordinates and field data: ordered by field
             // and then its data.
             for (int j = 0; j < m_fields.num_elements(); ++j)
             {
                 for (int i = 0; i < m_fields[j].num_elements(); ++i)
                 {
                     if ((!(i % 1000)) && i)
                     {
                         outfile << std::endl;
                     }
                     outfile << m_fields[j][i] << " ";
                 }
                 outfile << std::endl;
             }
         }
     }
     else
     {
         std::string dirs[] = { "I", "J", "K" };
         outfile << "Zone";
         for (int i = 0; i < m_numPoints.size(); ++i)
         {
             outfile << ", " << dirs[i] << "=" << m_numPoints[i];
         }
         outfile << ", F=POINT" << std::endl;
 
         // Write out coordinates and field data: ordered by each point then each
         // field.
         for (int i = 0; i < m_fields[0].num_elements(); ++i)
         {
             for (int j = 0; j < m_fields.num_elements(); ++j)
             {
                 outfile << setw(12) << m_fields[j][i] << " ";
             }
             outfile << std::endl;
         }
     }
 }

Member Data Documentation

bool Nektar::FieldUtils::OutputTecplot::m_binary

protected

True if writing binary field output.

Definition at line 78 of file OutputTecplot.h.

Referenced by Nektar::FieldUtils::OutputTecplotBinary::OutputTecplotBinary(), and Process().

ModuleKey Nektar::FieldUtils::OutputTecplot::m_className

static

Initial value:

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