Nektar::FieldUtils::OutputTecplot Class Reference

Tecplot output class. More...

#include <OutputTecplot.h>

Inheritance diagram for Nektar::FieldUtils::OutputTecplot:

Public Member Functions
	OutputTecplot (FieldSharedPtr f)
virtual	~OutputTecplot ()
Public Member Functions inherited from Nektar::FieldUtils::OutputFileBase
	OutputFileBase (FieldSharedPtr f)
virtual	~OutputFileBase ()
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)
virtual	~Module ()=default
void	Process (po::variables_map &vm)
std::string	GetModuleName ()
std::string	GetModuleDescription ()
const ConfigOption &	GetConfigOption (const std::string &key) const
ModulePriority	GetModulePriority ()
FIELD_UTILS_EXPORT void	RegisterConfig (std::string key, std::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 void	AddFile (std::string fileType, std::string fileName)
FIELD_UTILS_EXPORT void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

Static Public Member Functions
static std::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	v_Process (po::variables_map &vm) override
	Write fld to output file. More...
virtual std::string	v_GetModuleName () override
virtual void	v_OutputFromPts (po::variables_map &vm) override
	Write from pts to output file. More...
virtual void	v_OutputFromExp (po::variables_map &vm) override
	Write from m_exp to output file. More...
virtual void	v_OutputFromData (po::variables_map &vm) override
	Write from data to output file. More...
virtual fs::path	v_GetPath (std::string &filename, po::variables_map &vm) override
virtual fs::path	v_GetFullOutName (std::string &filename, po::variables_map &vm) override
virtual void	v_WriteTecplotHeader (std::ofstream &outfile, std::vector< std::string > &var)
	Write Tecplot files header. More...
void	WriteTecplotHeader (std::ofstream &outfile, std::vector< std::string > &var)
virtual void	v_WriteTecplotZone (std::ofstream &outfile)
void	WriteTecplotZone (std::ofstream &outfile)
virtual void	v_WriteTecplotConnectivity (std::ofstream &outfile)
	Write Tecplot connectivity information (ASCII) More...
void	WriteTecplotConnectivity (std::ofstream &outfile)
void	WriteTecplotFile (po::variables_map &vm)
int	GetNumTecplotBlocks ()
	Calculate number of Tecplot blocks. More...
void	CalculateConnectivity ()
	Calculate connectivity information for each expansion dimension. More...
Protected Member Functions inherited from Nektar::FieldUtils::OutputFileBase
virtual std::string	v_GetModuleDescription () override
virtual ModulePriority	v_GetModulePriority () override
fs::path	GetPath (std::string &filename, po::variables_map &vm)
fs::path	GetFullOutName (std::string &filename, po::variables_map &vm)
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...
bool	m_writeHeader
	True if writing header. More...
TecplotZoneType	m_zoneType
	Tecplot zone type of output. More...
std::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...
std::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::OutputFileBase
bool	m_requireEquiSpaced
Protected Attributes inherited from Nektar::FieldUtils::OutputModule
std::ofstream	m_fldFile
	Output stream. More...
Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...
std::set< std::string >	m_allowedFiles
	List of allowed file formats. More...

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...

Detailed Description

Tecplot output class.

Definition at line 61 of file OutputTecplot.h.

Constructor & Destructor Documentation

OutputTecplot()

Nektar::FieldUtils::OutputTecplot::OutputTecplot

(

FieldSharedPtr

f

)

Definition at line 65 of file OutputTecplot.cpp.

    : OutputFileBase(f), m_binary(false), m_oneOutputFile(false)
{
    m_requireEquiSpaced = true;
    m_config["double"]  = ConfigOption(true, "0",
                                      "Write double-precision format data:"
                                      "more accurate but more disk space"
                                      " required");
}

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

~OutputTecplot()

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

virtual

Definition at line 75 of file OutputTecplot.cpp.

{
}

Member Function Documentation

CalculateConnectivity()

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

protected

Calculate connectivity information for each expansion dimension.

Parameters

outfile

Output file

Definition at line 988 of file OutputTecplot.cpp.

{
    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);
            int nPlanes = 1;
 
            if (m_f->m_exp[0]->GetExpType() == MultiRegions::e2DH1D)
            {
                nPlanes = m_f->m_exp[0]->GetZIDs().size();
 
                if (nPlanes > 1)
                {
                    int totPoints = m_f->m_exp[0]->GetPlane(0)->GetTotPoints();
 
                    Array<OneD, int> conn(4 * (np0 - 1) * (nPlanes - 1));
                    for (int n = 1; n < nPlanes; ++n)
                    {
                        for (k = 1; k < np0; ++k)
                        {
                            conn[cnt2++] = cnt + (n - 1) * totPoints + k;
                            conn[cnt2++] = cnt + (n - 1) * totPoints + k - 1;
                            conn[cnt2++] = cnt + n * totPoints + k - 1;
                            conn[cnt2++] = cnt + n * totPoints + k;
                        }
                    }
                    m_conn[i] = conn;
                }
            }
 
            if (nPlanes == 1)
            {
                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().size();
 
                // default to 2D case for HalfMode when nPlanes = 1
                if (nPlanes > 1)
                {
                    // If Fourier points, output extra plane to fill domain
                    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");
        }
    }
}

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

Referenced by v_OutputFromExp().

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 65 of file OutputTecplot.h.

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

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

GetNumTecplotBlocks()

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

protected

Calculate number of Tecplot blocks.

Parameters

outfile

Output file

Definition at line 951 of file OutputTecplot.cpp.

{
    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;
}

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

Referenced by v_OutputFromExp().

v_GetFullOutName()

fs::path Nektar::FieldUtils::OutputTecplot::v_GetFullOutName ( std::string &  filename, po::variables_map &  vm  )

overrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::OutputFileBase.

Definition at line 375 of file OutputTecplot.cpp.

{
    return GetPath(filename, vm);
}

References Nektar::FieldUtils::OutputFileBase::GetPath().

v_GetModuleName()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::OutputFileBase.

Definition at line 77 of file OutputTecplot.h.

    {
        return "OutputTecplot";
    }

v_GetPath()

fs::path Nektar::FieldUtils::OutputTecplot::v_GetPath ( std::string &  filename, po::variables_map &  vm  )

overrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::OutputFileBase.

Definition at line 355 of file OutputTecplot.cpp.

{
    boost::ignore_unused(vm);
 
    int nprocs = m_f->m_comm->GetSpaceComm()->GetSize();
    string returnstr(filename);
 
    // Amend for parallel output if required
    if (nprocs != 1 && !m_oneOutputFile)
    {
        int rank      = m_f->m_comm->GetSpaceComm()->GetRank();
        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);
        returnstr     = start + procId + ext;
    }
    return fs::path(returnstr);
}

References Nektar::FieldUtils::Module::m_f, and m_oneOutputFile.

v_OutputFromData()

void Nektar::FieldUtils::OutputTecplot::v_OutputFromData ( po::variables_map &  vm )

overrideprotectedvirtual

Write from data to output file.

Implements Nektar::FieldUtils::OutputFileBase.

Definition at line 347 of file OutputTecplot.cpp.

{
    boost::ignore_unused(vm);
 
    NEKERROR(ErrorUtil::efatal,
             "OutputTecplot can't write using only FieldData.");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

v_OutputFromExp()

void Nektar::FieldUtils::OutputTecplot::v_OutputFromExp ( po::variables_map &  vm )

overrideprotectedvirtual

Write from m_exp to output file.

Implements Nektar::FieldUtils::OutputFileBase.

Definition at line 233 of file OutputTecplot.cpp.

{
    m_numBlocks   = 0;
    m_writeHeader = true;
 
    // Calculate number of FE blocks
    m_numBlocks = GetNumTecplotBlocks();
 
    // Calculate coordinate dimension
    int nBases = m_f->m_exp[0]->GetExp(0)->GetNumBases();
 
    m_coordim     = m_f->m_exp[0]->GetExp(0)->GetCoordim();
    int totpoints = m_f->m_exp[0]->GetTotPoints();
 
    if (m_f->m_numHomogeneousDir > 0)
    {
        int nPlanes = m_f->m_exp[0]->GetZIDs().size();
        if (nPlanes == 1) // halfMode case
        {
            // do nothing
        }
        else
        {
            // If Fourier points, output extra plane to fill domain
            if (m_f->m_exp[0]->GetExpType() == MultiRegions::e3DH1D)
            {
                nPlanes += 1;
                totpoints += m_f->m_exp[0]->GetPlane(0)->GetTotPoints();
            }
            nBases += m_f->m_numHomogeneousDir;
            m_coordim += m_f->m_numHomogeneousDir;
            NekDouble tmp = m_numBlocks * (nPlanes - 1);
            m_numBlocks   = (int)tmp;
        }
    }
 
    m_zoneType = (TecplotZoneType)(2 * (nBases - 1) + 1);
 
    // Calculate connectivity
    CalculateConnectivity();
 
    // Set up storage for output fields
    m_fields = Array<OneD, Array<OneD, NekDouble>>(m_f->m_variables.size() +
                                                   m_coordim);
 
    // Get coordinates
    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 (m_f->m_exp[0]->GetExpType() == MultiRegions::e3DH1D)
    {
        // Copy values
        for (int i = 0; i < m_f->m_variables.size(); ++i)
        {
            m_fields[i + m_coordim] = Array<OneD, NekDouble>(totpoints);
 
            Vmath::Vcopy(m_f->m_exp[0]->GetTotPoints(),
                         m_f->m_exp[i]->UpdatePhys(), 1,
                         m_fields[i + m_coordim], 1);
        }
    }
    else
    {
        // Add references to m_fields
        for (int i = 0; i < m_f->m_variables.size(); ++i)
        {
            m_fields[i + m_coordim] = m_f->m_exp[i]->UpdatePhys();
        }
    }
 
    // If Fourier, fill extra plane with data
    if (m_f->m_exp[0]->GetExpType() == MultiRegions::e3DH1D)
    {
        int points_on_plane = m_f->m_exp[0]->GetPlane(0)->GetTotPoints();
        const int offset    = totpoints - points_on_plane;
        NekDouble z = m_fields[m_coordim - 1][totpoints - 2 * points_on_plane] +
                      (m_fields[m_coordim - 1][points_on_plane] -
                       m_fields[m_coordim - 1][0]);
        // x and y
        Array<OneD, NekDouble> tmp = m_fields[0] + offset;
        Vmath::Vcopy(points_on_plane, m_fields[0], 1, tmp, 1);
        tmp = m_fields[1] + offset;
        Vmath::Vcopy(points_on_plane, m_fields[1], 1, tmp, 1);
        // z coordinate
        tmp = m_fields[2] + offset;
        Vmath::Vcopy(points_on_plane, m_fields[2], 1, tmp, 1);
        Vmath::Sadd(points_on_plane, z, m_fields[2], 1, tmp, 1);
 
        // variables
        for (int i = 0; i < m_f->m_variables.size(); ++i)
        {
            tmp = m_fields[i + m_coordim] + offset;
            Vmath::Vcopy(points_on_plane, m_fields[i + m_coordim], 1, tmp, 1);
        }
    }
 
    WriteTecplotFile(vm);
}

References CalculateConnectivity(), Nektar::MultiRegions::e3DH1D, GetNumTecplotBlocks(), m_coordim, Nektar::FieldUtils::Module::m_f, m_fields, m_numBlocks, m_writeHeader, m_zoneType, Vmath::Sadd(), Vmath::Vcopy(), and WriteTecplotFile().

v_OutputFromPts()

void Nektar::FieldUtils::OutputTecplot::v_OutputFromPts ( po::variables_map &  vm )

overrideprotectedvirtual

Write from pts to output file.

Implements Nektar::FieldUtils::OutputFileBase.

Definition at line 151 of file OutputTecplot.cpp.

{
    LibUtilities::PtsFieldSharedPtr fPts = m_f->m_fieldPts;
 
    // do not output if zone is empty
    if (fPts->GetNpoints() == 0)
    {
        return;
    }
 
    int rank    = m_f->m_comm->GetSpaceComm()->GetRank();
    m_numBlocks = 0;
 
    m_coordim = fPts->GetDim();
 
    // Grab connectivity information.
    fPts->GetConnectivity(m_conn);
 
    switch (fPts->GetPtsType())
    {
        case LibUtilities::ePtsFile:
            m_numPoints.resize(1);
            m_numPoints[0] = fPts->GetNpoints();
            m_f->m_comm->GetSpaceComm()->AllReduce(m_numPoints[0],
                                                   LibUtilities::ReduceSum);
            m_zoneType = eOrdered;
            break;
        case LibUtilities::ePtsLine:
            m_numPoints.resize(1);
            m_numPoints[0] = fPts->GetPointsPerEdge(0);
            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].size() / 3;
            }
            break;
        }
        case LibUtilities::ePtsTetBlock:
        {
            m_zoneType = eFETetrahedron;
            for (int i = 0; i < m_conn.size(); ++i)
            {
                m_numBlocks += m_conn[i].size() / 4;
            }
            break;
        }
        default:
            ASSERTL0(false, "This points type is not supported yet.");
    }
 
    // Get fields and coordinates
    m_fields = Array<OneD, Array<OneD, NekDouble>>(m_f->m_variables.size() +
                                                   m_coordim);
 
    // 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
    m_writeHeader = (m_zoneType != eOrdered || rank == 0) || m_binary;
 
    WriteTecplotFile(vm);
}

References ASSERTL0, Nektar::FieldUtils::eFETetrahedron, Nektar::FieldUtils::eFETriangle, Nektar::FieldUtils::eOrdered, Nektar::LibUtilities::ePtsBox, Nektar::LibUtilities::ePtsFile, Nektar::LibUtilities::ePtsLine, Nektar::LibUtilities::ePtsPlane, Nektar::LibUtilities::ePtsTetBlock, Nektar::LibUtilities::ePtsTriBlock, m_binary, m_conn, m_coordim, Nektar::FieldUtils::Module::m_f, m_fields, m_numBlocks, m_numPoints, m_writeHeader, m_zoneType, Nektar::LibUtilities::ReduceSum, and WriteTecplotFile().

v_Process()

void Nektar::FieldUtils::OutputTecplot::v_Process ( po::variables_map &  vm )

overrideprotectedvirtual

Write fld to output file.

Reimplemented from Nektar::FieldUtils::OutputFileBase.

Definition at line 79 of file OutputTecplot.cpp.

{
 
    if (m_config["writemultiplefiles"].as<bool>())
    {
        m_oneOutputFile = false;
    }
    else
    {
        m_oneOutputFile = (m_f->m_comm->GetSpaceComm()->GetSize() > 1);
    }
 
    OutputFileBase::v_Process(vm);
}

References Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, m_oneOutputFile, and Nektar::FieldUtils::OutputFileBase::v_Process().

v_WriteTecplotConnectivity()

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

protectedvirtual

Write Tecplot connectivity information (ASCII)

Parameters

outfile

Output file

Reimplemented in Nektar::FieldUtils::OutputTecplotBinary.

Definition at line 837 of file OutputTecplot.cpp.

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

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 WriteTecplotConnectivity().

v_WriteTecplotHeader()

void Nektar::FieldUtils::OutputTecplot::v_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 451 of file OutputTecplot.cpp.

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

Referenced by WriteTecplotHeader().

v_WriteTecplotZone()

void Nektar::FieldUtils::OutputTecplot::v_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 506 of file OutputTecplot.cpp.

{
    bool useDoubles = m_config["double"].as<bool>();
 
    if (useDoubles)
    {
        int precision = std::numeric_limits<double>::max_digits10;
        outfile << std::setprecision(precision);
    }
 
    // Write either points or finite element block
    if (m_zoneType != eOrdered)
    {
        if ((m_oneOutputFile && m_f->m_comm->GetSpaceComm()->GetRank() == 0) ||
            !m_oneOutputFile)
        {
            // Number of points in zone
            int nPoints =
                m_oneOutputFile
                    ? Vmath::Vsum(m_f->m_comm->GetSpaceComm()->GetSize(),
                                  m_rankFieldSizes, 1)
                    : m_fields[0].size();
 
            outfile << "Zone, N=" << nPoints << ", E=" << m_numBlocks
                    << ", F=FEBlock, ET=" << TecplotZoneTypeMap[m_zoneType];
            if (m_f->m_fieldMetaDataMap.count("Time"))
            {
                outfile << ", SOLUTIONTIME=" << m_f->m_fieldMetaDataMap["Time"];
            }
            outfile << std::endl;
        }
 
        if (m_oneOutputFile && m_f->m_comm->GetSpaceComm()->GetRank() == 0)
        {
            for (int j = 0; j < m_fields.size(); ++j)
            {
                for (int i = 0; i < m_fields[j].size(); ++i)
                {
                    if ((!(i % 1000)) && i)
                    {
                        outfile << std::endl;
                    }
                    outfile << m_fields[j][i] << " ";
                }
 
                for (int n = 1; n < m_f->m_comm->GetSpaceComm()->GetSize(); ++n)
                {
                    if (m_rankFieldSizes[n])
                    {
                        Array<OneD, NekDouble> tmp(m_rankFieldSizes[n]);
                        m_f->m_comm->GetSpaceComm()->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->GetSpaceComm()->GetRank() > 0)
        {
            if (m_fields[0].size())
            {
                for (int i = 0; i < m_fields.size(); ++i)
                {
                    m_f->m_comm->GetSpaceComm()->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.size(); ++j)
            {
                for (int i = 0; i < m_fields[j].size(); ++i)
                {
                    if ((!(i % 1000)) && i)
                    {
                        outfile << std::endl;
                    }
                    outfile << m_fields[j][i] << " ";
                }
                outfile << std::endl;
            }
        }
    }
    else
    {
        if ((m_oneOutputFile && m_f->m_comm->GetSpaceComm()->GetRank() == 0) ||
            !m_oneOutputFile)
        {
            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;
        }
 
        if (m_oneOutputFile && m_f->m_comm->GetSpaceComm()->GetRank() == 0)
        {
            Array<OneD, NekDouble> tmp(m_fields.size());
            for (int i = 0; i < m_fields[0].size(); ++i)
            {
                for (int j = 0; j < m_fields.size(); ++j)
                {
                    outfile << setw(12) << m_fields[j][i] << " ";
                }
                outfile << std::endl;
            }
 
            for (int n = 1; n < m_f->m_comm->GetSpaceComm()->GetSize(); ++n)
            {
                for (int i = 0; i < m_rankFieldSizes[n]; ++i)
                {
                    m_f->m_comm->GetSpaceComm()->Recv(n, tmp);
                    for (int j = 0; j < m_fields.size(); ++j)
                    {
                        outfile << setw(12) << tmp[j] << " ";
                    }
                    outfile << std::endl;
                }
            }
        }
        else if (m_oneOutputFile && m_f->m_comm->GetSpaceComm()->GetRank() > 0)
        {
            Array<OneD, NekDouble> tmp(m_fields.size());
            for (int i = 0; i < m_fields[0].size(); ++i)
            {
                for (int j = 0; j < m_fields.size(); ++j)
                {
                    tmp[j] = m_fields[j][i];
                }
                m_f->m_comm->GetSpaceComm()->Send(0, tmp);
            }
        }
        else
        {
            // Write out coordinates and field data: ordered by each
            // point then each field.
            for (int i = 0; i < m_fields[0].size(); ++i)
            {
                for (int j = 0; j < m_fields.size(); ++j)
                {
                    outfile << setw(12) << m_fields[j][i] << " ";
                }
                outfile << std::endl;
            }
        }
    }
}

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

Referenced by WriteTecplotZone().

WriteTecplotConnectivity()

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

inlineprotected

Definition at line 135 of file OutputTecplot.h.

    {
        v_WriteTecplotConnectivity(outfile);
    }

References v_WriteTecplotConnectivity().

Referenced by WriteTecplotFile().

WriteTecplotFile()

void Nektar::FieldUtils::OutputTecplot::WriteTecplotFile ( po::variables_map &  vm )

protected

Definition at line 381 of file OutputTecplot.cpp.

{
    // Variable names
    std::string coordVars[]       = {"x", "y", "z"};
    std::vector<string> variables = m_f->m_variables;
    variables.insert(variables.begin(), coordVars, coordVars + m_coordim);
 
    int nprocs = m_f->m_comm->GetSpaceComm()->GetSize();
    int rank   = m_f->m_comm->GetSpaceComm()->GetRank();
 
    // Extract the output filename and extension
    string filename = m_config["outfile"].as<string>();
    string outFile  = LibUtilities::PortablePath(GetFullOutName(filename, vm));
    // Open output file
    ofstream outfile;
    if ((m_oneOutputFile && rank == 0) || !m_oneOutputFile)
    {
        outfile.open(outFile.c_str(), m_binary ? ios::binary : ios::out);
    }
 
    if (m_oneOutputFile)
    {
        // Reduce on number of blocks and number of points.
        m_f->m_comm->GetSpaceComm()->AllReduce(m_numBlocks,
                                               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].size();
 
        m_totConn = 0;
        for (int i = 0; i < m_conn.size(); ++i)
        {
            m_totConn += m_conn[i].size();
        }
 
        m_rankConnSizes[rank] = m_totConn;
 
        m_f->m_comm->GetSpaceComm()->AllReduce(m_rankFieldSizes,
                                               LibUtilities::ReduceSum);
        m_f->m_comm->GetSpaceComm()->AllReduce(m_rankConnSizes,
                                               LibUtilities::ReduceSum);
    }
 
    if (m_writeHeader)
    {
        WriteTecplotHeader(outfile, variables);
    }
 
    // 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: " << GetFullOutName(filename, vm) << endl;
    }
}

References Nektar::FieldUtils::OutputFileBase::GetFullOutName(), m_binary, Nektar::FieldUtils::Module::m_config, m_conn, m_coordim, Nektar::FieldUtils::Module::m_f, m_fields, m_numBlocks, m_oneOutputFile, m_rankConnSizes, m_rankFieldSizes, m_totConn, m_writeHeader, Nektar::LibUtilities::PortablePath(), Nektar::LibUtilities::ReduceSum, WriteTecplotConnectivity(), WriteTecplotHeader(), and WriteTecplotZone().

Referenced by v_OutputFromExp(), and v_OutputFromPts().

WriteTecplotHeader()

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

inlineprotected

Definition at line 124 of file OutputTecplot.h.

    {
        v_WriteTecplotHeader(outfile, var);
    }

References v_WriteTecplotHeader().

Referenced by WriteTecplotFile().

WriteTecplotZone()

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

inlineprotected

Definition at line 130 of file OutputTecplot.h.

    {
        v_WriteTecplotZone(outfile);
    }

References v_WriteTecplotZone().

Referenced by WriteTecplotFile().

Member Data Documentation

m_binary

bool Nektar::FieldUtils::OutputTecplot::m_binary

protected

True if writing binary field output.

Definition at line 98 of file OutputTecplot.h.

Referenced by Nektar::FieldUtils::OutputTecplotBinary::OutputTecplotBinary(), v_OutputFromPts(), and WriteTecplotFile().

m_className

ModuleKey Nektar::FieldUtils::OutputTecplot::m_className

static

Initial value:

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

Definition at line 70 of file OutputTecplot.h.

m_conn

std::vector<Array<OneD, int> > Nektar::FieldUtils::OutputTecplot::m_conn

protected

Connectivty for each block: one per element.

Definition at line 114 of file OutputTecplot.h.

Referenced by CalculateConnectivity(), v_OutputFromPts(), v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), and WriteTecplotFile().

m_coordim

int Nektar::FieldUtils::OutputTecplot::m_coordim

protected

Coordinate dimension of output.

Definition at line 110 of file OutputTecplot.h.

Referenced by v_OutputFromExp(), v_OutputFromPts(), and WriteTecplotFile().

m_fields

Array<OneD, Array<OneD, NekDouble> > Nektar::FieldUtils::OutputTecplot::m_fields

protected

Field data to output.

Definition at line 120 of file OutputTecplot.h.

Referenced by v_OutputFromExp(), v_OutputFromPts(), v_WriteTecplotZone(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and WriteTecplotFile().

m_numBlocks

int Nektar::FieldUtils::OutputTecplot::m_numBlocks

protected

Number of blocks in Tecplot file.

Definition at line 108 of file OutputTecplot.h.

Referenced by v_OutputFromExp(), v_OutputFromPts(), v_WriteTecplotZone(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and WriteTecplotFile().

m_numPoints

std::vector<int> Nektar::FieldUtils::OutputTecplot::m_numPoints

protected

Number of points per block in Tecplot file.

Definition at line 106 of file OutputTecplot.h.

Referenced by v_OutputFromPts(), v_WriteTecplotZone(), and Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone().

m_oneOutputFile

bool Nektar::FieldUtils::OutputTecplot::m_oneOutputFile

protected

True if writing a single output file.

Definition at line 100 of file OutputTecplot.h.

Referenced by v_GetPath(), v_Process(), v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotHeader(), v_WriteTecplotZone(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and WriteTecplotFile().

m_rankConnSizes

Array<OneD, int> Nektar::FieldUtils::OutputTecplot::m_rankConnSizes

protected

Each rank's connectivity sizes.

Definition at line 118 of file OutputTecplot.h.

Referenced by v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), and WriteTecplotFile().

m_rankFieldSizes

Array<OneD, int> Nektar::FieldUtils::OutputTecplot::m_rankFieldSizes

protected

Each rank's field sizes.

Definition at line 116 of file OutputTecplot.h.

Referenced by v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), v_WriteTecplotZone(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and WriteTecplotFile().

m_totConn

int Nektar::FieldUtils::OutputTecplot::m_totConn

protected

Total number of connectivity entries.

Definition at line 112 of file OutputTecplot.h.

Referenced by v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), and WriteTecplotFile().

m_writeHeader

bool Nektar::FieldUtils::OutputTecplot::m_writeHeader

protected

True if writing header.

Definition at line 102 of file OutputTecplot.h.

Referenced by v_OutputFromExp(), v_OutputFromPts(), and WriteTecplotFile().

m_zoneType

TecplotZoneType Nektar::FieldUtils::OutputTecplot::m_zoneType

protected

Tecplot zone type of output.

Definition at line 104 of file OutputTecplot.h.

Referenced by v_OutputFromExp(), v_OutputFromPts(), v_WriteTecplotConnectivity(), v_WriteTecplotZone(), and Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone().