TileHitVecToCntTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
//**************************************************************************
// Filename : TileHitVecToCntTool.h
// Author   : Vishnu Zutshi
// Created  : Dec. 2009
//
// DESCRIPTION
//
//    TileHitVecToCnt copies all TileHits from TileHitVector (AthenaHitsVector)
//    to TileHitContainer (identifiable container) without any corrections.
//    If pileup option is set, all hits are merged. The pileup is done bunchXing
//    by bunchXing (main difference from TileHitVecToCnt). If several hits have
//    the same ID, energy and time from all of them is stored in vectors
//    inside single TileHit.
//
// Properties (JobOption Parameters):
//
//    TileHitVectors            string   Name of TileHitVector to read
//    TileHitContainer          string   Name of TileHitContainer to write
//    TileInfoName              string   Name of object in TDS with all parameters
//    PileUp                    bool     Do or not pileup
//    HitTimeFlag               int      Working with hit times
//**************************************************************************
 
#ifndef TILESIMALGS_TILEHITVECTOCNTTOOL_H
#define TILESIMALGS_TILEHITVECTOCNTTOOL_H
 
// Tile includes
#include "TileIdentifier/TileFragHash.h"
#include "TileSimEvent/TileHitVector.h"
#include "TileEvent/TileHitContainer.h"
#include "TileEvent/TileHitNonConstContainer.h"
#include "TileConditions/TileCablingSvc.h"
#include "TileConditions/TileSamplingFraction.h"
 
// Athena includes
#include "PileUpTools/PileUpToolBase.h"
#include "StoreGate/WriteHandleKey.h"
#include "AthenaKernel/IAthRNGSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "CommissionEvent/CosTrigTime.h"
#include "AthContainers/OwnershipPolicy.h"
// Pile up
#include "PileUpTools/PileUpMergeSvc.h"
 
// Gaudi includes
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/SystemOfUnits.h"
#include <memory>
 
// Avoid pushing dependencies into clients- just fwd declare the following:
 
class TileID;
class TileTBID;
class TileHWID;
class TileHit;
class TileDetDescrManager;
class Identifier;
class TileCablingService;
class TileHitCollection;
 
 
namespace CLHEP {
  class HepRandomEngine;
}
 
// C++ STL includes
#include <string>
#include <vector>
 
class TileHitVecToCntTool: public PileUpToolBase {
 
public:
  TileHitVecToCntTool(const std::string& type, const std::string& name, const IInterface* parent); 
  StatusCode initialize() override final;
  virtual StatusCode prepareEvent(const EventContext& ctx, unsigned int /*nInputEvents*/) override final;
  virtual StatusCode mergeEvent(const EventContext& ctx) override final;
  virtual StatusCode processBunchXing(int bunchXing,
                                      SubEventIterator bSubEvents,
                                      SubEventIterator eSubEvents) override final;
  virtual StatusCode processAllSubEvents(const EventContext& ctx) override final;
  virtual StatusCode processAllSubEvents(const EventContext& ctx) const;
  StatusCode finalize() override final;
 
private:
  StatusCode createContainers();
  void processHitVectorForOverlay(const TileHitVector* inputHits, std::unique_ptr<TileHitNonConstContainer>& hits, int& nHit, double& eHitTot) const;
  void processHitVectorForPileUp(const TileHitVector* inputHits, double SubEvtTimOffset, std::vector<std::unique_ptr<TileHit>>& allHits,
                                 std::vector<std::unique_ptr<TileHit>>& allHits_DigiHSTruth, int& nHit, double& eHitTot, bool isSignal = false) const;
  void processHitVectorWithoutPileUp(const TileHitVector* inputHits, int& nHit, double& eHitTot, TileHitNonConstContainer* hitCont, CLHEP::HepRandomEngine * engine) const;
  // Method to apply photostatistics effect
  double applyPhotoStatistics(double energy, Identifier pmt_id, CLHEP::HepRandomEngine* engine, const TileSamplingFraction* samplingFraction, int drawerIdx) const;
  void findAndMergeE1(TileHitCollection* coll, int frag_id, TileHitNonConstContainer* hitCont) const;
  void findAndMergeMBTS(TileHitCollection* coll, int frag_id, TileHitNonConstContainer* hitCont) const;
  void findAndMergeMultipleHitsInChannel(std::unique_ptr<TileHitNonConstContainer>& hitCont) const;
  void mergeExtraHitToChannelHit(TileHit* extraHit, TileHit* channelHit) const;
  void putAllHitsInContainer(std::vector<std::unique_ptr<TileHit>>& allHits,
                              std::vector<std::unique_ptr<TileHit>>& allHits_DigiHSTruth,
                              std::unique_ptr<TileHitNonConstContainer>& hits,
                              std::unique_ptr<TileHitNonConstContainer>& hits_DigiHSTruth,
                              SG::OwnershipPolicy ownPolicy) const;
  StatusCode commitContainers(const EventContext& ctx,
                              std::unique_ptr<TileHitNonConstContainer>& hits,
                              std::unique_ptr<TileHitNonConstContainer>& hits_DigiHSTruth,
                              SG::OwnershipPolicy ownPolicy) const;
  void prepareAllHits(std::vector<std::unique_ptr<TileHit>>& allHits) const;
 
 
  Gaudi::Property<bool> m_onlyUseContainerName{this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."};
  StringArrayProperty m_inputKeys{this, "TileHitVectors", {"TileHitVec"},
      "Name of input hit vectors (default=TileHitVec)" };  
  SG::ReadHandleKeyArray<TileHitVector> m_hitVectorKeys{this, "TileHitVectorKeys", {}, "Do not set manually!"};
  std::vector<std::string> m_hitVectorNames{};
 
  SG::WriteHandleKey<TileHitContainer> m_hitContainerKey{this,"TileHitContainer","TileHitCnt",
      "Output Tile hit container key"};
 
  SG::WriteHandleKey<TileHitContainer> m_hitContainer_DigiHSTruthKey{this,"TileHitContainer_DigiHSTruth","TileHitCnt_DigiHSTruth",
      "Output DigiHSTruth Tile hit container key"};
 
  SG::ReadCondHandleKey<TileSamplingFraction> m_samplingFractionKey{this,
      "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};
 
  bool m_run2{false};                                
  bool m_run2plus{false};                            
  Gaudi::Property<bool> m_pileUp{this, "PileUp", false,
      "To switch on pileup (default=false)"}; 
  Gaudi::Property<double> m_deltaT{this, "DeltaT", 1.0*Gaudi::Units::nanosecond,
      "Minimal Time granularity in TileHit (default=1ns)"}; 
  Gaudi::Property<int> m_timeFlag{this, "HitTimeFlag", 0,
      "Special options to deal with times of hits for cosmics and TB (default=0)"}; 
  Gaudi::Property<double> m_triggerTime{this, "TriggerTime", 0.0,
      "Fixed trigger time value (default=0)"}; 
  Gaudi::Property<double> m_maxHitTime{this, "MaxHitTime", 150.5*Gaudi::Units::nanosecond,
      "All sub-hits with time above m_maxHitTime will be ignored"}; 
  Gaudi::Property<double> m_photoStatisticsWindow{this, "PhotostatWindow", 62.5*Gaudi::Units::nanosecond,
      "Sum up energy in [-m_photoStatWindow,+m_photoStatWindow] and use it for photostatistics"}; 
  Gaudi::Property<int> m_photoElectronStatistics{this, "PhotostatType", 2,
      "Method to apply photostatistics (default=2)"}; 
  Gaudi::Property<bool> m_skipNoHit{this, "SkipNoHit", false,
      "Skip events with no Tile hits (default=false)"}; 
  Gaudi::Property<bool> m_rndmEvtOverlay{this, "RndmEvtOverlay", false,
      "Pileup and/or noise added by overlaying random events (default=false)"}; 
  Gaudi::Property<bool> m_useTriggerTime{this, "UseTriggerTime", false,
      "Take trigger time from external tool (default=false)"}; 
  Gaudi::Property<bool> m_doDigiTruth{this, "DoHSTruthReconstruction", false,
      "DigiTruth reconstruction"};                       
  Gaudi::Property<bool> m_usePhotoStatistics{this,
      "usePhotoStatistics", true, "Simulate photo statistics effect (default=true)"};
  Gaudi::Property<bool> m_mergeMultipleHitsInChannel{this, "MergeMultipleHitsInChannel", true,
      "Find and merge multiple hits for the same channel in container (default=true)"};
  SG::ReadHandleKey<CosTrigTime> m_triggerTimeKey{this,"CosTimeKey", "", "To take the trigger time from"};
  ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};
 
  const TileID* m_tileID{nullptr};              
  const TileTBID* m_tileTBID{nullptr};          
  const TileHWID* m_tileHWID{nullptr};          
 
  ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};     
  Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "Tile_HitVecToCnt", ""};
 
  std::vector<std::unique_ptr<TileHit>> m_allHits;           
  std::vector<std::unique_ptr<TileHit>> m_allHits_DigiHSTruth;           
  std::unique_ptr<TileHitNonConstContainer> m_hits{};          
  std::unique_ptr<TileHitNonConstContainer> m_hits_DigiHSTruth{};   
 
  int m_mbtsOffset{0};                           //<! index of first MBTS hit in m_allHits vector
  static const int N_SIDE = 2;
  static const int N_PHI = 8;
  static const int N_ETA = 2;
  static const int N_MBTS_CELLS = N_SIDE * N_PHI * N_ETA;
  inline int mbts_index(int side, int phi, int eta) const {
    return (side * N_PHI + phi) * N_ETA + eta + m_mbtsOffset;
  }
  static const int E4_SIDE = -1;
  static const int E4_ETA  = 2;
  static const int E4_N_PHI = 4;
  static const int N_E4PRIME_CELLS = E4_N_PHI;
  inline int e4pr_index(int phi) const {
    return  phi + N_MBTS_CELLS + m_mbtsOffset;
  }
 
  ServiceHandle<TileCablingSvc> m_cablingSvc{this, "TileCablingSvc", "TileCablingSvc", ""};
  const TileCablingService* m_cabling{};
  TileFragHash m_fragHashFunc;
  std::vector<bool> m_E1merged;
  std::vector<bool> m_MBTSmerged;
  enum CELL_TOWER{E1_TOWER = 10};
};
 
#endif // TILESIMALGS_TILEHITVECTOCNTTOOL_H