namespace Gambit::Printers #

Forward declaration. More…

Namespaces #

Classes #

Types #

Functions #

Attributes #

Detailed Description #

Forward declaration.

Forward declaration of Printers::BasePrinter class for use in print functions.

Types Documentation #

typedef BaseBufferMap #

typedef std::map<VBIDpair, VertexBufferBase*> Gambit::Printers::BaseBufferMap;

Helpful typedefs.

Type of the global buffer map

typedef ushort #

typedef unsigned short int Gambit::Printers::ushort;

PRINT FUNCTIONS Need to define one of these for every type we want to print!

enum Tags #

Reserved tags for MPI messages TAG_REQ - for messages registering/requesting a new tags INIT_PASS - for messages registering completion of initialisation PPFILES_PASS - for messages registering completion of preprocessing of existing files (combination/deletion) FINAL_PASS - for messages registering passing of checkpoint during finalise PPID_SEND - for messages transferring point ID information N_BUFFERS_SENT - for messages counting the number of buffer transfer messages being sent in one ‘package’ RA_BUFFERS_SENT - Contains no data, just indicates that RA buffer messages from some process are waiting to send. FINAL_SYNC - Contains no data, used to trigger final buffer sends and receives.

typedef uint #

typedef unsigned int Gambit::Printers::uint;

typedef ulong #

typedef unsigned long Gambit::Printers::ulong;

typedef longlong #

typedef long long Gambit::Printers::longlong;

typedef ulonglong #

typedef unsigned long long Gambit::Printers::ulonglong;

typedef create_reader_function #

typedef BaseReader * Gambit::Printers::create_reader_function(const Options &);

typedef LineBuf #

typedef std::map<int, std::vector<double> > Gambit::Printers::LineBuf;

typedef Buffer #

typedef std::map<std::pair<int,int>,Record> Gambit::Printers::Buffer;

typedef sql_callback_fptr #

typedef int Gambit::Printers::sql_callback_fptr(void *, int, char **, char **);

typedef llint #

typedef long long int Gambit::Printers::llint;

typedef str #

typedef std::string Gambit::Printers::str;

Functions Documentation #

function error_if_key_exists #

template <class T ,
class U >
void error_if_key_exists(
    const std::map< T, U > & m,
    const T & key,
    const std::string & tag
)

Helper function to check if a VertexBuffer key already exists in a map.

function printAllH5Types #

void printAllH5Types(
    void 
)

DEBUG: print to stdout all HDF5 type IDs.

function SQLiteReader::get_sql_col< std::string > #

std::string SQLiteReader::get_sql_col< std::string >(
    const std::string & col_name
)

function getTypeID #

template <class T >
std::size_t getTypeID(
    void 
)

Author: Ben Farmer (ben.farmer@gmail.com)

Date: 2016 Mar, 2017 Jan, Feb, Mar

Helper template functions to retrieve type IDs for a type. ID is just a unique integer for each printable type

function parse_label_for_ModelParameters #

bool parse_label_for_ModelParameters(
    const std::string & fulllabel,
    const std::string & modelname,
    std::string & out,
    std::string & rest,
    bool case_sensitive =true
)

Helper function for the ModelParameters ‘_retrieve’ functions Parses a printer label and checks if it contains a single model parameter. “out” is a memory location to store the parameter name, if found. “labelroot” is a memory location to store the rest of the label (i.e. minus the parameter name)

function parse_label_for_spectrum_entry #

bool parse_label_for_spectrum_entry(
    const std::string & fulllabel,
    const std::string & req_capability,
    const std::string & req_module,
    const std::string & req_function,
    std::string & outname,
    std::string & outtag,
    std::string & labelroot,
    bool case_sensitive =true
)

Helper function for parsing Spectrum label strings.

Helper function for the Spectrum ‘_retrieve’ functions Parses a printer label and checks if it contains a single Spectrum entry. “out” is a memory location to store the spectrum entry name, if found. “labelroot” is a memory location to store the rest of the label (i.e. minus the entry name)

function printAllTypeIDs #

void printAllTypeIDs(
    void 
)

For debugging; print to stdout all the typeIDs for all types.

function auto_increment #

EXPORT_SYMBOLS bool & auto_increment()

Global flag to indicate if auto-incrementing of the PointID by the likelihood container is allowed.

function get_point_id #

EXPORT_SYMBOLS unsigned long long int & get_point_id()

Returns unigue pointid;.

Global scan point ID number.

function get_param_id #

EXPORT_SYMBOLS int get_param_id(
    const std::string & name,
    bool & is_new
)

Consolidated ‘get id’ function, for both main and aux.

bjf> I think that there is actually no need or reason to maintain two separate lists of IDs. I am changing this to now use only one list, although both old ways of accessing the IDs (main vs aux) will still exist for backwards compatibility.

function get_param_id #

EXPORT_SYMBOLS int get_param_id(
    const std::string & name
)

function get_all_params #

EXPORT_SYMBOLS std::vector< std::string > get_all_params()

Get names of all parameters known to printer system (vector index corresponds to ID number)

Get names of all parameters known to printer system (vector index corresponds to ID number) Assumes IDs were assigned starting at zero and incrementing upwards! This should be what is happening, but just keep note of this in case of future changes!

function get_main_param_id #

EXPORT_SYMBOLS int get_main_param_id(
    const std::string & name
)

Returns unique positive parameter id; just a thin wrapper for get_param_id.

function get_main_param_id #

EXPORT_SYMBOLS int get_main_param_id(
    const std::string & name,
    bool & is_new
)

Extra argument returns true if new ID was assigned.

function get_aux_param_id #

EXPORT_SYMBOLS int get_aux_param_id(
    const std::string & name
)

Returns unique negative parameter id; just a thin wrapper for get_param_id.

function get_aux_param_id #

EXPORT_SYMBOLS int get_aux_param_id(
    const std::string & name,
    bool & is_new
)

Extra argument returns true if new ID was assigned.

function _common_print #

template <typename P ,
typename T >
void _common_print(
    P & ,
    T const & ,
    const std::string & ,
    const int ,
    const unsigned int ,
    const unsigned long 
)

Common print overload template.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    std::vector< double > const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

Vector-of-doubles print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    const map_const_str_dbl & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

String-to-double map print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    const map_str_dbl & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    const map_const_str_map_const_str_dbl & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

String-to-map print overload (where map is string-to-double)

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    const map_str_map_str_dbl & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    const map_str_str & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

String-to-string map print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    map_intpair_dbl const & map,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

Integer pair-to-double map print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    ModelParameters const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

ModelParameters print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    triplet< double > const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

Triplet print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    DM_nucleon_couplings const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

DM-nucleon coupling print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    flav_prediction const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

Generic flavour prediction print overload.

function _common_print #

template <typename P >
void _common_print(
    P & printer,
    BBN_container const & value,
    const std::string & label,
    const int vID,
    const unsigned int mpirank,
    const unsigned long pointID
)

BBN observables print overload.

function h5v2_type #

template <class T >
constexpr int h5v2_type()

Typedef’d types; enabled only where they differ from the true types.

function h5v2_type< int > #

constexpr int h5v2_type< int >()

function h5v2_type< unsigned int > #

constexpr int h5v2_type< unsigned int >()

function h5v2_type< long > #

constexpr int h5v2_type< long >()

function h5v2_type< unsigned long > #

constexpr int h5v2_type< unsigned long >()

function h5v2_type< long long > #

constexpr int h5v2_type< long long >()

function h5v2_type< unsigned long long > #

constexpr int h5v2_type< unsigned long long >()

function h5v2_type< float > #

constexpr int h5v2_type< float >()

function h5v2_type< double > #

constexpr int h5v2_type< double >()

function h5v2_bufname #

const int h5v2_bufname(
    10 
)

MPI tags for HDF5 printer v2.

function h5v2_bufdata_points #

const int h5v2_bufdata_points(
    11 
)

function h5v2_bufdata_ranks #

const int h5v2_bufdata_ranks(
    12 
)

function h5v2_bufdata_valid #

const int h5v2_bufdata_valid(
    13 
)

function h5v2_bufdata_type #

const int h5v2_bufdata_type(
    14 
)

function h5v2_bufdata_values #

const int h5v2_bufdata_values(
    15 
)

function h5v2_BLOCK #

const int h5v2_BLOCK(
    30 
)

function h5v2_BEGIN #

const int h5v2_BEGIN(
    31 
)

function set_diff #

template <class T >
std::set< T > set_diff(
    const std::set< T > & set1,
    const std::set< T > & set2
)

function pairfunc #

inline std::size_t pairfunc(
    const std::size_t i,
    const std::size_t j
)

function col_name_callback #

int col_name_callback(
    void * colmap_in,
    int ,
    char ** data,
    char ** 
)

function cpp2sql #

template <typename T >
std::string cpp2sql()

function cpp2sql< long long int > #

std::string cpp2sql< long long int >()

function cpp2sql< double > #

std::string cpp2sql< double >()

function cpp2sql< std::string > #

std::string cpp2sql< std::string >()

function define_typecodes #

std::map< unsigned int, std::string > define_typecodes()

function fill_SQLtype_to_basic #

std::map< std::string, std::string, Utils::ci_less > fill_SQLtype_to_basic()

function SQLite_equaltypes #

bool SQLite_equaltypes(
    const std::string & type1,
    const std::string & type2
)

function next_el #

template <typename Iter >
Iter next_el(
    Iter iter
)

function comma_unless_last #

template <typename Iter ,
typename Cont >
std::string comma_unless_last(
    Iter it,
    const Cont & c
)

function SQLiteReader::get_sql_col< std::string > #

std::string SQLiteReader::get_sql_col< std::string >(
    const std::string & col_name
)

function get_param_id_map #

std::unordered_map< std::string, long long int > & get_param_id_map()

function open_output_file #

void open_output_file(
    std::ofstream & output,
    std::string filename,
    std::ios_base::openmode mode
)

Open file stream with error checking.

function safe_col_lookup #

uint safe_col_lookup(
    const std::string & key,
    const std::map< std::string, uint > & colmap,
    std::string fname
)

Helper function for map lookup.

function check_for_error_messages #

void check_for_error_messages()

function openfile_read #

hid_t openfile_read(
    std::string file
)

function lsGroup_process #

std::vector< std::string > lsGroup_process(
    hid_t location_id
)

function cpp2sql< long long int > #

std::string cpp2sql< long long int >()

function cpp2sql< double > #

std::string cpp2sql< double >()

function cpp2sql< std::string > #

std::string cpp2sql< std::string >()

function typecode2sql #

const std::map< unsigned int, std::string > typecode2sql(
    define_typecodes() 
)

function SQLtype_to_basic #

const std::map< std::string, std::string, Utils::ci_less > SQLtype_to_basic(
    fill_SQLtype_to_basic() 
)

function operator< #

bool operator<(
    const VBIDpair & l,
    const VBIDpair & r
)

function operator== #

bool operator==(
    const VBIDpair & l,
    const VBIDpair & r
)

function operator!= #

bool operator!=(
    const VBIDpair & l,
    const VBIDpair & r
)

function operator< #

bool operator<(
    const VBIDtrip & l,
    const VBIDtrip & r
)

function operator== #

bool operator==(
    const VBIDtrip & l,
    const VBIDtrip & r
)

function operator!= #

bool operator!=(
    const VBIDtrip & l,
    const VBIDtrip & r
)

function operator< #

EXPORT_SYMBOLS bool operator<(
    const PPIDpair & l,
    const PPIDpair & r
)

function operator== #

EXPORT_SYMBOLS bool operator==(
    const PPIDpair & l,
    const PPIDpair & r
)

function operator!= #

EXPORT_SYMBOLS bool operator!=(
    const PPIDpair & l,
    const PPIDpair & r
)

function define_mpiHDF5bufferchunk #

void define_mpiHDF5bufferchunk()

function printer_error #

EXPORT_SYMBOLS error & printer_error()

Printer errors.

function printer_warning #

EXPORT_SYMBOLS warning & printer_warning()

Printer warnings.

function operator« #

std::ostream & operator<<(
    std::ostream & stream,
    const PPIDpair & ppid
)

Stream operator overloads.

Attributes Documentation #

variable gambit_registry #

gambit_registry {
            typedef BasePrinter* create_printer_function(const Options&, BasePrinter* const&);

Maps in which to keep factory functions for the printers (printer_creators) and readers (reader_creators)

variable printer_creators #

reg_elem< create_printer_function > printer_creators;

variable reader_creators #

reg_elem< create_reader_function > reader_creators;

variable BUFFERLENGTH #

static const std::size_t BUFFERLENGTH = 100;

variable MAX_PPIDPAIRS #

static const unsigned long MAX_PPIDPAIRS = 10*BUFFERLENGTH;

Max number of PPIDpairs to be tracked i.e. chunks of RA output longer than this can potentially contain multiple writes to the same point. It is up to the combine script to apply the last scheduled write preferentially.

variable HDF5_CHUNKLENGTH #

static const std::size_t HDF5_CHUNKLENGTH = 100;

Length of chunks in chunked HDF5 dataset. Affects write/retrieval performance for blocks of data of various sizes. It is set to an “intermediate” sort of size since that seems to work well enough.

variable DSETRANK #

static const std::size_t DSETRANK = 1;

Dimension of output dataset. We are only using 1D datasets for simplicity.

variable MAX_BUFFER_SIZE #

static const std::size_t MAX_BUFFER_SIZE = 100000;

Largest allowed size of buffers. Size can be dynamically set from 1 to this number.

variable CHUNKLENGTH #

static const std::size_t CHUNKLENGTH = 100;

Length of dataset chunks read into memory during certain search operations. For maximum efficiency this should probably match the chunking length used to write the files in the first place.

variable typecode2sql #

const std::map< unsigned int, std::string > typecode2sql;

variable SQLtype_to_basic #

const std::map< std::string, std::string, Utils::ci_less > SQLtype_to_basic;

variable FIRST_EMPTY_TAG #

const int FIRST_EMPTY_TAG = FINAL_SYNC+1;

variable nullpoint #

EXPORT_SYMBOLS const PPIDpair nullpoint = PPIDpair();

Define ’nullpoint’ const.

Updated on 2023-06-26 at 21:36:52 +0000