Skip to content
Snippets Groups Projects
Select Git revision
  • cb004f33c9ff076b6ce7316b92fdcb247f64e5f4
  • develop default protected
  • feature/variational-hydro
  • origin/stage/bouguettaia
  • feature/gmsh-reader
  • feature/reconstruction
  • save_clemence
  • feature/kinetic-schemes
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

test_ASTNodeCFunctionExpressionBuilder.cpp

Blame
  • MeshModule.cpp 16.59 KiB
    #include <language/modules/MeshModule.hpp>
    
    #include <algebra/TinyVector.hpp>
    #include <language/node_processor/ExecutionPolicy.hpp>
    #include <language/utils/BinaryOperatorProcessorBuilder.hpp>
    #include <language/utils/BuiltinFunctionEmbedder.hpp>
    #include <language/utils/FunctionTable.hpp>
    #include <language/utils/ItemArrayVariantFunctionInterpoler.hpp>
    #include <language/utils/ItemValueVariantFunctionInterpoler.hpp>
    #include <language/utils/OStream.hpp>
    #include <language/utils/OperatorRepository.hpp>
    #include <language/utils/SymbolTable.hpp>
    #include <language/utils/TypeDescriptor.hpp>
    #include <mesh/CartesianMeshBuilder.hpp>
    #include <mesh/Connectivity.hpp>
    #include <mesh/ConnectivityUtils.hpp>
    #include <mesh/DualMeshManager.hpp>
    #include <mesh/GmshReader.hpp>
    #include <mesh/IBoundaryDescriptor.hpp>
    #include <mesh/IZoneDescriptor.hpp>
    #include <mesh/ItemArrayVariant.hpp>
    #include <mesh/ItemValueVariant.hpp>
    #include <mesh/Mesh.hpp>
    #include <mesh/MeshRelaxer.hpp>
    #include <mesh/MeshTransformer.hpp>
    #include <mesh/NamedBoundaryDescriptor.hpp>
    #include <mesh/NamedInterfaceDescriptor.hpp>
    #include <mesh/NamedZoneDescriptor.hpp>
    #include <mesh/NumberedBoundaryDescriptor.hpp>
    #include <mesh/NumberedInterfaceDescriptor.hpp>
    #include <mesh/NumberedZoneDescriptor.hpp>
    #include <mesh/SubItemArrayPerItemVariant.hpp>
    #include <mesh/SubItemValuePerItemVariant.hpp>
    #include <utils/Exceptions.hpp>
    
    #include <Kokkos_Core.hpp>
    
    MeshModule::MeshModule()
    {
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IMesh>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryDescriptor>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IInterfaceDescriptor>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IZoneDescriptor>>);
    
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const ItemType>>);
    
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const ItemValueVariant>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const ItemArrayVariant>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const SubItemValuePerItemVariant>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const SubItemArrayPerItemVariant>>);
    
      this->_addBuiltinFunction("cell", std::function(
    
                                          []() -> std::shared_ptr<const ItemType> {
                                            return std::make_shared<ItemType>(ItemType::cell);
                                          }
    
                                          ));
    
      this->_addBuiltinFunction("face", std::function(
    
                                          []() -> std::shared_ptr<const ItemType> {
                                            return std::make_shared<ItemType>(ItemType::face);
                                          }
    
                                          ));
    
      this->_addBuiltinFunction("edge", std::function(
    
                                          []() -> std::shared_ptr<const ItemType> {
                                            return std::make_shared<ItemType>(ItemType::edge);
                                          }
    
                                          ));
    
      this->_addBuiltinFunction("node", std::function(
    
                                          []() -> std::shared_ptr<const ItemType> {
                                            return std::make_shared<ItemType>(ItemType::node);
                                          }
    
                                          ));
    
      this->_addBuiltinFunction("readGmsh", std::function(
    
                                              [](const std::string& file_name) -> std::shared_ptr<const IMesh> {
                                                GmshReader gmsh_reader(file_name);
                                                return gmsh_reader.mesh();
                                              }
    
                                              ));
    
      this->_addBuiltinFunction("boundaryName",
                                std::function(
    
                                  [](const std::string& boundary_name) -> std::shared_ptr<const IBoundaryDescriptor> {
                                    return std::make_shared<NamedBoundaryDescriptor>(boundary_name);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("boundaryTag", std::function(
    
                                                 [](int64_t boundary_tag) -> std::shared_ptr<const IBoundaryDescriptor> {
                                                   return std::make_shared<NumberedBoundaryDescriptor>(boundary_tag);
                                                 }
    
                                                 ));
    
      this->_addBuiltinFunction("interfaceName",
                                std::function(
    
                                  [](const std::string& interface_name) -> std::shared_ptr<const IInterfaceDescriptor> {
                                    return std::make_shared<NamedInterfaceDescriptor>(interface_name);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("interfaceTag", std::function(
    
                                                  [](int64_t interface_tag) -> std::shared_ptr<const IInterfaceDescriptor> {
                                                    return std::make_shared<NumberedInterfaceDescriptor>(interface_tag);
                                                  }
    
                                                  ));
    
      this->_addBuiltinFunction("zoneTag", std::function(
    
                                             [](int64_t zone_tag) -> std::shared_ptr<const IZoneDescriptor> {
                                               return std::make_shared<NumberedZoneDescriptor>(zone_tag);
                                             }
    
                                             ));
    
      this->_addBuiltinFunction("zoneName", std::function(
    
                                              [](const std::string& zone_name) -> std::shared_ptr<const IZoneDescriptor> {
                                                return std::make_shared<NamedZoneDescriptor>(zone_name);
                                              }
    
                                              ));
    
      this->_addBuiltinFunction("interpolate",
                                std::function(
    
                                  [](std::shared_ptr<const IMesh> mesh, std::shared_ptr<const ItemType> item_type,
                                     const FunctionSymbolId& function_id) -> std::shared_ptr<const ItemValueVariant> {
                                    return ItemValueVariantFunctionInterpoler{mesh, *item_type, function_id}.interpolate();
                                  }
    
                                  ));
    
      this->_addBuiltinFunction(
        "interpolate_array",
        std::function(
    
          [](std::shared_ptr<const IMesh> mesh, std::shared_ptr<const ItemType> item_type,
             const std::vector<FunctionSymbolId>& function_id_list) -> std::shared_ptr<const ItemArrayVariant> {
            return ItemArrayVariantFunctionInterpoler{mesh, *item_type, function_id_list}.interpolate();
          }
    
          ));
    
      this->_addBuiltinFunction("transform", std::function(
    
                                               [](std::shared_ptr<const IMesh> p_mesh,
                                                  const FunctionSymbolId& function_id) -> std::shared_ptr<const IMesh> {
                                                 return MeshTransformer{}.transform(function_id, p_mesh);
                                               }
    
                                               ));
    
      this->_addBuiltinFunction("relax", std::function(
    
                                           [](const std::shared_ptr<const IMesh>& source_mesh,
                                              const std::shared_ptr<const IMesh>& destination_mesh,
                                              const double& theta) -> std::shared_ptr<const IMesh> {
                                             return MeshRelaxer{}.relax(source_mesh, destination_mesh, theta);
                                           }
    
                                           ));
    
      this->_addBuiltinFunction("check_connectivity_ordering",
                                std::function(
    
                                  [](const std::shared_ptr<const IMesh>& i_mesh) -> bool {
                                    switch (i_mesh->dimension()) {
                                    case 1: {
                                      using MeshType = Mesh<Connectivity<1>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return checkConnectivityOrdering(p_mesh->connectivity());
                                    }
                                    case 2: {
                                      using MeshType = Mesh<Connectivity<2>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return checkConnectivityOrdering(p_mesh->connectivity());
                                    }
                                    case 3: {
                                      using MeshType = Mesh<Connectivity<3>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return checkConnectivityOrdering(p_mesh->connectivity());
                                    }
                                    default: {
                                      throw UnexpectedError("invalid dimension");
                                    }
                                    }
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("cartesianMesh",
                                std::function(
    
                                  [](const TinyVector<1> a, const TinyVector<1> b,
                                     const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
                                    constexpr uint64_t dimension = 1;
    
                                    if (box_sizes.size() != dimension) {
                                      throw NormalError("expecting " + stringify(dimension) + " dimensions, provided " +
                                                        stringify(box_sizes.size()));
                                    }
    
                                    const TinyVector<dimension, uint64_t> sizes = [&]() {
                                      TinyVector<dimension, uint64_t> s;
                                      for (size_t i = 0; i < dimension; ++i) {
                                        s[i] = box_sizes[i];
                                      }
                                      return s;
                                    }();
    
                                    CartesianMeshBuilder builder{a, b, sizes};
                                    return builder.mesh();
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("cartesianMesh",
                                std::function(
    
                                  [](const TinyVector<2> a, const TinyVector<2> b,
                                     const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
                                    constexpr uint64_t dimension = 2;
    
                                    if (box_sizes.size() != dimension) {
                                      throw NormalError("expecting " + stringify(dimension) + " dimensions, provided " +
                                                        stringify(box_sizes.size()));
                                    }
    
                                    const TinyVector<dimension, uint64_t> sizes = [&]() {
                                      TinyVector<dimension, uint64_t> s;
                                      for (size_t i = 0; i < dimension; ++i) {
                                        s[i] = box_sizes[i];
                                      }
                                      return s;
                                    }();
    
                                    CartesianMeshBuilder builder{a, b, sizes};
                                    return builder.mesh();
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("cartesianMesh",
                                std::function(
    
                                  [](const TinyVector<3>& a, const TinyVector<3>& b,
                                     const std::vector<uint64_t>& box_sizes) -> std::shared_ptr<const IMesh> {
                                    constexpr uint64_t dimension = 3;
    
                                    if (box_sizes.size() != dimension) {
                                      throw NormalError("expecting " + stringify(dimension) + " dimensions, provided " +
                                                        stringify(box_sizes.size()));
                                    }
    
                                    const TinyVector<dimension, uint64_t> sizes = [&]() {
                                      TinyVector<dimension, uint64_t> s;
                                      for (size_t i = 0; i < dimension; ++i) {
                                        s[i] = box_sizes[i];
                                      }
                                      return s;
                                    }();
    
                                    CartesianMeshBuilder builder{a, b, sizes};
                                    return builder.mesh();
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("diamondDual",
                                std::function(
    
                                  [](const std::shared_ptr<const IMesh>& i_mesh) -> std::shared_ptr<const IMesh> {
                                    switch (i_mesh->dimension()) {
                                    case 1: {
                                      using MeshType = Mesh<Connectivity<1>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getDiamondDualMesh(*p_mesh);
                                    }
                                    case 2: {
                                      using MeshType = Mesh<Connectivity<2>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getDiamondDualMesh(*p_mesh);
                                    }
                                    case 3: {
                                      using MeshType = Mesh<Connectivity<3>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getDiamondDualMesh(*p_mesh);
                                    }
                                    default: {
                                      throw UnexpectedError("invalid dimension");
                                    }
                                    }
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("medianDual",
                                std::function(
    
                                  [](const std::shared_ptr<const IMesh>& i_mesh) -> std::shared_ptr<const IMesh> {
                                    switch (i_mesh->dimension()) {
                                    case 1: {
                                      using MeshType = Mesh<Connectivity<1>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getMedianDualMesh(*p_mesh);
                                    }
                                    case 2: {
                                      using MeshType = Mesh<Connectivity<2>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getMedianDualMesh(*p_mesh);
                                    }
                                    case 3: {
                                      using MeshType = Mesh<Connectivity<3>>;
    
                                      std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
                                      return DualMeshManager::instance().getMedianDualMesh(*p_mesh);
                                    }
                                    default: {
                                      throw UnexpectedError("invalid dimension");
                                    }
                                    }
                                  }
    
                                  ));
    }
    
    void
    MeshModule::registerOperators() const
    {
      OperatorRepository& repository = OperatorRepository::instance();
    
      repository.addBinaryOperator<language::shift_left_op>(
        std::make_shared<BinaryOperatorProcessorBuilder<language::shift_left_op, std::shared_ptr<const OStream>,
                                                        std::shared_ptr<const OStream>, std::shared_ptr<const IMesh>>>());
    }