void PetscDMRegister()
{
if (PetscDMRegistered)
return;
PetscErrorCode ierr;
#if PETSC_RELEASE_LESS_THAN(3,4,0)
ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr);
#else
ierr = DMRegister(DMLIBMESH, DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr);
#endif
PetscDMRegistered = PETSC_TRUE;
}
void PetscDMRegister()
{
if (PetscDMRegistered)
return;
PetscErrorCode ierr;
ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD, ierr);
PetscDMRegistered = PETSC_TRUE;
}
/*@C
DMRegisterAll - Registers all of the DM components in the DM package.
Not Collective
Input parameter:
. path - The dynamic library path
Level: advanced
.keywords: DM, register, all
.seealso: DMRegister(), DMRegisterDestroy()
@*/
PetscErrorCode DMRegisterAll()
{
PetscErrorCode ierr;
PetscFunctionBegin;
DMRegisterAllCalled = PETSC_TRUE;
ierr = DMRegister(DMDA, DMCreate_DA);CHKERRQ(ierr);
ierr = DMRegister(DMCOMPOSITE, DMCreate_Composite);CHKERRQ(ierr);
ierr = DMRegister(DMSLICED, DMCreate_Sliced);CHKERRQ(ierr);
ierr = DMRegister(DMSHELL, DMCreate_Shell);CHKERRQ(ierr);
ierr = DMRegister(DMREDUNDANT, DMCreate_Redundant);CHKERRQ(ierr);
ierr = DMRegister(DMPLEX, DMCreate_Plex);CHKERRQ(ierr);
ierr = DMRegister(DMPATCH, DMCreate_Patch);CHKERRQ(ierr);
#if defined(PETSC_HAVE_MOAB)
ierr = DMRegister(DMMOAB, DMCreate_Moab);CHKERRQ(ierr);
#endif
ierr = DMRegister(DMNETWORK, DMCreate_Network);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
LibMeshInit::LibMeshInit (int argc, const char * const * argv,
MPI_Comm COMM_WORLD_IN)
#endif
{
// should _not_ be initialized already.
libmesh_assert (!libMesh::initialized());
// Build a command-line parser.
command_line.reset (new GetPot (argc, argv));
// Disable performance logging upon request
{
if (libMesh::on_command_line ("--disable-perflog"))
libMesh::perflog.disable_logging();
}
// Build a task scheduler
{
// Get the requested number of threads, defaults to 1 to avoid MPI and
// multithreading competition. If you would like to use MPI and multithreading
// at the same time then (n_mpi_processes_per_node)x(n_threads) should be the
// number of processing cores per node.
std::vector<std::string> n_threads(2);
n_threads[0] = "--n_threads";
n_threads[1] = "--n-threads";
libMesh::libMeshPrivateData::_n_threads =
libMesh::command_line_value (n_threads, 1);
// If there's no threading model active, force _n_threads==1
#if !LIBMESH_USING_THREADS
if (libMesh::libMeshPrivateData::_n_threads != 1)
{
libMesh::libMeshPrivateData::_n_threads = 1;
libmesh_warning("Warning: You requested --n-threads>1 but no threading model is active!\n"
<< "Forcing --n-threads==1 instead!");
}
#endif
// Set the number of OpenMP threads to the same as the number of threads libMesh is going to use
#ifdef LIBMESH_HAVE_OPENMP
omp_set_num_threads(libMesh::libMeshPrivateData::_n_threads);
#endif
task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
// Construct singletons who may be at risk of the
// "static initialization order fiasco"
Singleton::setup();
// Make sure the construction worked
libmesh_assert(remote_elem);
#if defined(LIBMESH_HAVE_MPI)
// Allow the user to bypass MPI initialization
if (!libMesh::on_command_line ("--disable-mpi"))
{
// Check whether the calling program has already initialized
// MPI, and avoid duplicate Init/Finalize
int flag;
libmesh_call_mpi(MPI_Initialized (&flag));
if (!flag)
{
int mpi_thread_provided;
const int mpi_thread_requested = libMesh::n_threads() > 1 ?
MPI_THREAD_FUNNELED :
MPI_THREAD_SINGLE;
libmesh_call_mpi
(MPI_Init_thread (&argc, const_cast<char ***>(&argv),
mpi_thread_requested, &mpi_thread_provided));
if ((libMesh::n_threads() > 1) &&
(mpi_thread_provided < MPI_THREAD_FUNNELED))
{
libmesh_warning("Warning: MPI failed to guarantee MPI_THREAD_FUNNELED\n"
<< "for a threaded run.\n"
<< "Be sure your library is funneled-thread-safe..."
<< std::endl);
// Ideally, if an MPI stack tells us it's unsafe for us
// to use threads, we shouldn't use threads.
// In practice, we've encountered one MPI stack (an
// mvapich2 configuration) that returned
// MPI_THREAD_SINGLE as a proper warning, two stacks
// that handle MPI_THREAD_FUNNELED properly, and two
// current stacks plus a couple old stacks that return
// MPI_THREAD_SINGLE but support libMesh threaded runs
// anyway.
// libMesh::libMeshPrivateData::_n_threads = 1;
// task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
libmesh_initialized_mpi = true;
}
// Duplicate the input communicator for internal use
// And get a Parallel::Communicator copy too, to use
// as a default for that API
this->_comm = COMM_WORLD_IN;
libMesh::GLOBAL_COMM_WORLD = COMM_WORLD_IN;
//MPI_Comm_set_name not supported in at least SGI MPT's MPI implementation
//MPI_Comm_set_name (libMesh::COMM_WORLD, "libMesh::COMM_WORLD");
libMeshPrivateData::_processor_id =
cast_int<processor_id_type>(this->comm().rank());
libMeshPrivateData::_n_processors =
cast_int<processor_id_type>(this->comm().size());
// Set up an MPI error handler if requested. This helps us get
// into a debugger with a proper stack when an MPI error occurs.
if (libMesh::on_command_line ("--handle-mpi-errors"))
{
libmesh_call_mpi
(MPI_Comm_create_errhandler(libMesh_MPI_Handler, &libmesh_errhandler));
libmesh_call_mpi
(MPI_Comm_set_errhandler(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler));
libmesh_call_mpi
(MPI_Comm_set_errhandler(MPI_COMM_WORLD, libmesh_errhandler));
}
}
// Could we have gotten bad values from the above calls?
libmesh_assert_greater (libMeshPrivateData::_n_processors, 0);
// The cast_int already tested _processor_id>=0
// libmesh_assert_greater_equal (libMeshPrivateData::_processor_id, 0);
// Let's be sure we properly initialize on every processor at once:
libmesh_parallel_only(this->comm());
#endif
#if defined(LIBMESH_HAVE_PETSC)
// Allow the user to bypass PETSc initialization
if (!libMesh::on_command_line ("--disable-petsc")
#if defined(LIBMESH_HAVE_MPI)
// If the user bypassed MPI, we'd better be safe and assume that
// PETSc was built to require it; otherwise PETSc initialization
// dies.
&& !libMesh::on_command_line ("--disable-mpi")
#endif
)
{
int ierr=0;
PETSC_COMM_WORLD = libMesh::GLOBAL_COMM_WORLD;
// Check whether the calling program has already initialized
// PETSc, and avoid duplicate Initialize/Finalize
PetscBool petsc_already_initialized;
ierr = PetscInitialized(&petsc_already_initialized);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
if (petsc_already_initialized != PETSC_TRUE)
libmesh_initialized_petsc = true;
# if defined(LIBMESH_HAVE_SLEPC)
// If SLEPc allows us to check whether the calling program
// has already initialized it, we do that, and avoid
// duplicate Initialize/Finalize.
// We assume that SLEPc will handle PETSc appropriately,
// which it does in the versions we've checked.
if (!SlepcInitializeCalled)
{
ierr = SlepcInitialize (&argc, const_cast<char ***>(&argv), nullptr, nullptr);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
libmesh_initialized_slepc = true;
}
# else
if (libmesh_initialized_petsc)
{
ierr = PetscInitialize (&argc, const_cast<char ***>(&argv), nullptr, nullptr);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
}
# endif
#if !PETSC_RELEASE_LESS_THAN(3,3,0)
// Register the reference implementation of DMlibMesh
#if PETSC_RELEASE_LESS_THAN(3,4,0)
ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
#else
ierr = DMRegister(DMLIBMESH, DMCreate_libMesh); CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
#endif
#endif
}
#endif
#if defined(LIBMESH_HAVE_MPI) && defined(LIBMESH_HAVE_VTK)
// Do MPI initialization for VTK.
_vtk_mpi_controller = vtkMPIController::New();
_vtk_mpi_controller->Initialize(&argc, const_cast<char ***>(&argv), /*initialized_externally=*/1);
_vtk_mpi_controller->SetGlobalController(_vtk_mpi_controller);
#endif
// Re-parse the command-line arguments. Note that PETSc and MPI
// initialization above may have removed command line arguments
// that are not relevant to this application in the above calls.
// We don't want a false-positive by detecting those arguments.
//
// Note: this seems overly paranoid/like it should be unnecessary,
// plus we were doing it wrong for many years and not clearing the
// existing GetPot object before re-parsing the command line, so all
// the command line arguments appeared twice in the GetPot object...
command_line.reset (new GetPot (argc, argv));
// The following line is an optimization when simultaneous
// C and C++ style access to output streams is not required.
// The amount of benefit which occurs is probably implementation
// defined, and may be nothing. On the other hand, I have seen
// some IO tests where IO performance improves by a factor of two.
if (!libMesh::on_command_line ("--sync-with-stdio"))
std::ios::sync_with_stdio(false);
// Honor the --separate-libmeshout command-line option.
// When this is specified, the library uses an independent ostream
// for libMesh::out/libMesh::err messages, and
// std::cout and std::cerr are untouched by any other options
if (libMesh::on_command_line ("--separate-libmeshout"))
{
// Redirect. We'll share streambufs with cout/cerr for now, but
// presumably anyone using this option will want to replace the
// bufs later.
std::ostream * newout = new std::ostream(std::cout.rdbuf());
libMesh::out = *newout;
std::ostream * newerr = new std::ostream(std::cerr.rdbuf());
libMesh::err = *newerr;
}
// Process command line arguments for redirecting stdout/stderr.
bool
cmdline_has_redirect_stdout = libMesh::on_command_line ("--redirect-stdout"),
cmdline_has_redirect_output = libMesh::on_command_line ("--redirect-output");
// The --redirect-stdout command-line option has been deprecated in
// favor of "--redirect-output basename".
if (cmdline_has_redirect_stdout)
libmesh_warning("The --redirect-stdout command line option has been deprecated. "
"Use '--redirect-output basename' instead.");
// Honor the "--redirect-stdout" and "--redirect-output basename"
// command-line options. When one of these is specified, each
// processor sends libMesh::out/libMesh::err messages to
// stdout.processor.#### (default) or basename.processor.####.
if (cmdline_has_redirect_stdout || cmdline_has_redirect_output)
{
std::string basename = "stdout";
// Look for following argument if using new API
if (cmdline_has_redirect_output)
{
// Set the cursor to the correct location in the list of command line arguments.
command_line->search(1, "--redirect-output");
// Get the next option on the command line as a string.
std::string next_string = "";
next_string = command_line->next(next_string);
// If the next string starts with a dash, we assume it's
// another flag and not a file basename requested by the
// user.
if (next_string.size() > 0 && next_string.find_first_of("-") != 0)
basename = next_string;
}
std::ostringstream filename;
filename << basename << ".processor." << libMesh::global_processor_id();
_ofstream.reset (new std::ofstream (filename.str().c_str()));
// Redirect, saving the original streambufs!
out_buf = libMesh::out.rdbuf (_ofstream->rdbuf());
err_buf = libMesh::err.rdbuf (_ofstream->rdbuf());
}
// redirect libMesh::out to nothing on all
// other processors unless explicitly told
// not to via the --keep-cout command-line argument.
if (libMesh::global_processor_id() != 0)
if (!libMesh::on_command_line ("--keep-cout"))
libMesh::out.rdbuf (nullptr);
// Similarly, the user can request to drop cerr on all non-0 ranks.
// By default, errors are printed on all ranks, but this can lead to
// interleaved/unpredictable outputs when doing parallel regression
// testing, which this option is designed to support.
if (libMesh::global_processor_id() != 0)
if (libMesh::on_command_line ("--drop-cerr"))
libMesh::err.rdbuf (nullptr);
// Check command line to override printing
// of reference count information.
if (libMesh::on_command_line("--disable-refcount-printing"))
ReferenceCounter::disable_print_counter_info();
#ifdef LIBMESH_ENABLE_EXCEPTIONS
// Set our terminate handler to write stack traces in the event of a
// crash
old_terminate_handler = std::set_terminate(libmesh_terminate_handler);
#endif
if (libMesh::on_command_line("--enable-fpe"))
libMesh::enableFPE(true);
if (libMesh::on_command_line("--enable-segv"))
libMesh::enableSEGV(true);
// The library is now ready for use
libMeshPrivateData::_is_initialized = true;
// Make sure these work. Library methods
// depend on these being implemented properly,
// so this is a good time to test them!
libmesh_assert (libMesh::initialized());
libmesh_assert (!libMesh::closed());
}
