[Core] Geometries to entities modeler

kratos/modeler/create_entities_from_geometries_modeler.cpp

@@ -0,0 +1,168 @@
+//    |  /           |
+//    ' /   __| _` | __|  _ \   __|
+//    . \  |   (   | |   (   |\__ `
+//   _|\_\_|  \__,_|\__|\___/ ____/
+//                   Multi-Physics
+//
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
+//
+//  Main authors:    Ruben Zorrilla
+//
+
+// System includes
+
+// External includes
+
+// Project includes
+#include "includes/parallel_environment.h"
+#include "utilities/entities_utilities.h"
+#include "utilities/variable_utils.h"
+#include "create_entities_from_geometries_modeler.h"
+
+namespace Kratos
+{
+
+namespace {
+
+/**
+ * @brief Create entities from geometries.
+ * @param EntityName the name of the entity
+ * @param rModelPart the model part
+ */
+template <class TEntitiesContainerType, class TEntityIdentifier>
+void CreateEntitiesFromGeometries(
+    const TEntityIdentifier& rEntityIdentifier,
+    ModelPart& rModelPart
+    )
+{
+    // Create the entities container and allocate space
+    TEntitiesContainerType entities_to_add;
+    entities_to_add.reserve(rModelPart.NumberOfGeometries());
+
+    // Get current max element id
+    using SizeType = std::size_t;
+    SizeType max_id;
+    const auto& r_root_model_part = rModelPart.GetRootModelPart();
+    if constexpr (std::is_same<typename TEntitiesContainerType::value_type, Element>::value) {
+        max_id = block_for_each<MaxReduction<SizeType>>(r_root_model_part.Elements(), [](auto& rElement){
+            return rElement.Id();
+        });
+    } else if constexpr (std::is_same<typename TEntitiesContainerType::value_type, Condition>::value) {
+        max_id = block_for_each<MaxReduction<SizeType>>(r_root_model_part.Conditions(), [](auto& rCondition){
+            return rCondition.Id();
+        });
+    }
+
+    // Loop geometries to create the corresponding entities from them
+    // Note that we retrieve the corresponding prototype entity from the entities idenfifier
+    // This makes possible to loop and create entities from different type geometries
+    for (auto& r_geom : rModelPart.Geometries()) {
+        if (rEntityIdentifier.HasPrototypeEntity(r_geom)) {
+            const auto& r_ref_entity = rEntityIdentifier.GetPrototypeEntity(r_geom);
+            auto p_entity = r_ref_entity.Create(++max_id, r_geom, nullptr);
+            entities_to_add.push_back(p_entity);
+        }
+    }
+
+    // Add the created entities to current submodelpart
+    if constexpr (std::is_same<typename TEntitiesContainerType::value_type, Element>::value) {
+        rModelPart.AddElements(entities_to_add.begin(), entities_to_add.end());
+    } else if constexpr (std::is_same<typename TEntitiesContainerType::value_type, Condition>::value) {
+        rModelPart.AddConditions(entities_to_add.begin(), entities_to_add.end());
+    }
+}
+
+}
+
+template <>
+void CreateEntitiesFromGeometriesModeler::RemoveModelPartEntities<Element>(ModelPart &rModelPart)
+{
+    const SizeType n_elements = rModelPart.NumberOfElements();
+    KRATOS_WARNING_IF("CreateEntitiesFromGeometriesModeler", n_elements != 0)
+        << "There are " << n_elements << " elements in '" << rModelPart.FullName() << "' model part. These are to be removed." << std::endl;
+    VariableUtils().SetFlag(TO_ERASE, true, rModelPart.Elements());
+    rModelPart.RemoveElementsFromAllLevels(TO_ERASE);
+}
+
+template <>
+void CreateEntitiesFromGeometriesModeler::RemoveModelPartEntities<Condition>(ModelPart &rModelPart)
+{
+    const SizeType n_conditions = rModelPart.NumberOfConditions();
+    KRATOS_WARNING_IF("CreateEntitiesFromGeometriesModeler", n_conditions != 0)
+        << "There are " << n_conditions << " conditions in '" << rModelPart.FullName() << "' model part. These are to be removed." << std::endl;
+    VariableUtils().SetFlag(TO_ERASE, true, rModelPart.Conditions());
+    rModelPart.RemoveConditionsFromAllLevels(TO_ERASE);
+}
+
+template <>
+void CreateEntitiesFromGeometriesModeler::LoopEntitiesList<Element>(Parameters EntitiesList)
+{
+    for (auto& r_data : EntitiesList) {
+        // Get model part in which the entities are to be created
+        const std::string& r_model_part_name = r_data["model_part_name"].GetString();
+        auto& r_model_part = mpModel->GetModelPart(r_model_part_name);
+
+        // Get entities substitution list
+        // Note that the entities identifier allow to substitue different geometry types
+        const std::string& r_element_name = r_data["element_name"].GetString();
+        auto entity_identifier = EntitiesUtilities::EntitityIdentifier<Element>(r_element_name);
+
+        // Wipe current model part entities
+        RemoveModelPartEntities<Element>(r_model_part);
+
+        // Create submodelpart elements from geometries
+        CreateEntitiesFromGeometries<ModelPart::ElementsContainerType, EntitiesUtilities::EntitityIdentifier<Element>>(entity_identifier, r_model_part);
+    }
+}
+
+template <>
+void CreateEntitiesFromGeometriesModeler::LoopEntitiesList<Condition>(Parameters EntitiesList)
+{
+    for (auto& r_data : EntitiesList) {
+        // Get model part in which the entities are to be created
+        const std::string& r_model_part_name = r_data["model_part_name"].GetString();
+        auto& r_model_part = mpModel->GetModelPart(r_model_part_name);
+
+        // Get entities substitution list
+        // Note that the entities identifier allow to substitue different geometry types
+        const std::string& r_element_name = r_data["condition_name"].GetString();
+        auto entity_identifier = EntitiesUtilities::EntitityIdentifier<Condition>(r_element_name);
+
+        // Wipe current model part entities
+        RemoveModelPartEntities<Condition>(r_model_part);
+
+        // Create submodelpart conditions from geometries
+        CreateEntitiesFromGeometries<ModelPart::ConditionsContainerType, EntitiesUtilities::EntitityIdentifier<Condition>>(entity_identifier, r_model_part);
+    }
+}
+
+void CreateEntitiesFromGeometriesModeler::SetupModelPart()
+{
+    // Check parallelism
+    //TODO: Make this MPI compatible by renumbering the local ids
+    KRATOS_ERROR_IF(ParallelEnvironment::GetDefaultDataCommunicator().IsDistributed())
+        << "CreateEntitiesFromGeometriesModeler is not MPI compatible yet." << std::endl;
+
+    // Get the elements list from input settings
+    const auto& r_elements_list = mParameters.GetValue("elements_list");
+    const SizeType n_element_pairs = r_elements_list.size();
+    KRATOS_INFO_IF("CreateEntitiesFromGeometriesModeler", mEchoLevel != 0 && n_element_pairs == 0)
+        << "No elements found in element list." << std::endl;
+
+    // Loop the element list to create the correspoding entities
+    LoopEntitiesList<Element>(r_elements_list);
+
+    // Get the conditions list from input settings
+    const auto& r_conditions_list = mParameters.GetValue("conditions_list");
+    const SizeType n_condition_pairs = r_conditions_list.size();
+    KRATOS_INFO_IF("CreateEntitiesFromGeometriesModeler", mEchoLevel != 0 && n_condition_pairs == 0)
+        << "No conditions found in condition list." << std::endl;
+
+    // Loop the condition list to create the correspoding entities
+    LoopEntitiesList<Condition>(r_conditions_list);
+}
+
+}  // namespace Kratos.
+
+

kratos/modeler/create_entities_from_geometries_modeler.h

@@ -0,0 +1,183 @@
+//    |  /           |
+//    ' /   __| _` | __|  _ \   __|
+//    . \  |   (   | |   (   |\__ `
+//   _|\_\_|  \__,_|\__|\___/ ____/
+//                   Multi-Physics
+//
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
+//
+//  Main authors:    Ruben Zorrilla
+//
+//
+
+#pragma once
+
+// System includes
+
+// External includes
+
+// Project includes
+#include "containers/model.h"
+#include "includes/define.h"
+#include "includes/define_registry.h"
+#include "includes/kratos_components.h"
+#include "modeler/modeler.h"
+#include "utilities/parallel_utilities.h"
+#include "utilities/reduction_utilities.h"
+
+namespace Kratos
+{
+
+///@name Kratos Classes
+///@{
+
+/**
+ * @class CreateEntitiesFromGeometriesModeler
+ * @ingroup KratosCore
+ * @brief Modeler to create element/condition entities from geometries
+ * @details Given a list of pairs of the type submodelpart name and entity (element/condition) name,
+ * this modeler creates the corresponding entities from the submodelpart geometries.
+ * @author Ruben Zorrilla
+ */
+class KRATOS_API(KRATOS_CORE) CreateEntitiesFromGeometriesModeler
+    : public Modeler
+{
+public:
+    ///@name Type Definitions
+    ///@{
+
+    /// Pointer definition of Modeler
+    KRATOS_CLASS_POINTER_DEFINITION(CreateEntitiesFromGeometriesModeler);
+
+    ///@}
+    ///@name Life Cycle
+    ///@{
+
+    /// Default constructor
+    CreateEntitiesFromGeometriesModeler() : Modeler() {};
+
+    /// Constructor with Model
+    CreateEntitiesFromGeometriesModeler(
+        Model &rModel,
+        Parameters Settings)
+        : Modeler(rModel, Settings)
+    {
+        mpModel = &rModel;
+        mParameters.ValidateAndAssignDefaults(GetDefaultParameters());
+    }
+
+    /// Destructor.
+    ~CreateEntitiesFromGeometriesModeler() = default;
+
+    /// Creates the CreateEntitiesFromGeometriesModeler Pointer
+    Modeler::Pointer Create(
+        Model& rModel,
+        const Parameters Settings) const override
+    {
+        return Kratos::make_shared<CreateEntitiesFromGeometriesModeler>(rModel, Settings);
+    }
+
+    ///@}
+    ///@name Operations
+    ///@{
+
+    /// Convert the geometry model or import analysis suitable models.
+    void SetupModelPart() override;
+
+    /// This method provides the defaults parameters to avoid conflicts between the different constructors
+    const Parameters GetDefaultParameters() const override
+    {
+        const Parameters default_parameters = Parameters(R"({
+            "echo_level" : 0,
+            "elements_list" : [],
+            "conditions_list" : []
+        })");
+        return default_parameters;
+    }
+
+    ///@}
+    ///@name Operators
+    ///@{
+
+
+    ///@}
+    ///@name Input and output
+    ///@{
+
+    /// Turn back information as a string.
+    std::string Info() const override
+    {
+        return "CreateEntitiesFromGeometriesModeler";
+    }
+
+    /// Print information about this object.
+    void PrintInfo(std::ostream& rOStream) const override
+    {
+        rOStream << Info();
+    }
+
+    /// Print object's data.
+    void PrintData(std::ostream& rOStream) const override
+    {
+    }
+
+    ///@}
+private:
+    ///@name Static Member Variables
+    ///@{
+
+    KRATOS_REGISTRY_ADD_PROTOTYPE("Modelers.KratosMultiphysics", Modeler, CreateEntitiesFromGeometriesModeler)
+    KRATOS_REGISTRY_ADD_PROTOTYPE("Modelers.All", Modeler, CreateEntitiesFromGeometriesModeler)
+
+    ///@name Private members
+    ///@{
+
+    Model* mpModel = nullptr; /// The model considered in the geometry replacement
+
+    ///@}
+    ///@name Private Operations
+    ///@{
+
+    /**
+     * @brief Loops through a list of entities.
+     * @tparam TEntityType The type of entity.
+     * @param EntitiesList The list of entities.
+     */
+    template <class TEntityType>
+    void LoopEntitiesList(Parameters EntitiesList);
+
+    /**
+     * @brief Removes entities from a model part.
+     * @tparam TEntityType The type of entity.
+     * @param rModelPart The model part from which entities will be removed.
+     */
+    template <class TEntityType>
+    void RemoveModelPartEntities(ModelPart& rModelPart);
+
+    ///@}
+}; // Class CreateEntitiesFromGeometriesModeler
+
+///@}
+///@name Input and output
+///@{
+
+/// input stream function
+inline std::istream& operator >> (
+    std::istream& rIStream,
+    CreateEntitiesFromGeometriesModeler& rThis);
+
+/// output stream function
+inline std::ostream& operator << (
+    std::ostream& rOStream,
+    const CreateEntitiesFromGeometriesModeler& rThis)
+{
+    rThis.PrintInfo(rOStream);
+    rOStream << std::endl;
+    rThis.PrintData(rOStream);
+
+    return rOStream;
+}
+///@}
+
+}  // namespace Kratos.

kratos/python/add_modeler_to_python.cpp

@@ -21,6 +21,7 @@
 #include "modeler/modeler_factory.h"
 #include "modeler/edge_swapping_2d_modeler.h"
 #include "modeler/connectivity_preserve_modeler.h"
+#include "modeler/create_entities_from_geometries_modeler.h"
 #include "modeler/serial_model_part_combinator_modeler.h"
 #include "modeler/duplicate_mesh_modeler.h"
 #include "modeler/copy_properties_modeler.h"
@@ -60,6 +61,7 @@ void  AddModelerToPython(pybind11::module& m)
     py::class_<Modeler, Modeler::Pointer>(m,"Modeler")
     .def(py::init<>())
     .def(py::init<Model&, Parameters>())
+    .def("Create", &Modeler::Create)
     // Modeler Stages Initialize
     .def("SetupGeometryModel", &Modeler::SetupGeometryModel)
     .def("PrepareGeometryModel", &Modeler::PrepareGeometryModel)
@@ -106,6 +108,9 @@ void  AddModelerToPython(pybind11::module& m)
         .def(py::init<Model&, Parameters>())
     ;
 
+    py::class_< CreateEntitiesFromGeometriesModeler, CreateEntitiesFromGeometriesModeler::Pointer, Modeler >(m, "CreateEntitiesFromGeometriesModeler")
+        .def(py::init<Model&, Parameters>())
+    ;
 }
 
 }  // namespace Kratos::Python.

kratos/python/add_registry_to_python.cpp

@@ -20,6 +20,7 @@
 #include "includes/define_python.h"
 #include "includes/registry.h"
 #include "add_registry_to_python.h"
+#include "modeler/modeler.h"
 #include "operations/operation.h"
 #include "processes/process.h"
 
@@ -67,6 +68,7 @@ void AddRegistryToPython(pybind11::module& m)
         .def_static("HasItems", &Registry::HasItems)
         .def_static("HasValue", &Registry::HasValue)
         .def_static("GetItem", &Registry::GetItem, py::return_value_policy::reference)
+        .def_static("GetModeler", &Registry::GetValue<Modeler>, py::return_value_policy::reference)
         .def_static("GetOperation", &Registry::GetValue<Operation>, py::return_value_policy::reference)
         .def_static("GetProcess", &Registry::GetValue<Process>, py::return_value_policy::reference)
         .def_static("RemoveItem", &Registry::RemoveItem)