AliEmcalTriggerMakerKernel.h

Go to the documentation of this file.

#ifndef ALIEMCALTRIGGERMAKERKERNEL_H
#define ALIEMCALTRIGGERMAKERKERNEL_H
/* Copyright(c) 1998-2015, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

#include <set>
#include <iostream>
#include <vector>

#include <TObject.h>
#include <TArrayF.h>
//#include <AliEMCALTriggerPatchInfoV1.h>

class TF1;
class TObjArray;
class AliEMCALTriggerPatchInfo;
class AliEMCALTriggerRawPatch;
class AliEMCALGeometry;
class AliVCaloCells;
class AliVCaloTrigger;
class AliVEvent;
class AliVVZERO;
class AliEMCALTriggerBitConfig;
template<class T> class AliEMCALTriggerDataGrid;
template<class T> class AliEMCALTriggerAlgorithm;
template<class T> class AliEMCALTriggerPatchFinder;

// To be moved to AliRoot in AliEMCALTriggerConstants.h at the first occasion
namespace EMCALTrigger {
const Double_t kEMCL0ADCtoGeV_AP = 0.018970588*4;  // 0.075882352;             ///< Conversion from EMCAL Level0 ADC to energy
}

class AliEmcalTriggerMakerKernel : public TObject {
public:

  enum ELevel0TriggerStatus_t { kNotLevel0, kLevel0Candidate, kLevel0Fired };

  AliEmcalTriggerMakerKernel();

  virtual ~AliEmcalTriggerMakerKernel();

  void Init();

  void CreateTriggerPatches(const AliVEvent *inputevent, std::vector<AliEMCALTriggerPatchInfo> &outputcont, Bool_t useL0amp=kFALSE);

  const std::set<Short_t> &GetListOfBadFastORAbsIDs() const { return fBadChannels; }

  const std::set<Short_t> &GetListOfOfflineBadCellAbsIDs() const { return fOfflineBadChannels; }

  void SetTriggerThresholdJetLow   ( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[2][0] = a; fThresholdConstants[2][1] = b; fThresholdConstants[2][2] = c; }
  void SetTriggerThresholdJetHigh  ( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[0][0] = a; fThresholdConstants[0][1] = b; fThresholdConstants[0][2] = c; }
  void SetTriggerThresholdGammaLow ( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[3][0] = a; fThresholdConstants[3][1] = b; fThresholdConstants[3][2] = c; }
  void SetTriggerThresholdGammaHigh( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[1][0] = a; fThresholdConstants[1][1] = b; fThresholdConstants[1][2] = c; }
  void SetBackgroundThreshold(Int_t t)                           { fBkgThreshold             = t; }
  void SetL0Threshold(Int_t t)                                   { fL0Threshold              = t; }

  double GetL0TriggerChannelAmplitude(Int_t col, Int_t row) const;

  double GetTriggerChannelADC(Int_t col, Int_t row) const;

  double GetTriggerChannelEnergyRough(Int_t col, Int_t row) const;

  double GetTriggerChannelADCSimple(Int_t col, Int_t row) const;

  double GetTriggerChannelEnergy(Int_t col, Int_t row) const;

  double GetTriggerChannelEnergySmeared(Int_t col, Int_t row) const;

  double GetDataGridDimensionRows() const;

  void SetIsMC(Bool_t isMC) { fIsMC = isMC; }

  void SetGeometry(const AliEMCALGeometry *const geo) { fGeometry = geo; }

  void SetTriggerBitConfig(const AliEMCALTriggerBitConfig *const config);

  void SetL0TimeRange(Int_t min, Int_t max) { fL0MinTime = min; fL0MaxTime = max; }

  void SetFastORandCellThresholds(Int_t l0, Int_t l1, Int_t cell) { fMinL0FastORAmp = l0; fMinL1FastORAmp = l1; fMinCellAmp = cell; }

  void SetL1ADCtoGeVConversion(Double_t conversionfactor) { fADCtoGeV = conversionfactor; }

  void AddFastORBadChannel(Short_t absId) { fBadChannels.insert(absId); }

  void ReadFastORBadChannelFromStream(std::istream& stream);

  void ClearFastORBadChannels();

  void ReadFastORBadChannelFromFile(const char* fname);

  void AddOfflineBadChannel(Short_t absId) { fOfflineBadChannels.insert(absId); }

  void ReadOfflineBadChannelFromStream(std::istream& stream);

  void ReadOfflineBadChannelFromFile(const char* fname);

  void ClearOfflineBadChannels();

  void ReadFastORPedestalFromStream(std::istream& stream);

  void ReadFastORPedestalFromFile(const char* fname);

  void SetFastORPedestal(Short_t absId, Float_t ped);

  void ResetFastORPedestal() { fFastORPedestal.Reset(); }

  void SetMaxAbsCellTime(Double_t maxCellTime) { fCellTimeLimits[0] = -maxCellTime; fCellTimeLimits[1] = maxCellTime; }

  void SetAcceptCellTimeRange(Double_t minCellTime, Double_t maxCellTime) { fCellTimeLimits[0] = minCellTime; fCellTimeLimits[1] = maxCellTime; }

  void SetLowerCellTimeCut(Double_t minCellTime) { fCellTimeLimits[0] = minCellTime; }

  void SetUpperCellTimeCut(Double_t maxCellTime) { fCellTimeLimits[1] = maxCellTime; }

  void SetMinFEEAmplitude(Double_t minamp) { fMinCellAmplitude = minamp; }

  void SetApplyOnlineBadChannelMaskingToOffline(Bool_t doApply = kTRUE) { fApplyOnlineBadChannelsToOffline = doApply; }

  void Reset();

  void ReadTriggerData(AliVCaloTrigger *trigger);

  void ReadCellData(AliVCaloCells *cells);

  void BuildL1ThresholdsOffline(const AliVVZERO *vzdata);

  void AddL1TriggerAlgorithm(Int_t rowmin, Int_t rowmax, UInt_t bitmask, Int_t patchSize, Int_t subregionSize);

  void SetL0TriggerAlgorithm(Int_t rowmin, Int_t rowmax, UInt_t bitmask, Int_t patchSize, Int_t subregionSize);

  void SetSmearModel(TF1 *mean, TF1 *width) {
    fSmearModelMean = mean;
    fSmearModelSigma = width;
  }

  void SetSmearThreshold(Double_t threshold) { fSmearThreshold = threshold; }

  Bool_t IsConfigured() const { return fConfigured; }

  void ConfigureForPbPb2015();

  void ConfigureForPP2015();

  void ConfigureForPP20158x8();

  void ConfigureForPPb2013();

  void ConfigureForPP2012();

  void ConfigureForPbPb2011();

  void ConfigureForPP2011();

protected:
  enum{
    kColsEta = 48
  };

  ELevel0TriggerStatus_t CheckForL0(Int_t col, Int_t row) const;

  Bool_t IsGammaPatch(const AliEMCALTriggerRawPatch &patch) const;
  Bool_t IsJetPatch(const AliEMCALTriggerRawPatch &patch) const;
  Bool_t IsBkgPatch(const AliEMCALTriggerRawPatch &patch) const;

  bool HasPHOSOverlap(const AliEMCALTriggerRawPatch &patch) const;

  std::set<Short_t>                         fBadChannels;                 
  std::set<Short_t>                         fOfflineBadChannels;          
  TArrayF                                   fFastORPedestal;              
  const AliEMCALTriggerBitConfig           *fTriggerBitConfig;            

  AliEMCALTriggerPatchFinder<double>       *fPatchFinder;                 
  AliEMCALTriggerAlgorithm<double>         *fLevel0PatchFinder;           
  Int_t                                     fL0MinTime;                   
  Int_t                                     fL0MaxTime;                   
  Int_t                                     fMinCellAmp;                  
  Int_t                                     fMinL0FastORAmp;              
  Int_t                                     fMinL1FastORAmp;              
  Int_t                                     fThresholdConstants[4][3];    
  ULong64_t                                 fL1ThresholdsOffline[4];      
  Int_t                                     fBkgThreshold;                
  Int_t                                     fL0Threshold;                 
  Bool_t                                    fIsMC;                        
  Int_t                                     fDebugLevel;                  
  Double_t                                  fCellTimeLimits[2];           
  Double_t                                  fMinCellAmplitude;            
  Bool_t                                    fApplyOnlineBadChannelsToOffline;   
  Bool_t                                    fConfigured;                  
  TF1                                       *fSmearModelMean;             
  TF1                                       *fSmearModelSigma;            
  Double_t                                  fSmearThreshold;              

  const AliEMCALGeometry                    *fGeometry;                   
  AliEMCALTriggerDataGrid<double>           *fPatchAmplitudes;            
  AliEMCALTriggerDataGrid<double>           *fPatchADCSimple;             
  AliEMCALTriggerDataGrid<double>           *fPatchADC;                   
  AliEMCALTriggerDataGrid<double>           *fPatchEnergySimpleSmeared;   
  AliEMCALTriggerDataGrid<char>             *fLevel0TimeMap;              
  AliEMCALTriggerDataGrid<int>              *fTriggerBitMap;              

  Double_t                                  fADCtoGeV;                    

  ClassDef(AliEmcalTriggerMakerKernel, 4);
};

#endif