Line data    Source code

       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : 
      19             : 
      20             : #ifndef LIBMESH_MEDIT_IO_H
      21             : #define LIBMESH_MEDIT_IO_H
      22             : 
      23             : // Local includes
      24             : #include "libmesh/libmesh_common.h"
      25             : #include "libmesh/mesh_output.h"
      26             : 
      27             : // C++ includes
      28             : #include <cstddef>
      29             : 
      30             : namespace libMesh
      31             : {
      32             : 
      33             : // Forward declarations:
      34             : class MeshBase;
      35             : 
      36             : /**
      37             :  * This class implements writing meshes in the mesh format
      38             :  * used by the MEdit visualization tool developed in the Gamma Project
      39             :  * at INRIA Roquencourt.
      40             :  * For a full description of the mesh format and to obtain the
      41             :  * MEdit software see the
      42             :  * <a href="http://www-rocq1.inria.fr/gamma/medit/medit.html">MEdit home page</a>.
      43             :  *
      44             :  * \author Florian Prill
      45             :  * \date 2004
      46             :  */
      47             : class MEDITIO : public MeshOutput<MeshBase>
      48             : {
      49             : public:
      50             : 
      51             :   /**
      52             :    * Constructor.  Takes a reference to a constant mesh object.
      53             :    * This constructor will only allow us to write the mesh.
      54             :    */
      55             :   explicit
      56             :   MEDITIO (const MeshBase &);
      57             : 
      58             :   /**
      59             :    * Constructor.  Takes a reference to a constant mesh object.
      60             :    * and the desired scalar index for mesh colouring.
      61             :    * MEdit seems to understand only one scalar value.
      62             :    */
      63             :   MEDITIO (const MeshBase &, unsigned int c);
      64             : 
      65             :   /**
      66             :    * This method implements writing a mesh to a specified ".mesh" file.
      67             :    */
      68             :   virtual void write (const std::string &) override;
      69             : 
      70             :   /**
      71             :    * Bring in base class functionality for name resolution and to
      72             :    * avoid warnings about hidden overloaded virtual functions.
      73             :    */
      74             :   using MeshOutput<MeshBase>::write_nodal_data;
      75             : 
      76             :   /**
      77             :    * This method implements writing a mesh with nodal data to a
      78             :    * specified file where the nodal data and variable names are provided.
      79             :    */
      80             :   virtual void write_nodal_data (const std::string &,
      81             :                                  const std::vector<Number> &,
      82             :                                  const std::vector<std::string> &) override;
      83             : 
      84             :   /**
      85             :    * Flag indicating whether or not to write a binary file
      86             :    */
      87             :   bool & binary ();
      88             : 
      89             : private:
      90             : 
      91             :   /**
      92             :    * This method implements writing a mesh with nodal data to a
      93             :    * specified file where the nodal data and variable names are optionally
      94             :    * provided.  This will write an ASCII file.
      95             :    */
      96             :   void write_ascii (const std::string &,
      97             :                     const std::vector<Number> * = nullptr,
      98             :                     const std::vector<std::string> * = nullptr);
      99             : 
     100             :   /**
     101             :    * Flag to write binary data.
     102             :    */
     103             :   bool _binary;
     104             : 
     105             :   unsigned int scalar_idx;
     106             : };
     107             : 
     108             : 
     109             : 
     110             : // ------------------------------------------------------------
     111             : // medit_io inline members
     112             : inline
     113           0 : MEDITIO::MEDITIO (const MeshBase & mesh_in) :
     114             :   MeshOutput<MeshBase> (mesh_in),
     115           0 :   _binary (false),
     116           0 :   scalar_idx (0)
     117             : {
     118           0 : }
     119             : 
     120             : inline
     121             : MEDITIO::MEDITIO (const MeshBase & mesh_in, unsigned int c) :
     122             :   MeshOutput<MeshBase> (mesh_in),
     123             :   _binary    (false),
     124             :   scalar_idx (c)
     125             : {
     126             : }
     127             : 
     128             : 
     129             : inline
     130           0 : bool & MEDITIO::binary ()
     131             : {
     132           0 :   return _binary;
     133             : }
     134             : 
     135             : 
     136             : } // namespace libMesh
     137             : 
     138             : 
     139             : #endif // LIBMESH_MEDIT_IO_H