Nektar::SpatialDomains::BoundaryConditions Class Reference

#include <Conditions.h>

Public Member Functions
	BoundaryConditions (const LibUtilities::SessionReaderSharedPtr &pSession, const MeshGraphSharedPtr &meshGraph)
	BoundaryConditions (void)
	~BoundaryConditions (void)
const BoundaryRegionCollection &	GetBoundaryRegions (void) const
void	AddBoundaryRegions (const int regionID, BoundaryRegionShPtr &bRegion)
const BoundaryConditionCollection &	GetBoundaryConditions (void) const
void	AddBoundaryConditions (const int regionID, BoundaryConditionMapShPtr &bCond)
const std::string	GetVariable (unsigned int indx)
std::map< int, LibUtilities::CommSharedPtr >	GetBoundaryCommunicators () const

Protected Attributes
MeshGraphSharedPtr	m_meshGraph
	The mesh graph to use for referencing geometry info. More...
LibUtilities::SessionReaderSharedPtr	m_session
BoundaryRegionCollection	m_boundaryRegions
BoundaryConditionCollection	m_boundaryConditions
std::map< int, LibUtilities::CommSharedPtr >	m_boundaryCommunicators

Private Member Functions
void	Read (TiXmlElement *conditions)
	Read segments (and general MeshGraph) given TiXmlDocument. More...
void	ReadBoundaryRegions (TiXmlElement *regions)
void	ReadBoundaryConditions (TiXmlElement *conditions)
void	CreateBoundaryComms ()

Detailed Description

Definition at line 230 of file Conditions.h.

Constructor & Destructor Documentation

BoundaryConditions() [1/2]

Nektar::SpatialDomains::BoundaryConditions::BoundaryConditions	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const MeshGraphSharedPtr &	meshGraph
	)

Constructor - collective on the session's communicator.

Definition at line 50 of file Conditions.cpp.

References m_session, and Read().

    : m_meshGraph(meshGraph), m_session(pSession)

{
    Read(m_session->GetElement("Nektar/Conditions"));
}

BoundaryConditions() [2/2]

Nektar::SpatialDomains::BoundaryConditions::BoundaryConditions

(

void

)

Definition at line 59 of file Conditions.cpp.

{
}

~BoundaryConditions()

Nektar::SpatialDomains::BoundaryConditions::~BoundaryConditions

(

void

)

Definition at line 63 of file Conditions.cpp.

{
}

Member Function Documentation

AddBoundaryConditions()

void Nektar::SpatialDomains::BoundaryConditions::AddBoundaryConditions ( const int  regionID, BoundaryConditionMapShPtr &  bCond  )

inline

Definition at line 254 of file Conditions.h.

            {
                m_boundaryConditions[regionID] = bCond; 
            }

AddBoundaryRegions()

void Nektar::SpatialDomains::BoundaryConditions::AddBoundaryRegions ( const int  regionID, BoundaryRegionShPtr &  bRegion  )

inline

Definition at line 243 of file Conditions.h.

            {
                m_boundaryRegions[regionID] = bRegion;
            }

CreateBoundaryComms()

void Nektar::SpatialDomains::BoundaryConditions::CreateBoundaryComms ( )

private

Create a new communicator for each boundary region. Collective on the session's communicator.

Definition at line 174 of file Conditions.cpp.

References ASSERTL0, m_boundaryCommunicators, m_boundaryRegions, m_session, and Nektar::SpatialDomains::ShareAllBoundaryIDs().

Referenced by Read().

{
    LibUtilities::CommSharedPtr comm = m_session->GetComm();

    if (comm->IsSerial())
    {
        // Do not try and generate a communicator if we have a serial
        // communicator. Arises with a FieldConvert communicator when
        // using --nparts in FieldConvert. Just set communicator to comm
        // in this case.
        for (auto &it : m_boundaryRegions)
        {
            m_boundaryCommunicators[it.first] = comm;
        }
        return;
    }

    std::set<int> allids = ShareAllBoundaryIDs(m_boundaryRegions, comm);

    for (auto &it : allids)
    {
        auto reg_it                = m_boundaryRegions.find(it);
        int this_rank_participates = (reg_it != m_boundaryRegions.end());
        LibUtilities::CommSharedPtr comm_region =
            comm->CommCreateIf(this_rank_participates);

        ASSERTL0(bool(comm_region) == bool(this_rank_participates),
                 "Rank should be in communicator but wasn't or is in "
                 "communicator but shouldn't be.");

        if (this_rank_participates)
        {
            m_boundaryCommunicators[reg_it->first] = comm_region;
        }
    }
}

GetBoundaryCommunicators()

std::map<int, LibUtilities::CommSharedPtr> Nektar::SpatialDomains::BoundaryConditions::GetBoundaryCommunicators ( ) const

inline

Definition at line 264 of file Conditions.h.

            {
                return m_boundaryCommunicators;
            }

GetBoundaryConditions()

const BoundaryConditionCollection& Nektar::SpatialDomains::BoundaryConditions::GetBoundaryConditions ( void  ) const

inline

Definition at line 248 of file Conditions.h.

Referenced by Nektar::MultiRegions::DisContField2D::FindPeriodicEdges(), Nektar::MultiRegions::DisContField3D::FindPeriodicFaces(), Nektar::MultiRegions::DisContField1D::FindPeriodicVertices(), Nektar::MultiRegions::DisContField3D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField1D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField2D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField1D::GetDomainBCs(), Nektar::MultiRegions::DisContField1D::SetBoundaryConditionExpansion(), and Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions().

            {
                return m_boundaryConditions;
            }

GetBoundaryRegions()

const BoundaryRegionCollection& Nektar::SpatialDomains::BoundaryConditions::GetBoundaryRegions ( void  ) const

inline

Definition at line 238 of file Conditions.h.

Referenced by Nektar::SolverUtils::ForcingAbsorption::CalcAbsorption(), Nektar::MultiRegions::DisContField2D::FindPeriodicEdges(), Nektar::MultiRegions::DisContField3D::FindPeriodicFaces(), Nektar::MultiRegions::DisContField1D::FindPeriodicVertices(), Nektar::MultiRegions::DisContField1D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField3D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField2D::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField1D::GetDomainBCs(), main(), Nektar::FieldUtils::OutputFileBase::Process(), Nektar::FieldUtils::ProcessBoundaryExtract::Process(), Nektar::FieldUtils::ProcessWSS::Process(), Nektar::MultiRegions::DisContField1D::SetBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::SetupBoundaryConditions(), Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions(), Nektar::FilterMovingBody::v_Initialise(), and Nektar::SolverUtils::FilterAeroForces::v_Initialise().

            {
                return m_boundaryRegions;
            }

GetVariable()

const std::string Nektar::SpatialDomains::BoundaryConditions::GetVariable ( unsigned int  indx )

inline

Definition at line 259 of file Conditions.h.

            {
                return m_session->GetVariable(indx);
            }

Read()

void Nektar::SpatialDomains::BoundaryConditions::Read ( TiXmlElement *  conditions )

private

Read segments (and general MeshGraph) given TiXmlDocument.

Collective on the session's communicator.

Definition at line 214 of file Conditions.cpp.

References ASSERTL0, CreateBoundaryComms(), ReadBoundaryConditions(), and ReadBoundaryRegions().

Referenced by BoundaryConditions().

{
    ASSERTL0(conditions, "Unable to find CONDITIONS tag in file.");

    TiXmlElement *boundaryRegions =
        conditions->FirstChildElement("BOUNDARYREGIONS");

    if (boundaryRegions)
    {
        ReadBoundaryRegions(conditions);
        CreateBoundaryComms();
        ReadBoundaryConditions(conditions);
    }
}

ReadBoundaryConditions()

void Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions ( TiXmlElement *  conditions )

private

Definition at line 311 of file Conditions.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::StdRegions::find(), Nektar::ParseUtils::GenerateSeqVector(), m_boundaryCommunicators, m_boundaryConditions, m_boundaryRegions, and m_session.

Referenced by Read().

{
    // Protect against multiple reads.
    if (m_boundaryConditions.size() != 0)
    {
        return;
    }

    // Read REGION tags
    TiXmlElement *boundaryConditionsElement =
        conditions->FirstChildElement("BOUNDARYCONDITIONS");
    ASSERTL0(boundaryConditionsElement,
             "Boundary conditions must be specified.");

    TiXmlElement *regionElement =
        boundaryConditionsElement->FirstChildElement("REGION");

    // Read R (Robin), D (Dirichlet), N (Neumann), P (Periodic) C(Cauchy) tags
    while (regionElement)
    {
        BoundaryConditionMapShPtr boundaryConditions =
            MemoryManager<BoundaryConditionMap>::AllocateSharedPtr();

        int boundaryRegionID;
        int err = regionElement->QueryIntAttribute("REF", &boundaryRegionID);
        ASSERTL0(err == TIXML_SUCCESS,
                 "Error reading boundary region reference.");

        ASSERTL0(m_boundaryConditions.count(boundaryRegionID) == 0,
                 "Boundary region '" +
                 boost::lexical_cast<std::string>(boundaryRegionID) +
                 "' appears multiple times.");

        // Find the boundary region corresponding to this ID.
        std::string boundaryRegionIDStr;
        std::ostringstream boundaryRegionIDStrm(boundaryRegionIDStr);
        boundaryRegionIDStrm << boundaryRegionID;

        if (m_boundaryRegions.count(boundaryRegionID) == 0)
        {
            regionElement = regionElement->NextSiblingElement("REGION");
            continue;
        }

        ASSERTL0(m_boundaryRegions.count(boundaryRegionID) == 1,
                 "Boundary region " +
                 boost::lexical_cast<string>(boundaryRegionID) +
                 " not found");

        // Find the communicator that belongs to this ID
        LibUtilities::CommSharedPtr boundaryRegionComm =
            m_boundaryCommunicators[boundaryRegionID];

        TiXmlElement *conditionElement = regionElement->FirstChildElement();
        std::vector<std::string> vars  = m_session->GetVariables();

        while (conditionElement)
        {
            // Check type.
            std::string conditionType = conditionElement->Value();
            std::string attrData;
            bool isTimeDependent = false;

            // All have var specified, or else all variables are zero.
            TiXmlAttribute *attr = conditionElement->FirstAttribute();

            std::vector<std::string>::iterator iter;
            std::string attrName;

            attrData = conditionElement->Attribute("VAR");

            if (!attrData.empty())
            {
                iter = std::find(vars.begin(), vars.end(), attrData);
                ASSERTL0(
                    iter != vars.end(),
                    (std::string("Cannot find variable: ") + attrData).c_str());
            }

            if (conditionType == "N")
            {
                if (attrData.empty())
                {
                    // All variables are Neumann and are set to zero.
                    for (auto &varIter : vars)
                    {
                        BoundaryConditionShPtr neumannCondition(
                            MemoryManager<NeumannBoundaryCondition>::
                            AllocateSharedPtr(m_session, "00.0"));
                        (*boundaryConditions)[varIter] = neumannCondition;
                    }
                }
                else
                {
                    if (attr)
                    {
                        std::string equation, userDefined, filename;

                        while (attr)
                        {

                            attrName = attr->Name();

                            if (attrName == "VAR")
                            {
                                // if VAR do nothing
                            }
                            else if (attrName == "USERDEFINEDTYPE")
                            {
                                // Do stuff for the user defined attribute
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "USERDEFINEDTYPE attribute must have "
                                         "associated value.");

                                // Suppose to go here?
                                m_session->SubstituteExpressions(attrData);

                                userDefined = attrData;
                                isTimeDependent =
                                    boost::iequals(attrData, "TimeDependent");
                            }
                            else if (attrName == "VALUE")
                            {
                                ASSERTL0(attrName == "VALUE",
                                         (std::string("Unknown attribute: ") +
                                          attrName)
                                             .c_str());

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "VALUE attribute must be specified.");

                                m_session->SubstituteExpressions(attrData);

                                equation = attrData;
                            }
                            else if (attrName == "FILE")
                            {
                                ASSERTL0(attrName == "FILE",
                                         (std::string("Unknown attribute: ") +
                                          attrName)
                                             .c_str());

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "FILE attribute must be specified.");

                                m_session->SubstituteExpressions(attrData);

                                filename = attrData;
                            }
                            else
                            {
                                ASSERTL0(false,
                                         (std::string("Unknown boundary "
                                                      "condition attribute: ") +
                                          attrName)
                                             .c_str());
                            }
                            attr = attr->Next();
                        }

                        BoundaryConditionShPtr neumannCondition(
                            MemoryManager<NeumannBoundaryCondition>::
                            AllocateSharedPtr(m_session, equation,
                                              userDefined, filename,
                                              boundaryRegionComm));
                        neumannCondition->SetIsTimeDependent(isTimeDependent);
                        (*boundaryConditions)[*iter] = neumannCondition;
                    }
                    else
                    {
                        // This variable's condition is zero.
                        BoundaryConditionShPtr neumannCondition(
                            MemoryManager<NeumannBoundaryCondition>::
                            AllocateSharedPtr(m_session, "0"));
                        (*boundaryConditions)[*iter] = neumannCondition;
                    }
                }
            }
            else if (conditionType == "D")
            {
                if (attrData.empty())
                {
                    // All variables are Dirichlet and are set to zero.
                    for (auto &varIter : vars)
                    {
                        BoundaryConditionShPtr dirichletCondition(
                            MemoryManager<DirichletBoundaryCondition>::
                            AllocateSharedPtr(m_session, "0"));
                        (*boundaryConditions)[varIter] = dirichletCondition;
                    }
                }
                else
                {
                    if (attr)
                    {
                        std::string equation, userDefined, filename;

                        while (attr)
                        {

                            attrName = attr->Name();

                            if (attrName == "VAR")
                            {
                                // if VAR do nothing
                            }
                            else if (attrName == "USERDEFINEDTYPE")
                            {

                                // Do stuff for the user defined attribute
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "USERDEFINEDTYPE attribute must have "
                                         "associated value.");

                                m_session->SubstituteExpressions(attrData);

                                userDefined = attrData;
                                isTimeDependent =
                                    boost::iequals(attrData, "TimeDependent");
                            }
                            else if (attrName == "VALUE")
                            {
                                ASSERTL0(attrName == "VALUE",
                                         (std::string("Unknown attribute: ") +
                                          attrName)
                                             .c_str());

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "VALUE attribute must have associated "
                                         "value.");

                                m_session->SubstituteExpressions(attrData);

                                equation = attrData;
                            }
                            else if (attrName == "FILE")
                            {
                                ASSERTL0(attrName == "FILE",
                                         (std::string("Unknown attribute: ") +
                                          attrName)
                                             .c_str());

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "FILE attribute must be specified.");

                                m_session->SubstituteExpressions(attrData);

                                filename = attrData;
                            }
                            else
                            {
                                ASSERTL0(false,
                                         (std::string("Unknown boundary "
                                                      "condition attribute: ") +
                                          attrName)
                                             .c_str());
                            }
                            attr = attr->Next();
                        }

                        BoundaryConditionShPtr dirichletCondition(
                            MemoryManager<DirichletBoundaryCondition>::
                            AllocateSharedPtr(m_session, equation,
                                              userDefined, filename,
                                              boundaryRegionComm));
                        dirichletCondition->SetIsTimeDependent(isTimeDependent);
                        (*boundaryConditions)[*iter] = dirichletCondition;
                    }
                    else
                    {
                        // This variable's condition is zero.
                        BoundaryConditionShPtr dirichletCondition(
                            MemoryManager<DirichletBoundaryCondition>::
                            AllocateSharedPtr(m_session, "0"));
                        (*boundaryConditions)[*iter] = dirichletCondition;
                    }
                }
            }
            else if (conditionType == "R") // Read du/dn +  PRIMCOEFF u = VALUE
            {
                if (attrData.empty())
                {
                    // All variables are Robin and are set to zero.
                    for (auto &varIter : vars)
                    {
                        BoundaryConditionShPtr robinCondition(
                            MemoryManager<RobinBoundaryCondition>::
                            AllocateSharedPtr(m_session, "0", "0"));
                        (*boundaryConditions)[varIter] = robinCondition;
                    }
                }
                else
                {

                    if (attr)
                    {
                        std::string equation1, equation2, userDefined;
                        std::string filename;

                        bool primcoeffset = false;

                        while (attr)
                        {

                            attrName = attr->Name();

                            if (attrName == "VAR")
                            {
                                // if VAR do nothing
                            }
                            else if (attrName == "USERDEFINEDTYPE")
                            {

                                // Do stuff for the user defined attribute
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "USERDEFINEDTYPE attribute must have "
                                         "associated value.");

                                m_session->SubstituteExpressions(attrData);
                                userDefined = attrData;
                                isTimeDependent =
                                    boost::iequals(attrData, "TimeDependent");
                            }
                            else if (attrName == "VALUE")
                            {

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "VALUE attributes must have "
                                         "associated values.");

                                m_session->SubstituteExpressions(attrData);

                                equation1 = attrData;
                            }
                            else if (attrName == "PRIMCOEFF")
                            {

                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "PRIMCOEFF attributes must have "
                                         "associated values.");

                                m_session->SubstituteExpressions(attrData);

                                equation2 = attrData;

                                primcoeffset = true;
                            }
                            else if (attrName == "FILE")
                            {
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "FILE attribute must be specified.");

                                m_session->SubstituteExpressions(attrData);

                                filename = attrData;
                            }
                            else
                            {
                                ASSERTL0(false,
                                         (std::string("Unknown boundary "
                                                      "condition attribute: ") +
                                          attrName)
                                             .c_str());
                            }
                            attr = attr->Next();
                        }

                        if (primcoeffset == false)
                        {
                            ASSERTL0(false, "PRIMCOEFF must be specified in a "
                                            "Robin boundary condition");
                        }
                        BoundaryConditionShPtr robinCondition(
                            MemoryManager<RobinBoundaryCondition>::
                            AllocateSharedPtr(
                                m_session, equation1, equation2,
                                userDefined, filename, boundaryRegionComm));
                        (*boundaryConditions)[*iter] = robinCondition;
                    }
                    else
                    {
                        // This variable's condition is zero.
                        BoundaryConditionShPtr robinCondition(
                            MemoryManager<RobinBoundaryCondition>::
                            AllocateSharedPtr(m_session, "0", "0"));
                        robinCondition->SetIsTimeDependent(isTimeDependent);
                        (*boundaryConditions)[*iter] = robinCondition;
                    }
                }
            }
            else if (conditionType == "P")
            {
                if (attrData.empty())
                {
                    ASSERTL0(false, "Periodic boundary conditions should "
                                    "be explicitely defined");
                }
                else
                {

                    if (attr)
                    {
                        std::string userDefined;
                        vector<unsigned int> periodicBndRegionIndex;
                        while (attr)
                        {
                            attrName = attr->Name();

                            if (attrName == "VAR")
                            {
                                // if VAR do nothing
                            }
                            else if (attrName == "USERDEFINEDTYPE")
                            {
                                // Do stuff for the user defined attribute
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "USERDEFINEDTYPE attribute must have "
                                         "associated value.");

                                m_session->SubstituteExpressions(attrData);
                                userDefined = attrData;
                                isTimeDependent =
                                    boost::iequals(attrData, "TimeDependent");
                            }
                            else if (attrName == "VALUE")
                            {
                                attrData = attr->Value();
                                ASSERTL0(!attrData.empty(),
                                         "VALUE attribute must have associated "
                                         "value.");

                                int beg = attrData.find_first_of("[");
                                int end = attrData.find_first_of("]");
                                std::string periodicBndRegionIndexStr =
                                    attrData.substr(beg + 1, end - beg - 1);
                                ASSERTL0(
                                    beg < end,
                                    (std::string("Error reading periodic "
                                                 "boundary region definition "
                                                 "for boundary region: ") +
                                     boundaryRegionIDStrm.str())
                                        .c_str());

                                bool parseGood = ParseUtils::GenerateSeqVector(
                                    periodicBndRegionIndexStr.c_str(),
                                    periodicBndRegionIndex);

                                ASSERTL0(
                                    parseGood &&
                                    (periodicBndRegionIndex.size() == 1),
                                    (std::string(
                                        "Unable to read periodic boundary "
                                        "condition for boundary region: ") +
                                     boundaryRegionIDStrm.str())
                                        .c_str());
                            }
                            attr = attr->Next();
                        }
                        BoundaryConditionShPtr periodicCondition(
                            MemoryManager<PeriodicBoundaryCondition>::
                            AllocateSharedPtr(periodicBndRegionIndex[0],
                                              userDefined,
                                              boundaryRegionComm));
                        (*boundaryConditions)[*iter] = periodicCondition;
                    }
                    else
                    {
                        ASSERTL0(false, "Periodic boundary conditions should "
                                        "be explicitely defined");
                    }
                }
            }
            else if (conditionType == "C")
            {
                ASSERTL0(false, "Cauchy type boundary conditions not "
                                "implemented.");
            }

            conditionElement = conditionElement->NextSiblingElement();
        }

        m_boundaryConditions[boundaryRegionID] = boundaryConditions;
        regionElement = regionElement->NextSiblingElement("REGION");
    }
}

ReadBoundaryRegions()

void Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryRegions ( TiXmlElement *  regions )

private

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

Definition at line 232 of file Conditions.cpp.

References ASSERTL0, m_boundaryRegions, and m_meshGraph.

Referenced by Read().

{
    // ensure boundary regions only read once per class definition
    if (m_boundaryRegions.size() != 0)
    {
        return;
    }

    TiXmlElement *boundaryRegions =
        conditions->FirstChildElement("BOUNDARYREGIONS");
    ASSERTL0(boundaryRegions, "Unable to find BOUNDARYREGIONS block.");

    // See if we have boundary regions defined.
    TiXmlElement *boundaryRegionsElement =
        boundaryRegions->FirstChildElement("B");

    while (boundaryRegionsElement)
    {
        /// All elements are of the form: "<B ID="#"> ... </B>", with
        /// ? being the element type.
        int indx;
        int err = boundaryRegionsElement->QueryIntAttribute("ID", &indx);
        ASSERTL0(err == TIXML_SUCCESS, "Unable to read attribute ID.");

        TiXmlNode *boundaryRegionChild = boundaryRegionsElement->FirstChild();
        // This is primarily to skip comments that may be present.
        // Comments appear as nodes just like elements.
        // We are specifically looking for text in the body
        // of the definition.
        while (boundaryRegionChild &&
               boundaryRegionChild->Type() != TiXmlNode::TINYXML_TEXT)
        {
            boundaryRegionChild = boundaryRegionChild->NextSibling();
        }

        ASSERTL0(boundaryRegionChild,
                 "Unable to read variable definition body.");
        std::string boundaryRegionStr =
            boundaryRegionChild->ToText()->ValueStr();

        std::string::size_type indxBeg =
            boundaryRegionStr.find_first_of('[') + 1;
        std::string::size_type indxEnd =
            boundaryRegionStr.find_last_of(']') - 1;

        ASSERTL0(indxBeg <= indxEnd,
                 (std::string("Error reading boundary region definition:") +
                  boundaryRegionStr)
                     .c_str());

        std::string indxStr =
            boundaryRegionStr.substr(indxBeg, indxEnd - indxBeg + 1);

        if (!indxStr.empty())
        {
            // Extract the composites from the string and return them in a list.
            BoundaryRegionShPtr boundaryRegion(
                MemoryManager<BoundaryRegion>::AllocateSharedPtr());

            ASSERTL0(m_boundaryRegions.count(indx) == 0,
                     "Boundary region " + indxStr +
                     " defined more than "
                     "once!");

            m_meshGraph->GetCompositeList(indxStr, *boundaryRegion);
            if (boundaryRegion->size() > 0)
            {
                m_boundaryRegions[indx] = boundaryRegion;
            }
        }

        boundaryRegionsElement =
            boundaryRegionsElement->NextSiblingElement("B");
    }
}

Member Data Documentation

m_boundaryCommunicators

std::map<int, LibUtilities::CommSharedPtr> Nektar::SpatialDomains::BoundaryConditions::m_boundaryCommunicators

protected

Definition at line 276 of file Conditions.h.

Referenced by CreateBoundaryComms(), and ReadBoundaryConditions().

m_boundaryConditions

BoundaryConditionCollection Nektar::SpatialDomains::BoundaryConditions::m_boundaryConditions

protected

Definition at line 275 of file Conditions.h.

Referenced by ReadBoundaryConditions().

m_boundaryRegions

BoundaryRegionCollection Nektar::SpatialDomains::BoundaryConditions::m_boundaryRegions

protected

Definition at line 274 of file Conditions.h.

Referenced by CreateBoundaryComms(), ReadBoundaryConditions(), and ReadBoundaryRegions().

m_meshGraph

MeshGraphSharedPtr Nektar::SpatialDomains::BoundaryConditions::m_meshGraph

protected

The mesh graph to use for referencing geometry info.

Definition at line 271 of file Conditions.h.

Referenced by ReadBoundaryRegions().

m_session

LibUtilities::SessionReaderSharedPtr Nektar::SpatialDomains::BoundaryConditions::m_session

protected

Definition at line 272 of file Conditions.h.

Referenced by BoundaryConditions(), CreateBoundaryComms(), and ReadBoundaryConditions().