RecEventFlat.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 _ZDC_RECEVENTFLAT_H_
#define _ZDC_RECEVENTFLAT_H_
 
#include "CommonDataFormat/RangeReference.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "DataFormatsZDC/BCRecData.h"
#include "DataFormatsZDC/ZDCEnergy.h"
#include "DataFormatsZDC/ZDCTDCData.h"
#include "ZDCBase/Constants.h"
#include "MathUtils/Cartesian.h"
#include <Rtypes.h>
#include <gsl/span>
#include <array>
#include <vector>
#include <map>
#include <cmath>
 
 
namespace o2
{
namespace zdc
{
using FirstEntry = int;
using NElem = int;
 
struct RecEventScale {
  static std::array<float, NChannels> fe;
  static std::array<float, NTDCChannels> fa;
  static void reset();
  static void setGeV();
  static void setGeVZN();
  static void setGeVZP();
  static void setTeV();
  static void setTeVZN();
  static void setTeVZP();
  static void setNucleonEnergy(float energy);
  static void setNucleonEnergyZN(float energy);
  static void setNucleonEnergyZP(float energy);
};
 
struct RecEventFlat { // NOLINT: false positive in clang-tidy !!
  o2::InteractionRecord ir;
  uint32_t channels = 0;                         
  uint32_t ezdcDecoded = 0;                      
  uint32_t triggers = 0;                         
  std::map<uint8_t, float> ezdc;                 
  std::vector<float> TDCVal[NTDCChannels];       
  std::vector<float> TDCAmp[NTDCChannels];       
  std::vector<bool> TDCPile[NTDCChannels];       
  gsl::span<const o2::zdc::BCRecData> mRecBC;    
  gsl::span<const o2::zdc::ZDCEnergy> mEnergy;   
  gsl::span<const o2::zdc::ZDCTDCData> mTDCData; 
  gsl::span<const uint16_t> mInfo;               
  std::vector<uint16_t> mDecodedInfo;            
  uint64_t mEntry = 0;                           
  uint64_t mNEntries = 0;                        
  FirstEntry mFirstE = 0;                        
  FirstEntry mFirstT = 0;                        
  FirstEntry mFirstI = 0;                        
  FirstEntry mStopE = 0;                         
  FirstEntry mStopT = 0;                         
  FirstEntry mStopI = 0;                         
  NElem mNE = 0;                                 
  NElem mNT = 0;                                 
  NElem mNI = 0;                                 
  std::array<bool, NChannels> isBeg{};           
  std::array<bool, NChannels> isEnd{};           
  BCRecData mCurB;                               
  std::vector<float> inter[NChannels];           
  std::array<bool, 4> mComputed{};               
 
  // Reconstruction messages
  std::array<bool, NChannels> genericE{};       
  std::array<bool, NChannels> tdcPedEv{};       
  std::array<bool, NChannels> tdcPedOr{};       
  std::array<bool, NChannels> tdcPedQC{};       
  std::array<bool, NChannels> tdcPedMissing{};  
  std::array<bool, NChannels> adcPedEv{};       
  std::array<bool, NChannels> adcPedOr{};       
  std::array<bool, NChannels> adcPedQC{};       
  std::array<bool, NChannels> adcPedMissing{};  
  std::array<bool, NChannels> offPed{};         
  std::array<bool, NChannels> pilePed{};        
  std::array<bool, NChannels> pileTM{};         
  std::array<bool, NChannels> adcMissingwTDC{}; 
  std::array<bool, NChannels> tdcPileEvC{};     
  std::array<bool, NChannels> tdcPileEvE{};     
  std::array<bool, NChannels> tdcPileM1C{};     
  std::array<bool, NChannels> tdcPileM1E{};     
  std::array<bool, NChannels> tdcPileM2C{};     
  std::array<bool, NChannels> tdcPileM2E{};     
  std::array<bool, NChannels> tdcPileM3C{};     
  std::array<bool, NChannels> tdcPileM3E{};     
  std::array<bool, NChannels> tdcSigE{};        
  // End_of_messages
 
  void clearBitmaps();
 
  uint8_t mVerbosity = DbgZero; 
  uint32_t mTriggerMask = 0;    
 
  void init(const std::vector<o2::zdc::BCRecData>* RecBC, const std::vector<o2::zdc::ZDCEnergy>* Energy, const std::vector<o2::zdc::ZDCTDCData>* TDCData, const std::vector<uint16_t>* Info);
  void init(const gsl::span<const o2::zdc::BCRecData> RecBC, const gsl::span<const o2::zdc::ZDCEnergy> Energy, const gsl::span<const o2::zdc::ZDCTDCData> TDCData, const gsl::span<const uint16_t> Info);
 
  int next();
  int at(int ientry);
 
  void allocate(int isig)
  {
    if (inter[isig].size() != NIS) {
      inter[isig].resize(NIS);
    }
  }
 
  BCRecData& getCurB()
  {
    return mCurB;
  }
 
  inline int getEntries() const
  {
    return mNEntries;
  }
 
  inline int getNextEntry() const
  {
    return mEntry;
  }
 
  inline NElem getNEnergy() const
  {
    return mNE;
  }
 
  inline bool getEnergy(int32_t i, uint8_t& key, float& val) const
  {
    if (i < mNE) {
      auto it = ezdc.begin();
      std::advance(it, i);
      key = it->first;
      val = it->second;
      return true;
    }
    return false;
  }
 
  inline NElem getNTDC() const
  {
    return mNT;
  }
 
  inline NElem getNInfo() const
  {
    return mNI;
  }
 
  const std::vector<uint16_t>& getDecodedInfo()
  {
    return mDecodedInfo;
  }
 
  float tdcV(uint8_t ich, uint64_t ipos) const
  {
    if (ich < NTDCChannels) {
      if (ipos < TDCVal[ich].size()) {
        return FTDCVal * TDCVal[ich][ipos];
      }
    }
    return -std::numeric_limits<float>::infinity();
  }
 
  float tdcA(uint8_t ich, uint64_t ipos) const
  {
    if (ich < NTDCChannels) {
      if (ipos < TDCAmp[ich].size()) {
        return TDCAmp[ich][ipos];
      }
    }
    return -std::numeric_limits<float>::infinity();
  }
 
  int NtdcV(uint8_t ich) const
  {
    if (ich < NTDCChannels) {
      return TDCVal[ich].size();
    } else {
      return 0;
    }
  }
 
  int NtdcA(uint8_t ich) const
  {
    if (ich < NTDCChannels) {
      return TDCAmp[ich].size();
    } else {
      return 0;
    }
  }
 
  float EZDC(uint8_t ich) const
  {
    std::map<uint8_t, float>::const_iterator it = ezdc.find(ich);
    if (it != ezdc.end()) {
      return it->second;
    } else {
      return -std::numeric_limits<float>::infinity();
    }
  }
 
  float EZNAC() const { return EZDC(IdZNAC); }
  float EZNA1() const { return EZDC(IdZNA1); }
  float EZNA2() const { return EZDC(IdZNA2); }
  float EZNA3() const { return EZDC(IdZNA3); }
  float EZNA4() const { return EZDC(IdZNA4); }
  float EZNASum() const { return EZDC(IdZNASum); }
 
  float EZPAC() const { return EZDC(IdZPAC); }
  float EZPA1() const { return EZDC(IdZPA1); }
  float EZPA2() const { return EZDC(IdZPA2); }
  float EZPA3() const { return EZDC(IdZPA3); }
  float EZPA4() const { return EZDC(IdZPA4); }
  float EZPASum() const { return EZDC(IdZPASum); }
 
  float EZEM1() const { return EZDC(IdZEM1); }
  float EZEM2() const { return EZDC(IdZEM2); }
 
  float EZNCC() const { return EZDC(IdZNCC); }
  float EZNC1() const { return EZDC(IdZNC1); }
  float EZNC2() const { return EZDC(IdZNC2); }
  float EZNC3() const { return EZDC(IdZNC3); }
  float EZNC4() const { return EZDC(IdZNC4); }
  float EZNCSum() const { return EZDC(IdZNCSum); }
 
  float EZPCC() const { return EZDC(IdZPCC); }
  float EZPC1() const { return EZDC(IdZPC1); }
  float EZPC2() const { return EZDC(IdZPC2); }
  float EZPC3() const { return EZDC(IdZPC3); }
  float EZPC4() const { return EZDC(IdZPC4); }
  float EZPCSum() const { return EZDC(IdZPCSum); }
 
  // Centroid cartesian reference frame as seen by projectile fragments
  // Side A: X direction towards outside of the ring
  // Side C: X direction towards inside of the ring
  // Y direction up
  // Unit: cm
  void centroidZNA(float& x, float& y);
  void centroidZNC(float& x, float& y);
  void centroidZPA(float& x, float& rms);
  void centroidZPC(float& x, float& rms);
  float xZNA();
  float yZNA();
  float xZNC();
  float yZNC();
  float xZPA(); // Positive
  float xZPC(); // Negative
  float rmsZPA();
  float rmsZPC();
 
  void decodeInfo(uint8_t ch, uint16_t code);
  void decodeMapInfo(uint32_t ch, uint16_t code);
 
  void print() const;
  void printDecodedMessages() const;
  void printEvent() const;
  ClassDefNV(RecEventFlat, 1);
};
 
} // namespace zdc
} // namespace o2
 
#endif