TileHitToTTL1.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//****************************************************************************
// Filename : TileHitToTTL1.h
// Author   : F. Merritt, UC-ATLAS TileCal group
// Created  : Feb 2003
//
// DESCRIPTION
// 
// Creates TileTTL1 Digits from TileHit
//
// Properties (JobOption Parameters):
//
//    TileHitContainer          string   Name of container with TileHit to read
//    TileTTL1Container         string   Name of container with TileTTL1Digits to write
//    TileInfoName              string   Name of object in TDS with all parameters
//
// BUGS:
//  
// History:
//  
//  
//****************************************************************************
 
#ifndef TILESIMALGS_TILEHITTOTTL1_H
#define TILESIMALGS_TILEHITTOTTL1_H
 
// Tile includes
#include "TileEvent/TileHitContainer.h"
#include "TileEvent/TileTTL1Container.h"
#include "TileConditions/TileEMScale.h"
#include "TileConditions/TileBadChannels.h"
#include "TileConditions/TileCablingSvc.h"
#include "TileConditions/TileSamplingFraction.h"
 
// Atlas includes
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
 
// Gaudi includes
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include <string>
 
class IAthRNGSvc;
class TileID;
class TileTBID;
class TileHWID;
class TileInfo;
class CaloLVL1_ID;
class TileCablingService;

class TileHitToTTL1: public AthReentrantAlgorithm {
  public:
 
    using AthReentrantAlgorithm::AthReentrantAlgorithm;
    virtual ~TileHitToTTL1() = default; 
 
    virtual StatusCode initialize() override; 
    virtual StatusCode execute(const EventContext &ctx) const override;    
    virtual StatusCode finalize() override;   
 
  private:
 
    Gaudi::Property<bool> m_maskBadChannels{this,
        "maskBadChannels", true, "If true then bad channels are masked"};
 
    Gaudi::Property<std::string> m_infoName{this,
        "TileInfoName", "TileInfo", "TileInfo object name"};
 
    Gaudi::Property<std::string> m_TileTTL1Type{this,
        "TileTTL1Type", "Standard", "Name of Trigger Type"};
 
    SG::ReadHandleKey<TileHitContainer> m_hitContainerKey{this,"TileHitContainer","TileHitCnt",
                                                          "input Tile hit container key"};
 
    SG::WriteHandleKey<TileTTL1Container> m_ttl1ContainerKey{this,"TileTTL1Container",
                                                             "TileTTL1Cnt",
                                                             "Output Tile TTL1 container key"};
 
    SG::WriteHandleKey<TileTTL1Container> m_mbtsTTL1ContainerKey{this,"TileMBTSTTL1Container",
                                                                 "TileTTL1MBTS",
                                                                 "Output Tile MBTS TTL1 container key"};

    SG::ReadCondHandleKey<TileSamplingFraction> m_samplingFractionKey{this,
        "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};
 
    bool m_cosmicsType{false};              
 
    const TileID* m_tileID{nullptr};   
    const TileTBID* m_tileTBID{nullptr}; 
    const TileHWID* m_tileHWID{nullptr}; 
    const TileInfo* m_tileInfo{nullptr}; 
    const CaloLVL1_ID* m_TT_ID{nullptr}; 
    const TileCablingService* m_cabling{nullptr}; 
 
 
    // Variables for the trigger towers
    int m_nSamples{0};     
    int m_iTrig{0};          
 
    // Variables for the MBTS
    int m_MBTSnSamples{0}; 
    int m_MBTSiTrig{0};      
 
    int m_lastTower{15};    
 
    bool m_tileNoise{false};   
    bool m_tileThresh{false};  

    ServiceHandle<TileCablingSvc> m_cablingSvc{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};
 
    ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""}; 
    Gaudi::Property<std::string> m_randomStreamName{this, "RandomStreamName", "Tile_HitToTTL1", ""};

    SG::ReadCondHandleKey<TileEMScale> m_emScaleKey{this,
        "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"};

    SG::ReadCondHandleKey<TileBadChannels> m_badChannelsKey{this,
        "TileBadChannels", "TileBadChannels", "Input Tile bad channel status"};
 
};
 
#endif // TILESIMALGS_TILEHITTOTTL1_H