C++ API

C++ Module Structure

The setup and execute functions in C++ modules should be enclosed in extern "C" { ... } to enable cosmosis to fund them.

Here’s an example module:

#include "cosmosis/datablock/datablock.hh"
#include "cosmosis/datablock/section_names.h"


extern "C" {
void * setup(DataBlock * options)
{
    // Read options from the CosmoSIS configuration ini file,
    // passed via the "options" argument

    // Record any configuration information required

    // Pass back any object you like
}

DATABLOCK_STATUS execute(DataBlock * block, void * config)
{
    // Config is whatever you returned from setup above
    // Block is the collection of parameters and calculations for
    // this set of cosmological parameters

    DATABLOCK_STATUS status = 0;

    return status;
}
}

Getters

The DataBlock class that you get passed in the setup and execute functions has methods for loading and saving data.

get_val is a template method that gets (i.e. reads/loads) any kind of object from the data block, depending on the type of value. You can optionally also supply a default value:

// get functions return the status, and set the value of their
// output argument only upon success.

template <class T>
DATABLOCK_STATUS
DataBlock::get_val(std::string section,
                   std::string name,
                   T& val);

template <class T>
DATABLOCK_STATUS
DataBlock::get_val(std::string section,
                   std::string name,
                   T const& def,
                   T& val);

Setters

put_val is a template method that puts (i.e. writes/saves) any kind of object into the data block, depending on the type of value:

template <class T>
DATABLOCK_STATUS
DataBlock::put_val(std::string section,
                   std::string name,
                   T const& val);

Replacers

replace_val replaces (overwrites) an existing object in the data block:

template <class T>
DATABLOCK_STATUS
DataBlock::replace_val(std::string section,
                       std::string name,
                       T const& val);

Data Types

The data types T for any of these methods can be any of:

int
double
std::string
std::complex<double>
std::vector<int>
std::vector<double>
std::vector<std::string>
std::vector<std::complex<double>>
cosmosis::ndarray<int>
cosmosis::ndarray<double>
cosmosis::ndarray<std::complex>

Array data types are done using the std::vector types above. There are C++ standard library types for arrays.

Multidimensional arrays are done using the cosmosis::ndarray.

Introspection

These methods check what is in the data block

// Return true if the datablock has a value in the given
// section with the given name, and false otherwise.
bool has_val(std::string section,
             std::string name) const;

// Return -1 if no parameter of the given name in the given section
// is found, or if the parameter is not an array. Return -2 if the
// length of the array is larger than MAXINT. Otherwise, return the
// length of the array.
int get_size(std::string section,
             std::string name) const;


// Return true if the DataBlock has a section with the given name.
bool has_section(std::string name) const;

// Return the extents of the array of the given name in the given
// section. If the found item is actually an array carrying the
// right fundamental data type, return DBS_SUCCESS and fill in
// extents. If no object is found, or if the object is not an array,
// return an error status, and do no modify extents.
template <class T>
DATABLOCK_STATUS get_array_shape(std::string section,
                                 std::string name,
                                 std::vector<std::size_t>& extents);

// Get the type, if any, of the named object. The types are
// identified by the enumeration type datablock_type_t. Returns
// DBS_SUCCESS if found.
DATABLOCK_STATUS get_type(std::string section,
                          std::string name,
                          datablock_type_t& t) const;