CP::PileupReweightingTool Class Reference

Implementation of the PileupReweighting tool. More...

#include <PileupReweightingTool.h>

Inheritance diagram for CP::PileupReweightingTool:

Public Member Functions
virtual UInt_t	GetRandomLumiBlockNumber (UInt_t runNumber)
	Get a random lumiblock number for the given run number.
virtual Double_t	GetIntegratedLumi (UInt_t start, UInt_t end)
	Get the integrated luminosity (in pb-1) between start and end run (inclusive)
virtual Double_t	GetIntegratedLumi (const TString &trigger)
	Total lumi (in pb-1) for a given trigger combination .. leave blank for the unprescaled.
virtual Double_t	GetIntegratedLumi (Int_t periodNumber, UInt_t start, UInt_t end)
	similar to above, but for only the given mcRunNumber/periodNumber
virtual Double_t	GetIntegratedLumiFraction (Int_t periodNumber, UInt_t start, UInt_t end)
	return fraction of lumi assigned to periodNumber (or mcRunNumber) that is between start and end data run numbers
virtual Double_t	GetIntegratedLumiFraction (Int_t periodNumber, Double_t mu, UInt_t start, UInt_t end)
	return fraction of lumi assigned to periodNumber (or mcRunNumber) with given mu, that is between start and end data run numbers
virtual Int_t	AddPeriod (Int_t periodNumber, UInt_t start, UInt_t end)
	use these methods when generating config files
virtual Int_t	SetBinning (Int_t nbinsx, Double_t *xbins, Int_t nbinsy=0, Double_t *ybins=0)
virtual Int_t	SetUniformBinning (Int_t nbinsx, Double_t xlow, Double_t xup, Int_t nbinsy=0, Double_t ylow=0, Double_t yup=0)
virtual Int_t	SetBinning (TH1 *hist)
virtual Double_t	GetSumOfEventWeights (Int_t channel)
	helpful alternative to using the EventBookkeepers info ... assuming you made your PRW Config file!!
virtual Double_t	GetNumberOfEvents (Int_t channel)
	PileupReweightingTool (const std::string &name)
	Constructor for standalone usage.
virtual StatusCode	initialize ()
	Function initialising the tool.
virtual StatusCode	finalize ()
	Finalize - can call the WriteToFile for us.
virtual StatusCode	apply (const xAOD::EventInfo &eventInfo, bool mu_dependent)
	Decorates with: MC: PileupWeight (CombinedWeight[*UnrepresentedDataWeight if action=2]), RandomRunNumber, RandomLumiBlockNumber Data: corrected_averageInteractionsPerCrossing mu_dependent says if the mu_dependency should be used for random run numbers or the data weights.
virtual float	getCombinedWeight (const xAOD::EventInfo &eventInfo, bool correctUnrepresented)
	Return combined pileup weight.
virtual float	getCombinedWeight (const xAOD::EventInfo &eventInfo, Double_t x, Double_t y, bool correctUnrepresented)
	Same as above, but for a 'custom weight' variable.
virtual float	getCombinedWeight (const xAOD::EventInfo &eventInfo, const TString &trigger, bool mu_dependent, bool correctUnrepresented)
	get combined weight (i.e. pileup weight) but with a 1./dataWeight factor applied, this if used for 'prescaling' MC
virtual ULong64_t	getPRWHash (const xAOD::EventInfo &eventInfo)
	return the prw hash used for fast updates of weights at the post-processing level ... see the share/makeWeightTree.C script for usage
virtual float	getCorrectedAverageInteractionsPerCrossing (const xAOD::EventInfo &eventInfo, bool includeDataScaleFactor)
	Get the mu of a lumiblock ... needed to 'correct' the number in datasets.
virtual float	getCorrectedActualInteractionsPerCrossing (const xAOD::EventInfo &eventInfo, bool includeDataScaleFactor)
	Get the corrected 'actual' interactions per crossing.
virtual double	getLumiBlockIntegratedLumi (const xAOD::EventInfo &eventInfo)
	Get the integrated lumi of a lumiblock (in pb-1)
virtual float	getUnrepresentedDataWeight (const xAOD::EventInfo &eventInfo)
	When using UnrepresentedDataAction=2, you may want to apply this additional weight to ensure sum of weights are preserved.
virtual float	getDataWeight (const xAOD::EventInfo &eventInfo, const TString &trigger, bool mu_dependent)
	Get the dataWeight used to 'unprescale' data collected from a given trigger combination. mu_dependency is recommended to be true.
virtual float	getPrescaleWeight (const xAOD::EventInfo &eventInfo, const TString &trigger, bool mu_dependent)
	Get weight used to 'prescale' Monte Carlo for given trigger comibnation.
virtual int	getRandomRunNumber (const xAOD::EventInfo &eventInfo, bool mu_dependent)
	Get a random run number for this MC event, using mu-dependent randomization by default ... jetetmiss seem to like it muchly.
virtual int	fill (const xAOD::EventInfo &eventInfo)
	Call this method once per event when in config file generating mode and you want standard mu reweighting.
virtual int	fill (const xAOD::EventInfo &eventInfo, Double_t x, Double_t y)
	Use this method if you want to do a generic reweighting instead.
virtual CP::TPileupReweighting *	expert ()
	Get pointer to the underlying tool - expert use only. Will require #include "PileupReweighting/TPileupReweighting.h".
bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	The ISystematicsTool methods.
CP::SystematicSet	affectingSystematics () const
	the list of all systematics this tool can be affected by
CP::SystematicSet	recommendedSystematics () const
	the list of all systematics this tool recommends to use
StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig)
	effects: configure this tool for the given list of systematic variations.
void	updateHandler (Gaudi::Details::PropertyBase &)
Int_t	Merge (TCollection *coll)
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual float	getCorrectedMu (const xAOD::EventInfo &eventInfo, bool includedDataScaleFactor=false)
	Get the corrected average mu of a lumiblock ... (averaging is over all filled BCID in the fill) The additional flag indicates if the returned value should include the data scale factor or not.
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Static Public Member Functions
static Version_t	Class_Version ()

Protected Member Functions
virtual bool	runLbnOK (Int_t runNbr, Int_t lbn)
virtual bool	passTriggerBeforePrescale (const TString &trigger) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
Int_t	UsePeriodConfig (const TString &configName)
	use a hardcoded period configuration
void	SetDefaultChannel (Int_t channel, Int_t mcRunNumber=-1)
	Set which channel should be used as a default when specific mc channel distributions cannot be found.
Int_t	GetDefaultChannel (Int_t mcRunNumber=-1)
void	RemapPeriod (Int_t periodNumber1, Int_t periodNumber2)
	Combine two period numbers.
Double_t	GetLumiBlockIntegratedLumi (Int_t runNumber, UInt_t lb)
	get integrated lumi for specific run and lumiblock number .
Float_t	GetLumiBlockMu (Int_t runNumber, UInt_t lb)
	get the lumiblock mu, useful for 'updating' the mu coming from data to account for new lumitags
void	DisableWarnings (Bool_t in)
	Indicate if warnings should be suppressed.
void	EnableDebugging (Bool_t in)
	Indicate if additional debugging information should be output.
void	PrintInfo (Bool_t in)
	disable info
void	SetUnrepresentedDataAction (Int_t action, Double_t tolerance=0.05)
	Set how to handle configurations where some of your data has no corresponding mc to describe it 0=Default (Throw exception), 1=Subtract lumi from normalizations (i.e.
Double_t	GetUnrepresentedDataFraction (Int_t periodNumber, Int_t channel)
	return the unrepresented data fraction in a given channel .
Float_t	GetUnrepresentedDataWeight (Int_t periodNumber, Int_t channel)
Bool_t	IsUnrepresentedData (Int_t runNumber, Float_t x, Float_t y=0.)
void	IgnoreConfigFilePeriods (Bool_t in)
	Should the tool ignore period assignments encoded in config file.
Int_t	GetFirstFoundPeriodNumber (UInt_t runNumber)
	Get the first period number with the data run number contained - assume all periods are disconnected for this to be useful.
void	SetDataScaleFactors (Float_t x, Float_t y=1.)
	Scale the LumiMetaData mu values by this factor.
void	SetMCScaleFactors (Float_t x, Float_t y=1.)
Int_t	AddConfigFile (const TString &fileName)
Int_t	AddLumiCalcFile (const TString &fileName, const TString &trigger="None")
Int_t	AddMetaDataFile (const TString &fileName, const TString &channelBranchName="mc_channel_number")
Bool_t	RemoveChannel (int chanNum)
	Removes a channel from the inputs ... this is for experts only.
Int_t	Initialize ()
	Initialize this class once before the event loop starts If distribution information is provided, it is assumed to be for the standard pileup reweighting.
Float_t	GetCombinedWeight (Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y=0.)
Float_t	GetPeriodWeight (Int_t periodNumber, Int_t channelNumber)
Float_t	GetPrimaryWeight (Int_t periodNumber, Int_t channelNumber, Float_t x)
Float_t	GetSecondaryWeight (Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y)
Double_t	GetMetaData (const TString &metadataName, Int_t channelNumber)
TTree *	GetMetaDataTree ()
	combines loaded metadata with channel sumsofweights and entry counts
Int_t	GenerateMetaDataFile (const TString &fileName, const TString &channelBranchName="mc_channel_number")
Int_t	Fill (Int_t runNumber, Int_t channelNumber, Float_t w, Float_t x, Float_t y=0.)
Int_t	WriteToFile (const TString &filename="")
Int_t	WriteToFile (TFile *outFile)
ULong64_t	GetPRWHash (Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y=0.)
Bool_t	MakeWeightTree (TString channelNumbers, TString outFile, TString hashBranch="PRWHash", TString weightBranch="PileupWeight")
void	SetRandomSeed (int seed)
int	GetRandomSeed ()
UInt_t	GetRandomRunNumber (Int_t mcRunNumber)
	Gets a random data run number according to the integrated lumi distribution associated to this mcRunNumber.
UInt_t	GetRandomRunNumber (Int_t mcRunNumber, Double_t mu)
	Get random run number according to integrated lumi distribution for the given mu value (uses the binning of the mu histogram)
Int_t	GetRandomPeriodNumber (Int_t mcRunNumber)
	Get random period number from the sub-periods assigned to this run number.
std::vector< int >	GetPeriodNumbers () const
TH1 *	GetInputHistogram (Int_t channelNumber, Int_t periodNumber)
TH1 *	GetPrimaryDistribution (Int_t channelNumber, Int_t periodNumber)
TH1 *	GetPrimaryTriggerDistribution (const TString &trigger, Int_t periodNumber, long triggerBits)
Double_t	GetDataWeight (Int_t runNumber, const TString &trigger, Double_t x, bool run_dependent=false)
	Method for weighting data to account for prescales and mu bias.
Double_t	GetDataWeight (Int_t runNumber, const TString &trigger)
Double_t	GetPrescaleWeight (Int_t runNumber, const TString &trigger, Double_t x, bool run_dependent=false)
	Method for prescaling MC to account for prescales in data.
Double_t	GetPrescaleWeight (Int_t runNumber, const TString &trigger)
Bool_t	IsInitialized ()
Int_t	AddDistribution (TH1 *hist, Int_t runNumber, Int_t channelNumber)
void	ResetCountingMode ()
	This method is DEFINITELY EXPERT USE ONLY.
void	SetParentTool (TPileupReweighting *tool)
Float_t	GetDataScaleFactor () const
void	SetTriggerBit (const TString &trigger, bool in=true)
void	ResetTriggerBits ()
double	GetRunAverageMu (int run)
Int_t	GetNearestGoodBin (Int_t thisMCRunNumber, Int_t bin)
Int_t	IsBadBin (Int_t thisMCRunNumber, Int_t bin)
std::unique_ptr< TH1 >	CloneEmptyHistogram (Int_t runNumber, Int_t channelNumber)
void	normalizeHistogram (TH1 *histo)
	Normalize histograms.
void	AddDistributionTree (TTree *tree, TFile *file)
void	CalculatePrescaledLuminosityHistograms (const TString &trigger, int run_dependent=0)
std::unique_ptr< CompositeTrigger >	makeTrigger (const TString &s)
void	calculateHistograms (CompositeTrigger *trigger, int run_dependent)
void	PrintPeriods ()
std::map< UInt_t, Run > &	GetRunMap ()
void	CopyProperties (const TPileupReweighting *in)

Protected Attributes
std::map< TString, bool >	m_triggerPassBits
TPileupReweighting *	m_parentTool
Bool_t	m_SetWarnings
Bool_t	m_debugging
Bool_t	m_printInfo
Bool_t	m_countingMode
Int_t	m_unrepresentedDataAction
Bool_t	m_isInitialized
Bool_t	m_lumiVectorIsLoaded
Float_t	m_dataScaleFactorX
Float_t	m_dataScaleFactorY
Float_t	m_mcScaleFactorX
Float_t	m_mcScaleFactorY
Int_t	m_nextPeriodNumber
Bool_t	m_ignoreFilePeriods
TTree *	m_metadatatree
Double_t	m_unrepDataTolerance
Bool_t	m_doGlobalDataWeight
Bool_t	m_doPrescaleWeight = false
Int_t	m_lumicalcRunNumberOffset
std::map< TString, std::vector< TString > >	m_lumicalcFiles
	map storing the lumicalc file locations - used when building DataPileupWeights
std::unique_ptr< TH1 >	m_emptyHistogram
	the empty histogram used for this weight... effectively holds the configuration of the binning
std::map< TString, std::map< Int_t, Double_t > >	m_metadata
	channel metadata map
std::map< TString, std::unique_ptr< CompositeTrigger > >	m_triggerObjs
std::list< Period >	m_periodList
	List physically holding (owning) period objects.
std::map< Int_t, Period * >	m_periods
std::map< UInt_t, Run >	m_runs
std::map< Int_t, Double_t >	unrepDataByChannel
std::string	m_prwFilesPathPrefix
std::unique_ptr< TRandom3 >	m_random3
Bool_t	m_ignoreBadChannels
Bool_t	m_useMultiPeriods = true
int	m_autoRunStart = 0
int	m_autoRunEnd = 0

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_configStream
bool	m_inConfigMode
std::unique_ptr< CP::TPileupReweighting >	m_upTool
std::unique_ptr< CP::TPileupReweighting >	m_downTool
double	m_upVariation
double	m_downVariation
CP::SystematicVariation	m_systUp
CP::SystematicVariation	m_systDown
CP::TPileupReweighting *	m_activeTool
std::vector< std::string >	m_prwFiles
std::vector< std::string >	m_toolLumicalcFiles
std::string	m_prefix
int	m_defaultChannel
std::string	m_usePeriodConfig
std::map< int, bool >	m_doneConfigs
bool	m_noWeightsMode
bool	m_varyRunNumber
bool	m_useRunDependentPrescaleWeight
std::vector< int >	m_customPeriods
	Default weight tool in standalone mode.
std::unique_ptr< IWeightTool >	m_defaultWeightTool
ToolHandle< IWeightTool >	m_weightTool
ToolHandle< IGoodRunsListSelectionTool >	m_grlTool
ToolHandle< Trig::ITrigDecisionTool >	m_tdt
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Implementation of the PileupReweighting tool.

Author

Will Buttinger

Definition at line 33 of file PileupReweightingTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

PileupReweightingTool()

CP::PileupReweightingTool::PileupReweightingTool

(

const std::string &

name

)

Constructor for standalone usage.

Definition at line 34 of file PileupReweightingTool.cxx.

                                                                    :CP::TPileupReweighting(name.c_str()), asg::AsgTool( name ), 
   m_inConfigMode(false), 
   m_upTool(), m_downTool(), m_systUp("PRW_DATASF", 1 ), m_systDown("PRW_DATASF", -1), 
   m_activeTool(this), 
   m_noWeightsMode(false),
#ifdef XAOD_STANDALONE
   m_defaultWeightTool( new McEventWeight( "DefaultWeightTool" ) ),
#endif // XAOD_STANDALONE
   m_weightTool("McEventWeight/myWeightTool"),
   m_grlTool(""), m_tdt("") {
 
   m_defaultChannel=0;
 
#ifndef XAOD_STANDALONE
   declareProperty("ConfigOutputStream", m_configStream="", "When creating PRW config files, this is the THistSvc stream it goes into. If blank, it wont write this way");
#endif
 
   declareProperty("ConfigFiles", m_prwFiles, "List of prw config files"); //array of files
   declareProperty("ConfigFilesPathPrefix", m_prwFilesPathPrefix="", "Path of additional folder structure in prw config files"); //string prefix
   declareProperty("LumiCalcFiles", m_toolLumicalcFiles, "List of lumicalc files, in the format '<filename>:<trigger>' .. if no trigger given, 'None' is assumed"); //array of files
   declareProperty("Prefix",m_prefix="","Prefix to attach to all decorations ... only used in the 'apply' method");
   declareProperty("UnrepresentedDataAction",m_unrepresentedDataAction=3,"1 = remove unrepresented data, 2 = leave it there, 3 = reassign it to nearest represented bin");
   declareProperty("UnrepresentedDataThreshold",m_unrepDataTolerance=0.05,"When unrepresented data is above this level, will require the PRW config file to be repaired");
   declareProperty("UseMultiPeriods",m_useMultiPeriods=true,"If true, will try to treat each mc runNumber in a single mc dataset (channel) as a modelling a distinct period of data taking");
   declareProperty("UseRunDependentPrescaleWeight",m_useRunDependentPrescaleWeight=false,"If true, prescale weights in the getCombinedWeight method with Trigger string are determined with the specific random run number");
   declareProperty("DataScaleFactor",m_dataScaleFactorX=1./1.03);
   declareProperty("UsePeriodConfig",m_usePeriodConfig="auto","Use this period configuration when in config generating mode. Set to 'auto' to auto-detect");
   declareProperty("IgnoreBadChannels",m_ignoreBadChannels=true,"If true, will ignore channels with too much unrepresented data, printing a warning for them");
   declareProperty("DataScaleFactorUP",m_upVariation=1./0.99,"Set to a value representing the 'up' fluctuation - will report a PRW_DATASF uncertainty to Systematic Registry");
   declareProperty("DataScaleFactorDOWN",m_downVariation=1./1.07,"Set to a value representing the 'down' fluctuation - will report a PRW_DATASF uncertainty to Systematic Registry");
   declareProperty("VaryRandomRunNumber",m_varyRunNumber=false,"If true, then when doing systematic variations, RandomRunNumber will fluctuate as well. Off by default as believed to lead to overestimated uncertainties");
   declareProperty("PeriodAssignments", m_customPeriods={284500,222222,324300,300000,324300,344495,310000,344496,367384,410000,422633,440613,450000,450360,461002,470000,473235,486706,495000,497924,999999}, "Specify period number assignments to run numbers ranges - this is usually an expert option");
   declareProperty("GRLTool", m_grlTool, "If you provide a GoodRunsListSelectionTool, any information from lumicalc files will be automatically filtered" );
   declareProperty("TrigDecisionTool",m_tdt, "When using the getDataWeight method, the TDT will be used to check decisions before prescale. Alternatively do expert()->SetTriggerBit('trigger',0) to flag which triggers are not fired before prescale (assumed triggers are fired if not specified)");
 
#ifdef XAOD_STANDALONE
   declareProperty( "WeightTool", m_weightTool = m_defaultWeightTool.get(),
                    "The tool to compute the weight in the sumOfWeights" );
#else
   declareProperty( "WeightTool", m_weightTool,
                    "The tool to compute the weight in the sumOfWeights" );
#endif
 
#ifndef XAOD_STANDALONE
   //attached update handler to the outputlevel property, so we can pass changes on to the underlying tool
   auto props = getProperties();
    for( Gaudi::Details::PropertyBase* prop : props ) {
      if( prop->name() != "OutputLevel" ) {
         continue;
      }
      prop->declareUpdateHandler( &PileupReweightingTool::updateHandler, this );
      break;
   }
#endif
}

Member Function Documentation

AddConfigFile()

Int_t TPileupReweighting::AddConfigFile ( const TString & fileName )

inherited

Definition at line 936 of file TPileupReweighting.cxx.

                                                                 {
 
   //open the file and look for config TTrees
   //recognised TTrees are: ChannelMetaData, MCPileupReweighting, MCCustomReweighting, DataCustomReweighting
 
   if(m_isInitialized) {
      Error("AddConfigFile","You cannot AddConfigFile after initializing the tool. Reorder your code!");
      throw std::runtime_error("Throwing 5: You cannot AddConfigFile after initializing the tool. Reorder your code!");
   }
 
   TDirectory* origDir = gDirectory;
   // Load the data ROOT file
   TFile* rootFile = TFile::Open( fileName, "READ" );
   if ( rootFile->IsZombie() ) {
      Error("AddConfigFile","Could not open file: %s",fileName.Data());
      std::string toThrow = "Throwing 6: Could not open file: "; toThrow += fileName.Data();
      throw std::runtime_error(toThrow);
   } else {
      //try to get the the known TTrees
      TTree *tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"MCPileupReweighting").c_str() );
      if(tmp) {
         //Info("AddConfigFile","Adding MCPileupReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
      tmp = 0;tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"MCCustomReweighting").c_str() );
      if(tmp) {
         //Info("AddConfigFile","Adding MCCustomReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
      tmp = 0;tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"DataCustomReweighting").c_str() );
      if(tmp) {
         //Info("AddConfigFile","Adding DataCustomReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
      tmp=0; tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"PileupReweighting/MCPileupReweighting").c_str() ); //allow trees in the PileupReweighting dir instead
      if(tmp) {
         //Info("AddConfigFile","Adding MCPileupReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
      tmp = 0;tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"PileupReweighting/MCCustomReweighting").c_str() );
      if(tmp) {
         //Info("AddConfigFile","Adding MCCustomReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
      tmp = 0;tmp = (TTree*)rootFile->Get( std::string(m_prwFilesPathPrefix+"PileupReweighting/DataCustomReweighting").c_str() );
      if(tmp) {
         //Info("AddConfigFile","Adding DataCustomReweighting...");
         AddDistributionTree(tmp,rootFile);
         m_countingMode=false;
      }
   }
 
   delete rootFile;
 
   // Return to the original ROOT directory
   gDirectory = origDir;
 
   return 0;
}

AddDistribution()

Int_t TPileupReweighting::AddDistribution ( TH1 * hist, Int_t runNumber, Int_t channelNumber )

inherited

Definition at line 728 of file TPileupReweighting.cxx.

                                                                                          {
 
  //NOTE: should probably just ignore histograms with 0 entries
 
   if(m_isInitialized) {
      Error("AddDistribution","You cannot AddDistribution after initializing the tool. Reorder your code!");
      throw std::runtime_error("Throwing 5: You cannot AddLumiCalcFile after initializing the tool. Reorder your code!");
   }
 
   if(channelNumber>=0 && !m_periods[runNumber]) {
      Error("AddDistribution","Unrecognised periodNumber: %d .. please use AddPeriod to define a period",runNumber);
      throw std::runtime_error("Throwing 6: Unrecognised periodNumber. Please use AddPeriod to define a period");
   }
 
   if(!m_useMultiPeriods && runNumber>=0) {
      //not allowing multi periods in a single channel, so before we go any further, require no periods other than this incoming one to have a hist defined for this channel
      //the global one can though
      for(auto& period : m_periods) {
        if(period.first<0) continue; //global sum period
        if(period.first==runNumber) continue; //ok to add to this
        if(period.second->inputHists.find(channelNumber)!=period.second->inputHists.end()) {
          TString myMsg = TString::Format("Attempt to add distribution for channel %d to period %d, but this channels already has period %d defined.\nThis is indicative of use of incompatible PRW config files, please check your config files for multiple periods/runNumbers for the same channel.",channelNumber,runNumber,period.first);
          Error("AddDistribution","%s",myMsg.Data());
          throw std::runtime_error(myMsg.Data());
        }
      }
   }
 
 
   auto& inputHist = (channelNumber<0) ? m_runs[runNumber].inputHists["None"] : m_periods[runNumber]->inputHists[channelNumber];
 
   if(!inputHist) {
      //if no emptyHistogram specified, we will use this histogram as the structure for the empty;
      if(!m_emptyHistogram) {
         //check if the input histogram is a TH1D or not. We like TH1D, not yucky TH1F
         if(strcmp(hist->IsA()->GetName(),"TH1D")==0 || strcmp(hist->IsA()->GetName(),"TH2D")==0) {
            m_emptyHistogram.reset( dynamic_cast<TH1*>(hist->Clone("default")) );
         } else {
            //check dimensionality
            if(hist->GetDimension()==1) {
               std::vector<Double_t> binsX;
               for(int i=0;i<=hist->GetNbinsX();i++) binsX.push_back(hist->GetXaxis()->GetBinLowEdge(i+1));
               TH1D tmpHist("tmpHist","tmpHist",binsX.size()-1,&binsX[0]);
               m_emptyHistogram.reset( dynamic_cast<TH1*>(tmpHist.Clone("default")) );
            } else if(hist->GetDimension()==2) {
               std::vector<Double_t> binsX;std::vector<Double_t> binsY;
               for(int i=0;i<=hist->GetNbinsX();i++) binsX.push_back(hist->GetXaxis()->GetBinLowEdge(i+1));
               for(int i=0;i<=hist->GetNbinsY();i++) binsY.push_back(hist->GetYaxis()->GetBinLowEdge(i+1));
               TH2D tmpHist("tmpHist","tmpHist",binsX.size()-1,&binsX[0],binsY.size()-1,&binsY[0]);
               m_emptyHistogram.reset( dynamic_cast<TH1*>(tmpHist.Clone("default")) );
            } else {
               Error("AddDistribution","Unknown input histogram dimensionality: %d",hist->GetDimension());
               throw std::runtime_error("Throwing 98");
            }
         }
         if (m_emptyHistogram)
         {
           m_emptyHistogram->Reset();m_emptyHistogram->SetEntries(0);m_emptyHistogram->SetDirectory(0);//clear the histogram
         }
      }
      inputHist = CloneEmptyHistogram(runNumber,channelNumber);
 
   }
 
 
   //iterator over bins of histogram, filling the TH1 stored in the data map
   Double_t numEntries = inputHist->GetEntries();
 
   std::unique_ptr<TH1> tmpHist;
   if(channelNumber<0) {
    m_runs[runNumber].nominalFromHists = true;
    //for data we will do an interpolation to build the shape and then scale it to the integral ...
    tmpHist.reset( static_cast<TH1*>(inputHist->Clone("tmpHist")) );
    tmpHist->Reset();
    Int_t bin,binx,biny;
    for(biny=1; biny<=tmpHist->GetNbinsY(); biny++) {
      for(binx=1; binx<=tmpHist->GetNbinsX(); binx++) {
         bin = tmpHist->GetBin(binx,biny);
         Double_t x = tmpHist->GetXaxis()->GetBinCenter(binx)/m_dataScaleFactorX;
         Double_t y = tmpHist->GetYaxis()->GetBinCenter(biny)/m_dataScaleFactorY;
         if(tmpHist->GetDimension()==1){
          tmpHist->SetBinContent(bin, hist->Interpolate(x));
         } else {
          tmpHist->SetBinContent(bin, hist->Interpolate(x,y));
         }
      }
    }
    tmpHist->Scale( hist->Integral() / tmpHist->Integral() );
    tmpHist->SetEntries( hist->GetEntries() );
    hist = tmpHist.get();
   }
 
   Int_t bin,binx,biny;
   for(biny=1; biny<=hist->GetNbinsY(); biny++) {
      for(binx=1; binx<=hist->GetNbinsX(); binx++) {
         bin = hist->GetBin(binx,biny);
         Double_t value = hist->GetBinContent(bin);
         Double_t x = hist->GetXaxis()->GetBinCenter(binx);
         Double_t y = hist->GetYaxis()->GetBinCenter(biny);
         //shift x,y,z by the MCScaleFactors as appropriate
         if(channelNumber>=0) {x *= m_mcScaleFactorX; y *= m_mcScaleFactorY;}
         //data scale factor now dealt with in above interpolation
         Int_t inBin = inputHist->FindFixBin(x,y);
         Double_t inValue = inputHist->GetBinContent(inBin);
         inputHist->SetBinContent(inBin,inValue+value);
      }
   }
 
   //also keep track of the number of entries
   //SetBinContent screws with the entry count, so had to record it before the loops above
   inputHist->SetEntries(numEntries+hist->GetEntries());
 
 
   m_countingMode=false;
   return 0;
 
}

AddDistributionTree()

void TPileupReweighting::AddDistributionTree ( TTree * tree, TFile * file )

protectedinherited

Definition at line 648 of file TPileupReweighting.cxx.

                                                                       {
 
   bool isMC=true;
   //should have the standard structure
   Int_t channel = 0; UInt_t runNbr = 0;
   auto pStarts = std::make_unique< std::vector< UInt_t > >();
   auto pStartsPtr = pStarts.get();
   auto pEnds = std::make_unique< std::vector< UInt_t > >();
   auto pEndsPtr = pEnds.get();
   Char_t histName[150];
   Char_t customName[150];
   Bool_t isDefaultForRunNumber(false); bool hasDefaultsBranch=false;
   if(strcmp(tree->GetName(),"MCPileupReweighting")==0) {strcpy(customName,"pileup");isMC=true;}
   else {
      if(tree->SetBranchAddress("CustomName",&customName)!=0) {
         Error("AddDistributionTree","Could not find CustomName branch in TTree");throw std::runtime_error("Throwing 18");
      }
   }
   if(strcmp(tree->GetName(),"DataCustomReweighting")==0) {channel=-1;isMC=false;}
   else {
      if(tree->SetBranchAddress("Channel",&channel)!=0) {
         Error("AddDistributionTree","Could not find Channel branch in TTree");throw std::runtime_error("Throwing 18");
      }
   }
   if(tree->SetBranchAddress("RunNumber",&runNbr)!=0) {
      Error("AddDistributionTree","Could not find RunNumber branch in TTree");throw std::runtime_error("Throwing 18");
   }
   if(isMC) {
      if(tree->SetBranchAddress("PeriodStarts",&pStartsPtr)!=0) {
         Error("AddDistributionTree","Could not find PeriodStarts branch in TTree");throw std::runtime_error("Throwing 18");
      }
      if(tree->SetBranchAddress("PeriodEnds",&pEndsPtr)!=0) {
         Error("AddDistributionTree","Could not find PeriodEnds branch in TTree");throw std::runtime_error("Throwing 18");
      }
      if(tree->FindBranch("IsDefaultForRunNumber")!=0) {
         tree->SetBranchAddress("IsDefaultForRunNumber",&isDefaultForRunNumber);
         hasDefaultsBranch=true;
      }
   }
 
   if(tree->SetBranchAddress("HistName",&histName)!=0) {
      Error("AddDistributionTree","Could not find HistName branch in TTree");throw std::runtime_error("Throwing 18");
   }
   long n = tree->GetEntries();
   std::map<TString,bool> loadedHistos; //avoid double-loading from this file
   for(long i=0;i<n;i++) {
      tree->GetEntry(i);
      TString sHistName(histName);
      TString weightName(customName);
      const auto &[ptr, inserted] = loadedHistos.try_emplace(sHistName, true);
 
      if(inserted) {
         if(( (!m_ignoreFilePeriods) || m_periods.find(runNbr)==m_periods.end()) && isMC) {
            //if ignoring file periods, will still add the period if it doesnt exist!
            for(unsigned int j=0;j<pStarts->size();j++) {
               unsigned int start = pStarts->at(j);
               unsigned int end = pEnds->at(j);
               AddPeriod(runNbr,start,end);
            }
         }
         //load the histogram
         TH1 *histo = (TH1*)file->Get( sHistName );
         if(!histo) histo = (TH1*)file->Get( TString::Format("%sPileupReweighting/%s",m_prwFilesPathPrefix.c_str(),sHistName.Data()) ); //try from subdir
         if(!histo) {
            Error("AddDistributionTree","Unable to find the histogram %s in the File %s",sHistName.Data(),file->GetName());
            throw std::runtime_error("Throwing 21");
         }
         //add it to the histograms
         AddDistribution(histo, runNbr, channel);
         //we also add it to the global count, if this isn't data
         if(channel>=0) AddDistribution(histo,-1,channel);
      }
      if(hasDefaultsBranch) {
         if(isDefaultForRunNumber && m_periods.find(runNbr)!=m_periods.end()) m_periods[runNbr]->defaultChannel=channel;
      }
   }
 
}

AddLumiCalcFile()

Int_t TPileupReweighting::AddLumiCalcFile ( const TString & fileName, const TString & trigger = "None" )

inherited

Definition at line 847 of file TPileupReweighting.cxx.

                                                                                           {
 
   if(m_isInitialized) {
      Error("AddLumiCalcFile","You cannot AddLumiCalcFile after initializing the tool. Reorder your code!");
      throw std::runtime_error("Throwing 5: You cannot AddLumiCalcFile after initializing the tool. Reorder your code!");
   }
   TDirectory* origDir = gDirectory;
   // Load the data ROOT file
   TFile* rootFile = TFile::Open( fileName, "READ" );
   if ( rootFile->IsZombie() ) {
      Error("AddConfigFile","Could not open file: %s",fileName.Data());
      std::string toThrow = "Throwing 6: Could not open file: "; toThrow += fileName.Data();
      throw std::runtime_error(toThrow);
   } else {
      //try to get the the known TTrees
      TTree *tmp = (TTree*)rootFile->Get( "LumiMetaData" );
      if(tmp) {
         m_lumicalcFiles[trigger].push_back(fileName);
         if(trigger=="None") {
           if (m_printInfo) {
             Info("AddLumiCalcFile","Adding LumiMetaData (scale factor=%f)...",m_dataScaleFactorX);
           }
            //structure expected is as given by iLumiCalc:
            //   RunNbr, AvergeInteractionPerXing, IntLumi
            UInt_t runNbr=0;Float_t intLumi=0;UInt_t lbn=0;TBranch *b_runNbr=0;TBranch *b_intLumi=0;TBranch *b_lbn=0;
            Float_t mu=0.; TBranch *b_mu=0;
            if(tmp->SetBranchAddress("RunNbr",&runNbr,&b_runNbr)!=0) {
               Error("AddLumiCalcFile","Could not find RunNbr branch in Data TTree");throw std::runtime_error("Could not find RunNbr branch in Data TTree");
            }
            if(tmp->SetBranchAddress("AvergeInteractionPerXing",&mu,&b_mu)!=0) {
               Error("AddLumiCalcFile","Could not find AvergeInteractionPerXing branch in Data TTree");throw std::runtime_error("Could not find AvergeInteractionPerXing branch in Data TTree");
            }
            if(tmp->SetBranchAddress("IntLumi",&intLumi,&b_intLumi)!=0) {
               Error("AddLumiCalcFile","Could not find IntLumi branch in Data TTree");throw std::runtime_error("Could not find IntLumi branch in Data TTree");
            }
            if(tmp->SetBranchAddress("LBStart",&lbn,&b_lbn)!=0) {
               Error("AddLumiCalcFile","Could not find LBStart branch in Data TTree");throw std::runtime_error("Could not find LBStart branch in Data TTree");
            }
            long nEntries = tmp->GetEntries();
 
            for(long i=0;i<nEntries;i++) {
               b_runNbr->GetEntry(i);b_intLumi->GetEntry(i);b_mu->GetEntry(i);
               runNbr += m_lumicalcRunNumberOffset;
               //save the lumi by run and lbn
               b_lbn->GetEntry(i);
 
               //before going any further, check the runnbr and lbn are ok
               if(!m_parentTool->runLbnOK(runNbr,lbn)) continue;
 
               Run& r = m_runs[runNbr];
               if(trigger=="None") {
                r.lumiByLbn[lbn].first += intLumi;
                r.lumiByLbn[lbn].second = mu;
                if(r.nominalFromHists) continue; //don't fill runs that we already filled from hists ... only happens for the 'None' trigger
               }
 
               //rescale the mu value  ... do this *after* having stored the mu value in the lumiByLbn map
               mu *= m_dataScaleFactorX;
               //fill into input data histograms
               //check if we need to create an empty histogram
 
               std::unique_ptr<TH1>& histptr = r.inputHists[trigger];
               if (!histptr) {
                  histptr = CloneEmptyHistogram(runNbr,-1);
               }
               histptr->Fill(mu,intLumi);
            }
            m_countingMode=false;
            m_lumiVectorIsLoaded=true;
         } else {
           if (m_printInfo) {
             Info("AddLumiCalcFile","Adding LumiMetaData for DataWeight (trigger=%s) (scale factor=%f)...",trigger.Data(),m_dataScaleFactorX);
           }
         }
 
      } else {
        Error("AddLumiCalcFile","No LumiMetaData found in file %s. not a LumiCalcFile?", fileName.Data());
        throw std::runtime_error("No LumiMetaData found in file, not a LumiCalcFile?");
      }
   }
 
   delete rootFile;
 
   // Return to the original ROOT directory
   gDirectory = origDir;
 
   return 0;
}

AddMetaDataFile()

Int_t TPileupReweighting::AddMetaDataFile ( const TString & fileName, const TString & channelBranchName = "mc_channel_number" )

inherited

Definition at line 506 of file TPileupReweighting.cxx.

                                                                                                    {
   TDirectory* origDir = gDirectory;
   TTree* tmp = 0;
   TFile* rootFile = 0;
   if(fileName.EndsWith(".root")) {
      //looks for ChannelMetaData ttree
      // Load the data ROOT file
      rootFile = TFile::Open( fileName, "READ" );
      if ( rootFile->IsZombie() ) {
         Error("AddMetaDataFile","Could not open file: %s",fileName.Data());
         throw std::runtime_error("Throwing 6");
      } else {
         //try to get the the known TTrees
         tmp = (TTree*)rootFile->Get( "ChannelMetaData" );
         if(!tmp) {
            Error("AddMetaDataFile","%s is not a valid metadata file. Should have a ChannelMetaData TTree",fileName.Data());
            throw std::runtime_error("Throwing 7");
         }
         rootFile->Close();
      }
      delete rootFile;
   } else {
      //try to make the TTree by reading the file
      tmp = new TTree("ChannelMetaData","ChannelMetaData");
      tmp->ReadFile(fileName);
   }
   Int_t chanNum;
   std::map<TString, Double_t> data;
   TObjArray *leaves = tmp->GetListOfLeaves();
   if(leaves==0) {Error("AddMetaDataFile","No leaves"); return -1; }
   for(Int_t i=0;i<leaves->GetEntries();++i) {
      TLeaf *leaf = (TLeaf *)leaves->At(i);
      if(leaf) {
         TBranch *branch = leaf->GetBranch();
         if(strcmp(branch->GetName(),channelBranchName)==0) {
            //this is the channel branch
            if(strcmp(leaf->GetTypeName(),"Int_t")!=0) {
               Error("AddMetaDataFile","Channel Branch must be type Int_t");
               throw std::runtime_error("Throwing 7");
            }
            branch->SetAddress(&chanNum);
         } else if(strcmp(leaf->GetTypeName(),"Double_t")!=0) {
               Warning("AddMetaDataFile","Cannot read non-double branch: %s",branch->GetName());
         } else {
            branch->SetAddress(&(data[branch->GetName()]));
         }
      }
   }
   //loop over tree entries and read in the values
   for(Int_t i=0;i<tmp->GetEntries();++i) {
      tmp->GetEntry(i);
      for(std::map<TString, Double_t>::iterator it = data.begin();it!=data.end();++it) {
         if(m_metadata.find(it->first)!=m_metadata.end()&&m_metadata[it->first].find(chanNum)!=m_metadata[it->first].end() && m_metadata[it->first][chanNum]!=it->second) {
            Warning("AddMetaDataFile", "Overriding metadata [%s,%d]. %f becomes %f",(it->first).Data(),chanNum,m_metadata[it->first][chanNum],it->second);
         }
         m_metadata[it->first][chanNum] = it->second;
      }
   }
 
   delete tmp;
   if(rootFile) { rootFile->Close();delete rootFile;}
 
   // Return to the original ROOT directory
   gDirectory = origDir;
 
   return 0;
}

AddPeriod()

virtual Int_t CP::PileupReweightingTool::AddPeriod ( Int_t periodNumber, UInt_t start, UInt_t end )

inlinevirtual

use these methods when generating config files

Implements CP::IPileupReweightingTool.

Definition at line 59 of file PileupReweightingTool.h.

{ return m_activeTool->AddPeriod(periodNumber, start, end); }

affectingSystematics()

CP::SystematicSet CP::PileupReweightingTool::affectingSystematics ( ) const

virtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 119 of file PileupReweightingTool.cxx.

                                                                  {
   CP::SystematicSet result;
   if(m_upVariation) result.insert( m_systUp  );
   if(m_downVariation) result.insert( m_systDown );
   return result;
}

apply()

StatusCode CP::PileupReweightingTool::apply ( const xAOD::EventInfo & eventInfo, bool mu_dependent )

virtual

Decorates with: MC: PileupWeight (CombinedWeight[*UnrepresentedDataWeight if action=2]), RandomRunNumber, RandomLumiBlockNumber Data: corrected_averageInteractionsPerCrossing mu_dependent says if the mu_dependency should be used for random run numbers or the data weights.

You will get random run numbers of 0 for events with zero pileup weight

Implements CP::IPileupReweightingTool.

Definition at line 456 of file PileupReweightingTool.cxx.

                                                                                         {
 
   if(m_inConfigMode)  {
      fill( eventInfo );
      return StatusCode::SUCCESS;
   }
 
   SG::Decorator<float> corrAvgIntPerXingDec(m_prefix+"corrected_averageInteractionsPerCrossing");
   if(!eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION)){
      if(!corrAvgIntPerXingDec.isAvailable(eventInfo))
         corrAvgIntPerXingDec(eventInfo) = getCorrectedAverageInteractionsPerCrossing(eventInfo,false);
      return StatusCode::SUCCESS;
   }
 
   //just copy the value over for MC
   if(!corrAvgIntPerXingDec.isAvailable(eventInfo))
      corrAvgIntPerXingDec(eventInfo) = eventInfo.averageInteractionsPerCrossing();
 
   //decorate with random run number etc
   SG::Decorator<unsigned int> rrnDec(m_prefix+"RandomRunNumber");
   SG::ConstAccessor<unsigned int> rrnAcc(rrnDec.auxid());
   if(!rrnDec.isAvailable(eventInfo)){
      unsigned int rrn = getRandomRunNumber( eventInfo, mu_dependent );
      rrnDec(eventInfo) = (rrn==0) ? getRandomRunNumber(eventInfo, false) : rrn;
   }
   SG::Decorator<unsigned int> rlbnDec(m_prefix+"RandomLumiBlockNumber");
   SG::Decorator<unsigned int> rlbnAcc(rlbnDec.auxid());
   if(!rlbnDec.isAvailable(eventInfo))
      rlbnDec(eventInfo) = (rrnAcc(eventInfo)==0) ? 0 : /*m_tool->*/GetRandomLumiBlockNumber(  rrnAcc(eventInfo)  );
   SG::Decorator<ULong64_t> prwHashDec(m_prefix+"PRWHash");
   if(!prwHashDec.isAvailable(eventInfo))
      prwHashDec(eventInfo) = getPRWHash( eventInfo );
 
   //decorate with standard PileupWeight 
   SG::Decorator<float> puWeightDec(m_prefix+"PileupWeight");
   SG::ConstAccessor<float> puWeightAcc(puWeightDec.auxid());
   if(!m_noWeightsMode && !puWeightDec.isAvailable(eventInfo))
      puWeightDec(eventInfo) = getCombinedWeight(eventInfo, true);
      
   ATH_MSG_VERBOSE("PileupWeight = " << puWeightAcc(eventInfo) << " RandomRunNumber = " << rrnAcc(eventInfo) << " RandomLumiBlockNumber = " << rlbnAcc(eventInfo));
 
   return StatusCode::SUCCESS;
}

applySystematicVariation()

StatusCode CP::PileupReweightingTool::applySystematicVariation ( const CP::SystematicSet & systConfig )

virtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 130 of file PileupReweightingTool.cxx.

                                                                                              { 
   if(systConfig.find( m_systUp ) != systConfig.end() && systConfig.find( m_systDown ) != systConfig.end()) {
      ATH_MSG_ERROR("Errr... what the!? You're trying to do both PRW_DATASF directions at the same time!!!??"); 
      return StatusCode::FAILURE; 
   }
   if(systConfig.find( m_systUp ) != systConfig.end()) {
      if(!m_upTool) { ATH_MSG_ERROR("Requested up variation of PRW_DATASF, but not configured to do this :-("); return StatusCode::FAILURE; }
      m_activeTool = m_upTool.get();
   }
   else if(systConfig.find( m_systDown ) != systConfig.end() ) {
      if(!m_downTool) { ATH_MSG_ERROR("Requested down variation of PRW_DATASF, but not configured to do this :-("); return StatusCode::FAILURE; }
      m_activeTool = m_downTool.get();
   }
   else m_activeTool = this;
   return StatusCode::SUCCESS;
}

calculateHistograms()

void TPileupReweighting::calculateHistograms ( CompositeTrigger * trigger, int run_dependent )

protectedinherited

Definition at line 2111 of file TPileupReweighting.cxx.

                                                                                       {
  TH1* unprescaledLumi = 0;
  if(runDependentRun) {
     unprescaledLumi = m_triggerObjs["None"]->triggerHists[-runDependentRun][0].get();
  }
  bool fillUnprescaledLumi = (unprescaledLumi==0); //only fill the unprescaled histogram once ... so if it already exists, it must have already been filled
 
   //now we need the trigger bits for this trigger for this event
   long tbits = t->getBits(this);
   //1. Open all the lumicalc files
   //2. For each entry in the 'None' lumicalc file, lookup the run and lb in the subTriggers, and get the prescales (if not found, assume trigger not in, prescale=infinity)
   //3. perform calculation of lumi as: Lumi*(1 - Prod_triggers(1-1/prescale)) .. sum this up into the output histogram
   //    Note: Put each lumi into the period that contains the run ( use  )
 
   TDirectory* origDir = gDirectory;
 
   std::map<TString, std::map<Int_t, std::map<Int_t, Float_t> > > prescaleByRunAndLbn;
 
   //Load the prescales for each lumicalc subTrigger
   for(std::vector<TString>::iterator it = t->subTriggers.begin();it!=t->subTriggers.end();++it) {
      //Info("aa","subtrigger %s Int lumi is %f", it->Data(), m_triggerPrimaryDistributions[*it][1]->Integral());
      for(auto& fileName : m_lumicalcFiles[*it]) {
        //if the file is also in the "None" list, then we will now the prescale must be 0
        //it seems that in these no-trigger files used for unprescaled lumi the prescales are all set to -1
        bool isUnprescaled = (std::find(m_lumicalcFiles["None"].begin(),m_lumicalcFiles["None"].end(),fileName)!=m_lumicalcFiles["None"].end());
 
        TFile* rootFile = TFile::Open( fileName, "READ" );
        if ( rootFile->IsZombie() ) {
          Error("CalculatePrescaledLuminosityHistograms","Could not open file: %s",fileName.Data());
          std::string toThrow = "Throwing 6: Could not open file: "; toThrow += fileName.Data();
          throw std::runtime_error(toThrow);
        } else {
          //try to get the the known TTrees
          TTree *tmp = (TTree*)rootFile->Get( "LumiMetaData" );
          if(tmp) {
              //structure expected is as given by iLumiCalc:
              //   RunNbr, AvergeInteractionPerXing, IntLumi
              UInt_t runNbr=0;Float_t ps1=0;Float_t ps2=0; Float_t ps3=0;UInt_t lbn=0;TBranch *b_runNbr=0;TBranch *b_L1Presc=0;TBranch *b_L2Presc=0;TBranch *b_L3Presc=0;TBranch *b_lbn=0;
              if(tmp->SetBranchAddress("RunNbr",&runNbr,&b_runNbr)!=0) {
                Error("CalculatePrescaledLuminosityHistograms","Could not find RunNbr branch in Data TTree");throw std::runtime_error("Could not find RunNbr branch in Data TTree");
              }
              if(tmp->SetBranchAddress("L1Presc",&ps1,&b_L1Presc)!=0) {
                Error("CalculatePrescaledLuminosityHistograms","Could not find L1Presc branch in Data TTree");throw std::runtime_error("Could not find L1Presc branch in Data TTree");
              }
              if(tmp->SetBranchAddress("L2Presc",&ps2,&b_L2Presc)!=0) {
                Error("CalculatePrescaledLuminosityHistograms","Could not find L2Presc branch in Data TTree");throw std::runtime_error("Could not find L2Presc branch in Data TTree");
              }
              if(tmp->SetBranchAddress("L3Presc",&ps3,&b_L3Presc)!=0) {
                Error("CalculatePrescaledLuminosityHistograms","Could not find L3Presc branch in Data TTree");throw std::runtime_error("Could not find L3Presc branch in Data TTree");
              }
              if(tmp->SetBranchAddress("LBStart",&lbn,&b_lbn)!=0) {
                Error("CalculatePrescaledLuminosityHistograms","Could not find LBStart branch in Data TTree");throw std::runtime_error("Could not find LBStart branch in Data TTree");
              }
              long nEntries = tmp->GetEntries();
              for(long i=0;i<nEntries;i++) {
                b_runNbr->GetEntry(i);b_L1Presc->GetEntry(i);b_L2Presc->GetEntry(i);b_L3Presc->GetEntry(i);b_lbn->GetEntry(i);
                runNbr += m_lumicalcRunNumberOffset;
                if(runDependentRun && int(runNbr)!=runDependentRun) continue; //only use the given run with doing calculation run-dependently
                //save the prescale by run and lbn
                //if(runNbr==215643)
                if(m_debugging && m_printInfo) Info("...","prescale in [%d,%d] = %f %f %f", runNbr,lbn,ps1,ps2,ps3);
                if(ps1>0&&ps2>0&&ps3>0) prescaleByRunAndLbn[*it][runNbr][lbn] = ps1*ps2*ps3;
                else if(isUnprescaled) prescaleByRunAndLbn[*it][runNbr][lbn] = 1; //special case where the trigger is an unprescaled one and user is reusing the unprescaled lumicalc
              }
          }
          rootFile->Close();
        }
        delete rootFile;
       } //end of loop over lumicalc files for this trigger
   }
 
   for(auto& fileName : m_lumicalcFiles["None"]) {
    // Load the data ROOT file for the 'None' lumicalc file
    TFile* rootFile = TFile::Open( fileName, "READ" );
    if ( rootFile->IsZombie() ) {
        Error("CalculatePrescaledLuminosityHistograms","Could not open file: %s",fileName.Data());
        std::string toThrow = "Throwing 6: Could not open file: "; toThrow += fileName.Data();
        throw std::runtime_error(toThrow);
    } else {
        //try to get the the known TTrees
        TTree *tmp = (TTree*)rootFile->Get( "LumiMetaData" );
        if(tmp) {
          //structure expected is as given by iLumiCalc:
          //   RunNbr, AvergeInteractionPerXing, IntLumi
          UInt_t runNbr=0;Float_t intLumi=0;UInt_t lbn=0;TBranch *b_runNbr=0;TBranch *b_intLumi=0;TBranch *b_lbn=0;
          Float_t mu=0.; TBranch *b_mu=0;
          if(tmp->SetBranchAddress("RunNbr",&runNbr,&b_runNbr)!=0) {
              Error("CalculatePrescaledLuminosityHistograms","Could not find RunNbr branch in Data TTree");throw std::runtime_error("Could not find RunNbr branch in Data TTree");
          }
          if(tmp->SetBranchAddress("AvergeInteractionPerXing",&mu,&b_mu)!=0) {
              Error("CalculatePrescaledLuminosityHistograms","Could not find AvergeInteractionPerXing branch in Data TTree");throw std::runtime_error("Could not find AvergeInteractionPerXing branch in Data TTree");
          }
          if(tmp->SetBranchAddress("IntLumi",&intLumi,&b_intLumi)!=0) {
              Error("CalculatePrescaledLuminosityHistograms","Could not find IntLumi branch in Data TTree");throw std::runtime_error("Could not find IntLumi branch in Data TTree");
          }
          if(tmp->SetBranchAddress("LBStart",&lbn,&b_lbn)!=0) {
              Error("CalculatePrescaledLuminosityHistograms","Could not find LBStart branch in Data TTree");throw std::runtime_error("Could not find LBStart branch in Data TTree");
          }
          long nEntries = tmp->GetEntries();
          //this loop ends up calling the triggerBeforePrescale method each time, but this should hopefully stop once the loading is done
          for(long i=0;i<nEntries;i++) {
              b_runNbr->GetEntry(i);b_intLumi->GetEntry(i);b_mu->GetEntry(i);
              b_lbn->GetEntry(i);
 
              runNbr += m_lumicalcRunNumberOffset;
              if(runDependentRun && int(runNbr)!=runDependentRun) continue; //only use the given run with doing calculation run-dependently
              //for each subtrigger, lookup prescale, and calculate pFactor
 
              double pFactor = t->eval(prescaleByRunAndLbn,runNbr,lbn,this);
 
              //Info("...","prescale in [%d,%d] = %f", runNbr,lbn,1./pFactor);
 
              int bin = m_emptyHistogram->FindFixBin(mu*m_dataScaleFactorX);
 
              //add into all periods that contain this runNbr
              bool firstFill=false;
              for(auto p : m_periods) {
                if(p.first != p.second->id) continue; //skips remappings
                if(!p.second->contains(runNbr)) continue;
                if(runDependentRun && firstFill) continue; //only fill runDependentRun once, since they aren't kept in the period they go in their own run-indexed histogram
 
                int idx = (runDependentRun) ? -runDependentRun : p.second->id; //use negative runNumber to avoid clash with periodID
 
 
                auto& triggerHists = t->triggerHists[idx];
                std::unique_ptr<TH1>& histptr = triggerHists[tbits];
                if(!histptr) {
                    histptr = CloneEmptyHistogram(p.first,-1);
                    if(m_debugging && m_printInfo) Info("CalculatePrescaledLuminosityHistograms","Created Data Weight Histogram for [%s,%d,%d,%ld]",t->val.Data(),p.first,idx,tbits);
                }
                  //check if we were about to fill a bad bin ... if we are, we either skipp the fill (unrep action=1) or redirect (unrep action=3)
                if( (m_unrepresentedDataAction==1) && p.second->inputBinRedirect[bin]!=bin) { } //do nothing
                else if( m_unrepresentedDataAction==3 ) {histptr->Fill(triggerHists[tbits]->GetBinCenter(p.second->inputBinRedirect[bin]), intLumi*pFactor);}
                else triggerHists[tbits]->Fill(mu*m_dataScaleFactorX,intLumi*pFactor);
 
 
                if(runDependentRun && fillUnprescaledLumi) {
                  //need to fill unprescaled lumi histogram for this particular run ...
                  if(unprescaledLumi==0) {
                    m_triggerObjs["None"]->triggerHists[-runDependentRun][0] = CloneEmptyHistogram(p.first,-1);
                    unprescaledLumi = m_triggerObjs["None"]->triggerHists[-runDependentRun][0].get();
                  }
                  if( (m_unrepresentedDataAction==1) && p.second->inputBinRedirect[bin]!=bin) { } //do nothing
                  else if( m_unrepresentedDataAction==3 ) {unprescaledLumi->Fill(unprescaledLumi->GetBinCenter(p.second->inputBinRedirect[bin]), intLumi);}
                  else unprescaledLumi->Fill(mu*m_dataScaleFactorX,intLumi);
                }
 
                firstFill=true;
 
              }
          }
          rootFile->Close();
        }
    }
    delete rootFile;
   } //end loop over unprescaled lumicalc files
 
 
   //Info("aa","Int lumi is %f", m_triggerPrimaryDistributions[trigger][1]->Integral());
 
 
 
   // Return to the original ROOT directory
   gDirectory = origDir;
 
 
}

CalculatePrescaledLuminosityHistograms()

void TPileupReweighting::CalculatePrescaledLuminosityHistograms ( const TString & trigger, int run_dependent = 0 )

protectedinherited

Definition at line 2088 of file TPileupReweighting.cxx.

                                                                                                             {
   //check if this is a composite trigger (user has provided OR of triggers that are passed before prescale)
 
   TString triggerCopy = trigger; triggerCopy.ReplaceAll(" ",""); triggerCopy.ReplaceAll("&&","&");triggerCopy.ReplaceAll("||","|");
   auto t = makeTrigger(triggerCopy);
   if( ! t ) {
      Error("GetDataWeight","Error parsing composite trigger set: %s",trigger.Data());
      throw std::runtime_error("Could not parse composite trigger");
   }
 
   std::vector<TString> subTriggers;
 
   t->getTriggers(subTriggers); //fills the vector
 
   t->subTriggers = std::move(subTriggers); //cache the vector of triggers
 
   calculateHistograms(t.get(),runDependentRun);
 
   //save trigger object
   m_triggerObjs[trigger] = std::move( t );
 
}

Class_Version()

Version_t CP::PileupReweightingTool::Class_Version ( )

inlinestatic

Definition at line 177 of file PileupReweightingTool.h.

{ return 0; }

CloneEmptyHistogram()

std::unique_ptr< TH1 > TPileupReweighting::CloneEmptyHistogram ( Int_t runNumber, Int_t channelNumber )

protectedinherited

Definition at line 435 of file TPileupReweighting.cxx.

                                                                              {
 
   TString s("pileup");
   if(channelNumber>=0) {
      s += "_chan"; s += channelNumber;
   } else {
      s += "_data";
   }
   s+="_run"; s+= runNumber;
   //get the empty histogram
   if(!m_emptyHistogram) {
      Error("CloneEmptyHistogram","There is no binning info - use SetBinning/SetUniformBinning or load a prw config file (This usually means you need to call AddConfigFile BEFORE AddLumiCalcFile)");
      throw std::runtime_error("Throwing 47: There is no binning info - use SetBinning/SetUniformBinning or load a prw config file (This usually means you need to call AddConfigFile BEFORE AddLumiCalcFile)");
   }
 
   std::unique_ptr< TH1 > out( dynamic_cast<TH1*>(m_emptyHistogram->Clone(s)) );
   if (out) {
     out->SetTitle(s);
     out->SetDirectory(0); //take ownership
     out->SetEntries(0);
   }
   return out;
 
}

CopyProperties()

void CP::TPileupReweighting::CopyProperties ( const TPileupReweighting * in )

inlineinherited

Definition at line 479 of file TPileupReweighting.h.

                                                               {
         m_prwFilesPathPrefix = in->m_prwFilesPathPrefix;
         m_ignoreBadChannels = in->m_ignoreBadChannels;
         m_unrepresentedDataAction = in->m_unrepresentedDataAction;
         m_unrepDataTolerance= in->m_unrepDataTolerance;
      }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

DisableWarnings()

void CP::TPileupReweighting::DisableWarnings ( Bool_t in )

inlineinherited

Indicate if warnings should be suppressed.

Definition at line 116 of file TPileupReweighting.h.

{ m_SetWarnings = !in;}

EnableDebugging()

void CP::TPileupReweighting::EnableDebugging ( Bool_t in )

inlineinherited

Indicate if additional debugging information should be output.

Definition at line 118 of file TPileupReweighting.h.

{ m_debugging = in;}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

expert()

virtual CP::TPileupReweighting * CP::PileupReweightingTool::expert ( )

inlinevirtual

Get pointer to the underlying tool - expert use only. Will require #include "PileupReweighting/TPileupReweighting.h".

Implements CP::IPileupReweightingTool.

Definition at line 121 of file PileupReweightingTool.h.

{ return m_activeTool; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

Fill()

Int_t TPileupReweighting::Fill ( Int_t runNumber, Int_t channelNumber, Float_t w, Float_t x, Float_t y = 0. )

inherited

Definition at line 1839 of file TPileupReweighting.cxx.

                                                                                                   {
  if(!m_isInitialized ) {
    if (m_printInfo) Info("Fill","Initializing the subtool..");
    Initialize();
  }
   //should only be given genuine mcRunNumbers if mc (channel>=0). We don't fill periodNumber distributions
 
   TH1* hist = 0;
 
   //get the period if mc, get the data run if data
   if(channelNumber>=0) {
      if(m_periods.find(runNumber)==m_periods.end()) {
        //if assume default binning is true, will add binning from 0 to 100 for this run number
        if(m_autoRunStart || m_autoRunEnd) {
          AddPeriod(runNumber,m_autoRunStart,m_autoRunEnd);
        }
         if(m_periods.find(runNumber)==m_periods.end()) {
           Error("Fill","Unrecognised runNumber: %d.  Check your period configuration (AddPeriod or UsePeriodConfig)",runNumber);
           throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
         }
      }
      Period* p = m_periods[runNumber];
      if(!p) {
         Error("Fill","Unrecognised runNumber: %d.  Check your period configuration (AddPeriod or UsePeriodConfig) ... but should never have got here so please report this!",runNumber);
         throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
      }
      std::unique_ptr<TH1>& histptr = p->inputHists[channelNumber];
      if(!histptr) {
         //need to create my period histogram
         histptr = CloneEmptyHistogram(runNumber,channelNumber);
      }
      hist = histptr.get();
   } else {
      Run& r = m_runs[runNumber];
      if( ! r.inputHists["None"]) r.inputHists["None"]=CloneEmptyHistogram(runNumber,channelNumber);
      hist = r.inputHists["None"].get();
   }
 
   if(!hist) {
      Error("Fill","Unknown [run,channel] = [%d,%d]",runNumber,channelNumber);
      throw std::runtime_error("Throwing 45: Fill:: Unknown [run,channel] ");
   }
 
   if(hist->GetDimension()==1) {
      return hist->Fill(x,w);
   } else if(hist->GetDimension()==2) {
      return (static_cast<TH2*>(hist))->Fill(x,y,w);
   }
   return -1;
}

fill() [1/2]

int CP::PileupReweightingTool::fill ( const xAOD::EventInfo & eventInfo )

virtual

Call this method once per event when in config file generating mode and you want standard mu reweighting.

Implements CP::IPileupReweightingTool.

Definition at line 430 of file PileupReweightingTool.cxx.

                                                                {
   return fill(eventInfo,eventInfo.averageInteractionsPerCrossing(),0);
}

fill() [2/2]

int CP::PileupReweightingTool::fill ( const xAOD::EventInfo & eventInfo, Double_t x, Double_t y )

virtual

Use this method if you want to do a generic reweighting instead.

Implements CP::IPileupReweightingTool.

Definition at line 434 of file PileupReweightingTool.cxx.

                                                                                       {
   
   //auto-detect the period config if necessary 
   if(m_usePeriodConfig=="auto" && !m_doneConfigs[eventInfo.runNumber()]) { //try autodetect based on runnum of first event ... 
      //if data, we only need to ensure a binning is done ... for now, we assume the MC15 binning
      if(!eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION)) {
         if(!m_emptyHistogram) { SetUniformBinning(100,0,100.); } //use a default binning
      } else {
         switch(eventInfo.runNumber()) {
            case 212272: UsePeriodConfig("MC14_8TeV");break;
            case 222222: UsePeriodConfig("MC14_13TeV");break;
            case 222510: case 222525: case 222526: case 284500: UsePeriodConfig("MC15"); break;
         }
     if(eventInfo.runNumber()>284500) UsePeriodConfig("Run2"); //this is the automatic period config, allows any run numbers to be added
      }
      m_doneConfigs[eventInfo.runNumber()] = true;
   }
 
   return TPileupReweighting::Fill(eventInfo.runNumber(), eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION) ? eventInfo.mcChannelNumber() : -1 /*data*/, eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION) ? m_weightTool->getWeight() : 1., x, y);
 
}

finalize()

StatusCode CP::PileupReweightingTool::finalize ( )

virtual

Finalize - can call the WriteToFile for us.

Definition at line 304 of file PileupReweightingTool.cxx.

                                           {
   if(m_inConfigMode) {
#ifndef XAOD_STANDALONE
   if(m_configStream=="") {
      //write the prw config files
      std::string nameWithoutParent = this->name().substr(this->name().find(".")+1);
      TString fileName = TString::Format("%s.prw.root", nameWithoutParent.c_str());
      /*m_tool->*/WriteToFile(fileName);
   } else {
      //write to the histsvc stream instead ...
      
      ServiceHandle<ITHistSvc> histSvc("THistSvc",name());
      CHECK( histSvc.retrieve() );
 
      TTree *outTreeMC=0;
      TTree *outTreeData=0;
      Int_t channel = 0;UInt_t runNumber = 0; 
      std::vector<UInt_t> pStarts;
      std::vector<UInt_t> pEnds;
      std::vector<UInt_t>* pStartsPtr = &pStarts;
      std::vector<UInt_t>* pEndsPtr = &pEnds;
      Char_t histName[150];
      
 
      //loop over periods ... periods only get entry in table if they have an input histogram 
      for(auto period : m_periods) {
         if(!period.second) continue; //should never happen, but just in case!
         if(period.first<0) continue; //avoid the global run number
         if(period.first != period.second->id) continue; //skips redirects 
         runNumber = period.first;
         pStarts.clear();
         pEnds.clear();
         if(period.second->subPeriods.size()==0) { 
            pStarts.push_back(period.second->start); pEnds.push_back(period.second->end); 
         }
         else {
            for(auto subp : period.second->subPeriods) {
               pStarts.push_back(subp->start); pEnds.push_back(subp->end);
            }
         }
         for(auto& inHist : period.second->inputHists) {
            channel = inHist.first;
            TH1* hist = inHist.second.release();
            strncpy(histName,hist->GetName(),sizeof(histName)-1);
            CHECK( histSvc->regHist(TString::Format("/%s/PileupReweighting/%s",m_configStream.c_str(),hist->GetName()).Data(),hist) );
            if(!outTreeMC) {
               outTreeMC = new TTree("MCPileupReweighting","MCPileupReweighting");
               outTreeMC->Branch("Channel",&channel);
               outTreeMC->Branch("RunNumber",&runNumber);
               outTreeMC->Branch("PeriodStarts",&pStartsPtr);
               outTreeMC->Branch("PeriodEnds",&pEndsPtr);
               outTreeMC->Branch("HistName",&histName,"HistName/C");
               CHECK( histSvc->regTree(TString::Format("/%s/PileupReweighting/%s",m_configStream.c_str(),outTreeMC->GetName()).Data(),outTreeMC) );
            }
            outTreeMC->Fill();
         }
      }
 
      //loop over data 
      for(auto& run : m_runs) {
         runNumber = run.first;
         if(run.second.inputHists.find("None")==run.second.inputHists.end()) continue;
   
         TH1* hist = run.second.inputHists["None"].release();
         strncpy(histName,hist->GetName(),sizeof(histName)-1);
         CHECK( histSvc->regHist(TString::Format("/%s/PileupReweighting/%s",m_configStream.c_str(),hist->GetName()).Data(),hist) );
         if(!outTreeData) {
            outTreeData = new TTree("DataPileupReweighting","DataPileupReweighting");
            outTreeData->Branch("RunNumber",&runNumber);
            outTreeData->Branch("HistName",&histName,"HistName/C");
            CHECK( histSvc->regTree(TString::Format("/%s/PileupReweighting/%s",m_configStream.c_str(),outTreeData->GetName()).Data(),outTreeData) );
         }
         outTreeData->Fill();
      }
 
      Info("WriteToFile", "Successfully generated config file to stream: %s",m_configStream.c_str());
      Info("WriteToFile", "Happy Reweighting :-)");
 
   }
 
#else
      //write the prw config files
      std::string nameWithoutParent = this->name().substr(this->name().find(".")+1);
      TString fileName = TString::Format("%s.prw.root", nameWithoutParent.c_str());
      /*m_tool->*/WriteToFile(fileName);
#endif
   }
 
   m_upTool.reset(); m_downTool.reset(); 
 
   return StatusCode::SUCCESS;
}

GenerateMetaDataFile()

Int_t TPileupReweighting::GenerateMetaDataFile ( const TString & fileName, const TString & channelBranchName = "mc_channel_number" )

inherited

Definition at line 460 of file TPileupReweighting.cxx.

                                                                                                         {
 
   TTree inTree("in","in");
   inTree.ReadFile(fileName);
   TTree outTree("ChannelMetaData","ChannelMetaData");
   Int_t chanNum;
      std::map<TString, Double_t> data;
      TObjArray *leaves = inTree.GetListOfLeaves();
      if(leaves==0) {Error("GenerateMetaDataFile","No leaves"); return -1; }
      for(Int_t i=0;i<leaves->GetEntries();++i) {
         TLeaf *leaf = (TLeaf *)leaves->At(i);
         if(leaf) {
            TBranch *branch = leaf->GetBranch();
            if(strcmp(branch->GetName(),channelBranchName)==0) {
               //this is the channel branch
               if(strcmp(leaf->GetTypeName(),"Int_t")!=0) {
                  Error("GenerateMetaDataFile","Channel Branch must be type Int_t"); return -1;
               }
               branch->SetAddress(&chanNum);
               outTree.Branch(channelBranchName,&chanNum);
            } else if(strcmp(leaf->GetTypeName(),"Double_t")!=0) {
                  Warning("GenerateMetaDataFile","Cannot read non-double branch: %s",branch->GetName());
            } else {
               branch->SetAddress(&(data[branch->GetName()]));
               outTree.Branch(branch->GetName(),&(data[branch->GetName()]));
            }
         }
      }
      //loop over tree entries and read in the values according to property type
      for(Int_t i=0;i<inTree.GetEntries();++i) {
         inTree.GetEntry(i);
         outTree.Fill();
      }
 
      //remove the file extension and replace with .root
      TString outName = fileName(0,fileName.Last('.'));
      outName += ".prw.root";
      TFile f1(outName,"RECREATE");
      outTree.Write();
      f1.Close();
      if (m_printInfo) {
        Info("GenerateMetaDataFile","Succesfully Generated File %s",outName.Data());
      }
      return 0;
}

GetCombinedWeight()

Float_t TPileupReweighting::GetCombinedWeight ( Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y = 0. )

inherited

Definition at line 1605 of file TPileupReweighting.cxx.

                                                                                                             {
   if(!m_isInitialized) {
     if (m_printInfo) Info("GetCombinedWeight","Initializing the subtool..");
     Initialize();
   }
   if(m_countingMode) return 0.;
 
   //decide how many dimensions this weight has - use the emptyHistogram to tell...
   TH1* hist = m_emptyHistogram.get();
   if(!hist) {
      Error("GetCombinedWeight","Tool not configured properly ... please report this!");
      throw std::runtime_error("Throwing 47: Tool not configured properly ... please report this!");
   }
 
   Float_t out = GetPeriodWeight(periodNumber,channelNumber)*GetPrimaryWeight(periodNumber,channelNumber,x);
   if(hist->GetDimension()>1) out *= GetSecondaryWeight(periodNumber,channelNumber,x,y);
 
   return out;
}

getCombinedWeight() [1/3]

float CP::PileupReweightingTool::getCombinedWeight ( const xAOD::EventInfo & eventInfo, bool correctUnrepresented )

virtual

Return combined pileup weight.

Implements CP::IPileupReweightingTool.

Definition at line 402 of file PileupReweightingTool.cxx.

                                                                                                          {
   float weight = m_activeTool->GetCombinedWeight(   eventInfo.runNumber(), eventInfo.mcChannelNumber(), eventInfo.averageInteractionsPerCrossing() );
   if(correctUnrepresented && m_unrepresentedDataAction==2) 
      weight *= getUnrepresentedDataWeight( eventInfo );
   return weight;
}

getCombinedWeight() [2/3]

float CP::PileupReweightingTool::getCombinedWeight ( const xAOD::EventInfo & eventInfo, const TString & trigger, bool mu_dependent, bool correctUnrepresented )

virtual

get combined weight (i.e. pileup weight) but with a 1./dataWeight factor applied, this if used for 'prescaling' MC

Implements CP::IPileupReweightingTool.

Definition at line 530 of file PileupReweightingTool.cxx.

                                                                                                                                                      {
   float out = getCombinedWeight(eventInfo, correctUnrepresented);
   if(!out) return out; //don't try to evaluate DataWeight if our PRW is 0 ... means there is no data available at that mu anyway
 
   out *= getPrescaleWeight(eventInfo, trigger, mu_dependent);
   return out;
}

getCombinedWeight() [3/3]

float CP::PileupReweightingTool::getCombinedWeight ( const xAOD::EventInfo & eventInfo, Double_t x, Double_t y, bool correctUnrepresented )

virtual

Same as above, but for a 'custom weight' variable.

Implements CP::IPileupReweightingTool.

Definition at line 409 of file PileupReweightingTool.cxx.

                                                                                                                                  {
   float weight = m_activeTool->GetCombinedWeight(   eventInfo.runNumber(), eventInfo.mcChannelNumber(), x, y );
   if(correctUnrepresented && m_unrepresentedDataAction==2) 
      weight *= getUnrepresentedDataWeight( eventInfo );
   return weight;
}

getCorrectedActualInteractionsPerCrossing()

float CP::PileupReweightingTool::getCorrectedActualInteractionsPerCrossing ( const xAOD::EventInfo & eventInfo, bool includeDataScaleFactor )

virtual

Get the corrected 'actual' interactions per crossing.

Implements CP::IPileupReweightingTool.

Definition at line 157 of file PileupReweightingTool.cxx.

                                                                                                                                    { 
   float result = 1.;
   const float actualInteractions = eventInfo.actualInteractionsPerCrossing();
   if(eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION)) {
      return actualInteractions; //no correction needed for MC
   }
   float correctedMu = CP::TPileupReweighting::GetLumiBlockMu(eventInfo.runNumber(),eventInfo.lumiBlock());
   if(correctedMu<0) return correctedMu; //will be -1
   if ( const auto avg = eventInfo.averageInteractionsPerCrossing(); avg != 0.){
     result =  actualInteractions * (correctedMu/avg) * ( (includeDataScaleFactor) ? m_activeTool->GetDataScaleFactor() : 1.); 
   } 
   return result;
}

getCorrectedAverageInteractionsPerCrossing()

float CP::PileupReweightingTool::getCorrectedAverageInteractionsPerCrossing ( const xAOD::EventInfo & eventInfo, bool includeDataScaleFactor )

virtual

Get the mu of a lumiblock ... needed to 'correct' the number in datasets.

Implements CP::IPileupReweightingTool.

Definition at line 148 of file PileupReweightingTool.cxx.

                                                                                                                                     { 
   if(eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION)) {
      return eventInfo.averageInteractionsPerCrossing(); //no correction needed for MC
   }
   float out = CP::TPileupReweighting::GetLumiBlockMu(eventInfo.runNumber(),eventInfo.lumiBlock());
   if(out<0) return out; //will be -1
   return out * ( (includeDataScaleFactor) ? m_activeTool->GetDataScaleFactor() : 1.); 
}

getCorrectedMu()

virtual float CP::IPileupReweightingTool::getCorrectedMu ( const xAOD::EventInfo & eventInfo, bool includedDataScaleFactor = false )

inlinevirtualinherited

Get the corrected average mu of a lumiblock ... (averaging is over all filled BCID in the fill) The additional flag indicates if the returned value should include the data scale factor or not.

Note: if the lumiblock is not present in the input lumicalc file, then -1.0 will be returned This method will soon be deprecated in favour of the new naming: getCorrectedAverageInteractionsPerCrossing

Definition at line 61 of file IPileupReweightingTool.h.

                                                                                                            {
            return getCorrectedAverageInteractionsPerCrossing( eventInfo, includedDataScaleFactor );
         }

GetDataScaleFactor()

Float_t CP::TPileupReweighting::GetDataScaleFactor ( ) const

inlineinherited

Definition at line 298 of file TPileupReweighting.h.

{ return m_dataScaleFactorX; }

GetDataWeight() [1/2]

Double_t TPileupReweighting::GetDataWeight ( Int_t runNumber, const TString & trigger )

inherited

Definition at line 1724 of file TPileupReweighting.cxx.

                                                                                    {
   //special mu-independent version of GetDataWeight. Will just use the global luminosity
   m_doGlobalDataWeight=true;
   double out = GetDataWeight(runNumber, trigger, 0);
   m_doGlobalDataWeight=false;
   return out;
}

GetDataWeight() [2/2]

Double_t TPileupReweighting::GetDataWeight ( Int_t runNumber, const TString & trigger, Double_t x, bool run_dependent = false )

inherited

Method for weighting data to account for prescales and mu bias.

Use by giving the tool multiple lumicalc files, one for each trigger

Definition at line 1732 of file TPileupReweighting.cxx.

                                                                                                                   {
 
  if(!m_isInitialized ) {
    if (m_printInfo) Info("GetDataWeight","Initializing the subtool..");
    Initialize();
  }
   if(m_countingMode) return 0.;
 
   //determine which period this run number is in
   Int_t periodNumber = GetFirstFoundPeriodNumber(runNumber);
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetDataWeight","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
 
   //see if we already made this trigger hist
   auto tobj = m_triggerObjs.find(trigger);
 
 
   if(tobj==m_triggerObjs.end()) {
      //try to do a subtrigger calculation we need to reopen all the lumicalc files and do the fiddily prescaled luminosity calculation
      //will throw errors if can't
      CalculatePrescaledLuminosityHistograms(trigger,0);
      tobj = m_triggerObjs.find(trigger);
   }
 
   //check
 
 
 
   if(tobj->second->triggerHists.find(p->id) == tobj->second->triggerHists.end()) {
    Error("GetDataWeight","Could not find trigger %s in period %d",trigger.Data(),p->id);
    throw std::runtime_error("GetDataWeight: Could not find trigger 1");
   }
 
 
   //now we need to evaluate the trigger bits, and if necessary calculate the new trigger hist for the new bits combination
   long tbits = tobj->second->getBits(this);
 
   if(tbits==0) return 1; //no trigger passed
 
   int idx = (runDependent) ? -runNumber : p->id;
 
 
   auto dItr = tobj->second->triggerHists[idx].find(tbits);
 
   TH1* denomHist = 0;
   if(dItr == tobj->second->triggerHists[idx].end()) {
      //possible that the tbits for this event have not been encountered before, so just redo the calculation ...
      calculateHistograms(tobj->second.get(),(runDependent) ? runNumber:0);
 
      denomHist = tobj->second->triggerHists[idx][tbits].get();
      if(denomHist==0) {
        Error("GetDataWeight","Could not find trigger %s in period %d with bits %ld",trigger.Data(),idx, tbits);
        throw std::runtime_error("GetDataWeight: Could not find trigger 2");
      }
   } else {
      denomHist = dItr->second.get();
   }
 
 
   TH1* numerHist = m_triggerObjs["None"]->triggerHists[idx][0].get();
   if(numerHist==0) {
      Error("GetDataWeight","Could not find unprescaled trigger in period %d",idx);
      throw std::runtime_error("GetDataWeight: Could not find unprescaled trigger. Please AddLumiCalc with a 'None' trigger");
   }
 
   if(m_doGlobalDataWeight) return numerHist->Integral(0,numerHist->GetNbinsX()+1)/denomHist->Integral(0,denomHist->GetNbinsX()+1);
 
   Int_t bin=(m_doPrescaleWeight) ? numerHist->FindFixBin(x) : //DO NOT SHIFT IF GETTING A PRESCALE WEIGHT - applied to MC, we only shift incoming mu if we are data
     numerHist->FindFixBin(x*m_dataScaleFactorX); //if getting a data weight (i.e. running on data) MUST SCALE BY THE DATA SCALE FACTOR! (assume incoming is raw unscaled)
 
   //we also need to redirect the binning if necessary (unrepData=3)
   if( (!m_doPrescaleWeight) && m_unrepresentedDataAction==3) bin = p->inputBinRedirect[bin];
 
   if(!denomHist->GetBinContent(bin)) {
     if(m_doPrescaleWeight) return -1; //happens if trigger was disabled/unavailable for that mu, even though that mu is in the dataset
      Error("GetDataWeight","Unrecognised mu value %f ... are you sure you included all lumicalc files",x);
      throw std::runtime_error("GetDataWeight: Unrecognised mu value. Please AddLumiCalc enough lumi with 'None' trigger");
   }
 
   return numerHist->GetBinContent(bin)/denomHist->GetBinContent(bin);
}

getDataWeight()

float CP::PileupReweightingTool::getDataWeight ( const xAOD::EventInfo & eventInfo, const TString & trigger, bool mu_dependent )

virtual

Get the dataWeight used to 'unprescale' data collected from a given trigger combination. mu_dependency is recommended to be true.

Implements CP::IPileupReweightingTool.

Definition at line 500 of file PileupReweightingTool.cxx.

                                                                                                                    {
 
   if(eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION)) {
      ATH_MSG_WARNING("Requesting Data Weight is not intended for simulated events. Returning 1.");
      return 1; //no data weights for simulated events
   }
 
   if(!mu_dependent) return /*m_tool->*/m_activeTool->GetDataWeight(eventInfo.runNumber(), trigger);
   
   double correctedMu = getCorrectedAverageInteractionsPerCrossing(eventInfo,false);
   if(correctedMu<0) {
      ATH_MSG_ERROR("Unrecognised run+lumiblock number (" << eventInfo.runNumber() << "," << eventInfo.lumiBlock() << ") ... please ensure your lumicalc files are complete! Returning 1.");
      return 1;
   }
   
   return /*m_tool->*/m_activeTool->GetDataWeight( eventInfo.runNumber(), trigger,  correctedMu/*use the 'correct' mu instead of the one from the file!!*/ );
 
}

GetDefaultChannel()

Int_t TPileupReweighting::GetDefaultChannel ( Int_t mcRunNumber = -1 )

inherited

Definition at line 109 of file TPileupReweighting.cxx.

                                                               {
   if(m_parentTool != this) return m_parentTool->GetDefaultChannel(mcRunNumber);
   return m_periods[mcRunNumber]->defaultChannel;
}

GetFirstFoundPeriodNumber()

Int_t TPileupReweighting::GetFirstFoundPeriodNumber ( UInt_t runNumber )

inherited

Get the first period number with the data run number contained - assume all periods are disconnected for this to be useful.

Definition at line 422 of file TPileupReweighting.cxx.

                                                                      {
   //go through periods, first period that includes this runNumber wins!
   //otherwise it returns the 'global period number': -1
   for(auto period : m_periods) {
      if(period.second->id==-1) continue;
      if(period.second->contains(runNumber)) return period.second->id;
   }
   return -1;
 
}

GetInputHistogram()

TH1 * CP::TPileupReweighting::GetInputHistogram ( Int_t channelNumber, Int_t periodNumber )

inlineinherited

Definition at line 251 of file TPileupReweighting.h.

                                                                      {
         if(m_periods.find(periodNumber)==m_periods.end()||
            m_periods[periodNumber]->inputHists.find(channelNumber)==m_periods[periodNumber]->inputHists.end()) {
            return 0;
         }
         return m_periods[periodNumber]->inputHists[channelNumber].get();
      }

GetIntegratedLumi() [1/3]

virtual Double_t CP::PileupReweightingTool::GetIntegratedLumi ( const TString & trigger )

inlinevirtual

Total lumi (in pb-1) for a given trigger combination .. leave blank for the unprescaled.

Implements CP::IPileupReweightingTool.

Definition at line 51 of file PileupReweightingTool.h.

{ return m_activeTool->GetIntegratedLumi(trigger); }

GetIntegratedLumi() [2/3]

virtual Double_t CP::PileupReweightingTool::GetIntegratedLumi ( Int_t periodNumber, UInt_t start, UInt_t end )

inlinevirtual

similar to above, but for only the given mcRunNumber/periodNumber

Implements CP::IPileupReweightingTool.

Definition at line 53 of file PileupReweightingTool.h.

{ return m_activeTool->GetIntegratedLumi(periodNumber, start, end); }

GetIntegratedLumi() [3/3]

virtual Double_t CP::PileupReweightingTool::GetIntegratedLumi ( UInt_t start, UInt_t end )

inlinevirtual

Get the integrated luminosity (in pb-1) between start and end run (inclusive)

Implements CP::IPileupReweightingTool.

Definition at line 49 of file PileupReweightingTool.h.

{ return m_activeTool->GetIntegratedLumi(start, end); }

GetIntegratedLumiFraction() [1/2]

virtual Double_t CP::PileupReweightingTool::GetIntegratedLumiFraction ( Int_t periodNumber, Double_t mu, UInt_t start, UInt_t end )

inlinevirtual

return fraction of lumi assigned to periodNumber (or mcRunNumber) with given mu, that is between start and end data run numbers

Implements CP::IPileupReweightingTool.

Definition at line 57 of file PileupReweightingTool.h.

{ return m_activeTool->GetIntegratedLumiFraction(periodNumber, mu, start, end); }

GetIntegratedLumiFraction() [2/2]

virtual Double_t CP::PileupReweightingTool::GetIntegratedLumiFraction ( Int_t periodNumber, UInt_t start, UInt_t end )

inlinevirtual

return fraction of lumi assigned to periodNumber (or mcRunNumber) that is between start and end data run numbers

Implements CP::IPileupReweightingTool.

Definition at line 55 of file PileupReweightingTool.h.

{ return m_activeTool->GetIntegratedLumiFraction(periodNumber, start, end); }

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

GetLumiBlockIntegratedLumi()

Double_t TPileupReweighting::GetLumiBlockIntegratedLumi ( Int_t runNumber, UInt_t lb )

inherited

get integrated lumi for specific run and lumiblock number .

. comes from the 'unprescaled lumi', and is in pb

Definition at line 154 of file TPileupReweighting.cxx.

                                                                                    {
   if(!m_isInitialized) {
     if (m_printInfo) {
       Info("GetIntegratedLumi","Initializing the subtool..");
     }
     Initialize();
   }
   if(m_runs.find(runNumber)==m_runs.end()) return 0.;
   auto& run = m_runs[runNumber];
 
   if(run.lumiByLbn.find(lb)==run.lumiByLbn.end()) return 0.;
   return run.lumiByLbn[lb].first*1E-6;
}

getLumiBlockIntegratedLumi()

double CP::PileupReweightingTool::getLumiBlockIntegratedLumi ( const xAOD::EventInfo & eventInfo )

virtual

Get the integrated lumi of a lumiblock (in pb-1)

Implements CP::IPileupReweightingTool.

Definition at line 172 of file PileupReweightingTool.cxx.

{ return CP::TPileupReweighting::GetLumiBlockIntegratedLumi(eventInfo.runNumber(),eventInfo.lumiBlock()); }

GetLumiBlockMu()

Float_t TPileupReweighting::GetLumiBlockMu ( Int_t runNumber, UInt_t lb )

inherited

get the lumiblock mu, useful for 'updating' the mu coming from data to account for new lumitags

Definition at line 168 of file TPileupReweighting.cxx.

                                                                       {
  if(!m_isInitialized) {
    if (m_printInfo) {
      Info("GetLumiBlockMu","Initializing the subtool..");
    }
    Initialize();
  }
   if(m_runs.find(runNumber)==m_runs.end()) return -1.0;
   auto& run = m_runs[runNumber];
 
   if(run.lumiByLbn.find(lb)==run.lumiByLbn.end()) return -1.0;
   return run.lumiByLbn[lb].second;
}

GetMetaData()

Double_t CP::TPileupReweighting::GetMetaData ( const TString & metadataName, Int_t channelNumber )

inlineinherited

Definition at line 188 of file TPileupReweighting.h.

                                                                            {
         if(m_metadata.find(metadataName)==m_metadata.end()) {
            Error("GetMetaData","Metadata %s not known",metadataName.Data());
            return 0;
         }
         if(m_metadata[metadataName].find(channelNumber)==m_metadata[metadataName].end()) {
            Error("GetMetaData","Metadata %s not known in channel %d",metadataName.Data(), channelNumber);
            return 0;
         }
         return m_metadata[metadataName][channelNumber];
      }

GetMetaDataTree()

TTree * TPileupReweighting::GetMetaDataTree ( )

inherited

combines loaded metadata with channel sumsofweights and entry counts

Definition at line 574 of file TPileupReweighting.cxx.

                                             {
   if(m_metadatatree) delete m_metadatatree;
   m_metadatatree = new TTree(TString(this->GetName())+"MetaData",TString(this->GetName())+"MetaData");
   m_metadatatree->SetDirectory(0);
   Int_t channel=0;
   m_metadatatree->Branch("mc_channel_number",&channel);
   std::map<TString,Double_t> data;
   std::map<Int_t,bool> channels;
   //create a branch for each metadata item
   for(std::map<TString,std::map<Int_t,Double_t> >::iterator it=m_metadata.begin();it!=m_metadata.end();++it) {
      for(std::map<Int_t,Double_t>::iterator it2=(it->second).begin();it2!=(it->second).end();++it2) {
         channels[it2->first]=true; //records which channels we have metadata for
      }
      const auto &[ptr, inserted ] = data.try_emplace(it->first, 0.);
      if (inserted){
        m_metadatatree->Branch(it->first,&(data[it->first]));
      }
   }
   //also create branches for the NumberOfEvents and SumOfEventWeights
   data["NumberOfEvents"]=0.;
   m_metadatatree->Branch("NumberOfEvents",&(data["NumberOfEvents"]));
   data["SumOfEventWeights"]=0.;
   m_metadatatree->Branch("SumOfEventWeights",&(data["SumOfEventWeights"]));
   //and add to channels list any channels that have events
   auto& myMap = m_periods[-1]->sumOfWeights;
   for(std::map<Int_t,Double_t>::iterator it=myMap.begin();it!=myMap.end();++it) {
      if(it->first>=0 && it->second>0.) channels[it->first]=true;
   }
 
   //now loop over the channels and fill the TTree
   for(std::map<Int_t,bool>::iterator it=channels.begin();it!=channels.end();++it) {
      channel=it->first;
      for(std::map<TString,Double_t>::iterator it2=data.begin();it2!=data.end();++it2) {
         if(it2->first=="NumberOfEvents") {
            //check for this in globalNumberOfEntries
            if(myMap.find(channel)==myMap.end()) {
               data[it2->first]=0.;
               Warning("GetMetaDataTree","Channel %d does not have MetaData %s",it->first,(it2->first).Data());
            } else {
               data[it2->first]=m_periods[-1]->numberOfEntries[channel];
            }
         } else if(it2->first=="SumOfEventWeights") {
            //check for this in globalTotals
            auto& myMap2 = m_periods[-1]->sumOfWeights;
            if(myMap2.find(channel)==myMap2.end()) {
               data[it2->first]=0.;
               Warning("GetMetaDataTree","Channel %d does not have MetaData %s",it->first,(it2->first).Data());
            } else {
               data[it2->first]=m_periods[-1]->sumOfWeights[channel];
            }
         } else {
            auto& myMap2 = m_metadata[it2->first];
            if(myMap2.find(channel)==myMap2.end()) {
               //this channel doesn't have this property
               data[it2->first]=0.;
               Warning("GetMetaDataTree","Channel %d does not have MetaData %s",it->first,(it2->first).Data());
            } else {
               data[it2->first]=myMap2[channel];
            }
         }
      }
      m_metadatatree->Fill();
   }
 
   m_metadatatree->BuildIndex("mc_channel_number");
   m_metadatatree->ResetBranchAddresses();
 
   return m_metadatatree;
}

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

GetNearestGoodBin()

Int_t TPileupReweighting::GetNearestGoodBin ( Int_t thisMCRunNumber, Int_t bin )

protectedinherited

Definition at line 1369 of file TPileupReweighting.cxx.

                                                                              {
 
   int binDistance = 1;
   do {
      int res1 = IsBadBin(thisMCRunNumber,bin+binDistance);
      if(!res1) return bin+binDistance;
      int res2 = IsBadBin(thisMCRunNumber,bin-binDistance);
      if(!res2) return bin-binDistance;
      if(res1==2 && res2==2) { //run out of bins
         Error("GetNearestGoodBin", "None of the bins are good!!??");
         return -1;
      }
      binDistance++;
   } while(true); //scary!
 
   return -1;
 
}

GetNumberOfEvents()

virtual Double_t CP::PileupReweightingTool::GetNumberOfEvents ( Int_t channel )

inlinevirtual

Implements CP::IPileupReweightingTool.

Definition at line 65 of file PileupReweightingTool.h.

{ return m_activeTool->GetNumberOfEvents(channel) ; }

GetPeriodNumbers()

std::vector< int > CP::TPileupReweighting::GetPeriodNumbers ( ) const

inlineinherited

Definition at line 242 of file TPileupReweighting.h.

                                              {
        std::vector<int> out;
        for(auto& p : m_periods) { out.push_back(p.first); }
        return out;
      }

GetPeriodWeight()

Float_t TPileupReweighting::GetPeriodWeight ( Int_t periodNumber, Int_t channelNumber )

inherited

Definition at line 1625 of file TPileupReweighting.cxx.

                                                                                     {
   //= L_A/L / N_A/N
  if(!m_isInitialized) {
    if (m_printInfo) Info("GetPeriodWeight","Initializing the subtool..");
     Initialize();
  }
   if(m_countingMode) return 0.;
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetPeriodWeight","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
   if(p->sumOfWeights.find(channelNumber) == p->sumOfWeights.end()) {
    channelNumber = GetDefaultChannel(periodNumber);//p->defaultChannel;
    if(channelNumber!=0) {
      Warning("GetPeriodWeight","You're using a default config file ... you're gonna have a bad time!!");
      Warning("GetPeriodWeight","Please generate proper config files!");
    }
   }
 
   double n_a = p->sumOfWeights[channelNumber];
   double n = m_periods[-1]->sumOfWeights[channelNumber];
 
   double l_a = p->sumOfWeights[-1];
   double l = m_periods[-1]->sumOfWeights[-1];
 
   return (l_a/l) / (n_a/n);
}

GetPrescaleWeight() [1/2]

Double_t TPileupReweighting::GetPrescaleWeight ( Int_t runNumber, const TString & trigger )

inherited

Definition at line 1819 of file TPileupReweighting.cxx.

                                                                                        {
   //special mu-independent version of GetPrescaleWeight. Will just use the global luminosity
   m_doGlobalDataWeight=true;
   double out = GetPrescaleWeight(runNumber, trigger, 0);
   m_doGlobalDataWeight=false;
   return out;
}

GetPrescaleWeight() [2/2]

Double_t TPileupReweighting::GetPrescaleWeight ( Int_t runNumber, const TString & trigger, Double_t x, bool run_dependent = false )

inherited

Method for prescaling MC to account for prescales in data.

Definition at line 1827 of file TPileupReweighting.cxx.

                                                                                                                       {
 
  m_doPrescaleWeight = true;
  double out = GetDataWeight(runNumber,trigger,x,runDependent);
  m_doPrescaleWeight = false;
  if(out<=0) return 0; //happens when triggers disabled/unavailable for a given mu ... therefore the prescale weight is 0
  return 1./out;
 
}

getPrescaleWeight()

float CP::PileupReweightingTool::getPrescaleWeight ( const xAOD::EventInfo & eventInfo, const TString & trigger, bool mu_dependent )

virtual

Get weight used to 'prescale' Monte Carlo for given trigger comibnation.

Implements CP::IPileupReweightingTool.

Definition at line 519 of file PileupReweightingTool.cxx.

                                                                                                                           {
   //need to use the random run number ... only used to pick the subperiod, but in run2 so far we only have one subperiod
   SG::ConstAccessor<unsigned int> rrnAcc (m_prefix+"RandomRunNumber");
   unsigned int randomRunNum = rrnAcc.withDefault (eventInfo, 0);
   if (randomRunNum == 0) {
     randomRunNum = getRandomRunNumber( eventInfo, mu_dependent );
   }
   if(!mu_dependent) return m_activeTool->GetPrescaleWeight(randomRunNum, trigger);
   return m_activeTool->GetPrescaleWeight( randomRunNum, trigger, getCorrectedAverageInteractionsPerCrossing(eventInfo,false) /*use the 'correct' mu instead of the one from the file!!*/, m_useRunDependentPrescaleWeight /*run-dependent*/ );
}

GetPrimaryDistribution()

TH1 * CP::TPileupReweighting::GetPrimaryDistribution ( Int_t channelNumber, Int_t periodNumber )

inlineinherited

Definition at line 259 of file TPileupReweighting.h.

                                                                           {
         if(m_periods.find(periodNumber)==m_periods.end()||
            m_periods[periodNumber]->primaryHists.find(channelNumber)==m_periods[periodNumber]->primaryHists.end()) {
            return 0;
         }
         return m_periods[periodNumber]->primaryHists[channelNumber].get();
      }

GetPrimaryTriggerDistribution()

TH1 * CP::TPileupReweighting::GetPrimaryTriggerDistribution ( const TString & trigger, Int_t periodNumber, long triggerBits )

inlineinherited

Definition at line 267 of file TPileupReweighting.h.

                                                                                                        {
         if(m_triggerObjs.find(trigger)==m_triggerObjs.end() || m_triggerObjs[trigger]->triggerHists.find(periodNumber) ==m_triggerObjs[trigger]->triggerHists.end() ||
            m_triggerObjs[trigger]->triggerHists[periodNumber].find(triggerBits) == m_triggerObjs[trigger]->triggerHists[periodNumber].end()) return 0;
      /*
         if(m_triggerObjs.find(trigger)==m_triggerObjs.end() || m_triggerObjs.at(trigger).second->triggerHists.find(periodNumber)==m_triggerObjs.at(trigger).second->->triggerHists.end() ||
            m_triggerObjs.at(trigger).second->triggerHists.at(periodNumber).find(triggerBits) == m_triggerObjs.at(trigger).second.at(periodNumber).end()) return 0;
      */
         
         return m_triggerObjs[trigger]->triggerHists[periodNumber][triggerBits].get();
      }

GetPrimaryWeight()

Float_t TPileupReweighting::GetPrimaryWeight ( Int_t periodNumber, Int_t channelNumber, Float_t x )

inherited

Definition at line 1655 of file TPileupReweighting.cxx.

                                                                                                {
   //= L_i/L_A / N_i/N_A .. primaryHists have already been normalized
  if(!m_isInitialized ) {
    if (m_printInfo) Info("GetPrimaryWeight","Initializing the subtool..");
    Initialize();
  }
   if(m_countingMode) return 0.;
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetPrimaryWeight","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
   int oChanNumber = channelNumber;
   if(p->sumOfWeights.find(channelNumber) == p->sumOfWeights.end()) channelNumber = GetDefaultChannel(periodNumber);//p->defaultChannel;
 
   if(!p->primaryHists[channelNumber]) {
      Error("GetPrimaryWeight","Unrecognised channelNumber %d for periodNumber %d",oChanNumber,periodNumber);
      throw std::runtime_error("Throwing 2: Unrecognised channelNumber");
   }
 
   int bin = p->primaryHists[channelNumber]->FindFixBin(x);
 
   double n = p->primaryHists[channelNumber]->GetBinContent(bin);
 
   // There is a special case  that needs some additional protection
   // If you have the sum of weights ==0 for a given mu then you will have 0 in the PRW
   // profile leading to an exception or FPE later
   if (n==0){
      Warning("GetPrimaryWeight","No events expected in channelNumber %d for periodNumber %d with x=%g.  Incorrect PRW profile or are you very unlucky???",channelNumber,periodNumber,x);
      return 1.;
   }
 
   if(!p->primaryHists[-1]) {
      Error("GetPrimaryWeight","No data loaded for period %d. Did you forget to load a lumicalc file or data config file?",periodNumber);
      throw std::runtime_error("Throwing 3: No data loaded. Did you forget to load a lumicalc file or data config file?");
   }
 
   double l = p->primaryHists[-1]->GetBinContent(bin);
 
   if (l==0 && n==0){
      Error("GetPrimaryWeight","No events expected with this mu.  Incorrect PRW profile?  Throwing exception ...");
      throw std::runtime_error(Form("Incorrect PRW profile detected. x=%g is not in the config file profile for channel %d, period %d", x, channelNumber, periodNumber ));
   }
 
   return l/n;
}

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

GetPRWHash()

ULong64_t TPileupReweighting::GetPRWHash ( Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y = 0. )

inherited

Definition at line 1586 of file TPileupReweighting.cxx.

                                                                                                        {
  if(!m_isInitialized) {
    if (m_printInfo) Info("GetPRWHash","Initializing the subtool..");
    Initialize();
  }
   TH1* hist = m_emptyHistogram.get();
   if(!hist) {
      Error("GetPRWHash","Tool not configured properly ... please report this!");
      throw std::runtime_error("Throwing 47: Tool not configured properly ... please report this!");
   }
 
   ULong64_t out = hist->FindFixBin(x,y);
   out += (unsigned long)(channelNumber)*10000000000;
   out += (unsigned long)(periodNumber)*10000;
 
   return out;
 
}

getPRWHash()

ULong64_t CP::PileupReweightingTool::getPRWHash ( const xAOD::EventInfo & eventInfo )

virtual

return the prw hash used for fast updates of weights at the post-processing level ... see the share/makeWeightTree.C script for usage

Implements CP::IPileupReweightingTool.

Definition at line 397 of file PileupReweightingTool.cxx.

                                                                            {
   return m_activeTool->GetPRWHash(eventInfo.runNumber(), eventInfo.mcChannelNumber(), eventInfo.averageInteractionsPerCrossing() );
}

GetRandomLumiBlockNumber()

virtual UInt_t CP::PileupReweightingTool::GetRandomLumiBlockNumber ( UInt_t runNumber )

inlinevirtual

Get a random lumiblock number for the given run number.

Implements CP::IPileupReweightingTool.

Definition at line 47 of file PileupReweightingTool.h.

{ return m_activeTool->GetRandomLumiBlockNumber(runNumber); }

GetRandomPeriodNumber()

Int_t TPileupReweighting::GetRandomPeriodNumber ( Int_t mcRunNumber )

inherited

Get random period number from the sub-periods assigned to this run number.

Definition at line 1494 of file TPileupReweighting.cxx.

                                                                    {
   if(!m_isInitialized) {
     if (m_printInfo) Info("GetRandomPeriodNumber","Initializing the subtool..");
     Initialize();
   }
   if(m_countingMode) { return 0; } //do nothing when in counting mode
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetRandomPeriodNumber","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
 
   //if no subperiods, we just return ourselves
   if(p->subPeriods.size()==0) return p->id;
 
   //need the total lumi of this period
   double lumi = p->sumOfWeights[-1] * m_random3->Rndm();
 
   //loop over subPeriods ..
   double lumiSum=0;
   for(auto subp : p->subPeriods) {
      lumiSum += subp->sumOfWeights[-1];
      if(lumiSum >= lumi) return subp->id;
   }
 
   Error("GetRandomPeriodNumber","overran integrated luminosity for periodNumber=%d",periodNumber);
   throw std::runtime_error("Throwing 46.1: overran integrated luminosity for GetRandomPeriodNumber");
   return 0;
 
}

GetRandomRunNumber() [1/2]

UInt_t TPileupReweighting::GetRandomRunNumber ( Int_t mcRunNumber )

inherited

Gets a random data run number according to the integrated lumi distribution associated to this mcRunNumber.

allows use of custom reweighting config files

Definition at line 1414 of file TPileupReweighting.cxx.

                                                                  {
   if(!m_isInitialized) {
     if (m_printInfo)Info("GetRandomRunNumber","Initializing the subtool..");
     Initialize();
   }
   if(m_countingMode) { return 0; } //do nothing when in counting mode
 
   Period* p = m_periods[periodNumber];
   if(!p || !p->primaryHists[-1]) {
      Error("GetRandomRunNumber","Unrecognised periodNumber or no data loaded for: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
 
   double lumi = p->sumOfWeights[-1] * m_random3->Rndm();
 
   //go through the runs assigned to this period ...
   double lumiSum=0;
   for(auto runNum : p->runNumbers) {
      lumiSum += m_runs[runNum].inputHists["None"]->GetSumOfWeights();
      if(lumiSum >= lumi-0.00001) return runNum; //small difference is to catch rounding errors
   }
   Error("GetRandomRunNumber","overran integrated luminosity for periodNumber=%d (%f vs %f)",periodNumber,lumiSum,lumi);
   throw std::runtime_error("Throwing 46.1: overran integrated luminosity for GetRandomRunNumber");
   return 0;
}

GetRandomRunNumber() [2/2]

UInt_t TPileupReweighting::GetRandomRunNumber ( Int_t mcRunNumber, Double_t mu )

inherited

Get random run number according to integrated lumi distribution for the given mu value (uses the binning of the mu histogram)

Definition at line 1440 of file TPileupReweighting.cxx.

                                                                              {
   if(!m_isInitialized) {
     if (m_printInfo) Info("GetRandomRunNumber","Initializing the subtool..");
     Initialize();
   }
   if(m_countingMode) { return 0; } //do nothing when in counting mode
 
   Period* p = m_periods[periodNumber];
   if(!p || !p->primaryHists[-1]) {
      Error("GetRandomRunNumber","Unrecognised periodNumber or no data loaded for: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
 
   int bin = m_emptyHistogram->FindFixBin(x);
 
   double lumi = p->primaryHists[-1]->GetBinContent(bin) * p->sumOfWeights[-1] * m_random3->Rndm();
 
   if(!lumi) { return 0; } //no lumi with that mu
 
 
   //go through the runs assigned to this period ...
   double lumiSum=0;
   for(auto runNum : p->runNumbers) {
      lumiSum += m_runs[runNum].inputHists["None"]->GetBinContent(bin);
      if(lumiSum >= lumi-0.00001) return runNum;  //small difference is to catch rounding errors
   }
   Error("GetRandomRunNumber","overran integrated luminosity for periodNumber=%d (%f vs %f)",periodNumber,lumiSum,lumi);
   throw std::runtime_error("Throwing 46.1: overran integrated luminosity for GetRandomRunNumber");
   return 0;
}

getRandomRunNumber()

int CP::PileupReweightingTool::getRandomRunNumber ( const xAOD::EventInfo & eventInfo, bool mu_dependent )

virtual

Get a random run number for this MC event, using mu-dependent randomization by default ... jetetmiss seem to like it muchly.

Get a random run number for this MC event, mu_dependency is not recommended for this.

Implements CP::IPileupReweightingTool.

Definition at line 423 of file PileupReweightingTool.cxx.

                                                                                                 {
   CP::TPileupReweighting* tool = (m_varyRunNumber) ? m_activeTool : this;
   tool->SetRandomSeed(314159+eventInfo.mcChannelNumber()*2718+eventInfo.eventNumber()); //to make randomization repeatable
   if(mu_dependent) return tool->GetRandomRunNumber(   eventInfo.runNumber(), eventInfo.averageInteractionsPerCrossing()  );
   else return tool->GetRandomRunNumber( eventInfo.runNumber() );
}

GetRandomSeed()

int CP::TPileupReweighting::GetRandomSeed ( )

inlineinherited

Definition at line 223 of file TPileupReweighting.h.

{return m_random3->GetSeed();}

GetRunAverageMu()

double CP::TPileupReweighting::GetRunAverageMu ( int run )

inlineinherited

Definition at line 303 of file TPileupReweighting.h.

{ return m_runs[run].inputHists["None"]->GetMean(); }

GetRunMap()

std::map< UInt_t, Run > & CP::TPileupReweighting::GetRunMap ( )

inlineinherited

Definition at line 453 of file TPileupReweighting.h.

{ return m_runs; }

GetSecondaryWeight()

Float_t TPileupReweighting::GetSecondaryWeight ( Int_t periodNumber, Int_t channelNumber, Float_t x, Float_t y )

inherited

Definition at line 1703 of file TPileupReweighting.cxx.

                                                                                                            {
   //= L_j/L_i / N_j/N_i .. secondary hists have already been normalized
  if(!m_isInitialized ) {
    if (m_printInfo) Info("GetSecondaryWeight","Initializing the subtool..");
    Initialize();
  }
   if(m_countingMode) return 0.;
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetSecondaryWeight","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
   if(p->sumOfWeights.find(channelNumber) == p->sumOfWeights.end()) channelNumber = GetDefaultChannel(periodNumber);//p->defaultChannel;
   int bin = p->secondaryHists[channelNumber]->FindFixBin(x,y);
   double n = p->secondaryHists[channelNumber]->GetBinContent(bin);
   double l = p->secondaryHists[-1]->GetBinContent(bin);
 
   return l/n;
}

GetSumOfEventWeights()

virtual Double_t CP::PileupReweightingTool::GetSumOfEventWeights ( Int_t channel )

inlinevirtual

helpful alternative to using the EventBookkeepers info ... assuming you made your PRW Config file!!

Implements CP::IPileupReweightingTool.

Definition at line 64 of file PileupReweightingTool.h.

{ return m_activeTool->GetSumOfEventWeights(channel); }

GetUnrepresentedDataFraction()

Double_t TPileupReweighting::GetUnrepresentedDataFraction ( Int_t periodNumber, Int_t channel )

inherited

return the unrepresented data fraction in a given channel .

. when using action=2, you will want to scale up all MC events by 1/(1-unrepFraction) to account for missed data

Definition at line 1388 of file TPileupReweighting.cxx.

                                                                                            {
 
  //return unrepDataByChannel[channel]/GetSumOfEventWeights(-1); //the denominator is equivalent to asking for the total data!
 
 
   Period* p = m_periods[periodNumber];
   if(!p) {
      Error("GetUnrepresentedDataFraction","Unrecognised periodNumber: %d",periodNumber);
      throw std::runtime_error("Throwing 1: Unrecognised periodNumber");
   }
 
   //look for channel through sumOfWeights - because if the channel has no unrepData, it will have no entry in the unrepData map
   if(p->sumOfWeights.find(channel) == p->sumOfWeights.end()) channel = GetDefaultChannel(periodNumber);
 
 
   if(p->sumOfWeights.find(channel) == p->sumOfWeights.end()) {
      Error("GetUnrepresentedDataFraction","Unrecognised channel: %d",channel);
      throw std::runtime_error("GetUnrepresentedDataFraction: Unrecognised channel");
   }
 
   return p->unrepData[channel]/p->sumOfWeights[-1];
 
}

GetUnrepresentedDataWeight()

Float_t CP::TPileupReweighting::GetUnrepresentedDataWeight ( Int_t periodNumber, Int_t channel )

inlineinherited

Definition at line 134 of file TPileupReweighting.h.

                                                                                  { 
         if(m_unrepresentedDataAction!=2) {
            Warning("GetUnrepresentedDataWeight","You should not be applying this weight unless the UnrepresentedDataAction=2");
         }
         return 1./(1. - GetUnrepresentedDataFraction(periodNumber,channel));
      }

getUnrepresentedDataWeight()

float CP::PileupReweightingTool::getUnrepresentedDataWeight ( const xAOD::EventInfo & eventInfo )

virtual

When using UnrepresentedDataAction=2, you may want to apply this additional weight to ensure sum of weights are preserved.

Implements CP::IPileupReweightingTool.

Definition at line 417 of file PileupReweightingTool.cxx.

                                                                                        {
    return m_activeTool->GetUnrepresentedDataWeight( eventInfo.runNumber(), eventInfo.mcChannelNumber() );
}

IgnoreConfigFilePeriods()

void CP::TPileupReweighting::IgnoreConfigFilePeriods ( Bool_t in )

inlineinherited

Should the tool ignore period assignments encoded in config file.

Definition at line 146 of file TPileupReweighting.h.

{ m_ignoreFilePeriods=in; }

Initialize()

Int_t TPileupReweighting::Initialize ( )

inherited

Initialize this class once before the event loop starts If distribution information is provided, it is assumed to be for the standard pileup reweighting.

Definition at line 1021 of file TPileupReweighting.cxx.

                                       {
 
   //Need to calculate a period weight for each period
   //Need a reweighting histogram for each period
   //for merged mc run numbers, we must generate or modify the existing mc distributions
 
   //print out the period assignments if in debug mode
   if(m_debugging) {
      PrintPeriods();
   }
 
   if(m_countingMode) {
     if (m_printInfo) {
       Info("Initialize","In Config File Generating mode. Remember to call WriteToFile!");
     }
      //need to check no periods have subperiods, this is not allowed in counting mode
      for(auto period : m_periods) {
         if(period.second->subPeriods.size()!=0) {
            Error("Initialize","You cannot have subperiods when in Config File Generating mode");
            throw std::runtime_error("Throwing 44: In Config File Generating mode, but detected subperiods in the period definition. This is not allowed.");
         }
      }
      //histograms are instantiated in the event loop as the channels occur
      //can delay period definition here
      m_isInitialized=true;
      return 0;
   }
 
   //find all channels that have too much unrepresented data (more than tolerance). We will remove these channels entirely
 
   std::map<int,std::map<int,bool>> trackWarnings; //map used to avoid reprinting warnings as loop over histogram bins
 
   double totalData(0);
   //count up the unrepresented data, indexed by channel
   for(auto& run : m_runs) {
      if(run.second.inputHists.find("None") == run.second.inputHists.end()) continue;
      TH1* hist = run.second.inputHists["None"].get();
      Int_t bin,binx,biny;
      for(biny=1; biny<=hist->GetNbinsY(); biny++) {
         for(binx=1; binx<=hist->GetNbinsX(); binx++) {
            bin = hist->GetBin(binx,biny);
            Double_t value = hist->GetBinContent(bin);
            totalData += value;
            if(value==0.) continue;
            bool isUnrep(false);
            std::map<Int_t, bool> doneChannels;
            for(auto& period : m_periods) {
               if(period.first != period.second->id) continue; //skip remappings
               if(period.first == -1) continue; //don't look at the global period when calculating unrepresented data
               if(!period.second->contains(run.first)) continue;
               for(auto& inHist : m_periods[-1]->inputHists) { //use global period to iterate over channels
                  if(inHist.first<0) continue; //skips any data hists (shouldn't happen really)
                  if(doneChannels[inHist.first]) continue; //dont doublecount the data if the channel was to blame across multiple period
                  if(period.second->inputHists.find(inHist.first)==period.second->inputHists.end()) {
                    //all the data is missing ..
                    isUnrep=true;doneChannels[inHist.first]=true;
                    unrepDataByChannel[inHist.first] += value;
                    if(!trackWarnings[inHist.first][period.first]) {
                      trackWarnings[inHist.first][period.first]=true;
                      Warning("Initialize","Channel %d has no configuration for period %d -- this is symptomatic of you trying to reweight an MC campaign to data not intended for that campaign (e.g. MC16a with 2017 data)",inHist.first,period.first);
                    }
                  } else if(period.second->inputHists[inHist.first]->GetBinContent(bin)==0) {
                    //hist for this channel in this period exists, but this bin is empty
                    isUnrep=true;doneChannels[inHist.first]=true;
                    unrepDataByChannel[inHist.first] += value;
                  }
               }
            }
            if(isUnrep) unrepDataByChannel[-1] += value; //store total unrep data
         }
      }
   }
   if (totalData == 0.){ //should be impossible
     Error("Initialize", "totalData is still zero.");
   }
   if(m_ignoreBadChannels && unrepDataByChannel[-1] && totalData && (unrepDataByChannel[-1]/totalData)>m_unrepDataTolerance) {
      Warning("Initialize","There is %f%% unrepresented data and 'IgnoreBadChannels' property is set to true. Will start ignoring channels until this is below the tolerance (%f%%)", 100.*(unrepDataByChannel[-1]/totalData),100.*m_unrepDataTolerance);
      //remove channels one-by-one until we are under tolerance
      while( (unrepDataByChannel[-1]/totalData)>m_unrepDataTolerance ) {
         int worstChannel = -1;
         double worstFraction = 0;
         for(auto& channel : unrepDataByChannel) {
            if(channel.first<0) continue; //ignore the data
            if(channel.second/totalData > worstFraction) { worstChannel=channel.first; worstFraction = channel.second/totalData; }
         }
         if(worstChannel==-1) {
            Error("Initialize","Run out of channels to remove. All your channels are bad ... oh dear oh dear oh dear. Please a better PRW config file");
            throw std::runtime_error("Throwing exception 333: Run out of channels to remove. All your channels are bad ... oh dear oh dear oh dear. Please a better PRW config file");
         }
 
         Warning("Initialize","Ignoring channel %d, which has %f%% unrepresented data (%f%% of the total unrep data)",worstChannel,100.*unrepDataByChannel[worstChannel]/totalData,100.*unrepDataByChannel[worstChannel]/unrepDataByChannel[-1]);
         //remove the bad channel
         RemoveChannel(worstChannel);
         unrepDataByChannel.erase(unrepDataByChannel.find(worstChannel));
 
         //recalculate the total unrep data
         unrepDataByChannel[-1] = 0;
         for(auto& run : m_runs) {
            if(run.second.inputHists.find("None") == run.second.inputHists.end()) continue;
            TH1* hist = run.second.inputHists["None"].get();
            Int_t bin,binx,biny;
            for(biny=1; biny<=hist->GetNbinsY(); biny++) {
               for(binx=1; binx<=hist->GetNbinsX(); binx++) {
                  bin = hist->GetBin(binx,biny);
                  Double_t value = hist->GetBinContent(bin);
                  if(value==0.) continue;
                  for(auto& period : m_periods) {
                     if(period.first != period.second->id) continue; //skip remappings
                     if(!period.second->contains(run.first)) continue;
                     bool done(false);
                     for(auto& inHist : period.second->inputHists) {
                        if(inHist.first<0) continue; //skips any data hists (shouldn't happen really)
                        if((inHist.second)->GetBinContent(bin)==0) {
                           unrepDataByChannel[-1] += value; done=true; break;
                        }
                     }
                     if(done) break;
                  }
               }
            }
         }
      }
   }
 
 
   //need a CompositeTrigger to hold the unprescaled lumi hists ...
   m_triggerObjs["None"] = std::make_unique< CompositeTrigger >();
 
   //go through all periods, use inputHists to populate the primary and secondary dists, and fill sumOfWeights and numberOfEntries
   for(auto period : m_periods) {
      if(period.first != period.second->id) continue; //skips remappings
      for(auto& inputHist : period.second->inputHists) {
         int channel = inputHist.first;
         TH1* hist = inputHist.second.get();
         period.second->sumOfWeights[channel] += hist->GetSumOfWeights();
         period.second->numberOfEntries[channel] += hist->GetEntries();
         if(hist->GetDimension()==1) {
            period.second->primaryHists[channel] = CloneEmptyHistogram(period.first,channel);
            period.second->primaryHists[channel]->Add(hist);
         }
      }
      //also add all runs that belong to us ... only do the "None" trigger
      for(auto& run : m_runs) {
         if(!period.second->contains(run.first)) continue;
         if(run.second.inputHists.find("None") == run.second.inputHists.end()) continue;
         //add to list of runNumbers for this period
         period.second->runNumbers.push_back(run.first);
         TH1* hist = run.second.inputHists["None"].get();
 
         //sweep over bins, checking for unrepresented data and acting accordingly
         Int_t bin,binx,biny;
         for(biny=1; biny<=hist->GetNbinsY(); biny++) {
            for(binx=1; binx<=hist->GetNbinsX(); binx++) {
               bin = hist->GetBin(binx,biny);
               Double_t value = hist->GetBinContent(bin);
               if(value==0.) continue;
               //loop over channels, check for zero in this bin  ... only need to do if we haven't checked ourselves
               if(period.second->inputBinRedirect.find(bin) == period.second->inputBinRedirect.end()) {
                  for(auto& inputHist : period.second->inputHists) {
                     if(inputHist.first<0) continue; //skips data
                     Double_t mcValue = (inputHist.second)->GetBinContent(bin);
                     if(mcValue==0.) {
                       if(m_unrepresentedDataAction!=0 && m_debugging && m_printInfo) {
                           Info("Initialize","Unrepresented data at coords [%f,%f] caused by periodNumber %d in channel %d",hist->GetXaxis()->GetBinCenter(binx),hist->GetYaxis()->GetBinCenter(biny),period.first,inputHist.first);
                         }
                        //if we are doing unrepaction=2, just set to 'not the bin number'. if we are doing action=3, find the nearest good bin
                        if(m_unrepresentedDataAction==0) {period.second->inputBinRedirect[bin] = bin-1;Error("Initialize","Unrepresented data at coords [%f,%f] caused by periodNumber %d in channel %d",hist->GetXaxis()->GetBinCenter(binx),hist->GetYaxis()->GetBinCenter(biny),period.first,inputHist.first);}
                        if(m_unrepresentedDataAction==1||m_unrepresentedDataAction==2) period.second->inputBinRedirect[bin] = bin-1;
                        else if(m_unrepresentedDataAction==3) period.second->inputBinRedirect[bin] = GetNearestGoodBin(period.first, bin);
                        break;
                     }
                  }
                  if(period.second->inputBinRedirect.find(bin) == period.second->inputBinRedirect.end()) period.second->inputBinRedirect[bin] = bin; //a good bin
               }
               //if is a bad bin, act accordingly
               if(period.second->inputBinRedirect[bin] != bin) {
                  run.second.badBins[bin]=value;
                  if(m_unrepresentedDataAction==1) {
                     //remove this data. we have to remember to do this for the trigger data too if this is the pileup weight
                     hist->SetBinContent(bin,0);
                     //also modify the m_inputTriggerHistograms ...
                     for(auto& triggerDists : run.second.inputHists) triggerDists.second->SetBinContent(bin,0);
                  } else if(m_unrepresentedDataAction==3) {
                     //reassign the content to that bin
                     hist->SetBinContent(period.second->inputBinRedirect[bin],hist->GetBinContent(period.second->inputBinRedirect[bin])+hist->GetBinContent(bin));
                     hist->SetBinContent(bin,0);
                     //also modify the m_inputTriggerHistograms ...
                     for(auto& triggerDists : run.second.inputHists) {
                        triggerDists.second->SetBinContent(period.second->inputBinRedirect[bin],triggerDists.second->GetBinContent(period.second->inputBinRedirect[bin])+triggerDists.second->GetBinContent(bin));
                        triggerDists.second->SetBinContent(bin,0);
                     }
                   }
                }
            }
         }
 
         //ensure hist is normalized correctly, if was read in from the 'actual mu' config files (where the normalization can be slightly wrong)
         if(run.second.nominalFromHists) {
          //get the total lumi for the run ...
          double totLumi(0);
          for(auto lb : run.second.lumiByLbn) {
            totLumi += lb.second.first;
          }
          const double integral = hist->Integral();
          if (std::abs(integral) > 0.) {
            hist->Scale(totLumi / integral);
          }
 
         }
 
         //create the period's 'data' hist if necessary
         if( hist->GetDimension()==1 ) {
              if(!period.second->primaryHists[-1] )  {
                  period.second->primaryHists[-1] = CloneEmptyHistogram(period.first,-1);
 
                  //this will remain unnormalized, unlike the 'primaryHist'
                  m_triggerObjs["None"]->triggerHists[period.second->id][0] =
                     CloneEmptyHistogram( period. first, -1 );
               }
         }
         else if( hist->GetDimension()==2 ) {
            if(!period.second->secondaryHists[-1] ) {
               auto h = CloneEmptyHistogram(period.first,-1);
               period.second->secondaryHists[-1].reset( dynamic_cast< TH2* >( h.release() ) );
               period.second->primaryHists[-1].reset(
                  period.second->secondaryHists[-1]->ProjectionX() );
               period.second->primaryHists[-1]->SetDirectory(0);
               period.second->primaryHists[-1]->Reset();
               m_triggerObjs["None"]->triggerHists[period.second->id][0].reset(
                  static_cast<TH1*>(period.second->primaryHists[-1]->Clone("triggerHist")) );
               m_triggerObjs["None"]->triggerHists[period.second->id][0]->SetDirectory(0);
            }
 
         }
 
      }
 
   }
 
 
   //now that all periods and runs have been checked, with redirects set up where necessary, we actually accumulate the data across the runs
   //we should also check if there are any data runs that are not covered by the period assignments
 
   double ignoredData(0);
   for(auto& run : m_runs) {
      bool covered(false);
      TH1* hist = run.second.inputHists["None"].get();
      for(auto& period : m_periods) {
         if(!period.second->contains(run.first)) continue;
         if(period.first!=-1) covered=true; //don't count the global period
         if(hist->GetDimension()==1) {
            period.second->primaryHists[-1]->Add(hist);
            m_triggerObjs["None"]->triggerHists[period.second->id][0]->Add(hist);
         } else if(hist->GetDimension()==2) {
            period.second->secondaryHists[-1]->Add(hist);
            TH1* proj = static_cast<TH2*>(hist)->ProjectionX();
            period.second->primaryHists[-1]->Add(proj);
            m_triggerObjs["None"]->triggerHists[period.second->id][0]->Add(proj);
            delete proj;
         }
         period.second->sumOfWeights[-1] += hist->GetSumOfWeights();
         period.second->numberOfEntries[-1] += hist->GetEntries();
      }
      if(!covered && m_periods.size()>1) {
         Warning("Initialize","loaded data in run %d that is not covered by period assignments",run.first);
         ignoredData += hist->GetSumOfWeights();
      }
   }
   //double totalData =  (m_unrepresentedDataAction==1) ? (m_periods[-1]->sumOfWeights[-1]+unrepDataByChannel[-1]) : m_periods[-1]->sumOfWeights[-1];
   if (totalData == 0){
     Error("Initialize", "totalData is zero.");
     throw std::runtime_error("totalData is zero after summing. This should never happen.");
   }
   if(ignoredData>0.) Warning("Initialize", "Period Assignments missed %f%% data",100.*ignoredData/totalData);
   if(unrepDataByChannel[-1]) {
      double frac = unrepDataByChannel[-1]/totalData;
      if( frac  > m_unrepDataTolerance) {
        Error("Initialize", "%f%% unrepresented data, which suggests something is wrong with your prw config. Try EnableDebugging(true) to investigate",100.* (unrepDataByChannel[-1]/totalData));
      }
      if(m_unrepresentedDataAction==1) {
         Warning("Initialize","has %f%% unrepresented data. This was removed (UnrepresentedDataAction=1)",100.*frac);
      }  else if(m_unrepresentedDataAction==2) {
         Warning("Initialize","has %f%% unrepresented data. This was kept in (UnrepresentedDataAction=2)",100.*frac);
      } else if(m_unrepresentedDataAction==3) {
         Warning("Initialize","has %f%% unrepresented data. This was reassigned (UnrepresentedDataAction=3)",100.*frac);
      } else if(m_unrepresentedDataAction==0) {
         Error("Initialize","has %f%% unrepresented data:",100.*frac);
         //print the report of which channels caused it
         for(auto& it : unrepDataByChannel) {
            if(it.first<0) continue; //ignore data
            Error("Initialize","   Channel %d caused %f%% of the unrepresented data (nEntries=%d)",it.first,100.*it.second/unrepDataByChannel[-1],m_periods[-1]->numberOfEntries[it.first]);
         }
         Error("Initialize","Exiting. You must decide how to proceed...");
         Error("Initialize","1) use AddPeriod or RemapPeriod to redefine the mc periods to include this data. You should not need to regenerate your mc config file");
         Error("Initialize","2) use SetUnrepresentedDataAction(1) to remove this data from the weight calculations. You should also veto such data events (using IsUnrepresentedData(..,..) method)");
         Error("Initialize","3) use SetUnrepresentedDataAction(2) to leave this data in the calculation. I hope you know what you're doing!!");
         Error("Initialize","4) use SetUnrepresentedDataAction(3) to reassign the data to the nearest representable bin");
         throw std::runtime_error("Throwing exception 22: Unrepresented data exists. Make a choice how to handle this. See err log for details");
      }
      //if get here, through the exception if frac is bad
      if( frac  > m_unrepDataTolerance) {
         throw std::runtime_error("Throwing exception 222: Some channel had too much unrepresented data. You should fix your prw file");
      }
   }
 
 
   if(m_debugging && m_printInfo) Info("Initialize","Normalizing histograms and cleaning up...");
   //now that all the distributions are built. Normalize them all
   for(auto period : m_periods) {
      if(period.first != period.second->id) continue;
      for(auto& pHist : period.second->primaryHists) {
         normalizeHistogram(pHist.second.get());
      }
      for(auto& pHist : period.second->secondaryHists) {
         normalizeHistogram(pHist.second.get());
      }
      period.second->inputHists.clear();
   }
 
   //we keep the inputHists for data, because can use that to do random run numbers based on mu
 
   if(m_debugging && m_printInfo) Info("Initialize","...Done");
   //if no input histograms were added, we are in counting mode
 
 
   m_isInitialized=true;
 
  return 0;
}

initialize()

StatusCode CP::PileupReweightingTool::initialize ( void )

virtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 174 of file PileupReweightingTool.cxx.

                                             {
 
   //set debugging if debugging is on:
   EnableDebugging(this->msgLvl(MSG::DEBUG));
   PrintInfo(msgLvl(MSG::INFO));
 
   //convert custom periods vector to a vector of vectors (length 3) ...
   std::vector<std::vector<int>> customPeriods;
   for(auto& num : m_customPeriods) {
    if(customPeriods.size()==0 || customPeriods.back().size()==3) customPeriods.resize(customPeriods.size()+1);
    customPeriods.back().push_back(num);
   }
 
   for(auto& period : customPeriods) {
    if(period.size()!=3) {
      ATH_MSG_FATAL("Recevied period with " << period.size() << " numbers. Period configuration requires 3 numbers: periodNumber, startNumber, endNumber");
      return StatusCode::FAILURE;
    }
    AddPeriod(period[0],period[1],period[2]);
   }
 
   //see if we need variations 
   if(m_upVariation && (m_prwFiles.size()+m_toolLumicalcFiles.size())!=0) {
      m_upTool.reset( new TPileupReweighting((name()+"_upVariation").c_str()) );
      m_upTool->PrintInfo(msgLvl(MSG::INFO));
      m_upTool->SetParentTool(this);
      m_upTool->CopyProperties(this);
      m_upTool->SetDataScaleFactors(m_upVariation);
      for(auto& period : customPeriods) m_upTool->AddPeriod(period[0],period[1],period[2]); //already checked sizes above
   }
   if(m_downVariation && (m_prwFiles.size()+m_toolLumicalcFiles.size())!=0) {
      m_downTool.reset( new TPileupReweighting((name()+"_downVariation").c_str()) );
      m_downTool->PrintInfo(msgLvl(MSG::INFO));
      m_downTool->SetParentTool(this);
      m_downTool->CopyProperties(this);
      m_downTool->SetDataScaleFactors(m_downVariation);
      for(auto& period : customPeriods) m_downTool->AddPeriod(period[0],period[1],period[2]); //already checked sizes above
   }
 
   SetDefaultChannel(m_defaultChannel); //handled in GetDefaultChannel method now! if(m_upTool) m_upTool->SetDefaultChannel(m_defaultChannel); if(m_downTool) m_downTool->SetDefaultChannel(m_defaultChannel);
 
 
   //should we set the period config (file maker mode)
   if(m_prwFiles.size()+m_toolLumicalcFiles.size()==0) {
      m_inConfigMode=true;
      ATH_MSG_INFO("In Config file making mode."); 
      if(m_usePeriodConfig!="auto" && m_usePeriodConfig!="") {
         /*m_tool->*/UsePeriodConfig(m_usePeriodConfig);
      }
#ifndef XAOD_STANDALONE
      //retrieve histsvc now, otherwise it wont get correctly configured by the time it's used in the finalize ... so it seems
      ServiceHandle<ITHistSvc> histSvc("THistSvc",name());
      CHECK( histSvc.retrieve() );
#endif
   } else {
      //have we any prw to load
      if(m_prwFiles.size() && m_usePeriodConfig=="auto") {
        //will override the input config period assignments, will assume PRW is so standardized by r21 that we know best!
        IgnoreConfigFilePeriods(true);
        if(m_upTool) m_upTool->IgnoreConfigFilePeriods(true);
        if(m_downTool) m_downTool->IgnoreConfigFilePeriods(true);
        UsePeriodConfig("MC16"); //hardcoded period assignments
        if(m_upTool) m_upTool->UsePeriodConfig("MC16");
        if(m_downTool) m_downTool->UsePeriodConfig("MC16");
      }
      
      for(unsigned int j=0;j<m_prwFiles.size();j++) {
            ATH_MSG_VERBOSE("Locating File: " << m_prwFiles[j]);
            std::string file = PathResolverFindCalibFile(m_prwFiles[j]);
            if(file=="") { ATH_MSG_ERROR("Unable to find the PRW Config file: " << m_prwFiles[j]); return StatusCode::FAILURE; }
            ATH_MSG_VERBOSE("Adding Config file: " << file);
            /*m_tool->*/AddConfigFile(file.c_str());
            if(m_upTool) m_upTool->AddConfigFile(file.c_str());
            if(m_downTool) m_downTool->AddConfigFile(file.c_str());
      }
 
      //have we any lumicalc files to load? .. if we do and had no prwFiles then the user must specify the period configuration
      if(m_toolLumicalcFiles.size()>0 && m_prwFiles.size()==0) {
         if(m_usePeriodConfig!="auto" && m_usePeriodConfig!="") {
            ATH_MSG_INFO("Setting up without a PRW config file, but with period config " << m_usePeriodConfig << ". You will only be able to use random run number and data weight functionality... no reweighting!");
            if(UsePeriodConfig(m_usePeriodConfig)!=0) {
               ATH_MSG_ERROR("Unrecognised PeriodConfig: " << m_usePeriodConfig); return StatusCode::FAILURE;
            }
            m_noWeightsMode=true; //will stop the prw weight being decorated in apply method
            if(m_upTool) m_upTool->UsePeriodConfig(m_usePeriodConfig);
            if(m_downTool) m_downTool->UsePeriodConfig(m_usePeriodConfig);
         } else {
           ATH_MSG_WARNING("No config files provided, but " << m_toolLumicalcFiles.size() << " lumicalc file provided. Assuming a period config of MC16 ");
            UsePeriodConfig("MC16");
            m_noWeightsMode=true; //will stop the prw weight being decorated in apply method
            if(m_upTool) m_upTool->UsePeriodConfig("MC16");
            if(m_downTool) m_downTool->UsePeriodConfig("MC16");
         }
      }
   
      for(unsigned int j=0;j<m_toolLumicalcFiles.size();j++) {
            //see if there's a trigger at the end of the filename .. format is "file:trigger" 
            TString myFile = m_toolLumicalcFiles[j];
            TString myTrigger = (myFile.Contains(':')) ? TString(myFile(myFile.Last(':')+1,myFile.Length()-myFile.Last(':'))) : TString("None");
            myFile = (myFile.Contains(':')) ? TString(myFile(0,myFile.Last(':'))) : myFile;
            ATH_MSG_VERBOSE("Locating File: " << myFile);
            std::string file = PathResolverFindCalibFile(myFile.Data());
            if(file=="") { ATH_MSG_ERROR("Unable to find the Lumicalc file: " << myFile); return StatusCode::FAILURE; }
            /*m_tool->*/AddLumiCalcFile(file.c_str(),myTrigger);
            if(m_upTool) m_upTool->AddLumiCalcFile(file.c_str(),myTrigger);
            if(m_downTool) m_downTool->AddLumiCalcFile(file.c_str(),myTrigger);
      }
   }
 
   //register ourselves with the systematic registry! 
   CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
   if( registry.registerSystematics( *this ) != StatusCode::SUCCESS ) return StatusCode::FAILURE;
 
 
   //delay initializing underlying tool until first usage, just in case user wants to do any advanced initialization options
 
   ATH_MSG_DEBUG("Retrieving weight tool...");
   StatusCode sc = m_weightTool.retrieve();
   if (sc != StatusCode::SUCCESS) {
     ATH_MSG_ERROR("    " << m_weightTool->name() << " could not be retrieved.");
     return sc;
   }
   else {
     ATH_MSG_DEBUG("    " << m_weightTool->name() << " retrieved.");
     m_weightTool->print();
   }
 
   return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isAffectedBySystematic()

bool CP::PileupReweightingTool::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

virtual

The ISystematicsTool methods.

Implements CP::ISystematicsTool.

Definition at line 115 of file PileupReweightingTool.cxx.

                                                                                                  {
   CP::SystematicSet sys = affectingSystematics(); return sys.find( systematic ) != sys.end();
}

IsBadBin()

Int_t TPileupReweighting::IsBadBin ( Int_t thisMCRunNumber, Int_t bin )

protectedinherited

Definition at line 1353 of file TPileupReweighting.cxx.

                                                                  {
 
   if(bin<0) return 2; //out of range
 
   Period* p = m_periods[periodNumber];
   for(auto& inHist : p->inputHists) {
      int channelNumber = inHist.first;
      if(channelNumber<0) continue; //skip data hists
      if(bin > (inHist.second->GetNbinsX()+2)*(inHist.second->GetNbinsY()+2)*(inHist.second->GetNbinsZ()+2)) return 2; //definitely out of range by this point!
      if(inHist.second->GetBinContent(bin)==0) return 1;
   }
   return 0;
 
}

IsInitialized()

Bool_t CP::TPileupReweighting::IsInitialized ( )

inlineinherited

Definition at line 288 of file TPileupReweighting.h.

{ return m_isInitialized; }

IsUnrepresentedData()

Bool_t TPileupReweighting::IsUnrepresentedData ( Int_t runNumber, Float_t x, Float_t y = 0. )

inherited

Definition at line 1526 of file TPileupReweighting.cxx.

                                                                                      {
   int bin = m_emptyHistogram->FindFixBin(x,y);
   return ( m_runs[runNumber].badBins[bin] );
}

makeTrigger()

std::unique_ptr< CP::TPileupReweighting::CompositeTrigger > TPileupReweighting::makeTrigger ( const TString & s )

protectedinherited

Definition at line 2280 of file TPileupReweighting.cxx.

                                                  {
 
   if( m_debugging && m_printInfo ) {
      Info( "makeTrigger", "Doing %s", s.Data() );
   }
 
   // Find the first operand
   TString oper1;
   std::unique_ptr< CompositeTrigger > cOper1;
   if( s.BeginsWith( "(" ) ) {
      // Find closing bracket
      int bCounter=1; int i=1;
      while( ( bCounter != 0 ) && ( i <= s.Length() ) ) {
         if( s( i ) == '(' ) {
            bCounter++;
         } else if( s( i ) == ')' ) {
            bCounter--;
         }
         i++;
      }
      if( bCounter != 0 ) {
         Error( "makeTrigger", "Missing closing bracket" );
         return std::unique_ptr< CompositeTrigger >();
      }
      oper1 = s( 1, i - 2 );
      if( i == s.Length() + 1 ) {
         return makeTrigger( oper1 ); //meainingless brackets, just return evaluation
      } else {
         cOper1 = makeTrigger( oper1 );
         if( ! cOper1 ) {
            return 0;
         }
      }
   }
 
   // Find the second operand. Do this by finding the first operation at
   // this level. If cannot find, then just set val
   int i=0;int bCounter=0; int op=0;
   while( i <= s.Length() ) {
      if( s( i ) == '(' ) {
         bCounter++;
      } else if( s( i ) == ')' ) {
         bCounter--;
      } else if( ( s( i ) == '&' ) && ( bCounter == 0 ) ) {
         op = 2;
         break;
      } else if( ( s( i ) == '|' ) && ( bCounter == 0 ) ) {
         op = 1;
         break;
      }
      i++;
   }
 
 
   if( op == 0 ) {
      if( m_lumicalcFiles.find( s ) == m_lumicalcFiles.end() ) {
         Error( "GetDataWeight", "Could not find subTrigger %s", s.Data() );
         return std::unique_ptr< CompositeTrigger >();
      }
      if( cOper1 ) {
         return cOper1;
      }
      auto out = std::make_unique< CompositeTrigger >();
      out->op = op;
      out->val = s;
      return out; //just a value trigger
   }
 
   auto out = std::make_unique< CompositeTrigger >();
   out->op = op;
 
   if( op == 1 ) { //an OR
      if( cOper1 ) {
         out->trig1 = std::move( cOper1 );
      } else {
         oper1 = s( 0, i );
         out->trig1 = makeTrigger( oper1 );
         if( ! out->trig1 ) {
            return std::unique_ptr< CompositeTrigger >();
         }
      }
      TString oper2 = s( i + 1, s.Length() );
      out->trig2 = makeTrigger( oper2 );
      if( ! out->trig2 ) {
         return std::unique_ptr< CompositeTrigger >();
      }
      return out;
   }
 
   // Got here, must be an AND keep going until we hit an OR at this level,
   // then make all that the first operand (delete cOper if necessary)
   int j = i;
   bCounter = 0;
   while( j <= s.Length() ) {
      if( s( j ) == '(' ) {
         bCounter++;
      } else if( s( j )== ')' ) {
         bCounter--;
      } else if( ( s( j ) == '|' ) && ( bCounter == 0 ) ) {
         op=1;
         break;
      }
      j++;
   }
   if( ( j == s.Length() + 1 ) && ( op == 2 ) ) { //no more OR found, set oper2 to remainder
      if( cOper1 ) {
         out->trig1 = std::move( cOper1 );
      } else {
         oper1 = s( 0, i );
         out->trig1 = makeTrigger( oper1 );
      }
      TString oper2 = s( i + 1, s.Length() );
      if( m_debugging && m_printInfo ) {
         Info( "makeTrigger", "Found & %s %s", oper1.Data(), oper2.Data() );
      }
      out->trig2 = makeTrigger( oper2 );
      if( ! out->trig2 ) {
         return std::unique_ptr< CompositeTrigger >();
      }
      return out;
   } else if( op ==1 ) {   //found an OR, set oper1 to everything up to this
 
      oper1 = s( 0, j );
      TString oper2 = s( j + 1, s.Length() );
      if( m_debugging && m_printInfo ) {
         Info( "makeTrigger", "Found & then | %s %s", oper1.Data(),
               oper2.Data() );
      }
      out->op = op; //updates to an OR
      out->trig1 = makeTrigger( oper1 );
      if( ! out->trig1 ) {
         return std::unique_ptr< CompositeTrigger >();
      }
      out->trig2 = makeTrigger( oper2 );
      if( ! out->trig2 ) {
         return std::unique_ptr< CompositeTrigger >();
      }
      return out;
   }
   Error( "makeTrigger", "Should never have got here!, but did with %s",
          s.Data() );
   return std::unique_ptr< CompositeTrigger >();
}

MakeWeightTree()

Bool_t TPileupReweighting::MakeWeightTree ( TString channelNumbers, TString outFile, TString hashBranch = "PRWHash", TString weightBranch = "PileupWeight" )

inherited

Definition at line 1532 of file TPileupReweighting.cxx.

                                                                                                                             {
   if(!m_isInitialized ) {
     if (m_printInfo) Info("MakeWeightTree","Initializing the subtool..");
     Initialize();
   }
   TH1* hist = m_emptyHistogram.get();
   if(!hist) {
      Error("MakeWeightTree","Tool not configured properly ... please report this!");
      throw std::runtime_error("Throwing 47: Tool not configured properly ... please report this!");
   }
 
   //loop over given channels, and loop over all periods (except the global period) and get the pileup weight in each case for each bin
   TFile f1(outFile,"RECREATE");
 
   TTree* outTree = new TTree("prwTree","prwTree");
   ULong64_t prwHash(0);Float_t weight(0.);
   outTree->Branch(hashBranch,&prwHash);
   outTree->Branch(weightBranch,&weight);
 
   TObjArray *tx = channelNumbers.Tokenize(",");
   for (Int_t i = 0; i < tx->GetEntries(); i++) {
      int channelNumber = ((TObjString *)(tx->At(i)))->String().Atoi();
      if(channelNumber>999999 || channelNumber<0) {
         Error("MakeWeightTree","ChannelNumber can not be bigger than 999999 or less than 0 ... got %d",channelNumber);
         f1.Close();
         return 0;
      }
      for(auto& period : m_periods) {
         if(period.first==-1) continue;
         int periodNumber = period.first;
         for(int i=1;i<=hist->GetNbinsX();i++) {
            double x = hist->GetXaxis()->GetBinCenter(i);
            for(int j=1;j<=hist->GetNbinsY();j++) {
               double y = hist->GetYaxis()->GetBinCenter(j);
               weight = GetCombinedWeight(periodNumber,channelNumber,x,y);
               prwHash = GetPRWHash(periodNumber,channelNumber,x,y);
               outTree->Fill();
            }
         }
 
      }
   }
 
   outTree->BuildIndex(hashBranch.Data());
   outTree->Write();
   f1.Close();
 
   if (m_printInfo) {
     Info("MakeWeightTree","Successfully wrote prwTree to %s",outFile.Data());
   }
 
   return true;
}

Merge()

Int_t TPileupReweighting::Merge

(

TCollection *

coll

)

Definition at line 238 of file TPileupReweighting.cxx.

                                                   {
   if(!coll) return 0;
   if(coll->IsEmpty()) return 0;
 
   // Iterate over the elements of the collection:
   TIter next( coll );
   TObject* obj = 0;
   while( ( obj = next() ) ) {
 
      // Check that the element is of the right type:
      CP::TPileupReweighting* vobj = dynamic_cast< CP::TPileupReweighting* >( obj );
      if( ! vobj ) {
         Error( "Merge", "Unknown object type encountered: %s",obj->ClassName() );
         return 0;
      }
 
      //merge the inputHistograms ... all the periods should be identical
      for(auto period : vobj->m_periods) {
         if(period.first != period.second->id) continue;
         for(auto& iHist : period.second->inputHists) {
            if(GetInputHistogram(period.first,iHist.first)==0) {
               m_periods[period.first]->inputHists[iHist.first].reset(
                  dynamic_cast<TH1*>(iHist.second->Clone(iHist.second->GetName())) );
               m_periods[period.first]->inputHists[iHist.first]->SetDirectory(0);
            } else {
               GetInputHistogram(period.first,iHist.first)->Add(iHist.second.get());
            }
         }
      }
      //also must remember to merge the runs too (where the data is held)
      for(auto& run : vobj->m_runs) {
         for(auto& iHist : run.second.inputHists) {
            if( ! m_runs[run.first].inputHists[iHist.first] ) {
               m_runs[run.first].inputHists[iHist.first].reset(
                  dynamic_cast<TH1*>( iHist.second->Clone(iHist.second->GetName())) );
               m_runs[run.first].inputHists[iHist.first]->SetDirectory(0);
            } else {
               m_runs[run.first].inputHists[iHist.first]->Add(iHist.second.get());
            }
         }
      }
   }
 
   return 1;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

normalizeHistogram()

void TPileupReweighting::normalizeHistogram ( TH1 * histo )

protectedinherited

Normalize histograms.

Definition at line 1998 of file TPileupReweighting.cxx.

                                                      {
   // normalize the data histogram based on which sort of histogram it is
   if(hist){
      if(hist->InheritsFrom("TH3")) {
         Error("normalizeHistogram","3D reweighting not supported yet");
         throw std::runtime_error("Throwing 3: 3D reweighting not supported yet");
      }
      else if(hist->InheritsFrom("TH2")) {
         bool skipNorm=false;
         //normalize each bin according to the projection in x
         TH1D* proj = static_cast<TH2*>(hist)->ProjectionX();
         Int_t bin,binx,biny,binz;
         for(binz=1; binz<=hist->GetNbinsZ(); binz++) {
            for(biny=1; biny<=hist->GetNbinsY(); biny++) {
               for(binx=1; binx<=hist->GetNbinsX(); binx++) {
                  bin = hist->GetBin(binx,biny,binz);
                  Double_t value = hist->GetBinContent(bin);
                  Double_t normalizer = proj->GetBinContent(binx);
                  if(normalizer!=0.0) {
                     hist->SetBinContent(bin,value/normalizer);
                  } else {
                     skipNorm=true;
                  }
               }
            }
         }
         delete proj;
         if(skipNorm && m_debugging) Warning("normalizeHistogram","Skipped normalization in hist %s",hist->GetName());
      } else {
         //normalize to the sum of weights
         if(hist->GetSumOfWeights()!=0.0) {
            hist->Scale(1.0/hist->GetSumOfWeights());
         } else {
            if (m_debugging) Warning("normalizeHistogram","Skipping Normalizing histogram %s to ~zero: %f",hist->GetName(),hist->GetSumOfWeights());
         }
      }
   } else {
      Error("normalizeHistogram","Non existent histogram for normalizing");throw std::runtime_error("Throwing 56");
   }
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

passTriggerBeforePrescale()

bool CP::PileupReweightingTool::passTriggerBeforePrescale ( const TString & trigger ) const

protectedvirtual

Reimplemented from CP::TPileupReweighting.

Definition at line 106 of file PileupReweightingTool.cxx.

                                                                                  {
  if(m_tdt.empty()) return TPileupReweighting::passTriggerBeforePrescale(trigger); 
  ATH_MSG_VERBOSE("Checking tdt decision of " << trigger);
  //Note that the trigger *must* be a rerun trigger if this result is to be valid ... could check this in the trigconf is absolutely necessary
  //but for now we just assume it's a rerun
  //if it's not rerun, all we will get back here is the TAP result
  return m_tdt->isPassed( trigger.Data() , TrigDefs::Physics | TrigDefs::allowResurrectedDecision ); // Definitions in TrigDecisionInterface/Conditions.h
}

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

PrintInfo()

void CP::TPileupReweighting::PrintInfo ( Bool_t in )

inlineinherited

disable info

Definition at line 120 of file TPileupReweighting.h.

{ m_printInfo = in; }

PrintPeriods()

void CP::TPileupReweighting::PrintPeriods ( )

inlineinherited

Definition at line 413 of file TPileupReweighting.h.

{ for(auto p : m_periods) {std::cout << p.first << " -> "; p.second->print("");} }

recommendedSystematics()

CP::SystematicSet CP::PileupReweightingTool::recommendedSystematics ( ) const

virtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 126 of file PileupReweightingTool.cxx.

                                                                    {
   return affectingSystematics();
}

RemapPeriod()

void TPileupReweighting::RemapPeriod ( Int_t periodNumber1, Int_t periodNumber2 )

inherited

Combine two period numbers.

Histos are merged and the first number will be redirected to the second (the second is created if it doesn't exist)

Definition at line 63 of file TPileupReweighting.cxx.

                                                                               {
   //check if periodNumber2 exists
   if(m_periods.find(periodNumber2)==m_periods.end()) {
      m_periodList.emplace_back( periodNumber2, 0, 0, GetDefaultChannel(-1) );
      m_periods[periodNumber2] = &( m_periodList.back() );
   }
   m_periods[periodNumber1] = m_periods[periodNumber2];
}

RemoveChannel()

Bool_t TPileupReweighting::RemoveChannel ( int chanNum )

inherited

Removes a channel from the inputs ... this is for experts only.

Definition at line 1001 of file TPileupReweighting.cxx.

                                                      {
   if(m_isInitialized) {
      Error("RemoveChannel","You cannot RemoveChannel after initializing the tool. Reorder your code!");
      throw std::runtime_error("Throwing 5: You cannot RemoveChannel after initializing the tool. Reorder your code!");
   }
 
   bool found(false);
   for(auto& period : m_periods) {
      auto itr = period.second->inputHists.begin();
      while(itr != period.second->inputHists.end()) {
         if(itr->first!=chanNum) ++itr;
         else {
            found=true;
            itr = period.second->inputHists.erase(itr);
         }
      }
   }
   return found;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

ResetCountingMode()

void CP::TPileupReweighting::ResetCountingMode ( )

inlineinherited

This method is DEFINITELY EXPERT USE ONLY.

Used in the checkPRWConfigFile utitlity

Definition at line 293 of file TPileupReweighting.h.

{ m_countingMode=true; }

ResetTriggerBits()

void CP::TPileupReweighting::ResetTriggerBits ( )

inlineinherited

Definition at line 301 of file TPileupReweighting.h.

{ m_triggerPassBits.clear(); }

runLbnOK()

bool CP::PileupReweightingTool::runLbnOK ( Int_t runNbr, Int_t lbn )

protectedvirtual

Reimplemented from CP::TPileupReweighting.

Definition at line 101 of file PileupReweightingTool.cxx.

                                                            {
   if(m_grlTool.empty()) return true;
   return m_grlTool->passRunLB(runNbr,lbn);
}

SetBinning() [1/2]

virtual Int_t CP::PileupReweightingTool::SetBinning ( Int_t nbinsx, Double_t * xbins, Int_t nbinsy = 0, Double_t * ybins = 0 )

inlinevirtual

Implements CP::IPileupReweightingTool.

Definition at line 60 of file PileupReweightingTool.h.

{ return m_activeTool->SetBinning(nbinsx, xbins, nbinsy, ybins); }

SetBinning() [2/2]

virtual Int_t CP::PileupReweightingTool::SetBinning ( TH1 * hist )

inlinevirtual

Implements CP::IPileupReweightingTool.

Definition at line 62 of file PileupReweightingTool.h.

{ return m_activeTool->SetBinning(hist); }

SetDataScaleFactors()

void CP::TPileupReweighting::SetDataScaleFactors ( Float_t x, Float_t y = 1. )

inlineinherited

Scale the LumiMetaData mu values by this factor.

Definition at line 156 of file TPileupReweighting.h.

{ m_dataScaleFactorX=x;m_dataScaleFactorY=y; }

SetDefaultChannel()

void TPileupReweighting::SetDefaultChannel ( Int_t channel, Int_t mcRunNumber = -1 )

inherited

Set which channel should be used as a default when specific mc channel distributions cannot be found.

default channels can now be assigned for each mc run number .. mcRunNumber=-1 is the global default

Definition at line 72 of file TPileupReweighting.cxx.

                                                                              {
   //check if periodNumber2 exists
   if(m_periods.find(periodNumber)==m_periods.end()) {
      m_periodList.emplace_back( periodNumber, 0, 0, channel );
      m_periods[periodNumber] = &( m_periodList.back() );
   } else {
      m_periods[periodNumber]->SetDefaultChannel(channel);
   }
}

SetMCScaleFactors()

void CP::TPileupReweighting::SetMCScaleFactors ( Float_t x, Float_t y = 1. )

inlineinherited

Definition at line 157 of file TPileupReweighting.h.

{ m_mcScaleFactorX=x;m_mcScaleFactorY=y;}

SetParentTool()

void CP::TPileupReweighting::SetParentTool ( TPileupReweighting * tool )

inlineinherited

Definition at line 296 of file TPileupReweighting.h.

{ m_parentTool = tool; }

SetRandomSeed()

void CP::TPileupReweighting::SetRandomSeed ( int seed )

inlineinherited

Definition at line 222 of file TPileupReweighting.h.

{m_random3->SetSeed(seed);}

SetTriggerBit()

void CP::TPileupReweighting::SetTriggerBit ( const TString & trigger, bool in = true )

inlineinherited

Definition at line 300 of file TPileupReweighting.h.

{ m_triggerPassBits[trigger]=in; }

SetUniformBinning()

virtual Int_t CP::PileupReweightingTool::SetUniformBinning ( Int_t nbinsx, Double_t xlow, Double_t xup, Int_t nbinsy = 0, Double_t ylow = 0, Double_t yup = 0 )

inlinevirtual

Implements CP::IPileupReweightingTool.

Definition at line 61 of file PileupReweightingTool.h.

{ return m_activeTool->SetUniformBinning(nbinsx, xlow, xup, nbinsy, ylow, yup); }

SetUnrepresentedDataAction()

void CP::TPileupReweighting::SetUnrepresentedDataAction ( Int_t action, Double_t tolerance = 0.05 )

inlineinherited

Set how to handle configurations where some of your data has no corresponding mc to describe it 0=Default (Throw exception), 1=Subtract lumi from normalizations (i.e.

discard data), 2=keep lumi and continue

Definition at line 124 of file TPileupReweighting.h.

                                                                                    {
         if(action<0 || action>3) {
            Fatal("SetUnrepresentedDataAction","Set action=%d - I'm afraid I can't let you do that, Dave",action);
            throw std::runtime_error("Throwing 2001");
         } 
         m_unrepresentedDataAction=action;
         m_unrepDataTolerance=tolerance; //applicable for action=2 mode. Default is 5%
      }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateHandler()

void CP::PileupReweightingTool::updateHandler

(

Gaudi::Details::PropertyBase &

)

Definition at line 92 of file PileupReweightingTool.cxx.

                                                                     {
   // commenting this out as it doesn't compile anymore
   // leaving it to domain expert to decide whether to keep or remove it
   // //call the original update handler 
   // this->msg_update_handler(p);
   EnableDebugging(this->msgLvl(MSG::DEBUG));
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

UsePeriodConfig()

Int_t TPileupReweighting::UsePeriodConfig ( const TString & configName )

inherited

use a hardcoded period configuration

Definition at line 234 of file TPileupReweighting.cxx.

                                                                     {
   if(configName=="MC11a") {
      AddPeriod(180164, 177986,180481); //associates mc runnumber 180164 with data period 177986 to 180481 (period B-D)
      AddPeriod(183003, 180614,184169); //period E-H
      AddPeriod(185649, 185353,186934); //period I-K1. For I-K you would change the last number to 187815
      AddPeriod(185761, 186935,191933); //everything else. Thanks Ellie!
      SetUniformBinning(100,0,50);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC11a Period configuration");
      }
      return 0;
   } else if(configName=="MC11b" || configName=="MC11c") {
      AddPeriod(180164, 177986, 180481);
      AddPeriod(183003, 180614, 184169);
      AddPeriod(186169, 185353, 187815);
      AddPeriod(189751, 188902, 191933);
      SetUniformBinning(100,0,50);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC11b/c Period configuration");
      }
      return 0;
   } else if(configName=="MC12a") {
      AddPeriod(195847,200804,216432);
      //mc12a binning is in integer values of mu
 
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=50 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1)+0.5)>0.01|| fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(50)-49.5)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC12a, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC14, an incompatible config has already been set up");
         return -1;
      }
 
      SetUniformBinning(50,-0.5,49.5);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC12a Period configuration");
      }
      return 0;
   } else if(configName=="MC12b") {
      AddPeriod(195848,200804,216432);
      //mc12b binning is in integer values of mu
 
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=50 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1)+0.5)>0.01|| fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(50)-49.5)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC12b, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC14, an incompatible config has already been set up");
         return -1;
      }
 
      SetUniformBinning(50,-0.5,49.5);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC12b Period configuration");
      }
      return 0;
   } else if(configName=="MC12ab") {
      AddPeriod(195847,200804,216432);
      AddPeriod(195848,200804,216432);
 
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=50 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1)+0.5)>0.01|| fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(50)-49.5)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC12ab, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC14, an incompatible config has already been set up");
         return -1;
      }
 
      //mc12a/b binning is in integer values of mu
      SetUniformBinning(50,-0.5,49.5);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC12ab Period configuration");
      }
      return 0;
   } else if(configName=="MC14_8TeV") {
      AddPeriod(212272,200804,216432);
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=50 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1)+0.5)>0.01 || fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(50)-49.5)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC14_8TeV, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC14_8TeV, an incompatible config has already been set up");
         return -1;
      }
      SetUniformBinning(50,-0.5,49.5);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC14_8TeV Period configuration");
      }
      return 0;
   } else if(configName=="MC14_13TeV") {
      AddPeriod(222222,222222,999999);
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=100 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1)+0.5)>0.01|| fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(100)-99.5)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC14_13TeV, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC14_13TeV, an incompatible config has already been set up");
         return -1;
      }
      SetUniformBinning(100,-0.5,99.5);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC14_13TeV Period configuration");
      }
      return 0;
   } else if(configName=="MC15") {
      AddPeriod(222510,222222,999999);
      AddPeriod(222525,222222,999999);
      AddPeriod(222526,222222,999999);
      AddPeriod(284500,222222,999999);
      AddPeriod(295000,222222,999999); //mc15c for pPb data in 2016
      if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=100 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1))>0.01 || fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(100)-100.)>0.01) ) {
         Error("UsePeriodConfig","Cannot use MC15, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use MC15, an incompatible config has already been set up");
         return -1;
      }
      SetUniformBinning(100,0,100);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using MC15 Period configuration");
      }
      return 0;
   } else if(configName=="Run2") {
     m_autoRunStart = 222222; m_autoRunEnd = 999999; //periods will be automatically added during Fill
     if(m_emptyHistogram && (m_emptyHistogram->GetNbinsX()!=100 || fabs(m_emptyHistogram->GetXaxis()->GetBinLowEdge(1))>0.01 || fabs(m_emptyHistogram->GetXaxis()->GetBinUpEdge(100)-100.)>0.01) ) {
         Error("UsePeriodConfig","Cannot use open Run2, an incompatible config has already been set up");
         throw std::runtime_error("Throwing 13: Cannot use Run2 config, an incompatible config has already been set up");
         return -1;
      }
      SetUniformBinning(100,0,100);
      if (m_printInfo) {
        Info("UsePeriodConfig","Using Run2 Period configuration, which assumes period assignment of 222222 to 999999");
      }
      return 0;
   } else if(configName=="MC16") {
     /* period configs are now assigned through the parent tool for MC16 */
 
     SetUniformBinning(100,0,100);
     if (m_printInfo) {
       Info("UsePeriodConfig","Using MC16 Period configuration");
     }
     return 0;
   }
   Error("UsePeriodConfig","Unrecognized period config");
   return -1;
}

WriteToFile() [1/2]

Int_t TPileupReweighting::WriteToFile ( const TString & filename = "" )

inherited

Definition at line 1890 of file TPileupReweighting.cxx.

                                                            {
 
   if(!m_countingMode) {Warning("WriteToFile","Not in counting mode, so no file will be written");return 0;}
 
 
   //build a TTree with the correct mc structure, and dump the mc histogram info in to it
   //also build aggregate histograms across all channels - shouldn't be used as input histograms unless for a single channel
   TString filename = fname;
   filename += (filename=="") ? TString(this->GetName()) + ".prw.root" : "";
 
   //loop over the weights. "pileup" gets it own MCPileupReweighting ttree. ... since we got rid of weightNames in this version, everything goes in MCPileupReweighting now!
   //data goes in to DataCustomReweighting. other goes in to MCCustomReweighting
   TFile* outFile = TFile::Open(filename,"RECREATE");
   Int_t r = WriteToFile(outFile);
   outFile->Close();
   return r;
}

WriteToFile() [2/2]

Int_t TPileupReweighting::WriteToFile ( TFile * outFile )

inherited

Definition at line 1909 of file TPileupReweighting.cxx.

                                                      {
   if(!m_countingMode) {Warning("WriteToFile","Not in counting mode, so no file will be written");return 0;}
 
   TDirectory* origDir = gDirectory;
 
   outFile->cd();
 
   std::unique_ptr< TTree > outTreeMC;
   std::unique_ptr< TTree > outTreeData;
   Int_t channel = 0; UInt_t runNumber = 0;
   auto pStarts = std::make_unique< std::vector< UInt_t > >();
   auto pStartsPtr = pStarts.get();
   auto pEnds = std::make_unique< std::vector< UInt_t > >();
   auto pEndsPtr = pEnds.get();
   Char_t histName[150];
 
 
   //loop over periods ... periods only get entry in table if they have an input histogram
   for(auto period : m_periods) {
      if(period.first != period.second->id) continue; //skips redirects
      if(period.first<0) continue; //avoid the global run number
      runNumber = period.first;
      pStarts->clear();
      pEnds->clear();
      if(period.second->subPeriods.size()==0) {
         pStarts->push_back(period.second->start); pEnds->push_back(period.second->end);
      }
      else {
         for(auto subp : period.second->subPeriods) {
            pStarts->push_back(subp->start); pEnds->push_back(subp->end);
         }
      }
      for(auto& inHist : period.second->inputHists) {
         channel = inHist.first;
         TH1* hist = inHist.second.get();
         strncpy(histName,hist->GetName(),sizeof(histName)-1);
         hist->Write();
 
         if(!outTreeMC) {
            outTreeMC.reset( new TTree("MCPileupReweighting","MCPileupReweighting") );
            outTreeMC->Branch("Channel",&channel);
            outTreeMC->Branch("RunNumber",&runNumber);
            outTreeMC->Branch("PeriodStarts",&pStartsPtr);
            outTreeMC->Branch("PeriodEnds",&pEndsPtr);
            outTreeMC->Branch("HistName",&histName,"HistName/C");
         }
         outTreeMC->Fill();
      }
   }
 
   //loop over data
   for(auto& run : m_runs) {
      runNumber = run.first;
      if(run.second.inputHists.find("None")==run.second.inputHists.end()) continue;
 
      TH1* hist = run.second.inputHists["None"].get();
      strncpy(histName,hist->GetName(),sizeof(histName)-1);
      hist->Write();
      if(!outTreeData) {
         outTreeData.reset( new TTree("DataPileupReweighting","DataPileupReweighting") );
         outTreeData->Branch("RunNumber",&runNumber);
         outTreeData->Branch("HistName",&histName,"HistName/C");
      }
      outTreeData->Fill();
   }
 
 
   //write the non-zero ttrees
   if( outTreeMC ) {
      outTreeMC->Write();
   }
   if( outTreeData ) {
      outTreeData->Write();
   }
 
   if (m_printInfo) {
   Info("WriteToFile", "Successfully generated config file: %s",outFile->GetName());
   Info("WriteToFile", "Happy Reweighting :-)");
   }
 
   gDirectory = origDir;
 
   return 0;
}

Member Data Documentation

m_activeTool

CP::TPileupReweighting* CP::PileupReweightingTool::m_activeTool

private

Definition at line 149 of file PileupReweightingTool.h.

m_autoRunEnd

int CP::TPileupReweighting::m_autoRunEnd = 0

protectedinherited

Definition at line 475 of file TPileupReweighting.h.

m_autoRunStart

int CP::TPileupReweighting::m_autoRunStart = 0

protectedinherited

Definition at line 474 of file TPileupReweighting.h.

m_configStream

std::string CP::PileupReweightingTool::m_configStream

private

Definition at line 140 of file PileupReweightingTool.h.

m_countingMode

Bool_t CP::TPileupReweighting::m_countingMode

protectedinherited

Definition at line 335 of file TPileupReweighting.h.

m_customPeriods

std::vector<int> CP::PileupReweightingTool::m_customPeriods

private

Default weight tool in standalone mode.

Definition at line 165 of file PileupReweightingTool.h.

m_dataScaleFactorX

Float_t CP::TPileupReweighting::m_dataScaleFactorX

protectedinherited

Definition at line 338 of file TPileupReweighting.h.

m_dataScaleFactorY

Float_t CP::TPileupReweighting::m_dataScaleFactorY

protectedinherited

Definition at line 338 of file TPileupReweighting.h.

m_debugging

Bool_t CP::TPileupReweighting::m_debugging

protectedinherited

Definition at line 333 of file TPileupReweighting.h.

m_defaultChannel

int CP::PileupReweightingTool::m_defaultChannel

private

Definition at line 156 of file PileupReweightingTool.h.

m_defaultWeightTool

std::unique_ptr< IWeightTool > CP::PileupReweightingTool::m_defaultWeightTool

private

Definition at line 168 of file PileupReweightingTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doGlobalDataWeight

Bool_t CP::TPileupReweighting::m_doGlobalDataWeight

protectedinherited

Definition at line 344 of file TPileupReweighting.h.

m_doneConfigs

std::map<int, bool> CP::PileupReweightingTool::m_doneConfigs

private

Definition at line 158 of file PileupReweightingTool.h.

m_doPrescaleWeight

Bool_t CP::TPileupReweighting::m_doPrescaleWeight = false

protectedinherited

Definition at line 345 of file TPileupReweighting.h.

m_downTool

std::unique_ptr< CP::TPileupReweighting > CP::PileupReweightingTool::m_downTool

private

Definition at line 145 of file PileupReweightingTool.h.

m_downVariation

double CP::PileupReweightingTool::m_downVariation

private

Definition at line 147 of file PileupReweightingTool.h.

m_emptyHistogram

std::unique_ptr< TH1 > CP::TPileupReweighting::m_emptyHistogram

protectedinherited

the empty histogram used for this weight... effectively holds the configuration of the binning

Definition at line 358 of file TPileupReweighting.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_grlTool

ToolHandle<IGoodRunsListSelectionTool> CP::PileupReweightingTool::m_grlTool

private

Definition at line 171 of file PileupReweightingTool.h.

m_ignoreBadChannels

Bool_t CP::TPileupReweighting::m_ignoreBadChannels

protectedinherited

Definition at line 470 of file TPileupReweighting.h.

m_ignoreFilePeriods

Bool_t CP::TPileupReweighting::m_ignoreFilePeriods

protectedinherited

Definition at line 341 of file TPileupReweighting.h.

m_inConfigMode

bool CP::PileupReweightingTool::m_inConfigMode

private

Definition at line 141 of file PileupReweightingTool.h.

m_isInitialized

Bool_t CP::TPileupReweighting::m_isInitialized

protectedinherited

Definition at line 337 of file TPileupReweighting.h.

m_lumicalcFiles

std::map<TString,std::vector<TString> > CP::TPileupReweighting::m_lumicalcFiles

protectedinherited

map storing the lumicalc file locations - used when building DataPileupWeights

Definition at line 349 of file TPileupReweighting.h.

m_lumicalcRunNumberOffset

Int_t CP::TPileupReweighting::m_lumicalcRunNumberOffset

protectedinherited

Definition at line 346 of file TPileupReweighting.h.

m_lumiVectorIsLoaded

Bool_t CP::TPileupReweighting::m_lumiVectorIsLoaded

protectedinherited

Definition at line 337 of file TPileupReweighting.h.

m_mcScaleFactorX

Float_t CP::TPileupReweighting::m_mcScaleFactorX

protectedinherited

Definition at line 339 of file TPileupReweighting.h.

m_mcScaleFactorY

Float_t CP::TPileupReweighting::m_mcScaleFactorY

protectedinherited

Definition at line 339 of file TPileupReweighting.h.

m_metadata

std::map<TString, std::map<Int_t, Double_t> > CP::TPileupReweighting::m_metadata

protectedinherited

channel metadata map

Definition at line 363 of file TPileupReweighting.h.

m_metadatatree

TTree* CP::TPileupReweighting::m_metadatatree

protectedinherited

Definition at line 342 of file TPileupReweighting.h.

m_nextPeriodNumber

Int_t CP::TPileupReweighting::m_nextPeriodNumber

protectedinherited

Definition at line 340 of file TPileupReweighting.h.

m_noWeightsMode

bool CP::PileupReweightingTool::m_noWeightsMode

private

Definition at line 160 of file PileupReweightingTool.h.

m_parentTool

TPileupReweighting* CP::TPileupReweighting::m_parentTool

protectedinherited

Definition at line 331 of file TPileupReweighting.h.

m_periodList

std::list< Period > CP::TPileupReweighting::m_periodList

protectedinherited

List physically holding (owning) period objects.

Definition at line 456 of file TPileupReweighting.h.

m_periods

std::map<Int_t, Period*> CP::TPileupReweighting::m_periods

protectedinherited

Definition at line 457 of file TPileupReweighting.h.

m_prefix

std::string CP::PileupReweightingTool::m_prefix

private

Definition at line 154 of file PileupReweightingTool.h.

m_printInfo

Bool_t CP::TPileupReweighting::m_printInfo

protectedinherited

Definition at line 334 of file TPileupReweighting.h.

m_prwFiles

std::vector<std::string> CP::PileupReweightingTool::m_prwFiles

private

Definition at line 151 of file PileupReweightingTool.h.

m_prwFilesPathPrefix

std::string CP::TPileupReweighting::m_prwFilesPathPrefix

protectedinherited

Definition at line 462 of file TPileupReweighting.h.

m_random3

std::unique_ptr< TRandom3 > CP::TPileupReweighting::m_random3

protectedinherited

Definition at line 468 of file TPileupReweighting.h.

m_runs

std::map<UInt_t, Run> CP::TPileupReweighting::m_runs

protectedinherited

Definition at line 458 of file TPileupReweighting.h.

m_SetWarnings

Bool_t CP::TPileupReweighting::m_SetWarnings

protectedinherited

Definition at line 332 of file TPileupReweighting.h.

m_systDown

CP::SystematicVariation CP::PileupReweightingTool::m_systDown

private

Definition at line 148 of file PileupReweightingTool.h.

m_systUp

CP::SystematicVariation CP::PileupReweightingTool::m_systUp

private

Definition at line 148 of file PileupReweightingTool.h.

m_tdt

ToolHandle<Trig::ITrigDecisionTool> CP::PileupReweightingTool::m_tdt

private

Definition at line 172 of file PileupReweightingTool.h.

m_toolLumicalcFiles

std::vector<std::string> CP::PileupReweightingTool::m_toolLumicalcFiles

private

Definition at line 152 of file PileupReweightingTool.h.

m_triggerObjs

std::map<TString, std::unique_ptr<CompositeTrigger> > CP::TPileupReweighting::m_triggerObjs

protectedinherited

Definition at line 407 of file TPileupReweighting.h.

m_triggerPassBits

std::map<TString, bool> CP::TPileupReweighting::m_triggerPassBits

protectedinherited

Definition at line 315 of file TPileupReweighting.h.

m_unrepDataTolerance

Double_t CP::TPileupReweighting::m_unrepDataTolerance

protectedinherited

Definition at line 343 of file TPileupReweighting.h.

m_unrepresentedDataAction

Int_t CP::TPileupReweighting::m_unrepresentedDataAction

protectedinherited

Definition at line 336 of file TPileupReweighting.h.

m_upTool

std::unique_ptr< CP::TPileupReweighting > CP::PileupReweightingTool::m_upTool

private

Definition at line 144 of file PileupReweightingTool.h.

m_upVariation

double CP::PileupReweightingTool::m_upVariation

private

Definition at line 147 of file PileupReweightingTool.h.

m_useMultiPeriods

Bool_t CP::TPileupReweighting::m_useMultiPeriods = true

protectedinherited

Definition at line 471 of file TPileupReweighting.h.

m_usePeriodConfig

std::string CP::PileupReweightingTool::m_usePeriodConfig

private

Definition at line 157 of file PileupReweightingTool.h.

m_useRunDependentPrescaleWeight

bool CP::PileupReweightingTool::m_useRunDependentPrescaleWeight

private

Definition at line 163 of file PileupReweightingTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_varyRunNumber

bool CP::PileupReweightingTool::m_varyRunNumber

private

Definition at line 162 of file PileupReweightingTool.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_weightTool

ToolHandle<IWeightTool> CP::PileupReweightingTool::m_weightTool

private

Definition at line 170 of file PileupReweightingTool.h.

unrepDataByChannel

std::map<Int_t, Double_t> CP::TPileupReweighting::unrepDataByChannel

protectedinherited

Definition at line 460 of file TPileupReweighting.h.

---

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

• PileupReweightingTool.h
• PileupReweightingTool.cxx