Generator.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_EVENTGEN_GENERATOR_H_
#define ALICEO2_EVENTGEN_GENERATOR_H_
 
#include "FairGenerator.h"
#include "TParticle.h"
#include "Generators/Trigger.h"
#include <functional>
#include <vector>
#include <unordered_map>
 
namespace o2
{
namespace dataformats
{
class MCEventHeader;
}
} // namespace o2
 
namespace o2
{
namespace eventgen
{
 
class GenTPCLoopers; // Forward declaration
class EventDecayer;
struct EventDecayerReport;
 
/*****************************************************************/
/*****************************************************************/
 
// this class implements a generic FairGenerator extension
// that provides a base class for the ALICEo2 simulation needs
// such that different interfaces to the event generators
// (i.e. TGenerator, HEPdata reader) can be implemented
// according to a common protocol
 
class Generator : public FairGenerator
{
 
 public:
  enum ETriggerMode_t { kTriggerOFF,
                        kTriggerOR,
                        kTriggerAND };
 
  Generator();
  Generator(const Char_t* name, const Char_t* title = "ALICEo2 Generator");
  ~Generator() override;
 
  Bool_t Init() override;
 
  Bool_t ReadEvent(FairPrimaryGenerator* primGen) final;
 
  virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
  virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
  Bool_t finalizeEvent();               // final part of event generation that can be customised using external macros
  virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
  Bool_t triggerEvent();
 
  void setMomentumUnit(double val) { mMomentumUnit = val; };
  double getMomentumUnit() const { return mMomentumUnit; }
  void setEnergyUnit(double val) { mEnergyUnit = val; };
  double getEnergyUnit() const { return mEnergyUnit; }
  void setPositionUnit(double val) { mPositionUnit = val; };
  double getPositionUnit() const { return mPositionUnit; }
  void setTimeUnit(double val) { mTimeUnit = val; };
  double getTimeUnit() const { return mTimeUnit; }
  void setBoost(Double_t val) { mBoost = val; };
  void setTriggerMode(ETriggerMode_t val) { mTriggerMode = val; };
  void addTrigger(Trigger trigger) { mTriggers.push_back(trigger); };
  void addDeepTrigger(DeepTrigger trigger) { mDeepTriggers.push_back(trigger); };
  // setter for global number of events
  static void setTotalNEvents(unsigned int& n) { gTotalNEvents = n; }
 
  const std::vector<TParticle>& getParticles() const { return mParticles; }; 
  static unsigned int getTotalNEvents() { return gTotalNEvents; };
 
  // Check if simulation is running in Hyperloop mode
  static bool isHyperloop();
 
  // Number of parallel sub-generator clones a Hyperloop-aware generator expands into
  // (currently used by the external-generator-to-hybrid expansion in GeneratorFactory).
  // 8 matches the standard core counts of Grid/Hyperloop nodes
  static constexpr int NHyperloopParallelGenerators = 8;
 
  void clearParticles() { mParticles.clear(); };
 
  virtual void notifyEmbedding(const o2::dataformats::MCEventHeader* eventHeader){};
 
  virtual void stop() {}
 
  void setTriggerOkHook(std::function<void(std::vector<TParticle> const& p, int eventCount)> f) { mTriggerOkHook = f; }
  void setTriggerFalseHook(std::function<void(std::vector<TParticle> const& p, int eventCount)> f) { mTriggerFalseHook = f; }
 
 protected:
  Generator(const Generator&);
  Generator& operator=(const Generator&);
 
  Bool_t addTracks(FairPrimaryGenerator* primGen);
  Bool_t boostEvent();
 
  void addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription);
  void notifySubGenerator(int subGeneratorId) { mSubGeneratorId = subGeneratorId; }
 
  void* mInterface = nullptr;
  std::string mInterfaceName;
 
  ETriggerMode_t mTriggerMode = kTriggerOFF;
  std::vector<Trigger> mTriggers;         
  std::vector<DeepTrigger> mDeepTriggers; 
 
  // we allow to register callbacks so as to take specific user actions when
  // a trigger was ok nor not
  std::function<void(std::vector<TParticle> const& p, int eventCount)> mTriggerOkHook = [](std::vector<TParticle> const& p, int eventCount) {};
  std::function<void(std::vector<TParticle> const& p, int eventCount)> mTriggerFalseHook = [](std::vector<TParticle> const& p, int eventCount) {};
  int mReadEventCounter = 0; // counting the number of times
 
  double mMomentumUnit = 1.;        // [GeV/c]
  double mEnergyUnit = 1.;          // [GeV/c]
  double mPositionUnit = 0.1;       // [cm]
  double mTimeUnit = 3.3356410e-12; // [s]
 
  std::vector<TParticle> mParticles; 
 
  Double_t mBoost;
 
  // a unique generator instance counter
  // this can be used to make sure no two generator instances have the same seed etc.
  static std::atomic<int> InstanceCounter;
  int mThisInstanceID = 0;
 
 private:
  void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
  // loopers flag
  Bool_t mAddTPCLoopers = kFALSE; // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
  // collect an ID and a short description of sub-generator entities
  std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
  // the current ID of the sub-generator used in the current event (if applicable)
  int mSubGeneratorId = -1;
 
  // global static information about (upper limit of) number of events to be generated
  static unsigned int gTotalNEvents;
 
  // Loopers generator instance
  o2::eventgen::GenTPCLoopers* mTPCLoopersGen = nullptr;
 
  // decay step after the trigger, created on first use when EventDecayer.enable is set
  o2::eventgen::EventDecayer* mEventDecayer = nullptr;             
  o2::eventgen::EventDecayerReport* mEventDecayerReport = nullptr; 
  Bool_t decayParticles(o2::dataformats::MCEventHeader* header);
#ifdef GENERATORS_WITH_TPCLOOPERS
  bool initTPCLoopersGen();
#endif
 
  ClassDefOverride(Generator, 2);
 
}; 
/*****************************************************************/
/*****************************************************************/
 
} // namespace eventgen
} // namespace o2
 
#endif /* ALICEO2_EVENTGEN_GENERATOR_H_ */