Nektar::SpatialDomains::MeshGraphXmlCompressed Class Reference

#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 ()
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	SetExpansionInfo (const std::string variable, ExpansionInfoMapShPtr &exp)
	This function sets the expansion #exp in map with entry #variable. More...
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 ()
int	GetNumElements ()
Geometry2DSharedPtr	GetGeometry2D (int gID)
LibUtilities::BasisKey	GetEdgeBasisKey (SegGeomSharedPtr edge, const std::string variable="DefaultVar")
GeometryLinkSharedPtr	GetElementsFromEdge (Geometry1DSharedPtr edge)
GeometryLinkSharedPtr	GetElementsFromFace (Geometry2DSharedPtr face)
LibUtilities::BasisKey	GetFaceBasisKey (Geometry2DSharedPtr face, const int facedir, const std::string variable="DefaultVar")
	3D functions More...
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)
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
void	ReadDomain ()
void	ReadElements ()
void	ReadComposites ()
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)
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
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
CompositeMap	m_meshComposites
std::map< int, std::string >	m_compositesLabels
std::map< int, CompositeMap >	m_domain
LibUtilities::DomainRangeShPtr	m_domainRange
ExpansionInfoMapShPtrMap	m_expansionMapShPtrMap
GeomInfoMap	m_geomInfo
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.

    {
    }

~MeshGraphXmlCompressed()

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

inlinevirtual

Definition at line 51 of file MeshGraphXmlCompressed.h.

    {
    }

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::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 ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), 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 ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), 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 ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), 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(), 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 ASSERTL0, Nektar::LibUtilities::CompressData::GetCompressString(), 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(), 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);
}

References Nektar::SpatialDomains::MeshCurvedInfo::entityid, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshVertex::id, Nektar::SpatialDomains::MeshCurvedInfo::id, Nektar::SpatialDomains::MeshCurvedPts::id, Nektar::SpatialDomains::MeshCurvedPts::index, Nektar::SpatialDomains::MeshCurvedInfo::npoints, Nektar::SpatialDomains::MeshCurvedInfo::ptid, Nektar::SpatialDomains::MeshCurvedInfo::ptoffset, Nektar::SpatialDomains::MeshCurvedPts::pts, Nektar::SpatialDomains::MeshCurvedInfo::ptype, Nektar::SpatialDomains::MeshVertex::x, Nektar::SpatialDomains::MeshVertex::y, Nektar::SpatialDomains::MeshVertex::z, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

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::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::SpatialDomains::MeshQuad::e, Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::SpatialDomains::MeshQuad::id, 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.