TileL2Builder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//****************************************************************************
// Filename : TileL2Builder.h
// Author   : Aranzazu Ruiz
// Created  : February 2009
//
// DESCRIPTION
//    TileL2 from TileRawChannel.
//
// BUGS:
//  
// History:
//  
//****************************************************************************
 
#ifndef TILEL2ALGS_TILEL2BUILDER_H
#define TILEL2ALGS_TILEL2BUILDER_H
 
// Tile includes
#include "TileEvent/TileContainer.h"
#include "TileEvent/TileRawChannelContainer.h"
#include "TileIdentifier/TileFragHash.h"
#include "TileConditions/TileEMScale.h"
#include "TileConditions/TileBadChannels.h"
 
// Athena includes
#include "AthenaBaseComps/AthAlgTool.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
 
// Gaudi includes
#include "GaudiKernel/ToolHandle.h"
 
// C++ STL includes
#include <string>
#include <vector>
 
// forward declarations
class TileHWID;
 
class TileL2Builder: public AthAlgTool {
 
  public:
 
    TileL2Builder(const std::string& type
                  , const std::string& name
                  , const IInterface* parent);
 
    virtual ~TileL2Builder() override;
 
    virtual StatusCode initialize() override;
 
    virtual StatusCode finalize() override;
 
    virtual StatusCode process(int fragmin, int fragmax, TileL2Container *l2Container) const;
    virtual StatusCode process(int fragmin, int fragmax, TileL2Container *l2Container, const EventContext& ctx) const;
 
    inline int indexToId(int i) const {
      return m_hashFunc.identifier(i);
    }
 
    inline int idToIndex(int id) const {
      return m_hashFunc(id);
    }
 
    // AlgTool InterfaceID
    static const InterfaceID& interfaceID();
 
    void MaskBad(int partition, float* E, int* gain, bool* bad) const;
 
    void MTagLB(int partition
                , int drawer
                , float* EMeV
                , std::vector<float> &EtaMuons
                , std::vector<float> &EMuons0
                , std::vector<float> &EMuons1
                , std::vector<float> &EMuons2
                , std::vector<unsigned int> &qf
                , std::vector<unsigned int> &extraWord) const;
 
    inline void MTagLB(int partition
                      , int drawer
                      , float* EMeV
                      , int* gain
                      , bool* bad
                      , std::vector<float> &EtaMuons
                      , std::vector<float> &EMuons0
                      , std::vector<float> &EMuons1
                      , std::vector<float> &EMuons2
                      , std::vector<unsigned int> &qf
                      , std::vector<unsigned int> &extraWord) const {
      MaskBad(partition, EMeV, gain, bad);
      MTagLB(partition, drawer, EMeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
    }
 
    void MTagEB(int partition
                , int drawer
                , float* EMeV
                , std::vector<float> &EtaMuons
                , std::vector<float> &EMuons0
                , std::vector<float> &EMuons1
                , std::vector<float> &EMuons2
                , std::vector<unsigned int> &qf
                , std::vector<unsigned int> &extraWord) const;
 
    inline void MTagEB(int partition
                      , int drawer
                      , float* EMeV
                      , int* gain
                      , bool* bad
                      , std::vector<float> &EtaMuons
                      , std::vector<float> &EMuons0
                      , std::vector<float> &EMuons1
                      , std::vector<float> &EMuons2
                      , std::vector<unsigned int> &qf
                      , std::vector<unsigned int> &extraWord) const {
      MaskBad(partition, EMeV, gain, bad);
      MTagEB(partition, drawer, EMeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
    }
 
    void SumE(int partition, int drawer, float * E, std::vector<float> &sumE) const;
    void SumE(int partition, int drawer, int unit, float* E, int* gain, std::vector<float> &sumE) const;
    inline void SumE(int partition
                    , int drawer
                    , int unit
                    , float* E
                    , int* gain
                    , bool* bad
                    , std::vector<float> &sumE) const {
      MaskBad(partition, E, gain, bad);
      SumE(partition, drawer, unit, E, gain, sumE);
    }
 
  protected:
 
    // properties
    SG::ReadHandleKey<TileRawChannelContainer> m_rawChannelContainerKey{this,"TileRawChannelContainer",
                                                                        "TileRawChannelCnt",
                                                                        "Input Tile raw channel container key"};
 
 
    float m_noiseThreshold;
    int m_noiseType;
 
    const TileHWID* m_tileHWID;
 
    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"};
 
 
    TileFragHash m_hashFunc;
 
    float m_sinTh[4][48];
    float m_sinThRound[4][48];
    float m_cosTh[4][48];
    float m_cosThRound[4][48];
    bool m_connected[4][48];
    int m_channelPairs[4][48];
};
 
#endif // TILEL2ALGS_TILEL2BUILDER_H