#include <Movement.h>

Public Member Functions
	Movement ()=default
	Default constructor.

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

	~Movement ()=default
	Default destructor.

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

const InterfaceCollection &	GetInterfaces () const

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

void	PerformMovement (NekDouble timeStep)

const bool &	GetMoveFlag () const

bool &	GetCoordExchangeFlag ()

const bool &	GetMovedFlag () const

const bool &	GetTranslateFlag () const

const bool &	GetRotateFlag () const

const bool &	GetSectorRotateFlag () const

const bool &	GetImplicitALESolverFlag () const

const bool &	GetMeshDistortedFlag () const

void	SetImplicitALEFlag (bool &ImplicitALE)

void	SetMeshDistortedFlag (bool &meshDistorted)

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

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

Protected Attributes
InterfaceCollection	m_interfaces

std::map< int, ZoneBaseShPtr >	m_zones

bool	m_moveFlag = false

bool	m_translate = false

bool	m_rotate = false

bool	m_sectorRotate = false

bool	m_moved = false

bool	m_implicitALESolver = false

bool	m_meshDistorted = false

bool	m_coordExchangeFlag

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

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

void	UpdateTransZoneBox (const LibUtilities::SessionReaderSharedPtr &pSession)
	Update the box of translate zones.

Detailed Description

Definition at line 52 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 71 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);
        }
 
        if (m_translate)
        {
            UpdateTransZoneBox(pSession);
        }
    }
 
    // 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 m_interfaces, m_translate, m_zones, Nektar::SpatialDomains::MovementTypeStr, ReadInterfaces(), ReadZones(), Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceSum, Nektar::LibUtilities::ShapeTypeMap, and UpdateTransZoneBox().

◆ ~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 592 of file Movement/Movement.cpp.

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

References m_interfaces.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE(), Nektar::MovementTests::BOOST_AUTO_TEST_CASE(), and export_Movement().

◆ 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 581 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(), Nektar::MovementTests::BOOST_AUTO_TEST_CASE(), and export_Movement().

◆ GetCoordExchangeFlag()

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

inline

Definition at line 86 of file Movement.h.

    {
        return m_coordExchangeFlag;
    }

References m_coordExchangeFlag.

◆ GetImplicitALESolverFlag()

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

inline

Definition at line 111 of file Movement.h.

    {
        return m_implicitALESolver;
    }

References m_implicitALESolver.

◆ GetInterfaces()

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

inline

Definition at line 69 of file Movement.h.

    {
        return m_interfaces;
    }

References m_interfaces.

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

◆ GetMeshDistortedFlag()

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

inline

Definition at line 116 of file Movement.h.

    {
        return m_meshDistorted;
    }

References m_meshDistorted.

◆ GetMovedFlag()

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

inline

Definition at line 91 of file Movement.h.

    {
        return m_moved;
    }

References m_moved.

◆ GetMoveFlag()

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

inline

Definition at line 81 of file Movement.h.

    {
        return m_moveFlag;
    }

References m_moveFlag.

◆ GetRotateFlag()

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

inline

Definition at line 101 of file Movement.h.

    {
        return m_rotate;
    }

References m_rotate.

◆ GetSectorRotateFlag()

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

inline

Definition at line 106 of file Movement.h.

    {
        return m_sectorRotate;
    }

References m_sectorRotate.

◆ GetTranslateFlag()

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

inline

Definition at line 96 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 74 of file Movement.h.

    {
        return m_zones;
    }

References m_zones.

Referenced by Nektar::MovementTests::BOOST_AUTO_TEST_CASE(), Nektar::MovementTests::BOOST_AUTO_TEST_CASE(), and export_Movement().

◆ PerformMovement()

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

Definition at line 553 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.

Referenced by export_Movement().

◆ ReadInterfaces()

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

private

Read interfaces given TiXmlDocument.

Definition at line 368 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, 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 193 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);
 
            std::string rampTimeStr;
            err = zonesElement->QueryStringAttribute("RAMPTIME", &rampTimeStr);
            NekDouble rampTime = 0.0;
            if (err == TIXML_SUCCESS)
            {
                LibUtilities::Interpreter expEvaluator;
                int expr_id = expEvaluator.DefineFunction("", rampTimeStr);
                rampTime    = expEvaluator.Evaluate(expr_id);
            }
 
            std::string sectorStr;
            err = zonesElement->QueryStringAttribute("SECTOR", &sectorStr);
            NekDouble sector = 0.0;
            Array<OneD, NekDouble> base(3);
            if (err == TIXML_SUCCESS)
            {
 
                LibUtilities::Interpreter expEvaluator;
                int expr_id = expEvaluator.DefineFunction("", sectorStr);
                sector      = expEvaluator.Evaluate(expr_id);
 
                std::string baseStr;
                err = zonesElement->QueryStringAttribute("BASE", &baseStr);
                ASSERTL0(err == TIXML_SUCCESS, "Unable to read base.");
                std::vector<NekDouble> baseVec;
                ParseUtils::GenerateVector(baseStr, baseVec);
                // Ensure the vector has exactly 3 elements before assignment
                ASSERTL0(baseVec.size() == 3,
                         "BASE attribute must have exactly 3 elements.");
                for (int i = 0; i < 3; ++i)
                {
                    base[i] = baseVec[i];
                }
                m_sectorRotate = true;
            }
 
            zone = ZoneRotateShPtr(MemoryManager<ZoneRotate>::AllocateSharedPtr(
                indx, domFind, domain, coordDim, origin, axis, angularVelEqn,
                rampTime, sector, base));
 
            m_moveFlag = true;
            m_rotate   = 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::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::ParseUtils::GenerateVector(), Nektar::SpatialDomains::MeshGraph::GetDomain(), Nektar::SpatialDomains::MeshGraph::GetSpaceDimension(), m_moveFlag, m_rotate, m_sectorRotate, m_translate, m_zones, Nektar::NekVector< DataType >::Normalize(), Nektar::SpatialDomains::ReadTag(), and WARNINGL0.

Referenced by Movement().

◆ SetImplicitALEFlag()

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

inline

Definition at line 121 of file Movement.h.

    {
        m_implicitALESolver = ImplicitALE;
    }

References m_implicitALESolver.

◆ SetMeshDistortedFlag()

void Nektar::SpatialDomains::Movement::SetMeshDistortedFlag ( bool & meshDistorted )

inline

Definition at line 126 of file Movement.h.

    {
        m_moved = meshDistorted;
    }

References m_moved.

◆ UpdateTransZoneBox()

void Nektar::SpatialDomains::Movement::UpdateTransZoneBox ( const LibUtilities::SessionReaderSharedPtr & pSession )

private

Update the box of translate zones.

Generate domain box for translation mesh.

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

{
    // Loop over all translate zones to get the box of the whole zone
    for (auto &zones : m_zones)
    {
        if (zones.second->GetMovementType() == eTranslate)
        {
            auto zone = std::static_pointer_cast<ZoneTranslate>(zones.second);
            Array<OneD, NekDouble> ZoneBox(6);
            Array<OneD, NekDouble> ZoneLength(3);
            ZoneBox    = zone->GetZoneBox();
            ZoneLength = zone->GetZoneLength();
            auto comm  = pSession->GetComm();
            for (int i = 0; i < 3; ++i)
            {
                auto &min = ZoneBox[i];
                auto &max = ZoneBox[i + 3];
                comm->GetSpaceComm()->AllReduce(min, LibUtilities::ReduceMin);
                comm->GetSpaceComm()->AllReduce(max, LibUtilities::ReduceMax);
                ZoneLength[i] = max - min;
            }
            // Update the zone box for all translate zones
            zone->UpdateZoneBox(ZoneBox, ZoneLength);
        }
    }
}

References Nektar::SpatialDomains::eTranslate, m_zones, tinysimd::max(), tinysimd::min(), Nektar::LibUtilities::ReduceMax, and Nektar::LibUtilities::ReduceMin.

Referenced by Movement().

◆ 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 454 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(), m_interfaces, m_zones, Nektar::SpatialDomains::MovementTypeStr, and Nektar::SpatialDomains::StripParentheses().

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 150 of file Movement.h.

Referenced by GetCoordExchangeFlag().

◆ m_implicitALESolver

bool Nektar::SpatialDomains::Movement::m_implicitALESolver = false

protected

Definition at line 148 of file Movement.h.

Referenced by GetImplicitALESolverFlag(), and SetImplicitALEFlag().

◆ m_interfaces

InterfaceCollection Nektar::SpatialDomains::Movement::m_interfaces

protected

Definition at line 141 of file Movement.h.

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

◆ m_meshDistorted

bool Nektar::SpatialDomains::Movement::m_meshDistorted = false

protected

Definition at line 149 of file Movement.h.

Referenced by GetMeshDistortedFlag().

◆ m_moved

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

protected

Definition at line 147 of file Movement.h.

Referenced by GetMovedFlag(), PerformMovement(), and SetMeshDistortedFlag().

◆ m_moveFlag

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

protected

Definition at line 143 of file Movement.h.

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

◆ m_rotate

bool Nektar::SpatialDomains::Movement::m_rotate = false

protected

Definition at line 145 of file Movement.h.

Referenced by GetRotateFlag(), and ReadZones().

◆ m_sectorRotate

bool Nektar::SpatialDomains::Movement::m_sectorRotate = false

protected

Definition at line 146 of file Movement.h.

Referenced by GetSectorRotateFlag(), and ReadZones().

◆ m_translate

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

protected

Definition at line 144 of file Movement.h.

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

◆ m_zones

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

protected

Definition at line 142 of file Movement.h.

Referenced by AddZone(), GetZones(), Movement(), PerformMovement(), ReadZones(), UpdateTransZoneBox(), 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()

◆ GetCoordExchangeFlag()

◆ GetImplicitALESolverFlag()

◆ GetInterfaces()

◆ GetMeshDistortedFlag()

◆ GetMovedFlag()

◆ GetMoveFlag()

◆ GetRotateFlag()

◆ GetSectorRotateFlag()

◆ GetTranslateFlag()

◆ GetZones()

◆ PerformMovement()

◆ ReadInterfaces()

◆ ReadZones()

◆ SetImplicitALEFlag()

◆ SetMeshDistortedFlag()

◆ UpdateTransZoneBox()

◆ WriteMovement()

Member Data Documentation

◆ m_coordExchangeFlag

◆ m_implicitALESolver

◆ m_interfaces

◆ m_meshDistorted

◆ m_moved

◆ m_moveFlag

◆ m_rotate

◆ m_sectorRotate

◆ m_translate

◆ m_zones