#include <Movement.h>

Public Member Functions
	Movement ()=default
	Default constructor. More...

	Movement (const LibUtilities::SessionReaderSharedPtr &pSession, MeshGraph *meshGraph)
	Constructor to read from XML file. More...

	~Movement ()=default
	Default destructor. More...

void	WriteMovement (TiXmlElement *root)
	Write the MOVEMENT section of the XML file. More...

const InterfaceCollection &	GetInterfaces () const

const std::map< int, ZoneBaseShPtr > &	GetZones () const

void	PerformMovement (NekDouble timeStep)

const bool &	GetMoveFlag () const

bool &	GetCoordExchangeFlag ()

const Array< OneD, NekDouble > &	GetDomainBox () const

const Array< OneD, NekDouble > &	GetDomainLength () const

const bool &	GetMovedFlag () const

const bool &	GetTranslateFlag () const

const bool &	GetImplicitALESolverFlag () const

void	SetImplicitALEFlag (bool &ImplicitALE)

void	AddZone (ZoneBaseShPtr zone)
	Add a zone object to this Movement data. More...

void	AddInterface (std::string name, InterfaceShPtr left, InterfaceShPtr right)
	Add pair of interfaces to this data. More...

Protected Attributes
InterfaceCollection	m_interfaces

std::map< int, ZoneBaseShPtr >	m_zones

bool	m_moveFlag = false

bool	m_translate = false

bool	m_moved = false

bool	m_ImplicitALESolver = false

bool	m_coordExchangeFlag

Array< OneD, NekDouble >	m_DomainBox

Array< OneD, NekDouble >	m_DomainLength

Private Member Functions
void	ReadZones (TiXmlElement zonesTag, MeshGraph meshGraph, const LibUtilities::SessionReaderSharedPtr &pSession)
	Read zones given TiXmlDocument. More...

void	ReadInterfaces (TiXmlElement interfacesTag, MeshGraph meshGraph)
	Read interfaces given TiXmlDocument. More...

void	DomainBox ()
	Calculate length of the domain. More...

Detailed Description

Definition at line 51 of file Movement.h.

Constructor & Destructor Documentation

◆ Movement() [1/2]

Nektar::SpatialDomains::Movement::Movement ( )

default

Default constructor.

◆ Movement() [2/2]

Nektar::SpatialDomains::Movement::Movement	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		MeshGraph *	meshGraph
	)

Constructor to read from XML file.

Definition at line 70 of file Movement/Movement.cpp.

{
    TiXmlNode *nektar = pSession->GetElement("NEKTAR");
    if (nektar == nullptr)
    {
        return;
    }
 
    TiXmlNode *movement = nektar->FirstChild("MOVEMENT");
    if (movement != nullptr)
    {
        bool zones = movement->FirstChild("ZONES") != nullptr;
        if (zones)
        {
            TiXmlElement *zonesTag =
                pSession->GetElement("NEKTAR/MOVEMENT/ZONES");
            ReadZones(zonesTag, meshGraph, pSession);
        }
 
        bool interfaces = movement->FirstChild("INTERFACES") != nullptr;
        if (interfaces)
        {
            TiXmlElement *interfacesTag =
                pSession->GetElement("NEKTAR/MOVEMENT/INTERFACES");
            ReadInterfaces(interfacesTag, meshGraph);
        }
 
        ASSERTL0(zones == interfaces,
                 "Only one of ZONES or INTERFACES present in the MOVEMENT "
                 "block.")
        // Generate domain box
        DomainBox();
        // Get DomainBox from all processes
        if (m_translate)
        {
            auto comm = pSession->GetComm();
            for (int i = 0; i < 3; ++i)
            {
                auto &min = m_DomainBox[i];
                auto &max = m_DomainBox[i + 3];
                comm->GetSpaceComm()->AllReduce(min, LibUtilities::ReduceMin);
                comm->GetSpaceComm()->AllReduce(max, LibUtilities::ReduceMax);
                m_DomainLength[i] = max - min;
            }
        }
    }
 
    // DEBUG COMMENTS
    if (movement != nullptr && pSession->DefinesCmdLineArgument("verbose"))
    {
        auto comm = pSession->GetComm();
        if (comm->TreatAsRankZero())
        {
            std::cout << "Movement Info:\n";
            std::cout << "\tNum zones: " << m_zones.size() << "\n";
        }
 
        for (auto &zone : m_zones)
        {
            auto numEl = zone.second->GetElements().size();
            comm->GetSpaceComm()->AllReduce(numEl, LibUtilities::ReduceSum);
 
            // Find shape type if not on this proc
            int shapeType =
                !zone.second->GetElements().empty()
                    ? zone.second->GetElements().front()->GetShapeType()
                    : -1;
            comm->GetSpaceComm()->AllReduce(shapeType, LibUtilities::ReduceMax);
 
            if (comm->TreatAsRankZero())
            {
                std::cout << "\t- " << zone.first << " "
                          << MovementTypeStr[static_cast<int>(
                                 zone.second->GetMovementType())]
                          << ": " << numEl << " "
                          << LibUtilities::ShapeTypeMap[shapeType] << "s\n";
            }
        }
 
        if (comm->TreatAsRankZero())
        {
            std::cout << "\tNum interfaces: " << m_interfaces.size() << "\n";
        }
 
        for (auto &interface : m_interfaces)
        {
            auto numLeft =
                interface.second->GetLeftInterface()->GetEdge().size();
            auto numRight =
                interface.second->GetRightInterface()->GetEdge().size();
            comm->GetSpaceComm()->AllReduce(numLeft, LibUtilities::ReduceSum);
            comm->GetSpaceComm()->AllReduce(numRight, LibUtilities::ReduceSum);
 
            // Find shape type if not on this proc
            int shapeTypeLeft =
                !interface.second->GetLeftInterface()->GetEdge().empty()
                    ? interface.second->GetLeftInterface()
                          ->GetEdge()
                          .begin()
                          ->second->GetShapeType()
                    : -1;
            comm->GetSpaceComm()->AllReduce(shapeTypeLeft,
                                            LibUtilities::ReduceMax);
            int shapeTypeRight =
                !interface.second->GetRightInterface()->GetEdge().empty()
                    ? interface.second->GetRightInterface()
                          ->GetEdge()
                          .begin()
                          ->second->GetShapeType()
                    : -1;
            comm->GetSpaceComm()->AllReduce(shapeTypeRight,
                                            LibUtilities::ReduceMax);
 
            if (comm->TreatAsRankZero())
            {
                std::cout << "\t- \"" << interface.first.second << "\": "
                          << interface.second->GetLeftInterface()->GetId()
                          << " (" << numLeft << " "
                          << LibUtilities::ShapeTypeMap[shapeTypeLeft]
                          << "s) <-> "
                          << interface.second->GetRightInterface()->GetId()
                          << " (" << numRight << " "
                          << LibUtilities::ShapeTypeMap[shapeTypeRight]
                          << "s)\n";
            }
        }
 
        comm->GetSpaceComm()->Block();
        if (comm->TreatAsRankZero())
        {
            std::cout << std::endl;
        }
    }
}

References ASSERTL0, DomainBox(), m_DomainBox, m_DomainLength, m_interfaces, m_translate, m_zones, Nektar::SpatialDomains::MovementTypeStr, ReadInterfaces(), ReadZones(), Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceMin, Nektar::LibUtilities::ReduceSum, and Nektar::LibUtilities::ShapeTypeMap.

◆ ~Movement()

Nektar::SpatialDomains::Movement::~Movement ( )

default

Default destructor.

Member Function Documentation

◆ AddInterface()

void Nektar::SpatialDomains::Movement::AddInterface	(	std::string	name,
		InterfaceShPtr	left,
		InterfaceShPtr	right
	)

Add pair of interfaces to this data.

Store an interface pair with this Movement data.

Definition at line 567 of file Movement/Movement.cpp.

{
    m_interfaces[std::make_pair(m_interfaces.size(), name)] =
        InterfacePairShPtr(
            MemoryManager<InterfacePair>::AllocateSharedPtr(left, right));
}

References m_interfaces, and CellMLToNektar.pycml::name.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE().

◆ AddZone()

void Nektar::SpatialDomains::Movement::AddZone ( ZoneBaseShPtr zone )

Add a zone object to this Movement data.

Store a zone object with this Movement data.

Definition at line 556 of file Movement/Movement.cpp.

{
    m_zones[zone->GetId()] = zone;
    MovementType mtype     = zone->GetMovementType();
    if (mtype != MovementType::eFixed && mtype != MovementType::eNone)
    {
        m_moveFlag = true;
    }
}

References Nektar::SpatialDomains::eFixed, Nektar::SpatialDomains::eNone, m_moveFlag, and m_zones.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE().

◆ DomainBox()

void Nektar::SpatialDomains::Movement::DomainBox ( )

private

Calculate length of the domain.

Generate domain box for translation mesh.

Definition at line 576 of file Movement/Movement.cpp.

{
    if (m_translate)
    {
        // NekDouble minx, miny, minz, maxx, maxy, maxz;
        Array<OneD, NekDouble> min(3, 0.0), max(3, 0.0);
        Array<OneD, NekDouble> x(3, 0.0);
 
        // Find a point in the domian for parallel
        for (auto &zones : m_zones)
        {
            int NumVerts = zones.second->GetOriginalVertex().size();
            if (NumVerts != 0)
            {
                PointGeom p = zones.second->GetOriginalVertex()[0];
                p.GetCoords(x[0], x[1], x[2]);
                for (int j = 0; j < 3; ++j)
                {
                    min[j] = x[j];
                    max[j] = x[j];
                }
                break;
            }
        }
 
        // loop over all zones and original vertexes
        for (auto &zones : m_zones)
        {
            int NumVerts = zones.second->GetOriginalVertex().size();
            for (int i = 0; i < NumVerts; ++i)
            {
                PointGeom p = zones.second->GetOriginalVertex()[i];
                p.GetCoords(x[0], x[1], x[2]);
                for (int j = 0; j < 3; ++j)
                {
                    min[j] = (x[j] < min[j] ? x[j] : min[j]);
                    max[j] = (x[j] > max[j] ? x[j] : max[j]);
                }
            }
        }
        // save bounding length
        m_DomainLength = Array<OneD, NekDouble>(3, 0.0);
        // save bounding box
        m_DomainBox = Array<OneD, NekDouble>(6, 0.0);
        for (int j = 0; j < 3; ++j)
        {
            m_DomainBox[j]     = min[j];
            m_DomainBox[j + 3] = max[j];
        }
    }
}

References m_DomainBox, m_DomainLength, m_translate, m_zones, and CellMLToNektar.cellml_metadata::p.

Referenced by Movement().

◆ GetCoordExchangeFlag()

bool & Nektar::SpatialDomains::Movement::GetCoordExchangeFlag ( )

inline

Definition at line 85 of file Movement.h.

    {
        return m_coordExchangeFlag;
    }

References m_coordExchangeFlag.

◆ GetDomainBox()

const Array< OneD, NekDouble > & Nektar::SpatialDomains::Movement::GetDomainBox ( ) const

inline

Definition at line 90 of file Movement.h.

    {
        return m_DomainBox;
    }

References m_DomainBox.

◆ GetDomainLength()

const Array< OneD, NekDouble > & Nektar::SpatialDomains::Movement::GetDomainLength ( ) const

inline

Definition at line 95 of file Movement.h.

    {
        return m_DomainLength;
    }

References m_DomainLength.

◆ GetImplicitALESolverFlag()

const bool & Nektar::SpatialDomains::Movement::GetImplicitALESolverFlag ( ) const

inline

Definition at line 110 of file Movement.h.

    {
        return m_ImplicitALESolver;
    }

References m_ImplicitALESolver.

◆ GetInterfaces()

const InterfaceCollection & Nektar::SpatialDomains::Movement::GetInterfaces ( ) const

inline

Definition at line 68 of file Movement.h.

    {
        return m_interfaces;
    }

References m_interfaces.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE().

◆ GetMovedFlag()

const bool & Nektar::SpatialDomains::Movement::GetMovedFlag ( ) const

inline

Definition at line 100 of file Movement.h.

    {
        return m_moved;
    }

References m_moved.

◆ GetMoveFlag()

const bool & Nektar::SpatialDomains::Movement::GetMoveFlag ( ) const

inline

Definition at line 80 of file Movement.h.

    {
        return m_moveFlag;
    }

References m_moveFlag.

◆ GetTranslateFlag()

const bool & Nektar::SpatialDomains::Movement::GetTranslateFlag ( ) const

inline

Definition at line 105 of file Movement.h.

    {
        return m_translate;
    }

References m_translate.

◆ GetZones()

const std::map< int, ZoneBaseShPtr > & Nektar::SpatialDomains::Movement::GetZones ( ) const

inline

Definition at line 73 of file Movement.h.

    {
        return m_zones;
    }

References m_zones.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE().

◆ PerformMovement()

void Nektar::SpatialDomains::Movement::PerformMovement ( NekDouble timeStep )

Definition at line 528 of file Movement/Movement.cpp.

{
    std::set<int> movedZoneIds;
    for (auto &zone : m_zones)
    {
        if (zone.second->Move(timeStep))
        {
            movedZoneIds.insert(zone.first);
        }
    }
 
    // If zone has moved, set all interfaces on that zone to moved.
    for (auto &interPair : m_interfaces)
    {
        int leftId  = interPair.second->GetLeftInterface()->GetId();
        int rightId = interPair.second->GetRightInterface()->GetId();
 
        if (movedZoneIds.find(leftId) != movedZoneIds.end() ||
            movedZoneIds.find(rightId) != movedZoneIds.end())
        {
            m_zones[leftId]->GetMoved()  = true;
            m_zones[rightId]->GetMoved() = true;
        }
    }
    m_moved = true;
}

References m_interfaces, m_moved, and m_zones.

◆ ReadInterfaces()

void Nektar::SpatialDomains::Movement::ReadInterfaces	(	TiXmlElement *	interfacesTag,
		MeshGraph *	meshGraph
	)

private

Read interfaces given TiXmlDocument.

Definition at line 343 of file Movement/Movement.cpp.

{
    ASSERTL0(interfacesTag, "Unable to find INTERFACES tag in file.");
    TiXmlElement *interfaceElement = interfacesTag->FirstChildElement();
 
    while (interfaceElement)
    {
        ASSERTL0(
            "INTERFACE" == (std::string)interfaceElement->Value(),
            "Only INTERFACE tags may be present inside the INTERFACES block.")
 
        int err;
 
        std::string name;
        err = interfaceElement->QueryStringAttribute("NAME", &name);
        ASSERTL0(err == TIXML_SUCCESS, "Unable to read interface name.");
        TiXmlElement *sideElement = interfaceElement->FirstChildElement();
 
        Array<OneD, InterfaceShPtr> interfaces(2);
        std::vector<int> cnt;
        while (sideElement)
        {
            ASSERTL0(
                cnt.size() < 2,
                "In INTERFACE NAME " + name +
                    ", only two sides may be present in each INTERFACE block.")
 
            // Read ID
            int indx;
            err = sideElement->QueryIntAttribute("ID", &indx);
            ASSERTL0(err == TIXML_SUCCESS, "Unable to read interface ID.");
 
            // Read boundary
            std::string boundaryStr;
            err = sideElement->QueryStringAttribute("BOUNDARY", &boundaryStr);
            ASSERTL0(err == TIXML_SUCCESS,
                     "Unable to read BOUNDARY in interface " +
                         std::to_string(indx));
 
            CompositeMap boundaryEdge;
            std::string indxStr = ReadTag(boundaryStr);
            meshGraph->GetCompositeList(indxStr, boundaryEdge);
 
            // Read SKIPCHECK flag
            bool skipCheck = false;
            err = sideElement->QueryBoolAttribute("SKIPCHECK", &skipCheck);
 
            // Sets location in interface pair to 0 for left, and 1 for right
            auto sideElVal = sideElement->ValueStr();
            if (sideElVal == "LEFT" || sideElVal == "L")
            {
                cnt.emplace_back(0);
            }
            else if (sideElVal == "RIGHT" || sideElVal == "R")
            {
                cnt.emplace_back(1);
            }
            else
            {
                NEKERROR(ErrorUtil::efatal,
                         sideElement->ValueStr() +
                             " is not a valid interface side for interface "
                             "NAME " +
                             name + ". Please only use LEFT or RIGHT.")
            }
 
            interfaces[cnt[cnt.size() - 1]] =
                InterfaceShPtr(MemoryManager<Interface>::AllocateSharedPtr(
                    indx, boundaryEdge, skipCheck));
 
            sideElement = sideElement->NextSiblingElement();
        }
 
        ASSERTL0(std::accumulate(cnt.begin(), cnt.end(), 0) == 1,
                 "You must have only one LEFT and one RIGHT side"
                 " present in interface NAME " +
                     name)
 
        m_interfaces[std::make_pair(m_interfaces.size(), name)] =
            InterfacePairShPtr(MemoryManager<InterfacePair>::AllocateSharedPtr(
                interfaces[0], interfaces[1]));
        interfaceElement = interfaceElement->NextSiblingElement();
    }
}

References ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::SpatialDomains::MeshGraph::GetCompositeList(), m_interfaces, CellMLToNektar.pycml::name, NEKERROR, and Nektar::SpatialDomains::ReadTag().

Referenced by Movement().

◆ ReadZones()

void Nektar::SpatialDomains::Movement::ReadZones	(	TiXmlElement *	zonesTag,
		MeshGraph *	meshGraph,
		const LibUtilities::SessionReaderSharedPtr &	pSession
	)

private

Read zones given TiXmlDocument.

Definition at line 206 of file Movement/Movement.cpp.

{
    int coordDim = meshGraph->GetSpaceDimension();
 
    ASSERTL0(zonesTag, "Unable to find ZONES tag in file.");
    TiXmlElement *zonesElement = zonesTag->FirstChildElement();
    while (zonesElement)
    {
        std::string zoneType = zonesElement->Value();
 
        int err;
        int indx;
 
        err = zonesElement->QueryIntAttribute("ID", &indx);
        ASSERTL0(err == TIXML_SUCCESS, "Unable to read zone ID.");
 
        std::string interfaceDomainStr;
        err = zonesElement->QueryStringAttribute("DOMAIN", &interfaceDomainStr);
        ASSERTL0(err == TIXML_SUCCESS, "Unable to read zone domain.");
 
        auto &domains = meshGraph->GetDomain();
        auto domFind  = std::stoi(ReadTag(interfaceDomainStr));
        std::map<int, CompositeSharedPtr> domain;
        if (domains.find(domFind) != domains.end())
        {
            domain = domains.at(domFind);
        }
 
        ZoneBaseShPtr zone;
        if (zoneType == "F" || zoneType == "FIXED")
        {
            zone = ZoneFixedShPtr(MemoryManager<ZoneFixed>::AllocateSharedPtr(
                indx, domFind, domain, coordDim));
        }
        else if (zoneType == "R" || zoneType == "ROTATE" ||
                 zoneType == "ROTATING")
        {
            std::string originStr;
            err = zonesElement->QueryStringAttribute("ORIGIN", &originStr);
            ASSERTL0(err == TIXML_SUCCESS, "Unable to read origin.");
            std::vector<NekDouble> originVec;
            ParseUtils::GenerateVector(originStr, originVec);
            NekPoint<NekDouble> origin =
                NekPoint<NekDouble>(originVec[0], originVec[1], originVec[2]);
 
            std::string axisStr;
            err = zonesElement->QueryStringAttribute("AXIS", &axisStr);
            ASSERTL0(err == TIXML_SUCCESS, "Unable to read axis.");
            DNekVec axis(axisStr);
            axis.Normalize();
 
            std::string angularVelStr;
            err = zonesElement->QueryStringAttribute("ANGVEL", &angularVelStr);
            ASSERTL0(err == TIXML_SUCCESS, "Unable to read angular velocity.");
 
            LibUtilities::EquationSharedPtr angularVelEqn =
                MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                    pSession->GetInterpreter(), angularVelStr);
 
            zone = ZoneRotateShPtr(MemoryManager<ZoneRotate>::AllocateSharedPtr(
                indx, domFind, domain, coordDim, origin, axis, angularVelEqn));
 
            m_moveFlag = true;
        }
        else if (zoneType == "T" || zoneType == "TRANSLATE" ||
                 zoneType == "TRANSLATING")
        {
            // Read velocity information
            std::string velocityStr;
            err = zonesElement->QueryStringAttribute("VELOCITY", &velocityStr);
            ASSERTL0(err == TIXML_SUCCESS,
                     "Unable to read VELOCITY for translating zone " +
                         std::to_string(indx));
 
            std::vector<std::string> velocityStrSplit;
            ParseUtils::GenerateVector(velocityStr, velocityStrSplit);
 
            ASSERTL0(velocityStrSplit.size() >= coordDim,
                     "VELOCITY dimensions must be greater than or equal to the "
                     "coordinate dimension for translating zone " +
                         std::to_string(indx));
 
            Array<OneD, LibUtilities::EquationSharedPtr> velocityEqns(coordDim);
            for (int i = 0; i < coordDim; ++i)
            {
                velocityEqns[i] =
                    MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                        pSession->GetInterpreter(), velocityStrSplit[i]);
            }
 
            // Read displacement information
            std::string displacementStr;
            err = zonesElement->QueryStringAttribute("DISPLACEMENT",
                                                     &displacementStr);
            ASSERTL0(err == TIXML_SUCCESS,
                     "Unable to read DISPLACEMENT for translating zone " +
                         std::to_string(indx));
 
            std::vector<std::string> displacementStrSplit;
            ParseUtils::GenerateVector(displacementStr, displacementStrSplit);
 
            ASSERTL0(
                displacementStrSplit.size() >= coordDim,
                "DISPLACEMENT dimensions must be greater than or equal to the "
                "coordinate dimension for translating zone " +
                    std::to_string(indx));
 
            Array<OneD, LibUtilities::EquationSharedPtr> displacementEqns(
                coordDim);
            for (int i = 0; i < coordDim; ++i)
            {
                displacementEqns[i] =
                    MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                        pSession->GetInterpreter(), displacementStrSplit[i]);
            }
 
            zone = ZoneTranslateShPtr(
                MemoryManager<ZoneTranslate>::AllocateSharedPtr(
                    indx, domFind, domain, coordDim, velocityEqns,
                    displacementEqns));
 
            m_moveFlag  = true;
            m_translate = true;
        }
        else
        {
            WARNINGL0(false, "Zone type '" + zoneType +
                                 "' is unsupported. Valid types are: 'Fixed', "
                                 "'Rotate', or 'Translate'.")
        }
 
        m_zones[indx] = zone;
        zonesElement  = zonesElement->NextSiblingElement();
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::MovementTests::axis, Nektar::MovementTests::displacementStr, Nektar::ParseUtils::GenerateVector(), Nektar::SpatialDomains::MeshGraph::GetDomain(), Nektar::SpatialDomains::MeshGraph::GetSpaceDimension(), m_moveFlag, m_translate, m_zones, Nektar::NekVector< DataType >::Normalize(), Nektar::MovementTests::origin, Nektar::SpatialDomains::ReadTag(), Nektar::MovementTests::velocityStr, and WARNINGL0.

Referenced by Movement().

◆ SetImplicitALEFlag()

void Nektar::SpatialDomains::Movement::SetImplicitALEFlag ( bool & ImplicitALE )

inline

Definition at line 115 of file Movement.h.

    {
        m_ImplicitALESolver = ImplicitALE;
    }

References m_ImplicitALESolver.

◆ WriteMovement()

void Nektar::SpatialDomains::Movement::WriteMovement ( TiXmlElement * root )

Write the MOVEMENT section of the XML file.

Export this Movement information to a Nektar++ XML file.

Definition at line 429 of file Movement/Movement.cpp.

{
    if (m_zones.size() == 0 && m_interfaces.size() == 0)
    {
        return;
    }
    TiXmlElement *movement = new TiXmlElement("MOVEMENT");
    root->LinkEndChild(movement);
 
    TiXmlElement *zones = new TiXmlElement("ZONES");
    for (auto &i : m_zones)
    {
        const ZoneBaseShPtr z    = i.second;
        const MovementType mtype = z->GetMovementType();
        std::string label        = MovementTypeStr[static_cast<int>(mtype)];
        TiXmlElement *e          = new TiXmlElement(label.substr(0, 1));
        e->SetAttribute("ID", i.first);
        std::stringstream s;
        s << "D[" << z->GetDomainID() << "]";
        e->SetAttribute("DOMAIN", s.str());
 
        switch (mtype)
        {
            case MovementType::eRotate:
            {
                auto rotate = std::static_pointer_cast<ZoneRotate>(z);
                e->SetAttribute(
                    "ORIGIN", StripParentheses(rotate->GetOrigin().AsString()));
                e->SetAttribute("AXIS",
                                StripParentheses(rotate->GetAxis().AsString()));
                e->SetAttribute("ANGVEL",
                                rotate->GetAngularVelEqn()->GetExpression());
            }
            break;
            case MovementType::eTranslate:
            {
                auto translate = std::static_pointer_cast<ZoneTranslate>(z);
                e->SetAttribute(
                    "XVELOCITY",
                    translate->GetVelocityEquation()[0]->GetExpression());
                e->SetAttribute(
                    "XDISPLACEMENT",
                    translate->GetDisplacementEquation()[0]->GetExpression());
                e->SetAttribute(
                    "YVELOCITY",
                    translate->GetVelocityEquation()[1]->GetExpression());
                e->SetAttribute(
                    "YDISPLACEMENT",
                    translate->GetDisplacementEquation()[1]->GetExpression());
                e->SetAttribute(
                    "ZVELOCITY",
                    translate->GetVelocityEquation()[2]->GetExpression());
                e->SetAttribute(
                    "ZDISPLACEMENT",
                    translate->GetDisplacementEquation()[2]->GetExpression());
            }
            break;
            default:
                break;
        }
        zones->LinkEndChild(e);
    }
    movement->LinkEndChild(zones);
 
    TiXmlElement *interfaces = new TiXmlElement("INTERFACES");
    for (auto &i : m_interfaces)
    {
        const std::string interfaceName = i.first.second;
        TiXmlElement *e                 = new TiXmlElement("INTERFACE");
        e->SetAttribute("NAME", interfaceName);
        const InterfaceShPtr left  = i.second->GetLeftInterface();
        const InterfaceShPtr right = i.second->GetRightInterface();
        if (left)
        {
            TiXmlElement *left_e = new TiXmlElement("L");
            left_e->SetAttribute("ID", left->GetId());
            left_e->SetAttribute(
                "BOUNDARY",
                "C[" + ParseUtils::GenerateSeqString(left->GetCompositeIDs()) +
                    "]");
            e->LinkEndChild(left_e);
        }
        if (right)
        {
            TiXmlElement *right_e = new TiXmlElement("R");
            right_e->SetAttribute("ID", right->GetId());
            right_e->SetAttribute(
                "BOUNDARY",
                "C[" + ParseUtils::GenerateSeqString(right->GetCompositeIDs()) +
                    "]");
            e->LinkEndChild(right_e);
        }
        interfaces->LinkEndChild(e);
    }
    movement->LinkEndChild(interfaces);
}

References Nektar::SpatialDomains::eRotate, Nektar::SpatialDomains::eTranslate, Nektar::ParseUtils::GenerateSeqString(), CG_Iterations::label, m_interfaces, m_zones, Nektar::SpatialDomains::MovementTypeStr, Nektar::SpatialDomains::StripParentheses(), and Nektar::UnitTests::z().

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE().

Member Data Documentation

◆ m_coordExchangeFlag

bool Nektar::SpatialDomains::Movement::m_coordExchangeFlag

protected

Initial value:

=

true

Definition at line 136 of file Movement.h.

Referenced by GetCoordExchangeFlag().

◆ m_DomainBox

Array<OneD, NekDouble> Nektar::SpatialDomains::Movement::m_DomainBox

protected

Definition at line 138 of file Movement.h.

Referenced by DomainBox(), GetDomainBox(), and Movement().

◆ m_DomainLength

Array<OneD, NekDouble> Nektar::SpatialDomains::Movement::m_DomainLength

protected

Definition at line 139 of file Movement.h.

Referenced by DomainBox(), GetDomainLength(), and Movement().

◆ m_ImplicitALESolver

bool Nektar::SpatialDomains::Movement::m_ImplicitALESolver = false

protected

Definition at line 135 of file Movement.h.

Referenced by GetImplicitALESolverFlag(), and SetImplicitALEFlag().

◆ m_interfaces

InterfaceCollection Nektar::SpatialDomains::Movement::m_interfaces

protected

Definition at line 130 of file Movement.h.

Referenced by AddInterface(), GetInterfaces(), Movement(), PerformMovement(), ReadInterfaces(), and WriteMovement().

◆ m_moved

bool Nektar::SpatialDomains::Movement::m_moved = false

protected

Definition at line 134 of file Movement.h.

Referenced by GetMovedFlag(), and PerformMovement().

◆ m_moveFlag

bool Nektar::SpatialDomains::Movement::m_moveFlag = false

protected

Definition at line 132 of file Movement.h.

Referenced by AddZone(), GetMoveFlag(), and ReadZones().

◆ m_translate

bool Nektar::SpatialDomains::Movement::m_translate = false

protected

Definition at line 133 of file Movement.h.

Referenced by DomainBox(), GetTranslateFlag(), Movement(), and ReadZones().

◆ m_zones

std::map<int, ZoneBaseShPtr> Nektar::SpatialDomains::Movement::m_zones

protected

Definition at line 131 of file Movement.h.

Referenced by AddZone(), DomainBox(), GetZones(), Movement(), PerformMovement(), ReadZones(), and WriteMovement().

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Movement() [1/2]

◆ Movement() [2/2]

◆ ~Movement()

Member Function Documentation

◆ AddInterface()

◆ AddZone()

◆ DomainBox()

◆ GetCoordExchangeFlag()

◆ GetDomainBox()

◆ GetDomainLength()

◆ GetImplicitALESolverFlag()

◆ GetInterfaces()

◆ GetMovedFlag()

◆ GetMoveFlag()

◆ GetTranslateFlag()

◆ GetZones()

◆ PerformMovement()

◆ ReadInterfaces()

◆ ReadZones()

◆ SetImplicitALEFlag()

◆ WriteMovement()

Member Data Documentation

◆ m_coordExchangeFlag

◆ m_DomainBox

◆ m_DomainLength

◆ m_ImplicitALESolver

◆ m_interfaces

◆ m_moved

◆ m_moveFlag

◆ m_translate

◆ m_zones