AODToHepMC.h

Go to the documentation of this file.

// Copyright 2023-2099 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_EVENTGEN_AODTOHEPMC_H_
#define ALICEO2_EVENTGEN_AODTOHEPMC_H_
#include <Framework/AnalysisDataModel.h>
#include <Framework/AnalysisManagers.h>
#include <Framework/Configurable.h>
#include <HepMC3/GenEvent.h>
#include <HepMC3/GenParticle.h>
#include <HepMC3/GenVertex.h>
#include <HepMC3/GenPdfInfo.h>
#include <HepMC3/GenHeavyIon.h>
#include <HepMC3/GenCrossSection.h>
#include <HepMC3/WriterAscii.h>
#include <fstream>
#include <list>
 
namespace o2
{
namespace eventgen
{
struct AODToHepMC {
  struct {
    std::string dump{""};
    bool onlyGen{false};
    bool useTree{false};
    int precision{8};
    bool recenter{false};
  } configs;
  using Headers = o2::aod::McCollisions;
  using Header = o2::aod::McCollision;
  using Tracks = o2::aod::McParticles;
  using Track = typename Tracks::iterator;
  using XSections = o2::aod::HepMCXSections;
  using PdfInfos = o2::aod::HepMCPdfInfos;
  using HeavyIons = o2::aod::HepMCHeavyIons;
  using XSection = typename XSections::iterator;
  using PdfInfo = typename PdfInfos::iterator;
  using HeavyIon = typename HeavyIons::iterator;
  using FourVector = HepMC3::FourVector;
  using ParticlePtr = HepMC3::GenParticlePtr;
  using VertexPtr = HepMC3::GenVertexPtr;
  using Event = HepMC3::GenEvent;
  using HeavyIonPtr = HepMC3::GenHeavyIonPtr;
  using CrossSectionPtr = HepMC3::GenCrossSectionPtr;
  using PdfInfoPtr = HepMC3::GenPdfInfoPtr;
  using ParticleMap = std::unordered_map<long, ParticlePtr>;
  using ParticleVector = std::vector<ParticlePtr>;
  using ParticleList = std::list<ParticlePtr>;
  using VertexVector = std::vector<VertexPtr>;
  using VertexList = std::list<VertexPtr>;
  using WriterAscii = HepMC3::WriterAscii;
  using WriterAsciiPtr = std::shared_ptr<WriterAscii>;
  Event mEvent;
  CrossSectionPtr mCrossSec = nullptr;
  HeavyIonPtr mIon = nullptr;
  PdfInfoPtr mPdf = nullptr;
  ParticleMap mParticles; 
  VertexList mVertices; 
  ParticleVector mBeams; 
  ParticleList mOrphans; 
  WriterAsciiPtr mWriter = nullptr;
  int mEventNo = 0;
  int mLastBC = -1;
  bool mOnlyGen = false;
  bool mUseTree = true;
  std::ofstream* mOutput = nullptr;
  int mPrecision = 16;
  bool mRecenter = false;
  virtual void init();
  virtual void startEvent();
  virtual void process(Header const& collision, Tracks const& tracks);
  virtual void process(Header const& collision,
                       XSections const& xsections,
                       PdfInfos const& pdfs,
                       HeavyIons const& heavyions);
  virtual void endEvent();
  virtual bool postRun()
  {
    enableDump("");
    return true;
  }
 protected:
  virtual void makeEvent(Header const& collision,
                         Tracks const& tracks);
  virtual void makeHeader(Header const& header);
  virtual void makeXSection(XSections const& xsection);
  virtual void makePdfInfo(PdfInfos const& pdf);
  virtual void makeHeavyIon(HeavyIons const& heavyion,
                            Header const& header);
  virtual void makeBeams(Header const& header, const VertexPtr ip) {}
  virtual void makeParticles(Tracks const& tracks);
  virtual ParticlePtr getParticle(Track const& ref) const;
  virtual bool isIgnored(Track const& track) const;
  virtual ParticlePtr makeParticleRecursive(Track const& track,
                                            Tracks const& tracks,
                                            bool force = false);
  virtual ParticlePtr makeParticle(const Track& track,
                                   Int_t& motherStatus,
                                   bool force) const;
  virtual VertexPtr makeVertex(const Track& track);
  virtual void fleshOut(Tracks const& tracks);
  virtual void fleshOutParticle(Track const& track, Tracks const& tracks);
  virtual void recenter(Header const& collision);
  void enableDump(const std::string& dump);
 
}; 
} // namespace eventgen
 
namespace framework
{
struct AODToHepMCPostRun {
  static AODToHepMCPostRun& instance()
  {
    static AODToHepMCPostRun inst{};
    return inst;
  }
 
  AODToHepMCPostRun(eventgen::AODToHepMC* ptr_ = nullptr)
    : ptr{ptr_}
  {
  }
 
  void endOfStream()
  {
    if (ptr != nullptr) {
      ptr->postRun();
    }
  }
 
  eventgen::AODToHepMC* ptr = nullptr;
};
} // namespace framework
} // namespace o2
 
#endif /* ALICEO2_EVENTGEN_GENERATOR_H_ */
// Local Variables:
//  mode: C++
// End: