CP::TreeBranchHelpers::BranchConfig Struct Reference

the user configuration of an output branch More...

#include <TreeBranchHelpers.h>

Collaboration diagram for CP::TreeBranchHelpers::BranchConfig:

Public Member Functions
StatusCode	parse (const std::string &branchDecl, MsgStream &msg)
	parse the user configuration string
StatusCode	configureTypes (std::set< std::string > &decosWithoutType, MsgStream &msg)
	configure the associated decoration types
StatusCode	configureSystematics (ISystematicsSvc &sysSvc, MsgStream &msg)
	configure the systematics

Public Attributes
std::string	branchDecl
	the original user configuration string
std::string	sgName
	the SG name of the object to read from
std::string	auxName
	the aux data variable name to read from
std::string	branchName
	the name of the output branch
std::string	typeName
	the name of the type (or empty to read from aux-registry)
bool	nominalOnly = false
	whether we only want to write out the nominal
std::optional< int >	basketSize
	the basket size for this branch
std::string	metTermName
	MET ONLY: the name of the MET term to write out.
SG::auxid_t	nominalAuxId = SG::null_auxid
	the aux-id for the nominal decoration
const std::type_info *	auxType = nullptr
	the type of the decoration we read
const std::type_info *	auxVecType = nullptr
	the vector type of the decoration we read
const SG::IAuxTypeVectorFactory *	auxFactory = nullptr
	pointer to the aux vector factory
CP::SystematicSet	sgNameFilterSys
	the affecting systematics for the sgName
CP::SystematicSet	auxNameFilterSys
	the affecting systematics for the auxName
CP::SystematicSet	branchNameFilterSys
	the affecting systematics for the branchName

Detailed Description

the user configuration of an output branch

Definition at line 61 of file TreeBranchHelpers.h.

Member Function Documentation

configureSystematics()

StatusCode CP::TreeBranchHelpers::BranchConfig::configureSystematics	(	ISystematicsSvc &	sysSvc,
		MsgStream &	msg )

configure the systematics

Definition at line 463 of file TreeBranchHelpers.cxx.

    {
      if (sgName.find ("%SYS%") == std::string::npos &&
          auxName.find ("%SYS%") == std::string::npos &&
          branchName.find ("%SYS%") == std::string::npos)
      {
        nominalOnly = true;
      }
      if (!nominalOnly)
      {
        if (branchName.find ("%SYS%") == std::string::npos)
        {
          msg << MSG::ERROR << "Branch with systematics without %SYS% in branch name: "
              << branchName << endmsg;
          return StatusCode::FAILURE;
        }
        if (sgName.find ("%SYS%") == std::string::npos &&
            auxName.find ("%SYS%") == std::string::npos)
        {
          msg << MSG::ERROR << "Branch with systematics without %SYS% in SG or aux name: "
              << sgName << "." << auxName << endmsg;
          return StatusCode::FAILURE;
        }
        if (auxName.find ("NOSYS") != std::string::npos)
        {
          msg << MSG::ERROR << "Branch with systematics with NOSYS in aux name: "
              << sgName << "." << auxName << endmsg;
          return StatusCode::FAILURE;
        }
        if (sgName.find ("NOSYS") != std::string::npos && auxName.find ("%SYS%") == std::string::npos)
        {
          msg << MSG::ERROR << "Branch with NOSYS in SG name but without %SYS% in aux name: "
              << sgName << "." << auxName << endmsg;
          return StatusCode::FAILURE;
        }
 
        if (sgName.find ("%SYS%") != std::string::npos)
          sgNameFilterSys = sysSvc.getObjectSystematics( sgName );
 
        if (auxName.find ("%SYS%") != std::string::npos)
        {
          if (auto pos = sgName.find ("NOSYS"); pos == std::string::npos)
            auxNameFilterSys = sysSvc.getDecorSystematics (sgName, auxName);
          else
          {
            // Sometimes while object systematics were applied we are not interested in them,
            // NOSYS will then be used on the container name.
            // Decoration systematics however will only be aware of containers with %SYS% included.
            // Some special handling is needed to translate from NOSYS back to %SYS%.
            std::string sgNameSys = sgName;
            sgNameSys.replace (pos, 5, "%SYS%");
 
            // these will be the object systematics
            auto objectSys = sysSvc.getObjectSystematics (sgNameSys);
 
            // these will be all systematics (object+decor)
            auto allSys = sysSvc.getDecorSystematics (sgNameSys, auxName);
 
            // we now need to filter-out object systematics
            for (auto& variation : allSys)
            {
              if (objectSys.find (variation) == objectSys.end())
                auxNameFilterSys.insert (variation);
            }
          }
        }
 
        branchNameFilterSys = sgNameFilterSys;
        branchNameFilterSys.insert (auxNameFilterSys);
        if (branchNameFilterSys.empty())
          nominalOnly = true;
      }
 
      return StatusCode::SUCCESS;
    }

configureTypes()

StatusCode CP::TreeBranchHelpers::BranchConfig::configureTypes	(	std::set< std::string > &	decosWithoutType,
		MsgStream &	msg )

configure the associated decoration types

Definition at line 360 of file TreeBranchHelpers.cxx.

    {
      std::string nominalAuxName = auxName;
      if (auto pos = nominalAuxName.find ("%SYS%"); pos != std::string::npos)
        nominalAuxName.replace (pos, 5, "NOSYS");
      if (!typeName.empty())
      {
        if (typeName == "char")
          SG::ConstAccessor<char> {nominalAuxName};
        else if (typeName == "float")
          SG::ConstAccessor<float> {nominalAuxName};
        else if (typeName == "int")
          SG::ConstAccessor<int> {nominalAuxName};
        else if (typeName == "unsigned")
          SG::ConstAccessor<unsigned> {nominalAuxName};
        else if (typeName == "unsigned_char")
          SG::ConstAccessor<unsigned char> {nominalAuxName};
        else if (typeName == "unsigned_long_long")
          SG::ConstAccessor<unsigned long long> {nominalAuxName};
        else if (typeName == "int8")
          SG::ConstAccessor<std::int8_t> {nominalAuxName};
        else if (typeName == "int16")
          SG::ConstAccessor<std::int16_t> {nominalAuxName};
        else if (typeName == "int32")
          SG::ConstAccessor<std::int32_t> {nominalAuxName};
        else if (typeName == "int64")
          SG::ConstAccessor<std::int64_t> {nominalAuxName};
        else if (typeName == "uint8")
          SG::ConstAccessor<std::uint8_t> {nominalAuxName};
        else if (typeName == "uint16")
          SG::ConstAccessor<std::uint16_t> {nominalAuxName};
        else if (typeName == "uint32")
          SG::ConstAccessor<std::uint32_t> {nominalAuxName};
        else if (typeName == "uint64")
          SG::ConstAccessor<std::uint64_t> {nominalAuxName};
        else if (typeName == "vector_float")
          SG::ConstAccessor<std::vector<float>> {nominalAuxName};
        else if (typeName == "vector_int")
          SG::ConstAccessor<std::vector<int>> {nominalAuxName};
        else if (typeName == "vector_vector_float")
          SG::ConstAccessor<std::vector<std::vector<float>>> {nominalAuxName};
        else if (typeName == "vector_vector_int")
          SG::ConstAccessor<std::vector<std::vector<int>>> {nominalAuxName};
        else
        {
          unsigned line = __LINE__ - 2;
          std::string file = __FILE__;
          file = file.substr (file.find_last_of("/\\") + 1);
          msg << MSG::ERROR << "Unknown type requested, please extend " << file << " near line " << line << " for type " << typeName << endmsg;
          return StatusCode::FAILURE;
        }
      }
      const SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
      if (nominalAuxId == SG::null_auxid)
      {
        nominalAuxId = reg.findAuxID (nominalAuxName);
        if (nominalAuxId == SG::null_auxid)
        {
          decosWithoutType.insert (nominalAuxName);
          msg << MSG::DEBUG << "No aux ID found for auxiliary variable: " << nominalAuxName << endmsg;
          // just returning SUCCESS here, our caller will report failure
          return StatusCode::SUCCESS;
        }
      }
      if (auxType == nullptr)
      {
        auxType = reg.getType (nominalAuxId);
        if (auxType == nullptr)
        {
          msg << MSG::ERROR
              << "No std::type_info available for aux-store variable: "
              << nominalAuxName << endmsg;
          return StatusCode::FAILURE;
        }
      }
      if (auxVecType == nullptr)
      {
        auxVecType = reg.getVecType (nominalAuxId);
        if (auxVecType == nullptr)
        {
          msg << MSG::ERROR
              << "No std::type_info available for aux-store variable: "
              << nominalAuxName << endmsg;
          return StatusCode::FAILURE;
        }
      }
      if (auxFactory == nullptr)
      {
        auxFactory = reg.getFactory (nominalAuxId);
        if (auxFactory == nullptr)
        {
          msg << MSG::ERROR
              << "No factory found for auxiliary variable: "
              << nominalAuxName << endmsg;
          return StatusCode::FAILURE;
        }
      }
      return StatusCode::SUCCESS;
    }

parse()

StatusCode CP::TreeBranchHelpers::BranchConfig::parse	(	const std::string &	branchDecl,
		MsgStream &	msg )

parse the user configuration string

Definition at line 320 of file TreeBranchHelpers.cxx.

    {
      // The regular expression used to extract the needed info. The logic
      // is supposed to be:
      //
      // (match[1]).(match[2])<any whitespace>-><any whitespace>(match[3])[<any whitespace>type=(match[5])][<any whitespace>metTerm=(match[7])][<any whitespace>basketSize=(match[9])]
      //
      // Like:
      //    "Electrons.eta  -> el_eta"
      //    "Electrons.eta  -> el_eta type=float"
      //    "MissingET.px   -> met_px metTerm=Final"
      static const std::regex
         re( "\\s*([\\w%]+)\\.([\\w%]+)\\s*->\\s*([\\w%]+)(\\s+type=([\\w%]+))?(\\s+metTerm=([\\w%]+))?(\\s+basketSize=([\\w%]+))?" );
 
      // Interpret this branch declaration.
      std::smatch match;
      if( ! std::regex_match( branchDecl, match, re ) ) {
        msg << MSG::ERROR << "Expression \"" << branchDecl << "\" doesn't match \"<object>.<variable> -> <branch>\"" << endmsg;
         return StatusCode::FAILURE;
      }
      this->branchDecl = branchDecl;
      sgName = match[ 1 ];
      auxName = match[ 2 ];
      branchName = match[ 3 ];
      typeName = match[ 5 ];
      metTermName = match[ 7 ];
      if (match[9].matched) {
        try {
          basketSize = std::stoi(match[9]);
        } catch (const std::exception& ) {
          msg << MSG::ERROR << "Could not parse basket size value: " << match[9] << endmsg;
          return StatusCode::FAILURE;
        }
      }
      return StatusCode::SUCCESS;
    }

Member Data Documentation

auxFactory

const SG::IAuxTypeVectorFactory* CP::TreeBranchHelpers::BranchConfig::auxFactory = nullptr

pointer to the aux vector factory

Definition at line 98 of file TreeBranchHelpers.h.

auxName

std::string CP::TreeBranchHelpers::BranchConfig::auxName

the aux data variable name to read from

Definition at line 70 of file TreeBranchHelpers.h.

auxNameFilterSys

CP::SystematicSet CP::TreeBranchHelpers::BranchConfig::auxNameFilterSys

the affecting systematics for the auxName

Definition at line 105 of file TreeBranchHelpers.h.

auxType

const std::type_info* CP::TreeBranchHelpers::BranchConfig::auxType = nullptr

the type of the decoration we read

Definition at line 92 of file TreeBranchHelpers.h.

auxVecType

const std::type_info* CP::TreeBranchHelpers::BranchConfig::auxVecType = nullptr

the vector type of the decoration we read

Definition at line 95 of file TreeBranchHelpers.h.

basketSize

std::optional<int> CP::TreeBranchHelpers::BranchConfig::basketSize

the basket size for this branch

Definition at line 82 of file TreeBranchHelpers.h.

branchDecl

std::string CP::TreeBranchHelpers::BranchConfig::branchDecl

the original user configuration string

Definition at line 64 of file TreeBranchHelpers.h.

branchName

std::string CP::TreeBranchHelpers::BranchConfig::branchName

the name of the output branch

Definition at line 73 of file TreeBranchHelpers.h.

branchNameFilterSys

CP::SystematicSet CP::TreeBranchHelpers::BranchConfig::branchNameFilterSys

the affecting systematics for the branchName

Definition at line 108 of file TreeBranchHelpers.h.

metTermName

std::string CP::TreeBranchHelpers::BranchConfig::metTermName

MET ONLY: the name of the MET term to write out.

Definition at line 85 of file TreeBranchHelpers.h.

nominalAuxId

SG::auxid_t CP::TreeBranchHelpers::BranchConfig::nominalAuxId = SG::null_auxid

the aux-id for the nominal decoration

Definition at line 89 of file TreeBranchHelpers.h.

nominalOnly

bool CP::TreeBranchHelpers::BranchConfig::nominalOnly = false

whether we only want to write out the nominal

Definition at line 79 of file TreeBranchHelpers.h.

sgName

std::string CP::TreeBranchHelpers::BranchConfig::sgName

the SG name of the object to read from

Definition at line 67 of file TreeBranchHelpers.h.

sgNameFilterSys

CP::SystematicSet CP::TreeBranchHelpers::BranchConfig::sgNameFilterSys

the affecting systematics for the sgName

Definition at line 102 of file TreeBranchHelpers.h.

typeName

std::string CP::TreeBranchHelpers::BranchConfig::typeName

the name of the type (or empty to read from aux-registry)

Definition at line 76 of file TreeBranchHelpers.h.

---

The documentation for this struct was generated from the following files:

• TreeBranchHelpers.h
• TreeBranchHelpers.cxx