LArCalibValidationAlg.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef LARCALIBVALIDATIONALG_H
#define LARCALIBVALIDATIONALG_H
 
#include <vector>
#include <string>
#include <sstream> 
#include <fstream>
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "LArRecConditions/LArBadChannelMask.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "LArRecConditions/LArBadChannelCont.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArRecConditions/LArCalibLineMapping.h"
 
#include "CaloIdentifier/CaloGain.h"
#include "CaloIdentifier/CaloCell_ID.h"
 
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
class LArCalibValidationAlg:public AthAlgorithm {
 
public:
  LArCalibValidationAlg (const std::string& name, ISvcLocator* pSvcLocator);
 
  ~LArCalibValidationAlg();
 
  StatusCode initialize();
 
  StatusCode execute() {return StatusCode::SUCCESS;}
 
  StatusCode stop();
  StatusCode finalize(){return StatusCode::SUCCESS;}
 
protected:
  typedef typename CONDITIONSCONTAINER::ConstConditionsMapIterator CONTIT;
  typedef typename CONDITIONSCONTAINER::LArCondObj LArCondObj;
  typedef typename CONDITIONSCONTAINER::MultChanCollection MULTICHANCOLL;
 
  virtual StatusCode preLoop();
 
  
  virtual bool validateChannel(const LArCondObj& ref, const LArCondObj& val, const HWIdentifier chid, const int gain, const LArOnOffIdMapping *cabling,const LArBadChannelCont *bcCont)=0;
 
 
  virtual LArCondObj getRefObj(const HWIdentifier chid, const int gain) const=0;
 
  virtual StatusCode summary(const LArOnOffIdMapping *cabling,const LArBadChannelCont *bcCont);
 
  const std::string channelDescription(const HWIdentifier& chid, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont, const unsigned gain=99, bool isFeb=false) const;
 
 
private:
  bool checkCoolChannelCompleteness(const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont, const LArBadChannelCont *bcCont);
 
 
  typedef std::vector<std::pair<HWIdentifier,unsigned> > FEBANDGAIN_t;
  bool patchMissingFEBs(const FEBANDGAIN_t& febAndGain, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont);
 
typedef std::vector<std::pair<std::pair<HWIdentifier,unsigned>, unsigned > > CBANDCHANANDGAIN_t;
  bool patchMissingCalibBoards(const CBANDCHANANDGAIN_t& CBAndGain, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont);
 
  void febOutput(const HWIdentifier& febid, const unsigned gain, const unsigned nGood, const unsigned nBad);
 
  void findFailedPatterns(const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont, const LArBadChannelCont *bcCont);
 
  std::vector<std::string> m_gainMap;
 
protected:
  MSG::Level m_myMsgLvl;
  int m_myMsgLvlProp;
 
 
  SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};
  SG::ReadCondHandleKey<LArBadChannelCont> m_BCKey{this, "BadChanKey", "LArBadChannel", "SG bad channels key"};
  SG::ReadCondHandleKey<LArCalibLineMapping>  m_CLKey{this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"};
  LArBadChannelMask m_bcMask;
  Gaudi::Property<std::vector<std::string> > m_problemsToMask{this,"ProblemsToMask",{}, "Bad-Channel categories to mask"};
  Gaudi::Property<std::vector<unsigned int> > m_patchCBs{this, "PatchCBs", {}, "List of missing CalibBoards to patch using values from reference container."};
  BooleanProperty m_isSC{this, "SuperCells", false, "Working on SuperCells ?"};
 
  // Pointers to various identifier helper classes, not used her, but
  // probably useful for deriving algorithm
  const LArOnlineID_Base* m_onlineHelper=nullptr; 
  const CaloCell_Base_ID* m_caloId=nullptr;
 
 
  const REFCONTAINER* m_reference=nullptr;  
 
  const CONDITIONSCONTAINER* m_validation=nullptr;  
 
  CONDITIONSCONTAINER* m_nc_validation=nullptr;  
 
  std::string    m_validationKey;
 
  SG::ReadCondHandleKey<REFCONTAINER> m_referenceKey{this,"ReferenceKey","", "SG key of the LArConditionsContainer used as reference"};
 
  bool m_useBCInfo;
 
  bool m_checkCompleteness;
 
  bool m_patchMissingFEBs;
 
  bool m_printFailedPattern;
 
  bool m_doFebAverages; 
 
  unsigned m_maxmessages; 
 
  //Count the various cases:
 
  unsigned m_nChecked=0;
 
  unsigned m_nFailedValidation=0;
 
  unsigned m_nValidated=0;
 
  unsigned m_nBad=0;
 
  unsigned m_nNoReference=0;
 
  typedef std::vector<std::pair<HWIdentifier, bool > > CHECKEDID_t;
  std::vector<CHECKEDID_t> m_checkedIds;
 
  std::string m_chanFileName;
 
  std::ofstream  m_chanFile;
  
  std::string m_febFileName;
 
  std::ofstream  m_febFile;
 
  bool m_useCorrChannel;
 
};
 
#include "LArCalibValidationAlg.icc"
 
#endif