File bout++.cxx#




void bout_signal_handler(int sig)#

Signal handler - handles all signals.

std::string time_to_hms(BoutReal t)#

Write a time in h:mm:ss.s format.

char get_spin()#

Produce a spinning bar character.

int BoutInitialise(int &argc, char **&argv)#

Initialise BOUT++


The command-line arguments argc and argv are passed by reference, and pointers to these will be stored in various places in BOUT++.


Any non-zero return value should halt the simulation. If the return value is less than zero, the exit status from BOUT++ is 0, otherwise it is the return value of BoutInitialise.

int BoutFinalise(bool write_settings)#

BOUT++ finalisation. This should be called at the end of the program.

Frees memory, flushes buffers, and closes files. If BOUT++ initialised MPI or external libraries, then these are also finalised.

If write_settings is true, output the settings, showing which options were used. This overwrites the file written during initialisation (BOUT.settings by default)


const char DEFAULT_DIR[] = "data"#
BoutReal simtime = {0.0}#
int iteration = {0}#
bool user_requested_exit = false#
namespace bout

Provides access to the Hypre library, handling initialisation and finalisation.


#include <bout/hyprelib.hxx>

class MyClass { public:

private: HypreLib lib; };

This will then automatically initialise Hypre the first time an object is created, and finalise it when the last object is destroyed.

Copyright 2012 B.D.Dudson, S.Farley, M.V.Umansky, X.Q.Xu

Contact: Ben Dudson,

This file is part of BOUT++.

BOUT++ is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

BOUT++ is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with BOUT++. If not, see

Information about the version of BOUT++

The build system will update this file on every commit, which may result in files that include it getting rebuilt. Therefore it should be included in as few places as possible

Information about the version of BOUT++

The build system will update this file at configure-time

SNB model

namespace experimental#


void setupSignalHandler(SignalHandler signal_handler)#

Set a signal handler for user-requested clean exit, and (optionally) segmentation faults and floating point errors

  • For segmentation faults, compile with --enable-signal.

  • For floating point errors, compile with --enable-sigfpe

void defaultSignalHandler(int sig)#

The default BOUT++ signal handler: throw an exception with an appropriate message

void setupGetText()#

Set up the i18n environment.

CommandLineArgs parseCommandLineArgs(int argc, char **argv)#

Parse the “fixed” command line arguments, like &#8212;help and -d.

void checkDataDirectoryIsAccessible(const std::string &data_dir)#

Throw an exception if data_dir is either not a directory or not accessible. We do not check whether we can write, as it is sufficient that the files we need are writeable

void setupOutput(const std::string &data_dir, const std::string &log_file, int verbosity, int MYPE = 0)#

Set up the output: open the log file for each processor, enable or disable the default outputs based on verbosity, disable writing to stdout for MYPE != 0

void savePIDtoFile(const std::string &data_dir, int MYPE)#

Save the process ID for processor N = MYPE to file “” in data_dir, so it can be shut down by user signal

Throws if it was not possible to create the file

void printStartupHeader(int MYPE, int NPES)#

Print the initial header.

void printCompileTimeOptions()#

Print the compile-time options.

void printCommandLineArguments(const std::vector<std::string> &original_argv)#

Print the arguments given on the command line.

bool setupBoutLogColor(bool color_output, int MYPE)#

Setup the pipe etc and run stdout through bout-log-color. Return true if it was successful

void setRunStartInfo(Options &options)#

Set BOUT++ version information, along with current time (as started), into run section of options

void setRunFinishInfo(Options &options)#

Set the current time (as finished) into run section of options

void writeSettingsFile(Options &options, const std::string &data_dir, const std::string &settings_file)#

Write options to settings_file in directory data_dir.

void addBuildFlagsToOptions(Options &options)#

Add the configure-time build options to options.

template<class Factory>
void printAvailableImplementations()#

Print all of the available implementations for a given Factory

template<class Factory>
void printTypeOptions(const std::string &type)#

Print all the Options used in constructing type.

template<class Factory>
void handleFactoryHelp(const std::string &current_arg, int i, int argc, char **argv, bool plural_needs_e = false)#

Handle the command line options for the given Factory: listing all types, and used options for a given type