RawWriter.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_EMCAL_RAWWRITER_H
#define ALICEO2_EMCAL_RAWWRITER_H
 
#include <gsl/span>
 
#include <array>
#include <cstdint>
#include <fstream>
#include <memory>
#include <string>
#include <map>
#include <vector>
 
#include "Rtypes.h"
 
#include "DetectorsRaw/RawFileWriter.h"
#include "EMCALBase/Mapper.h"
#include "DataFormatsEMCAL/Digit.h"
#include "DataFormatsEMCAL/TriggerRecord.h"
#include "EMCALReconstruction/AltroHelper.h"
 
namespace o2
{
 
namespace emcal
{
 
class Geometry;
 
union ChannelHeader {
  uint32_t mDataWord; 
  struct {
    uint32_t mHardwareAddress : 16; 
    uint32_t mPayloadSize : 10;     
    uint32_t mZero1 : 3;            
    uint32_t mBadChannel : 1;       
    uint32_t mHeaderBits : 2;       
  };
};
 
union CaloBunchWord {
  uint32_t mDataWord; 
  struct {
    uint32_t mWord2 : 10; 
    uint32_t mWord1 : 10; 
    uint32_t mWord0 : 10; 
    uint32_t mZero : 2;   
  };
};
 
class RawWriter
{
 public:
  enum class FileFor_t {
    kFullDet, 
    kSubDet,  
    kCRORC,   
    kLink     
  };
 
  RawWriter() = default;
 
  RawWriter(const char* outputdir) { setOutputLocation(outputdir); }
 
  ~RawWriter() = default;
 
  o2::raw::RawFileWriter& getWriter() const { return *mRawWriter; }
 
  void setOutputLocation(const char* outputdir) { mOutputLocation = outputdir; }
  void setDigits(gsl::span<o2::emcal::Digit> digits) { mDigits = digits; }
 
  void setFileFor(FileFor_t filefor) { mFileFor = filefor; }
 
  void setNumberOfADCSamples(int nsamples) { mNADCSamples = nsamples; }
 
  void setMinADCSamplesBunch(int nsamples) { mMinADCBunch = nsamples; }
 
  void setPedestal(int pedestal) { mPedestal = pedestal; }
 
  void setGeometry(o2::emcal::Geometry* geo) { mGeometry = geo; }
 
  void init();
 
  void digitsToRaw(gsl::span<o2::emcal::Digit> digits, gsl::span<o2::emcal::TriggerRecord> triggers);
 
  bool processTrigger(const o2::emcal::TriggerRecord& trg);
 
  int carryOverMethod(const header::RDHAny* rdh, const gsl::span<char> data,
                      const char* ptr, int maxSize, int splitID,
                      std::vector<char>& trailer, std::vector<char>& header) const;
 
 protected:
  void createPayload(o2::emcal::ChannelData channel, o2::emcal::ChannelType_t chanType, int ddlID, std::vector<char>& payload, bool& saturatedBunch);
 
  std::vector<AltroBunch> findBunches(const std::vector<o2::emcal::Digit*>& channelDigits, ChannelType_t channelType);
 
  ChannelHeader createChannelHeader(int hardwareAddress, int payloadSize, bool isBadChannel);
 
  std::vector<char> createRCUTrailer(int payloadsize, double timesample, uint64_t triggertime, int feeID);
 
  std::vector<int> encodeBunchData(const std::vector<int>& data);
 
  int getBranchIndexFromHwAddress(int hwaddress) { return ((hwaddress >> 11) & 0x1); }
 
  int getFecIndexFromHwAddress(int hwaddress) { return ((hwaddress >> 7) & 0xF); }
 
  int getChannelIndexFromHwAddress(int hwaddress) { return (hwaddress & 0xF); }
 
 private:
  int mNADCSamples = 15;                                      
  int mPedestal = 1;                                          
  int mMinADCBunch = 3;                                       
  FileFor_t mFileFor = FileFor_t::kFullDet;                   
  o2::emcal::Geometry* mGeometry = nullptr;                   
  std::string mOutputLocation;                                
  std::unique_ptr<o2::emcal::MappingHandler> mMappingHandler; 
  gsl::span<o2::emcal::Digit> mDigits;                        
  std::vector<SRUDigitContainer> mSRUdata;                    
  std::unique_ptr<o2::raw::RawFileWriter> mRawWriter;         
 
  ClassDefNV(RawWriter, 1);
};
 
} // namespace emcal
 
} // namespace o2
 
#endif