#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 1419 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; }

◆ MakePlots() [2/2]

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

private

Definition at line 1493 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 1354 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 1397 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 1454 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 1468 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.

◆ m_afterprescaleof

bool LumiCalculator::m_afterprescaleof {}

private

Definition at line 148 of file LumiCalculator.h.

◆ m_AvEvtsPerBX

float LumiCalculator::m_AvEvtsPerBX {}

private

Definition at line 124 of file LumiCalculator.h.

◆ m_avgintperbx

TH1F* LumiCalculator::m_avgintperbx {}

private

Definition at line 218 of file LumiCalculator.h.

◆ m_beforeprescale

ULong64_t LumiCalculator::m_beforeprescale {}

private

Definition at line 149 of file LumiCalculator.h.

◆ m_beforeprescaleof

bool LumiCalculator::m_beforeprescaleof {}

private

Definition at line 150 of file LumiCalculator.h.

◆ m_bs_database

std::string LumiCalculator::m_bs_database {}

private

Definition at line 79 of file LumiCalculator.h.

◆ m_bsonl

std::string LumiCalculator::m_bsonl {}

private

Definition at line 90 of file LumiCalculator.h.

◆ m_bstag

std::string LumiCalculator::m_bstag {}

private

Definition at line 91 of file LumiCalculator.h.

◆ m_bsvalid

float LumiCalculator::m_bsvalid {}

private

Definition at line 183 of file LumiCalculator.h.

◆ m_clumiblocknbr

uint32_t LumiCalculator::m_clumiblocknbr {}

private

Definition at line 159 of file LumiCalculator.h.

◆ m_clumiblocknbrend

uint32_t LumiCalculator::m_clumiblocknbrend {}

private

Definition at line 160 of file LumiCalculator.h.

◆ m_collsgrl

Root::TGoodRunsList* LumiCalculator::m_collsgrl {}

private

Definition at line 203 of file LumiCalculator.h.

◆ m_data_db

std::string LumiCalculator::m_data_db {}

private

Definition at line 85 of file LumiCalculator.h.

◆ m_delLumi

float LumiCalculator::m_delLumi {}

private

Definition at line 126 of file LumiCalculator.h.

◆ m_deltaT

float LumiCalculator::m_deltaT {}

private

Definition at line 128 of file LumiCalculator.h.

◆ m_effxsec

float LumiCalculator::m_effxsec {}

private

Definition at line 191 of file LumiCalculator.h.

◆ m_instLumi

float LumiCalculator::m_instLumi {}

private

Definition at line 123 of file LumiCalculator.h.

◆ m_intLumi

float LumiCalculator::m_intLumi {}

private

Definition at line 127 of file LumiCalculator.h.

◆ m_intlumi

TH1F* LumiCalculator::m_intlumi {}

private

Definition at line 209 of file LumiCalculator.h.

◆ m_intlumiruns

TH1F* LumiCalculator::m_intlumiruns {}

private

Definition at line 214 of file LumiCalculator.h.

◆ m_intlumitrigrate

TH1F* LumiCalculator::m_intlumitrigrate {}

private

Definition at line 210 of file LumiCalculator.h.

◆ m_intlumitrigrate_recorded

TH1F* LumiCalculator::m_intlumitrigrate_recorded {}

private

Definition at line 212 of file LumiCalculator.h.

◆ 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.

◆ m_intlumitrigrateruns_recorded

TH1F* LumiCalculator::m_intlumitrigrateruns_recorded {}

private

Definition at line 216 of file LumiCalculator.h.

◆ 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.

◆ m_l1accof

bool LumiCalculator::m_l1accof {}

private

Definition at line 134 of file LumiCalculator.h.

◆ m_L1id

cool::ChannelId LumiCalculator::m_L1id {}

private

Definition at line 235 of file LumiCalculator.h.

◆ m_L1idList

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

private

Definition at line 188 of file LumiCalculator.h.

◆ m_l1prescale

float LumiCalculator::m_l1prescale {}

private

Definition at line 142 of file LumiCalculator.h.

◆ m_l1rate

float LumiCalculator::m_l1rate {}

private

Definition at line 192 of file LumiCalculator.h.

◆ m_l1ratediveffxsec

float LumiCalculator::m_l1ratediveffxsec {}

private

Definition at line 195 of file LumiCalculator.h.

◆ m_l1ratediveffxsec_recorded

float LumiCalculator::m_l1ratediveffxsec_recorded {}

private

Definition at line 198 of file LumiCalculator.h.

◆ m_L1triggerchains

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

private

Definition at line 187 of file LumiCalculator.h.

◆ m_L1Valid

bool LumiCalculator::m_L1Valid {}

private

Definition at line 238 of file LumiCalculator.h.

◆ m_l2acc

unsigned int LumiCalculator::m_l2acc {}

private

Definition at line 135 of file LumiCalculator.h.

◆ m_L2id

cool::ChannelId LumiCalculator::m_L2id {}

private

Definition at line 234 of file LumiCalculator.h.

◆ m_l2prescale

float LumiCalculator::m_l2prescale {}

private

Definition at line 143 of file LumiCalculator.h.

◆ m_l2rate

float LumiCalculator::m_l2rate {}

private

Definition at line 193 of file LumiCalculator.h.

◆ m_L2Valid

bool LumiCalculator::m_L2Valid {}

private

Definition at line 239 of file LumiCalculator.h.

◆ m_l3acc

unsigned int LumiCalculator::m_l3acc {}

private

Definition at line 136 of file LumiCalculator.h.

◆ m_L3id

cool::ChannelId LumiCalculator::m_L3id {}

private

Definition at line 233 of file LumiCalculator.h.

◆ m_l3prescale

float LumiCalculator::m_l3prescale {}

private

Definition at line 144 of file LumiCalculator.h.

◆ m_l3rate

float LumiCalculator::m_l3rate {}

private

Definition at line 194 of file LumiCalculator.h.

◆ m_L3Valid

bool LumiCalculator::m_L3Valid {}

private

Definition at line 240 of file LumiCalculator.h.

◆ m_lar_database

std::string LumiCalculator::m_lar_database {}

private

Definition at line 78 of file LumiCalculator.h.

◆ m_larfrac

float LumiCalculator::m_larfrac {}

private

Definition at line 182 of file LumiCalculator.h.

◆ m_laroff

std::string LumiCalculator::m_laroff {}

private

Definition at line 88 of file LumiCalculator.h.

◆ m_lartag

std::string LumiCalculator::m_lartag {}

private

Definition at line 89 of file LumiCalculator.h.

◆ m_lartime

float LumiCalculator::m_lartime {}

private

Definition at line 181 of file LumiCalculator.h.

◆ m_lbcollectionname

std::string LumiCalculator::m_lbcollectionname {}

private

Definition at line 189 of file LumiCalculator.h.

◆ m_lbcollname

std::string LumiCalculator::m_lbcollname {}

private

Definition at line 108 of file LumiCalculator.h.

◆ m_lbendtime

double LumiCalculator::m_lbendtime {}

private

Definition at line 117 of file LumiCalculator.h.

◆ m_lbstart

uint32_t LumiCalculator::m_lbstart {}

private

Definition at line 152 of file LumiCalculator.h.

◆ m_lbstart_prev

uint32_t LumiCalculator::m_lbstart_prev {}

private

Definition at line 154 of file LumiCalculator.h.

◆ m_lbstarttime

double LumiCalculator::m_lbstarttime {}

private

Definition at line 116 of file LumiCalculator.h.

◆ m_lbstop

uint32_t LumiCalculator::m_lbstop {}

private

Definition at line 153 of file LumiCalculator.h.

◆ m_lbstop_prev

uint32_t LumiCalculator::m_lbstop_prev {}

private

Definition at line 155 of file LumiCalculator.h.

◆ m_livefrac

float LumiCalculator::m_livefrac {}

private

Definition at line 130 of file LumiCalculator.h.

◆ m_LiveL1id

cool::ChannelId LumiCalculator::m_LiveL1id {}

private

Definition at line 236 of file LumiCalculator.h.

◆ m_livetime

float LumiCalculator::m_livetime {}

private

Definition at line 131 of file LumiCalculator.h.

◆ m_livetime_afterprescale

ULong64_t LumiCalculator::m_livetime_afterprescale {}

private

Definition at line 147 of file LumiCalculator.h.

◆ m_livetime_beforeprescale

ULong64_t LumiCalculator::m_livetime_beforeprescale {}

private

Definition at line 146 of file LumiCalculator.h.

◆ m_livetime_l1acc

unsigned int LumiCalculator::m_livetime_l1acc {}

private

Definition at line 133 of file LumiCalculator.h.

◆ m_livetrigger

std::string LumiCalculator::m_livetrigger {}

private

Definition at line 82 of file LumiCalculator.h.

◆ m_LiveValid

bool LumiCalculator::m_LiveValid {}

private

Definition at line 241 of file LumiCalculator.h.

◆ m_livtrig_totall1acc

unsigned int LumiCalculator::m_livtrig_totall1acc {}

private

Definition at line 138 of file LumiCalculator.h.

◆ m_logger

Root::TMsgLogger LumiCalculator::m_logger {}

private

Definition at line 107 of file LumiCalculator.h.

◆ m_lumi_database

std::string LumiCalculator::m_lumi_database {}

private

Definition at line 76 of file LumiCalculator.h.

◆ m_lumichannel

int LumiCalculator::m_lumichannel {}

private

Definition at line 92 of file LumiCalculator.h.

◆ m_Lumiid

cool::ChannelId LumiCalculator::m_Lumiid {}

private

Definition at line 232 of file LumiCalculator.h.

◆ m_lumiLAr

float LumiCalculator::m_lumiLAr {}

private

Definition at line 168 of file LumiCalculator.h.

◆ m_lumimethod

std::string LumiCalculator::m_lumimethod {}

private

Definition at line 87 of file LumiCalculator.h.

◆ m_lumioff

std::string LumiCalculator::m_lumioff {}

private

Definition at line 83 of file LumiCalculator.h.

◆ m_lumionl

std::string LumiCalculator::m_lumionl {}

private

Definition at line 84 of file LumiCalculator.h.

◆ m_lumiplb

TH1F* LumiCalculator::m_lumiplb {}

private

Definition at line 207 of file LumiCalculator.h.

◆ 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.

◆ m_LumiTree

TTree* LumiCalculator::m_LumiTree {}

private

Definition at line 69 of file LumiCalculator.h.

◆ m_lumitrigrateplb

TH1F* LumiCalculator::m_lumitrigrateplb {}

private

Definition at line 208 of file LumiCalculator.h.

◆ m_lumitrigrateplb_recorded

TH1F* LumiCalculator::m_lumitrigrateplb_recorded {}

private

Definition at line 211 of file LumiCalculator.h.

◆ 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.

◆ m_makecollList

bool LumiCalculator::m_makecollList {}

private

Definition at line 230 of file LumiCalculator.h.

◆ m_makePlots

bool LumiCalculator::m_makePlots {}

private

Definition at line 229 of file LumiCalculator.h.

◆ m_maxrun

unsigned int LumiCalculator::m_maxrun {}

private

Definition at line 248 of file LumiCalculator.h.

◆ m_minrun

unsigned int LumiCalculator::m_minrun {}

private

Definition at line 247 of file LumiCalculator.h.

◆ m_mintrigrate

float LumiCalculator::m_mintrigrate {}

private

Definition at line 201 of file LumiCalculator.h.

◆ m_ntrigplb

TH1F* LumiCalculator::m_ntrigplb {}

private

Definition at line 205 of file LumiCalculator.h.

◆ 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.

◆ m_parhltmenufolder

std::string LumiCalculator::m_parhltmenufolder {}

private

Definition at line 98 of file LumiCalculator.h.

◆ m_parhltprescalesfolder

std::string LumiCalculator::m_parhltprescalesfolder {}

private

Definition at line 99 of file LumiCalculator.h.

◆ m_parlareventvetofolder

std::string LumiCalculator::m_parlareventvetofolder {}

private

Definition at line 104 of file LumiCalculator.h.

◆ m_parlumiestfolder

std::string LumiCalculator::m_parlumiestfolder {}

private

Definition at line 96 of file LumiCalculator.h.

◆ m_parlumihltfolder

std::string LumiCalculator::m_parlumihltfolder {}

private

Definition at line 101 of file LumiCalculator.h.

◆ m_parlumilvl1folder

std::string LumiCalculator::m_parlumilvl1folder {}

private

Definition at line 100 of file LumiCalculator.h.

◆ m_parlvl1lblbfolder

std::string LumiCalculator::m_parlvl1lblbfolder {}

private

Definition at line 103 of file LumiCalculator.h.

◆ m_parlvl1menufolder

std::string LumiCalculator::m_parlvl1menufolder {}

private

Definition at line 97 of file LumiCalculator.h.

◆ m_parlvl1prescalesfolder

std::string LumiCalculator::m_parlvl1prescalesfolder {}

private

Definition at line 102 of file LumiCalculator.h.

◆ m_parofflumiestfolder

std::string LumiCalculator::m_parofflumiestfolder {}

private

Definition at line 94 of file LumiCalculator.h.

◆ m_paronlbeamspotfolder

std::string LumiCalculator::m_paronlbeamspotfolder {}

private

Definition at line 105 of file LumiCalculator.h.

◆ m_paronllumiestfolder

std::string LumiCalculator::m_paronllumiestfolder {}

private

Definition at line 95 of file LumiCalculator.h.

◆ m_recordTTree

bool LumiCalculator::m_recordTTree {}

private

Definition at line 70 of file LumiCalculator.h.

◆ m_runnbr

uint32_t LumiCalculator::m_runnbr {}

private

Definition at line 151 of file LumiCalculator.h.

◆ m_runnbr_prev

uint32_t LumiCalculator::m_runnbr_prev {}

private

Definition at line 156 of file LumiCalculator.h.

◆ m_State

bool LumiCalculator::m_State {}

private

Definition at line 73 of file LumiCalculator.h.

◆ m_t_deltaT

float LumiCalculator::m_t_deltaT {}

private

Definition at line 174 of file LumiCalculator.h.

◆ m_t_l1acc

unsigned int LumiCalculator::m_t_l1acc {}

private

Definition at line 175 of file LumiCalculator.h.

◆ m_t_l2acc

unsigned int LumiCalculator::m_t_l2acc {}

private

Definition at line 176 of file LumiCalculator.h.

◆ m_t_l3acc

unsigned int LumiCalculator::m_t_l3acc {}

private

Definition at line 177 of file LumiCalculator.h.

◆ m_t_lumiLAr

float LumiCalculator::m_t_lumiLAr {}

private

Definition at line 169 of file LumiCalculator.h.

◆ m_t_lumiWOPrescale

float LumiCalculator::m_t_lumiWOPrescale {}

private

Definition at line 167 of file LumiCalculator.h.

◆ m_t_totalbadblock

unsigned int LumiCalculator::m_t_totalbadblock {}

private

Definition at line 179 of file LumiCalculator.h.

◆ m_t_totalDelL

float LumiCalculator::m_t_totalDelL {}

private

Definition at line 170 of file LumiCalculator.h.

◆ m_t_totalgoodblock

unsigned int LumiCalculator::m_t_totalgoodblock {}

private

Definition at line 178 of file LumiCalculator.h.

◆ m_t_totalL

float LumiCalculator::m_t_totalL {}

private

Definition at line 171 of file LumiCalculator.h.

◆ m_t_totall1befpresc

unsigned int LumiCalculator::m_t_totall1befpresc {}

private

Definition at line 180 of file LumiCalculator.h.

◆ m_t_totalLRun

float LumiCalculator::m_t_totalLRun {}

private

Definition at line 172 of file LumiCalculator.h.

◆ m_t_totalPrescale

float LumiCalculator::m_t_totalPrescale {}

private

Definition at line 165 of file LumiCalculator.h.

◆ m_t_totalPrescaleWLiveTime

float LumiCalculator::m_t_totalPrescaleWLiveTime {}

private

Definition at line 163 of file LumiCalculator.h.

◆ m_t_totaltime

float LumiCalculator::m_t_totaltime {}

private

Definition at line 173 of file LumiCalculator.h.

◆ m_total_l1ratediveffxsec

float LumiCalculator::m_total_l1ratediveffxsec {}

private

Definition at line 196 of file LumiCalculator.h.

◆ m_total_l1ratediveffxsec_recorded

float LumiCalculator::m_total_l1ratediveffxsec_recorded {}

private

Definition at line 199 of file LumiCalculator.h.

◆ m_total_l1ratediveffxsecRun

float LumiCalculator::m_total_l1ratediveffxsecRun {}

private

Definition at line 197 of file LumiCalculator.h.

◆ m_total_l1ratediveffxsecRun_recorded

float LumiCalculator::m_total_l1ratediveffxsecRun_recorded {}

private

Definition at line 200 of file LumiCalculator.h.

◆ m_totalbadblock

unsigned int LumiCalculator::m_totalbadblock {}

private

Definition at line 158 of file LumiCalculator.h.

◆ m_totalDelL

float LumiCalculator::m_totalDelL {}

private

Definition at line 119 of file LumiCalculator.h.

◆ m_TotaldeltaT

float LumiCalculator::m_TotaldeltaT {}

private

Definition at line 129 of file LumiCalculator.h.

◆ m_totalgoodblock

unsigned int LumiCalculator::m_totalgoodblock {}

private

Definition at line 157 of file LumiCalculator.h.

◆ m_totalL

float LumiCalculator::m_totalL {}

private

Definition at line 120 of file LumiCalculator.h.

◆ m_totall1acc

unsigned int LumiCalculator::m_totall1acc {}

private

Definition at line 137 of file LumiCalculator.h.

◆ m_totall1befpresc

unsigned int LumiCalculator::m_totall1befpresc {}

private

Definition at line 139 of file LumiCalculator.h.

◆ m_totall2acc

unsigned int LumiCalculator::m_totall2acc {}

private

Definition at line 140 of file LumiCalculator.h.

◆ m_totall3acc

unsigned int LumiCalculator::m_totall3acc {}

private

Definition at line 141 of file LumiCalculator.h.

◆ m_totalLRun

float LumiCalculator::m_totalLRun {}

private

Definition at line 121 of file LumiCalculator.h.

◆ m_totalPrescale

float LumiCalculator::m_totalPrescale {}

private

Definition at line 164 of file LumiCalculator.h.

◆ m_totalPrescaleWLiveTime

float LumiCalculator::m_totalPrescaleWLiveTime {}

private

Definition at line 162 of file LumiCalculator.h.

◆ m_totaltime

float LumiCalculator::m_totaltime {}

private

Definition at line 122 of file LumiCalculator.h.

◆ m_trig_database

std::string LumiCalculator::m_trig_database {}

private

Definition at line 77 of file LumiCalculator.h.

◆ m_trigger

std::string LumiCalculator::m_trigger {}

private

Definition at line 81 of file LumiCalculator.h.

◆ m_triggerchain

std::string LumiCalculator::m_triggerchain {}

private

Definition at line 185 of file LumiCalculator.h.

◆ m_triggerlowerchains

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

private

Definition at line 186 of file LumiCalculator.h.

◆ m_triglevel

unsigned int LumiCalculator::m_triglevel {}

private

Definition at line 161 of file LumiCalculator.h.

◆ m_trigrateplb

TH1F* LumiCalculator::m_trigrateplb {}

private

Definition at line 206 of file LumiCalculator.h.

◆ 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.

◆ m_uselar

bool LumiCalculator::m_uselar {}

private

Definition at line 244 of file LumiCalculator.h.

◆ m_uselivetrigger

bool LumiCalculator::m_uselivetrigger {}

private

Definition at line 109 of file LumiCalculator.h.

◆ m_Valid

cool::UInt32 LumiCalculator::m_Valid {}

private

Definition at line 125 of file LumiCalculator.h.

◆ m_verbose

bool LumiCalculator::m_verbose {}

private

Definition at line 110 of file LumiCalculator.h.

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