LArCalibPatchingAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
//Dear emacs, this is -*-c++-*-
 
#ifndef LARCALIBPATCHINGALG_H
#define LARCALIBPATCHINGALG_H
 
#include <vector>
#include <string>
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "LArRecConditions/LArBadChannelMask.h"
#include "LArRawConditions/LArMphysOverMcalComplete.h"
#include "LArRawConditions/LArRampComplete.h"
#include "LArRawConditions/LArAutoCorrComplete.h"
#include "LArRawConditions/LArOFCComplete.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "LArRecConditions/LArBadChannelCont.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArRecConditions/LArCalibLineMapping.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
 
 
 
template<class CONDITIONSCONTAINER>
class ATLAS_NOT_THREAD_SAFE LArCalibPatchingAlg:public AthAlgorithm {
 
public:
  LArCalibPatchingAlg (const std::string& name, ISvcLocator* pSvcLocator);
 
  ~LArCalibPatchingAlg(){};
 
  StatusCode initialize();
 
  StatusCode execute() {return StatusCode::SUCCESS;}
 
  StatusCode stop();
  StatusCode finalize(){return StatusCode::SUCCESS;}
 
private:
 
  typedef typename CONDITIONSCONTAINER::ConstConditionsMapIterator CONTIT;
  typedef typename CONDITIONSCONTAINER::LArCondObj LArCondObj;
  
  bool patch(const HWIdentifier chid, const int gain, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, const LArCalibLineMapping *clCont); 
 
    
  bool getAverage(const HWIdentifier chid, const int gain, LArRampP1& patch, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, bool isphi=true); 
 
  bool getAverage(const HWIdentifier chid, const int gain, LArOFCP1& patch, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, bool isphi=true); 
 
  bool getAverage(const HWIdentifier chid, const int gain, LArAutoCorrP1& patch, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, bool isphi=false); 
 
  bool setZero(const HWIdentifier chid, const int gain, LArRampP1& patch); 
  bool setZero(const HWIdentifier chid, const int gain, LArOFCP1& patch); 
  bool setZero(const HWIdentifier chid, const int gain, LArCaliWaveVec& patch); 
  bool setZero(const HWIdentifier chid, const int gain, LArAutoCorrP1& patch); 
 
 
 
 
  //The following #ifdef-logic is to make this package compile against 13.2.0. as well as 14.X.0
  //since the payload object of LArMphysOverMcal has changed from LArMphysOverMcalP1 to LArSingleFloatP
 
 
#ifdef LARRAWCONDITIONS_LARMPHYSOVERMCALP
 
  //For backward compatiblity only!!! Will be removed at some point
  bool getAverage(const HWIdentifier chid, const int gain, LArMphysOverMcalP1& patch, const LArBadChannelCont* bcCont, bool isphi=true);
#endif
 
 
#ifdef LARRAWCONDITIONS_LARSINGLEFLOATP
 
  bool getAverage(const HWIdentifier chid, const int gain, LArSingleFloatP& patch, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, bool isphi=true);
  bool setZero(LArSingleFloatP& patch);
#endif
 
 
 
 
  bool getAverage(const HWIdentifier,const int, LArCaliWaveVec&, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, bool isphi=true) ;
 
  std::vector<HWIdentifier>& getPhiRing(const HWIdentifier chid, const LArBadChannelCont* bcCont, const LArOnOffIdMapping* cabling, unsigned distance=1);
  
  /* Get list of channels in the same FEB. Used for FEBAverage method */
  std::vector<HWIdentifier>& getFEBChans(const HWIdentifier chid, const LArBadChannelCont* bcCont);
 
  StatusCode setSymlink(const LArRampComplete* ramp) const;
  StatusCode setSymlink(const LArOFCComplete* ofc) const;
  StatusCode setSymlink(const LArMphysOverMcalComplete* ramp) const;
  StatusCode setSymlink(const LArCaliWaveContainer* ) const 
  {return StatusCode::SUCCESS;};
  StatusCode setSymlink(const LArAutoCorrComplete* ) const; 
 
  enum patchMethod{
    FEBNeighbor,
    PhiNeighbor,
    PhiAverage,
    FEBAverage,
    SetZero
  };
 
  SG::ReadCondHandleKey<LArBadChannelCont> m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"};
  SG::ReadCondHandleKey<LArOnOffIdMapping>  m_cablingKey{this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"};
  SG::ReadCondHandleKey<LArCalibLineMapping>  m_CLKey{this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"};
  LArBadChannelMask m_bcMask;
  Gaudi::Property<std::vector<std::string> > m_problemsToPatch{this,"ProblemsToPatch",{}, "Bad-Channel categories to patch"};
  Gaudi::Property<std::vector<unsigned int> > m_doNotPatchCBs{this, "DoNotPatchCBs", {}, "Do not patch channels from this CalibBoard"};
 
 
  BooleanProperty m_useCorrChannel{this, "UseCorrChannels", true, "True: Use separate correction COOL channel, False: Correction + data in the same channel"};
  BooleanProperty m_patchAllMissing{this, "PatchAllMissing", false, "True: Patch missing calibration constants regardless of their bad-channel status"};
  BooleanProperty m_unlock{this, "Unlock", false, "Modify input container"};
  BooleanProperty m_isSC{this, "SuperCells", false, "Working on the SuperCells ?"};
 
  const LArOnlineID_Base* m_onlineHelper;
  const CaloCell_Base_ID* m_caloId;
 
  const CONDITIONSCONTAINER* m_contIn;  
  CONDITIONSCONTAINER* m_contOut;  
 
  patchMethod    m_patchMethod;
  StringProperty m_containerKey{this, "ContainerKey", "", "SG key of the LArConditionsContainer to be patched"};
  StringProperty m_newContainerKey{this, "NewContainerKey", "", "If the corrections go in a separate container put SG key here"};
  StringProperty m_patchMethodProp{this, "PatchMethod", "FEBNeighbor", "Method to patch conditions for channels with broken calibration line"};
 
  std::vector<HWIdentifier> m_idList;
 
};
 
#include "LArCalibPatchingAlg.icc"
 
#endif