Store JO metadata specific to the Bmumu analysis. More...

#include <Bmumu_metadata.h>

Inheritance diagram for DerivationFramework::Bmumu_metadata:

Collaboration diagram for DerivationFramework::Bmumu_metadata:

Public Member Functions
	Bmumu_metadata (const std::string &t, const std::string &n, const IInterface *p)
	Main constructor.
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
virtual StatusCode	addBranches (const EventContext &ctx) const

Protected Member Functions
virtual void	recordPropertyI (const std::string &name, int val)
virtual void	recordPropertyL (const std::string &name, long val)
virtual void	recordPropertyD (const std::string &name, double val)
virtual void	recordPropertyB (const std::string &name, bool val)
virtual void	recordPropertyS (const std::string &name, const std::string &val)
virtual void	recordPropertyVI (const std::string &name, const std::vector< int > &val)
virtual void	recordPropertyVL (const std::string &name, const std::vector< long > &val)
virtual void	recordPropertyVD (const std::string &name, const std::vector< double > &val)
virtual void	recordPropertyVB (const std::string &name, const std::vector< bool > &val)
virtual void	recordPropertyVS (const std::string &name, const std::vector< std::string > &val)

Private Member Functions
virtual StatusCode	saveMetaDataBPhys () const
virtual std::string	buildFolderName (const std::string &fname="") const
virtual std::string	vecToString (const std::vector< int > &v) const
virtual std::string	vecToString (const std::vector< long > &v) const
virtual std::string	vecToString (const std::vector< double > &v) const
virtual std::string	vecToString (const std::vector< bool > &v) const
virtual std::string	vecToString (const std::vector< std::string > &v) const

Private Attributes
ServiceHandle< StoreGateSvc >	m_outputMetaStore
	Object accessing the output metadata store.
std::string	m_derivationName
std::string	m_mdFolderName
std::string	m_prefix
std::map< std::string, int >	m_propInt
std::map< std::string, long >	m_propLong
std::map< std::string, double >	m_propDouble
std::map< std::string, bool >	m_propBool
std::map< std::string, std::string >	m_propString
std::map< std::string, std::vector< int > >	m_propVInt
std::map< std::string, std::vector< long > >	m_propVLong
std::map< std::string, std::vector< double > >	m_propVDouble
std::map< std::string, std::vector< bool > >	m_propVBool
std::map< std::string, std::vector< std::string > >	m_propVString

Detailed Description

Store JO metadata specific to the Bmumu analysis.

Author: Wolfgang Walkowiak <Wolfg.nosp@m.ang..nosp@m.Walko.nosp@m.wiak.nosp@m.@cern.nosp@m..ch.>

Store JO metadata specific to the Bmumu analysis in the output file. This class inherits from BPhysMetadataBase.

Definition at line 34 of file Bmumu_metadata.h.

Constructor & Destructor Documentation

◆ Bmumu_metadata()

DerivationFramework::Bmumu_metadata::Bmumu_metadata	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Main constructor.

Definition at line 16 of file Bmumu_metadata.cxx.

                                       : 
    BPhysMetadataBase(t,n,p) {
 
    // configuration defaults etc.
    recordPropertyI("verbose", 0);
    recordPropertyB("isSimulation", false);
    recordPropertyS("projectTag", "__NONE__");
    recordPropertyB("isRelease21" , true);
    recordPropertyS("mcCampaign", "__NONE__");
    recordPropertyS("triggerStream", "__NONE__");
    
    // MC dataset number lists
    recordPropertyVI("mcBsmumu"         , {});
    recordPropertyVI("mcBplusJpsiKplus" , {});
    recordPropertyVI("mcBsJpsiPhi"      , {});
    recordPropertyVI("mcBplusJpsiPiplus", {});
    recordPropertyVI("mcBhh"            , {});
 
    // MC datasets without trigger information
    recordPropertyVI("mcNoTrigger"     , {});
 
    // special data runs
    recordPropertyVI("specDataRuns", {});
    
    // special MC channels
    recordPropertyVI("specMcChannels", {});
    
    // blind search
    recordPropertyB("doBmumuBlinding"       , true);
    recordPropertyB("doCutBlinded"          , true);
    recordPropertyB("blindOnlyAllMuonsTight", true);
    recordPropertyS("BlindingKey"           , "");
    recordPropertyS("BlindedVars"           , "");
    recordPropertyS("BlindingFlag"          , "");
    
    // include trigger
    recordPropertyB("doTriggerInfo"  , true);
 
    // include soft B tagging vertex containers
    recordPropertyB("doAddSoftBVertices"    , true);
 
    // trigger navigation thinning
    recordPropertyB("doTrigNavThinning", true);
    recordPropertyVS("TrigNavThinList" , {});
 
    // wide mumu mass range
    recordPropertyB("doUseWideMuMuMassRange", false);
 
    // use mass calculated using the combined muon track information in cuts?
    recordPropertyB("useMuCalcMass",    true);
 
    // use calibrated muons instead of the original ones
    recordPropertyI("useCalibratedMuons", 0);
 
    // adjust primary track to muon kinematics for MUCALC mass
    recordPropertyB("adjustMucalcKinematics", false);
 
    // add MUCALC mass from non-modified muons for debugging
    recordPropertyB("addMucalcMassForDebug", false);
 
    // primary vertex types to consider for MinChi2ToAnyPV
    recordPropertyVI("MinChi2ToAnyPVTypes", {1, 3});
    
    // JpsiFinder: muAndMu or TrackAndTrack option?
    recordPropertyB("JfTwoMuons" , true );
    recordPropertyB("JfTwoTracks", false);
 
    // JpsiFinder: TrackThresholdPt
    recordPropertyD("JfTrackThresholdPt", 0.);
    
    // muon calibration and smearing tool configuration
    recordPropertyS("McstYear"                 , "Data16");
    recordPropertyS("McstRelease"              , "_NONE_");
    recordPropertyB("McstStatComb"             , true);
    recordPropertyB("McstSagittaCorr"          , true);
    recordPropertyS("McstSagittaRelease"       , "_NONE_");
    recordPropertyB("McstDoSagittaMCDistortion", false);
    recordPropertyB("McstSagittaCorrPhaseSpace", true);
    
    // muon collections
    recordPropertyS("MuonCollection"     , "Muons");
    recordPropertyS("CalMuonCollection"  , "Muons");
    recordPropertyS("UsedMuonCollection" , "Muons");
    recordPropertyVS("AllMuonCollections", {}     );
 
    // Global mass values (in MeV, from PDG 2015)
    recordPropertyD("GlobalMuonMass" ,  ParticleConstants::muonMassInMeV);
    recordPropertyD("GlobalPionMass" ,  ParticleConstants::chargedPionMassInMeV);
    recordPropertyD("GlobalKaonMass" ,  ParticleConstants::chargedKaonMassInMeV );
    recordPropertyD("GlobalJpsiMass" ,  ParticleConstants::JpsiMassInMeV  );
    recordPropertyD("GlobalBplusMass",  ParticleConstants::BPlusMassInMeV );
    recordPropertyD("GlobalB0Mass"   ,  ParticleConstants::BZeroMassInMeV );
    recordPropertyD("GlobalBsMass"   ,  ParticleConstants::BsMassInMeV );
 
    // mass ranges
    recordPropertyD("GlobalBMassUpperCut"     , 7000.);
    recordPropertyD("GlobalBMassLowerCut"     , 3500.);
    recordPropertyD("GlobalDiMuonMassUpperCut", 7000.);
    recordPropertyD("GlobalDiMuonMassLowerCut", 2000.);
    recordPropertyD("GlobalJpsiMassUpperCut"  , 7000.);
    recordPropertyD("GlobalJpsiMassLowerCut"  , 2000.);
    recordPropertyD("GlobalBlindUpperCut"     , 5166.);
    recordPropertyD("GlobalBlindLowerCut"     , 5526.);
    recordPropertyD("GlobalTrksMassUpperCut"  , 7500.);
    recordPropertyD("GlobalTrksMassLowerCut"  , 3000.);
    
    // Global chi2 cut for vertexing
    recordPropertyD("GlobalChi2CutBase", 15.0);
    // Different chi2 cuts for 2-, 3- and 4-prong vertices
    recordPropertyD("Chi2Cut2Prong"    , 30.0);
    recordPropertyD("Chi2Cut3Prong"    , 45.0);
    recordPropertyD("Chi2Cut4Prong"    , 60.0);
 
    // Cut values for kaon candidates
    recordPropertyD("GlobalKaonPtCut" , 1000.); // MeV
    recordPropertyD("GlobalKaonEtaCut",  2.5 );
 
    // MCP cuts for JpsiFinder
    recordPropertyB("useJpsiFinderMCPCuts", false);
 
    // reject muons in JpsiPlus1Track or JpsiPlus2Track finders
    recordPropertyS("GlobalMuonsUsedInJpsi", "NONE"); // turn off by default
 
    // run number
    recordPropertyI("runNumber", -1);
 
    // MC channel number
    recordPropertyI("mcChNumber", -1);
    
    // channels to be processed
    recordPropertyVS("doChannels", {});
 
    // vertex types to be done
    recordPropertyI("doVertexType", 7);
    
    // minimum number of tracks in PV considered for PV association
    recordPropertyI("minNTracksInPV", 0);
 
    // mode of minLogChi2ToAnyPV calculation
    recordPropertyI("AddMinChi2ToAnyPVMode", 0);
 
    // record 3-dimensional proper time in addition
    recordPropertyB("do3dProperTime", false);
    
    // thinning level
    recordPropertyI("thinLevel", 0);
 
    // selection expression
    recordPropertyS("SelExpression", "");
    
    // MC truth decay parents
    recordPropertyVI("TruthDecayParents", {});
 
    // vertex isolation properties
    recordPropertyVS("IsoTrackCategoryName" , {});
    recordPropertyVS("IsoTrackCutLevel"     , {});
    recordPropertyVD("IsoTrackPtCut"        , {});
    recordPropertyVD("IsoTrackEtaCut"       , {});
    recordPropertyVI("IsoTrackPixelHits"    , {});
    recordPropertyVI("IsoTrackSCTHits"      , {});
    recordPropertyVI("IsoTrackbLayerHits"   , {});
    recordPropertyVI("IsoTrackIBLHits"      , {});
    recordPropertyVD("IsolationConeSizes"   , {});
    recordPropertyVD("IsoTrkImpLogChi2Max"  , {});
    recordPropertyVI("IsoDoTrkImpLogChi2Cut", {});
    recordPropertyVL("useIsoTrackTypes"     , {});
    recordPropertyB("IsoUseOptimizedAlgo"   ,  true);
    recordPropertyS("IsoTvaWorkingPoint"    , "Nominal");
    recordPropertyVS("IsoIncludes"          , {});
 
    
    // muon isolation properties (muons of B candidate)
    recordPropertyVS("MuIsoTrackCategoryName" , {});
    recordPropertyVS("MuIsoTrackCutLevel"     , {});
    recordPropertyVD("MuIsoTrackPtCut"        , {});
    recordPropertyVD("MuIsoTrackEtaCut"       , {});
    recordPropertyVI("MuIsoTrackPixelHits"    , {});
    recordPropertyVI("MuIsoTrackSCTHits"      , {});
    recordPropertyVI("MuIsoTrackbLayerHits"   , {});
    recordPropertyVI("MuIsoTrackIBLHits"      , {});
    recordPropertyVD("MuIsolationConeSizes"   , {});
    recordPropertyVD("MuIsoTrkImpLogChi2Max"  , {});
    recordPropertyVI("MuIsoDoTrkImpLogChi2Cut", {});
    recordPropertyVL("useMuIsoTrackTypes"     , {});
    recordPropertyS("MuIsoTvaWorkingPoint"    , "Nominal");
    recordPropertyVS("MuIsoIncludes"          , {});
 
    // closest track properties
    recordPropertyVS("CloseTrackCategoryName"  , {});
    recordPropertyVS("CloseTrackCutLevel"      , {});
    recordPropertyVD("CloseTrackPtCut"         , {});
    recordPropertyVD("CloseTrackEtaCut"        , {});
    recordPropertyVI("CloseTrackPixelHits"     , {});
    recordPropertyVI("CloseTrackSCTHits"       , {});
    recordPropertyVI("CloseTrackbLayerHits"    , {});
    recordPropertyVI("CloseTrackIBLHits"       , {});
    recordPropertyVL("useCloseTrackTypes"      , {});
    recordPropertyVS("CloseTrackChi2SetName"   , {});
    recordPropertyVI("CloseTrackCorrChi2"      , {});
    recordPropertyVB("CloseTrackMinDCAin3D"    , {});
    recordPropertyVD("CloseTrackMaxLogChi2"    , {});
    recordPropertyVD("NCloseTrackMaxLogChi2"   , {});
    recordPropertyS("CloseTrackTvaWorkingPoint", "Nominal");
    recordPropertyVS("CloseTrackIncludes"      , {});
 
    // debug track types for isolation and closest track tools
    recordPropertyI("DebugTrackTypes", 0);
 
    // track-to-vertex association check tool
    recordPropertyI("DebugTrkToVtxMaxEvents" , 0);
 
    // output containers and branch prefixes
    // (mostly used for isolation tools)
    recordPropertyS("TrkPartContName", "InDetTrackParticles");
    recordPropertyS("PVContName"     , "PrimaryVertices");
    recordPropertyVS("VtxContNames"  , {} );
    recordPropertyVS("RefPVContNames", {} );
    recordPropertyVS("BranchPrefixes", {} );
 
  }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::BPhysMetadataBase::addBranches ( const EventContext & ctx ) const

virtualinherited

Definition at line 91 of file BPhysMetadataBase.cxx.

                                                                     {
 
    // nothing to do here
    return StatusCode::SUCCESS;
  }  

◆ buildFolderName()

std::string DerivationFramework::BPhysMetadataBase::buildFolderName ( const std::string & fname = "" ) const

privatevirtualinherited

Definition at line 149 of file BPhysMetadataBase.cxx.

                                                                           {
 
    std::string result = fname;
    if ( m_mdFolderName != "_NONE_" && m_mdFolderName != "" ) {
      result += m_mdFolderName;
    } else {
      if ( m_derivationName != "_NOSUCHFORMAT_" && m_derivationName != "" ) {
        result += m_derivationName;
      } else {
        // default to the tool's name
        result += name();
      }
    }
    return result;
  }

◆ finalize()

StatusCode DerivationFramework::BPhysMetadataBase::finalize ( )

virtualinherited

Definition at line 83 of file BPhysMetadataBase.cxx.

                                         {
 
    ATH_MSG_DEBUG("BPhysMetaDataBase::finalize()");
 
    // everything all right
    return StatusCode::SUCCESS;
  }

◆ initialize()

StatusCode DerivationFramework::BPhysMetadataBase::initialize ( )

virtualinherited

Definition at line 63 of file BPhysMetadataBase.cxx.

                                           {
  
    ATH_MSG_DEBUG("BPhysMetaDataBase::initialize() -- begin");
 
    // handle general prefix
    if ( m_prefix == "" ) {
      if ( m_derivationName == "_NOSUCHFORMAT_" ) {
    m_prefix = name() +"_";
      } else {
    m_prefix = m_derivationName + "_";
      }
    }
      
    CHECK( saveMetaDataBPhys() );
    
    ATH_MSG_DEBUG("BPhysMetaDataBase::initialize() -- end");
 
    return StatusCode::SUCCESS;
  }

◆ recordPropertyB()

void DerivationFramework::BPhysMetadataBase::recordPropertyB	(	const std::string &	name,
		bool	val )

protectedvirtualinherited

Definition at line 180 of file BPhysMetadataBase.cxx.

                                                                         {
    ATH_MSG_INFO("Calling recordProperty(bool)");
    declareProperty(name, m_propBool[name] = val);
  }

◆ recordPropertyD()

void DerivationFramework::BPhysMetadataBase::recordPropertyD	(	const std::string &	name,
		double	val )

protectedvirtualinherited

Definition at line 175 of file BPhysMetadataBase.cxx.

                                                                           {
    ATH_MSG_INFO("Calling recordProperty(double)");
    declareProperty(name, m_propDouble[name] = val);
  }

◆ recordPropertyI()

void DerivationFramework::BPhysMetadataBase::recordPropertyI	(	const std::string &	name,
		int	val )

protectedvirtualinherited

Definition at line 165 of file BPhysMetadataBase.cxx.

                                                                        {
    ATH_MSG_INFO("Calling recordProperty(int)");
    declareProperty(name, m_propInt[name] = val);
  }

◆ recordPropertyL()

void DerivationFramework::BPhysMetadataBase::recordPropertyL	(	const std::string &	name,
		long	val )

protectedvirtualinherited

Definition at line 170 of file BPhysMetadataBase.cxx.

                                                                         {
    ATH_MSG_INFO("Calling recordProperty(long)");
    declareProperty(name, m_propLong[name] = val);
  }

◆ recordPropertyS()

void DerivationFramework::BPhysMetadataBase::recordPropertyS	(	const std::string &	name,
		const std::string &	val )

protectedvirtualinherited

Definition at line 185 of file BPhysMetadataBase.cxx.

                                                                                     {
    ATH_MSG_INFO("Calling recordProperty(string)");
    declareProperty(name, m_propString[name] = val);
  }

◆ recordPropertyVB()

void DerivationFramework::BPhysMetadataBase::recordPropertyVB	(	const std::string &	name,
		const std::vector< bool > &	val )

protectedvirtualinherited

Definition at line 208 of file BPhysMetadataBase.cxx.

                                                {
    ATH_MSG_INFO("Calling recordProperty(vector<bool>)");
    declareProperty(name, m_propVBool[name] = val);
  }

◆ recordPropertyVD()

void DerivationFramework::BPhysMetadataBase::recordPropertyVD	(	const std::string &	name,
		const std::vector< double > &	val )

protectedvirtualinherited

Definition at line 202 of file BPhysMetadataBase.cxx.

                                                     {
    ATH_MSG_INFO("Calling recordProperty(vector<double>)");
    declareProperty(name, m_propVDouble[name] = val);
  }

◆ recordPropertyVI()

void DerivationFramework::BPhysMetadataBase::recordPropertyVI	(	const std::string &	name,
		const std::vector< int > &	val )

protectedvirtualinherited

Definition at line 190 of file BPhysMetadataBase.cxx.

                                                  {
    ATH_MSG_INFO("Calling recordProperty(vector<int>)");
    declareProperty(name, m_propVInt[name] = val);
  }

◆ recordPropertyVL()

void DerivationFramework::BPhysMetadataBase::recordPropertyVL	(	const std::string &	name,
		const std::vector< long > &	val )

protectedvirtualinherited

Definition at line 196 of file BPhysMetadataBase.cxx.

                                                   {
    ATH_MSG_INFO("Calling recordProperty(vector<long>)");
    declareProperty(name, m_propVLong[name] = val);
  }

◆ recordPropertyVS()

void DerivationFramework::BPhysMetadataBase::recordPropertyVS	(	const std::string &	name,
		const std::vector< std::string > &	val )

protectedvirtualinherited

Definition at line 214 of file BPhysMetadataBase.cxx.

                                                        {
    ATH_MSG_INFO("Calling recordProperty(vector<string>)");
    declareProperty(name, m_propVString[name] = val);
  }

◆ saveMetaDataBPhys()

StatusCode DerivationFramework::BPhysMetadataBase::saveMetaDataBPhys ( ) const

privatevirtualinherited

Definition at line 103 of file BPhysMetadataBase.cxx.

                                                        {
    
    ATH_MSG_DEBUG("BPhysMetaDataBase::saveMetaDataBPhys() -- begin");
 
    std::string mdFolderKey = buildFolderName() + "_MetaData";
    // protection
    if ( m_outputMetaStore->contains< xAOD::FileMetaData >( mdFolderKey ) ) {
      ATH_MSG_WARNING("saveMetaDataBPhys2: "
              "xAOD::FileMetaData already in output: "
              << mdFolderKey
              << " -- BPhys metadata will NOT be saved!");
    } else {
      // create a FileMetaData object
      auto fm    = std::make_unique< xAOD::FileMetaData >();
      auto fmAux = std::make_unique< xAOD::FileMetaDataAuxInfo >();
      fm->setStore( fmAux.get() );
      
      // fill it
      SG::Accessor<std::string> DerivationNameAcc(m_prefix+"DerivationName");
      DerivationNameAcc(*fm) = m_derivationName;
 
      SG::Accessor<std::string> MetaDatafolderNameAcc(m_prefix+"MetaDataFolderName");
      MetaDatafolderNameAcc(*fm) = m_mdFolderName;
 
      // fill it with contents of maps
      SET_VALUES_IMP( int                     , m_propInt     );
      SET_VALUES_IMP( long                    , m_propLong    );
      SET_VALUES_IMP( double                  , m_propDouble  );
      SET_VALUES_IMP( bool                    , m_propBool    );
      SET_VALUES_IMP( std::string             , m_propString  );
      SET_VALUES_IMP( std::vector<int>        , m_propVInt    );
      SET_VALUES_IMP( std::vector<long>       , m_propVLong   );
      SET_VALUES_IMP( std::vector<double>     , m_propVDouble );
      SET_VALUES_IMP( std::vector<bool>       , m_propVBool   );
      SET_VALUES_IMP( std::vector<std::string>, m_propVString );
      
      // record it
      ATH_CHECK( m_outputMetaStore->record( std::move(fm), mdFolderKey ) );
      ATH_CHECK( m_outputMetaStore->record( std::move(fmAux),
                        mdFolderKey+"Aux." ) );
    }
 
    return StatusCode::SUCCESS;
  }

◆ vecToString() [1/5]

std::string DerivationFramework::BPhysMetadataBase::vecToString ( const std::vector< bool > & v ) const

privatevirtualinherited

Definition at line 250 of file BPhysMetadataBase.cxx.

                                                                         {
    std::string str("[");
    for (unsigned int i=0; i<v.size(); ++i) {
      str += std::to_string(v[i]);
      if ( i < v.size()-1 ) str += ",";
    }
    str += "]";
    return str;
  }

◆ vecToString() [2/5]

std::string DerivationFramework::BPhysMetadataBase::vecToString ( const std::vector< double > & v ) const

privatevirtualinherited

Definition at line 240 of file BPhysMetadataBase.cxx.

                                                                           {
    std::string str("[");
    for (unsigned int i=0; i<v.size(); ++i) {
      str += std::to_string(v[i]);
      if ( i < v.size()-1 ) str += ",";
    }
    str += "]";
    return str;
  }

◆ vecToString() [3/5]

std::string DerivationFramework::BPhysMetadataBase::vecToString ( const std::vector< int > & v ) const

privatevirtualinherited

Definition at line 220 of file BPhysMetadataBase.cxx.

                                                                        {
    std::string str("[");
    for (unsigned int i=0; i<v.size(); ++i) {
      str += std::to_string(v[i]);
      if ( i < v.size()-1 ) str += ",";
    }
    str += "]";
    return str;
  }

◆ vecToString() [4/5]

std::string DerivationFramework::BPhysMetadataBase::vecToString ( const std::vector< long > & v ) const

privatevirtualinherited

Definition at line 230 of file BPhysMetadataBase.cxx.

                                                                         {
    std::string str("[");
    for (unsigned int i=0; i<v.size(); ++i) {
      str += std::to_string(v[i]);
      if ( i < v.size()-1 ) str += ",";
    }
    str += "]";
    return str;
  }

◆ vecToString() [5/5]

std::string DerivationFramework::BPhysMetadataBase::vecToString ( const std::vector< std::string > & v ) const

privatevirtualinherited

Definition at line 260 of file BPhysMetadataBase.cxx.

                                                                              {
    std::string str("[");
    for (unsigned int i=0; i<v.size(); ++i) {
      str += "'";
      str += v[i];
      str += "'";
      if ( i < v.size()-1 ) str += ",";
    }
    str += "]";
    return str;
  }

Member Data Documentation

◆ m_derivationName

std::string DerivationFramework::BPhysMetadataBase::m_derivationName

privateinherited

Definition at line 81 of file BPhysMetadataBase.h.

◆ m_mdFolderName

std::string DerivationFramework::BPhysMetadataBase::m_mdFolderName

privateinherited

Definition at line 82 of file BPhysMetadataBase.h.

◆ m_outputMetaStore

ServiceHandle< StoreGateSvc > DerivationFramework::BPhysMetadataBase::m_outputMetaStore

privateinherited

Object accessing the output metadata store.

Definition at line 78 of file BPhysMetadataBase.h.

◆ m_prefix

std::string DerivationFramework::BPhysMetadataBase::m_prefix

privateinherited

Definition at line 83 of file BPhysMetadataBase.h.

◆ m_propBool

std::map<std::string, bool> DerivationFramework::BPhysMetadataBase::m_propBool

privateinherited

Definition at line 89 of file BPhysMetadataBase.h.

◆ m_propDouble

std::map<std::string, double> DerivationFramework::BPhysMetadataBase::m_propDouble

privateinherited

Definition at line 88 of file BPhysMetadataBase.h.

◆ m_propInt

std::map<std::string, int> DerivationFramework::BPhysMetadataBase::m_propInt

privateinherited

Definition at line 86 of file BPhysMetadataBase.h.

◆ m_propLong

std::map<std::string, long> DerivationFramework::BPhysMetadataBase::m_propLong

privateinherited

Definition at line 87 of file BPhysMetadataBase.h.

◆ m_propString

std::map<std::string, std::string> DerivationFramework::BPhysMetadataBase::m_propString

privateinherited

Definition at line 90 of file BPhysMetadataBase.h.

◆ m_propVBool

std::map<std::string, std::vector<bool> > DerivationFramework::BPhysMetadataBase::m_propVBool

privateinherited

Definition at line 94 of file BPhysMetadataBase.h.

◆ m_propVDouble

std::map<std::string, std::vector<double> > DerivationFramework::BPhysMetadataBase::m_propVDouble

privateinherited

Definition at line 93 of file BPhysMetadataBase.h.

◆ m_propVInt

std::map<std::string, std::vector<int> > DerivationFramework::BPhysMetadataBase::m_propVInt

privateinherited

Definition at line 91 of file BPhysMetadataBase.h.

◆ m_propVLong

std::map<std::string, std::vector<long> > DerivationFramework::BPhysMetadataBase::m_propVLong

privateinherited

Definition at line 92 of file BPhysMetadataBase.h.

◆ m_propVString

std::map<std::string, std::vector<std::string> > DerivationFramework::BPhysMetadataBase::m_propVString

privateinherited

Definition at line 95 of file BPhysMetadataBase.h.

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Bmumu_metadata()

Member Function Documentation

◆ addBranches()

◆ buildFolderName()

◆ finalize()

◆ initialize()

◆ recordPropertyB()

◆ recordPropertyD()

◆ recordPropertyI()

◆ recordPropertyL()

◆ recordPropertyS()

◆ recordPropertyVB()

◆ recordPropertyVD()

◆ recordPropertyVI()

◆ recordPropertyVL()

◆ recordPropertyVS()

◆ saveMetaDataBPhys()

◆ vecToString() [1/5]

◆ vecToString() [2/5]

◆ vecToString() [3/5]

◆ vecToString() [4/5]

◆ vecToString() [5/5]

Member Data Documentation

◆ m_derivationName

◆ m_mdFolderName

◆ m_outputMetaStore

◆ m_prefix

◆ m_propBool

◆ m_propDouble

◆ m_propInt

◆ m_propLong

◆ m_propString

◆ m_propVBool

◆ m_propVDouble

◆ m_propVInt

◆ m_propVLong

◆ m_propVString