Namespaces
namespace	CORRELATIONFUNCTIONS
	This namespace deals with computing correlations functions (N-point functions) in real and fourier space.

namespace	COSMOLOGY
	This namespace deals with various cosmology specific things: background evolution, perturbation theory, recombination history etc.

namespace	FILEUTILS
	This namespace deals with reading and writing files to disc.

namespace	FOF
	This namespace deals how to link together particles in groups.

namespace	GRID
	This namespace contains various grids for holding data shared across different tasks.

namespace	HESSIAN
	This namespace deals with computing the Hessian of a grid and related algorithms that rely on this.

namespace	INTERPOLATION
	This namespace deals with interpolation and density assignment.

namespace	MATH
	This namespace deals with special math functions and general math algorithms needed in the library.

namespace	NBODY
	This namespace deals with N-body simulations.

namespace	PARTICLE
	This namespace contains things related to particles: different types, containers for holding shared particles across tasks and algorithms for doing stuff with particles.

namespace	RANDOM
	This namespace deals with generating random numbers and random fields.

namespace	SOLVERS
	This nanespace contains various solvers.

namespace	SURVEY
	This namespace contains methods for dealing with surveys.

namespace	TRIANGULATION
	This namespace deals with performin triangulations (Delaunay and Voronoi)

namespace	UTILS
	This namespace contains useful things that don't fit anywhere else.

Data Structures
struct	FFTWSetup
	Singleton for initializing and cleaning up FFTW with MPI and threads automatically. More...

struct	FMLSetup
	Singleton for initializing and cleaning up FML Takes care of automatically initializing MPI and FFTW. More...

struct	LogAllocator
	Custom allocator that logs allocations. More...

class	MemoryLog
	Logs all heap allocations in the code that are larger than min_bytes_to_log. More...

struct	MPISetup
	Singleton for initializing and finalizing MPI automatically on startup and exit. More...

Typedefs
template<class T >
using	Allocator = FML::LogAllocator< T >

template<class T >
using	Vector = std::vector< T, Allocator< T > >

using	IndexIntType = long long int

using	TimePoint = std::chrono::time_point< std::chrono::steady_clock >

Functions
double	uniform_random ()

void	init_mpi (int argc, char **argv)
	Initialize MPI. More...

void	init_fml ()
	Initialize the global variables within FML We here assume MPI has been initialized. More...

void	info ()
	Show some info about FML. More...

void	abort_mpi (int exit_code)

void	finalize_mpi ()

void	printf_mpi (const char *fmt,...)

bool	create_folder (std::string foldername)

std::pair< double, double >	get_system_memory_use ()
	Fetch the resident set size currently and the peak value so far of it. More...

void	print_system_memory_use ()
	Print the resident set size and the peak value of it so far. More...

	TYPES (char)

	TYPES (int)

	TYPES (unsigned int)

	TYPES (long long)

	TYPES (size_t)

	TYPES (ptrdiff_t)

	TYPES (float)

	TYPES (double)

	TYPES (long double)

template<class T >
std::vector< T >	GatherFromTasks (T *value)
	Gather a single value from all tasks. Value from task ThisTask is stored in values[ThisTask]. More...

template<class T >
void	MaxOverTasks (T *value)
	Inplace max over tasks of a single value. More...

template<class T >
void	MinOverTasks (T *value)
	Inplace min over tasks of a single value. More...

template<class T >
void	SumOverTasks (T *value)
	Inplace sum over tasks of a single value. More...

template<class T >
void	SumArrayOverTasks (T *value, int n)
	Inplace sum over tasks of a contigious array of values. More...

constexpr void	__assert_mpi (const char expr_str, bool expr, const char file, int line, const char *msg)
	An assert function that calls MPI_Abort instead of just abort to avoid deadlock. More...

constexpr long long int	power (int base, int exponent)
	Simple integer a^b power-function by squaring. More...

	OPS (+) OPS(-) OPS() OPS(/) OPS(+) OPS(-) OPS() OPS(/) OPS(+) OPS(-) OPS(*) OPS(/) template< class T > Vector< T > pow(const Vector< T > &x

Vector< T >	y (n)

	for (size_t i=0;i< n;i++)

template<typename T , typename U >
bool	operator== (const LogAllocator< T > &, const LogAllocator< U > &)

template<typename T , typename U >
bool	operator!= (const LogAllocator< T > &a, const LogAllocator< U > &b)

Variables
FML::UTILS::Timings	global_timer

FMLSetup &	fmlsetup = FMLSetup::init()

int	ThisTask = 0
	The MPI task number. More...

int	NTasks = 1
	Total number of MPI tasks. More...

int	NThreads = 1
	Total number of threads availiable. More...

bool	FFTWThreadsOK = false

bool	MPIThreadsOK = false
	If MPI and threads can work together with FFTW. More...

double	xmin_domain = 0.0
	The local extent of the domain (global domain goes from 0 to 1) More...

double	xmax_domain = 1.0
	The local extent of the domain (global domain goes from 0 to 1) More...

std::mt19937	generator

const double	exp

return	y

Typedef Documentation

◆ Allocator

template<class T >

typedef std::allocator< T > FML::Allocator

Definition at line 70 of file Global.h.

◆ IndexIntType

using FML::IndexIntType = typedef long long int

Definition at line 84 of file Global.h.

◆ TimePoint

using FML::TimePoint = typedef std::chrono::time_point<std::chrono::steady_clock>

Definition at line 38 of file MemoryLogging.h.

◆ Vector

template<class T >

using FML::Vector = typedef std::vector<T, Allocator<T> >

Definition at line 79 of file Global.h.

Function Documentation

◆ __assert_mpi()

constexpr void FML::__assert_mpi	(	const char *	expr_str,
		bool	expr,
		const char *	file,
		int	line,
		const char *	msg
	)

constexpr

An assert function that calls MPI_Abort instead of just abort to avoid deadlock.

Definition at line 172 of file Global.h.

                                                                                                                 {
        if (not expr) {
            std::cout << "[assert_mpi] Assertion failed: [" << expr_str << "], File: [" << file << "], Line: [" << line
                      << "], Message: [" << msg << "]" << std::endl;
#ifdef USE_MPI
            MPI_Abort(MPI_COMM_WORLD, 1);
#endif
            abort();
        }
    }

◆ abort_mpi()

void FML::abort_mpi ( int exit_code )

Definition at line 170 of file Global.cpp.

                                  {
#ifdef USE_MPI
        MPI_Abort(MPI_COMM_WORLD, exit_code);
#endif
        exit(exit_code);
    }

◆ create_folder()

bool FML::create_folder ( std::string foldername )

Definition at line 207 of file Global.cpp.

                                             {
        bool ok = true;
        if (FML::ThisTask == 0) {
            int status = mkdir(foldername.c_str(), 0777);
            ok = not((status < 0) && (errno != EEXIST));
            if (not ok) {
                throw std::runtime_error("Failed to create snapshot folder [" + foldername + "]");
            }
        }
        return ok;
    }

◆ finalize_mpi()

void FML::finalize_mpi ( )

Definition at line 180 of file Global.cpp.

                        {
#ifdef USE_FFTW
        // If we have MPI and FFTW then FFTW takes care of finalizing
        return;
#endif
#ifdef USE_MPI
        MPI_Finalize();
#endif
    }

◆ for()

FML::for ( )

Definition at line 262 of file Global.h.

                                       {
            y[i] = std::pow(x[i], exp);
        }

◆ GatherFromTasks()

template<class T >

std::vector< T > FML::GatherFromTasks ( T * value )

Gather a single value from all tasks. Value from task ThisTask is stored in values[ThisTask].

Definition at line 109 of file Global.h.

                                            {
        std::vector<T> values(FML::NTasks);
#ifdef USE_MPI
        MPI_Allgather(value, sizeof(T), MPI_BYTE, values.data(), sizeof(T), MPI_BYTE, MPI_COMM_WORLD);
#else
        values[0] = *value;
#endif
        return values;
    }

◆ get_system_memory_use()

std::pair< double, double > FML::get_system_memory_use ( )

Fetch the resident set size currently and the peak value so far of it.

Returns bytes

Definition at line 223 of file Global.cpp.

                                                    {
        double currentSize_bytes = getCurrentRSS();
        double peakSize_bytes = getPeakRSS();
        return {currentSize_bytes, peakSize_bytes};
    }

◆ info()

void FML::info ( )

Show some info about FML.

Definition at line 103 of file Global.cpp.

                {
        if (ThisTask == 0) {
 
            std::cout << "\n";
            std::cout << "#=====================================================\n";
            std::cout << "#           ________________  .____         \n";
            std::cout << "#           \\_   _____/     \\ |    |      \n";
            std::cout << "#            |    __)/  \\ /  \\|    |      \n";
            std::cout << "#            |     \\/    Y    \\    |___   \n";
            std::cout << "#            \\___  /\\____|__  /_______ \\ \n";
            std::cout << "#                \\/         \\/        \\/ \n";
            std::cout << "#\n";
 
            std::cout << "# Initializing FML, MPI and FFTW\n";
#ifdef USE_MPI
            std::cout << "# MPI is enabled. Running with " << NTasks << " MPI tasks\n";
#else
            std::cout << "# MPI is *not* enabled\n";
#endif
#ifdef USE_OMP
            std::cout << "# OpenMP is enabled. Main task has " << NThreads << " threads availiable\n";
#else
            std::cout << "# OpenMP is *not* enabled\n";
#endif
#if defined(USE_MPI) && defined(USE_OMP)
            std::cout << "# MPI + Threads is" << (FML::MPIThreadsOK ? " " : " *not* ") << "working\n";
#endif
#ifdef USE_FFTW
            std::cout << "# FFTW is enabled. ";
            std::cout << "Thread support is" << (FML::FFTWThreadsOK ? " " : " *not* ") << "enabled\n";
#else
            std::cout << "# FFTW is *not* enabled\n";
#endif
            std::cout << "#\n";
            std::cout << "# List of tasks:\n";
        }
 
        for (int i = 0; i < NTasks; i++) {
            if (FML::ThisTask == i) {
                std::cout << "# Task " << std::setw(4) << i << " [" << processor_name << "]\n";
                std::cout << "#     x-domain [" << std::setw(8) << FML::xmin_domain << " , " << std::setw(8)
                          << FML::xmax_domain << ")" << std::endl;
            }
#ifdef USE_MPI
            // Sleep to syncronize output to screen (this is not guaranteed to ensure syncronized output, but the only
            // alternative is communiation and its not that important)
            MPI_Barrier(MPI_COMM_WORLD);
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
#endif
        }
 
        if (FML::ThisTask == 0) {
            std::cout << std::flush;
            std::cout << "#\n";
            std::cout << "#=====================================================\n";
            std::cout << "\n";
        }
 
#ifdef USE_MPI
        MPI_Barrier(MPI_COMM_WORLD);
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
#endif
    }

◆ init_fml()

void FML::init_fml ( )

Initialize the global variables within FML We here assume MPI has been initialized.

Definition at line 71 of file Global.cpp.

                    {
#ifdef USE_MPI
        MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
        MPI_Comm_size(MPI_COMM_WORLD, &NTasks);
        int plen;
        char pname[MPI_MAX_PROCESSOR_NAME];
        MPI_Get_processor_name(pname, &plen);
        processor_name = std::string(pname);
#else
        ThisTask = 0;
        NTasks = 1;
        processor_name = "ComputerNameNotAvailiable";
#endif
 
        // Initialize OpenMP
#ifdef USE_OMP
#pragma omp parallel
        {
            int id = omp_get_thread_num();
            if (id == 0)
                NThreads = omp_get_num_threads();
        }
#else
        NThreads = 1;
#endif
 
        // Set range for local domain
        xmin_domain = ThisTask / double(NTasks);
        xmax_domain = (ThisTask + 1) / double(NTasks);
    }

◆ init_mpi()

void FML::init_mpi	(	int *	argc,
		char ***	argv
	)

Initialize MPI.

This function is automatically called unless NO_AUTO_MPI_SETUP is defined

Definition at line 55 of file Global.cpp.

                                                                               {
#ifdef USE_MPI
#ifdef USE_OMP
        int provided;
        MPI_Init_thread(argc, argv, MPI_THREAD_FUNNELED, &provided);
        MPIThreadsOK = provided >= MPI_THREAD_FUNNELED;
#else
        MPI_Init(argc, argv);
#endif
#endif
    }

◆ MaxOverTasks()

template<class T >

void FML::MaxOverTasks ( T * value )

Inplace max over tasks of a single value.

Definition at line 121 of file Global.h.

                                                  {
        if (FML::NTasks == 1)
            return;
        std::vector<T> values = GatherFromTasks(value);
        T maxvalue = *value;
        for (auto v : values)
            if (maxvalue < v)
                maxvalue = v;
        *value = maxvalue;
    }

◆ MinOverTasks()

template<class T >

void FML::MinOverTasks ( T * value )

Inplace min over tasks of a single value.

Definition at line 134 of file Global.h.

                                                  {
        if (FML::NTasks == 1)
            return;
        std::vector<T> values = GatherFromTasks(value);
        T minvalue = *value;
        for (auto v : values)
            if (minvalue > v)
                minvalue = v;
        *value = minvalue;
    }

◆ operator!=()

template<typename T , typename U >

bool FML::operator!=	(	const LogAllocator< T > &	a,
		const LogAllocator< U > &	b
	)

inline

Definition at line 308 of file MemoryLogging.h.

                                                                                 {
        return not(a == b);
    }

◆ operator==()

template<typename T , typename U >

bool FML::operator==	(	const LogAllocator< T > &	,
		const LogAllocator< U > &
	)

inline

Definition at line 303 of file MemoryLogging.h.

                                                                             {
        return true;
    }

◆ OPS()

FML::OPS ( + ) const &

◆ power()

constexpr long long int FML::power	(	int	base,
		int	exponent
	)

constexpr

Simple integer a^b power-function by squaring.

Definition at line 187 of file Global.h.

                                                          {
        return exponent == 0 ?
                   1 :
                   (exponent % 2 == 0 ?
                        power(base, exponent / 2) * power(base, exponent / 2) :
                        (long long int)(base)*power(base, (exponent - 1) / 2) * power(base, (exponent - 1) / 2));
    }

◆ print_system_memory_use()

void FML::print_system_memory_use ( )

Print the resident set size and the peak value of it so far.

Definition at line 233 of file Global.cpp.

                                   {
        auto sysmem = FML::get_system_memory_use();
        double cur_rss = sysmem.first / 1e6;
        double peak_rss = sysmem.second / 1e6;
        double min_cur_rss = cur_rss;
        double max_cur_rss = cur_rss;
        double min_peak = peak_rss;
        double max_peak = peak_rss;
        FML::MinOverTasks(&min_cur_rss);
        FML::MaxOverTasks(&max_cur_rss);
        FML::MinOverTasks(&min_peak);
        FML::MaxOverTasks(&max_peak);
        if (FML::ThisTask == 0) {
            std::cout << "#=====================================================\n";
            std::cout << "# System memory use (resident set size): \n";
            std::cout << "# Current RSS: " << std::setw(15) << min_cur_rss << " MB (min over tasks)\n";
            std::cout << "# Current RSS: " << std::setw(15) << max_cur_rss << " MB (max over tasks)\n";
            std::cout << "# Peak RSS:    " << std::setw(15) << min_peak << " MB (min over tasks)\n";
            std::cout << "# Peak RSS:    " << std::setw(15) << max_peak << " MB (max over tasks)\n";
            std::cout << "#=====================================================\n";
        }
    }

◆ printf_mpi()

void FML::printf_mpi	(	const char *	fmt,
			...
	)

Definition at line 193 of file Global.cpp.

                                           {
        if (FML::ThisTask == 0) {
            va_list argp;
            va_start(argp, fmt);
            std::vfprintf(stdout, fmt, argp);
            std::fflush(stdout);
            va_end(argp);
        }
    }

◆ SumArrayOverTasks()

template<class T >

void FML::SumArrayOverTasks	(	T *	value,
		int	n
	)

Inplace sum over tasks of a contigious array of values.

Definition at line 160 of file Global.h.

                                                              {
        if (FML::NTasks == 1)
            return;
        for(int i = 0; i < n; i++){
          SumOverTasks(&value[i]);
        }
    }

◆ SumOverTasks()

template<class T >

void FML::SumOverTasks ( T * value )

Inplace sum over tasks of a single value.

Definition at line 147 of file Global.h.

                                                  {
        if (FML::NTasks == 1)
            return;
        std::vector<T> values = GatherFromTasks(value);
        T sum = 0;
        for (auto v : values) {
            sum += v;
        }
        *value = sum;
    }

◆ TYPES() [1/9]

FML::TYPES ( char )

◆ TYPES() [2/9]

FML::TYPES ( double )

◆ TYPES() [3/9]

FML::TYPES ( float )

◆ TYPES() [4/9]

FML::TYPES ( int )

◆ TYPES() [5/9]

FML::TYPES ( long double )

◆ TYPES() [6/9]

FML::TYPES ( long long )

◆ TYPES() [7/9]

FML::TYPES ( ptrdiff_t )

◆ TYPES() [8/9]

FML::TYPES ( size_t )

◆ TYPES() [9/9]

FML::TYPES ( unsigned int )

◆ uniform_random()

auto FML::uniform_random ( )

Definition at line 46 of file Global.cpp.

                            {
        auto udist = std::uniform_real_distribution<double>(0.0, 1.0);
        return udist(generator);
    }

◆ y()

Vector< T > FML::y ( n )

Variable Documentation

◆ exp

const double FML::exp

Initial value:

{

const size_t n = x.size()

Definition at line 259 of file Global.h.

◆ FFTWThreadsOK

bool FML::FFTWThreadsOK = false

Definition at line 37 of file Global.cpp.

◆ fmlsetup

FMLSetup& FML::fmlsetup = FMLSetup::init()

Definition at line 24 of file Global.cpp.

◆ generator

std::mt19937 FML::generator

Definition at line 45 of file Global.cpp.

◆ global_timer

FML::UTILS::Timings FML::global_timer

Definition at line 18 of file Global.cpp.

◆ MPIThreadsOK

bool FML::MPIThreadsOK = false

If MPI and threads can work together with FFTW.

Definition at line 38 of file Global.cpp.

◆ NTasks

int FML::NTasks = 1

Total number of MPI tasks.

Definition at line 34 of file Global.cpp.

◆ NThreads

int FML::NThreads = 1

Total number of threads availiable.

Definition at line 35 of file Global.cpp.

◆ ThisTask

int FML::ThisTask = 0

The MPI task number.

Definition at line 33 of file Global.cpp.

◆ xmax_domain

double FML::xmax_domain = 1.0

The local extent of the domain (global domain goes from 0 to 1)

Definition at line 42 of file Global.cpp.

◆ xmin_domain

double FML::xmin_domain = 0.0

The local extent of the domain (global domain goes from 0 to 1)

Definition at line 41 of file Global.cpp.

◆ y

return FML::y

Definition at line 265 of file Global.h.

Namespaces

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

◆ Allocator

◆ IndexIntType

◆ TimePoint

◆ Vector

Function Documentation

◆ __assert_mpi()

◆ abort_mpi()

◆ create_folder()

◆ finalize_mpi()

◆ for()

◆ GatherFromTasks()

◆ get_system_memory_use()

◆ info()

◆ init_fml()

◆ init_mpi()

◆ MaxOverTasks()

◆ MinOverTasks()

◆ operator!=()

◆ operator==()

◆ OPS()

◆ power()

◆ print_system_memory_use()

◆ printf_mpi()

◆ SumArrayOverTasks()

◆ SumOverTasks()

◆ TYPES() [1/9]

◆ TYPES() [2/9]

◆ TYPES() [3/9]

◆ TYPES() [4/9]

◆ TYPES() [5/9]

◆ TYPES() [6/9]

◆ TYPES() [7/9]

◆ TYPES() [8/9]

◆ TYPES() [9/9]

◆ uniform_random()

◆ y()

Variable Documentation

◆ exp

◆ FFTWThreadsOK

◆ fmlsetup

◆ generator

◆ global_timer

◆ MPIThreadsOK

◆ NTasks

◆ NThreads

◆ ThisTask

◆ xmax_domain

◆ xmin_domain

◆ y