#include <MeshGraphXmlCompressed.h>

Inheritance diagram for Nektar::SpatialDomains::MeshGraphXmlCompressed:

Public Member Functions
	MeshGraphXmlCompressed ()

virtual	~MeshGraphXmlCompressed ()

Public Member Functions inherited from Nektar::SpatialDomains::MeshGraphXml
	MeshGraphXml ()

virtual	~MeshGraphXml ()

void	WriteXMLGeometry (std::string outname, std::vector< std::set< unsigned int > > elements, std::vector< unsigned int > partitions)

Public Member Functions inherited from Nektar::SpatialDomains::MeshGraph
	MeshGraph ()

virtual	~MeshGraph ()

void	WriteGeometry (std::string &outfilename, bool defaultExp=false, const LibUtilities::FieldMetaDataMap &metadata=LibUtilities::NullFieldMetaDataMap)

void	Empty (int dim, int space)

void	FillGraph ()

void	FillBoundingBoxTree ()

std::vector< int >	GetElementsContainingPoint (PointGeomSharedPtr p)

void	ReadExpansionInfo ()

void	ReadRefinementInfo ()
	Read refinement info. More...

int	GetMeshDimension ()
	Dimension of the mesh (can be a 1D curve in 3D space). More...

int	GetSpaceDimension ()
	Dimension of the space (can be a 1D curve in 3D space). More...

void	SetDomainRange (NekDouble xmin, NekDouble xmax, NekDouble ymin=NekConstants::kNekUnsetDouble, NekDouble ymax=NekConstants::kNekUnsetDouble, NekDouble zmin=NekConstants::kNekUnsetDouble, NekDouble zmax=NekConstants::kNekUnsetDouble)

bool	CheckRange (Geometry2D &geom)
	Check if goemetry is in range definition if activated. More...

bool	CheckRange (Geometry3D &geom)
	Check if goemetry is in range definition if activated. More...

CompositeSharedPtr	GetComposite (int whichComposite)

GeometrySharedPtr	GetCompositeItem (int whichComposite, int whichItem)

void	GetCompositeList (const std::string &compositeStr, CompositeMap &compositeVector) const

std::map< int, CompositeSharedPtr > &	GetComposites ()

std::map< int, std::string > &	GetCompositesLabels ()

std::map< int, std::map< int, CompositeSharedPtr > > &	GetDomain ()

std::map< int, CompositeSharedPtr > &	GetDomain (int domain)

const ExpansionInfoMap &	GetExpansionInfo (const std::string variable="DefaultVar")

ExpansionInfoShPtr	GetExpansionInfo (GeometrySharedPtr geom, const std::string variable="DefaultVar")

void	SetExpansionInfo (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
	Sets expansions given field definitions. More...

void	SetExpansionInfo (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef, std::vector< std::vector< LibUtilities::PointsType > > &pointstype)
	Sets expansions given field definition, quadrature points. More...

void	SetExpansionInfoToEvenlySpacedPoints (int npoints=0)
	Sets expansions to have equispaced points. More...

void	SetExpansionInfoToNumModes (int nmodes)
	Reset expansion to have specified polynomial order nmodes. More...

void	SetExpansionInfoToPointOrder (int npts)
	Reset expansion to have specified point order npts. More...

void	SetRefinementInfo (ExpansionInfoMapShPtr &expansionMap)
	This function sets the expansion #exp in map with entry #variable. More...

void	PRefinementElmts (ExpansionInfoMapShPtr &expansionMap, RefRegion *&region, GeometrySharedPtr geomVecIter)
	Perform the p-refinement in the selected elements. More...

void	SetExpansionInfo (const std::string variable, ExpansionInfoMapShPtr &exp)

void	SetSession (LibUtilities::SessionReaderSharedPtr pSession)

void	SetBasisKey (LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys, std::string var="DefaultVar")
	Sets the basis key for all expansions of the given shape. More...

void	ResetExpansionInfoToBasisKey (ExpansionInfoMapShPtr &expansionMap, LibUtilities::ShapeType shape, LibUtilities::BasisKeyVector &keys)

bool	SameExpansionInfo (const std::string var1, const std::string var2)

bool	ExpansionInfoDefined (const std::string var)

bool	CheckForGeomInfo (std::string parameter)

const std::string	GetGeomInfo (std::string parameter)

LibUtilities::BasisKeyVector	DefineBasisKeyFromExpansionTypeHomo (GeometrySharedPtr in, ExpansionType type_x, ExpansionType type_y, ExpansionType type_z, const int nummodes_x, const int nummodes_y, const int nummodes_z)

int	GetNvertices ()

PointGeomSharedPtr	GetVertex (int id)

SegGeomSharedPtr	GetSegGeom (int id)

CurveMap &	GetCurvedEdges ()

CurveMap &	GetCurvedFaces ()

std::map< int, PointGeomSharedPtr > &	GetAllPointGeoms ()

std::map< int, SegGeomSharedPtr > &	GetAllSegGeoms ()

TriGeomMap &	GetAllTriGeoms ()

QuadGeomMap &	GetAllQuadGeoms ()

TetGeomMap &	GetAllTetGeoms ()

PyrGeomMap &	GetAllPyrGeoms ()

PrismGeomMap &	GetAllPrismGeoms ()

HexGeomMap &	GetAllHexGeoms ()

std::unordered_map< int, GeometryLinkSharedPtr > &	GetAllFaceToElMap ()

int	GetNumElements ()

Geometry2DSharedPtr	GetGeometry2D (int gID)

GeometryLinkSharedPtr	GetElementsFromEdge (Geometry1DSharedPtr edge)

GeometryLinkSharedPtr	GetElementsFromFace (Geometry2DSharedPtr face)

void	SetPartition (SpatialDomains::MeshGraphSharedPtr graph)

CompositeOrdering &	GetCompositeOrdering ()

void	SetCompositeOrdering (CompositeOrdering p_compOrder)

BndRegionOrdering &	GetBndRegionOrdering ()

void	SetBndRegionOrdering (BndRegionOrdering p_bndRegOrder)

void	ReadGeometry (LibUtilities::DomainRangeShPtr rng, bool fillGraph)

void	PartitionMesh (LibUtilities::SessionReaderSharedPtr session)

std::map< int, MeshEntity >	CreateMeshEntities ()
	Create mesh entities for this graph. More...

CompositeDescriptor	CreateCompositeDescriptor ()

MovementSharedPtr &	GetMovement ()

Static Public Member Functions
static MeshGraphSharedPtr	create ()

Static Public Member Functions inherited from Nektar::SpatialDomains::MeshGraphXml
static MeshGraphSharedPtr	create ()

Static Public Member Functions inherited from Nektar::SpatialDomains::MeshGraph
static MeshGraphSharedPtr	Read (const LibUtilities::SessionReaderSharedPtr pSession, LibUtilities::DomainRangeShPtr rng=LibUtilities::NullDomainRangeShPtr, bool fillGraph=true, SpatialDomains::MeshGraphSharedPtr partitionedGraph=nullptr)

static LibUtilities::BasisKeyVector	DefineBasisKeyFromExpansionType (GeometrySharedPtr in, ExpansionType type, const int order)

Static Public Attributes
static std::string	className

Static Public Attributes inherited from Nektar::SpatialDomains::MeshGraphXml
static std::string	className

Protected Member Functions
virtual void	v_ReadVertices () override

virtual void	v_ReadCurves () override

virtual void	v_ReadEdges () override

virtual void	v_ReadFaces () override

virtual void	v_ReadElements1D () override

virtual void	v_ReadElements2D () override

virtual void	v_ReadElements3D () override

virtual void	v_WriteVertices (TiXmlElement *geomTag, PointGeomMap &verts) override

virtual void	v_WriteEdges (TiXmlElement *geomTag, SegGeomMap &edges) override

virtual void	v_WriteTris (TiXmlElement *faceTag, TriGeomMap &tris) override

virtual void	v_WriteQuads (TiXmlElement *faceTag, QuadGeomMap &quads) override

virtual void	v_WriteHexs (TiXmlElement *elmtTag, HexGeomMap &hexs) override

virtual void	v_WritePrisms (TiXmlElement *elmtTag, PrismGeomMap &pris) override

virtual void	v_WritePyrs (TiXmlElement *elmtTag, PyrGeomMap &pyrs) override

virtual void	v_WriteTets (TiXmlElement *elmtTag, TetGeomMap &tets) override

virtual void	v_WriteCurves (TiXmlElement *geomTag, CurveMap &edges, CurveMap &faces) override

Protected Member Functions inherited from Nektar::SpatialDomains::MeshGraphXml
virtual void	v_WriteGeometry (std::string &outfilename, bool defaultExp=false, const LibUtilities::FieldMetaDataMap &metadata=LibUtilities::NullFieldMetaDataMap) override
	Write out an XML file containing the GEOMETRY block representing this MeshGraph instance inside a NEKTAR tag. More...

virtual void	v_ReadGeometry (LibUtilities::DomainRangeShPtr rng, bool fillGraph) override

virtual void	v_PartitionMesh (LibUtilities::SessionReaderSharedPtr session) override

virtual void	v_ReadVertices ()

virtual void	v_ReadCurves ()

void	ReadDomain ()

virtual void	v_ReadEdges ()

virtual void	v_ReadFaces ()

void	ReadElements ()

void	ReadComposites ()

virtual void	v_ReadElements1D ()

virtual void	v_ReadElements2D ()

virtual void	v_ReadElements3D ()

void	ResolveGeomRef (const std::string &prevToken, const std::string &token, CompositeSharedPtr &composite)

void	ResolveGeomRef1D (const std::string &prevToken, const std::string &token, CompositeSharedPtr &composite)

void	ResolveGeomRef2D (const std::string &prevToken, const std::string &token, CompositeSharedPtr &composite)

void	ResolveGeomRef3D (const std::string &prevToken, const std::string &token, CompositeSharedPtr &composite)

virtual void	v_WriteVertices (TiXmlElement *geomTag, PointGeomMap &verts)

virtual void	v_WriteEdges (TiXmlElement *geomTag, SegGeomMap &edges)

virtual void	v_WriteTris (TiXmlElement *faceTag, TriGeomMap &tris)

virtual void	v_WriteQuads (TiXmlElement *faceTag, QuadGeomMap &quads)

virtual void	v_WriteHexs (TiXmlElement *elmtTag, HexGeomMap &hexs)

virtual void	v_WritePrisms (TiXmlElement *elmtTag, PrismGeomMap &pris)

virtual void	v_WritePyrs (TiXmlElement *elmtTag, PyrGeomMap &pyrs)

virtual void	v_WriteTets (TiXmlElement *elmtTag, TetGeomMap &tets)

virtual void	v_WriteCurves (TiXmlElement *geomTag, CurveMap &edges, CurveMap &faces)

void	WriteComposites (TiXmlElement *geomTag, CompositeMap &comps, std::map< int, std::string > &compLabels)

void	WriteDomain (TiXmlElement *geomTag, std::map< int, CompositeMap > &domain)

void	WriteDefaultExpansion (TiXmlElement *root)

CompositeOrdering	CreateCompositeOrdering ()

Protected Member Functions inherited from Nektar::SpatialDomains::MeshGraph
virtual void	v_WriteGeometry (std::string &outfilename, bool defaultExp=false, const LibUtilities::FieldMetaDataMap &metadata=LibUtilities::NullFieldMetaDataMap)=0

virtual void	v_ReadGeometry (LibUtilities::DomainRangeShPtr rng, bool fillGraph)=0

virtual void	v_PartitionMesh (LibUtilities::SessionReaderSharedPtr session)=0

void	PopulateFaceToElMap (Geometry3DSharedPtr element, int kNfaces)
	Given a 3D geometry object #element, populate the face to element map m_faceToElMap which maps faces to their corresponding element(s). More...

ExpansionInfoMapShPtr	SetUpExpansionInfoMap ()

std::string	GetCompositeString (CompositeSharedPtr comp)
	Returns a string representation of a composite. More...

Additional Inherited Members
Protected Attributes inherited from Nektar::SpatialDomains::MeshGraph
LibUtilities::SessionReaderSharedPtr	m_session

PointGeomMap	m_vertSet

CurveMap	m_curvedEdges

CurveMap	m_curvedFaces

SegGeomMap	m_segGeoms

TriGeomMap	m_triGeoms

QuadGeomMap	m_quadGeoms

TetGeomMap	m_tetGeoms

PyrGeomMap	m_pyrGeoms

PrismGeomMap	m_prismGeoms

HexGeomMap	m_hexGeoms

int	m_meshDimension

int	m_spaceDimension

int	m_partition

bool	m_meshPartitioned = false

bool	m_useExpansionType

std::map< int, CompositeMap >	m_refComposite
	Link the refinement id with the composites. More...

std::map< int, RefRegion * >	m_refRegion
	Link the refinement id with the surface region data. More...

bool	m_refFlag = false

CompositeMap	m_meshComposites

std::map< int, std::string >	m_compositesLabels

std::map< int, CompositeMap >	m_domain

LibUtilities::DomainRangeShPtr	m_domainRange

ExpansionInfoMapShPtrMap	m_expansionMapShPtrMap

std::unordered_map< int, GeometryLinkSharedPtr >	m_faceToElMap

TiXmlElement *	m_xmlGeom

CompositeOrdering	m_compOrder

BndRegionOrdering	m_bndRegOrder

std::unique_ptr< GeomRTree >	m_boundingBoxTree

MovementSharedPtr	m_movement = nullptr

Detailed Description

Definition at line 44 of file MeshGraphXmlCompressed.h.

Constructor & Destructor Documentation

◆ MeshGraphXmlCompressed()

Nektar::SpatialDomains::MeshGraphXmlCompressed::MeshGraphXmlCompressed ( )

inline

Definition at line 47 of file MeshGraphXmlCompressed.h.

48 {

49 }

◆ ~MeshGraphXmlCompressed()

virtual Nektar::SpatialDomains::MeshGraphXmlCompressed::~MeshGraphXmlCompressed ( )

inlinevirtual

Definition at line 51 of file MeshGraphXmlCompressed.h.

52 {

53 }

Member Function Documentation

◆ create()

static MeshGraphSharedPtr Nektar::SpatialDomains::MeshGraphXmlCompressed::create ( )

inlinestatic

Definition at line 55 of file MeshGraphXmlCompressed.h.

    {
        return MemoryManager<MeshGraphXmlCompressed>::AllocateSharedPtr();
    }

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

◆ v_ReadCurves()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves ( )

overrideprotectedvirtual

Look for elements in CURVE block.

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 206 of file MeshGraphXmlCompressed.cpp.

{
    // check to see if any scaling parameters are in
    // attributes and determine these values
    TiXmlElement *element = m_xmlGeom->FirstChildElement("VERTEX");
    ASSERTL0(element, "Unable to find mesh VERTEX tag in file.");
 
    NekDouble xscale, yscale, zscale;
 
    LibUtilities::Interpreter expEvaluator;
    const char *xscal = element->Attribute("XSCALE");
    if (!xscal)
    {
        xscale = 1.0;
    }
    else
    {
        std::string xscalstr = xscal;
        int expr_id          = expEvaluator.DefineFunction("", xscalstr);
        xscale               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *yscal = element->Attribute("YSCALE");
    if (!yscal)
    {
        yscale = 1.0;
    }
    else
    {
        std::string yscalstr = yscal;
        int expr_id          = expEvaluator.DefineFunction("", yscalstr);
        yscale               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *zscal = element->Attribute("ZSCALE");
    if (!zscal)
    {
        zscale = 1.0;
    }
    else
    {
        std::string zscalstr = zscal;
        int expr_id          = expEvaluator.DefineFunction("", zscalstr);
        zscale               = expEvaluator.Evaluate(expr_id);
    }
 
    NekDouble xmove, ymove, zmove;
 
    // check to see if any moving parameters are in
    // attributes and determine these values
 
    const char *xmov = element->Attribute("XMOVE");
    if (!xmov)
    {
        xmove = 0.0;
    }
    else
    {
        std::string xmovstr = xmov;
        int expr_id         = expEvaluator.DefineFunction("", xmovstr);
        xmove               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *ymov = element->Attribute("YMOVE");
    if (!ymov)
    {
        ymove = 0.0;
    }
    else
    {
        std::string ymovstr = ymov;
        int expr_id         = expEvaluator.DefineFunction("", ymovstr);
        ymove               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *zmov = element->Attribute("ZMOVE");
    if (!zmov)
    {
        zmove = 0.0;
    }
    else
    {
        std::string zmovstr = zmov;
        int expr_id         = expEvaluator.DefineFunction("", zmovstr);
        zmove               = expEvaluator.Evaluate(expr_id);
    }
 
    /// Look for elements in CURVE block.
    TiXmlElement *field = m_xmlGeom->FirstChildElement("CURVED");
 
    if (!field) // return if no curved entities
    {
        return;
    }
 
    string IsCompressed;
    field->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
    if (IsCompressed.size() == 0)
    {
        // this could be that the curved tag is empty
        // in this case we dont want to read it
        return;
    }
 
    ASSERTL0(boost::iequals(IsCompressed,
                            LibUtilities::CompressData::GetCompressString()),
             "Compressed formats do not match. Expected :" +
                 LibUtilities::CompressData::GetCompressString() + " but got " +
                 boost::lexical_cast<std::string>(IsCompressed));
 
    std::vector<SpatialDomains::MeshCurvedInfo> edginfo;
    std::vector<SpatialDomains::MeshCurvedInfo> facinfo;
    SpatialDomains::MeshCurvedPts cpts;
 
    // read edge, face info and curved poitns.
    TiXmlElement *x = field->FirstChildElement();
    while (x)
    {
        const char *entitytype = x->Value();
        // read in edge or face info
        if (boost::iequals(entitytype, "E"))
        {
            // read in data
            std::string elmtStr;
            TiXmlNode *child = x->FirstChild();
 
            if (child->Type() == TiXmlNode::TINYXML_TEXT)
            {
                elmtStr += child->ToText()->ValueStr();
            }
 
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(elmtStr,
                                                                edginfo);
        }
        else if (boost::iequals(entitytype, "F"))
        {
            // read in data
            std::string elmtStr;
            TiXmlNode *child = x->FirstChild();
 
            if (child->Type() == TiXmlNode::TINYXML_TEXT)
            {
                elmtStr += child->ToText()->ValueStr();
            }
 
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(elmtStr,
                                                                facinfo);
        }
        else if (boost::iequals(entitytype, "DATAPOINTS"))
        {
            NekInt id;
            ASSERTL0(x->Attribute("ID", &id),
                     "Failed to get ID from PTS section");
            cpts.id = id;
 
            // read in data
            std::string elmtStr;
 
            TiXmlElement *DataIdx = x->FirstChildElement("INDEX");
            ASSERTL0(DataIdx, "Cannot read data index tag in compressed "
                              "curved section");
 
            TiXmlNode *child = DataIdx->FirstChild();
            if (child->Type() == TiXmlNode::TINYXML_TEXT)
            {
                elmtStr = child->ToText()->ValueStr();
            }
 
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(elmtStr,
                                                                cpts.index);
 
            TiXmlElement *DataPts = x->FirstChildElement("POINTS");
            ASSERTL0(DataPts, "Cannot read data pts tag in compressed "
                              "curved section");
 
            child = DataPts->FirstChild();
            if (child->Type() == TiXmlNode::TINYXML_TEXT)
            {
                elmtStr = child->ToText()->ValueStr();
            }
 
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(elmtStr,
                                                                cpts.pts);
        }
        else
        {
            ASSERTL0(false, "Unknown tag in curved section");
        }
        x = x->NextSiblingElement();
    }
 
    // rescale (x,y,z) points;
    for (int i = 0; i < cpts.pts.size(); ++i)
    {
        cpts.pts[i].x = xscale * cpts.pts[i].x + xmove;
        cpts.pts[i].y = yscale * cpts.pts[i].y + ymove;
        cpts.pts[i].z = zscale * cpts.pts[i].z + zmove;
    }
 
    for (int i = 0; i < edginfo.size(); ++i)
    {
        int edgeid = edginfo[i].entityid;
        LibUtilities::PointsType ptype;
 
        CurveSharedPtr curve(MemoryManager<Curve>::AllocateSharedPtr(
            edgeid, ptype = (LibUtilities::PointsType)edginfo[i].ptype));
 
        // load points
        int offset = edginfo[i].ptoffset;
        for (int j = 0; j < edginfo[i].npoints; ++j)
        {
            int idx = cpts.index[offset + j];
 
            PointGeomSharedPtr vert(MemoryManager<PointGeom>::AllocateSharedPtr(
                m_spaceDimension, edginfo[i].id, cpts.pts[idx].x,
                cpts.pts[idx].y, cpts.pts[idx].z));
            curve->m_points.push_back(vert);
        }
 
        m_curvedEdges[edgeid] = curve;
    }
 
    for (int i = 0; i < facinfo.size(); ++i)
    {
        int faceid = facinfo[i].entityid;
        LibUtilities::PointsType ptype;
 
        CurveSharedPtr curve(MemoryManager<Curve>::AllocateSharedPtr(
            faceid, ptype = (LibUtilities::PointsType)facinfo[i].ptype));
 
        int offset = facinfo[i].ptoffset;
        for (int j = 0; j < facinfo[i].npoints; ++j)
        {
            int idx = cpts.index[offset + j];
 
            PointGeomSharedPtr vert(MemoryManager<PointGeom>::AllocateSharedPtr(
                m_spaceDimension, facinfo[i].id, cpts.pts[idx].x,
                cpts.pts[idx].y, cpts.pts[idx].z));
            curve->m_points.push_back(vert);
        }
 
        m_curvedFaces[faceid] = curve;
    }
}

References ASSERTL0, Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshCurvedPts::id, Nektar::SpatialDomains::MeshCurvedPts::index, Nektar::SpatialDomains::MeshGraph::m_curvedEdges, Nektar::SpatialDomains::MeshGraph::m_curvedFaces, Nektar::SpatialDomains::MeshGraph::m_spaceDimension, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, Nektar::SpatialDomains::MeshCurvedPts::pts, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadEdges()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges ( )

overrideprotectedvirtual

Look for elements in ELEMENT block.

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 452 of file MeshGraphXmlCompressed.cpp.

{
    CurveMap::iterator it;
 
    /// Look for elements in ELEMENT block.
    TiXmlElement *field = m_xmlGeom->FirstChildElement("EDGE");
 
    ASSERTL0(field, "Unable to find EDGE tag in file.");
 
    string IsCompressed;
    field->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
    ASSERTL0(boost::iequals(IsCompressed,
                            LibUtilities::CompressData::GetCompressString()),
             "Compressed formats do not match. Expected :" +
                 LibUtilities::CompressData::GetCompressString() + " but got " +
                 std::string(IsCompressed));
    // Extract the edge body
    TiXmlNode *edgeChild = field->FirstChild();
    ASSERTL0(edgeChild, "Unable to extract the data from "
                        "the compressed edge tag.");
 
    std::string edgeStr;
    if (edgeChild->Type() == TiXmlNode::TINYXML_TEXT)
    {
        edgeStr += edgeChild->ToText()->ValueStr();
    }
 
    std::vector<SpatialDomains::MeshEdge> edgeData;
    LibUtilities::CompressData::ZlibDecodeFromBase64Str(edgeStr, edgeData);
 
    int indx;
    for (int i = 0; i < edgeData.size(); ++i)
    {
        indx                           = edgeData[i].id;
        PointGeomSharedPtr vertices[2] = {GetVertex(edgeData[i].v0),
                                          GetVertex(edgeData[i].v1)};
        SegGeomSharedPtr edge;
 
        it = m_curvedEdges.find(indx);
        if (it == m_curvedEdges.end())
        {
            edge = MemoryManager<SegGeom>::AllocateSharedPtr(
                indx, m_spaceDimension, vertices);
        }
        else
        {
            edge = MemoryManager<SegGeom>::AllocateSharedPtr(
                indx, m_spaceDimension, vertices, it->second);
        }
        m_segGeoms[indx] = edge;
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetVertex(), Nektar::SpatialDomains::MeshGraph::m_curvedEdges, Nektar::SpatialDomains::MeshGraph::m_segGeoms, Nektar::SpatialDomains::MeshGraph::m_spaceDimension, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadElements1D()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D ( )

overrideprotectedvirtual

Look for elements in ELEMENT block.

All elements are of the form: "<S ID = n> ... </S>", with ? being the element type.

See if this face has curves.

Keep looking for additional segments

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 620 of file MeshGraphXmlCompressed.cpp.

{
    TiXmlElement *field = NULL;
 
    /// Look for elements in ELEMENT block.
    field = m_xmlGeom->FirstChildElement("ELEMENT");
 
    ASSERTL0(field, "Unable to find ELEMENT tag in file.");
 
    /// All elements are of the form: "<S ID = n> ... </S>", with
    /// ? being the element type.
 
    TiXmlElement *segment = field->FirstChildElement("S");
    CurveMap::iterator it;
 
    while (segment)
    {
        string IsCompressed;
        segment->QueryStringAttribute("COMPRESSED", &IsCompressed);
        ASSERTL0(
            boost::iequals(IsCompressed,
                           LibUtilities::CompressData::GetCompressString()),
            "Compressed formats do not match. Expected :" +
                LibUtilities::CompressData::GetCompressString() + " but got " +
                std::string(IsCompressed));
 
        // Extract the face body
        TiXmlNode *child = segment->FirstChild();
        ASSERTL0(child, "Unable to extract the data from "
                        "the compressed face tag.");
 
        std::string str;
        if (child->Type() == TiXmlNode::TINYXML_TEXT)
        {
            str += child->ToText()->ValueStr();
        }
 
        int indx;
 
        std::vector<SpatialDomains::MeshEdge> data;
        LibUtilities::CompressData::ZlibDecodeFromBase64Str(str, data);
 
        for (int i = 0; i < data.size(); ++i)
        {
            indx = data[i].id;
 
            /// See if this face has curves.
            it = m_curvedEdges.find(indx);
 
            PointGeomSharedPtr vertices[2] = {GetVertex(data[i].v0),
                                              GetVertex(data[i].v1)};
            SegGeomSharedPtr seg;
 
            if (it == m_curvedEdges.end())
            {
                seg = MemoryManager<SegGeom>::AllocateSharedPtr(
                    indx, m_spaceDimension, vertices);
                seg->SetGlobalID(indx); // Set global mesh id
            }
            else
            {
                seg = MemoryManager<SegGeom>::AllocateSharedPtr(
                    indx, m_spaceDimension, vertices, it->second);
                seg->SetGlobalID(indx); // Set global mesh id
            }
            seg->SetGlobalID(indx);
            m_segGeoms[indx] = seg;
        }
        /// Keep looking for additional segments
        segment = segment->NextSiblingElement("S");
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetVertex(), Nektar::SpatialDomains::MeshGraph::m_curvedEdges, Nektar::SpatialDomains::MeshGraph::m_segGeoms, Nektar::SpatialDomains::MeshGraph::m_spaceDimension, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadElements2D()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D ( )

overrideprotectedvirtual

Look for elements in ELEMENT block.

All elements are of the form: "<? ID="#"> ... </?>", with ? being the element type.

See if this face has curves.

Create a TriGeom to hold the new definition.

See if this face has curves.

Create a QuadGeom to hold the new definition.

Keep looking

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 693 of file MeshGraphXmlCompressed.cpp.

{
    /// Look for elements in ELEMENT block.
    TiXmlElement *field = m_xmlGeom->FirstChildElement("ELEMENT");
 
    ASSERTL0(field, "Unable to find ELEMENT tag in file.");
 
    // Set up curve map for curved elements on an embedded manifold.
    CurveMap::iterator it;
 
    /// All elements are of the form: "<? ID="#"> ... </?>", with
    /// ? being the element type.
 
    TiXmlElement *element = field->FirstChildElement();
 
    while (element)
    {
        std::string elementType(element->ValueStr());
 
        ASSERTL0(
            elementType == "Q" || elementType == "T",
            (std::string("Unknown 2D element type: ") + elementType).c_str());
 
        string IsCompressed;
        element->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
        ASSERTL0(
            boost::iequals(IsCompressed,
                           LibUtilities::CompressData::GetCompressString()),
            "Compressed formats do not match. Expected :" +
                LibUtilities::CompressData::GetCompressString() + " but got " +
                std::string(IsCompressed));
 
        // Extract the face body
        TiXmlNode *faceChild = element->FirstChild();
        ASSERTL0(faceChild, "Unable to extract the data from "
                            "the compressed face tag.");
 
        std::string faceStr;
        if (faceChild->Type() == TiXmlNode::TINYXML_TEXT)
        {
            faceStr += faceChild->ToText()->ValueStr();
        }
 
        int indx;
        if (elementType == "T")
        {
            std::vector<SpatialDomains::MeshTri> faceData;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(faceStr,
                                                                faceData);
 
            for (int i = 0; i < faceData.size(); ++i)
            {
                indx = faceData[i].id;
 
                /// See if this face has curves.
                it = m_curvedFaces.find(indx);
 
                /// Create a TriGeom to hold the new definition.
                SegGeomSharedPtr edges[TriGeom::kNedges] = {
                    GetSegGeom(faceData[i].e[0]), GetSegGeom(faceData[i].e[1]),
                    GetSegGeom(faceData[i].e[2])};
 
                TriGeomSharedPtr trigeom;
                if (it == m_curvedFaces.end())
                {
                    trigeom =
                        MemoryManager<TriGeom>::AllocateSharedPtr(indx, edges);
                }
                else
                {
                    trigeom = MemoryManager<TriGeom>::AllocateSharedPtr(
                        indx, edges, it->second);
                }
                trigeom->SetGlobalID(indx);
                m_triGeoms[indx] = trigeom;
            }
        }
        else if (elementType == "Q")
        {
            std::vector<SpatialDomains::MeshQuad> faceData;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(faceStr,
                                                                faceData);
 
            for (int i = 0; i < faceData.size(); ++i)
            {
                indx = faceData[i].id;
 
                /// See if this face has curves.
                it = m_curvedFaces.find(indx);
 
                /// Create a QuadGeom to hold the new definition.
                SegGeomSharedPtr edges[QuadGeom::kNedges] = {
                    GetSegGeom(faceData[i].e[0]), GetSegGeom(faceData[i].e[1]),
                    GetSegGeom(faceData[i].e[2]), GetSegGeom(faceData[i].e[3])};
 
                QuadGeomSharedPtr quadgeom;
                if (it == m_curvedFaces.end())
                {
                    quadgeom =
                        MemoryManager<QuadGeom>::AllocateSharedPtr(indx, edges);
                }
                else
                {
                    quadgeom = MemoryManager<QuadGeom>::AllocateSharedPtr(
                        indx, edges, it->second);
                }
                quadgeom->SetGlobalID(indx);
                m_quadGeoms[indx] = quadgeom;
            }
        }
        /// Keep looking
        element = element->NextSiblingElement();
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetSegGeom(), Nektar::SpatialDomains::QuadGeom::kNedges, Nektar::SpatialDomains::TriGeom::kNedges, Nektar::SpatialDomains::MeshGraph::m_curvedFaces, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, Nektar::SpatialDomains::MeshGraph::m_triGeoms, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadElements3D()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D ( )

overrideprotectedvirtual

Look for elements in ELEMENT block.

All elements are of the form: "<? ID="#"> ... </?>", with ? being the element type.

Keep looking

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 809 of file MeshGraphXmlCompressed.cpp.

{
    /// Look for elements in ELEMENT block.
    TiXmlElement *field = m_xmlGeom->FirstChildElement("ELEMENT");
 
    ASSERTL0(field, "Unable to find ELEMENT tag in file.");
 
    /// All elements are of the form: "<? ID="#"> ... </?>", with
    /// ? being the element type.
 
    TiXmlElement *element = field->FirstChildElement();
 
    while (element)
    {
        std::string elementType(element->ValueStr());
 
        // A - tet, P - pyramid, R - prism, H - hex
        ASSERTL0(
            elementType == "A" || elementType == "P" || elementType == "R" ||
                elementType == "H",
            (std::string("Unknown 3D element type: ") + elementType).c_str());
 
        string IsCompressed;
        element->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
        ASSERTL0(
            boost::iequals(IsCompressed,
                           LibUtilities::CompressData::GetCompressString()),
            "Compressed formats do not match. Expected :" +
                LibUtilities::CompressData::GetCompressString() + " but got " +
                std::string(IsCompressed));
 
        // Extract the face body
        TiXmlNode *child = element->FirstChild();
        ASSERTL0(child, "Unable to extract the data from "
                        "the compressed face tag.");
 
        std::string str;
        if (child->Type() == TiXmlNode::TINYXML_TEXT)
        {
            str += child->ToText()->ValueStr();
        }
 
        int indx;
        if (elementType == "A")
        {
            std::vector<SpatialDomains::MeshTet> data;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(str, data);
            TriGeomSharedPtr tfaces[4];
            for (int i = 0; i < data.size(); ++i)
            {
                indx = data[i].id;
                for (int j = 0; j < 4; ++j)
                {
                    Geometry2DSharedPtr face = GetGeometry2D(data[i].f[j]);
                    tfaces[j] = static_pointer_cast<TriGeom>(face);
                }
 
                TetGeomSharedPtr tetgeom(
                    MemoryManager<TetGeom>::AllocateSharedPtr(indx, tfaces));
                m_tetGeoms[indx] = tetgeom;
                PopulateFaceToElMap(tetgeom, 4);
            }
        }
        else if (elementType == "P")
        {
            std::vector<SpatialDomains::MeshPyr> data;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(str, data);
            Geometry2DSharedPtr faces[5];
            for (int i = 0; i < data.size(); ++i)
            {
                indx        = data[i].id;
                int Ntfaces = 0;
                int Nqfaces = 0;
                for (int j = 0; j < 5; ++j)
                {
                    Geometry2DSharedPtr face = GetGeometry2D(data[i].f[j]);
 
                    if (face == Geometry2DSharedPtr() ||
                        (face->GetShapeType() != LibUtilities::eTriangle &&
                         face->GetShapeType() != LibUtilities::eQuadrilateral))
                    {
                        std::stringstream errorstring;
                        errorstring << "Element " << indx
                                    << " has invalid face: " << j;
                        ASSERTL0(false, errorstring.str().c_str());
                    }
                    else if (face->GetShapeType() == LibUtilities::eTriangle)
                    {
                        faces[j] = static_pointer_cast<TriGeom>(face);
                        Ntfaces++;
                    }
                    else if (face->GetShapeType() ==
                             LibUtilities::eQuadrilateral)
                    {
                        faces[j] = static_pointer_cast<QuadGeom>(face);
                        Nqfaces++;
                    }
                }
                ASSERTL0((Ntfaces == 4) && (Nqfaces == 1),
                         "Did not identify the correct number of "
                         "triangular and quadrilateral faces for a "
                         "pyramid");
 
                PyrGeomSharedPtr pyrgeom(
                    MemoryManager<PyrGeom>::AllocateSharedPtr(indx, faces));
 
                m_pyrGeoms[indx] = pyrgeom;
                PopulateFaceToElMap(pyrgeom, 5);
            }
        }
        else if (elementType == "R")
        {
            std::vector<SpatialDomains::MeshPrism> data;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(str, data);
            Geometry2DSharedPtr faces[5];
            for (int i = 0; i < data.size(); ++i)
            {
                indx        = data[i].id;
                int Ntfaces = 0;
                int Nqfaces = 0;
                for (int j = 0; j < 5; ++j)
                {
                    Geometry2DSharedPtr face = GetGeometry2D(data[i].f[j]);
                    if (face == Geometry2DSharedPtr() ||
                        (face->GetShapeType() != LibUtilities::eTriangle &&
                         face->GetShapeType() != LibUtilities::eQuadrilateral))
                    {
                        std::stringstream errorstring;
                        errorstring << "Element " << indx
                                    << " has invalid face: " << j;
                        ASSERTL0(false, errorstring.str().c_str());
                    }
                    else if (face->GetShapeType() == LibUtilities::eTriangle)
                    {
                        faces[j] = static_pointer_cast<TriGeom>(face);
                        Ntfaces++;
                    }
                    else if (face->GetShapeType() ==
                             LibUtilities::eQuadrilateral)
                    {
                        faces[j] = static_pointer_cast<QuadGeom>(face);
                        Nqfaces++;
                    }
                }
                ASSERTL0((Ntfaces == 2) && (Nqfaces == 3),
                         "Did not identify the correct number of "
                         "triangular and quadrilateral faces for a "
                         "prism");
 
                PrismGeomSharedPtr prismgeom(
                    MemoryManager<PrismGeom>::AllocateSharedPtr(indx, faces));
 
                m_prismGeoms[indx] = prismgeom;
                PopulateFaceToElMap(prismgeom, 5);
            }
        }
        else if (elementType == "H")
        {
            std::vector<SpatialDomains::MeshHex> data;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(str, data);
 
            QuadGeomSharedPtr faces[6];
            for (int i = 0; i < data.size(); ++i)
            {
                indx = data[i].id;
                for (int j = 0; j < 6; ++j)
                {
                    Geometry2DSharedPtr face = GetGeometry2D(data[i].f[j]);
                    faces[j] = static_pointer_cast<QuadGeom>(face);
                }
 
                HexGeomSharedPtr hexgeom(
                    MemoryManager<HexGeom>::AllocateSharedPtr(indx, faces));
                m_hexGeoms[indx] = hexgeom;
                PopulateFaceToElMap(hexgeom, 6);
            }
        }
        /// Keep looking
        element = element->NextSiblingElement();
    }
}

References ASSERTL0, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTriangle, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetGeometry2D(), Nektar::SpatialDomains::MeshGraph::m_hexGeoms, Nektar::SpatialDomains::MeshGraph::m_prismGeoms, Nektar::SpatialDomains::MeshGraph::m_pyrGeoms, Nektar::SpatialDomains::MeshGraph::m_tetGeoms, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, Nektar::SpatialDomains::MeshGraph::PopulateFaceToElMap(), and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadFaces()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces ( )

overrideprotectedvirtual

Look for elements in FACE block.

All faces are of the form: "<? ID="#"> ... </?>", with ? being an element type (either Q or T). They might be in compressed format and so then need upacking.

See if this face has curves.

Create a TriGeom to hold the new definition.

See if this face has curves.

Create a QuadGeom to hold the new definition.

Keep looking

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 506 of file MeshGraphXmlCompressed.cpp.

{
    /// Look for elements in FACE block.
    TiXmlElement *field = m_xmlGeom->FirstChildElement("FACE");
 
    ASSERTL0(field, "Unable to find FACE tag in file.");
 
    /// All faces are of the form: "<? ID="#"> ... </?>", with
    /// ? being an element type (either Q or T).
    /// They might be in compressed format and so then need upacking.
 
    TiXmlElement *element = field->FirstChildElement();
    CurveMap::iterator it;
 
    while (element)
    {
        std::string elementType(element->ValueStr());
 
        ASSERTL0(elementType == "Q" || elementType == "T",
                 (std::string("Unknown 3D face type: ") + elementType).c_str());
 
        string IsCompressed;
        element->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
        ASSERTL0(
            boost::iequals(IsCompressed,
                           LibUtilities::CompressData::GetCompressString()),
            "Compressed formats do not match. Expected :" +
                LibUtilities::CompressData::GetCompressString() + " but got " +
                std::string(IsCompressed));
 
        // Extract the face body
        TiXmlNode *faceChild = element->FirstChild();
        ASSERTL0(faceChild, "Unable to extract the data from "
                            "the compressed face tag.");
 
        std::string faceStr;
        if (faceChild->Type() == TiXmlNode::TINYXML_TEXT)
        {
            faceStr += faceChild->ToText()->ValueStr();
        }
 
        int indx;
        if (elementType == "T")
        {
            std::vector<SpatialDomains::MeshTri> faceData;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(faceStr,
                                                                faceData);
 
            for (int i = 0; i < faceData.size(); ++i)
            {
                indx = faceData[i].id;
 
                /// See if this face has curves.
                it = m_curvedFaces.find(indx);
 
                /// Create a TriGeom to hold the new definition.
                SegGeomSharedPtr edges[TriGeom::kNedges] = {
                    GetSegGeom(faceData[i].e[0]), GetSegGeom(faceData[i].e[1]),
                    GetSegGeom(faceData[i].e[2])};
 
                TriGeomSharedPtr trigeom;
                if (it == m_curvedFaces.end())
                {
                    trigeom =
                        MemoryManager<TriGeom>::AllocateSharedPtr(indx, edges);
                }
                else
                {
                    trigeom = MemoryManager<TriGeom>::AllocateSharedPtr(
                        indx, edges, it->second);
                }
                trigeom->SetGlobalID(indx);
                m_triGeoms[indx] = trigeom;
            }
        }
        else if (elementType == "Q")
        {
            std::vector<SpatialDomains::MeshQuad> faceData;
            LibUtilities::CompressData::ZlibDecodeFromBase64Str(faceStr,
                                                                faceData);
 
            for (int i = 0; i < faceData.size(); ++i)
            {
                indx = faceData[i].id;
 
                /// See if this face has curves.
                it = m_curvedFaces.find(indx);
 
                /// Create a QuadGeom to hold the new definition.
                SegGeomSharedPtr edges[QuadGeom::kNedges] = {
                    GetSegGeom(faceData[i].e[0]), GetSegGeom(faceData[i].e[1]),
                    GetSegGeom(faceData[i].e[2]), GetSegGeom(faceData[i].e[3])};
 
                QuadGeomSharedPtr quadgeom;
                if (it == m_curvedFaces.end())
                {
                    quadgeom =
                        MemoryManager<QuadGeom>::AllocateSharedPtr(indx, edges);
                }
                else
                {
                    quadgeom = MemoryManager<QuadGeom>::AllocateSharedPtr(
                        indx, edges, it->second);
                }
                quadgeom->SetGlobalID(indx);
                m_quadGeoms[indx] = quadgeom;
            }
        }
        /// Keep looking
        element = element->NextSiblingElement();
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::GetSegGeom(), Nektar::SpatialDomains::QuadGeom::kNedges, Nektar::SpatialDomains::TriGeom::kNedges, Nektar::SpatialDomains::MeshGraph::m_curvedFaces, Nektar::SpatialDomains::MeshGraph::m_quadGeoms, Nektar::SpatialDomains::MeshGraph::m_triGeoms, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_ReadVertices()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadVertices ( )

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 69 of file MeshGraphXmlCompressed.cpp.

{
    // Now read the vertices
    TiXmlElement *element = m_xmlGeom->FirstChildElement("VERTEX");
    ASSERTL0(element, "Unable to find mesh VERTEX tag in file.");
 
    NekDouble xscale, yscale, zscale;
 
    // check to see if any scaling parameters are in
    // attributes and determine these values
    LibUtilities::Interpreter expEvaluator;
    const char *xscal = element->Attribute("XSCALE");
    if (!xscal)
    {
        xscale = 1.0;
    }
    else
    {
        std::string xscalstr = xscal;
        int expr_id          = expEvaluator.DefineFunction("", xscalstr);
        xscale               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *yscal = element->Attribute("YSCALE");
    if (!yscal)
    {
        yscale = 1.0;
    }
    else
    {
        std::string yscalstr = yscal;
        int expr_id          = expEvaluator.DefineFunction("", yscalstr);
        yscale               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *zscal = element->Attribute("ZSCALE");
    if (!zscal)
    {
        zscale = 1.0;
    }
    else
    {
        std::string zscalstr = zscal;
        int expr_id          = expEvaluator.DefineFunction("", zscalstr);
        zscale               = expEvaluator.Evaluate(expr_id);
    }
 
    NekDouble xmove, ymove, zmove;
 
    // check to see if any moving parameters are in
    // attributes and determine these values
 
    const char *xmov = element->Attribute("XMOVE");
    if (!xmov)
    {
        xmove = 0.0;
    }
    else
    {
        std::string xmovstr = xmov;
        int expr_id         = expEvaluator.DefineFunction("", xmovstr);
        xmove               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *ymov = element->Attribute("YMOVE");
    if (!ymov)
    {
        ymove = 0.0;
    }
    else
    {
        std::string ymovstr = ymov;
        int expr_id         = expEvaluator.DefineFunction("", ymovstr);
        ymove               = expEvaluator.Evaluate(expr_id);
    }
 
    const char *zmov = element->Attribute("ZMOVE");
    if (!zmov)
    {
        zmove = 0.0;
    }
    else
    {
        std::string zmovstr = zmov;
        int expr_id         = expEvaluator.DefineFunction("", zmovstr);
        zmove               = expEvaluator.Evaluate(expr_id);
    }
 
    string IsCompressed;
    element->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
    if (boost::iequals(IsCompressed,
                       LibUtilities::CompressData::GetCompressString()))
    {
        // Extract the vertex body
        TiXmlNode *vertexChild = element->FirstChild();
        ASSERTL0(vertexChild, "Unable to extract the data from the compressed "
                              "vertex tag.");
 
        std::string vertexStr;
        if (vertexChild->Type() == TiXmlNode::TINYXML_TEXT)
        {
            vertexStr += vertexChild->ToText()->ValueStr();
        }
 
        std::vector<SpatialDomains::MeshVertex> vertData;
        LibUtilities::CompressData::ZlibDecodeFromBase64Str(vertexStr,
                                                            vertData);
 
        int indx;
        NekDouble xval, yval, zval;
        for (int i = 0; i < vertData.size(); ++i)
        {
            indx = vertData[i].id;
            xval = vertData[i].x;
            yval = vertData[i].y;
            zval = vertData[i].z;
 
            xval = xval * xscale + xmove;
            yval = yval * yscale + ymove;
            zval = zval * zscale + zmove;
 
            PointGeomSharedPtr vert(MemoryManager<PointGeom>::AllocateSharedPtr(
                m_spaceDimension, indx, xval, yval, zval));
 
            vert->SetGlobalID(indx);
            m_vertSet[indx] = vert;
        }
    }
    else
    {
        ASSERTL0(false, "Compressed formats do not match. Expected :" +
                            LibUtilities::CompressData::GetCompressString() +
                            " but got " + std::string(IsCompressed));
    }
}

References ASSERTL0, Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshGraph::m_spaceDimension, Nektar::SpatialDomains::MeshGraph::m_vertSet, Nektar::SpatialDomains::MeshGraph::m_xmlGeom, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

◆ v_WriteCurves()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteCurves	(	TiXmlElement *	geomTag,
		CurveMap &	edges,
		CurveMap &	faces
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1290 of file MeshGraphXmlCompressed.cpp.

{
    if (edges.size() == 0 && faces.size() == 0)
    {
        return;
    }
 
    TiXmlElement *curveTag = new TiXmlElement("CURVED");
 
    vector<MeshCurvedInfo> edgeInfo;
    vector<MeshCurvedInfo> faceInfo;
    MeshCurvedPts curvedPts;
    curvedPts.id = 0;
    int ptOffset = 0;
    int newIdx   = 0;
    int edgeCnt  = 0;
    int faceCnt  = 0;
 
    for (auto &i : edges)
    {
        MeshCurvedInfo cinfo;
        cinfo.id       = edgeCnt++;
        cinfo.entityid = i.first;
        cinfo.npoints  = i.second->m_points.size();
        cinfo.ptype    = i.second->m_ptype;
        cinfo.ptid     = 0;
        cinfo.ptoffset = ptOffset;
 
        edgeInfo.push_back(cinfo);
 
        for (int j = 0; j < i.second->m_points.size(); j++)
        {
            MeshVertex v;
            v.id = newIdx;
            v.x  = i.second->m_points[j]->x();
            v.y  = i.second->m_points[j]->y();
            v.z  = i.second->m_points[j]->z();
            curvedPts.pts.push_back(v);
            curvedPts.index.push_back(newIdx);
            newIdx++;
        }
        ptOffset += cinfo.npoints;
    }
 
    for (auto &i : faces)
    {
        MeshCurvedInfo cinfo;
        cinfo.id       = faceCnt++;
        cinfo.entityid = i.first;
        cinfo.npoints  = i.second->m_points.size();
        cinfo.ptype    = i.second->m_ptype;
        cinfo.ptid     = 0;
        cinfo.ptoffset = ptOffset;
 
        faceInfo.push_back(cinfo);
 
        for (int j = 0; j < i.second->m_points.size(); j++)
        {
            MeshVertex v;
            v.id = newIdx;
            v.x  = i.second->m_points[j]->x();
            v.y  = i.second->m_points[j]->y();
            v.z  = i.second->m_points[j]->z();
            curvedPts.pts.push_back(v);
            curvedPts.index.push_back(newIdx);
            newIdx++;
        }
        ptOffset += cinfo.npoints;
    }
 
    curveTag->SetAttribute("COMPRESSED",
                           LibUtilities::CompressData::GetCompressString());
    curveTag->SetAttribute("BITSIZE",
                           LibUtilities::CompressData::GetBitSizeStr());
 
    if (edgeInfo.size())
    {
        TiXmlElement *x = new TiXmlElement("E");
        string dataStr;
        LibUtilities::CompressData::ZlibEncodeToBase64Str(edgeInfo, dataStr);
 
        x->LinkEndChild(new TiXmlText(dataStr));
        curveTag->LinkEndChild(x);
    }
 
    if (faceInfo.size())
    {
        TiXmlElement *x = new TiXmlElement("F");
        string dataStr;
        LibUtilities::CompressData::ZlibEncodeToBase64Str(faceInfo, dataStr);
 
        x->LinkEndChild(new TiXmlText(dataStr));
        curveTag->LinkEndChild(x);
    }
 
    if (edgeInfo.size() || faceInfo.size())
    {
        TiXmlElement *x = new TiXmlElement("DATAPOINTS");
        x->SetAttribute("ID", curvedPts.id);
        TiXmlElement *subx = new TiXmlElement("INDEX");
        string dataStr;
        LibUtilities::CompressData::ZlibEncodeToBase64Str(curvedPts.index,
                                                          dataStr);
        subx->LinkEndChild(new TiXmlText(dataStr));
        x->LinkEndChild(subx);
 
        subx = new TiXmlElement("POINTS");
        LibUtilities::CompressData::ZlibEncodeToBase64Str(curvedPts.pts,
                                                          dataStr);
        subx->LinkEndChild(new TiXmlText(dataStr));
        x->LinkEndChild(subx);
        curveTag->LinkEndChild(x);
    }
 
    geomTag->LinkEndChild(curveTag);
}

◆ v_WriteEdges()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteEdges	(	TiXmlElement *	geomTag,
		SegGeomMap &	edges
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1027 of file MeshGraphXmlCompressed.cpp.

{
    if (edges.size() == 0)
    {
        return;
    }
 
    TiXmlElement *edgeTag =
        new TiXmlElement(m_meshDimension == 1 ? "S" : "EDGE");
 
    vector<MeshEdge> edgeInfo;
 
    for (auto &i : edges)
    {
        MeshEdge e;
        e.id = i.first;
        e.v0 = i.second->GetVid(0);
        e.v1 = i.second->GetVid(1);
        edgeInfo.push_back(e);
    }
 
    string edgeStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(edgeInfo, edgeStr);
 
    edgeTag->SetAttribute("COMPRESSED",
                          LibUtilities::CompressData::GetCompressString());
    edgeTag->SetAttribute("BITSIZE",
                          LibUtilities::CompressData::GetBitSizeStr());
 
    edgeTag->LinkEndChild(new TiXmlText(edgeStr));
 
    if (m_meshDimension == 1)
    {
        TiXmlElement *tmp = new TiXmlElement("ELEMENT");
        tmp->LinkEndChild(edgeTag);
        geomTag->LinkEndChild(tmp);
    }
    else
    {
        geomTag->LinkEndChild(edgeTag);
    }
}

References Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshEdge::id, Nektar::SpatialDomains::MeshGraph::m_meshDimension, Nektar::SpatialDomains::MeshEdge::v0, Nektar::SpatialDomains::MeshEdge::v1, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WriteHexs()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteHexs	(	TiXmlElement *	elmtTag,
		HexGeomMap &	hexs
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1142 of file MeshGraphXmlCompressed.cpp.

{
    if (hexs.size() == 0)
    {
        return;
    }
 
    string tag = "H";
 
    vector<MeshHex> elementInfo;
 
    for (auto &i : hexs)
    {
        MeshHex e;
        e.id   = i.first;
        e.f[0] = i.second->GetFid(0);
        e.f[1] = i.second->GetFid(1);
        e.f[2] = i.second->GetFid(2);
        e.f[3] = i.second->GetFid(3);
        e.f[4] = i.second->GetFid(4);
        e.f[5] = i.second->GetFid(5);
        elementInfo.push_back(e);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string elStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(elementInfo, elStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(elStr));
 
    elmtTag->LinkEndChild(x);
}

References Nektar::SpatialDomains::MeshHex::f, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshHex::id, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WritePrisms()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WritePrisms	(	TiXmlElement *	elmtTag,
		PrismGeomMap &	pris
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1180 of file MeshGraphXmlCompressed.cpp.

{
    if (pris.size() == 0)
    {
        return;
    }
 
    string tag = "R";
 
    vector<MeshPrism> elementInfo;
 
    for (auto &i : pris)
    {
        MeshPrism e;
        e.id   = i.first;
        e.f[0] = i.second->GetFid(0);
        e.f[1] = i.second->GetFid(1);
        e.f[2] = i.second->GetFid(2);
        e.f[3] = i.second->GetFid(3);
        e.f[4] = i.second->GetFid(4);
        elementInfo.push_back(e);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string elStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(elementInfo, elStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(elStr));
 
    elmtTag->LinkEndChild(x);
}

References Nektar::SpatialDomains::MeshPrism::f, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshPrism::id, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WritePyrs()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WritePyrs	(	TiXmlElement *	elmtTag,
		PyrGeomMap &	pyrs
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1217 of file MeshGraphXmlCompressed.cpp.

{
    if (pyrs.size() == 0)
    {
        return;
    }
 
    string tag = "P";
 
    vector<MeshPyr> elementInfo;
 
    for (auto &i : pyrs)
    {
        MeshPyr e;
        e.id   = i.first;
        e.f[0] = i.second->GetFid(0);
        e.f[1] = i.second->GetFid(1);
        e.f[2] = i.second->GetFid(2);
        e.f[3] = i.second->GetFid(3);
        e.f[4] = i.second->GetFid(4);
        elementInfo.push_back(e);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string elStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(elementInfo, elStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(elStr));
 
    elmtTag->LinkEndChild(x);
}

References Nektar::SpatialDomains::MeshPyr::f, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshPyr::id, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WriteQuads()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteQuads	(	TiXmlElement *	faceTag,
		QuadGeomMap &	quads
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1106 of file MeshGraphXmlCompressed.cpp.

{
    if (quads.size() == 0)
    {
        return;
    }
 
    string tag = "Q";
 
    vector<MeshQuad> quadInfo;
 
    for (auto &i : quads)
    {
        MeshQuad q;
        q.id   = i.first;
        q.e[0] = i.second->GetEid(0);
        q.e[1] = i.second->GetEid(1);
        q.e[2] = i.second->GetEid(2);
        q.e[3] = i.second->GetEid(3);
        quadInfo.push_back(q);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string quadStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(quadInfo, quadStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(quadStr));
 
    faceTag->LinkEndChild(x);
}

References Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::UnitTests::q(), and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WriteTets()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteTets	(	TiXmlElement *	elmtTag,
		TetGeomMap &	tets
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1254 of file MeshGraphXmlCompressed.cpp.

{
    if (tets.size() == 0)
    {
        return;
    }
 
    string tag = "A";
 
    vector<MeshTet> elementInfo;
 
    for (auto &i : tets)
    {
        MeshTet e;
        e.id   = i.first;
        e.f[0] = i.second->GetFid(0);
        e.f[1] = i.second->GetFid(1);
        e.f[2] = i.second->GetFid(2);
        e.f[3] = i.second->GetFid(3);
        elementInfo.push_back(e);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string elStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(elementInfo, elStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(elStr));
 
    elmtTag->LinkEndChild(x);
}

References Nektar::SpatialDomains::MeshTet::f, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshTet::id, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WriteTris()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteTris	(	TiXmlElement *	faceTag,
		TriGeomMap &	tris
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 1071 of file MeshGraphXmlCompressed.cpp.

{
    if (tris.size() == 0)
    {
        return;
    }
 
    string tag = "T";
 
    vector<MeshTri> triInfo;
 
    for (auto &i : tris)
    {
        MeshTri t;
        t.id   = i.first;
        t.e[0] = i.second->GetEid(0);
        t.e[1] = i.second->GetEid(1);
        t.e[2] = i.second->GetEid(2);
        triInfo.push_back(t);
    }
 
    TiXmlElement *x = new TiXmlElement(tag);
    string triStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(triInfo, triStr);
 
    x->SetAttribute("COMPRESSED",
                    LibUtilities::CompressData::GetCompressString());
    x->SetAttribute("BITSIZE", LibUtilities::CompressData::GetBitSizeStr());
 
    x->LinkEndChild(new TiXmlText(triStr));
 
    faceTag->LinkEndChild(x);
}

References Nektar::SpatialDomains::MeshTri::e, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshTri::id, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

◆ v_WriteVertices()

void Nektar::SpatialDomains::MeshGraphXmlCompressed::v_WriteVertices	(	TiXmlElement *	geomTag,
		PointGeomMap &	verts
	)

overrideprotectedvirtual

Reimplemented from Nektar::SpatialDomains::MeshGraphXml.

Definition at line 992 of file MeshGraphXmlCompressed.cpp.

{
    if (verts.size() == 0)
    {
        return;
    }
 
    TiXmlElement *vertTag = new TiXmlElement("VERTEX");
 
    vector<MeshVertex> vertInfo;
 
    for (auto &i : verts)
    {
        MeshVertex v;
        v.id = i.first;
        v.x  = i.second->x();
        v.y  = i.second->y();
        v.z  = i.second->z();
        vertInfo.push_back(v);
    }
 
    vertTag->SetAttribute("COMPRESSED",
                          LibUtilities::CompressData::GetCompressString());
    vertTag->SetAttribute("BITSIZE",
                          LibUtilities::CompressData::GetBitSizeStr());
 
    string vertStr;
    LibUtilities::CompressData::ZlibEncodeToBase64Str(vertInfo, vertStr);
 
    vertTag->LinkEndChild(new TiXmlText(vertStr));
 
    geomTag->LinkEndChild(vertTag);
}

References Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshVertex::id, Nektar::SpatialDomains::MeshVertex::x, Nektar::SpatialDomains::MeshVertex::y, Nektar::SpatialDomains::MeshVertex::z, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

Member Data Documentation

◆ className

std::string Nektar::SpatialDomains::MeshGraphXmlCompressed::className

static

Initial value:

=
    GetMeshGraphFactory().RegisterCreatorFunction(
        "XmlCompressed", MeshGraphXmlCompressed::create,
        "IO with Xml geometry")

Definition at line 60 of file MeshGraphXmlCompressed.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MeshGraphXmlCompressed()

◆ ~MeshGraphXmlCompressed()

Member Function Documentation

◆ create()

◆ v_ReadCurves()

◆ v_ReadEdges()

◆ v_ReadElements1D()

◆ v_ReadElements2D()

◆ v_ReadElements3D()

◆ v_ReadFaces()

◆ v_ReadVertices()

◆ v_WriteCurves()

◆ v_WriteEdges()

◆ v_WriteHexs()

◆ v_WritePrisms()

◆ v_WritePyrs()

◆ v_WriteQuads()

◆ v_WriteTets()

◆ v_WriteTris()

◆ v_WriteVertices()

Member Data Documentation

◆ className