#include <LumiCalculator.h>

Collaboration diagram for LumiCalculator:

Public Member Functions
	LumiCalculator ()
	~LumiCalculator ()
void	UseMC (bool mc=true)
void	UseLArNoiseDB (bool lar, const std::string &lardb)
void	UseBeamspot (bool bs, const std::string &bstag)
void	UseOnlineLumi (bool online)
void	Verbose (bool verbose=true)
void	UseLumiTag (const std::string &tag)
void	UseLumiMethod (const std::string &method)
void	UseLumiChannel (int chan)
void	UseLiveTrigger (bool live, std::string &livetrigger)
void IntegrateLumi	ATLAS_NOT_THREAD_SAFE (const xAOD::LumiBlockRangeContainer *iovc, const std::string &triggerchain)
void	SetCollName (const std::string &lbcollname)
void	setTree (TTree *tree=0)
TTree *	getTree ()
void	MakePlots (bool plots)
void	MakeCollList (bool collList)
void	ScaleL1TrigRate (const float &rate)
void	SetMinL1TrigRate (const float &mintrigrate)
void	printSummary (std::ostream &os)

Private Member Functions
void	DoHistogramAdmin (const uint32_t &runnbr, const TString &trigName, const float &effxsec)
void	SetHistogramStyle (TH1F hist, const char title=0, const char xaxis=0, const char yaxis=0)
void	RebinHistograms (const int &nbins, const double &start, const double &end)
void	MakePlots (const std::string &triggerchain)
void	LoadChannelIds ()
void	ParseL1Trigger (const std::string &lowerch, CoolQuery *cq_trigger)

Private Attributes
TTree *	m_LumiTree {}
bool	m_recordTTree {}
bool	m_State {}
std::string	m_lumi_database {}
std::string	m_trig_database {}
std::string	m_lar_database {}
std::string	m_bs_database {}
std::string	m_trigger {}
std::string	m_livetrigger {}
std::string	m_lumioff {}
std::string	m_lumionl {}
std::string	m_data_db {}
std::string	m_lumitag {}
std::string	m_lumimethod {}
std::string	m_laroff {}
std::string	m_lartag {}
std::string	m_bsonl {}
std::string	m_bstag {}
int	m_lumichannel {}
std::string	m_parofflumiestfolder {}
std::string	m_paronllumiestfolder {}
std::string	m_parlumiestfolder {}
std::string	m_parlvl1menufolder {}
std::string	m_parhltmenufolder {}
std::string	m_parhltprescalesfolder {}
std::string	m_parlumilvl1folder {}
std::string	m_parlumihltfolder {}
std::string	m_parlvl1prescalesfolder {}
std::string	m_parlvl1lblbfolder {}
std::string	m_parlareventvetofolder {}
std::string	m_paronlbeamspotfolder {}
Root::TMsgLogger	m_logger {}
std::string	m_lbcollname {}
bool	m_uselivetrigger {}
bool	m_verbose {}
double	m_lbstarttime {}
double	m_lbendtime {}
float	m_totalDelL {}
float	m_totalL {}
float	m_totalLRun {}
float	m_totaltime {}
float	m_instLumi {}
float	m_AvEvtsPerBX {}
cool::UInt32	m_Valid {}
float	m_delLumi {}
float	m_intLumi {}
float	m_deltaT {}
float	m_TotaldeltaT {}
float	m_livefrac {}
float	m_livetime {}
unsigned int	m_l1acc {}
unsigned int	m_livetime_l1acc {}
bool	m_l1accof {}
unsigned int	m_l2acc {}
unsigned int	m_l3acc {}
unsigned int	m_totall1acc {}
unsigned int	m_livtrig_totall1acc {}
unsigned int	m_totall1befpresc {}
unsigned int	m_totall2acc {}
unsigned int	m_totall3acc {}
float	m_l1prescale {}
float	m_l2prescale {}
float	m_l3prescale {}
ULong64_t	m_afterprescale {}
ULong64_t	m_livetime_beforeprescale {}
ULong64_t	m_livetime_afterprescale {}
bool	m_afterprescaleof {}
ULong64_t	m_beforeprescale {}
bool	m_beforeprescaleof {}
uint32_t	m_runnbr {}
uint32_t	m_lbstart {}
uint32_t	m_lbstop {}
uint32_t	m_lbstart_prev {}
uint32_t	m_lbstop_prev {}
uint32_t	m_runnbr_prev {}
unsigned int	m_totalgoodblock {}
unsigned int	m_totalbadblock {}
uint32_t	m_clumiblocknbr {}
uint32_t	m_clumiblocknbrend {}
unsigned int	m_triglevel {}
float	m_totalPrescaleWLiveTime {}
float	m_t_totalPrescaleWLiveTime {}
float	m_totalPrescale {}
float	m_t_totalPrescale {}
float	m_lumiWOPrescale {}
float	m_t_lumiWOPrescale {}
float	m_lumiLAr {}
float	m_t_lumiLAr {}
float	m_t_totalDelL {}
float	m_t_totalL {}
float	m_t_totalLRun {}
float	m_t_totaltime {}
float	m_t_deltaT {}
unsigned int	m_t_l1acc {}
unsigned int	m_t_l2acc {}
unsigned int	m_t_l3acc {}
unsigned int	m_t_totalgoodblock {}
unsigned int	m_t_totalbadblock {}
unsigned int	m_t_totall1befpresc {}
float	m_lartime {}
float	m_larfrac {}
float	m_bsvalid {}
std::string	m_triggerchain {}
std::vector< std::string >	m_triggerlowerchains {}
std::vector< std::string >	m_L1triggerchains {}
std::vector< cool::ChannelId >	m_L1idList {}
std::string	m_lbcollectionname {}
float	m_effxsec {}
float	m_l1rate {}
float	m_l2rate {}
float	m_l3rate {}
float	m_l1ratediveffxsec {}
float	m_total_l1ratediveffxsec {}
float	m_total_l1ratediveffxsecRun {}
float	m_l1ratediveffxsec_recorded {}
float	m_total_l1ratediveffxsec_recorded {}
float	m_total_l1ratediveffxsecRun_recorded {}
float	m_mintrigrate {}
Root::TGoodRunsList *	m_collsgrl {}
TH1F *	m_ntrigplb {}
TH1F *	m_trigrateplb {}
TH1F *	m_lumiplb {}
TH1F *	m_lumitrigrateplb {}
TH1F *	m_intlumi {}
TH1F *	m_intlumitrigrate {}
TH1F *	m_lumitrigrateplb_recorded {}
TH1F *	m_intlumitrigrate_recorded {}
TH1F *	m_intlumiruns {}
TH1F *	m_intlumitrigrateruns {}
TH1F *	m_intlumitrigrateruns_recorded {}
TH1F *	m_avgintperbx {}
std::vector< TH1F * >	m_ntrigplbVec
std::vector< TH1F * >	m_trigrateplbVec
std::vector< TH1F * >	m_lumiplbVec
std::vector< TH1F * >	m_lumitrigrateplbVec
std::vector< TH1F * >	m_intlumiVec
std::vector< TH1F * >	m_intlumitrigrateVec
std::vector< TH1F * >	m_lumitrigrateplb_recordedVec
std::vector< TH1F * >	m_intlumitrigrate_recordedVec
bool	m_makePlots {}
bool	m_makecollList {}
cool::ChannelId	m_Lumiid {}
cool::ChannelId	m_L3id {}
cool::ChannelId	m_L2id {}
cool::ChannelId	m_L1id {}
cool::ChannelId	m_LiveL1id {}
bool	m_L1Valid {}
bool	m_L2Valid {}
bool	m_L3Valid {}
bool	m_LiveValid {}
bool	m_onlinelumi {}
bool	m_uselar {}
bool	m_usebs {}
unsigned int	m_minrun {}
unsigned int	m_maxrun {}

Detailed Description

Definition at line 26 of file LumiCalculator.h.

Constructor & Destructor Documentation

◆ LumiCalculator()

LumiCalculator::LumiCalculator ( )

Definition at line 31 of file LumiCalculator.cxx.

 : m_LumiTree (nullptr)
 , m_recordTTree (false)
 , m_State (true)
 
 , m_trigger ("COOLONL_TRIGGER/")
 , m_lumioff ("COOLOFL_TRIGGER/")
 , m_lumionl ("COOLONL_TRIGGER/")
 , m_lumitag ("OflLumi-8TeV-002")// for offline:  OflLumi_CosmicFake, OflLumi_TopMix
 , m_lumimethod ("")// offline channels: ATLAS_PREFERRED, OflLumi_Fake0, OflLumi_Fake:, TopMixLumi 
 , m_laroff ("COOLOFL_LAR/")
 , m_bsonl ("COOLONL_INDET/")
 , m_bstag ("IndetBeamposOnl-HLT-UPD1-001-00")
 
 , m_parlvl1menufolder ("/TRIGGER/LVL1/Menu")
 , m_parhltmenufolder ("/TRIGGER/HLT/Menu")// ChainCounter is here for COOLONL_TRIGGER/COMP20
 , m_parhltprescalesfolder ("/TRIGGER/HLT/Prescales")// ChainCounter is here for COOLONL_TRIGGER/COMP20
 , m_parlumilvl1folder ("/TRIGGER/LUMI/LVL1COUNTERS")
 , m_parlumihltfolder ("/TRIGGER/LUMI/HLTCOUNTERS")
 , m_parlvl1prescalesfolder ("/TRIGGER/LVL1/Prescales")
 , m_parlvl1lblbfolder ("/TRIGGER/LUMI/LBLB")// for time information
 , m_parlareventvetofolder ("/LAR/BadChannelsOfl/EventVeto") // For LAr event veto
 , m_paronlbeamspotfolder ("/Indet/Onl/Beampos") // For invalid online beamspot
 
 , m_logger( "LumiCalculator" )
 , m_lbcollname ("LumiBlocks")
 , m_uselivetrigger (false)
 , m_verbose (false)
 , m_lbstarttime(0.)
 , m_lbendtime(0.)
 
 , m_totalDelL(0.)
 , m_totalL(0.)
 , m_totalLRun(0.)
 , m_totaltime(0.)
 , m_instLumi(0.)
 , m_AvEvtsPerBX(0.)
 , m_delLumi(0.)
 , m_intLumi(0.)
 , m_deltaT(0.)
 , m_TotaldeltaT(0.)
 , m_livefrac(0.)
 , m_livetime(0.)
 , m_l1acc(0)
 , m_livetime_l1acc(0)
 , m_l1accof(false)
 , m_l2acc(0)
 , m_l3acc(0)
 , m_totall1acc(0)
 , m_livtrig_totall1acc(0)
 , m_totall1befpresc(0)
 , m_totall2acc(0)
 , m_totall3acc(0)
 , m_l1prescale(0.)
 , m_l2prescale(0.)
 , m_l3prescale(0.)
 , m_afterprescale(0)
 , m_livetime_beforeprescale(0)
 , m_livetime_afterprescale(0)
 , m_afterprescaleof(false)
 , m_beforeprescale(0)
 , m_beforeprescaleof(false)
 , m_runnbr(0)
 , m_lbstart(0)
 , m_lbstop(0)
 , m_lbstart_prev(0)
 , m_lbstop_prev(0)
 , m_runnbr_prev(0)
 , m_totalgoodblock(0)
 , m_totalbadblock(0)
 , m_clumiblocknbr(0)
 , m_clumiblocknbrend(0)
 , m_triglevel(0)
 , m_totalPrescaleWLiveTime(0.)
 , m_t_totalPrescaleWLiveTime(0.)
 , m_totalPrescale(0.)
 , m_t_totalPrescale(0.)
 , m_lumiWOPrescale(0.)
 , m_t_lumiWOPrescale(0.)
 , m_lumiLAr(0.)
 , m_t_lumiLAr(0.)
 , m_t_totalDelL(0.)
 , m_t_totalL(0.)
 , m_t_totalLRun(0.)
 , m_t_totaltime(0.)
 , m_t_deltaT(0.)
 , m_t_l1acc(0)
 , m_t_l2acc(0)
 , m_t_l3acc(0)
 , m_t_totalgoodblock(0)
 , m_t_totalbadblock(0)
 , m_t_totall1befpresc(0)
 , m_lartime(0.)
 , m_larfrac(0.)
 , m_bsvalid(0.)
 , m_effxsec(1.)
 , m_l1rate(0.)
 , m_l2rate(0.)
 , m_l3rate(0.)
 , m_l1ratediveffxsec(0.)
 , m_total_l1ratediveffxsec(0.)
 , m_total_l1ratediveffxsecRun(0.)
 , m_l1ratediveffxsec_recorded(0.)
 , m_total_l1ratediveffxsec_recorded(0.)
 , m_total_l1ratediveffxsecRun_recorded(0.)
 , m_mintrigrate(5./120.)
 , m_collsgrl(0)
 , m_ntrigplb(0)
 , m_trigrateplb(0)
 , m_lumiplb(0)
 , m_lumitrigrateplb(0)
 , m_intlumi(0)
 , m_intlumitrigrate(0)
 , m_lumitrigrateplb_recorded(0)
 , m_intlumitrigrate_recorded(0)
 , m_intlumiruns(0)
 , m_intlumitrigrateruns(0)
 , m_intlumitrigrateruns_recorded(0)
 , m_avgintperbx(0)
 , m_makePlots(false)
 , m_makecollList(false)
 , m_Lumiid(0)
 , m_L3id(0)
 , m_L2id(0)
 , m_L1id(0)
 , m_LiveL1id(0)
 , m_L1Valid(false)
 , m_L2Valid(false)
 , m_L3Valid(false)
 , m_LiveValid(false)
 , m_onlinelumi(false)
 , m_uselar(false)
 , m_usebs(false)
 , m_minrun(0)
 , m_maxrun(0)
{
 
  // by default we use the "offline data" database name
  m_lumi_database = m_lumioff + m_data_db;
  m_trig_database = m_trigger + m_data_db;
  m_lar_database = m_laroff + m_data_db;
  m_bs_database = m_bsonl + m_data_db;
 
  m_lumichannel = 0;
 
}

◆ ~LumiCalculator()

LumiCalculator::~LumiCalculator ( )

Definition at line 179 of file LumiCalculator.cxx.

                               {
 
  // delete collisions grl
  if (m_collsgrl!=0) { delete m_collsgrl; m_collsgrl=0; }
 
  std::vector<TH1F*>::iterator itr;
  for (itr=m_ntrigplbVec.begin(); itr!=m_ntrigplbVec.end(); ++itr) { delete *itr; }
  for (itr=m_trigrateplbVec.begin(); itr!=m_trigrateplbVec.end(); ++itr) { delete *itr; }
  for (itr=m_lumiplbVec.begin(); itr!=m_lumiplbVec.end(); ++itr) { delete *itr; }
  for (itr=m_lumitrigrateplbVec.begin(); itr!=m_lumitrigrateplbVec.end(); ++itr) { delete *itr; }
  for (itr=m_intlumiVec.begin(); itr!=m_intlumiVec.end(); ++itr) { delete *itr; }
  for (itr=m_intlumitrigrateVec.begin(); itr!=m_intlumitrigrateVec.end(); ++itr) { delete *itr; }
  for (itr=m_lumitrigrateplb_recordedVec.begin(); itr!=m_lumitrigrateplb_recordedVec.end(); ++itr) { delete *itr; }
  for (itr=m_intlumitrigrate_recordedVec.begin(); itr!=m_intlumitrigrate_recordedVec.end(); ++itr) { delete *itr; }
 
  m_ntrigplbVec.clear();
  m_trigrateplbVec.clear();
  m_lumiplbVec.clear();
  m_lumitrigrateplbVec.clear();
  m_intlumiVec.clear();
  m_intlumitrigrateVec.clear();
  m_lumitrigrateplb_recordedVec.clear();
  m_intlumitrigrate_recordedVec.clear();
 
  if (m_intlumiruns!=0) { delete m_intlumiruns; m_intlumiruns=0; }
  if (m_intlumitrigrateruns!=0) { delete m_intlumitrigrateruns; m_intlumitrigrateruns=0; }
  if (m_intlumitrigrateruns_recorded!=0) { delete m_intlumitrigrateruns_recorded; m_intlumitrigrateruns_recorded=0; }
  if (m_avgintperbx != 0) { delete m_avgintperbx; m_avgintperbx = 0; }
 
}

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

void IntegrateLumi LumiCalculator::ATLAS_NOT_THREAD_SAFE	(	const xAOD::LumiBlockRangeContainer *	iovc,
		const std::string &	triggerchain )

◆ DoHistogramAdmin()

void LumiCalculator::DoHistogramAdmin	(	const uint32_t &	runnbr,
		const TString &	trigName,
		const float &	effxsec )

private

Definition at line 1425 of file LumiCalculator.cxx.

{
  // rebin the histograms once number of LBs is known
  int maxlb = 5000;
 
  m_ntrigplbVec.push_back(        new TH1F(Form("run%d_ntrigplb",runnbr),            Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_trigrateplbVec.push_back(     new TH1F(Form("run%d_trigrateplb",runnbr),         Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_lumiplbVec.push_back(         new TH1F(Form("run%d_peaklumiplb",runnbr),         Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_lumitrigrateplbVec.push_back( new TH1F(Form("run%d_peaklumitrigrateplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_intlumiVec.push_back(         new TH1F(Form("run%d_intlumi",runnbr),             Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_intlumitrigrateVec.push_back( new TH1F(Form("run%d_intlumitrigrate",runnbr),     Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_lumitrigrateplb_recordedVec.push_back( new TH1F(Form("run%d_peakrecordedlumitrigrateplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
  m_intlumitrigrate_recordedVec.push_back( new TH1F(Form("run%d_intrecordedlumitrigrate",runnbr),     Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
 
  m_ntrigplb        = *(m_ntrigplbVec.rbegin());
  m_trigrateplb     = *(m_trigrateplbVec.rbegin());
  m_lumiplb         = *(m_lumiplbVec.rbegin());
  m_lumitrigrateplb = *(m_lumitrigrateplbVec.rbegin());
  m_intlumi         = *(m_intlumiVec.rbegin());
  m_intlumitrigrate = *(m_intlumitrigrateVec.rbegin());
  m_lumitrigrateplb_recorded = *(m_lumitrigrateplb_recordedVec.rbegin());
  m_intlumitrigrate_recorded = *(m_intlumitrigrate_recordedVec.rbegin());
 
  this->SetHistogramStyle(m_ntrigplb,        Form("Run = %d",runnbr), "Luminosity block number", Form("# %s triggers / LB",trigName.Data()));
  this->SetHistogramStyle(m_trigrateplb,     Form("Run = %d",runnbr), "Luminosity block number", Form("%s trigger rate / LB",trigName.Data()));
  this->SetHistogramStyle(m_lumiplb,         Form("Run = %d",runnbr), "Luminosity block number", "Delivered luminosity (#mub^{-1}/s)");
  this->SetHistogramStyle(m_lumitrigrateplb, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s luminosity (#mub^{-1}/s)",trigName.Data()));
  this->SetHistogramStyle(m_intlumi,         Form("Run = %d",runnbr), "Luminosity block number", "Integrated delivered luminosity (#mub^{-1})");
  this->SetHistogramStyle(m_intlumitrigrate, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Integrated luminosity (#mub^{-1})",trigName.Data()));
  this->SetHistogramStyle(m_lumitrigrateplb_recorded, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Recorded luminosity (#mub^{-1}/s)",trigName.Data()));
  this->SetHistogramStyle(m_intlumitrigrate_recorded, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Integrated recorded luminosity (#mub^{-1})",trigName.Data()));
}

◆ getTree()

TTree * LumiCalculator::getTree ( )

Definition at line 308 of file LumiCalculator.cxx.

                               {
  if(m_LumiTree != 0)return m_LumiTree;
  return 0;
}

◆ LoadChannelIds()

void LumiCalculator::LoadChannelIds ( )

private

◆ MakeCollList()

void LumiCalculator::MakeCollList ( bool collList )

inline

Definition at line 48 of file LumiCalculator.h.

48{ m_makecollList = collList; }

◆ MakePlots() [1/2]

void LumiCalculator::MakePlots ( bool plots )

inline

Definition at line 47 of file LumiCalculator.h.

47{ m_makePlots = plots; }

covarianceTool.plots

plots

Definition covarianceTool.py:698

◆ MakePlots() [2/2]

void LumiCalculator::MakePlots ( const std::string & triggerchain )

private

Definition at line 1499 of file LumiCalculator.cxx.

{
  if(m_LumiTree != 0){
    // rebin and fill histograms:
    m_LumiTree->SetBranchAddress("LBStart", &m_clumiblocknbr);
    m_LumiTree->SetBranchAddress("L1AfterPrescale", &m_afterprescale);
    m_LumiTree->SetBranchAddress("L1Rate", &m_l1rate);
    m_LumiTree->SetBranchAddress("IntLumi",&m_intLumi);
    m_LumiTree->SetBranchAddress("L1Ratediveffxsec",&m_l1ratediveffxsec);
    m_LumiTree->SetBranchAddress("TotalLumi",&m_totalL);
    m_LumiTree->SetBranchAddress("Total_L1Ratediveffxsec",&m_total_l1ratediveffxsec);
    m_LumiTree->SetBranchAddress("TotalLumiRun",&m_totalLRun);
    m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRun",&m_total_l1ratediveffxsecRun);
    m_LumiTree->SetBranchAddress("RunNbr", &m_runnbr);
    m_LumiTree->SetBranchAddress("L1RatediveffxsecRecorded",&m_l1ratediveffxsec_recorded);
    m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRecorded",&m_total_l1ratediveffxsec_recorded);
    m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRunRecorded",&m_total_l1ratediveffxsecRun_recorded);
    m_LumiTree->SetBranchAddress("AvergeInteractionPerXing",&m_AvEvtsPerBX);
    
    // get first and last run number
    m_LumiTree->GetEntry(0); 
    int runnbrstart = m_runnbr;
    m_LumiTree->GetEntry(m_LumiTree->GetEntries()-1); 
    int runnbrend = m_runnbr;
    
    // makeup of integrated lumi histograms
    m_intlumiruns = new TH1F("intlumiruns","Luminosity",1,0.,1.);
    m_intlumitrigrateruns = new TH1F("intlumitrigrateruns","Delivered luminosity",1,0.,1.);
    m_intlumitrigrateruns_recorded = new TH1F("intlumitrigrateruns_recorded","Recorded luminosity",1,0.,1.);
    m_intlumiruns->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
    m_intlumitrigrateruns->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
    m_intlumitrigrateruns_recorded->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
 
    // Lumi-weighted average interactions per crossing
    m_avgintperbx = new TH1F("avgintperbx", "Avg Int/BX", 1000, 0., 100.);
    m_avgintperbx->SetTitle("Lumi-weighted Interactions per BX");
    this->SetHistogramStyle(m_avgintperbx, "Lumi-weighted Average Interactions per BX", "Average Interactions per BX", "Recorded Luminosity (mb-1)");
 
    // loop over the lumi tree    
    m_runnbr_prev = 0;
    int nlbs(0);
    float totalL(0.), total_l1ratediveffxsec(0.), total_l1ratediveffxsec_recorded(0.), totalLRun(0.), total_l1ratediveffxsecRun(0.), total_l1ratediveffxsecRun_recorded(0.);
    for(int i=0; i < m_LumiTree->GetEntries(); i++){
      m_LumiTree->GetEntry(i);
      
      // do histogram admin first
      if ( m_runnbr!=m_runnbr_prev ) {
    // first rebin prev histograms
    if (m_runnbr_prev>0) { 
      m_intlumi->SetTitle(Form("Delivered luminosity = %.1f /#mu b, Run = %d",totalLRun,m_runnbr_prev));
      m_intlumitrigrate->SetTitle(Form("Delivered luminosity = %.1f /#mu b, Efficiency * x-sec = %.1f #mu b, Run = %d",total_l1ratediveffxsecRun,m_effxsec,m_runnbr_prev));
      m_intlumitrigrate_recorded->SetTitle(Form("Recorded luminosity = %.1f /#mu b, Efficiency * x-sec = %.1f #mu b, Run = %d",total_l1ratediveffxsecRun_recorded,m_effxsec,m_runnbr_prev));
      this->RebinHistograms(nlbs+10,0,double(nlbs+10)); 
    }
    // create new histograms
    this->DoHistogramAdmin(m_runnbr,triggerchain,m_effxsec);
    // fill cullumative luminosity
    if (m_runnbr_prev>0) {
      for (uint32_t j=m_runnbr_prev; j<m_runnbr; ++j) {
        m_intlumiruns->Fill(j,totalL);
        m_intlumitrigrateruns->Fill(j,total_l1ratediveffxsec);
        m_intlumitrigrateruns_recorded->Fill(j,total_l1ratediveffxsec_recorded);
      }
    }
    m_runnbr_prev = m_runnbr ;
      }
      totalL = m_totalL;
      totalLRun = m_totalLRun;
      total_l1ratediveffxsec = m_total_l1ratediveffxsec;
      total_l1ratediveffxsecRun = m_total_l1ratediveffxsecRun;      
      total_l1ratediveffxsec_recorded = m_total_l1ratediveffxsec_recorded;
      total_l1ratediveffxsecRun_recorded = m_total_l1ratediveffxsecRun_recorded;
      nlbs = m_clumiblocknbr;
      
      m_ntrigplb->Fill(m_clumiblocknbr,(float)m_afterprescale);
      m_trigrateplb->Fill(m_clumiblocknbr,m_l1rate);
      m_lumiplb->Fill(m_clumiblocknbr,m_instLumi);
      m_lumitrigrateplb->Fill(m_clumiblocknbr,m_l1ratediveffxsec);
      m_intlumi->Fill(m_clumiblocknbr,m_totalLRun);
      m_intlumitrigrate->Fill(m_clumiblocknbr,m_total_l1ratediveffxsecRun);
      m_lumitrigrateplb_recorded->Fill(m_clumiblocknbr,m_l1ratediveffxsec_recorded);
      m_intlumitrigrate_recorded->Fill(m_clumiblocknbr,m_total_l1ratediveffxsecRun_recorded);
      m_avgintperbx->Fill(m_AvEvtsPerBX, m_intLumi);  // Lumi-weighted mu
 
    } // end tree loop
    m_intlumiruns->Fill(runnbrend,totalL);
    m_intlumitrigrateruns->Fill(runnbrend,total_l1ratediveffxsec);
    m_intlumitrigrateruns_recorded->Fill(runnbrend,total_l1ratediveffxsec_recorded);
    
    // finish histograms make-up
    m_intlumiruns->SetMinimum(0.);
    m_intlumitrigrateruns->SetMinimum(0.);
    this->RebinHistograms(nlbs+10,0,double(nlbs+10));
    this->SetHistogramStyle(m_intlumiruns, Form("Delivered luminosity = %.1f /ub",totalL), "Run number", "Luminosity (#mu b^{-1})");
    this->SetHistogramStyle(m_intlumitrigrateruns, Form("Delivered luminosity = %.1f /#mu b, Recorded luminosity = %.1f /#mu b", //, Efficiency * x-sec = %.1f mb",
                            total_l1ratediveffxsec,total_l1ratediveffxsec_recorded/*,m_effxsec*/), "Run number", Form("%s Luminosity (#mu b^{-1})",triggerchain.c_str()));
    this->SetHistogramStyle(m_intlumitrigrateruns_recorded, Form("Delivered luminosity = %.1f /#mub, Recorded luminosity = %.1f /#mub", //, Efficiency * x-sec = %.1f #mub",
                                 total_l1ratediveffxsec,total_l1ratediveffxsec_recorded/*,m_effxsec*/), "Run number", Form("%s Luminosity (#mu b^{-1})",triggerchain.c_str()));
    
    std::vector<TH1F*>::iterator itr;
    
  // and store the histograms
    TString histFileName = TString("ilumicalc_histograms_") + TString(triggerchain) + ( runnbrstart==runnbrend ? Form("_%d_",runnbrstart) : Form("_%d-%d_",runnbrstart,runnbrend)) + TString(m_lumitag) + TString(".root");
  TFile *ff = new TFile(histFileName.Data(),"recreate");
  m_avgintperbx->Write();
  if (m_effxsec==1.0) {
    m_intlumiruns->Write();
    for (itr=m_lumiplbVec.begin(); itr!=m_lumiplbVec.end(); ++itr)                 { (*itr)->Write(); }
    for (itr=m_intlumiVec.begin(); itr!=m_intlumiVec.end(); ++itr)                 { (*itr)->Write(); }
  }
  for (itr=m_ntrigplbVec.begin(); itr!=m_ntrigplbVec.end(); ++itr)                 { (*itr)->Write(); }
  for (itr=m_trigrateplbVec.begin(); itr!=m_trigrateplbVec.end(); ++itr)           { (*itr)->Write(); }
  if (m_effxsec!=1.0) { // results only make sense when proper xsec is provided externally
    m_intlumitrigrateruns->Write();
    m_intlumitrigrateruns_recorded->Write();
    for (itr=m_lumitrigrateplbVec.begin(); itr!=m_lumitrigrateplbVec.end(); ++itr) { (*itr)->Write(); }
    for (itr=m_intlumitrigrateVec.begin(); itr!=m_intlumitrigrateVec.end(); ++itr) { (*itr)->Write(); }
    for (itr=m_lumitrigrateplb_recordedVec.begin(); itr!=m_lumitrigrateplb_recordedVec.end(); ++itr) { (*itr)->Write(); }
    for (itr=m_intlumitrigrate_recordedVec.begin(); itr!=m_intlumitrigrate_recordedVec.end(); ++itr) { (*itr)->Write(); }
  }
  m_LumiTree->Write();
 
  // And write out the lumi tag information
  TObjString lumiTag(m_lumitag.c_str());
  lumiTag.Write("lumiTag");
 
  TObjString larTag(m_lartag.c_str());
  larTag.Write("larTag");
 
 
  ff->Close();
  delete ff;
  m_logger << Root::kINFO << "Histograms stored as          : " << histFileName << Root::GEndl;
 
  }else{
    m_logger << Root::kWARNING << "LumiTree pointer does not exist!          : " << Root::GEndl;
  }
 
 
}

◆ ParseL1Trigger()

void LumiCalculator::ParseL1Trigger	(	const std::string &	lowerch,
		CoolQuery *	cq_trigger )

private

Definition at line 1360 of file LumiCalculator.cxx.

                                                                               {
 
  //
  // Check if we have multiple entries
  size_t last = 0; 
  size_t next = 0; 
  cool::ChannelId id;
  bool valid;
  
  m_L1id = 0;
  m_L1Valid = false;
  
  if (lowerch.find(',', last) == std::string::npos) {
    // Normal case
    m_L1id = cq_trigger->getL1ChannelId(lowerch, m_parlvl1menufolder); 
    m_L1Valid = cq_trigger->channelIdValid();
    
  } else {
    m_logger << Root::kINFO << "L1 item is composite: " << lowerch << Root::GEndl;
    do {
      next = lowerch.find(',', last);
      // Check if these are valid before using them
      id = cq_trigger->getL1ChannelId(lowerch.substr(last, next-last),  m_parlvl1menufolder);
      valid = cq_trigger->channelIdValid();
      if (valid) {
    m_L1triggerchains.push_back(lowerch.substr(last, next-last));
    m_L1idList.push_back(m_L1id);
    m_L1id = id;
    m_L1Valid = true;
      } else {
    m_logger << Root::kINFO << lowerch.substr(last, next-last) << " Invalid" << Root::GEndl;     
      }
      
      last = next + 1; 
    } while (next != std::string::npos);
    
    
  }
}

◆ printSummary()

void LumiCalculator::printSummary ( std::ostream & os )

Definition at line 1403 of file LumiCalculator.cxx.

                                           {
 
  os << std::left << "-----------------------------------" << std::endl;
  os << std::left << "  LumiCalculator summary" << std::endl;
  os << std::left << "-----------------------------------" << std::endl;
  os << std::setw(10) << std::left << "Trigger: " << std::setw(10) << std::left << m_triggerchain << std::endl;
  os << std::setw(10) << std::left << "First Run: " << std::setw(10) << std::left << m_minrun << std::endl;
  os << std::setw(10) << std::left << "Last Run: " << std::setw(10) << std::left << m_maxrun << std::endl;
  os << std::setw(10) << std::left << "Total L1BeforePresc: " << std::setw(10) << std::left << m_totall1befpresc << std::endl;
  os << std::setw(10) << std::left  << "Total Livetime     : " << m_totaltime << std::endl;
  os << std::setw(10) << std::left << "Total prescale weighted Livetime: " <<  m_totalPrescaleWLiveTime << std::endl;
  os << std::setw(10) << std::left  << "Total Good LBs     : " << m_totalgoodblock - m_totalbadblock << std::endl;
  os << std::setw(10) << std::left  << "Total Bad LBs     : " << m_totalbadblock << std::endl;
  os << std::setw(10) << std::left << "Total IntL delivered (ub^-1) : " << m_totalDelL << std::endl;
  os << std::setw(10) << std::left << "Total IntL after livefraction (ub^-1):  " <<  m_lumiWOPrescale << std::endl;
  if (m_uselar)
    os << std::setw(10) << std::left << "Total IntL after LAr fraction (ub^-1):  " <<  m_lumiLAr << std::endl;
  os << std::setw(10) << std::left << "Total IntL recorded (ub^-1) : " << m_totalL << std::endl;
 
}

◆ RebinHistograms()

void LumiCalculator::RebinHistograms	(	const int &	nbins,
		const double &	start,
		const double &	end )

private

Definition at line 1460 of file LumiCalculator.cxx.

{
  m_ntrigplb->SetBins(nbins,start,end);        
  m_trigrateplb->SetBins(nbins,start,end);     
  m_lumiplb->SetBins(nbins,start,end);         
  m_lumitrigrateplb->SetBins(nbins,start,end); 
  m_intlumi->SetBins(nbins,start,end);         
  m_intlumitrigrate->SetBins(nbins,start,end); 
  m_lumitrigrateplb_recorded->SetBins(nbins,start,end);
  m_intlumitrigrate_recorded->SetBins(nbins,start,end);
}

◆ ScaleL1TrigRate()

void LumiCalculator::ScaleL1TrigRate ( const float & rate )

inline

Definition at line 49 of file LumiCalculator.h.

49{ m_effxsec=1./rate; }

◆ SetCollName()

void LumiCalculator::SetCollName ( const std::string & lbcollname )

Definition at line 256 of file LumiCalculator.cxx.

                                                           {
  m_lbcollname = lbcollname;
}

◆ SetHistogramStyle()

void LumiCalculator::SetHistogramStyle	(	TH1F *	hist,
		const char *	title = 0,
		const char *	xaxis = 0,
		const char *	yaxis = 0 )

private

Definition at line 1474 of file LumiCalculator.cxx.

{
  hist->SetFillColor(33); // light grey, blueish
  if (title!=0) hist->SetTitle(title);
  if (xaxis!=0) hist->GetXaxis()->SetTitle(xaxis);
  if (yaxis!=0) hist->GetYaxis()->SetTitle(yaxis);
 
  hist->GetXaxis()->SetLabelFont(52);
  hist->GetXaxis()->SetLabelSize(0.04);
  hist->GetXaxis()->SetTitleSize(0.05);
  hist->GetXaxis()->SetTitleOffset(1.28);
  hist->GetXaxis()->SetTitleFont(42);
 
  hist->GetYaxis()->SetLabelFont(52);
  hist->GetYaxis()->SetLabelSize(0.04);
  hist->GetYaxis()->SetTitleSize(0.05);
  hist->GetYaxis()->SetTitleOffset(1.25);
  hist->GetYaxis()->SetTitleFont(42);
 
  hist->SetStats(false);
 
  hist->SetLineWidth(2);
}

◆ SetMinL1TrigRate()

void LumiCalculator::SetMinL1TrigRate ( const float & mintrigrate )

inline

Definition at line 50 of file LumiCalculator.h.

50{ m_mintrigrate=mintrigrate; }

◆ setTree()

void LumiCalculator::setTree ( TTree * tree = 0 )

Definition at line 210 of file LumiCalculator.cxx.

                                        {
  // Register branches
  m_LumiTree = tree;
  if(m_LumiTree != 0){
 
    m_LumiTree->Branch("LBStartTime/D", &m_lbstarttime);
    m_LumiTree->Branch("LBEndTime/D", &m_lbendtime);
    m_LumiTree->Branch("Trigger", &m_triggerchain);
    m_LumiTree->Branch("LBCollection", &m_lbcollname);
    m_LumiTree->Branch("RunNbr", &m_runnbr);
    m_LumiTree->Branch("IOVRStart", &m_lbstart);
    m_LumiTree->Branch("IOVREnd", &m_lbstop);
    m_LumiTree->Branch("LBStart", &m_clumiblocknbr);
    m_LumiTree->Branch("Inst_m_Lumi", &m_instLumi);
    m_LumiTree->Branch("LiveTime", &m_livetime);
    m_LumiTree->Branch("L1Presc", &m_l1prescale);
    m_LumiTree->Branch("L2Presc", &m_l2prescale);
    m_LumiTree->Branch("L3Presc", &m_l3prescale);
    m_LumiTree->Branch("L1Count", &m_l1acc);
    m_LumiTree->Branch("L1CountOverFlow", &m_l1accof);
    m_LumiTree->Branch("L2Count", &m_l2acc);
    m_LumiTree->Branch("L3Count", &m_l3acc);
    m_LumiTree->Branch("L1AfterPrescale", &m_afterprescale);
    m_LumiTree->Branch("L1AfterPrescaleOverFlow", &m_afterprescaleof);
    m_LumiTree->Branch("L1BeforePrescale", &m_beforeprescale);
    m_LumiTree->Branch("L1BeforePrescaleOverFlow", &m_beforeprescaleof);
    m_LumiTree->Branch("Livefrac", &m_livefrac);
    m_LumiTree->Branch("LArfrac", &m_larfrac);
    m_LumiTree->Branch("DeltaT", &m_deltaT);
    m_LumiTree->Branch("L1Rate", &m_l1rate);
    m_LumiTree->Branch("IntLumi",&m_intLumi);
    m_LumiTree->Branch("L1Ratediveffxsec",&m_l1ratediveffxsec);
    m_LumiTree->Branch("TotalLumi",&m_totalL);
    m_LumiTree->Branch("Total_L1Ratediveffxsec",&m_total_l1ratediveffxsec);
    m_LumiTree->Branch("TotalLumiRun",&m_totalLRun);
    m_LumiTree->Branch("Total_L1RatediveffxsecRun",&m_total_l1ratediveffxsecRun);
    m_LumiTree->Branch("L1RatediveffxsecRecorded",&m_l1ratediveffxsec_recorded);
    m_LumiTree->Branch("Total_L1RatediveffxsecRecorded",&m_total_l1ratediveffxsec_recorded);
    m_LumiTree->Branch("Total_L1RatediveffxsecRunRecorded",&m_total_l1ratediveffxsecRun_recorded);
    m_LumiTree->Branch("AvergeInteractionPerXing",&m_AvEvtsPerBX);
    m_LumiTree->Branch("BSValid", &m_bsvalid);
  }
 
}

◆ UseBeamspot()

void LumiCalculator::UseBeamspot	(	bool	bs,
		const std::string &	bstag )

Definition at line 303 of file LumiCalculator.cxx.

                                                                {
  m_usebs = bs;
  m_bstag = bstag;
}

◆ UseLArNoiseDB()

void LumiCalculator::UseLArNoiseDB	(	bool	lar,
		const std::string &	lardb )

Definition at line 298 of file LumiCalculator.cxx.

                                                                    {
  m_uselar = lar;
  m_lartag = lartag;
}

◆ UseLiveTrigger()

void LumiCalculator::UseLiveTrigger	(	bool	live,
		std::string &	livetrigger )

Definition at line 293 of file LumiCalculator.cxx.

                                                                    {
  m_uselivetrigger = live;
  m_livetrigger = livetrigger;
}

◆ UseLumiChannel()

void LumiCalculator::UseLumiChannel ( int chan )

Definition at line 287 of file LumiCalculator.cxx.

                                           {
  m_lumichannel = chan;
  m_lumimethod = "";
}

◆ UseLumiMethod()

void LumiCalculator::UseLumiMethod ( const std::string & method )

Definition at line 283 of file LumiCalculator.cxx.

                                                         {
  m_lumimethod = method;
}

◆ UseLumiTag()

void LumiCalculator::UseLumiTag ( const std::string & tag )

Definition at line 279 of file LumiCalculator.cxx.

                                                   {
  m_lumitag = tag;
}

◆ UseMC()

void LumiCalculator::UseMC ( bool mc = true )

Definition at line 265 of file LumiCalculator.cxx.

                                 {
 
  // Print warning
  if (mc) 
    m_logger << Root::kWARNING << "Monte Carlo mode no longer supported!" << Root::GEndl;
 
}

◆ UseOnlineLumi()

void LumiCalculator::UseOnlineLumi ( bool online )

Definition at line 273 of file LumiCalculator.cxx.

                                             {
 
  m_onlinelumi = online;
 
}

◆ Verbose()

void LumiCalculator::Verbose ( bool verbose = true )

Definition at line 261 of file LumiCalculator.cxx.

                                        {
  m_verbose = verbose;
}

Member Data Documentation

◆ m_afterprescale

ULong64_t LumiCalculator::m_afterprescale {}

private

Definition at line 145 of file LumiCalculator.h.

145{};

◆ m_afterprescaleof

bool LumiCalculator::m_afterprescaleof {}

private

Definition at line 148 of file LumiCalculator.h.

148{};

◆ m_AvEvtsPerBX

float LumiCalculator::m_AvEvtsPerBX {}

private

Definition at line 124 of file LumiCalculator.h.

124{};

◆ m_avgintperbx

TH1F* LumiCalculator::m_avgintperbx {}

private

Definition at line 218 of file LumiCalculator.h.

218{};

◆ m_beforeprescale

ULong64_t LumiCalculator::m_beforeprescale {}

private

Definition at line 149 of file LumiCalculator.h.

149{};

◆ m_beforeprescaleof

bool LumiCalculator::m_beforeprescaleof {}

private

Definition at line 150 of file LumiCalculator.h.

150{};

◆ m_bs_database

std::string LumiCalculator::m_bs_database {}

private

Definition at line 79 of file LumiCalculator.h.

79{};

◆ m_bsonl

std::string LumiCalculator::m_bsonl {}

private

Definition at line 90 of file LumiCalculator.h.

90{};

◆ m_bstag

std::string LumiCalculator::m_bstag {}

private

Definition at line 91 of file LumiCalculator.h.

91{};

◆ m_bsvalid

float LumiCalculator::m_bsvalid {}

private

Definition at line 183 of file LumiCalculator.h.

183{};

◆ m_clumiblocknbr

uint32_t LumiCalculator::m_clumiblocknbr {}

private

Definition at line 159 of file LumiCalculator.h.

159{};

◆ m_clumiblocknbrend

uint32_t LumiCalculator::m_clumiblocknbrend {}

private

Definition at line 160 of file LumiCalculator.h.

160{};

◆ m_collsgrl

Root::TGoodRunsList* LumiCalculator::m_collsgrl {}

private

Definition at line 203 of file LumiCalculator.h.

203{};

◆ m_data_db

std::string LumiCalculator::m_data_db {}

private

Definition at line 85 of file LumiCalculator.h.

85{};

◆ m_delLumi

float LumiCalculator::m_delLumi {}

private

Definition at line 126 of file LumiCalculator.h.

126{};

◆ m_deltaT

float LumiCalculator::m_deltaT {}

private

Definition at line 128 of file LumiCalculator.h.

128{};

◆ m_effxsec

float LumiCalculator::m_effxsec {}

private

Definition at line 191 of file LumiCalculator.h.

191{};

◆ m_instLumi

float LumiCalculator::m_instLumi {}

private

Definition at line 123 of file LumiCalculator.h.

123{};

◆ m_intLumi

float LumiCalculator::m_intLumi {}

private

Definition at line 127 of file LumiCalculator.h.

127{};

◆ m_intlumi

TH1F* LumiCalculator::m_intlumi {}

private

Definition at line 209 of file LumiCalculator.h.

209{};

◆ m_intlumiruns

TH1F* LumiCalculator::m_intlumiruns {}

private

Definition at line 214 of file LumiCalculator.h.

214{};

◆ m_intlumitrigrate

TH1F* LumiCalculator::m_intlumitrigrate {}

private

Definition at line 210 of file LumiCalculator.h.

210{};

◆ m_intlumitrigrate_recorded

TH1F* LumiCalculator::m_intlumitrigrate_recorded {}

private

Definition at line 212 of file LumiCalculator.h.

212{};

◆ m_intlumitrigrate_recordedVec

std::vector<TH1F*> LumiCalculator::m_intlumitrigrate_recordedVec

private

Definition at line 227 of file LumiCalculator.h.

◆ m_intlumitrigrateruns

TH1F* LumiCalculator::m_intlumitrigrateruns {}

private

Definition at line 215 of file LumiCalculator.h.

215{};

◆ m_intlumitrigrateruns_recorded

TH1F* LumiCalculator::m_intlumitrigrateruns_recorded {}

private

Definition at line 216 of file LumiCalculator.h.

216{};

◆ m_intlumitrigrateVec

std::vector<TH1F*> LumiCalculator::m_intlumitrigrateVec

private

Definition at line 225 of file LumiCalculator.h.

◆ m_intlumiVec

std::vector<TH1F*> LumiCalculator::m_intlumiVec

private

Definition at line 224 of file LumiCalculator.h.

◆ m_l1acc

unsigned int LumiCalculator::m_l1acc {}

private

Definition at line 132 of file LumiCalculator.h.

132{};

◆ m_l1accof

bool LumiCalculator::m_l1accof {}

private

Definition at line 134 of file LumiCalculator.h.

134{};

◆ m_L1id

cool::ChannelId LumiCalculator::m_L1id {}

private

Definition at line 235 of file LumiCalculator.h.

235{};

◆ m_L1idList

std::vector<cool::ChannelId> LumiCalculator::m_L1idList {}

private

Definition at line 188 of file LumiCalculator.h.

188{};

◆ m_l1prescale

float LumiCalculator::m_l1prescale {}

private

Definition at line 142 of file LumiCalculator.h.

142{};

◆ m_l1rate

float LumiCalculator::m_l1rate {}

private

Definition at line 192 of file LumiCalculator.h.

192{};

◆ m_l1ratediveffxsec

float LumiCalculator::m_l1ratediveffxsec {}

private

Definition at line 195 of file LumiCalculator.h.

195{};

◆ m_l1ratediveffxsec_recorded

float LumiCalculator::m_l1ratediveffxsec_recorded {}

private

Definition at line 198 of file LumiCalculator.h.

198{};

◆ m_L1triggerchains

std::vector<std::string> LumiCalculator::m_L1triggerchains {}

private

Definition at line 187 of file LumiCalculator.h.

187{}; // Used for evaluating [L1_MU20,L1_MU21]

◆ m_L1Valid

bool LumiCalculator::m_L1Valid {}

private

Definition at line 238 of file LumiCalculator.h.

238{};

◆ m_l2acc

unsigned int LumiCalculator::m_l2acc {}

private

Definition at line 135 of file LumiCalculator.h.

135{};

◆ m_L2id

cool::ChannelId LumiCalculator::m_L2id {}

private

Definition at line 234 of file LumiCalculator.h.

234{};

◆ m_l2prescale

float LumiCalculator::m_l2prescale {}

private

Definition at line 143 of file LumiCalculator.h.

143{};

◆ m_l2rate

float LumiCalculator::m_l2rate {}

private

Definition at line 193 of file LumiCalculator.h.

193{};

◆ m_L2Valid

bool LumiCalculator::m_L2Valid {}

private

Definition at line 239 of file LumiCalculator.h.

239{};

◆ m_l3acc

unsigned int LumiCalculator::m_l3acc {}

private

Definition at line 136 of file LumiCalculator.h.

136{};

◆ m_L3id

cool::ChannelId LumiCalculator::m_L3id {}

private

Definition at line 233 of file LumiCalculator.h.

233{};

◆ m_l3prescale

float LumiCalculator::m_l3prescale {}

private

Definition at line 144 of file LumiCalculator.h.

144{};

◆ m_l3rate

float LumiCalculator::m_l3rate {}

private

Definition at line 194 of file LumiCalculator.h.

194{};

◆ m_L3Valid

bool LumiCalculator::m_L3Valid {}

private

Definition at line 240 of file LumiCalculator.h.

240{};

◆ m_lar_database

std::string LumiCalculator::m_lar_database {}

private

Definition at line 78 of file LumiCalculator.h.

78{};

◆ m_larfrac

float LumiCalculator::m_larfrac {}

private

Definition at line 182 of file LumiCalculator.h.

182{};

◆ m_laroff

std::string LumiCalculator::m_laroff {}

private

Definition at line 88 of file LumiCalculator.h.

88{};

◆ m_lartag

std::string LumiCalculator::m_lartag {}

private

Definition at line 89 of file LumiCalculator.h.

89{};

◆ m_lartime

float LumiCalculator::m_lartime {}

private

Definition at line 181 of file LumiCalculator.h.

181{};

◆ m_lbcollectionname

std::string LumiCalculator::m_lbcollectionname {}

private

Definition at line 189 of file LumiCalculator.h.

189{};

◆ m_lbcollname

std::string LumiCalculator::m_lbcollname {}

private

Definition at line 108 of file LumiCalculator.h.

108{};

◆ m_lbendtime

double LumiCalculator::m_lbendtime {}

private

Definition at line 117 of file LumiCalculator.h.

117{};

◆ m_lbstart

uint32_t LumiCalculator::m_lbstart {}

private

Definition at line 152 of file LumiCalculator.h.

152{};

◆ m_lbstart_prev

uint32_t LumiCalculator::m_lbstart_prev {}

private

Definition at line 154 of file LumiCalculator.h.

154{};

◆ m_lbstarttime

double LumiCalculator::m_lbstarttime {}

private

Definition at line 116 of file LumiCalculator.h.

116{}; // In seconds since start of epoch

◆ m_lbstop

uint32_t LumiCalculator::m_lbstop {}

private

Definition at line 153 of file LumiCalculator.h.

153{};

◆ m_lbstop_prev

uint32_t LumiCalculator::m_lbstop_prev {}

private

Definition at line 155 of file LumiCalculator.h.

155{};

◆ m_livefrac

float LumiCalculator::m_livefrac {}

private

Definition at line 130 of file LumiCalculator.h.

130{};

◆ m_LiveL1id

cool::ChannelId LumiCalculator::m_LiveL1id {}

private

Definition at line 236 of file LumiCalculator.h.

236{};

◆ m_livetime

float LumiCalculator::m_livetime {}

private

Definition at line 131 of file LumiCalculator.h.

131{};

◆ m_livetime_afterprescale

ULong64_t LumiCalculator::m_livetime_afterprescale {}

private

Definition at line 147 of file LumiCalculator.h.

147{};

◆ m_livetime_beforeprescale

ULong64_t LumiCalculator::m_livetime_beforeprescale {}

private

Definition at line 146 of file LumiCalculator.h.

146{};

◆ m_livetime_l1acc

unsigned int LumiCalculator::m_livetime_l1acc {}

private

Definition at line 133 of file LumiCalculator.h.

133{};

◆ m_livetrigger

std::string LumiCalculator::m_livetrigger {}

private

Definition at line 82 of file LumiCalculator.h.

82{};

◆ m_LiveValid

bool LumiCalculator::m_LiveValid {}

private

Definition at line 241 of file LumiCalculator.h.

241{};

◆ m_livtrig_totall1acc

unsigned int LumiCalculator::m_livtrig_totall1acc {}

private

Definition at line 138 of file LumiCalculator.h.

138{};

◆ m_logger

Root::TMsgLogger LumiCalculator::m_logger {}

private

Definition at line 107 of file LumiCalculator.h.

107{};

◆ m_lumi_database

std::string LumiCalculator::m_lumi_database {}

private

Definition at line 76 of file LumiCalculator.h.

76{};

◆ m_lumichannel

int LumiCalculator::m_lumichannel {}

private

Definition at line 92 of file LumiCalculator.h.

92{};

◆ m_Lumiid

cool::ChannelId LumiCalculator::m_Lumiid {}

private

Definition at line 232 of file LumiCalculator.h.

232{};

◆ m_lumiLAr

float LumiCalculator::m_lumiLAr {}

private

Definition at line 168 of file LumiCalculator.h.

168{};

◆ m_lumimethod

std::string LumiCalculator::m_lumimethod {}

private

Definition at line 87 of file LumiCalculator.h.

87{};

◆ m_lumioff

std::string LumiCalculator::m_lumioff {}

private

Definition at line 83 of file LumiCalculator.h.

83{};

◆ m_lumionl

std::string LumiCalculator::m_lumionl {}

private

Definition at line 84 of file LumiCalculator.h.

84{};

◆ m_lumiplb

TH1F* LumiCalculator::m_lumiplb {}

private

Definition at line 207 of file LumiCalculator.h.

207{};

◆ m_lumiplbVec

std::vector<TH1F*> LumiCalculator::m_lumiplbVec

private

Definition at line 222 of file LumiCalculator.h.

◆ m_lumitag

std::string LumiCalculator::m_lumitag {}

private

Definition at line 86 of file LumiCalculator.h.

86{};

◆ m_LumiTree

TTree* LumiCalculator::m_LumiTree {}

private

Definition at line 69 of file LumiCalculator.h.

69{};

◆ m_lumitrigrateplb

TH1F* LumiCalculator::m_lumitrigrateplb {}

private

Definition at line 208 of file LumiCalculator.h.

208{};

◆ m_lumitrigrateplb_recorded

TH1F* LumiCalculator::m_lumitrigrateplb_recorded {}

private

Definition at line 211 of file LumiCalculator.h.

211{};

◆ m_lumitrigrateplb_recordedVec

std::vector<TH1F*> LumiCalculator::m_lumitrigrateplb_recordedVec

private

Definition at line 226 of file LumiCalculator.h.

◆ m_lumitrigrateplbVec

std::vector<TH1F*> LumiCalculator::m_lumitrigrateplbVec

private

Definition at line 223 of file LumiCalculator.h.

◆ m_lumiWOPrescale

float LumiCalculator::m_lumiWOPrescale {}

private

Definition at line 166 of file LumiCalculator.h.

166{};

◆ m_makecollList

bool LumiCalculator::m_makecollList {}

private

Definition at line 230 of file LumiCalculator.h.

230{};

◆ m_makePlots

bool LumiCalculator::m_makePlots {}

private

Definition at line 229 of file LumiCalculator.h.

229{};

◆ m_maxrun

unsigned int LumiCalculator::m_maxrun {}

private

Definition at line 248 of file LumiCalculator.h.

248{};

◆ m_minrun

unsigned int LumiCalculator::m_minrun {}

private

Definition at line 247 of file LumiCalculator.h.

247{};

◆ m_mintrigrate

float LumiCalculator::m_mintrigrate {}

private

Definition at line 201 of file LumiCalculator.h.

201{};

◆ m_ntrigplb

TH1F* LumiCalculator::m_ntrigplb {}

private

Definition at line 205 of file LumiCalculator.h.

205{};

◆ m_ntrigplbVec

std::vector<TH1F*> LumiCalculator::m_ntrigplbVec

private

Definition at line 220 of file LumiCalculator.h.

◆ m_onlinelumi

bool LumiCalculator::m_onlinelumi {}

private

Definition at line 243 of file LumiCalculator.h.

243{};

◆ m_parhltmenufolder

std::string LumiCalculator::m_parhltmenufolder {}

private

Definition at line 98 of file LumiCalculator.h.

98{};

◆ m_parhltprescalesfolder

std::string LumiCalculator::m_parhltprescalesfolder {}

private

Definition at line 99 of file LumiCalculator.h.

99{};

◆ m_parlareventvetofolder

std::string LumiCalculator::m_parlareventvetofolder {}

private

Definition at line 104 of file LumiCalculator.h.

104{};

◆ m_parlumiestfolder

std::string LumiCalculator::m_parlumiestfolder {}

private

Definition at line 96 of file LumiCalculator.h.

96{};

◆ m_parlumihltfolder

std::string LumiCalculator::m_parlumihltfolder {}

private

Definition at line 101 of file LumiCalculator.h.

101{};

◆ m_parlumilvl1folder

std::string LumiCalculator::m_parlumilvl1folder {}

private

Definition at line 100 of file LumiCalculator.h.

100{};

◆ m_parlvl1lblbfolder

std::string LumiCalculator::m_parlvl1lblbfolder {}

private

Definition at line 103 of file LumiCalculator.h.

103{};

◆ m_parlvl1menufolder

std::string LumiCalculator::m_parlvl1menufolder {}

private

Definition at line 97 of file LumiCalculator.h.

97{};

◆ m_parlvl1prescalesfolder

std::string LumiCalculator::m_parlvl1prescalesfolder {}

private

Definition at line 102 of file LumiCalculator.h.

102{};

◆ m_parofflumiestfolder

std::string LumiCalculator::m_parofflumiestfolder {}

private

Definition at line 94 of file LumiCalculator.h.

94{};

◆ m_paronlbeamspotfolder

std::string LumiCalculator::m_paronlbeamspotfolder {}

private

Definition at line 105 of file LumiCalculator.h.

105{};

◆ m_paronllumiestfolder

std::string LumiCalculator::m_paronllumiestfolder {}

private

Definition at line 95 of file LumiCalculator.h.

95{};

◆ m_recordTTree

bool LumiCalculator::m_recordTTree {}

private

Definition at line 70 of file LumiCalculator.h.

70{};

◆ m_runnbr

uint32_t LumiCalculator::m_runnbr {}

private

Definition at line 151 of file LumiCalculator.h.

151{};

◆ m_runnbr_prev

uint32_t LumiCalculator::m_runnbr_prev {}

private

Definition at line 156 of file LumiCalculator.h.

156{};

◆ m_State

bool LumiCalculator::m_State {}

private

Definition at line 73 of file LumiCalculator.h.

73{};

◆ m_t_deltaT

float LumiCalculator::m_t_deltaT {}

private

Definition at line 174 of file LumiCalculator.h.

174{};

◆ m_t_l1acc

unsigned int LumiCalculator::m_t_l1acc {}

private

Definition at line 175 of file LumiCalculator.h.

175{};

◆ m_t_l2acc

unsigned int LumiCalculator::m_t_l2acc {}

private

Definition at line 176 of file LumiCalculator.h.

176{};

◆ m_t_l3acc

unsigned int LumiCalculator::m_t_l3acc {}

private

Definition at line 177 of file LumiCalculator.h.

177{};

◆ m_t_lumiLAr

float LumiCalculator::m_t_lumiLAr {}

private

Definition at line 169 of file LumiCalculator.h.

169{};

◆ m_t_lumiWOPrescale

float LumiCalculator::m_t_lumiWOPrescale {}

private

Definition at line 167 of file LumiCalculator.h.

167{};

◆ m_t_totalbadblock

unsigned int LumiCalculator::m_t_totalbadblock {}

private

Definition at line 179 of file LumiCalculator.h.

179{};

◆ m_t_totalDelL

float LumiCalculator::m_t_totalDelL {}

private

Definition at line 170 of file LumiCalculator.h.

170{};

◆ m_t_totalgoodblock

unsigned int LumiCalculator::m_t_totalgoodblock {}

private

Definition at line 178 of file LumiCalculator.h.

178{};

◆ m_t_totalL

float LumiCalculator::m_t_totalL {}

private

Definition at line 171 of file LumiCalculator.h.

171{};

◆ m_t_totall1befpresc

unsigned int LumiCalculator::m_t_totall1befpresc {}

private

Definition at line 180 of file LumiCalculator.h.

180{};

◆ m_t_totalLRun

float LumiCalculator::m_t_totalLRun {}

private

Definition at line 172 of file LumiCalculator.h.

172{};

◆ m_t_totalPrescale

float LumiCalculator::m_t_totalPrescale {}

private

Definition at line 165 of file LumiCalculator.h.

165{};

◆ m_t_totalPrescaleWLiveTime

float LumiCalculator::m_t_totalPrescaleWLiveTime {}

private

Definition at line 163 of file LumiCalculator.h.

163{};

◆ m_t_totaltime

float LumiCalculator::m_t_totaltime {}

private

Definition at line 173 of file LumiCalculator.h.

173{};

◆ m_total_l1ratediveffxsec

float LumiCalculator::m_total_l1ratediveffxsec {}

private

Definition at line 196 of file LumiCalculator.h.

196{};

◆ m_total_l1ratediveffxsec_recorded

float LumiCalculator::m_total_l1ratediveffxsec_recorded {}

private

Definition at line 199 of file LumiCalculator.h.

199{};

◆ m_total_l1ratediveffxsecRun

float LumiCalculator::m_total_l1ratediveffxsecRun {}

private

Definition at line 197 of file LumiCalculator.h.

197{};

◆ m_total_l1ratediveffxsecRun_recorded

float LumiCalculator::m_total_l1ratediveffxsecRun_recorded {}

private

Definition at line 200 of file LumiCalculator.h.

200{};

◆ m_totalbadblock

unsigned int LumiCalculator::m_totalbadblock {}

private

Definition at line 158 of file LumiCalculator.h.

158{};

◆ m_totalDelL

float LumiCalculator::m_totalDelL {}

private

Definition at line 119 of file LumiCalculator.h.

119{};

◆ m_TotaldeltaT

float LumiCalculator::m_TotaldeltaT {}

private

Definition at line 129 of file LumiCalculator.h.

129{};

◆ m_totalgoodblock

unsigned int LumiCalculator::m_totalgoodblock {}

private

Definition at line 157 of file LumiCalculator.h.

157{};

◆ m_totalL

float LumiCalculator::m_totalL {}

private

Definition at line 120 of file LumiCalculator.h.

120{};

◆ m_totall1acc

unsigned int LumiCalculator::m_totall1acc {}

private

Definition at line 137 of file LumiCalculator.h.

137{};

◆ m_totall1befpresc

unsigned int LumiCalculator::m_totall1befpresc {}

private

Definition at line 139 of file LumiCalculator.h.

139{};

◆ m_totall2acc

unsigned int LumiCalculator::m_totall2acc {}

private

Definition at line 140 of file LumiCalculator.h.

140{};

◆ m_totall3acc

unsigned int LumiCalculator::m_totall3acc {}

private

Definition at line 141 of file LumiCalculator.h.

141{};

◆ m_totalLRun

float LumiCalculator::m_totalLRun {}

private

Definition at line 121 of file LumiCalculator.h.

121{};

◆ m_totalPrescale

float LumiCalculator::m_totalPrescale {}

private

Definition at line 164 of file LumiCalculator.h.

164{};

◆ m_totalPrescaleWLiveTime

float LumiCalculator::m_totalPrescaleWLiveTime {}

private

Definition at line 162 of file LumiCalculator.h.

162{};

◆ m_totaltime

float LumiCalculator::m_totaltime {}

private

Definition at line 122 of file LumiCalculator.h.

122{};

◆ m_trig_database

std::string LumiCalculator::m_trig_database {}

private

Definition at line 77 of file LumiCalculator.h.

77{};

◆ m_trigger

std::string LumiCalculator::m_trigger {}

private

Definition at line 81 of file LumiCalculator.h.

81{};

◆ m_triggerchain

std::string LumiCalculator::m_triggerchain {}

private

Definition at line 185 of file LumiCalculator.h.

185{};

◆ m_triggerlowerchains

std::vector<std::string> LumiCalculator::m_triggerlowerchains {}

private

Definition at line 186 of file LumiCalculator.h.

186{};

◆ m_triglevel

unsigned int LumiCalculator::m_triglevel {}

private

Definition at line 161 of file LumiCalculator.h.

161{};

◆ m_trigrateplb

TH1F* LumiCalculator::m_trigrateplb {}

private

Definition at line 206 of file LumiCalculator.h.

206{};

◆ m_trigrateplbVec

std::vector<TH1F*> LumiCalculator::m_trigrateplbVec

private

Definition at line 221 of file LumiCalculator.h.

◆ m_usebs

bool LumiCalculator::m_usebs {}

private

Definition at line 245 of file LumiCalculator.h.

245{};

◆ m_uselar

bool LumiCalculator::m_uselar {}

private

Definition at line 244 of file LumiCalculator.h.

244{};

◆ m_uselivetrigger

bool LumiCalculator::m_uselivetrigger {}

private

Definition at line 109 of file LumiCalculator.h.

109{};

◆ m_Valid

cool::UInt32 LumiCalculator::m_Valid {}

private

Definition at line 125 of file LumiCalculator.h.

125{};

◆ m_verbose

bool LumiCalculator::m_verbose {}

private

Definition at line 110 of file LumiCalculator.h.

110{};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LumiCalculator()

◆ ~LumiCalculator()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ DoHistogramAdmin()

◆ getTree()

◆ LoadChannelIds()

◆ MakeCollList()

◆ MakePlots() [1/2]

◆ MakePlots() [2/2]

◆ ParseL1Trigger()

◆ printSummary()

◆ RebinHistograms()

◆ ScaleL1TrigRate()

◆ SetCollName()

◆ SetHistogramStyle()

◆ SetMinL1TrigRate()

◆ setTree()

◆ UseBeamspot()

◆ UseLArNoiseDB()

◆ UseLiveTrigger()

◆ UseLumiChannel()

◆ UseLumiMethod()

◆ UseLumiTag()

◆ UseMC()

◆ UseOnlineLumi()

◆ Verbose()

Member Data Documentation

◆ m_afterprescale

◆ m_afterprescaleof

◆ m_AvEvtsPerBX

◆ m_avgintperbx

◆ m_beforeprescale

◆ m_beforeprescaleof

◆ m_bs_database

◆ m_bsonl

◆ m_bstag

◆ m_bsvalid

◆ m_clumiblocknbr

◆ m_clumiblocknbrend

◆ m_collsgrl

◆ m_data_db

◆ m_delLumi

◆ m_deltaT

◆ m_effxsec

◆ m_instLumi

◆ m_intLumi

◆ m_intlumi

◆ m_intlumiruns

◆ m_intlumitrigrate

◆ m_intlumitrigrate_recorded

◆ m_intlumitrigrate_recordedVec

◆ m_intlumitrigrateruns

◆ m_intlumitrigrateruns_recorded

◆ m_intlumitrigrateVec

◆ m_intlumiVec

◆ m_l1acc

◆ m_l1accof

◆ m_L1id

◆ m_L1idList

◆ m_l1prescale

◆ m_l1rate

◆ m_l1ratediveffxsec

◆ m_l1ratediveffxsec_recorded

◆ m_L1triggerchains

◆ m_L1Valid

◆ m_l2acc

◆ m_L2id

◆ m_l2prescale

◆ m_l2rate

◆ m_L2Valid

◆ m_l3acc

◆ m_L3id

◆ m_l3prescale

◆ m_l3rate