SimpleEventDisplay.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_TPC_SIMPLEEVENTDISPLAY_H_
#define ALICEO2_TPC_SIMPLEEVENTDISPLAY_H_
 
 
#include "TH1.h"
 
#include "TPCBase/CalDet.h"
#include "TPCBase/CRU.h"
#include "TPCCalibration/CalibRawBase.h"
 
class TH2D;
class TH2Poly;
 
namespace o2
{
namespace tpc
{
 
class Mapper;
class SimpleEventDisplay : public CalibRawBase
{
 public:
  SimpleEventDisplay();
 
  ~SimpleEventDisplay() override = default;
 
  Int_t updateROC(const Int_t roc, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final;
 
  Int_t updateCRU(const CRU& cru, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final { return 0; }
 
  void updateSectorHists();
 
  CalPad* getCalPadMax() { return &mPadMax; }
 
  CalPad* getCalPadOccupancy() { return &mPadOccupancy; }
 
  void setSelectedSector(Int_t selectedSector) { mSelectedSector = selectedSector; }
 
  void setLastSector(Int_t lastSector) { mLastSector = lastSector; }
 
  void setLastSelSector(Int_t lastSelSector) { mLastSelSector = lastSelSector; }
 
  void setPedstals(CalPad* pedestals) { mPedestals = pedestals; }
 
  void setSignalThreshold(Int_t signalThreshold) { mSignalThreshold = signalThreshold; }
 
  void setShowOccupancy(bool showOccupancy) { mShowOccupancy = showOccupancy; }
 
  TH1D* makePadSignals(Int_t roc, Int_t row, Int_t pad);
 
  TH2D* getSigIROC() const { return mHSigIROC; }
  TH2D* getSigOROC() const { return mHSigOROC; }
 
  void fillSectorHistSingleTimeBin(TH2Poly* h, Int_t timeBin);
 
  void setTimeBinRange(int firstBin, int lastBin)
  {
    mFirstTimeBin = firstBin;
    mLastTimeBin = lastBin;
    initHistograms();
  }
 
  Int_t getFirstTimeBin() const { return mFirstTimeBin; }
  Int_t getLastTimeBin() const { return mLastTimeBin; }
 
  void endEvent() final {};
 
 private:
  CalPad mPadMax;       
  CalPad mPadOccupancy; 
  TH2D* mHSigIROC;      
  TH2D* mHSigOROC;      
  CalPad* mPedestals;   
 
  Int_t mCurrentChannel;  
  Int_t mCurrentROC;      
  Int_t mLastSector;      
  Int_t mSelectedSector;  
  Int_t mLastSelSector;   
  Int_t mCurrentRow;      
  Int_t mCurrentPad;      
  Float_t mMaxPadSignal;  
  Int_t mMaxTimeBin;      
  Bool_t mSectorLoop;     
  Int_t mFirstTimeBin;    
  Int_t mLastTimeBin;     
  Int_t mSignalThreshold; 
  Bool_t mShowOccupancy;  
 
  const Mapper& mTPCmapper; 
 
  void resetEvent() final;
  void initHistograms();
};
 
} // namespace tpc
 
} // namespace o2
#endif