DigitsToRawSpec.cxx

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.
 
 
#include <random>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <array>
#include <functional>
#include <vector>
#include <algorithm>
#include <filesystem>
#include "Framework/DataRefUtils.h"
#include "Framework/CallbackService.h"
#include "Framework/ConfigParamRegistry.h"
#include "Framework/ControlService.h"
#include "Framework/DataProcessorSpec.h"
#include "Framework/Lifetime.h"
#include "Framework/Output.h"
#include "Framework/Task.h"
#include "Framework/WorkflowSpec.h"
 
#include <fairlogger/Logger.h> // for LOG
#include "Framework/Logger.h"
#include "Framework/InputRecordWalker.h"
#include "DataFormatsParameters/GRPObject.h"
#include "CommonUtils/NameConf.h"
 
#include "TFile.h"
#include "TTree.h"
#include <TSystem.h>
#include "Headers/RAWDataHeader.h"
#include "DetectorsRaw/RDHUtils.h"
#include "DPLUtils/DPLRawParser.h"
 
#include "DataFormatsHMP/Digit.h"
#include "DataFormatsHMP/Trigger.h"
#include "HMPIDBase/Geo.h"
#include "HMPIDSimulation/HmpidCoder2.h"
#include "HMPIDWorkflow/DigitsToRawSpec.h"
 
namespace o2
{
namespace hmpid
{
 
using namespace o2;
using namespace o2::framework;
using RDH = o2::header::RDHAny;
 
//=======================
// Data decoder
void DigitsToRawSpec::init(framework::InitContext& ic)
{
  LOG(info) << "HMPID Write Raw File From Root sim Digits vector - init()";
  mDigitsReceived = 0;
  mEventsReceived = 0;
  mBaseRootFileName = ic.options().get<std::string>("in-file");
  mBaseFileName = ic.options().get<std::string>("outfile");
  mDirectoryName = ic.options().get<std::string>("outdir");
  mFileFor = ic.options().get<std::string>("file-for");
  mDumpDigits = ic.options().get<bool>("dump-digits"); // Debug flags
  mSkipEmpty = ic.options().get<bool>("skip-empty");
 
  // if needed, create output directory
  if (!std::filesystem::exists(mDirectoryName)) {
    if (!std::filesystem::create_directories(mDirectoryName)) {
      LOG(fatal) << "could not create output directory " << mDirectoryName;
    } else {
      LOG(info) << "created output directory " << mDirectoryName;
    }
  }
 
  std::string fullFName = o2::utils::Str::concat_string(mDirectoryName, "/", mBaseFileName);
 
  // Setup the Coder
  mCod = new HmpidCoder2(Geo::MAXEQUIPMENTS);
  mCod->setSkipEmptyEvents(mSkipEmpty);
  mCod->openOutputStream(fullFName, mFileFor);
  std::string inputGRP = o2::base::NameConf::getGRPFileName();
  std::unique_ptr<o2::parameters::GRPObject> grp{o2::parameters::GRPObject::loadFrom(inputGRP)};
  mCod->getWriter().setContinuousReadout(grp->isDetContinuousReadOut(o2::detectors::DetID::HMP)); // must be set explicitly
 
  // Open the ROOT file
  TFile* fdig = TFile::Open(mBaseRootFileName.data());
  assert(fdig != nullptr);
  LOG(info) << "Open Root digits file " << mBaseRootFileName.data();
  mDigTree = (TTree*)fdig->Get("o2sim");
 
  // Ready to operate
  mCod->getWriter().writeConfFile("HMP", "RAWDATA", o2::utils::Str::concat_string(mDirectoryName, '/', "HMPraw.cfg"));
  mExTimer.start();
}
 
void DigitsToRawSpec::readRootFile()
{
  std::vector<o2::hmpid::Digit> digitsPerEvent;
  std::vector<o2::hmpid::Digit> digits, *hmpBCDataPtr = &digits;
  std::vector<o2::hmpid::Trigger> interactions, *interactionsPtr = &interactions;
 
  // Keeps the Interactions !
  mDigTree->SetBranchAddress("InteractionRecords", &interactionsPtr);
  LOG(info) << "Number of Interaction Records vectors in the simulation file :" << mDigTree->GetEntries();
  for (int ient = 0; ient < mDigTree->GetEntries(); ient++) {
    mDigTree->GetEntry(ient);
    LOG(info) << "Interactions records in simulation :" << interactions.size();
    for (auto a : interactions) {
      LOG(info) << a;
    }
  }
 
  mDigTree->SetBranchAddress("HMPDigit", &hmpBCDataPtr);
  LOG(debug) << "Number of entries in the simulation file :" << mDigTree->GetEntries();
 
  // Loops in the Entry of ROOT Branch
  for (int ient = 0; ient < mDigTree->GetEntries(); ient++) {
    mDigTree->GetEntry(ient);
    int nbc = digits.size();
    if (nbc == 0) { // exit for empty
      LOG(info) << "The Entry :" << ient << " doesn't have digits !";
      continue;
    }
    if (mDumpDigits) { // we want the dump of digits ?
      std::ofstream dumpfile;
      dumpfile.open("/tmp/hmpDumpDigits.dat");
      for (o2::hmpid::Trigger& e : interactions) {
        dumpfile << "Trigger  Orbit=" << e.getOrbit() << " BC=" << e.getBc() << std::endl;
        for (int i = e.getFirstEntry(); i <= e.getLastEntry(); i++) {
          dumpfile << digits.at(i) << std::endl;
        }
      }
      dumpfile.close();
    }
    // ready to operate
    LOG(info) << "For the entry = " << ient << " there are " << nbc << " DIGITS stored.";
    for (o2::hmpid::Trigger& e : interactions) {
      mEventsReceived++;
      digitsPerEvent.clear();
      for (int i = e.getFirstEntry(); i <= e.getLastEntry(); i++) {
        digitsPerEvent.push_back(digits[i]);
      }
      LOG(debug) << "Orbit =" << e.getOrbit() << " BC =" << e.getBc() << "  Digits =" << digitsPerEvent.size();
      if (digitsPerEvent.size() == 0) {
        LOG(info) << "Empty event !" << e;
      }
      mCod->codeEventChunkDigits(digitsPerEvent, e.getIr());
      mDigitsReceived += digitsPerEvent.size();
    }
    if (mDigitsReceived != digits.size()) {
      LOG(warning) << "Digits outside the events defined !";
    }
  }
  mExTimer.logMes("End of Write raw file Job !");
  return;
}
 
void DigitsToRawSpec::run(framework::ProcessingContext& pc)
{
  // Arrange Files path
  readRootFile();
  mCod->closeOutputStream();
  mCod->dumpResults(mBaseRootFileName);
  mExTimer.logMes("Raw File created ! Digits = " + std::to_string(mDigitsReceived) + " for Events =" + std::to_string(mEventsReceived));
  mExTimer.stop();
  pc.services().get<o2::framework::ControlService>().readyToQuit(framework::QuitRequest::Me);
}
 
void DigitsToRawSpec::endOfStream(framework::EndOfStreamContext& ec)
{
  return;
}
 
//_________________________________________________________________________________________________
o2::framework::DataProcessorSpec getDigitsToRawSpec()
{
  std::vector<o2::framework::InputSpec> inputs;
  std::vector<o2::framework::OutputSpec> outputs;
 
  return DataProcessorSpec{
    "digits-to-raw",
    inputs,
    outputs,
    AlgorithmSpec{adaptFromTask<DigitsToRawSpec>()},
    Options{{"outdir", VariantType::String, "./", {"base dir for output file"}},
            {"file-for", VariantType::String, "all", {"single file per: all,flp,link,crorcendpoint"}},
            {"outfile", VariantType::String, "HMP", {"base name for output file"}},
            {"in-file", VariantType::String, "hmpiddigits.root", {"name of the input sim root file"}},
            {"dump-digits", VariantType::Bool, false, {"out the digits file in /tmp/hmpDumpDigits.dat"}},
            {"skip-empty", VariantType::Bool, false, {"skip empty events"}}}};
}
 
} // namespace hmpid
} // end namespace o2