Skip to content
Snippets Groups Projects
Select Git revision
  • 4ae7fd57df5246d163381336a61f55bfa87c2e22
  • develop default protected
  • 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
  • feature/hypoelasticity-clean
  • 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

CompositeSchemeSourcesModule.cpp

Blame
  • WriterModule.cpp 4.95 KiB
    #include <language/modules/WriterModule.hpp>
    
    #include <language/utils/BuiltinFunctionEmbedder.hpp>
    #include <language/utils/TypeDescriptor.hpp>
    #include <mesh/Connectivity.hpp>
    #include <mesh/GmshReader.hpp>
    #include <mesh/Mesh.hpp>
    #include <output/GnuplotWriter.hpp>
    #include <output/GnuplotWriter1D.hpp>
    #include <output/IWriter.hpp>
    #include <output/NamedDiscreteFunction.hpp>
    #include <output/VTKWriter.hpp>
    #include <scheme/DiscreteFunctionP0.hpp>
    #include <scheme/IDiscreteFunction.hpp>
    #include <scheme/IDiscreteFunctionDescriptor.hpp>
    
    WriterModule::WriterModule()
    {
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const NamedDiscreteFunction>>);
    
      this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IWriter>>);
    
      this->_addBuiltinFunction("vtk_writer",
                                std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IWriter>(const std::string&,
                                                                                                        const double&)>>(
    
                                  [](const std::string& filename, const double& period) {
                                    return std::make_shared<VTKWriter>(filename, period);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("gnuplot_writer",
                                std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IWriter>(const std::string&,
                                                                                                        const double&)>>(
    
                                  [](const std::string& filename, const double& period) {
                                    return std::make_shared<GnuplotWriter>(filename, period);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("gnuplot_1d_writer",
                                std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IWriter>(const std::string&,
                                                                                                        const double&)>>(
    
                                  [](const std::string& filename, const double& period) {
                                    return std::make_shared<GnuplotWriter1D>(filename, period);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("name_output",
                                std::make_shared<BuiltinFunctionEmbedder<
                                  std::shared_ptr<const NamedDiscreteFunction>(std::shared_ptr<const IDiscreteFunction>,
                                                                               const std::string&)>>(
    
                                  [](std::shared_ptr<const IDiscreteFunction> discrete_function,
                                     const std::string& name) -> std::shared_ptr<const NamedDiscreteFunction> {
                                    return std::make_shared<const NamedDiscreteFunction>(discrete_function, name);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("write_mesh",
                                std::make_shared<BuiltinFunctionEmbedder<void(std::shared_ptr<const IWriter>,
                                                                              std::shared_ptr<const IMesh>)>>(
    
                                  [](std::shared_ptr<const IWriter> writer, std::shared_ptr<const IMesh> p_mesh) -> void {
                                    writer->writeMesh(p_mesh);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("write",
                                std::make_shared<BuiltinFunctionEmbedder<
                                  void(std::shared_ptr<const IWriter>,
                                       const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&, const double&)>>(
    
                                  [](std::shared_ptr<const IWriter> writer,
                                     const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&
                                       named_discrete_function_list,
                                     const double& time) -> void {
                                    writer->writeIfNeeded(named_discrete_function_list, time);
                                  }
    
                                  ));
    
      this->_addBuiltinFunction("force_write",
                                std::make_shared<BuiltinFunctionEmbedder<
                                  void(std::shared_ptr<const IWriter>,
                                       const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&, const double&)>>(
    
                                  [](std::shared_ptr<const IWriter> writer,
                                     const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&
                                       named_discrete_function_list,
                                     const double& time) -> void {
                                    writer->writeForced(named_discrete_function_list, time);
                                  }
    
                                  ));
    }