libMesh::LibMeshInit类 参考

The LibMeshInit class, when constructed, initializes the dependent libraries (e.g. 更多...

#include <libmesh.h>

Public 成员函数
	LibMeshInit (int argc, const char *const *argv, MPI_Comm COMM_WORLD_IN=MPI_COMM_WORLD, int n_threads=-1)
	Initialize the library for use, with the command line options provided. 更多...
	LibMeshInit (int argc, const char *const *argv, int COMM_WORLD_IN=0, int n_threads=-1)
virtual	~LibMeshInit ()
	Destructor. 更多...
const Parallel::Communicator &	comm () const
	Returns a Communicator created from the TIMPIInit object we hold, which will be a compatibility shim if MPI is not enabled. 更多...
Parallel::Communicator &	comm ()

Private 属性
TIMPI::TIMPIInit *	_timpi_init
Parallel::Communicator *	_comm
vtkMPIController *	_vtk_mpi_controller

详细描述

The LibMeshInit class, when constructed, initializes the dependent libraries (e.g.

MPI or PETSC) and does the command line parsing needed by libMesh. The LibMeshInit destructor closes those libraries properly.

For most users, a single LibMeshInit object should be created at the start of your main() function.

All libMesh functionality should be used only when a LibMeshInit object exists. Dependent library functionality, likewise, except in codes which manually initialize those libraries before LibMeshInit creation and finalize them after LibMeshInit destruction.

Since "it is best not to perform much more than a return rc after calling MPI_Finalize", applications which want to do anything after LibMeshInit destruction should manage MPI initialization and finalization manually.

在文件 libmesh.h 第 80 行定义.

构造及析构函数说明

libMesh::LibMeshInit::LibMeshInit	(	int	argc,
		const char *const *	argv,
		MPI_Comm	COMM_WORLD_IN = MPI_COMM_WORLD,
		int	n_threads = -1
	)

Initialize the library for use, with the command line options provided.

This will e.g. call MPI_Init if MPI is available and enabled and has not already been initialized; similar initialization may take place for Petsc, Slepc, multithreading support, libMesh Singleton objects, the libMesh::out/err IO streams, and any libMesh handlers for floating-point exceptions, signals, and/or C++ aborts.

You must create a LibMeshInit object before using any of the library functionality. This method may take an optional parameter to use a user-specified MPI communicator.

libMesh::LibMeshInit::LibMeshInit	(	int	argc,
		const char *const *	argv,
		int	COMM_WORLD_IN = 0,
		int	n_threads = -1
	)

libMesh::LibMeshInit::~LibMeshInit ( )

virtual

Destructor.

Cleans up libMesh Singleton objects, and thread manager if threading is in use. Prints reference count and performance logging information if enabled. Restores pre-LibMeshInit terminate handler and floating-point-exception handling. Finalizes any of Slepc, Petsc, and MPI which were initialized by LibMeshInit.

在文件 libmesh.C 第 668 行定义.

参考 _comm, libMesh::libMeshPrivateData::_is_initialized, _timpi_init, _vtk_mpi_controller, libMesh::Singleton::cleanup(), libMesh::closed(), comm(), libMesh::enableFPE(), libMesh::err, libMesh::ReferenceCounter::n_objects(), libMesh::old_terminate_handler, libMesh::on_command_line(), libMesh::out, libMesh::perflog , 以及 libMesh::ReferenceCounter::print_info().

{
  // Every processor had better be ready to exit at the same time.
  // This would be a libmesh_parallel_only() function, except that
  // libmesh_parallel_only() uses libmesh_assert() which throws an
  // exception() which causes compilers to scream about exceptions
  // inside destructors.

  // Even if we're not doing parallel_only debugging, we don't want
  // one processor to try to exit until all others are done working.
  this->comm().barrier();

  // We can't delete, finalize, etc. more than once without
  // reinitializing in between
  libmesh_exceptionless_assert(!libMesh::closed());

  // Delete reference counted singleton(s)
  Singleton::cleanup();

  // Clear the thread task manager we started
  task_scheduler.reset();

  // Force the \p ReferenceCounter to print
  // its reference count information.  This allows
  // us to find memory leaks.  By default the
  // \p ReferenceCounter only prints its information
  // when the last created object has been destroyed.
  // That does no good if we are leaking memory!
  ReferenceCounter::print_info ();


  // Print an informative message if we detect a memory leak
  if (ReferenceCounter::n_objects() != 0)
    {
      libMesh::err << "Memory leak detected!"
                   << std::endl;

#if !defined(LIBMESH_ENABLE_REFERENCE_COUNTING) || defined(NDEBUG)

      libMesh::err << "Compile in DEBUG mode with --enable-reference-counting"
                   << std::endl
                   << "for more information"
                   << std::endl;
#endif

    }

  //  print the perflog to individual processor's file.
  libMesh::perflog.print_log();

  // Now clear the logging object, we don't want it to print
  // a second time during the PerfLog destructor.
  libMesh::perflog.clear();

  // Reconnect the output streams
  // (don't do this, or we will get messages from objects
  //  that go out of scope after the following return)
  //std::cout.rdbuf(std::cerr.rdbuf());


  // Set the initialized() flag to false
  libMeshPrivateData::_is_initialized = false;

  if (libMesh::on_command_line ("--redirect-stdout") ||
      libMesh::on_command_line ("--redirect-output"))
    {
      // If stdout/stderr were redirected to files, reset them now.
      libMesh::out.rdbuf (out_buf);
      libMesh::err.rdbuf (err_buf);
    }

  // If we built our own output streams, we want to clean them up.
  if (libMesh::on_command_line ("--separate-libmeshout"))
    {
      delete libMesh::out.get();
      delete libMesh::err.get();

      libMesh::out.reset(std::cout);
      libMesh::err.reset(std::cerr);
    }

#ifdef LIBMESH_ENABLE_EXCEPTIONS
  // Reset the old terminate handler; maybe the user code wants to
  // keep doing C++ stuff after closing libMesh stuff.
  std::set_terminate(old_terminate_handler);
#endif


  if (libMesh::on_command_line("--enable-fpe"))
    libMesh::enableFPE(false);

#if defined(LIBMESH_HAVE_PETSC)
  // Allow the user to bypass PETSc finalization
  if (!libMesh::on_command_line ("--disable-petsc")
#if defined(LIBMESH_HAVE_MPI)
      && !libMesh::on_command_line ("--disable-mpi")
#endif
      )
    {
# if defined(LIBMESH_HAVE_SLEPC)
      if (libmesh_initialized_slepc)
        SlepcFinalize();
# else
      if (libmesh_initialized_petsc)
        PetscFinalize();
# endif
    }
#endif

#if defined(LIBMESH_HAVE_MPI) && defined(LIBMESH_HAVE_VTK)
  _vtk_mpi_controller->Finalize(/*finalized_externally=*/1);
  _vtk_mpi_controller->Delete();
#endif

  delete this->_comm;

#if defined(LIBMESH_HAVE_MPI)
  // Allow the user to bypass MPI finalization
  if (!libMesh::on_command_line ("--disable-mpi"))
    {
      delete this->_timpi_init;
    }
#else
  delete this->_timpi_init;
#endif
}

成员函数说明

const Parallel::Communicator& libMesh::LibMeshInit::comm ( ) const

inline

Returns a Communicator created from the TIMPIInit object we hold, which will be a compatibility shim if MPI is not enabled.

在文件 libmesh.h 第 118 行定义.

参考 _comm.

参考自 ~LibMeshInit().

{ return *_comm; }

Parallel::Communicator& libMesh::LibMeshInit::comm ( )

inline

在文件 libmesh.h 第 120 行定义.

参考 _comm.

{ return *_comm; }

类成员变量说明

Parallel::Communicator* libMesh::LibMeshInit::_comm

private

在文件 libmesh.h 第 132 行定义.

参考自 comm() , 以及 ~LibMeshInit().

TIMPI::TIMPIInit* libMesh::LibMeshInit::_timpi_init

private

在文件 libmesh.h 第 125 行定义.

参考自 ~LibMeshInit().

vtkMPIController* libMesh::LibMeshInit::_vtk_mpi_controller

private

在文件 libmesh.h 第 138 行定义.

参考自 ~LibMeshInit().

---

该类的文档由以下文件生成:

• /home/lwz/libmesh/include/base/libmesh.h
• /home/lwz/libmesh/src/base/libmesh.C