diff --git a/packages/core.cmake b/packages/core.cmake index ffb02efa1..7fef7715a 100644 --- a/packages/core.cmake +++ b/packages/core.cmake @@ -1,522 +1,520 @@ #=============================================================================== # @file core.cmake # # @author Guillaume Anciaux # @author Nicolas Richart # # @date creation: Mon Nov 21 2011 # @date last modification: Mon Jan 18 2016 # # @brief package description for core # # @section LICENSE # # Copyright (©) 2010-2012, 2014, 2015 EPFL (Ecole Polytechnique Fédérale de # Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des # Solides) # # Akantu is free software: you can redistribute it and/or modify it under the # terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with Akantu. If not, see . # #=============================================================================== package_declare(core NOT_OPTIONAL DESCRIPTION "core package for Akantu" FEATURES_PUBLIC cxx_strong_enums cxx_defaulted_functions cxx_deleted_functions cxx_auto_type cxx_decltype_auto FEATURES_PRIVATE cxx_lambdas cxx_nullptr cxx_range_for cxx_delegating_constructors DEPENDS INTERFACE Boost) package_declare_sources(core common/aka_array.cc common/aka_array.hh common/aka_array_tmpl.hh common/aka_bbox.hh common/aka_blas_lapack.hh common/aka_circular_array.hh common/aka_circular_array_inline_impl.cc common/aka_common.cc common/aka_common.hh common/aka_common_inline_impl.cc common/aka_csr.hh common/aka_element_classes_info_inline_impl.cc common/aka_error.cc common/aka_error.hh common/aka_event_handler_manager.hh common/aka_extern.cc common/aka_factory.hh common/aka_fwd.hh common/aka_grid_dynamic.hh common/aka_math.cc common/aka_math.hh common/aka_math_tmpl.hh common/aka_memory.cc common/aka_memory.hh common/aka_memory_inline_impl.cc common/aka_named_argument.hh common/aka_random_generator.hh common/aka_safe_enum.hh common/aka_static_memory.cc common/aka_static_memory.hh common/aka_static_memory_inline_impl.cc common/aka_static_memory_tmpl.hh common/aka_typelist.hh common/aka_types.hh common/aka_visitor.hh common/aka_voigthelper.hh common/aka_voigthelper_tmpl.hh common/aka_voigthelper.cc common/aka_warning.hh common/aka_warning_restore.hh common/aka_iterators.hh common/aka_static_if.hh common/aka_compatibilty_with_cpp_standard.hh fe_engine/element_class.hh fe_engine/element_class_tmpl.hh fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc fe_engine/element_classes/element_class_point_1_inline_impl.cc fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc fe_engine/element_classes/element_class_segment_2_inline_impl.cc fe_engine/element_classes/element_class_segment_3_inline_impl.cc fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc fe_engine/element_classes/element_class_triangle_3_inline_impl.cc fe_engine/element_classes/element_class_triangle_6_inline_impl.cc fe_engine/element_type_conversion.hh fe_engine/fe_engine.cc fe_engine/fe_engine.hh fe_engine/fe_engine_inline_impl.cc fe_engine/fe_engine_template.hh fe_engine/fe_engine_template_tmpl_field.hh fe_engine/fe_engine_template_tmpl.hh fe_engine/geometrical_element_property.hh fe_engine/geometrical_element_property.cc fe_engine/gauss_integration.cc fe_engine/gauss_integration_tmpl.hh fe_engine/integrator.hh fe_engine/integrator_gauss.hh fe_engine/integrator_gauss_inline_impl.cc fe_engine/interpolation_element_tmpl.hh fe_engine/integration_point.hh fe_engine/shape_functions.hh fe_engine/shape_functions.cc fe_engine/shape_functions_inline_impl.cc fe_engine/shape_lagrange_base.cc fe_engine/shape_lagrange_base.hh fe_engine/shape_lagrange_base_inline_impl.cc fe_engine/shape_lagrange.hh fe_engine/shape_lagrange_inline_impl.cc fe_engine/element.hh io/dumper/dumpable.hh io/dumper/dumpable.cc io/dumper/dumpable_dummy.hh io/dumper/dumpable_inline_impl.hh io/dumper/dumper_field.hh io/dumper/dumper_material_padders.hh io/dumper/dumper_filtered_connectivity.hh io/dumper/dumper_element_partition.hh io/mesh_io.cc io/mesh_io.hh - io/mesh_io/mesh_io_abaqus.cc - io/mesh_io/mesh_io_abaqus.hh io/mesh_io/mesh_io_diana.cc io/mesh_io/mesh_io_diana.hh io/mesh_io/mesh_io_msh.cc io/mesh_io/mesh_io_msh.hh #io/model_io.cc #io/model_io.hh io/parser/algebraic_parser.hh io/parser/input_file_parser.hh io/parser/parsable.cc io/parser/parsable.hh io/parser/parser.cc io/parser/parser_real.cc io/parser/parser_random.cc io/parser/parser_types.cc io/parser/parser_input_files.cc io/parser/parser.hh io/parser/parser_tmpl.hh io/parser/parser_grammar_tmpl.hh io/parser/cppargparse/cppargparse.hh io/parser/cppargparse/cppargparse.cc io/parser/cppargparse/cppargparse_tmpl.hh io/parser/parameter_registry.cc io/parser/parameter_registry.hh io/parser/parameter_registry_tmpl.hh mesh/element_group.cc mesh/element_group.hh mesh/element_group_inline_impl.cc mesh/element_type_map.cc mesh/element_type_map.hh mesh/element_type_map_tmpl.hh mesh/element_type_map_filter.hh mesh/group_manager.cc mesh/group_manager.hh mesh/group_manager_inline_impl.cc mesh/mesh.cc mesh/mesh.hh mesh/mesh_periodic.cc mesh/mesh_accessor.hh mesh/mesh_events.hh mesh/mesh_filter.hh mesh/mesh_global_data_updater.hh mesh/mesh_data.cc mesh/mesh_data.hh mesh/mesh_data_tmpl.hh mesh/mesh_inline_impl.cc mesh/node_group.cc mesh/node_group.hh mesh/node_group_inline_impl.cc mesh/mesh_iterators.hh mesh_utils/mesh_partition.cc mesh_utils/mesh_partition.hh mesh_utils/mesh_partition/mesh_partition_mesh_data.cc mesh_utils/mesh_partition/mesh_partition_mesh_data.hh mesh_utils/mesh_partition/mesh_partition_scotch.hh mesh_utils/mesh_utils_pbc.cc mesh_utils/mesh_utils.cc mesh_utils/mesh_utils.hh mesh_utils/mesh_utils_distribution.cc mesh_utils/mesh_utils_distribution.hh mesh_utils/mesh_utils.hh mesh_utils/mesh_utils_inline_impl.cc mesh_utils/global_ids_updater.hh mesh_utils/global_ids_updater.cc mesh_utils/global_ids_updater_inline_impl.cc model/boundary_condition.hh model/boundary_condition_functor.hh model/boundary_condition_functor_inline_impl.cc model/boundary_condition_tmpl.hh model/common/neighborhood_base.hh model/common/neighborhood_base.cc model/common/neighborhood_base_inline_impl.cc model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.hh model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion_inline_impl.cc model/common/non_local_toolbox/non_local_manager.hh model/common/non_local_toolbox/non_local_manager.cc model/common/non_local_toolbox/non_local_manager_inline_impl.cc model/common/non_local_toolbox/non_local_manager_callback.hh model/common/non_local_toolbox/non_local_neighborhood_base.hh model/common/non_local_toolbox/non_local_neighborhood_base.cc model/common/non_local_toolbox/non_local_neighborhood.hh model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh model/common/non_local_toolbox/non_local_neighborhood_inline_impl.cc model/common/non_local_toolbox/base_weight_function.hh model/common/non_local_toolbox/base_weight_function_inline_impl.cc model/dof_manager.cc model/dof_manager.hh model/dof_manager_default.cc model/dof_manager_default.hh model/dof_manager_default_inline_impl.cc model/dof_manager_inline_impl.cc model/model_solver.cc model/model_solver.hh model/non_linear_solver.cc model/non_linear_solver.hh model/non_linear_solver_default.hh model/non_linear_solver_lumped.cc model/non_linear_solver_lumped.hh model/solver_callback.hh model/solver_callback.cc model/time_step_solver.hh model/time_step_solvers/time_step_solver.cc model/time_step_solvers/time_step_solver_default.cc model/time_step_solvers/time_step_solver_default.hh model/time_step_solvers/time_step_solver_default_explicit.hh model/non_linear_solver_callback.hh model/time_step_solvers/time_step_solver_default_solver_callback.hh model/integration_scheme/generalized_trapezoidal.cc model/integration_scheme/generalized_trapezoidal.hh model/integration_scheme/integration_scheme.cc model/integration_scheme/integration_scheme.hh model/integration_scheme/integration_scheme_1st_order.cc model/integration_scheme/integration_scheme_1st_order.hh model/integration_scheme/integration_scheme_2nd_order.cc model/integration_scheme/integration_scheme_2nd_order.hh model/integration_scheme/newmark-beta.cc model/integration_scheme/newmark-beta.hh model/integration_scheme/pseudo_time.cc model/integration_scheme/pseudo_time.hh model/model.cc model/model.hh model/model_inline_impl.cc model/model_options.hh solver/sparse_solver.cc solver/sparse_solver.hh solver/sparse_solver_inline_impl.cc solver/sparse_matrix.cc solver/sparse_matrix.hh solver/sparse_matrix_inline_impl.cc solver/sparse_matrix_aij.cc solver/sparse_matrix_aij.hh solver/sparse_matrix_aij_inline_impl.cc solver/terms_to_assemble.hh synchronizer/communication_buffer_inline_impl.cc synchronizer/communication_descriptor.hh synchronizer/communication_descriptor_tmpl.hh synchronizer/communication_request.hh synchronizer/communication_tag.hh synchronizer/communications.hh synchronizer/communications_tmpl.hh synchronizer/communicator.cc synchronizer/communicator.hh synchronizer/communicator_dummy_inline_impl.cc synchronizer/communicator_event_handler.hh synchronizer/communicator_inline_impl.hh synchronizer/data_accessor.cc synchronizer/data_accessor.hh synchronizer/dof_synchronizer.cc synchronizer/dof_synchronizer.hh synchronizer/dof_synchronizer_inline_impl.cc synchronizer/element_info_per_processor.cc synchronizer/element_info_per_processor.hh synchronizer/element_info_per_processor_tmpl.hh synchronizer/element_synchronizer.cc synchronizer/element_synchronizer.hh synchronizer/facet_synchronizer.cc synchronizer/facet_synchronizer.hh synchronizer/facet_synchronizer_inline_impl.cc synchronizer/grid_synchronizer.cc synchronizer/grid_synchronizer.hh synchronizer/grid_synchronizer_tmpl.hh synchronizer/master_element_info_per_processor.cc synchronizer/node_info_per_processor.cc synchronizer/node_info_per_processor.hh synchronizer/node_synchronizer.cc synchronizer/node_synchronizer.hh synchronizer/periodic_node_synchronizer.cc synchronizer/periodic_node_synchronizer.hh synchronizer/slave_element_info_per_processor.cc synchronizer/synchronizer.cc synchronizer/synchronizer.hh synchronizer/synchronizer_impl.hh synchronizer/synchronizer_impl_tmpl.hh synchronizer/synchronizer_registry.cc synchronizer/synchronizer_registry.hh synchronizer/synchronizer_tmpl.hh synchronizer/communication_buffer.hh ) set(AKANTU_SPIRIT_SOURCES io/mesh_io/mesh_io_abaqus.cc io/parser/parser_real.cc io/parser/parser_random.cc io/parser/parser_types.cc io/parser/parser_input_files.cc PARENT_SCOPE ) package_declare_elements(core ELEMENT_TYPES _point_1 _segment_2 _segment_3 _triangle_3 _triangle_6 _quadrangle_4 _quadrangle_8 _tetrahedron_4 _tetrahedron_10 _pentahedron_6 _pentahedron_15 _hexahedron_8 _hexahedron_20 KIND regular GEOMETRICAL_TYPES _gt_point _gt_segment_2 _gt_segment_3 _gt_triangle_3 _gt_triangle_6 _gt_quadrangle_4 _gt_quadrangle_8 _gt_tetrahedron_4 _gt_tetrahedron_10 _gt_hexahedron_8 _gt_hexahedron_20 _gt_pentahedron_6 _gt_pentahedron_15 INTERPOLATION_TYPES _itp_lagrange_point_1 _itp_lagrange_segment_2 _itp_lagrange_segment_3 _itp_lagrange_triangle_3 _itp_lagrange_triangle_6 _itp_lagrange_quadrangle_4 _itp_serendip_quadrangle_8 _itp_lagrange_tetrahedron_4 _itp_lagrange_tetrahedron_10 _itp_lagrange_hexahedron_8 _itp_serendip_hexahedron_20 _itp_lagrange_pentahedron_6 _itp_lagrange_pentahedron_15 GEOMETRICAL_SHAPES _gst_point _gst_triangle _gst_square _gst_prism GAUSS_INTEGRATION_TYPES _git_point _git_segment _git_triangle _git_tetrahedron _git_pentahedron INTERPOLATION_KIND _itk_lagrangian FE_ENGINE_LISTS gradient_on_integration_points interpolate_on_integration_points interpolate compute_normals_on_integration_points inverse_map contains compute_shapes compute_shapes_derivatives get_shapes_derivatives lagrange_base ) package_declare_documentation_files(core manual.sty manual.cls manual.tex manual-macros.sty manual-titlepages.tex manual-authors.tex manual-changelog.tex manual-introduction.tex manual-gettingstarted.tex manual-io.tex manual-feengine.tex manual-elements.tex manual-appendix-elements.tex manual-appendix-packages.tex manual-backmatter.tex manual-bibliography.bib manual-bibliographystyle.bst figures/bc_and_ic_example.pdf figures/boundary.pdf figures/boundary.svg figures/dirichlet.pdf figures/dirichlet.svg # figures/doc_wheel.pdf # figures/doc_wheel.svg figures/hot-point-1.png figures/hot-point-2.png figures/insertion.pdf figures/interpolate.pdf figures/interpolate.svg figures/vectors.pdf figures/vectors.svg figures/elements/hexahedron_8.pdf figures/elements/hexahedron_8.svg figures/elements/quadrangle_4.pdf figures/elements/quadrangle_4.svg figures/elements/quadrangle_8.pdf figures/elements/quadrangle_8.svg figures/elements/segment_2.pdf figures/elements/segment_2.svg figures/elements/segment_3.pdf figures/elements/segment_3.svg figures/elements/tetrahedron_10.pdf figures/elements/tetrahedron_10.svg figures/elements/tetrahedron_4.pdf figures/elements/tetrahedron_4.svg figures/elements/triangle_3.pdf figures/elements/triangle_3.svg figures/elements/triangle_6.pdf figures/elements/triangle_6.svg figures/elements/xtemp.pdf ) package_declare_documentation(core "This package is the core engine of \\akantu. It depends on:" "\\begin{itemize}" "\\item A C++ compiler (\\href{http://gcc.gnu.org/}{GCC} >= 4, or \\href{https://software.intel.com/en-us/intel-compilers}{Intel})." "\\item The cross-platform, open-source \\href{http://www.cmake.org/}{CMake} build system." "\\item The \\href{http://www.boost.org/}{Boost} C++ portable libraries." "\\item The \\href{http://www.zlib.net/}{zlib} compression library." "\\end{itemize}" "" "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:" "\\begin{command}" " > sudo apt-get install cmake libboost-dev zlib1g-dev g++" "\\end{command}" "" "Under Mac OS X the installation requires the following steps:" "\\begin{itemize}" "\\item Install Xcode" "\\item Install the command line tools." "\\item Install the MacPorts project which allows to automatically" "download and install opensource packages." "\\end{itemize}" "Then the following commands should be typed in a terminal:" "\\begin{command}" " > sudo port install cmake gcc48 boost" "\\end{command}" ) find_program(READLINK_COMMAND readlink) find_program(ADDR2LINE_COMMAND addr2line) find_program(PATCH_COMMAND patch) mark_as_advanced(READLINK_COMMAND) mark_as_advanced(ADDR2LINE_COMMAND) package_declare_extra_files_to_package(core SOURCES common/aka_element_classes_info.hh.in common/aka_config.hh.in ) if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.9)) package_set_compile_flags(core CXX "-Wno-undefined-var-template") endif() if(DEFINED AKANTU_CXX11_FLAGS) package_declare(core_cxx11 NOT_OPTIONAL DESCRIPTION "C++ 11 additions for Akantu core" COMPILE_FLAGS CXX "${AKANTU_CXX11_FLAGS}") if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.6") set(AKANTU_CORE_CXX11 OFF CACHE BOOL "C++ 11 additions for Akantu core - not supported by the selected compiler" FORCE) endif() endif() package_declare_documentation(core_cxx11 "This option activates some features of the C++11 standard. This is usable with GCC>=4.7 or Intel>=13.") else() if(CMAKE_VERSION VERSION_LESS 3.1) message(FATAL_ERROR "Since version 3.0 Akantu requires at least c++11 capable compiler") endif() endif() diff --git a/src/io/mesh_io.cc b/src/io/mesh_io.cc index 23e96bb8a..98ec8f084 100644 --- a/src/io/mesh_io.cc +++ b/src/io/mesh_io.cc @@ -1,147 +1,143 @@ /** * @file mesh_io.cc * * @author Guillaume Anciaux * @author Nicolas Richart * * @date creation: Fri Jun 18 2010 * @date last modification: Thu Feb 01 2018 * * @brief common part for all mesh io classes * * @section LICENSE * * Copyright (©) 2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) * * Akantu is free software: you can redistribute it and/or modify it under the * terms of the GNU Lesser General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version. * * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public License * along with Akantu. If not, see . * */ /* -------------------------------------------------------------------------- */ #include "mesh_io.hh" #include "aka_common.hh" #include "aka_iterators.hh" /* -------------------------------------------------------------------------- */ namespace akantu { /* -------------------------------------------------------------------------- */ MeshIO::MeshIO() { canReadSurface = false; canReadExtendedData = false; } /* -------------------------------------------------------------------------- */ MeshIO::~MeshIO() = default; /* -------------------------------------------------------------------------- */ std::unique_ptr MeshIO::getMeshIO(const std::string & filename, const MeshIOType & type) { MeshIOType t = type; if (type == _miot_auto) { std::string::size_type idx = filename.rfind('.'); std::string ext; if (idx != std::string::npos) { ext = filename.substr(idx + 1); } if (ext == "msh") { t = _miot_gmsh; } else if (ext == "diana") { t = _miot_diana; - } else if (ext == "inp") { - t = _miot_abaqus; } else AKANTU_EXCEPTION("Cannot guess the type of file of " << filename << " (ext " << ext << "). " << "Please provide the MeshIOType to the read function"); } switch (t) { case _miot_gmsh: return std::make_unique(); #if defined(AKANTU_STRUCTURAL_MECHANICS) case _miot_gmsh_struct: return std::make_unique(); #endif case _miot_diana: return std::make_unique(); - case _miot_abaqus: - return std::make_unique(); default: return nullptr; } } /* -------------------------------------------------------------------------- */ void MeshIO::read(const std::string & filename, Mesh & mesh, const MeshIOType & type) { std::unique_ptr mesh_io = getMeshIO(filename, type); mesh_io->read(filename, mesh); } /* -------------------------------------------------------------------------- */ void MeshIO::write(const std::string & filename, Mesh & mesh, const MeshIOType & type) { std::unique_ptr mesh_io = getMeshIO(filename, type); mesh_io->write(filename, mesh); } /* -------------------------------------------------------------------------- */ void MeshIO::constructPhysicalNames(const std::string & tag_name, Mesh & mesh) { if (!phys_name_map.empty()) { for (Mesh::type_iterator type_it = mesh.firstType(); type_it != mesh.lastType(); ++type_it) { auto & name_vec = mesh.getDataPointer("physical_names", *type_it); const auto & tags_vec = mesh.getData(tag_name, *type_it); for (auto pair : zip(tags_vec, name_vec)) { auto tag = std::get<0>(pair); auto & name = std::get<1>(pair); auto map_it = phys_name_map.find(tag); if (map_it == phys_name_map.end()) { std::stringstream sstm; sstm << tag; name = sstm.str(); } else { name = map_it->second; } } } } } /* -------------------------------------------------------------------------- */ void MeshIO::printself(std::ostream & stream, int indent) const { std::string space; for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) ; if (phys_name_map.size()) { stream << space << "Physical map:" << std::endl; for (auto & pair : phys_name_map) { stream << space << pair.first << ": " << pair.second << std::endl; } } } /* -------------------------------------------------------------------------- */ } // namespace akantu diff --git a/src/io/mesh_io.hh b/src/io/mesh_io.hh index 5ff6aa2f8..03ceb12fe 100644 --- a/src/io/mesh_io.hh +++ b/src/io/mesh_io.hh @@ -1,117 +1,116 @@ /** * @file mesh_io.hh * * @author Guillaume Anciaux * @author Nicolas Richart * * @date creation: Fri Jun 18 2010 * @date last modification: Wed Aug 09 2017 * * @brief interface of a mesh io class, reader and writer * * @section LICENSE * * Copyright (©) 2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) * * Akantu is free software: you can redistribute it and/or modify it under the * terms of the GNU Lesser General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version. * * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public License * along with Akantu. If not, see . * */ /* -------------------------------------------------------------------------- */ #ifndef __AKANTU_MESH_IO_HH__ #define __AKANTU_MESH_IO_HH__ /* -------------------------------------------------------------------------- */ #include "aka_common.hh" #include "mesh.hh" #include "mesh_accessor.hh" /* -------------------------------------------------------------------------- */ namespace akantu { class MeshIO { /* ------------------------------------------------------------------------ */ /* Constructors/Destructors */ /* ------------------------------------------------------------------------ */ public: MeshIO(); virtual ~MeshIO(); /* ------------------------------------------------------------------------ */ /* Methods */ /* ------------------------------------------------------------------------ */ public: void read(const std::string & filename, Mesh & mesh, const MeshIOType & type); void write(const std::string & filename, Mesh & mesh, const MeshIOType & type); /// read a mesh from the file virtual void read(__attribute__((unused)) const std::string & filename, __attribute__((unused)) Mesh & mesh) {} /// write a mesh to a file virtual void write(__attribute__((unused)) const std::string & filename, __attribute__((unused)) const Mesh & mesh) {} /// function to request the manual construction of the physical names maps virtual void constructPhysicalNames(const std::string & tag_name, Mesh & mesh); /// method to permit to be printed to a generic stream virtual void printself(std::ostream & stream, int indent = 0) const; /// static contruction of a meshio object static std::unique_ptr getMeshIO(const std::string & filename, const MeshIOType & type); /* ------------------------------------------------------------------------ */ /* Accessors */ /* ------------------------------------------------------------------------ */ public: std::map & getPhysicalNameMap() { return phys_name_map; } /* ------------------------------------------------------------------------ */ /* Class Members */ /* ------------------------------------------------------------------------ */ protected: bool canReadSurface; bool canReadExtendedData; /// correspondance between a tag and physical names (if applicable) std::map phys_name_map; }; /* -------------------------------------------------------------------------- */ inline std::ostream & operator<<(std::ostream & stream, const MeshIO & _this) { _this.printself(stream); return stream; } /* -------------------------------------------------------------------------- */ } // namespace akantu -#include "mesh_io_abaqus.hh" #include "mesh_io_diana.hh" #include "mesh_io_msh.hh" #if defined(AKANTU_STRUCTURAL_MECHANICS) #include "mesh_io_msh_struct.hh" #endif #endif /* __AKANTU_MESH_IO_HH__ */ diff --git a/src/io/mesh_io/mesh_io_abaqus.cc b/src/io/mesh_io/mesh_io_abaqus.cc deleted file mode 100644 index fd16133b7..000000000 --- a/src/io/mesh_io/mesh_io_abaqus.cc +++ /dev/null @@ -1,475 +0,0 @@ -/** - * @file mesh_io_abaqus.cc - * - * @author Daniel Pino Muñoz - * @author Nicolas Richart - * - * @date creation: Fri Jan 04 2013 - * @date last modification: Tue Feb 20 2018 - * - * @brief read a mesh from an abaqus input file - * - * @section LICENSE - * - * Copyright (©) 2014-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) - * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) - * - * Akantu is free software: you can redistribute it and/or modify it under the - * terms of the GNU Lesser General Public License as published by the Free - * Software Foundation, either version 3 of the License, or (at your option) any - * later version. - * - * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with Akantu. If not, see . - * - */ - -/* -------------------------------------------------------------------------- */ -// std library header files -#include - -// akantu header files -#include "mesh.hh" -#include "mesh_io_abaqus.hh" -#include "mesh_utils.hh" - -#include "element_group.hh" -#include "node_group.hh" - -#if defined(__INTEL_COMPILER) -//#pragma warning ( disable : 383 ) -#elif defined(__clang__) // test clang to be sure that when we test for gnu it -// is only gnu -#elif (defined(__GNUC__) || defined(__GNUG__)) -#define GCC_VERSION \ - (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) -#if GCC_VERSION > 40600 -#pragma GCC diagnostic push -#endif -#pragma GCC diagnostic ignored "-Wunused-local-typedefs" -#endif - -/* -------------------------------------------------------------------------- */ -#include -#include -#include -/* -------------------------------------------------------------------------- */ - -namespace akantu { - -/* -------------------------------------------------------------------------- */ -MeshIOAbaqus::MeshIOAbaqus() = default; - -/* -------------------------------------------------------------------------- */ -MeshIOAbaqus::~MeshIOAbaqus() = default; - -/* -------------------------------------------------------------------------- */ -namespace spirit = boost::spirit; -namespace qi = boost::spirit::qi; -namespace ascii = boost::spirit::ascii; -namespace lbs = boost::spirit::qi::labels; -namespace phx = boost::phoenix; - -/* -------------------------------------------------------------------------- */ -void element_read(Mesh & mesh, const ElementType & type, UInt id, - const std::vector & conn, - const std::map & nodes_mapping, - std::map & elements_mapping) { - Vector tmp_conn(Mesh::getNbNodesPerElement(type)); - - AKANTU_DEBUG_ASSERT(conn.size() == tmp_conn.size(), - "The nodes in the Abaqus file have too many coordinates" - << " for the mesh you try to fill."); - - mesh.addConnectivityType(type); - Array & connectivity = mesh.getConnectivity(type); - - UInt i = 0; - for (auto it = conn.begin(); it != conn.end(); ++it) { - auto nit = nodes_mapping.find(*it); - AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(), - "There is an unknown node in the connectivity."); - tmp_conn[i++] = nit->second; - } - Element el{type, connectivity.size(), _not_ghost}; - elements_mapping[id] = el; - connectivity.push_back(tmp_conn); -} - -void node_read(Mesh & mesh, UInt id, const std::vector & pos, - std::map & nodes_mapping) { - Vector tmp_pos(mesh.getSpatialDimension()); - UInt i = 0; - for (auto it = pos.begin(); it != pos.end() || i < mesh.getSpatialDimension(); - ++it) - tmp_pos[i++] = *it; - - nodes_mapping[id] = mesh.getNbNodes(); - mesh.getNodes().push_back(tmp_pos); -} - -/* ------------------------------------------------------------------------ */ -void add_element_to_group(ElementGroup * el_grp, UInt element, - const std::map & elements_mapping) { - auto eit = elements_mapping.find(element); - AKANTU_DEBUG_ASSERT(eit != elements_mapping.end(), - "There is an unknown element (" - << element << ") in the in the ELSET " - << el_grp->getName() << "."); - - el_grp->add(eit->second, true, false); -} - -ElementGroup * element_group_create(Mesh & mesh, const ID & name) { - auto eg_it = mesh.element_group_find(name); - if (eg_it != mesh.element_group_end()) { - return eg_it->second; - } else { - return &mesh.createElementGroup(name, _all_dimensions); - } -} - -NodeGroup * node_group_create(Mesh & mesh, const ID & name) { - auto ng_it = mesh.node_group_find(name); - if (ng_it != mesh.node_group_end()) { - return ng_it->second; - } else { - return &mesh.createNodeGroup(name, mesh.getSpatialDimension()); - } -} - -void add_node_to_group(NodeGroup * node_grp, UInt node, - const std::map & nodes_mapping) { - auto nit = nodes_mapping.find(node); - - AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(), - "There is an unknown node in the in the NSET " - << node_grp->getName() << "."); - - node_grp->add(nit->second, false); -} - -void optimize_group(NodeGroup * grp) { grp->optimize(); } -void optimize_element_group(ElementGroup * grp) { grp->optimize(); } - -/* -------------------------------------------------------------------------- */ -template struct AbaqusSkipper : qi::grammar { - AbaqusSkipper() : AbaqusSkipper::base_type(skip, "abaqus_skipper") { - /* clang-format off */ - skip - = (ascii::space - spirit::eol) - | "**" >> *(qi::char_ - spirit::eol) >> spirit::eol - ; - /* clang-format on */ - } - qi::rule skip; -}; - -/* -------------------------------------------------------------------------- */ -template > -struct AbaqusMeshGrammar : qi::grammar { -public: - AbaqusMeshGrammar(Mesh & mesh) - : AbaqusMeshGrammar::base_type(start, "abaqus_mesh_reader"), mesh(mesh) { - - /* clang-format off */ - start - = *( - (qi::char_('*') - > ( (qi::no_case[ qi::lit("node output") ] > any_section) - | (qi::no_case[ qi::lit("element output") ] > any_section) - | (qi::no_case[ qi::lit("node") ] > nodes) - | (qi::no_case[ qi::lit("element") ] > elements) - | (qi::no_case[ qi::lit("heading") ] > header) - | (qi::no_case[ qi::lit("elset") ] > elements_set) - | (qi::no_case[ qi::lit("nset") ] > nodes_set) - | (qi::no_case[ qi::lit("material") ] > material) - | (keyword > any_section) - ) - ) - | spirit::eol - ) - ; - - header - = spirit::eol - > *any_line - ; - - nodes - = *(qi::char_(',') >> option) - >> spirit::eol - >> *( (qi::int_ - > node_position) [ phx::bind(&node_read, - phx::ref(mesh), - lbs::_1, - lbs::_2, - phx::ref(abaqus_nodes_to_akantu)) ] - >> spirit::eol - ) - ; - - elements - = ( - ( qi::char_(',') >> qi::no_case[qi::lit("type")] >> '=' - >> abaqus_element_type [ lbs::_a = lbs::_1 ] - ) - ^ *(qi::char_(',') >> option) - ) - >> spirit::eol - >> *( (qi::int_ - > connectivity) [ phx::bind(&element_read, - phx::ref(mesh), - lbs::_a, - lbs::_1, - lbs::_2, - phx::cref(abaqus_nodes_to_akantu), - phx::ref(abaqus_elements_to_akantu)) ] - >> spirit::eol - ) - ; - - elements_set - = ( - ( - ( qi::char_(',') >> qi::no_case[ qi::lit("elset") ] >> '=' - >> value [ lbs::_a = phx::bind(&element_group_create, - phx::ref(mesh), - lbs::_1) ] - ) - ^ *(qi::char_(',') >> option) - ) - >> spirit::eol - >> qi::skip - (qi::char_(',') | qi::space) - [ +(qi::int_ [ phx::bind(&add_element_to_group, - lbs::_a, - lbs::_1, - phx::cref(abaqus_elements_to_akantu) - ) - ] - ) - ] - ) [ phx::bind(&optimize_element_group, lbs::_a) ] - ; - - nodes_set - = ( - ( - ( qi::char_(',') - >> qi::no_case[ qi::lit("nset") ] >> '=' - >> value [ lbs::_a = phx::bind(&node_group_create, phx::ref(mesh), lbs::_1) ] - ) - ^ *(qi::char_(',') >> option) - ) - >> spirit::eol - >> qi::skip - (qi::char_(',') | qi::space) - [ +(qi::int_ [ phx::bind(&add_node_to_group, - lbs::_a, - lbs::_1, - phx::cref(abaqus_nodes_to_akantu) - ) - ] - ) - ] - ) [ phx::bind(&optimize_group, lbs::_a) ] - ; - - material - = ( - ( qi::char_(',') >> qi::no_case[ qi::lit("name") ] >> '=' - >> value [ phx::push_back(phx::ref(material_names), lbs::_1) ] - ) - ^ *(qi::char_(',') >> option) - ) >> spirit::eol; - ; - - node_position - = +(qi::char_(',') > real [ phx::push_back(lbs::_val, lbs::_1) ]) - ; - - connectivity - = +(qi::char_(',') > qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ]) - ; - - - any_section - = *(qi::char_(',') >> option) > spirit::eol - > *any_line - ; - - any_line - = *(qi::char_ - spirit::eol - qi::char_('*')) >> spirit::eol - ; - - keyword - = qi::lexeme[ +(qi::char_ - (qi::char_('*') | spirit::eol)) ] - ; - - option - = key > -( '=' >> value ); - - key - = qi::char_("a-zA-Z_") >> *(qi::char_("a-zA-Z_0-9") | qi::char_('-')) - ; - - value - = key.alias() - ; - - BOOST_SPIRIT_DEBUG_NODE(start); - - abaqus_element_type.add -#if defined(AKANTU_STRUCTURAL_MECHANICS) - ("BE21" , _bernoulli_beam_2) - ("BE31" , _bernoulli_beam_3) -#endif - ("T3D2" , _segment_2) // Gmsh generates this elements - ("T3D3" , _segment_3) // Gmsh generates this elements - ("CPE3" , _triangle_3) - ("CPS3" , _triangle_3) - ("DC2D3" , _triangle_3) - ("CPE6" , _triangle_6) - ("CPS6" , _triangle_6) - ("DC2D6" , _triangle_6) - ("CPE4" , _quadrangle_4) - ("CPS4" , _quadrangle_4) - ("DC2D4" , _quadrangle_4) - ("CPE8" , _quadrangle_8) - ("CPS8" , _quadrangle_8) - ("DC2D8" , _quadrangle_8) - ("C3D4" , _tetrahedron_4) - ("DC3D4" , _tetrahedron_4) - ("C3D8" , _hexahedron_8) - ("C3D8R" , _hexahedron_8) - ("DC3D8" , _hexahedron_8) - ("C3D10" , _tetrahedron_10) - ("DC3D10", _tetrahedron_10); - -#if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11) - qi::on_error(start, error_handler(lbs::_4, lbs::_3, lbs::_2)); -#endif - - start .name("abaqus-start-rule"); - connectivity .name("abaqus-connectivity"); - node_position .name("abaqus-nodes-position"); - nodes .name("abaqus-nodes"); - any_section .name("abaqus-any_section"); - header .name("abaqus-header"); - material .name("abaqus-material"); - elements .name("abaqus-elements"); - elements_set .name("abaqus-elements-set"); - nodes_set .name("abaqus-nodes-set"); - key .name("abaqus-key"); - value .name("abaqus-value"); - option .name("abaqus-option"); - keyword .name("abaqus-keyword"); - any_line .name("abaqus-any-line"); - abaqus_element_type.name("abaqus-element-type"); - - /* clang-format on */ - } - -public: - AKANTU_GET_MACRO(MaterialNames, material_names, - const std::vector &); - - /* ------------------------------------------------------------------------ */ - /* Rules */ - /* ------------------------------------------------------------------------ */ -private: - qi::rule start; - qi::rule(), Skipper> connectivity; - qi::rule(), Skipper> node_position; - qi::rule nodes, any_section, header, material; - qi::rule, Skipper> elements; - qi::rule, Skipper> elements_set; - qi::rule, Skipper> nodes_set; - - qi::rule key, value, option, keyword, - any_line; - - qi::real_parser> real; - - qi::symbols abaqus_element_type; - - /* ------------------------------------------------------------------------ */ - /* Mambers */ - /* ------------------------------------------------------------------------ */ -private: - /// reference to the mesh to read - Mesh & mesh; - - /// correspondance between the numbering of nodes in the abaqus file and in - /// the akantu mesh - std::map abaqus_nodes_to_akantu; - - /// correspondance between the element number in the abaqus file and the - /// Element in the akantu mesh - std::map abaqus_elements_to_akantu; - - /// list of the material names - std::vector material_names; -}; -/* -------------------------------------------------------------------------- */ - -/* -------------------------------------------------------------------------- */ -void MeshIOAbaqus::read(const std::string & filename, Mesh & mesh) { - namespace spirit = boost::spirit; - namespace qi = boost::spirit::qi; - namespace lbs = boost::spirit::qi::labels; - namespace ascii = boost::spirit::ascii; - namespace phx = boost::phoenix; - - std::ifstream infile; - infile.open(filename.c_str()); - - if (!infile.good()) { - AKANTU_ERROR("Cannot open file " << filename); - } - - std::string storage; // We will read the contents here. - infile.unsetf(std::ios::skipws); // No white space skipping! - std::copy(std::istream_iterator(infile), std::istream_iterator(), - std::back_inserter(storage)); - - using iterator_t = std::string::const_iterator; - using skipper = AbaqusSkipper; - using grammar = AbaqusMeshGrammar; - - grammar g(mesh); - skipper ws; - - iterator_t iter = storage.begin(); - iterator_t end = storage.end(); - - qi::phrase_parse(iter, end, g, ws); - - MeshAccessor mesh_accessor(mesh); - - for (auto & mat_name : g.getMaterialNames()) { - auto eg_it = mesh.element_group_find(mat_name); - auto & eg = *eg_it->second; - if (eg_it != mesh.element_group_end()) { - for (auto & type : eg.elementTypes()) { - Array & abaqus_material = - mesh_accessor.getData("abaqus_material", type); - - for (auto elem : eg.getElements(type)) { - abaqus_material(elem) = mat_name; - } - } - } - } - - mesh_accessor.setNbGlobalNodes(mesh.getNodes().size()); - MeshUtils::fillElementToSubElementsData(mesh); -} - -} // namespace akantu diff --git a/src/io/mesh_io/mesh_io_abaqus.hh b/src/io/mesh_io/mesh_io_abaqus.hh deleted file mode 100644 index 305eb2d93..000000000 --- a/src/io/mesh_io/mesh_io_abaqus.hh +++ /dev/null @@ -1,59 +0,0 @@ -/** - * @file mesh_io_abaqus.hh - * - * @author Nicolas Richart - * - * @date creation: Sun Sep 26 2010 - * @date last modification: Wed Nov 08 2017 - * - * @brief read a mesh from an abaqus input file - * - * @section LICENSE - * - * Copyright (©) 2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) - * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) - * - * Akantu is free software: you can redistribute it and/or modify it under the - * terms of the GNU Lesser General Public License as published by the Free - * Software Foundation, either version 3 of the License, or (at your option) any - * later version. - * - * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with Akantu. If not, see . - * - */ - -/* -------------------------------------------------------------------------- */ -#include "mesh_accessor.hh" -#include "mesh_io.hh" - -#ifndef __AKANTU_MESH_IO_ABAQUS_HH__ -#define __AKANTU_MESH_IO_ABAQUS_HH__ - -namespace akantu { - -/* -------------------------------------------------------------------------- */ -class MeshIOAbaqus : public MeshIO { -public: - MeshIOAbaqus(); - ~MeshIOAbaqus() override; - - /// read a mesh from the file - void read(const std::string & filename, Mesh & mesh) override; - - /// write a mesh to a file - // virtual void write(const std::string & filename, const Mesh & mesh); - -private: - /// correspondence between msh element types and akantu element types - std::map _abaqus_to_akantu_element_types; -}; - -} // akantu - -#endif /* __AKANTU_MESH_IO_ABAQUS_HH__ */