exodusII_io.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2014 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 // C++ includes
20 #include <fstream>
21 #include <cstring>
22 
23 // Local includes
24 #include "libmesh/exodusII_io.h"
25 #include "libmesh/boundary_info.h"
26 #include "libmesh/mesh_base.h"
27 #include "libmesh/enum_elem_type.h"
28 #include "libmesh/elem.h"
31 #include "libmesh/system.h"
32 #include "libmesh/numeric_vector.h"
34 
35 namespace libMesh
36 {
37 
38 // ------------------------------------------------------------
39 // ExodusII_IO class members
41  MeshInput<MeshBase> (mesh),
42  MeshOutput<MeshBase> (mesh),
43  ParallelObject(mesh),
44 #ifdef LIBMESH_HAVE_EXODUS_API
45  exio_helper(new ExodusII_IO_Helper(*this)),
46 #endif
47  _timestep(1),
48  _verbose(false),
49  _append(false),
50  _allow_empty_variables(false)
51 {
52 }
53 
54 
55 void ExodusII_IO::set_output_variables(const std::vector<std::string> & output_variables, bool allow_empty)
56 {
57  _output_variables = output_variables;
58  _allow_empty_variables = allow_empty;
59 }
60 
61 
62 
63 void ExodusII_IO::copy_nodal_solution(System& system, std::string var_name, unsigned int timestep)
64 {
65  libmesh_deprecated();
66  copy_nodal_solution(system, var_name, var_name, timestep);
67 }
68 
69 
70 
72 {
73  std::vector<std::string> solution_names;
74  std::vector<Number> v;
75 
76  es.build_variable_names (solution_names);
78 
79  this->write_nodal_data_discontinuous(name, v, solution_names);
80 }
81 
82 
83 
84 
85 // ------------------------------------------------------------
86 // When the Exodus API is present...
87 #ifdef LIBMESH_HAVE_EXODUS_API
88 
90 {
91  exio_helper->close();
92  delete exio_helper;
93 }
94 
95 
96 
97 void ExodusII_IO::read (const std::string& fname)
98 {
99  // Get a reference to the mesh we are reading
101 
102  // Clear any existing mesh data
103  mesh.clear();
104 
105  // Keep track of what kinds of elements this file contains
106  elems_of_dimension.clear();
107  elems_of_dimension.resize(4, false);
108 
109 #ifdef DEBUG
110  this->verbose(true);
111 #endif
112 
113  // Instantiate the ElementMaps interface
115 
116  // Open the exodus file in EX_READ mode
117  exio_helper->open(fname.c_str(), /*read_only=*/true);
118 
119  // Get header information from exodus file
121 
122  // Print header information
124 
125  // Read nodes from the exodus file
127 
128  // Reserve space for the nodes.
130 
131  // Read the node number map from the Exodus file. This is
132  // required if we want to preserve the numbering of nodes as it
133  // exists in the Exodus file. If the Exodus file does not contain
134  // a node_num_map, the identity map is returned by this call.
136 
137  // Loop over the nodes, create Nodes with local processor_id 0.
138  for (int i=0; i<exio_helper->num_nodes; i++)
139  {
140  // Use the node_num_map to get the correct ID for Exodus
141  int exodus_id = exio_helper->node_num_map[i];
142 
143  // Catch the node that was added to the mesh
144  Node* added_node = mesh.add_point (Point(exio_helper->x[i], exio_helper->y[i], exio_helper->z[i]), exodus_id-1);
145 
146  // If the Mesh assigned an ID different from what is in the
147  // Exodus file, we should probably error.
148  if (added_node->id() != static_cast<unsigned>(exodus_id-1))
149  {
150  libMesh::err << "Error! Mesh assigned node ID "
151  << added_node->id()
152  << " which is different from the (zero-based) Exodus ID "
153  << exodus_id-1
154  << "!"
155  << std::endl;
156  libmesh_error();
157  }
158  }
159 
160  // This assert is no longer valid if the nodes are not numbered
161  // sequentially starting from 1 in the Exodus file.
162  // libmesh_assert_equal_to (static_cast<unsigned int>(exio_helper->num_nodes), mesh.n_nodes());
163 
164  // Get information about all the blocks
166 
167  // Reserve space for the elements
169 
170  // Read the element number map from the Exodus file. This is
171  // required if we want to preserve the numbering of elements as it
172  // exists in the Exodus file. If the Exodus file does not contain
173  // an elem_num_map, the identity map is returned by this call.
175 
176  // Read in the element connectivity for each block.
177  int nelem_last_block = 0;
178 
179  // Loop over all the blocks
180  for (int i=0; i<exio_helper->num_elem_blk; i++)
181  {
182  // Read the information for block i
184  int subdomain_id = exio_helper->get_block_id(i);
185 
186  // populate the map of names
187  std::string subdomain_name = exio_helper->get_block_name(i);
188  if (!subdomain_name.empty())
189  mesh.subdomain_name(static_cast<subdomain_id_type>(subdomain_id)) = subdomain_name;
190 
191  // Set any relevant node/edge maps for this element
192  const std::string type_str (exio_helper->get_elem_type());
193  const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(type_str);
194 
195  // Loop over all the faces in this block
196  int jmax = nelem_last_block+exio_helper->num_elem_this_blk;
197  for (int j=nelem_last_block; j<jmax; j++)
198  {
199  Elem* elem = Elem::build (conv.get_canonical_type()).release();
200  libmesh_assert (elem);
201  elem->subdomain_id() = static_cast<subdomain_id_type>(subdomain_id) ;
202 
203  // Use the elem_num_map to obtain the ID of this element in the Exodus file
204  int exodus_id = exio_helper->elem_num_map[j];
205 
206  // Assign this element the same ID it had in the Exodus
207  // file, but make it zero-based by subtracting 1. Note:
208  // some day we could use 1-based numbering in libmesh and
209  // thus match the Exodus numbering exactly, but at the
210  // moment libmesh is zero-based.
211  elem->set_id(exodus_id-1);
212 
213  // Record that we have seen an element of dimension elem->dim()
214  elems_of_dimension[elem->dim()] = true;
215 
216  // Catch the Elem pointer that the Mesh throws back
217  elem = mesh.add_elem (elem);
218 
219  // If the Mesh assigned an ID different from what is in the
220  // Exodus file, we should probably error.
221  if (elem->id() != static_cast<unsigned>(exodus_id-1))
222  {
223  libMesh::err << "Error! Mesh assigned ID "
224  << elem->id()
225  << " which is different from the (zero-based) Exodus ID "
226  << exodus_id-1
227  << "!"
228  << std::endl;
229  libmesh_error();
230  }
231 
232  // Set all the nodes for this element
233  for (int k=0; k<exio_helper->num_nodes_per_elem; k++)
234  {
235  // global index
236  int gi = (j-nelem_last_block)*exio_helper->num_nodes_per_elem + conv.get_node_map(k);
237 
238  // The entries in 'connect' are actually (1-based)
239  // indices into the node_num_map, so to get the right
240  // node ID we:
241  // 1.) Subtract 1 from connect[gi]
242  // 2.) Pass it through node_num_map to get the corresponding Exodus ID
243  // 3.) Subtract 1 from that, since libmesh node numbering is "zero"-based,
244  // even when the Exodus node numbering doesn't start with 1.
245  int libmesh_node_id = exio_helper->node_num_map[exio_helper->connect[gi] - 1] - 1;
246 
247  // Set the node pointer in the Elem
248  elem->set_node(k) = mesh.node_ptr(libmesh_node_id);
249  }
250  }
251 
252  // running sum of # of elements per block,
253  // (should equal total number of elements in the end)
254  nelem_last_block += exio_helper->num_elem_this_blk;
255  }
256 
257  // This assert isn't valid if the Exodus file's numbering doesn't
258  // start with 1! For example, if Exodus's elem_num_map is 21, 22,
259  // 23, 24, 25, 26, 27, 28, 29, 30, ... 84, then by the time you are
260  // done with the loop above, mesh.n_elem() will report 84 and
261  // nelem_last_block will be 64.
262  // libmesh_assert_equal_to (static_cast<unsigned>(nelem_last_block), mesh.n_elem());
263 
264  // Set the mesh dimension to the largest encountered for an element
265  for (unsigned int i=0; i!=4; ++i)
266  if (elems_of_dimension[i])
267  mesh.set_mesh_dimension(i);
268 
269  // Read in sideset information -- this is useful for applying boundary conditions
270  {
271  // Get basic information about all sidesets
273  int offset=0;
274  for (int i=0; i<exio_helper->num_side_sets; i++)
275  {
276  // Compute new offset
277  offset += (i > 0 ? exio_helper->num_sides_per_set[i-1] : 0);
278  exio_helper->read_sideset (i, offset);
279 
280  std::string sideset_name = exio_helper->get_side_set_name(i);
281  if (!sideset_name.empty())
282  mesh.boundary_info->sideset_name(exio_helper->get_side_set_id(i)) = sideset_name;
283  }
284 
285  for (unsigned int e=0; e<exio_helper->elem_list.size(); e++)
286  {
287  // The numbers in the Exodus file sidesets should be thought
288  // of as (1-based) indices into the elem_num_map array. So,
289  // to get the right element ID we have to:
290  // 1.) Subtract 1 from elem_list[e] (to get a zero-based index)
291  // 2.) Pass it through elem_num_map (to get the corresponding Exodus ID)
292  // 3.) Subtract 1 from that, since libmesh is "zero"-based,
293  // even when the Exodus numbering doesn't start with 1.
294  int libmesh_elem_id = exio_helper->elem_num_map[exio_helper->elem_list[e] - 1] - 1;
295 
296  // Set any relevant node/edge maps for this element
297  Elem * elem = mesh.elem(libmesh_elem_id);
298 
299  const ExodusII_IO_Helper::Conversion conv = em.assign_conversion(elem->type());
300 
301  // Add this (elem,side,id) triplet to the BoundaryInfo object.
302  mesh.boundary_info->add_side (libmesh_elem_id,
303  conv.get_side_map(exio_helper->side_list[e]-1),
304  exio_helper->id_list[e]);
305  }
306  }
307 
308  // Read nodeset info
309  {
311 
312  for (int nodeset=0; nodeset<exio_helper->num_node_sets; nodeset++)
313  {
314  int nodeset_id = exio_helper->nodeset_ids[nodeset];
315 
316  std::string nodeset_name = exio_helper->get_node_set_name(nodeset);
317  if (!nodeset_name.empty())
318  mesh.boundary_info->nodeset_name(nodeset_id) = nodeset_name;
319 
320  exio_helper->read_nodeset(nodeset);
321 
322  for (unsigned int node=0; node<exio_helper->node_list.size(); node++)
323  {
324  // As before, the entries in 'node_list' are 1-based
325  // indcies into the node_num_map array, so we have to map
326  // them. See comment above.
327  int libmesh_node_id = exio_helper->node_num_map[exio_helper->node_list[node] - 1] - 1;
328  mesh.boundary_info->add_node(libmesh_node_id, nodeset_id);
329  }
330  }
331  }
332 
333 #if LIBMESH_DIM < 3
334  if (mesh.mesh_dimension() > LIBMESH_DIM)
335  {
336  libMesh::err << "Cannot open dimension " <<
337  mesh.mesh_dimension() <<
338  " mesh file when configured without " <<
339  mesh.mesh_dimension() << "D support." <<
340  std::endl;
341  libmesh_error();
342  }
343 #endif
344 }
345 
346 
347 
348 void ExodusII_IO::verbose (bool set_verbosity)
349 {
350  _verbose = set_verbosity;
351 
352  // Set the verbose flag in the helper object as well.
354 }
355 
356 
357 
359 {
361 }
362 
363 
364 
366 {
367  libmesh_deprecated();
369 }
370 
371 
372 
373 void ExodusII_IO::append(bool val)
374 {
375  _append = val;
376 }
377 
378 
379 
380 const std::vector<Real>& ExodusII_IO::get_time_steps()
381 {
383  {
384  libMesh::err << "ERROR, ExodusII file must be opened for reading before calling ExodusII_IO::get_time_steps()!" << std::endl;
385  libmesh_error();
386  }
387 
389  return exio_helper->time_steps;
390 }
391 
392 
393 
395 {
397  {
398  libMesh::err << "ERROR, ExodusII file must be opened for reading or writing before calling ExodusII_IO::get_num_time_steps()!" << std::endl;
399  libmesh_error();
400  }
401 
403  return exio_helper->num_time_steps;
404 }
405 
406 
407 
408 void ExodusII_IO::copy_nodal_solution(System& system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep)
409 {
411  {
412  libMesh::err << "ERROR, ExodusII file must be opened for reading before copying a nodal solution!" << std::endl;
413  libmesh_error();
414  }
415 
416  exio_helper->read_nodal_var_values(exodus_var_name, timestep);
417 
418  const unsigned int var_num = system.variable_number(system_var_name);
419 
420  for (unsigned int i=0; i<exio_helper->nodal_var_values.size(); ++i)
421  {
422  const Node* node = MeshInput<MeshBase>::mesh().query_node_ptr(i);
423 
424  if (!node)
425  {
426  libMesh::err << "Error! Mesh returned NULL pointer for node " << i << std::endl;
427  libmesh_error();
428  }
429 
430  dof_id_type dof_index = node->dof_number(system.number(), var_num, 0);
431 
432  // If the dof_index is local to this processor, set the value
433  if ((dof_index >= system.solution->first_local_index()) && (dof_index < system.solution->last_local_index()))
434  system.solution->set (dof_index, exio_helper->nodal_var_values[i]);
435  }
436 
437  system.solution->close();
438  system.update();
439 }
440 
441 
442 
443 void ExodusII_IO::copy_elemental_solution(System& system, std::string system_var_name, std::string exodus_var_name, unsigned int timestep)
444 {
446  {
447  libMesh::err << "ERROR, ExodusII file must be opened for reading before copying an elemental solution!" << std::endl;
448  libmesh_error();
449  }
450 
451  exio_helper->read_elemental_var_values(exodus_var_name, timestep);
452 
453  const unsigned int var_num = system.variable_number(system_var_name);
454  if (system.variable_type(var_num) != FEType(CONSTANT, MONOMIAL))
455  {
456  libMesh::err << "Error! Trying to copy elemental solution into a variable that is not of CONSTANT MONOMIAL type. " << std::endl;
457  libmesh_error();
458  }
459 
460  for (unsigned int i=0; i<exio_helper->elem_var_values.size(); ++i)
461  {
462  const Elem * elem = MeshInput<MeshBase>::mesh().query_elem(i);
463 
464  if (!elem)
465  {
466  libMesh::err << "Error! Mesh returned NULL pointer for elem " << i << std::endl;
467  libmesh_error();
468  }
469 
470  dof_id_type dof_index = elem->dof_number(system.number(), var_num, 0);
471 
472  // If the dof_index is local to this processor, set the value
473  if ((dof_index >= system.solution->first_local_index()) && (dof_index < system.solution->last_local_index()))
474  system.solution->set (dof_index, exio_helper->elem_var_values[i]);
475  }
476 
477  system.solution->close();
478  system.update();
479 }
480 
481 
482 
484 {
485  // Be sure the file has been opened for writing!
487  {
488  libMesh::err << "ERROR, ExodusII file must be initialized "
489  << "before outputting element variables.\n"
490  << std::endl;
491  libmesh_error();
492  }
493 
494  // This function currently only works on SerialMeshes. We rely on
495  // having a reference to a non-const MeshBase object from our
496  // MeshInput parent class to construct a MeshSerializer object,
497  // similar to what is done in ExodusII_IO::write(). Note that
498  // calling ExodusII_IO::write_timestep() followed by
499  // ExodusII_IO::write_element_data() when the underlying Mesh is a
500  // ParallelMesh will result in an unnecessary additional
501  // serialization/re-parallelization step.
503 
504  // To be (possibly) filled with a filtered list of variable names to output.
505  std::vector<std::string> names;
506 
507  // If _output_variables is populated, only output the monomials which are
508  // also in the _output_variables vector.
509  if (_output_variables.size() > 0)
510  {
511  std::vector<std::string> monomials;
512  const FEType type(CONSTANT, MONOMIAL);
513 
514  // Create a list of monomial variable names
515  es.build_variable_names(monomials, &type);
516 
517  // Filter that list against the _output_variables list. Note: if names is still empty after
518  // all this filtering, all the monomial variables will be gathered
519  std::vector<std::string>::iterator it = monomials.begin();
520  for (; it!=monomials.end(); ++it)
521  if (std::find(_output_variables.begin(), _output_variables.end(), *it) != _output_variables.end())
522  names.push_back(*it);
523  }
524 
525  // If we pass in a list of names to "get_solution" it'll filter the variables coming back
526  std::vector<Number> soln;
527  es.get_solution(soln, names);
528 
529  if(soln.empty()) // If there is nothing to write just return
530  return;
531 
532  // The data must ultimately be written block by block. This means that this data
533  // must be sorted appropriately.
534  if(MeshOutput<MeshBase>::mesh().processor_id())
535  return;
536 
538 
541 }
542 
543 
544 
545 void ExodusII_IO::write_nodal_data (const std::string& fname,
546  const std::vector<Number>& soln,
547  const std::vector<std::string>& names)
548 {
549  START_LOG("write_nodal_data()", "ExodusII_IO");
550 
552 
553  int num_vars = libmesh_cast_int<int>(names.size());
554  dof_id_type num_nodes = mesh.n_nodes();
555 
556  // The names of the variables to be output
557  std::vector<std::string> output_names;
558 
560  output_names = _output_variables;
561  else
562  output_names = names;
563 
564  // Call helper function for opening/initializing data
565  this->write_nodal_data_common(fname, output_names, /*continuous=*/true);
566 
567  if(mesh.processor_id())
568  {
569  STOP_LOG("write_nodal_data()", "ExodusII_IO");
570  return;
571  }
572 
573  // This will count the number of variables actually output
574  for (int c=0; c<num_vars; c++)
575  {
576  std::vector<std::string>::iterator pos =
577  std::find(output_names.begin(), output_names.end(), names[c]);
578  if (pos == output_names.end())
579  continue;
580 
581  unsigned int variable_name_position =
582  libmesh_cast_int<unsigned int>(pos - output_names.begin());
583 
584  std::vector<Number> cur_soln(num_nodes);
585 
586  // Copy out this variable's solution
587  for(dof_id_type i=0; i<num_nodes; i++)
588  cur_soln[i] = soln[i*num_vars + c];
589 
590  exio_helper->write_nodal_values(variable_name_position+1,cur_soln,_timestep);
591  }
592 
593  STOP_LOG("write_nodal_data()", "ExodusII_IO");
594 }
595 
596 
597 
598 
599 void ExodusII_IO::write_information_records (const std::vector<std::string>& records)
600 {
602  return;
603 
605  {
606  libMesh::err << "ERROR, ExodusII file must be initialized "
607  << "before outputting information records.\n"
608  << std::endl;
609  libmesh_error();
610  }
611 
613 }
614 
615 
616 
617 void ExodusII_IO::write_global_data (const std::vector<Number>& soln,
618  const std::vector<std::string>& names)
619 {
621  return;
622 
624  {
625  libMesh::err << "ERROR, ExodusII file must be initialized "
626  << "before outputting global variables.\n"
627  << std::endl;
628  libmesh_error();
629  }
630 
633 }
634 
635 
636 
637 void ExodusII_IO::write_timestep (const std::string& fname,
638  const EquationSystems& es,
639  const int timestep,
640  const Real time)
641 {
642  _timestep = timestep;
643  write_equation_systems(fname,es);
644 
646  return;
647 
648  exio_helper->write_timestep(timestep, time);
649 }
650 
651 
652 
653 void ExodusII_IO::write (const std::string& fname)
654 {
656 
657  // We may need to gather a ParallelMesh to output it, making that
658  // const qualifier in our constructor a dirty lie
659  MeshSerializer serialize(const_cast<MeshBase&>(mesh), !MeshOutput<MeshBase>::_is_parallel_format);
660 
662 
663  // If the user has set the append flag here, it doesn't really make
664  // sense: the intent of this function is to write a Mesh with no
665  // data, while "appending" is really intended to add data to an
666  // existing file. If we're verbose, print a message to this effect.
667  if (_append && _verbose)
668  libMesh::out << "Warning: Appending in ExodusII_IO::write() does not make sense.\n"
669  << "Creating a new file instead!"
670  << std::endl;
671 
672  exio_helper->create(fname);
673  exio_helper->initialize(fname,mesh);
678 
680  return;
681 
682  if( (mesh.boundary_info->n_edge_conds() > 0) &&
683  _verbose )
684  {
685  libMesh::out << "Warning: Mesh contains edge boundary IDs, but these "
686  << "are not supported by the ExodusII format."
687  << std::endl;
688  }
689 }
690 
691 
692 
693 void ExodusII_IO::write_nodal_data_discontinuous (const std::string& fname,
694  const std::vector<Number>& soln,
695  const std::vector<std::string>& names)
696 {
697  START_LOG("write_nodal_data_discontinuous()", "ExodusII_IO");
698 
700 
701  int num_vars = libmesh_cast_int<int>(names.size());
702  int num_nodes = 0;
705  for ( ; it != end; ++it)
706  num_nodes += (*it)->n_nodes();
707 
708  // Call helper function for opening/initializing data
709  this->write_nodal_data_common(fname, names, /*continuous=*/false);
710 
711  if (mesh.processor_id())
712  {
713  STOP_LOG("write_nodal_data_discontinuous()", "ExodusII_IO");
714  return;
715  }
716 
717  for (int c=0; c<num_vars; c++)
718  {
719  // Copy out this variable's solution
720  std::vector<Number> cur_soln(num_nodes);
721 
722  for(int i=0; i<num_nodes; i++)
723  cur_soln[i] = soln[i*num_vars + c];
724 
726  }
727 
728  STOP_LOG("write_nodal_data_discontinuous()", "ExodusII_IO");
729 }
730 
731 
732 
734  const std::vector<std::string>& names,
735  bool continuous)
736 {
738 
739  // This function can be called multiple times, we only want to open
740  // the ExodusII file the first time it's called.
742  {
743  // If we're appending, open() the file with read_only=false,
744  // otherwise create() it and write the contents of the mesh to
745  // it.
746  if (_append)
747  {
748  exio_helper->open(fname.c_str(), /*read_only=*/false);
749  // If we're appending, it's not valid to call exio_helper->initialize()
750  // or exio_helper->initialize_nodal_variables(), but we do need to set up
751  // certain aspects of the Helper object itself, such as the number of nodes
752  // and elements. We do that by reading the header...
754 
755  // ...and reading the block info
757  }
758  else
759  {
760  exio_helper->create(fname);
761 
762  if (continuous)
763  {
764  exio_helper->initialize(fname,mesh);
767  }
768  else
769  {
773  }
776 
777  if( (mesh.boundary_info->n_edge_conds() > 0) &&
778  _verbose )
779  {
780  libMesh::out << "Warning: Mesh contains edge boundary IDs, but these "
781  << "are not supported by the ExodusII format."
782  << std::endl;
783  }
784 
786  }
787  }
788  else
789  {
790  // We are already open for writing, so check that the filename
791  // passed to this function matches the filename currently in use
792  // by the helper.
793  if (fname != exio_helper->current_filename)
794  {
795  libMesh::err << "Error! This ExodusII_IO object is already associated with file: "
797  << ", cannot use it with requested file: "
798  << fname
799  << std::endl;
800  libmesh_error();
801  }
802  }
803 }
804 
805 
806 
807 // LIBMESH_HAVE_EXODUS_API is not defined, declare error() versions of functions...
808 #else
809 
810 
811 
813 {
814  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
815  libmesh_error();
816 }
817 
818 
819 
820 void ExodusII_IO::read (const std::string&)
821 {
822  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
823  libmesh_error();
824 }
825 
826 
827 
828 void ExodusII_IO::verbose (bool)
829 {
830  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
831  libmesh_error();
832 }
833 
834 
835 
837 {
838  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
839  libmesh_error();
840 }
841 
842 
843 
845 {
846  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
847  libmesh_error();
848 }
849 
850 
851 
852 void ExodusII_IO::append(bool val)
853 {
854  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
855  libmesh_error();
856 }
857 
858 
859 
860 const std::vector<Real>& ExodusII_IO::get_time_steps()
861 {
862  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
863  libmesh_error();
864 }
865 
866 
867 
869 {
870  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
871  libmesh_error();
872 }
873 
874 
875 void ExodusII_IO::copy_nodal_solution(System&, std::string, std::string, unsigned int)
876 {
877  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
878  libmesh_error();
879 }
880 
881 
882 
883 void ExodusII_IO::copy_elemental_solution(System&, std::string, std::string, unsigned int)
884 {
885  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
886  libmesh_error();
887 }
888 
889 
890 
891 void ExodusII_IO::write_element_data (const EquationSystems& es)
892 {
893  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
894  libmesh_error();
895 }
896 
897 
898 
899 void ExodusII_IO::write_nodal_data (const std::string&, const std::vector<Number>&, const std::vector<std::string>&)
900 {
901  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
902  libmesh_error();
903 }
904 
905 
906 
907 void ExodusII_IO::write_information_records (const std::vector<std::string>&)
908 {
909  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
910  libmesh_error();
911 }
912 
913 
914 
915 void ExodusII_IO::write_global_data (const std::vector<Number>&, const std::vector<std::string>&)
916 {
917  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
918  libmesh_error();
919 }
920 
921 
922 
923 void ExodusII_IO::write_timestep (const std::string&, const EquationSystems&, const int, const Real)
924 {
925  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
926  libmesh_error();
927 }
928 
929 
930 
931 void ExodusII_IO::write (const std::string&)
932 {
933  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
934  libmesh_error();
935 }
936 
937 
938 
939 void ExodusII_IO::write_nodal_data_discontinuous (const std::string&, const std::vector<Number>&, const std::vector<std::string>&)
940 {
941  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
942  libmesh_error();
943 }
944 
945 
946 
947  void ExodusII_IO::write_nodal_data_common(std::string,
948  const std::vector<std::string>&,
949  bool)
950 {
951  libMesh::err << "ERROR, ExodusII API is not defined." << std::endl;
952  libmesh_error();
953 }
954 
955 #endif // LIBMESH_HAVE_EXODUS_API
956 } // namespace libMesh

Site Created By: libMesh Developers
Last modified: February 07 2014 16:57:04 UTC

Hosted By:
SourceForge.net Logo