#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

const std::map< int, std::string > &	GetBoundaryLabels (void) const

Protected Attributes
MeshGraphSharedPtr	m_meshGraph
	The mesh graph to use for referencing geometry info. More...

LibUtilities::SessionReaderSharedPtr	m_session

BoundaryRegionCollection	m_boundaryRegions

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

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 224 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.

     : m_meshGraph(meshGraph), m_session(pSession)
  
 {
     Read(m_session->GetElement("Nektar/Conditions"));
 }

References m_session, and Read().

◆ BoundaryConditions() [2/2]

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

Definition at line 59 of file Conditions.cpp.

60 {

61 }

◆ ~BoundaryConditions()

Nektar::SpatialDomains::BoundaryConditions::~BoundaryConditions ( void )

Definition at line 63 of file Conditions.cpp.

64 {

65 }

Member Function Documentation

◆ AddBoundaryConditions()

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

inline

Definition at line 249 of file Conditions.h.

     {
         m_boundaryConditions[regionID] = bCond;
     }

References m_boundaryConditions.

Referenced by Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs().

◆ AddBoundaryRegions()

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

inline

Definition at line 239 of file Conditions.h.

     {
         m_boundaryRegions[regionID] = bRegion;
     }

References m_boundaryRegions.

Referenced by Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs().

◆ 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.

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

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

Referenced by Read().

◆ GetBoundaryCommunicators()

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

inline

Definition at line 260 of file Conditions.h.

     {
         return m_boundaryCommunicators;
     }

References m_boundaryCommunicators.

Referenced by Nektar::FieldUtils::OutputFileBase::Process().

◆ GetBoundaryConditions()

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

inline

Definition at line 244 of file Conditions.h.

     {
         return m_boundaryConditions;
     }

References m_boundaryConditions.

Referenced by Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::MultiRegions::DisContField::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField::GetDomainBCs(), and Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions().

◆ GetBoundaryLabels()

const std::map<int, std::string>& Nektar::SpatialDomains::BoundaryConditions::GetBoundaryLabels ( void ) const

inline

Definition at line 265 of file Conditions.h.

     {
         return m_boundaryLabels;
     }

References m_boundaryLabels.

Referenced by Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrderMultiBlock().

◆ GetBoundaryRegions()

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

inline

Definition at line 234 of file Conditions.h.

     {
         return m_boundaryRegions;
     }

References m_boundaryRegions.

Referenced by Nektar::SolverUtils::ForcingAbsorption::CalcAbsorption(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::MultiRegions::DisContField::GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::DisContField::GetDomainBCs(), main(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrderMultiBlock(), Nektar::FieldUtils::OutputFileBase::Process(), Nektar::FieldUtils::ProcessBoundaryExtract::Process(), Nektar::FieldUtils::ProcessWallNormalData::Process(), Nektar::FieldUtils::ProcessWSS::Process(), Nektar::MultiRegions::DisContField3DHomogeneous1D::SetupBoundaryConditions(), Nektar::MultiRegions::DisContField3DHomogeneous2D::SetupBoundaryConditions(), Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), and Nektar::FilterMovingBody::v_Initialise().

◆ GetVariable()

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

inline

Definition at line 255 of file Conditions.h.

     {
         return m_session->GetVariable(indx);
     }

References m_session.

◆ 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.

 {
     ASSERTL0(conditions, "Unable to find CONDITIONS tag in file.");
  
     TiXmlElement *boundaryRegions =
         conditions->FirstChildElement("BOUNDARYREGIONS");
  
     if (boundaryRegions)
     {
         ReadBoundaryRegions(conditions);
         CreateBoundaryComms();
         ReadBoundaryConditions(conditions);
     }
 }

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

Referenced by BoundaryConditions().

◆ ReadBoundaryConditions()

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

private

Definition at line 320 of file Conditions.cpp.

 {
     // 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;
  
                                 if (!boost::iequals(attrData, "0") &&
                                     (boost::iequals(userDefined,
                                                     "WallAdiabatic") ||
                                      boost::iequals(userDefined,
                                                     "WallViscous")))
                                 {
                                     isTimeDependent = true;
                                 }
                             }
                             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");
     }
 }

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

Referenced by Read().

◆ 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.

 {
     // 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;
             }
  
             // Read optional name as string and save to m_boundaryLabels if
             // exists
             std::string name;
             err = boundaryRegionsElement->QueryStringAttribute("NAME", &name);
             if (err == TIXML_SUCCESS)
             {
                 m_boundaryLabels[indx] = name;
             }
         }
  
         boundaryRegionsElement =
             boundaryRegionsElement->NextSiblingElement("B");
     }
 }

References ASSERTL0, m_boundaryLabels, m_boundaryRegions, m_meshGraph, and CellMLToNektar.pycml::name.

Referenced by Read().

Member Data Documentation

◆ m_boundaryCommunicators

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

protected

Definition at line 278 of file Conditions.h.

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

◆ m_boundaryConditions

BoundaryConditionCollection Nektar::SpatialDomains::BoundaryConditions::m_boundaryConditions

protected

Definition at line 277 of file Conditions.h.

Referenced by AddBoundaryConditions(), GetBoundaryConditions(), and ReadBoundaryConditions().

◆ m_boundaryLabels

std::map<int, std::string> Nektar::SpatialDomains::BoundaryConditions::m_boundaryLabels

protected

Definition at line 276 of file Conditions.h.

Referenced by GetBoundaryLabels(), and ReadBoundaryRegions().

◆ m_boundaryRegions

BoundaryRegionCollection Nektar::SpatialDomains::BoundaryConditions::m_boundaryRegions

protected

Definition at line 275 of file Conditions.h.

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

◆ m_meshGraph

MeshGraphSharedPtr Nektar::SpatialDomains::BoundaryConditions::m_meshGraph

protected

The mesh graph to use for referencing geometry info.

Definition at line 272 of file Conditions.h.

Referenced by ReadBoundaryRegions().

◆ m_session

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

protected

Definition at line 273 of file Conditions.h.

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

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ BoundaryConditions() [1/2]

◆ BoundaryConditions() [2/2]

◆ ~BoundaryConditions()

Member Function Documentation

◆ AddBoundaryConditions()

◆ AddBoundaryRegions()

◆ CreateBoundaryComms()

◆ GetBoundaryCommunicators()

◆ GetBoundaryConditions()

◆ GetBoundaryLabels()

◆ GetBoundaryRegions()

◆ GetVariable()

◆ Read()

◆ ReadBoundaryConditions()

◆ ReadBoundaryRegions()

Member Data Documentation

◆ m_boundaryCommunicators

◆ m_boundaryConditions

◆ m_boundaryLabels

◆ m_boundaryRegions

◆ m_meshGraph

◆ m_session