TileRawChannelBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TILERECUTILS_ITILERAWCHANNELBUILDER_H
#define TILERECUTILS_ITILERAWCHANNELBUILDER_H
 
/********************************************************************
 *
 * NAME:     TileRawChanelBuilder
 * PACKAGE:  offline/TileCalorimeter/TileRecUtils
 *
 * AUTHOR :  K. Gellerstedt
 * CREATED:  Nov 17 2003
 *
 * PURPOSE:  Interface for builder algorithms
 *
 *  Input: TileDigitsContainer
 *  Output: Container with TileRawChannels
 *  Parameters:
 *    TileRawChannelContainer - Name of output container
 *   
 ********************************************************************/
 
// Tile includes
#include "TileIdentifier/TileFragHash.h"
#include "TileIdentifier/TileRawChannelUnit.h"
#include "TileEvent/TileMutableRawChannelContainer.h"
#include "TileEvent/TileRawChannelContainer.h"
#include "TileEvent/TileDigitsCollection.h"
#include "TileEvent/TileDQstatus.h"
#include "TileRecUtils/ITileRawChannelTool.h"
#include "TileConditions/TileCondToolEmscale.h"
#include "TileConditions/TileCondToolTiming.h"
#include "TileConditions/TileCondIdTransforms.h"
#include "TileConditions/TileCablingSvc.h"
 
// Atlas includes
#include "AthenaBaseComps/AthAlgTool.h"
 
//Gaudi includes
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
#include "StoreGate/WriteHandleKey.h"
 
#include <utility>
#include <vector>
#include <memory>
 
class TileDigits;
class TileRawChannel;
class TileID;
class TileHWID;
class TileInfo;
class StoreGateSvc;
 
typedef std::vector<std::pair<TileRawChannel*, const TileDigits*> > Overflows_t;
 
class TileRawChannelBuilder: public AthAlgTool {
  public:
    TileRawChannelBuilder(const std::string& type, const std::string& name,
        const IInterface* parent);
 
    virtual ~TileRawChannelBuilder();
 
    // Algorithm tool virtual methods
    virtual StatusCode initialize();
    //virtual StatusCode execute();
    virtual StatusCode finalize();
 
    virtual StatusCode createContainer(const EventContext& ctx);
 
    virtual TileRawChannel* rawChannel(const TileDigits* digits, const EventContext& ctx);
 
    virtual StatusCode commitContainer(const EventContext& ctx);
 
    void initLog(const EventContext& ctx);
    void endLog();
 
    // process all digits from one collection and store results in internal container
    StatusCode build (const TileDigitsCollection* collection, const EventContext& ctx);
 
    static const InterfaceID& interfaceID();
 
    static double correctAmp(double phase, bool of2 = true); 
 
    static double correctTime( double phase, bool of2 = true); 
 
    static int CorruptedData(int ros, int drawer, int channel, int gain,
                 const std::vector<float> & digits, float &dmin, float &dmax, float ADCmaxMinusEps, float ADCmaskValueMinusEps);
 
    static const char* BadPatternName(float ped);
 
    void resetDrawer();
    void resetOverflows(void);
    Overflows_t& getOverflowedChannels(void);
    std::string getTileRawChannelContainerID(void);
 
  protected:
    // FIXME: Get rid of this abomination.
    friend class TileHid2RESrcID;
 
    // properties
    // DQ status.
    SG::ReadHandleKey<TileDQstatus> m_DQstatusKey{this, "TileDQstatus", 
                                                  "TileDQstatus", 
                                                  "TileDQstatus key"};
 
    // DSP container.  Only used of m_useDSP is set.
    SG::ReadHandleKey<TileRawChannelContainer> m_DSPContainerKey
      {this, "DSPContainer", "",  "DSP Container key"};
 
  // name of TDS container with output TileRawChannels
    SG::WriteHandleKey<TileRawChannelContainer> m_rawChannelContainerKey{this,"TileRawChannelContainer","TileRawChannelFiltered",
                                                                         "Output Tile raw channels container key"};
 
    // RawChannelContainer
    std::unique_ptr<TileMutableRawChannelContainer> m_rawChannelCnt;
 
    // parameters for RawChannelContainer
    TileFragHash::TYPE m_rChType;
    TileRawChannelUnit::UNIT m_rChUnit;
    unsigned int m_bsflags;
    // parameter to determine which sample to start with the analysis
    int m_firstSample;
    // Should energy be calibrated
    bool m_calibrateEnergy;
 
    // Should time be calibrated (delta added from laser run)
    bool m_correctTime;
 
 
    // Use DSP noise correction for incomplete containers
    bool m_useDSP;
 
    // thresholds for parabolic amplitude correction (used in optimal filter without iterations)
    float m_ampMinThresh;   
    float m_timeMinThresh;   
    float m_timeMaxThresh;   
 
    // runType used to override value of trigType in event
    int m_runType;
 
    // Tile objects
    const TileID* m_tileID;
    const TileHWID* m_tileHWID;
 
    ToolHandleArray<ITileRawChannelTool> m_noiseFilterTools{this,
        "NoiseFilterTools", {}, "Tile noise filter tools"};
 
    ToolHandle<TileCondToolEmscale> m_tileToolEmscale{this,
        "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"};
 
    ToolHandle<TileCondToolTiming> m_tileToolTiming{this,
        "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"};
 
    ToolHandle<TileCondIdTransforms> m_tileIdTransforms{this,
        "TileCondIdTransforms", "TileCondIdTransforms",
        "Tile tool to tranlate hardware identifier to the drawerIdx, channel, and adc"};
 
    ServiceHandle<TileCablingSvc> m_cablingSvc{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};
 
    const TileCablingService* m_cabling; 
 
    Gaudi::Property<std::vector<int>> m_demoFragIDs{this,
          "DemoFragIDs", {}, "List of Tile frag IDs with new electronics (demonstrator)"};
 
    int m_trigType;
    bool m_idophys;   // Phys fitting
    bool m_idolas; // Laser fitting
    bool m_idoped; // Ped run, phys fitting
    bool m_idocis; // CIS fitting
    int m_cischan; // which channel is fired by CIS
    double m_capdaq; // Capacitor
 
    unsigned int m_evtCounter;
    unsigned int m_chCounter;
 
    int m_nChL;
    int m_nChH;
    double m_RChSumL;
    double m_RChSumH;
 
    Overflows_t m_overflows;
    int m_dataPoollSize;
 
    static const int MAX_CHANNELS = 48;
    static const int MAX_DMUS = 16;
    int m_error[MAX_CHANNELS];
    int m_lastDrawer = -1;
    bool m_badDrawer = false;
    
    bool m_notUpgradeCabling;
 
    // TileInfo
    std::string m_infoName;
    const TileInfo* m_tileInfo;
    int m_i_ADCmax;
    float m_f_ADCmax;
    int m_i_ADCmaxPlus1;
    float m_f_ADCmaxPlus1;
    float m_ADCmaxMinusEps;
    float m_ADCmaskValueMinusEps; 
 
private:
    // find all bad patterns in a drawer and fill internal static arrays
    void fill_drawer_errors(const EventContext& ctx,
                            const TileDigitsCollection* collection);
 
};
 
#endif