TileHitToRawChannel.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//****************************************************************************
// Filename : TileHitToRawChannel.h
// Author   : UC-ATLAS TileCal group
// Created  : April 2002
//
// DESCRIPTION
// 
// To create TileRawChannel from TileHit
//
// Properties (JobOption Parameters):
//
//    TileHitContainer          string   Name of container with TileHit to read
//    TileRawChannelContainer   string   Name of CaloCellContainer to write
//    TileInfoName              string   Name of object in TDS with all parameters
//
// BUGS:
//  
// History:
//  
//  
//****************************************************************************
 
#ifndef TILESIMALGS_TILEHITTORAWCHANNEL_H
#define TILESIMALGS_TILEHITTORAWCHANNEL_H
 
// Tile includes
#include "TileEvent/TileHitContainer.h"
#include "TileEvent/TileRawChannelContainer.h"
#include "TileIdentifier/TileFragHash.h"
#include "TileIdentifier/TileRawChannelUnit.h"
#include "TileConditions/TileCondToolNoiseSample.h"
#include "TileConditions/TileEMScale.h"
#include "TileConditions/TileCablingSvc.h"
#include "TileConditions/TileSamplingFraction.h"
 
// Atlas includes
#include "AthenaBaseComps/AthAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
 
// Gaudi includes
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "CLHEP/Random/RandomEngine.h"
 
 
#include <string>
#include <vector>
 
 
class IAthRNGSvc;
class TileID;
class TileTBID;
class TileHWID;
class TileInfo;
class HWIdentifier;
class TileCablingService;
 
 
class TileHitToRawChannel: public AthAlgorithm {
  public:
 
    TileHitToRawChannel(const std::string& name, ISvcLocator* pSvcLocator); 
 
    virtual ~TileHitToRawChannel(); 
 
    virtual StatusCode initialize() override; 
    virtual StatusCode execute() override;    
    virtual StatusCode finalize() override;   
 
  private:
 
    SG::ReadHandleKey<TileHitContainer> m_hitContainerKey{this,"TileHitContainer","TileHitCnt",
                                                          "input Tile hit container key"};
 
    SG::WriteHandleKey<TileRawChannelContainer> m_rawChannelContainerKey{this,"TileRawChannelContainer",
                                                                         "TileRawChannelCnt",
                                                                         "Output Tile raw channel container key"};
    SG::ReadCondHandleKey<TileSamplingFraction> m_samplingFractionKey{this,
        "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};
 
 
    std::string m_infoName;             
    double m_deltaT;                    
    bool m_calibrateEnergy;             
 
    TileRawChannelUnit::UNIT m_rChUnit; 
    TileFragHash::TYPE m_rChType; 
 
    const TileID* m_tileID;   
    const TileTBID* m_tileTBID; 
    const TileHWID* m_tileHWID; 
    const TileInfo* m_tileInfo; 
    const TileCablingService* m_cabling;  
 
    std::vector<HWIdentifier *> m_all_ids; 
 
    bool m_tileNoise;    
    bool m_tileThresh;   
    double m_threshHi; 
    double m_ampMaxHi; 
 
    ServiceHandle<TileCablingSvc> m_cablingSvc{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};
 
    ServiceHandle<IAthRNGSvc> m_atRndmGenSvc{this, "RndmSvc", "AthRNGSvc", ""}; 
    Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "Tile_DigitsMaker", ""};
 
    SG::ReadCondHandleKey<TileEMScale> m_emScaleKey{this,
        "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"};
 
    ToolHandle<TileCondToolNoiseSample> m_tileToolNoiseSample{this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"};
 
};
 
#endif // TILESIMALGS_TILEHITTORAWCHANNEL_H