Brian has a system of global preferences that affect how certain objects
behave. These can be set either in scripts by using the prefs object
or in a file. Each preference looks like codegen.c.compiler, i.e. dotted
names.

Preferences can be accessed and set either keyword-based or attribute-based.
The following are equivalent:

prefs['codegen.c.compiler']='gcc'prefs.codegen.c.compiler='gcc'

Using the attribute-based form can be particulary useful for interactive
work, e.g. in ipython, as it offers autocompletion and documentation.
In ipython, prefs.codegen.c? would display a docstring with all
the preferences available in the codegen.c category.

Whether to pull out scalar expressions out of the statements, so that
they are only evaluated once instead of once for every neuron/synapse/...
Can be switched off, e.g. because it complicates the code (and the same
optimisation is already performed by the compiler) or because the
code generation target does not deal well with it. Defaults to True.

codegen.string_expression_target = 'numpy'

Default target for the evaluation of string expressions (e.g. when
indexing state variables). Should normally not be changed from the
default numpy target, because the overhead of compiling code is not
worth the speed gain for simple expressions.

'weave' uses scipy.weave to generate and compile C++ code,
should work anywhere where gcc is installed and available at the
command line.

'cython', uses the Cython package to generate C++ code. Needs a
working installation of Cython and a C++ compiler.

'numpy' works on all platforms and doesn’t need a C compiler but
is often less efficient.

Or it can be a CodeObject class.

codegen.cpp

C++ compilation preferences

codegen.cpp.compiler = ''

Compiler to use (uses default if empty)

Should be gcc or msvc.

codegen.cpp.define_macros = []

List of macros to define; each macro is defined using a 2-tuple,
where ‘value’ is either the string to define it to or None to
define it without a particular value (equivalent of “#define
FOO” in source or -DFOO on Unix C compiler command line).

codegen.cpp.extra_compile_args = None

Extra arguments to pass to compiler (if None, use either
extra_compile_args_gcc or extra_compile_args_msvc).

Extra compile arguments to pass to MSVC compiler (the default
/arch: flag is determined based on the processor architecture)

codegen.cpp.extra_link_args = []

Any extra platform- and compiler-specific information to use when
linking object files together.

codegen.cpp.headers = []

A list of strings specifying header files to use when compiling the
code. The list might look like [“<vector>”,“‘my_header’”]. Note that
the header strings need to be in a form than can be pasted at the end
of a #include statement in the C++ code.

codegen.cpp.include_dirs = []

Include directories to use. Note that $prefix/include will be
appended to the end automatically, where $prefix is Python’s
site-specific directory prefix as returned by sys.prefix.

codegen.cpp.libraries = []

List of library names (not filenames or paths) to link against.

codegen.cpp.library_dirs = []

List of directories to search for C/C++ libraries at link time.
Note that $prefix/lib will be appended to the end automatically,
where $prefix is Python’s site-specific directory prefix as returned
by sys.prefix.

codegen.cpp.msvc_architecture = ''

MSVC architecture name (or use system architectue by default).

Could take values such as x86, amd64, etc.

codegen.cpp.msvc_vars_location = ''

Location of the MSVC command line tool (or search for best by default).

Additional flags to pass to the GNU make command on Linux/OS-X.
Defaults to “-j” for parallel compilation.

devices.cpp_standalone.extra_make_args_windows = []

Additional flags to pass to the nmake command on Windows. By default, no
additional flags are passed.

devices.cpp_standalone.openmp_spatialneuron_strategy = None

Which strategy to chose for solving the three tridiagonal systems with
OpenMP: 'branches' means to solve the three systems sequentially, but
for all the branches in parallel, 'systems' means to solve the three
systems in parallel, but all the branches within each system
sequentially. The 'branches' approach is usually better for
morphologies with many branches and a large number of threads, while the
'systems' strategy should be better for morphologies with few
branches (e.g. cables) and/or simulations with no more than three
threads. If not specified (the default), the 'systems' strategy will
be used when using no more than three threads or when the morphology
has less than three branches in total.

devices.cpp_standalone.openmp_threads = 0

The number of threads to use if OpenMP is turned on. By default, this value is set to 0 and the C++ code
is generated without any reference to OpenMP. If greater than 0, then the corresponding number of threads
are used to launch the simulation.

If set to True (the default), log files (and the copy of the main
script) will be deleted after the brian process has exited, unless an
uncaught exception occured. If set to False, all log files will be kept.

logging.file_log = True

Whether to log to a file or not.

If set to True (the default), logging information will be written
to a file. The log level can be set via the logging.file_log_level
preference.

logging.file_log_level = 'DIAGNOSTIC'

What log level to use for the log written to the log file.

In case file logging is activated (see logging.file_log), which log
level should be used for logging. Has to be one of CRITICAL, ERROR,
WARNING, INFO, DEBUG or DIAGNOSTIC.

logging.save_script = True

Whether to save a copy of the script that is run.

If set to True (the default), a copy of the currently run script
is saved to a temporary location. It is deleted after a successful
run (unless logging.delete_log_on_exit is False) but is kept after
an uncaught exception occured. This can be helpful for debugging,
in particular when several simulations are running in parallel.

logging.std_redirection = True

Whether or not to redirect stdout/stderr to null at certain places.

This silences a lot of annoying compiler output, but will also hide
error messages making it harder to debug problems. You can always
temporarily switch it off when debugging. If
logging.std_redirection_to_file is set to True as well, then the
output is saved to a file and if an error occurs the name of this file
will be printed.

logging.std_redirection_to_file = True

Whether to redirect stdout/stderr to a file.

If both logging.std_redirection and this preference are set to
True, all standard output/error (most importantly output from
the compiler) will be stored in files and if an error occurs the name
of this file will be printed. If logging.std_redirection is True
and this preference is False, then all standard output/error will
be completely suppressed, i.e. neither be displayed nor stored in a
file.