libMesh
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
libMesh::FroIO Class Reference

This class implements writing meshes in the .fro format used by the MIT ACDL. More...

#include <fro_io.h>

Inheritance diagram for libMesh::FroIO:
[legend]

Public Member Functions

 FroIO (const MeshBase &)
 Constructor. More...
 
virtual void write (const std::string &) libmesh_override
 This method implements writing a mesh to a specified file. More...
 
virtual void write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=libmesh_nullptr)
 This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object. More...
 
virtual void write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
 This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided. More...
 
virtual void write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
 This method should be overridden by "parallel" output formats for writing nodal data. More...
 
unsigned intascii_precision ()
 Return/set the precision to use when writing ASCII files. More...
 

Protected Member Functions

const MeshBasemesh () const
 

Protected Attributes

const bool _is_parallel_format
 Flag specifying whether this format is parallel-capable. More...
 
const bool _serial_only_needed_on_proc_0
 Flag specifying whether this format can be written by only serializing the mesh to processor zero. More...
 

Detailed Description

This class implements writing meshes in the .fro format used by the MIT ACDL.

Valid only for triangular meshes.

Author
Benjamin S. Kirk
Date
2007

Definition at line 42 of file fro_io.h.

Constructor & Destructor Documentation

libMesh::FroIO::FroIO ( const MeshBase mesh_in)
explicit

Constructor.

Takes a reference to a constant mesh object. This constructor will only allow us to write the mesh.

Definition at line 64 of file fro_io.h.

64  :
65  MeshOutput<MeshBase> (mesh_in)
66 {
67 }

Member Function Documentation

unsigned int& libMesh::MeshOutput< MeshBase >::ascii_precision ( )
inherited

Return/set the precision to use when writing ASCII files.

By default we use numeric_limits<Real>::digits10 + 2, which should be enough to write out to ASCII and get the exact same Real back when reading in.

Referenced by libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

const MeshBase & libMesh::MeshOutput< MeshBase >::mesh ( ) const
protectedinherited
void libMesh::FroIO::write ( const std::string &  fname)
virtual

This method implements writing a mesh to a specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 41 of file fro_io.C.

References libMesh::MeshOutput< MeshBase >::_is_parallel_format, libMesh::MeshBase::active_element_ptr_range(), bc_id, libMesh::BoundaryInfo::build_side_list(), libMesh::Elem::build_side_ptr(), libMesh::MeshBase::elem_ref(), libMesh::BoundaryInfo::get_boundary_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::libmesh_assert(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshOutput< MeshBase >::mesh(), libMesh::BoundaryInfo::n_boundary_ids(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::point(), libMesh::processor_id(), side, and libMesh::TRI3.

Referenced by libMesh::NameBasedIO::write().

42 {
43  // We may need to gather a DistributedMesh to output it, making that
44  // const qualifier in our constructor a dirty lie
45  MeshSerializer serialize(const_cast<MeshBase &>(this->mesh()), !_is_parallel_format);
46 
47  if (this->mesh().processor_id() == 0)
48  {
49  // Open the output file stream
50  std::ofstream out_stream (fname.c_str());
51  libmesh_assert (out_stream.good());
52 
53  // Make sure it opened correctly
54  if (!out_stream.good())
55  libmesh_file_error(fname.c_str());
56 
57  // Get a reference to the mesh
58  const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
59 
60  // Write the header
61  out_stream << the_mesh.n_elem() << " "
62  << the_mesh.n_nodes() << " "
63  << "0 0 "
64  << the_mesh.get_boundary_info().n_boundary_ids() << " 1\n";
65 
66  // Write the nodes -- 1-based!
67  for (unsigned int n=0; n<the_mesh.n_nodes(); n++)
68  out_stream << n+1 << " \t"
69  << std::scientific
70  << std::setprecision(12)
71  << the_mesh.point(n)(0) << " \t"
72  << the_mesh.point(n)(1) << " \t"
73  << 0. << '\n';
74 
75  // Write the elements -- 1-based!
76  unsigned int e = 0;
77  for (const auto & elem : the_mesh.active_element_ptr_range())
78  {
79  // .fro likes TRI3's
80  if (elem->type() != TRI3)
81  libmesh_error_msg("ERROR: .fro format only valid for triangles!\n" \
82  << " writing of " << fname << " aborted.");
83 
84  out_stream << ++e << " \t";
85 
86  for (unsigned int n=0; n<elem->n_nodes(); n++)
87  out_stream << elem->node_id(n)+1 << " \t";
88 
89  // // LHS -> RHS Mapping, for inverted triangles
90  // out_stream << elem->node_id(0)+1 << " \t";
91  // out_stream << elem->node_id(2)+1 << " \t";
92  // out_stream << elem->node_id(1)+1 << " \t";
93 
94  out_stream << "1\n";
95  }
96 
97  // Write BCs.
98  {
99  const std::set<boundary_id_type> & bc_ids =
100  the_mesh.get_boundary_info().get_boundary_ids();
101 
102  std::vector<dof_id_type> el;
103  std::vector<unsigned short int> sl;
104  std::vector<boundary_id_type> il;
105 
106  the_mesh.get_boundary_info().build_side_list (el, sl, il);
107 
108 
109  // Map the boundary ids into [1,n_bc_ids],
110  // treat them one at a time.
112  for (std::set<boundary_id_type>::const_iterator id = bc_ids.begin();
113  id != bc_ids.end(); ++id)
114  {
115  std::deque<dof_id_type> node_list;
116 
117  std::map<dof_id_type, dof_id_type>
118  forward_edges, backward_edges;
119 
120  // Get all sides on this element with the relevant BC id.
121  for (std::size_t e=0; e<el.size(); e++)
122  if (il[e] == *id)
123  {
124  // need to build up node_list as a sorted array of edge nodes...
125  // for the following:
126  // a---b---c---d---e
127  // node_list [ a b c d e];
128  //
129  // the issue is just how to get this out of the elem/side based data structure.
130  // the approach is to build up 'chain links' like this:
131  // a---b b---c c---d d---e
132  // and piece them together.
133  //
134  // so, for an arbitrary edge n0---n1, we build the
135  // "forward_edges" map n0-->n1
136  // "backward_edges" map n1-->n0
137  // and then start with one chain link, and add on...
138  //
139  UniquePtr<const Elem> side =
140  the_mesh.elem_ref(el[e]).build_side_ptr(sl[e]);
141 
142  const dof_id_type
143  n0 = side->node_id(0),
144  n1 = side->node_id(1);
145 
146  // insert into forward-edge set
147  forward_edges.insert (std::make_pair(n0, n1));
148 
149  // insert into backward-edge set
150  backward_edges.insert (std::make_pair(n1, n0));
151 
152  // go ahead and add one edge to the list -- this will give us the beginning of a
153  // chain to work from!
154  if (node_list.empty())
155  {
156  node_list.push_front(n0);
157  node_list.push_back (n1);
158  }
159  }
160 
161  // we now have the node_list with one edge, the forward_edges, and the backward_edges
162  // the node_list will be filled when (node_list.size() == (n_edges+1))
163  // until that is the case simply add on to the beginning and end of the node_list,
164  // building up a chain of ordered nodes...
165  const std::size_t n_edges = forward_edges.size();
166 
167  while (node_list.size() != (n_edges+1))
168  {
169  const dof_id_type
170  front_node = node_list.front(),
171  back_node = node_list.back();
172 
173  // look for front_pair in the backward_edges list
174  {
175  std::map<dof_id_type, dof_id_type>::iterator
176  pos = backward_edges.find(front_node);
177 
178  if (pos != backward_edges.end())
179  {
180  node_list.push_front(pos->second);
181 
182  backward_edges.erase(pos);
183  }
184  }
185 
186  // look for back_pair in the forward_edges list
187  {
188  std::map<dof_id_type, dof_id_type>::iterator
189  pos = forward_edges.find(back_node);
190 
191  if (pos != forward_edges.end())
192  {
193  node_list.push_back(pos->second);
194 
195  forward_edges.erase(pos);
196  }
197  }
198 
199  // libMesh::out << "node_list.size()=" << node_list.size()
200  // << ", n_edges+1=" << n_edges+1 << std::endl;
201  }
202 
203 
204  out_stream << ++bc_id << " " << node_list.size() << '\n';
205 
206  std::deque<dof_id_type>::iterator pos = node_list.begin();
207  for ( ; pos != node_list.end(); ++pos)
208  out_stream << *pos+1 << " \t0\n";
209  }
210  }
211  }
212 }
const bool _is_parallel_format
Flag specifying whether this format is parallel-capable.
Definition: mesh_output.h:141
unsigned short int side
Definition: xdr_io.C:49
const MeshBase & mesh() const
boundary_id_type bc_id
Definition: xdr_io.C:50
libmesh_assert(j)
int8_t boundary_id_type
Definition: id_types.h:51
processor_id_type processor_id()
Definition: libmesh_base.h:96
uint8_t dof_id_type
Definition: id_types.h:64
virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  ,
const EquationSystems ,
const std::set< std::string > *  system_names = libmesh_nullptr 
)
virtualinherited

This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.

Reimplemented in libMesh::NameBasedIO.

Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_IO::write_timestep().

virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  ,
const std::vector< Number > &  ,
const std::vector< std::string > &   
)
virtualinherited

This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.

Reimplemented in libMesh::ExodusII_IO, libMesh::NameBasedIO, libMesh::GmshIO, libMesh::Nemesis_IO, libMesh::VTKIO, libMesh::UCDIO, libMesh::GMVIO, libMesh::MEDITIO, libMesh::GnuPlotIO, and libMesh::TecplotIO.

Definition at line 96 of file mesh_output.h.

References libMesh::MeshOutput< MT >::ascii_precision(), libMesh::MeshOutput< MT >::mesh(), and libMesh::MeshOutput< MT >::write_nodal_data().

99  { libmesh_not_implemented(); }
virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  ,
const NumericVector< Number > &  ,
const std::vector< std::string > &   
)
virtualinherited

This method should be overridden by "parallel" output formats for writing nodal data.

Instead of getting a localized copy of the nodal solution vector, it is passed a NumericVector of type=PARALLEL which is in node-major order i.e. (u0,v0,w0, u1,v1,w1, u2,v2,w2, u3,v3,w3, ...) and contains n_nodes*n_vars total entries. Then, it is up to the individual I/O class to extract the required solution values from this vector and write them in parallel.

If not implemented, localizes the parallel vector into a std::vector and calls the other version of this function.

Reimplemented in libMesh::Nemesis_IO.

Member Data Documentation

const bool libMesh::MeshOutput< MeshBase >::_is_parallel_format
protectedinherited

Flag specifying whether this format is parallel-capable.

If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 141 of file mesh_output.h.

Referenced by write(), libMesh::PostscriptIO::write(), and libMesh::EnsightIO::write().

const bool libMesh::MeshOutput< MeshBase >::_serial_only_needed_on_proc_0
protectedinherited

Flag specifying whether this format can be written by only serializing the mesh to processor zero.

If this is false (default) the mesh will be serialized to all processors

Definition at line 150 of file mesh_output.h.


The documentation for this class was generated from the following files: