d4/da3/TileAANtuple_8h_source.html

/*

  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration

*/


//****************************************************************************

//****************************************************************************

#ifndef TILEREC_TILEAANTUPLE_H

#define TILEREC_TILEAANTUPLE_H


// Tile includes

#include "TileConditions/TileCablingService.h"

#include "TileConditions/TileCablingSvc.h"

#include "TileIdentifier/TileRawChannelUnit.h"

#include "TileEvent/TileLaserObject.h"

#include "TileEvent/TileMuonReceiverContainer.h"

#include "TileEvent/TileRawChannelContainer.h"

#include "TileEvent/TileDQstatus.h"

#include "TileEvent/TileBeamElemContainer.h"

#include "TileConditions/ITileDCSTool.h"

#include "TileByteStream/TileHid2RESrcID.h"


// Athena includes

#include "AthenaBaseComps/AthAlgorithm.h"

#include "StoreGate/ReadHandleKey.h"

#include "ByteStreamCnvSvcBase/IROBDataProviderSvc.h"


// Gauid includes

#include "GaudiKernel/ToolHandle.h"

#include "GaudiKernel/ServiceHandle.h"

#include "GaudiKernel/IFileMgr.h"


#include <string>

#include <stdint.h>


#define N_ROS 4

#define N_ROS2 8

#define N_MODULES 64

#define N_DRAWERS 256

#define N_DMUS 16

#define N_CHANS 48

#define N_SAMPLES 7

#define N_RODS 129

#define N_CISPAR 110

#define N_TMDBCHANS 8 // 4 in EB and 8 in B

#define N_TMDBDECISIONS 4


class TTree;


class TileID;

class TileHWID;

class TileInfo;

class TileDetDescrManager;

class TileBeamElemContByteStreamCnv;

class ITileBadChanTool;

class TileCondToolEmscale;

class TileL2Builder;

class ITHistSvc;


class TileAANtuple : public AthAlgorithm {

  public:

    //Constructor

    TileAANtuple(const std::string& name, ISvcLocator* pSvcLocator);


    //Destructor

    virtual ~TileAANtuple();


    //Gaudi Hooks

    StatusCode ntuple_initialize(const EventContext& ctx,

                                 const TileDQstatus& DQstatus);

    StatusCode ntuple_clear();

    StatusCode initialize();

    StatusCode execute();

    StatusCode finalize();


  private:


    StatusCode storeRawChannels(const EventContext& ctx

                                 , const SG::ReadHandleKey<TileRawChannelContainer>& containerKey

                                , float ene[N_ROS2][N_MODULES][N_CHANS]

                                , float time[N_ROS2][N_MODULES][N_CHANS]

                                , float chi2[N_ROS2][N_MODULES][N_CHANS]

                                , float ped[N_ROS2][N_MODULES][N_CHANS]

                                , bool fillAll);


    StatusCode storeMFRawChannels(const EventContext& ctx

                                  , const SG::ReadHandleKey<TileRawChannelContainer>& containerKey

                                  , float * ene

                                  , float * time

                                  , float chi2[N_ROS2][N_MODULES][N_CHANS]

                                  , float ped[N_ROS2][N_MODULES][N_CHANS]

                                  , bool fillAll);


    StatusCode storeDigits(const EventContext& ctx

                           , const SG::ReadHandleKey<TileDigitsContainer>& containerKey

                           , short * sample

                           , short gain[N_ROS2][N_MODULES][N_CHANS]

                           , bool fillAll);


    StatusCode storeTMDBDecision(const EventContext& ctx);

    StatusCode storeTMDBDigits(const EventContext& ctx);

    StatusCode storeTMDBRawChannel(const EventContext& ctxx);


    StatusCode storeBeamElements(const TileDQstatus& DQstatus);

    StatusCode storeLaser(const EventContext& ctx);

    StatusCode storeDCS();


    StatusCode initNTuple(const EventContext& ctx);


    void fillCellMap(TTree* ntuplePtr);


    void TRIGGER_addBranch(void);

    void LASER_addBranch(void);

    void CISPAR_addBranch(void);

    void DIGI_addBranch(void);

    void DCS_addBranch(void);

    void TMDB_addBranch(void);


    void TRIGGER_clearBranch(void);

    void LASER_clearBranch(void);

    void CISPAR_clearBranch(void);

    void DIGI_clearBranch(void);

    void TMDB_clearBranch(void);


    inline int digiChannel2PMT(int fragType, int chan) {

      return (abs(m_cabling->channel2hole(fragType, chan)) - 1);

    }


    inline short CheckDMUFormat(uint32_t header) {

      if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))

        return 0; // no error

      else

        return 1; //error

    }


    inline short CheckDMUParity(uint32_t header) {

      uint32_t parity(0);

      for (int i = 0; i < 32; ++i)

        parity += header >> i & 0x1;


      if ((parity % 2) == 1)

        return 0; //no error

      else

        return 1; //error

    }


    int m_evtNr;


    // Trigger items

    int m_evTime;

    int m_run;

    int m_evt;

    int m_lumiBlock;

    int m_HHMMSS;

    char m_dateTime[32];

    int m_trigType;

    uint32_t m_dspFlags;


    int m_l1ID[N_RODS];

    int m_l1Type[N_RODS];

    int m_evBCID[N_RODS];

    int m_evType[N_RODS];


    // Cispar

    uint32_t m_cispar[N_CISPAR];


    // Laser items

    int m_las_version;

    int m_las_BCID;


    int m_las_Filt;

    float m_las_ReqAmp;

    float m_las_MeasAmp;

    float m_las_Temperature;


    struct Arrays {

      // LASERI

      int   m_las_D_ADC[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_Ped[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_Ped_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_Alpha[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_Alpha_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_AlphaPed[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};

      float m_las_D_AlphaPed_RMS[TileLaserObject::nbGains][TileLaserObject::nbDiodes] = {{0}};


      int   m_las_PMT_ADC[TileLaserObject::nbGains][TileLaserObject::nbPmts] = {{0}};

      int   m_las_PMT_TDC[TileLaserObject::nbGains][TileLaserObject::nbPmts] = {{0}};

      float m_las_PMT_Ped[TileLaserObject::nbGains][TileLaserObject::nbPmts] = {{0}};

      float m_las_PMT_Ped_RMS[TileLaserObject::nbGains][TileLaserObject::nbPmts] = {{0}};


      // LASERII

      int m_chan[32] = {0};             // Mean value for monitoring diodes, PMTs, phocal, CIS

      float m_chan_Ped[32] = {0};       // Corresponding pedestal values

      float m_chan_Led[32] = {0};       // Corresponding LED values

      float m_chan_Lin[32] = {0};       // Corresponding linearity values

      float m_chan_Alpha[32] = {0};     // Corresponding alpha peaks

      float m_chan_SPed[32] = {0};      // Sigma of pedestal values

      float m_chan_SLed[32] = {0};      // Sigma of LED values

      float m_chan_SLin[32] = {0};      // Sigma of linearity values

      float m_chan_SAlpha[32] = {0};    // Sigma of alpha peaks


      // Digi/Energy items


      short * m_sampleFlt = 0;

      short m_gainFlt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      short * m_sample = 0;

      short m_gain[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      short m_rodBCID[N_ROS][N_MODULES] = {{0}};

      short m_fragSize[N_ROS][N_MODULES] = {{0}};

      uint16_t m_dmuMask[N_ROS][N_MODULES][2] = {{{0}}};

      uint16_t m_slinkCRC[N_ROS][N_MODULES][2] = {{{0}}};


      uint32_t m_DMUheader[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUbcid[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUformatErr[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUparityErr[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUmemoryErr[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUDstrobeErr[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_DMUSstrobeErr[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_feCRC[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};

      short m_rodCRC[N_ROS2][N_MODULES][N_DMUS] = {{{0}}};


      float m_ene[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_time[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_ped[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedFit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2Fit[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedFitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2Fitc[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedOpt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2Opt[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedQIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2QIE[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedOF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2OF1[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedDsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2Dsp[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float * m_eMF = 0;

      float * m_tMF = 0;

      float m_chi2MF[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedMF[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      float m_eWiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_tWiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_pedWiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};

      float m_chi2Wiener[N_ROS2][N_MODULES][N_CHANS] = {{{0}}};


      short m_ROD_GlobalCRC[N_ROS][N_MODULES] = {{0}};

      short m_ROD_BCID[N_ROS][N_MODULES] = {{0}};

      short m_ROD_DMUBCIDErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUmemoryErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUSstrobeErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUDstrobeErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUHeadformatErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUHeadparityErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUDataformatErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUDataparityErr[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUfeCRC[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      short m_ROD_DMUrodCRC[N_ROS][N_MODULES][N_DMUS] = {{{0}}};

      uint16_t m_ROD_DMUMask[N_ROS][N_MODULES][2] = {{{0}}};


      float m_eTMDB[N_ROS][N_MODULES][N_TMDBCHANS] = {{{0}}}; // TMDB

      unsigned char *m_sampleTMDB = 0;

      unsigned char m_decisionTMDB[N_ROS][N_MODULES][N_TMDBDECISIONS] = {{{0}}}; // TMDB

      unsigned char m_bcidTMDB[N_ROS][N_MODULES][3] = {{{0}}};


      float m_TEMP[4][64][7] = {{{0}}};

      float m_HV[4][64][48] = {{{0}}};

      float m_HVSET[4][64][48] = {{{0}}};

      int m_DRSTATES[4][64] = {{0}};

      short m_HVSTATUS[4][64][48] = {{{0}}};

      short m_DRSTATUS[4][64] = {{0}};

      short m_CHSTATUS[4][64][48] = {{{0}}};

    };

    std::unique_ptr<Arrays> m_arrays;


    bool m_qdctimeout;

    bool m_tdctimeout;

    int m_daqtype;

    int m_nBadDr;

    int m_nBadHV;

    int m_nBadDCS;

    int m_nBadDB;

    int m_nBadTotal;


    int m_nSamples=0;

    bool m_reduced;

    int m_compressSettings;


    // jobOptions parameters - container names

    SG::ReadHandleKey<TileDigitsContainer> m_digitsContainerKey;

    SG::ReadHandleKey<TileDigitsContainer> m_fltDigitsContainerKey;

    SG::ReadHandleKey<TileBeamElemContainer> m_beamElemContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_rawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_fitRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_fitcRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_optRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_qieRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_dspRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_mfRawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_of1RawChannelContainerKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_wienerRawChannelContainerKey;

    SG::ReadHandleKey<TileLaserObject> m_laserObjectKey;

    SG::ReadHandleKey<TileRawChannelContainer> m_tileMuRcvRawChannelContainerKey; // TMDB

    SG::ReadHandleKey<TileDigitsContainer> m_tileMuRcvDigitsContainerKey; // TMDB

    SG::ReadHandleKey<TileMuonReceiverContainer> m_tileMuRcvContainerKey; // TMDB

    SG::ReadHandleKey<TileL2Container> m_l2CntKey;


   // other jobOptions parameters

    bool m_calibrateEnergy;

    bool m_useDspUnits;

    bool m_bsInput;

    bool m_pmtOrder;

    int m_finalUnit;

    bool m_calibMode;

    bool m_compareMode;

    bool m_checkDCS;

    int m_DCSBranches;


    // energy units

    TileRawChannelUnit::UNIT m_rchUnit;

    TileRawChannelUnit::UNIT m_dspUnit;


    // NTuple parameters

    std::string m_streamName;

    std::string m_ntupleID;

    int64_t m_treeSize;


    // The ntuple

    TTree* m_ntuplePtr;

    TTree* m_DCSntuplePtr;


    // handle to THistSvc

    ServiceHandle<ITHistSvc> m_thistSvc;

    ServiceHandle<IFileMgr>  m_fileMgr{this,

       "FileMgr", "FileMgr", "The File manager service" };


    // Identifiers

    const TileID* m_tileID;

    const TileHWID* m_tileHWID;


    // Various tools

    const TileCablingService* m_cabling;

    const TileDetDescrManager* m_tileMgr;


    ToolHandle<ITileBadChanTool> m_tileBadChanTool;


    ToolHandle<TileCondToolEmscale> m_tileToolEmscale;


    ToolHandle<ITileDCSTool> m_tileDCS{this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"};


    // variables to check SumEt in frag5

    ToolHandle<TileL2Builder> m_l2Builder;  //<! Pointer to TileL2Builder

    float m_sumEt_xx[N_DRAWERS];

    float m_sumEz_xx[N_DRAWERS];

    float m_sumE_xx[N_DRAWERS];

    float m_sumEt_yy[N_DRAWERS];

    float m_sumEz_yy[N_DRAWERS];

    float m_sumE_yy[N_DRAWERS];

    float m_sumEt_zz[N_DRAWERS];

    float m_sumEz_zz[N_DRAWERS];

    float m_sumE_zz[N_DRAWERS];

    bool m_bad[N_ROS][N_MODULES][N_CHANS];


    int m_skipEvents;


    std::vector<uint32_t> m_ROBID;


    ServiceHandle<TileCablingSvc> m_cablingSvc{ this,

       "TileCablingSvc", "TileCablingSvc", "The Tile cabling service" };


    ServiceHandle<IROBDataProviderSvc>  m_robSvc{this,

       "ROBDataProviderSvc", "ROBDataProviderSvc", "The ROB data provider service" };


    SG::ReadHandleKey<TileDQstatus> m_DQstatusKey{ this,

       "TileDQstatus", "TileDQstatus", "TileDQstatus key" };


   SG::ReadCondHandleKey<TileHid2RESrcID> m_hid2RESrcIDKey{this,

       "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"};

};


#endif // TILEREC_TILEAANTUPLE_H