IDCSim.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_IDCSIM_H_
#define ALICEO2_TPC_IDCSIM_H_
 
#include <vector>
#include <array>
#include "DataFormatsTPC/Constants.h"
#include "CommonConstants/LHCConstants.h"
#include "TPCBase/Mapper.h"
#include <gsl/span>
#include "Rtypes.h"
 
namespace o2::utils
{
class TreeStreamRedirector;
}
 
namespace o2::tpc
{
 
class Digit;
 
 
class IDCSim
{
 public:
  IDCSim(const unsigned int sector = 0, const unsigned int nOrbits = 12) : mSector{sector}, mNOrbits{nOrbits} {}
 
  // integrate IDCs for one TF
  void integrateDigitsForOneTF(const gsl::span<const o2::tpc::Digit>& digits);
 
  static void setNOrbitsPerTF(const unsigned int nOrbitsPerTF) { mOrbitsPerTF = nOrbitsPerTF; }
 
  void dumpIDCs(const char* outFileName, const char* outName = "IDCSim") const;
 
  void createDebugTree(const char* nameTree) const;
 
  static void createDebugTreeForAllSectors(const char* nameTree, const char* filename);
 
  const auto& get() const { return mIDCs[!mBufferIndex]; }
 
  unsigned int getSector() const { return mSector; }
 
  static unsigned int getNOrbitsPerTF() { return mOrbitsPerTF; }
 
  unsigned int getNOrbitsPerIntegrationInterval() const { return mNOrbits; }
 
  unsigned int getNTimeStampsPerIntegrationInterval() const { return mTimeStampsPerIntegrationInterval; }
 
  bool additionalInterval() const { return mAddInterval; }
 
  unsigned int getNIntegrationIntervalsPerTF() const { return mIntegrationIntervalsPerTF; }
 
  unsigned int getNTimeStampsRemainder() const { return mTimeStampsRemainder; }
 
  int getTimeBinsOff() const { return mTimeBinsOff; }
 
  void drawIDCs(const unsigned int integrationInterval = 0, const std::string filename = "IDCs.pdf") const;
 
  unsigned int getMaxIDCs(const unsigned int region) const { return mMaxIDCs[region]; }
 
 private:
  inline static unsigned int mOrbitsPerTF{256};                                                                                               
  const unsigned int mSector{};                                                                                                               
  const unsigned int mNOrbits{12};                                                                                                            
  const unsigned int mTimeStampsPerIntegrationInterval{(o2::constants::lhc::LHCMaxBunches * mNOrbits) / o2::tpc::constants::LHCBCPERTIMEBIN}; 
  const bool mAddInterval{(mOrbitsPerTF % mNOrbits) > 0 ? true : false};                                                                      
  const unsigned int mIntegrationIntervalsPerTF{mOrbitsPerTF / mNOrbits + mAddInterval};                                                      
  const unsigned int mTimeStampsRemainder{mTimeStampsPerIntegrationInterval * (mOrbitsPerTF % mNOrbits) / mNOrbits};                          
  int mTimeBinsOff{};                                                                                                                         
  bool mBufferIndex{false};                                                                                                                   
  const std::array<unsigned int, Mapper::NREGIONS> mMaxIDCs{
    Mapper::PADSPERREGION[0] * mIntegrationIntervalsPerTF, // region 0
    Mapper::PADSPERREGION[1] * mIntegrationIntervalsPerTF, // region 1
    Mapper::PADSPERREGION[2] * mIntegrationIntervalsPerTF, // region 2
    Mapper::PADSPERREGION[3] * mIntegrationIntervalsPerTF, // region 3
    Mapper::PADSPERREGION[4] * mIntegrationIntervalsPerTF, // region 4
    Mapper::PADSPERREGION[5] * mIntegrationIntervalsPerTF, // region 5
    Mapper::PADSPERREGION[6] * mIntegrationIntervalsPerTF, // region 6
    Mapper::PADSPERREGION[7] * mIntegrationIntervalsPerTF, // region 7
    Mapper::PADSPERREGION[8] * mIntegrationIntervalsPerTF, // region 8
    Mapper::PADSPERREGION[9] * mIntegrationIntervalsPerTF  // region 9
  };                                                       
  std::array<std::vector<float>, Mapper::NREGIONS> mIDCs[2]{
    {std::vector<float>(mMaxIDCs[0]),  // region 0
     std::vector<float>(mMaxIDCs[1]),  // region 1
     std::vector<float>(mMaxIDCs[2]),  // region 2
     std::vector<float>(mMaxIDCs[3]),  // region 3
     std::vector<float>(mMaxIDCs[4]),  // region 4
     std::vector<float>(mMaxIDCs[5]),  // region 5
     std::vector<float>(mMaxIDCs[6]),  // region 6
     std::vector<float>(mMaxIDCs[7]),  // region 7
     std::vector<float>(mMaxIDCs[8]),  // region 8
     std::vector<float>(mMaxIDCs[9])}, // region 9
    {std::vector<float>(mMaxIDCs[0]),  // region 0
     std::vector<float>(mMaxIDCs[1]),  // region 1
     std::vector<float>(mMaxIDCs[2]),  // region 2
     std::vector<float>(mMaxIDCs[3]),  // region 3
     std::vector<float>(mMaxIDCs[4]),  // region 4
     std::vector<float>(mMaxIDCs[5]),  // region 5
     std::vector<float>(mMaxIDCs[6]),  // region 6
     std::vector<float>(mMaxIDCs[7]),  // region 7
     std::vector<float>(mMaxIDCs[8]),  // region 8
     std::vector<float>(mMaxIDCs[9])}  // region 9
  };                                   
 
  unsigned int getLastTimeBinForSwitch() const;
 
  // set offset for the next time frame
  void setNewOffset();
 
  void resetIDCs();
 
  unsigned int getOrbit(const unsigned int timeStamp) const { return static_cast<unsigned int>((timeStamp + mTimeBinsOff) / mTimeStampsPerIntegrationInterval); }
 
  unsigned int getIndex(const unsigned int timeStamp, const unsigned int region, const unsigned int row, const unsigned int pad) const { return getOrbit(timeStamp) * Mapper::PADSPERREGION[region] + Mapper::getLocalPadNumber(row, pad); }
 
  static void createDebugTree(const IDCSim& idcsim, o2::utils::TreeStreamRedirector& pcstream);
 
  ClassDefNV(IDCSim, 1)
};
 
} // namespace o2::tpc
 
#endif