RawReader.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 O2_TPC_RAWREADER_H_
#define O2_TPC_RAWREADER_H_
 
 
#include <string>
#include <vector>
#include <map>
#include <memory>
#include <utility>
#include <tuple>
 
#include "TPCBase/PadPos.h"
#include "TPCBase/CalDet.h"
#include "TPCReconstruction/RawReaderEventSync.h"
 
namespace o2
{
namespace tpc
{
 
class RawReader
{
 public:
  struct Header {
    uint16_t dataType;     
    uint8_t reserved_01;   
    uint8_t headerVersion; 
    uint32_t nWords;       
    uint64_t timeStamp_w;  
    uint64_t eventCount_w; 
    uint64_t reserved_2_w; 
 
    uint64_t timeStamp() { return (timeStamp_w << 32) | (timeStamp_w >> 32); }
 
    uint64_t eventCount() { return (eventCount_w << 32) | (eventCount_w >> 32); }
 
    uint64_t reserved_2() { return (reserved_2_w << 32) | (reserved_2_w >> 32); }
 
    Header() = default;
 
    Header(const Header& other) = default; // : dataType(h.dataType), reserved_01(h.reserved_01),
                                           //headerVersion(h.headerVersion), nWords(h.nWords), timeStamp_w(h.timeStamp_w),
                                           //eventCount_w(h.eventCount_w), reserved_2_w(h.reserved_2_w) {};
  };
 
  struct EventInfo {
    std::string path; 
    int posInFile;    
    Header header;    
 
    EventInfo() : path(""), posInFile(-1), header(){};
 
    EventInfo(const EventInfo& other) = default;
    //: path(e.path), posInFile(e.posInFile), region(e.region),
    //  link(e.link), header(e.header) {};
  };
 
  RawReader(int region = -1, int link = -1, int run = -1, int sampaVersion = -1);
 
  RawReader(const RawReader& other) = default;
 
  ~RawReader() = default;
 
  int loadNextEvent();
 
  int loadNextEventNoWrap();
 
  int loadPreviousEvent();
 
  int loadPreviousEventNoWrap();
 
  bool loadEvent(int64_t event);
 
  //                #region/#fec/sampaVersion is a number and sampaVersion optional
  bool addInputFile(std::string infile);
 
  //                 #region/#fec/sampaVersion is a number and sampaVersion optional
  bool addInputFile(const std::vector<std::string>* infiles);
 
  bool addInputFile(int region, int link, int sampaVersion, std::string path, int run = -1);
 
  int64_t getFirstEvent() const { return mEvents.begin()->first; };
 
  int64_t getLastEvent() const { return (mEvents.size() == 0) ? mEvents.begin()->first : mEvents.rbegin()->first; };
 
  int64_t getNumberOfEvents() const { return mEvents.size(); };
 
  uint64_t getTimeStamp(short hf) const { return mTimestampOfFirstData[hf]; };
 
  std::shared_ptr<std::vector<uint16_t>> getData(const PadPos& padPos);
 
  std::shared_ptr<std::vector<uint16_t>> getNextData(PadPos& padPos);
 
  int getRegion() const { return mRegion; };
  int getLink() const { return mLink; };
  int getEventNumber() const { return mLastEvent; };
  int getRunNumber() const { return mRun; };
  short getSyncPos(short hf) const { return mSyncPos[hf]; };
 
  void setUseRawInMode3(bool useRaw) { mUseRawInMode3 = useRaw; };
 
  void setApplyChannelMask(bool applyMask) { mApplyChannelMask = applyMask; };
 
  void setChannelMask(std::shared_ptr<CalDet<bool>> channelMask) { mChannelMask = channelMask; };
 
  void setCheckAdcClock(bool checkAdc) { mCheckAdcClock = checkAdc; };
  void setSampaVersion(int sampaVerson) { mSampaVersion = sampaVerson; };
  std::shared_ptr<std::vector<EventInfo>> getEventInfo(uint64_t event) const;
 
  void addEventSynchronizer(std::shared_ptr<RawReaderEventSync> eventSync) { mEventSynchronizer = eventSync; };
 
  std::shared_ptr<std::vector<std::tuple<short, short, short>>> getAdcError() { return mAdcError; };
 
 private:
  bool decodeRawGBTFrames(EventInfo eventInfo);
  bool decodePreprocessedData(EventInfo eventInfo);
 
  bool mUseRawInMode3;                                                              
  bool mApplyChannelMask;                                                           
  bool mCheckAdcClock;                                                              
  int mRegion;                                                                      
  int mLink;                                                                        
  int mRun;                                                                         
  int mSampaVersion;                                                                
  int64_t mLastEvent;                                                               
  std::array<uint64_t, 5> mTimestampOfFirstData;                                    
  std::map<uint64_t, std::shared_ptr<std::vector<EventInfo>>> mEvents;              
  std::map<PadPos, std::shared_ptr<std::vector<uint16_t>>> mData;                   
  std::map<PadPos, std::shared_ptr<std::vector<uint16_t>>>::iterator mDataIterator; 
  std::array<short, 5> mSyncPos;                                                    
 
  std::shared_ptr<CalDet<bool>> mChannelMask;                              
  std::shared_ptr<std::vector<std::tuple<short, short, short>>> mAdcError; 
 
  std::shared_ptr<RawReaderEventSync> mEventSynchronizer; 
};
 
inline std::shared_ptr<std::vector<RawReader::EventInfo>> RawReader::getEventInfo(uint64_t event) const
{
  auto evIterator = mEvents.find(event);
  if (evIterator == mEvents.end()) {
    std::shared_ptr<std::vector<EventInfo>> emptyVecPtr(new std::vector<EventInfo>);
    return emptyVecPtr;
  }
  return evIterator->second;
};
 
inline std::shared_ptr<std::vector<uint16_t>> RawReader::getData(const PadPos& padPos)
{
  mDataIterator = mData.find(padPos);
  if (mDataIterator == mData.end()) {
    std::shared_ptr<std::vector<uint16_t>> emptyVecPtr(new std::vector<uint16_t>);
    return emptyVecPtr;
  }
  return mDataIterator->second;
};
 
inline std::shared_ptr<std::vector<uint16_t>> RawReader::getNextData(PadPos& padPos)
{
  if (mDataIterator == mData.end()) {
    return nullptr;
  }
  std::map<PadPos, std::shared_ptr<std::vector<uint16_t>>>::iterator last = mDataIterator;
  mDataIterator++;
  padPos = last->first;
  return last->second;
};
 
inline int RawReader::loadNextEvent()
{
  if (mLastEvent == -1) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    return getFirstEvent();
 
  } else if (mLastEvent == getLastEvent()) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    return getFirstEvent();
 
  } else {
 
    int event = mLastEvent + 1;
    loadEvent(event);
    return event;
  }
};
 
inline int RawReader::loadPreviousEvent()
{
  if (mLastEvent <= getFirstEvent()) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    loadEvent(getLastEvent());
    return getLastEvent();
 
  } else if (mLastEvent == getFirstEvent() + 1) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    return getFirstEvent();
 
  } else {
 
    int event = mLastEvent - 1;
    loadEvent(event);
    return event;
  }
};
 
inline int RawReader::loadNextEventNoWrap()
{
  if (mLastEvent == -1) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    return getFirstEvent();
 
  } else if (mLastEvent == getLastEvent()) {
 
    return -1;
 
  } else {
 
    int event = mLastEvent + 1;
    loadEvent(event);
    return event;
  }
};
 
inline int RawReader::loadPreviousEventNoWrap()
{
  if (mLastEvent <= getFirstEvent()) {
    return -1;
 
  } else if (mLastEvent == getFirstEvent() + 1) {
 
    mSyncPos.fill(-1);
    mTimestampOfFirstData.fill(0);
 
    loadEvent(getFirstEvent());
    return getFirstEvent();
 
  } else {
 
    int event = mLastEvent - 1;
    loadEvent(event);
    return event;
  }
};
 
} // namespace tpc
} // namespace o2
#endif