O2DPLDisplay.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 ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
 
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "DataFormatsGlobalTracking/RecoContainer.h"
#include "TPCCalibration/VDriftHelper.h"
#include "DetectorsBase/GRPGeomHelper.h"
#include "EMCALCalib/CellRecalibrator.h"
#include "EMCALWorkflow/CalibLoader.h"
#include "EveWorkflow/DetectorData.h"
#include "Framework/Task.h"
#include <memory>
 
using GID = o2::dataformats::GlobalTrackID;
 
namespace o2::trd
{
class GeometryFlat;
}
 
namespace o2::globaltracking
{
struct DataRequest;
}
 
namespace o2::itsmft
{
class TopologyDictionary;
}
 
namespace o2::event_visualisation
{
class TPCFastTransform;
 
class O2DPLDisplaySpec : public o2::framework::Task
{
 public:
  static constexpr auto allowedTracks =
    "ITS,TPC,MFT,MCH,MID,ITS-TPC,TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD,ITS-TPC-TRD-TOF,MCH-MID,MFT-MCH,MFT-MCH-MID,PHS,EMC,HMP";
  static constexpr auto allowedClusters = "ITS,TPC,TRD,TOF,MFT,MCH,MID,PHS,EMC,HMP";
 
  O2DPLDisplaySpec(bool disableWrite, bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask,
                   o2::dataformats::GlobalTrackID::mask_t clMask,
                   std::shared_ptr<o2::globaltracking::DataRequest> dataRequest,
                   std::shared_ptr<o2::base::GRPGeomRequest> gr,
                   std::shared_ptr<o2::emcal::CalibLoader> emcCalibLoader,
                   const std::string& jsonPath, const std::string& ext,
                   std::chrono::milliseconds timeInterval,
                   bool eveHostNameMatch,
                   const std::string& receiverHostname,
                   int receiverPort,
                   int receiverTimeout,
                   bool useOnlyFiles,
                   bool useOnlySockets)
    : mDisableWrite(disableWrite),
      mUseMC(useMC),
      mTrkMask(trkMask),
      mClMask(clMask),
      mDataRequest(dataRequest),
      mGGCCDBRequest(gr),
      mEMCALCalibLoader(emcCalibLoader),
      mJsonPath(jsonPath),
      mExt(ext),
      mTimeInterval(timeInterval),
      mEveHostNameMatch(eveHostNameMatch),
      mRunType(o2::parameters::GRPECS::NONE),
      mReceiverHostname(receiverHostname),
      mReceiverPort(receiverPort),
      mReceiverTimeout(receiverTimeout),
      mUseOnlyFiles(useOnlyFiles),
      mUseOnlySockets(useOnlySockets)
  {
    this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
  }
 
  ~O2DPLDisplaySpec() override = default;
  void init(o2::framework::InitContext& ic) final;
  void run(o2::framework::ProcessingContext& pc) final;
  void endOfStream(o2::framework::EndOfStreamContext& ec) final;
  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final;
 
 private:
  void updateTimeDependentParams(o2::framework::ProcessingContext& pc);
 
  bool mDisableWrite = false; // skip writing result (for testing performance)
  bool mUseMC = false;
  bool mEveHostNameMatch;                  // empty or correct hostname
  std::string mJsonPath;                   // folder where files are stored
  std::string mExt;                        // extension of created files (".json" or ".root")
  std::chrono::milliseconds mTimeInterval; // minimal interval between files in milliseconds
  bool mPrimaryVertexTriggers;
  // instead of drawing vertices with tracks (and maybe calorimeter triggers), draw vertices with calorimeter triggers (and maybe tracks)
  int mEventCounter = 0;
  std::chrono::time_point<std::chrono::high_resolution_clock> mTimeStamp;
 
  o2::dataformats::GlobalTrackID::mask_t mTrkMask;
  o2::dataformats::GlobalTrackID::mask_t mClMask;
  DetectorData mData;
  o2::parameters::GRPECS::RunType mRunType;
  std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest;
  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
  std::shared_ptr<o2::emcal::CalibLoader> mEMCALCalibLoader;
  std::unique_ptr<o2::emcal::CellRecalibrator> mEMCALCalibrator;
  o2::tpc::VDriftHelper mTPCVDriftHelper{};
 
  std::string mReceiverHostname;
  int mReceiverPort;
  int mReceiverTimeout;
  bool mUseOnlyFiles;
  bool mUseOnlySockets;
};
} // namespace o2::event_visualisation
 
#endif