ETCalibHistos.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 PHOS_ETCALIBHISTOS_H
#define PHOS_ETCALIBHISTOS_H
 
#include <array>
#include <cstring>
 
namespace o2
{
 
namespace phos
{
 
class ETCalibHistos
{
 public:
  // Histogram kinds to be filled
  enum hnames { kReInvMassPerCell,
                kMiInvMassPerCell,
                kReInvMassNonlin,
                kMiInvMassNonlin,
                kTimeHGPerCell,
                kTimeLGPerCell,
                kTimeHGSlewing,
                kTimeLGSlewing,
                kTimeDDL };
  static constexpr int nChannels = 14336 - 1793; // 4 full modules -1/2
  static constexpr int offset = 1793;            // 1/2 full module
  // mgg histos
  static constexpr int nMass = 150.;
  static constexpr float massMax = 0.3;
  static constexpr float dm = massMax / nMass;
  // time histograms
  static constexpr int nTime = 400;
  static constexpr float timeMin = -200.e-9;
  static constexpr float timeMax = 200.e-9;
  static constexpr float dt = (timeMax - timeMin) / nTime;
 
  // pt
  static constexpr int npt = 200;
  static constexpr float ptMax = 20;
  static constexpr float dpt = ptMax / npt;
 
  // L1 phase
  static constexpr int nDDL = 52; // 14 DDL * 4 BC
 
  ETCalibHistos() = default;
 
  ETCalibHistos& operator=(const ETCalibHistos& other) = default;
 
  virtual ~ETCalibHistos() = default;
 
  void merge(const ETCalibHistos* other)
  {
    for (int i = nChannels; --i;) {
      for (int j = nMass; --j;) {
        mReInvMassPerCell[i][j] += other->mReInvMassPerCell[i][j];
        mMiInvMassPerCell[i][j] += other->mMiInvMassPerCell[i][j];
      }
      for (int j = nTime; --j;) {
        mTimeHGPerCell[i][j] += other->mTimeHGPerCell[i][j];
        mTimeLGPerCell[i][j] += other->mTimeLGPerCell[i][j];
      }
    }
    for (int i = npt; --i;) {
      for (int j = nMass; --j;) {
        mReInvMassNonlin[i][j] += other->mReInvMassNonlin[i][j];
        mMiInvMassNonlin[i][j] += other->mMiInvMassNonlin[i][j];
      }
      for (int j = nTime; --j;) {
        mTimeHGSlewing[i][j] += other->mTimeHGSlewing[i][j];
        mTimeLGSlewing[i][j] += other->mTimeLGSlewing[i][j];
      }
    }
    for (int i = nDDL; --i;) {
      for (int j = nTime; --j;) {
        mTimeDDL[i][j] += other->mTimeDDL[i][j];
      }
    }
  }
 
  void fill(int kind, float x, float y)
  {
    if (kind == kReInvMassNonlin || kind == kMiInvMassNonlin) {
      int i = int(x / dm);
      int j = int(y / dpt);
      if (i < nMass && j < npt) {
        if (kind == kReInvMassNonlin) {
          mReInvMassNonlin[i][j]++;
        } else {
          mMiInvMassNonlin[i][j]++;
        }
      }
    }
    if (kind == kTimeHGSlewing || kind == kTimeLGSlewing) {
      int i = int((x - timeMin) / dt);
      int j = int(y / dpt);
      if (i >= 0 && i < nTime && j < npt) {
        if (kind == kTimeHGSlewing) {
          mTimeHGSlewing[i][j]++;
        } else {
          mTimeHGSlewing[i][j]++;
        }
      }
    }
  }
  void fill(int kind, int x, float y)
  {
    if (kind == kReInvMassPerCell || kind == kMiInvMassPerCell) {
      int j = int(y / dm);
      if (j < nMass) {
        if (kind == kReInvMassPerCell) {
          mReInvMassPerCell[x - offset][j]++;
        } else {
          mMiInvMassPerCell[x - offset][j]++;
        }
      }
    }
    if (kind == kTimeHGPerCell || kind == kTimeLGPerCell) {
      int j = int((y - timeMin) / dt);
      if (j >= 0 && j < nTime) {
        if (kind == kTimeHGPerCell) {
          mTimeHGPerCell[x - offset][j]++;
        } else {
          mTimeLGPerCell[x - offset][j]++;
        }
      }
    }
    if (kind == kTimeDDL) {
      int j = int((y - timeMin) / dt);
      if (j >= 0 && j < nTime) {
        mTimeDDL[x][j]++;
      }
    }
  }
  void reset()
  {
    memset(&mReInvMassPerCell, 0, sizeof(mReInvMassPerCell));
    memset(&mMiInvMassPerCell, 0, sizeof(mMiInvMassPerCell));
    memset(&mReInvMassNonlin, 0, sizeof(mReInvMassNonlin));
    memset(&mMiInvMassNonlin, 0, sizeof(mMiInvMassNonlin));
    memset(&mTimeHGPerCell, 0, sizeof(mTimeHGPerCell));
    memset(&mTimeLGPerCell, 0, sizeof(mTimeLGPerCell));
    memset(&mTimeHGSlewing, 0, sizeof(mTimeHGSlewing));
    memset(&mTimeLGSlewing, 0, sizeof(mTimeLGSlewing));
    memset(&mTimeDDL, 0, sizeof(mTimeDDL));
  }
 
 public:
  std::array<std::array<float, nMass>, nChannels> mReInvMassPerCell; 
  std::array<std::array<float, nMass>, nChannels> mMiInvMassPerCell; 
  std::array<std::array<float, npt>, nMass> mReInvMassNonlin;        
  std::array<std::array<float, npt>, nMass> mMiInvMassNonlin;        
  std::array<std::array<float, nTime>, nChannels> mTimeHGPerCell;    
  std::array<std::array<float, nTime>, nChannels> mTimeLGPerCell;    
  std::array<std::array<float, npt>, nTime> mTimeHGSlewing;          
  std::array<std::array<float, npt>, nTime> mTimeLGSlewing;          
  std::array<std::array<float, nDDL>, nTime> mTimeDDL;               
 
  ClassDef(ETCalibHistos, 2);
};
 
} // namespace phos
 
} // namespace o2
#endif