rom_auxiliary_utilities.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//                   Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_ROM_AUXILIARY_UTILITIES_H)
#define KRATOS_ROM_AUXILIARY_UTILITIES_H
 
// System includes
#include <unordered_map>
 
// External includes
 
// Project includes
#include "geometries/geometry.h"
#include "includes/key_hash.h"
#include "includes/node.h"
#include "includes/model_part.h"
#include "includes/ublas_interface.h"
#include "modified_shape_functions/modified_shape_functions.h"
#include "processes/find_nodal_neighbours_process.h"
 
// Application includes
#include "rom_application_variables.h"
 
 
namespace Kratos
{
 
 
class KRATOS_API(ROM_APPLICATION) RomAuxiliaryUtilities
{
public:
 
    using SizeType = std::size_t;
 
    using IndexType = std::size_t;
 
    using NodeType = Node;
 
    using GeometryType = Geometry<NodeType>;
 
    using GeometryPointerType = Geometry<NodeType>::Pointer;
 
    using NodesPointerSetType = ModelPart::NodesContainerType;
 
    using ElementFacesMapType = std::unordered_map<
        std::vector<IndexType>,
        std::pair<bool, GeometryPointerType>,
        KeyHasherRange<std::vector<IndexType>>,
        KeyComparorRange<std::vector<IndexType>>>;
 
 
    static void SetHRomComputingModelPart(
        const Parameters HRomWeights,
        const ModelPart& rOriginModelPart,
        ModelPart& rHRomComputingModelPart);
 
    static void SetHRomComputingModelPartWithNeighbours(
        const Parameters HRomWeights,
        ModelPart& rOriginModelPart,
        ModelPart& rHRomComputingModelPart);
 
    static void SetHRomVolumetricVisualizationModelPart(
        const ModelPart& rOriginModelPart,
        ModelPart& rHRomVisualizationModelPart);
 
    static std::vector<IndexType> GetHRomConditionParentsIds(
        const ModelPart& rModelPart,
        const std::map<std::string, std::map<IndexType, double>>& rHRomWeights);
 
    static std::vector<IndexType> GetNodalNeighbouringElementIdsNotInHRom(
        ModelPart& rModelPart,
        ModelPart& rGivenModelPart,
        const std::map<std::string, std::map<IndexType, double>>& rHRomWeights);
 
    static std::vector<IndexType> GetNodalNeighbouringElementIds(
        ModelPart& rModelPart,
        ModelPart& rGivenModelPart);
 
    static std::vector<IndexType> GetConditionIdsNotInHRomModelPart(
        const ModelPart& rModelPartWithConditionsToInclude,
        std::map<std::string, std::map<IndexType, double>>& rHRomWeights);
 
    static std::vector<IndexType> GetElementIdsNotInHRomModelPart(
        const ModelPart& rModelPartWithElementsToInclude,
        std::map<std::string, std::map<IndexType, double>>& rHRomWeights);
 
    static std::vector<IndexType> GetHRomMinimumConditionsIds(
        const ModelPart& rModelPart,
        const std::map<IndexType, double>& rHRomConditionWeights);
 
 
    static std::vector<IndexType> GetElementIdsInModelPart(
        const ModelPart& rModelPart
    );
 
    static std::vector<IndexType> GetConditionIdsInModelPart(
        const ModelPart& rModelPart
    );
 
    static void ProjectRomSolutionIncrementToNodes(
        const std::vector<std::string> &rRomVariableNames,
        ModelPart &rModelPart);
 
    static void GetPhiElemental(
        Matrix &rPhiElemental,
        const Element::DofsVectorType& rDofs,
        const Element::GeometryType& rGeom,
        const std::unordered_map<Kratos::VariableData::KeyType, Matrix::size_type>& rVarToRowMapping);
 
 
    static void GetPsiElemental(
        Matrix &rPsiElemental,
        const Element::DofsVectorType& rDofs,
        const Element::GeometryType& rGeom,
        const std::unordered_map<Kratos::VariableData::KeyType, Matrix::size_type>& rVarToRowMapping);
 
    static void GetJPhiElemental(
        Matrix &rJPhiElemental,
        const Element::DofsVectorType& rDofs,
        const Matrix &rJPhi);
        
 
    private:
 
 
    static void RecursiveHRomModelPartCreation(
        const NodesPointerSetType& rNodesSet,
        const std::vector<Element::Pointer>& rElementsVector,
        const std::vector<Condition::Pointer>& rConditionsVector,
        const ModelPart& rOriginModelPart,
        ModelPart& rDestinationModelPart);
 
    static void RecursiveHRomMinimumConditionIds(
        const ModelPart& rModelPart,
        const std::map<IndexType, double>& rHRomConditionWeights,
        std::vector<IndexType>& rMinimumConditionsIds);
 
    static void RecursiveVisualizationSubModelPartCreation(
        const ModelPart& rOriginSubModelPart,
        ModelPart& rDestinationModelPart);
 
 
};
 
 
} // namespace Kratos
 
#endif // KRATOS_ROM_AUXILIARY_UTILITIES_H