Skip to content
Snippets Groups Projects
Select Git revision
  • 9ab2f3e9543175c3d8cfdb6ddb7a6bdf683e798f
  • develop default protected
  • feature/gmsh-reader
  • origin/stage/bouguettaia
  • feature/kinetic-schemes
  • feature/reconstruction
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/variational-hydro
  • 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
  • feature/escobar-smoother
  • 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

SchemeModule.cpp

Blame
    • Stéphane Del Pino's avatar
      9ab2f3e9
      Reorganize boundary conditions · 9ab2f3e9
      Stéphane Del Pino authored
      Now BC types are
      - Dirichlet
      - Fourier
      - Neumann
      - Symmetry
      
      One can set tags for Dirichlet, Neumann and Fourier in order to
      distinguish variables concerned by these conditions.
      
      In the future, it is planned to allow freefem like conditions such
      as `u = g on XMIN` or `alpha * u + dnu (u) = g on 3`,...
      
      However this will only make sense when "algorithms" will be set in
      pugs' language.
      9ab2f3e9
      History
      Reorganize boundary conditions
      Stéphane Del Pino authored
      Now BC types are
      - Dirichlet
      - Fourier
      - Neumann
      - Symmetry
      
      One can set tags for Dirichlet, Neumann and Fourier in order to
      distinguish variables concerned by these conditions.
      
      In the future, it is planned to allow freefem like conditions such
      as `u = g on XMIN` or `alpha * u + dnu (u) = g on 3`,...
      
      However this will only make sense when "algorithms" will be set in
      pugs' language.
    SchemeModule.cpp 9.55 KiB
    #include <language/modules/SchemeModule.hpp>
    
    #include <language/algorithms/AcousticSolverAlgorithm.hpp>
    #include <language/utils/BuiltinFunctionEmbedder.hpp>
    #include <language/utils/TypeDescriptor.hpp>
    #include <mesh/Mesh.hpp>
    #include <scheme/DirichletBoundaryConditionDescriptor.hpp>
    #include <scheme/FourierBoundaryConditionDescriptor.hpp>
    #include <scheme/IBoundaryConditionDescriptor.hpp>
    #include <scheme/IBoundaryDescriptor.hpp>
    #include <scheme/NamedBoundaryDescriptor.hpp>
    #include <scheme/NeumannBoundaryConditionDescriptor.hpp>
    #include <scheme/NumberedBoundaryDescriptor.hpp>
    #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
    
    #include <memory>
    
    SchemeModule::SchemeModule()
    {
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryDescriptor>>);
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryConditionDescriptor>>);
    
      this->_addBuiltinFunction("boundaryName",
                                std::make_shared<
                                  BuiltinFunctionEmbedder<std::shared_ptr<const IBoundaryDescriptor>(const std::string&)>>(
    
                                  [](const std::string& boundary_name) -> std::shared_ptr<const IBoundaryDescriptor> {
                                    return std::make_shared<NamedBoundaryDescriptor>(boundary_name);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("boundaryTag",
                                std::make_shared<
                                  BuiltinFunctionEmbedder<std::shared_ptr<const IBoundaryDescriptor>(int64_t)>>(
    
                                  [](int64_t boundary_tag) -> std::shared_ptr<const IBoundaryDescriptor> {
                                    return std::make_shared<NumberedBoundaryDescriptor>(boundary_tag);
                                  }
    
                                  ));
    
      this
        ->_addBuiltinFunction("symmetry",
                              std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IBoundaryConditionDescriptor>(
                                std::shared_ptr<const IBoundaryDescriptor>)>>(
    
                                [](std::shared_ptr<const IBoundaryDescriptor> boundary)
                                  -> std::shared_ptr<const IBoundaryConditionDescriptor> {
                                  return std::make_shared<SymmetryBoundaryConditionDescriptor>(boundary);
                                }
    
                                ));
    
      this->_addBuiltinFunction("pressure",
                                std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<
                                  const IBoundaryConditionDescriptor>(std::shared_ptr<const IBoundaryDescriptor>,
                                                                      const FunctionSymbolId&)>>(
    
                                  [](std::shared_ptr<const IBoundaryDescriptor> boundary,
                                     const FunctionSymbolId& pressure_id)
                                    -> std::shared_ptr<const IBoundaryConditionDescriptor> {
                                    return std::make_shared<DirichletBoundaryConditionDescriptor>("pressure", boundary,
                                                                                                  pressure_id);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("velocity",
                                std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<
                                  const IBoundaryConditionDescriptor>(std::shared_ptr<const IBoundaryDescriptor>,
                                                                      const FunctionSymbolId&)>>(
    
                                  [](std::shared_ptr<const IBoundaryDescriptor> boundary,
                                     const FunctionSymbolId& velocity_id)
                                    -> std::shared_ptr<const IBoundaryConditionDescriptor> {
                                    return std::make_shared<DirichletBoundaryConditionDescriptor>("velocity", boundary,
                                                                                                  velocity_id);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("glace",
                                std::make_shared<BuiltinFunctionEmbedder<
                                  void(std::shared_ptr<const IMesh>,
                                       const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&,
                                       const FunctionSymbolId&, const FunctionSymbolId&, const FunctionSymbolId&)>>(
    
                                  [](std::shared_ptr<const IMesh> p_mesh,
                                     const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
                                       bc_descriptor_list,
                                     const FunctionSymbolId& rho_id, const FunctionSymbolId& u_id,
                                     const FunctionSymbolId& p_id) -> void {
                                    switch (p_mesh->dimension()) {
                                    case 1: {
                                      AcousticSolverAlgorithm<1>{AcousticSolverType::Glace,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    case 2: {
                                      AcousticSolverAlgorithm<2>{AcousticSolverType::Glace,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    case 3: {
                                      AcousticSolverAlgorithm<3>{AcousticSolverType::Glace,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    default: {
                                      throw UnexpectedError("invalid mesh dimension");
                                    }
                                    }
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("eucclhyd",
                                std::make_shared<BuiltinFunctionEmbedder<
                                  void(std::shared_ptr<const IMesh>,
                                       const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&,
                                       const FunctionSymbolId&, const FunctionSymbolId&, const FunctionSymbolId&)>>(
    
                                  [](std::shared_ptr<const IMesh> p_mesh,
                                     const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
                                       bc_descriptor_list,
                                     const FunctionSymbolId& rho_id, const FunctionSymbolId& u_id,
                                     const FunctionSymbolId& p_id) -> void {
                                    switch (p_mesh->dimension()) {
                                    case 1: {
                                      AcousticSolverAlgorithm<1>{AcousticSolverType::Eucclhyd,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    case 2: {
                                      AcousticSolverAlgorithm<2>{AcousticSolverType::Eucclhyd,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    case 3: {
                                      AcousticSolverAlgorithm<3>{AcousticSolverType::Eucclhyd,
                                                                 p_mesh,
                                                                 bc_descriptor_list,
                                                                 rho_id,
                                                                 u_id,
                                                                 p_id};
                                      break;
                                    }
                                    default: {
                                      throw UnexpectedError("invalid mesh dimension");
                                    }
                                    }
                                  }
    
                                  ));
    }