d5/d40/LumiCalculator_8h_source.html

/*

  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration

*/


#ifndef LUMICALC_LUMICALCULATOR_H

#define LUMICALC_LUMICALCULATOR_H


#include "CxxUtils/checker_macros.h"

#include "GoodRunsLists/TMsgLogger.h" //Root TMsgLogger

#include "CoolKernel/types.h" //Cool::Uint32 typedef

#include "CoolKernel/ChannelId.h" //Cool::ChannelId typedef

#include "xAODLuminosity/LumiBlockRangeContainer.h" // typedef

#include <string>

#include <vector>

#include <cstdint>


namespace Root {

  class TGoodRunsList;

}


class CoolQuery;

class TH1F;

class TTree;

class TString;


class LumiCalculator{


 public:

  LumiCalculator();

  ~LumiCalculator();


  void UseMC(bool mc = true); // No longer supported

  void UseLArNoiseDB(bool lar, const std::string& lardb); // Calculate LAr defect fraction

  void UseBeamspot(bool bs, const std::string& bstag); // Calculate online beamspot validity fraction

  void UseOnlineLumi(bool online);

  void Verbose(bool verbose = true);

  void UseLumiTag(const std::string& tag);// i.e. COOL Folder tag

  void UseLumiMethod(const std::string& method);// i.e. COOL Folder channel

  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();


  inline void MakePlots(bool plots) { m_makePlots = plots; }

  inline void MakeCollList(bool collList) { m_makecollList = collList; }

  inline void ScaleL1TrigRate( const float& rate ) { m_effxsec=1./rate; }

  inline void SetMinL1TrigRate( const float& mintrigrate ) { m_mintrigrate=mintrigrate; }


  // Print terse summary of results

  void printSummary(std::ostream& os);


 private:


  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);


  //TCanvas* GetNiceCanvas(const char* name="tcan", const char* title="tcan");


  // A TTree to bookkeep the calculation

  TTree * m_LumiTree{};

  bool m_recordTTree{};


  // State of LumiCalculator: True - OK, False - something went bad..

  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{};


  // Internal variables


  double m_lbstarttime{};  // In seconds since start of epoch

  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{};  // Used for evaluating [L1_MU20,L1_MU21]

  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{};

};


#endif //> LUMICALC_LUMICALCULATOR_H