All classes in the ldmx-sw project use this namespace. More...

Classes
class	AbortEventException
	Specific exception used to abort an event. More...

class	Analyzer
	Base class for a module which does not produce a data product. More...

class	Bus
	A map of bus passengers. More...

class	Conditions
	Container and cache for conditions and conditions providers. More...

class	ConditionsIOV
	Class which defines the run/event/type range for which a given condition is valid, including for all time. More...

class	ConditionsObject
	Base class for all conditions objects, very simple. More...

class	ConditionsObjectProvider
	Base class for all providers of conditions objects. More...

class	ConfigurePython
	Utility class which reads/executes a python script and creates a Process object based on the input. More...

class	Event
	Implements an event buffer system for storing event data. More...

class	EventFile
	This class manages all ROOT file input/output operations. More...

class	EventProcessor
	Base class for all event processing components. More...

class	HistogramHelper
	Interface class between an EventProcessor and the HistogramPool. More...

class	HistogramPool
	Singleton class used to create and pool histograms. More...

class	NtupleManager
	Singleton class used to manage the creation and pooling of ntuples. More...

class	PluginFactory
	Singleton module factory that creates EventProcessor objects. More...

class	Process
	Class which represents the process under execution. More...

class	Producer
	Base class for a module which produces a data product. More...

class	ProductTag
	Defines the identity of a product and can be used for searches. More...

class	RandomNumberSeedService
	System for consistent seeding of random number generators. More...

class	StorageControl
	Class which encapsulates storage control functionality, used by the Process class. More...

Typedefs
typedef ConditionsObjectProvider *	ConditionsObjectProviderMaker(const std::string &objname, const std::string &tagname, const framework::config::Parameters &params, Process &process)
	Typedef for PluginFactory use.

typedef EventProcessor *	EventProcessorMaker(const std::string &name, Process &process)
	Typedef for EventProcessorFactory use.

typedef std::unique_ptr< Process >	ProcessHandle
	A handle to the current process Used to pass a process from ConfigurePython to fire.cxx.

Functions
static std::string	getPyString (PyObject *pyObj)
	Turn the input python string object into a C++ string.

std::string	repr (PyObject *obj)
	Get a C++ string representation of the input python object.

PyObject *	extractDictionary (PyObject *obj)
	extract the dictionary of attributes from the input python object

static std::map< std::string, std::any >	getMembers (PyObject *object)
	Extract members from a python object.

static regex_t	construct_regex (const std::string &pattern, bool full_string_match)
	Construct an actual regex from the pass pattern (and full-string flag)

Variables
constexpr StorageControl::Hint	hint_shouldKeep
	storage control hint alias for backwards compatibility

constexpr StorageControl::Hint	hint_shouldDrop
	storage control hint alias for backwards compatibility

static const int	SEED_EXTERNAL = 2

static const int	SEED_RUN = 3

static const int	SEED_TIME = 4

Detailed Description

All classes in the ldmx-sw project use this namespace.

Typedef Documentation

◆ ConditionsObjectProviderMaker

typedef ConditionsObjectProvider * framework::ConditionsObjectProviderMaker(const std::string &objname, const std::string &tagname, const framework::config::Parameters &params, Process &process)

Typedef for PluginFactory use.

Definition at line 40 of file ConditionsObjectProvider.h.

◆ EventProcessorMaker

typedef EventProcessor * framework::EventProcessorMaker(const std::string &name, Process &process)

Typedef for EventProcessorFactory use.

Definition at line 38 of file EventProcessor.h.

◆ ProcessHandle

typedef std::unique_ptr<Process> framework::ProcessHandle

A handle to the current process Used to pass a process from ConfigurePython to fire.cxx.

Definition at line 248 of file Process.h.

Function Documentation

◆ construct_regex()

static regex_t framework::construct_regex	(	const std::string &	pattern,
		bool	full_string_match
	)

static

Construct an actual regex from the pass pattern (and full-string flag)

If the pattern is the empty string, then we generate the match-all regex .*.

If the pattern is not empty and we want to match on full-strings, then we prepend the pattern with ^ and append the pattern with $ to inform regex that the pattern should match the entire string.

Parameters

[in]	pattern	a regex pattern string
[in]	full_string_match	flag if we want full-string matches only (true) or if we can include sub-strings (false)

Returns: generated regex structure, expecting user to call regfree on it when done

Definition at line 47 of file Event.cxx.

                                                       {
  std::string pattern_regex{pattern};
  if (pattern_regex.empty())
    pattern_regex = ".*";
  else if (full_string_match)
    pattern_regex = "^" + pattern_regex + "$";
 
  regex_t reg;
  if (regcomp(&reg, pattern_regex.c_str(),
              REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
    // use input value in exception since we expect our code above evolving
    // the regex to be accurate
    EXCEPTION_RAISE("InvalidRegex", "The passed regex '" + pattern +
                                        "' is not a valid regular expression.");
  }
  return reg;
}

Referenced by framework::Event::searchProducts().

◆ extractDictionary()

PyObject * framework::extractDictionary ( PyObject * obj )

extract the dictionary of attributes from the input python object

This is separated into its own function to isolate the code that depends on the python version. Since memory-saving measures were integrated into Python between 3.6.9 and 3.10.6, we need to alter how we were using the C API to access an objects dict attribute. We are now using a "hidden" Python C API function which has only been added to the public C API documentation in Python 3.11. It has been manually tested for the two different Python versions we use by running the tests (some of which test the ConfigurePython) and running a basic simulation.

Exceptions

Exception if object does not have a dict and isn't a dict

Parameters

obj	pointer to python object to extract from

Returns: pointer to python dictionary for its members

Definition at line 74 of file ConfigurePython.cxx.

                                           {
#if PY_MAJOR_VERSION != 3
#error("Framework requires compiling with Python3")
#else
#if PY_MINOR_VERSION != 10 && PY_MINOR_VERSION != 6
#warning("Unrecognized Python3 minor version. Unsure if accessing C API properly for configuration.")
#endif
  PyObject** p_dictionary{_PyObject_GetDictPtr(obj)};
  if (p_dictionary == NULL) {
    if (PyDict_Check(obj)) {
      return obj;
    } else {
      EXCEPTION_RAISE("ObjFail",
                      "Python Object '" + repr(obj) +
                          "' does not have __dict__ member and is not a dict.");
    }
  }
  return *p_dictionary;
#endif
}

References repr().

Referenced by getMembers().

◆ getMembers()

static std::map< std::string, std::any > framework::getMembers ( PyObject * object )

static

Extract members from a python object.

Iterates through the object's dictionary and translates the objects inside of it into the type-specified C++ equivalents, then puts these objects into a STL map that can be passed to the Parameters class.

This function is recursive. If a non-base type is encountered, we pass it back along to this function to translate it's own dictionary.

We rely completely on python being awesome. For all higher level class objects, python keeps track of all of its member variables in the member dictionary dict.

No Py_DECREF calls are made because all of the members of an object are borrowed references, meaning that when we destory that object, it handles the other members. We destroy the one parent object pProcess at the end of ConfigurePython::ConfigurePython.

Note: Not sure if this is not leaking memory, kinda just trusting the Python / C API docs on this one.; Empty lists are NOT read in because there is no way for us to know what type should be inside the list. This means list parameters that can be empty need to put in a default empty list value: {}.

Parameters

object Python object to get members from

Returns: Mapping between member name and value.

Definition at line 136 of file ConfigurePython.cxx.

                                                              {
  PyObject* dictionary{extractDictionary(object)};
  PyObject *key(0), *value(0);
  Py_ssize_t pos = 0;
 
  std::map<std::string, std::any> params;
 
  while (PyDict_Next(dictionary, &pos, &key, &value)) {
    std::string skey{getPyString(key)};
    if (PyLong_Check(value)) {
      if (PyBool_Check(value)) {
        params[skey] = bool(PyLong_AsLong(value));
      } else {
        params[skey] = int(PyLong_AsLong(value));
      }
    } else if (PyFloat_Check(value)) {
      params[skey] = PyFloat_AsDouble(value);
    } else if (PyUnicode_Check(value)) {
      params[skey] = getPyString(value);
    } else if (PyList_Check(value)) {
      // assume everything is same value as first value
      if (PyList_Size(value) > 0) {
        auto vec0{PyList_GetItem(value, 0)};
 
        if (PyLong_Check(vec0)) {
          std::vector<int> vals;
 
          for (auto j{0}; j < PyList_Size(value); j++)
            vals.push_back(PyLong_AsLong(PyList_GetItem(value, j)));
 
          params[skey] = vals;
 
        } else if (PyFloat_Check(vec0)) {
          std::vector<double> vals;
 
          for (auto j{0}; j < PyList_Size(value); j++)
            vals.push_back(PyFloat_AsDouble(PyList_GetItem(value, j)));
 
          params[skey] = vals;
 
        } else if (PyUnicode_Check(vec0)) {
          std::vector<std::string> vals;
          for (Py_ssize_t j = 0; j < PyList_Size(value); j++) {
            PyObject* elem = PyList_GetItem(value, j);
            vals.push_back(getPyString(elem));
          }
 
          params[skey] = vals;
        } else if (PyList_Check(vec0)) {
          // a list in a list ??? oof-dah
          if (PyList_Size(vec0) > 0) {
            auto vecvec0{PyList_GetItem(vec0, 0)};
            if (PyLong_Check(vecvec0)) {
              std::vector<std::vector<int>> vals;
              for (auto j{0}; j < PyList_Size(value); j++) {
                auto subvec{PyList_GetItem(value, j)};
                std::vector<int> subvals;
                for (auto k{0}; k < PyList_Size(subvec); k++) {
                  subvals.push_back(PyLong_AsLong(PyList_GetItem(subvec, k)));
                }
                vals.push_back(subvals);
              }
              params[skey] = vals;
            } else if (PyFloat_Check(vecvec0)) {
              std::vector<std::vector<double>> vals;
              for (auto j{0}; j < PyList_Size(value); j++) {
                auto subvec{PyList_GetItem(value, j)};
                std::vector<double> subvals;
                for (auto k{0}; k < PyList_Size(subvec); k++) {
                  subvals.push_back(
                      PyFloat_AsDouble(PyList_GetItem(subvec, k)));
                }
                vals.push_back(subvals);
              }
              params[skey] = vals;
            } else if (PyUnicode_Check(vecvec0)) {
              std::vector<std::vector<std::string>> vals;
              for (auto j{0}; j < PyList_Size(value); j++) {
                auto subvec{PyList_GetItem(value, j)};
                std::vector<std::string> subvals;
                for (auto k{0}; k < PyList_Size(subvec); k++) {
                  subvals.push_back(getPyString(PyList_GetItem(subvec, k)));
                }
                vals.push_back(subvals);
              }
              params[skey] = vals;
            } else if (PyList_Check(vecvec0)) {
              EXCEPTION_RAISE("BadConf",
                              "A python list with dimension greater than 2 is "
                              "not supported.");
            } else {
              // RECURSION zoinks!
              std::vector<std::vector<framework::config::Parameters>> vals;
              for (auto j{0}; j < PyList_Size(value); j++) {
                auto subvec{PyList_GetItem(value, j)};
                std::vector<framework::config::Parameters> subvals;
                for (auto k{0}; k < PyList_Size(subvec); k++) {
                  subvals.emplace_back();
                  subvals.back().setParameters(
                      getMembers(PyList_GetItem(subvec, k)));
                }
                vals.push_back(subvals);
              }
              params[skey] = vals;
            }
          }  // non-zero size
        } else {
          // RECURSION zoinks!
          // If the objects stored in the list doesn't
          // satisfy any of the above conditions, just
          // create a vector of parameters objects
          std::vector<framework::config::Parameters> vals;
          for (auto j{0}; j < PyList_Size(value); ++j) {
            auto elem{PyList_GetItem(value, j)};
            vals.emplace_back();
            vals.back().setParameters(getMembers(elem));
          }
          params[skey] = vals;
        }  // type of object in python list
      }    // python list has non-zero size
    } else {
      // object got here, so we assume
      // it is a higher level object
      //(same logic as last option for a list)
 
      // RECURSION zoinks!
      framework::config::Parameters val;
      val.setParameters(getMembers(value));
 
      params[skey] = val;
 
    }  // python object type
  }    // loop through python dictionary
 
  return params;
}

References extractDictionary(), getMembers(), getPyString(), and framework::config::Parameters::setParameters().

Referenced by framework::ConfigurePython::ConfigurePython(), and getMembers().

◆ getPyString()

static std::string framework::getPyString ( PyObject * pyObj )

static

Turn the input python string object into a C++ string.

Helpful to condense down the multi-line nature of the python3 code.

Parameters

[in] python object assumed to be a string python object

Returns: the value stored in it

Definition at line 33 of file ConfigurePython.cxx.

                                              {
  std::string retval;
  PyObject* pyStr = PyUnicode_AsEncodedString(pyObj, "utf-8", "Error ~");
  retval = PyBytes_AS_STRING(pyStr);
  Py_XDECREF(pyStr);
  return retval;
}

Referenced by getMembers(), and repr().

◆ repr()

std::string framework::repr ( PyObject * obj )

Get a C++ string representation of the input python object.

This is replicating the repr(obj) syntax of Python.

Parameters

[in] obj python object to get repr for

Returns: std::string form of repr

Definition at line 49 of file ConfigurePython.cxx.

                              {
  PyObject* py_repr = PyObject_Repr(obj);
  if (py_repr == nullptr) return "";
  std::string str = getPyString(py_repr);
  Py_XDECREF(py_repr);
  return str;
}

References getPyString().

Referenced by extractDictionary().

Variable Documentation

◆ hint_shouldDrop

constexpr StorageControl::Hint framework::hint_shouldDrop

constexpr

Initial value:

=

StorageControl::Hint::ShouldDrop

storage control hint alias for backwards compatibility

Definition at line 139 of file StorageControl.h.

Referenced by dqm::EcalDigiVerifier::analyze(), recon::RecoilMissesEcalSkimmer::produce(), recon::EcalPreselectionSkimmer::produce(), ecal::DNNEcalVetoProcessor::produce(), ecal::EcalVetoProcessor::produce(), hcal::HcalAlignPolarfires::produce(), hcal::HcalVetoProcessor::produce(), hcal::HcalWABVetoProcessor::produce(), recon::SequentialTrigger::produce(), and recon::TriggerProcessor::produce().

◆ hint_shouldKeep

constexpr StorageControl::Hint framework::hint_shouldKeep

constexpr

Initial value:

=

StorageControl::Hint::ShouldKeep

storage control hint alias for backwards compatibility

Definition at line 133 of file StorageControl.h.

Referenced by dqm::EcalDigiVerifier::analyze(), recon::RecoilMissesEcalSkimmer::produce(), recon::EcalPreselectionSkimmer::produce(), ecal::DNNEcalVetoProcessor::produce(), ecal::EcalVetoProcessor::produce(), hcal::HcalAlignPolarfires::produce(), hcal::HcalVetoProcessor::produce(), hcal::HcalWABVetoProcessor::produce(), recon::SequentialTrigger::produce(), and recon::TriggerProcessor::produce().

◆ SEED_EXTERNAL

const int framework::SEED_EXTERNAL = 2

static

Definition at line 14 of file RandomNumberSeedService.cxx.

◆ SEED_RUN

const int framework::SEED_RUN = 3

static

Definition at line 15 of file RandomNumberSeedService.cxx.

◆ SEED_TIME

const int framework::SEED_TIME = 4

static

Definition at line 16 of file RandomNumberSeedService.cxx.

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ ConditionsObjectProviderMaker

◆ EventProcessorMaker

◆ ProcessHandle

Function Documentation

◆ construct_regex()

◆ extractDictionary()

◆ getMembers()

◆ getPyString()

◆ repr()

Variable Documentation

◆ hint_shouldDrop

◆ hint_shouldKeep

◆ SEED_EXTERNAL

◆ SEED_RUN

◆ SEED_TIME