CbmDigitize.h

Go to the documentation of this file.

 
#ifndef CBMDIGITIZE_H
#define CBMDIGITIZE_H 1
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Double_t, Bool_t, ULong64_t, kFALSE, kTRUE
 
 
#include <FairLogger.h>  // for LOG
#include <FairTask.h>
 
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
 
#include "CbmDaq.h"
#include "CbmDigitizeBase.h"
#include "CbmMatch.h"
#include "CbmTimeSlice.h"
 
 
template<class Digi>
class CbmDigitize : public CbmDigitizeBase {
 
public:
  typedef std::pair<std::unique_ptr<Digi>, std::unique_ptr<CbmMatch>> Data;
 
 
  CbmDigitize() {};
 
 
  CbmDigitize(const char* name, const char* branchName = "")
    : CbmDigitizeBase(name), fBranchName(branchName) {};
 
 
  virtual ~CbmDigitize() {};
 
 
  // --------------------------------------------------------------------------
  Bool_t CheckOutput() {
    assert(fDigis);
    if (fDigis->empty()) return kTRUE;
    Double_t prevTime = fDigis->begin()->GetTime();
    for (auto it = (fDigis->begin())++; it != fDigis->end(); it++) {
      if (it->GetTime() < prevTime) {
        LOG(error) << GetName()
                   << ": CheckBuffer: Found digi at t = " << it->GetTime()
                   << " ns after digi at t = " << prevTime << " ns";
        return kFALSE;
        break;
      }
      prevTime = it->GetTime();
    }
    return kTRUE;
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  void ClearOutput() {
    if (fDigis) fDigis->clear();
    if (fCreateMatches)
      if (fMatches != nullptr) fMatches->clear();
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  ULong64_t FillTimeSlice(CbmTimeSlice* timeSlice) {
    return FillTimeSlice(timeSlice, kFALSE, -1.);
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  ULong64_t FillTimeSlice(CbmTimeSlice* timeSlice, Double_t fillTime) {
    return FillTimeSlice(timeSlice, kTRUE, fillTime);
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  ULong64_t GetDaqBufferSize() const { return fDaqBuffer.size(); }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  std::string GetDaqBufferStatus() const {
    std::stringstream ss;
    ss << "Status DAQ buffer: " << GetDaqBufferSize()
       << " data from t = " << GetDaqBufferTimeFirst() << " to "
       << GetDaqBufferTimeLast() << " ns";
    return ss.str();
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  Double_t GetDaqBufferTimeFirst() const {
    if (fDaqBuffer.empty()) return -1.;
    return fDaqBuffer.begin()->first;
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  Double_t GetDaqBufferTimeLast() const {
    if (fDaqBuffer.empty()) return -1.;
    return (--fDaqBuffer.end())->first;
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  void RegisterOutput() {
 
    // --- Get FairRootManager instance
    FairRootManager* ioman = FairRootManager::Instance();
    assert(ioman);
 
    // --- Digi branch name. If not set otherwise (through constructor), it
    // --- equals the digi class name minus the leading "Cbm".
    TString digiBranchName = fBranchName;
    if (digiBranchName.IsNull()) {
      TString digiClassName = Digi::GetClassName();
      if (digiClassName.BeginsWith("Cbm"))
        digiBranchName = digiClassName(3, digiClassName.Length());
    }  //? No branch name set via constructor
 
 
    // --- Branch for digis
    fDigis = new std::vector<Digi>();
    ioman->RegisterAny(
      digiBranchName.Data(), fDigis, IsOutputBranchPersistent(digiBranchName));
    LOG(info) << GetName() << ": Registered branch " << digiBranchName;
 
    // --- Branch for matches
    if (fCreateMatches) {
      TString matchBranchName = digiBranchName + "Match";
      fMatches                = new std::vector<CbmMatch>();
      ioman->RegisterAny(matchBranchName.Data(),
                         fMatches,
                         IsOutputBranchPersistent(matchBranchName));
      LOG(info) << GetName() << ": Registered branch " << matchBranchName;
    }
  }
  // --------------------------------------------------------------------------
 
 
  // --------------------------------------------------------------------------
  void SendData(Digi* digi, CbmMatch* match = nullptr) {
    std::unique_ptr<Digi> tmpDigi(digi);
    std::unique_ptr<CbmMatch> tmpMatch(match);
    fDaqBuffer.insert(
      make_pair(digi->GetTime(),
                std::make_pair(std::move(tmpDigi), std::move(tmpMatch))));
  }
  // --------------------------------------------------------------------------
 
 
private:
  TString fBranchName             = "";       
  std::vector<Digi>* fDigis       = nullptr;  
  std::vector<CbmMatch>* fMatches = nullptr;  
 
 
private:
  std::multimap<double, Data> fDaqBuffer;  
 
 
  // --------------------------------------------------------------------------
  ULong64_t
  FillTimeSlice(CbmTimeSlice* timeSlice, Bool_t checkLimit, Double_t fillTime) {
 
    assert(timeSlice);
    ULong64_t nData     = 0;
    Double_t tMin       = timeSlice->GetStartTime();
    Double_t tMax       = timeSlice->GetEndTime();
    Bool_t checkMinTime = kTRUE;
    Bool_t checkMaxTime = kTRUE;
    if (timeSlice->IsRegular()) {
      if (checkLimit && fillTime < tMax) tMax = fillTime;
    } else if (timeSlice->IsFlexible() || timeSlice->IsEvent()) {
      checkMinTime = kFALSE;
      checkMaxTime = checkLimit;
      tMax         = fillTime;
    } else {
      LOG(fatal) << GetName() << ": Unknown time-slice type!";
    }
 
    // This implementation makes use of the fact that the data in the
    // DAQ buffer are time-sorted.
    auto it = fDaqBuffer.begin();
    while (it != fDaqBuffer.end() && ((!checkMaxTime) || it->first < tMax)) {
 
      // For regular time-slices, discard digis with negative times.
      // The first time slice starts at t = 0. All data before are just
      // not recorded.
      if (timeSlice->IsRegular() && it->first < 0.) {
        it++;
        continue;
      }
 
      // Digi times before the start of the current time slice
      // should not happen.
      assert((!checkMinTime) || it->first >= tMin);
 
      // TODO: This implementation uses the implicit copy constructor and
      // manual removal from the source vector. There might be a more
      // elegant way.
      assert(fDigis);
      assert(it->second.first);
      fDigis->push_back(*(it->second.first));
      if (fCreateMatches) {
        assert(fMatches);
        assert(it->second.second);
        fMatches->push_back(*(it->second.second));
      }
 
      // Register datum to the time slice header
      if (fCreateMatches)
        timeSlice->RegisterData(
          GetSystemId(), it->first, fMatches->at(fMatches->size() - 1));
      else
        timeSlice->RegisterData(GetSystemId(), it->first);
 
      nData++;
      it++;
    }
 
    // Remove the corresponding elements from the buffer
    fDaqBuffer.erase(fDaqBuffer.begin(), it);
 
    return nData;
  }
  // --------------------------------------------------------------------------
 
 
  ClassDef(CbmDigitize, 1);
};
 
#endif /* CBMDIGITIZE_H */