GeneratorPythia8.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_GENERATORPYTHIA8_H_
#define ALICEO2_EVENTGEN_GENERATORPYTHIA8_H_
 
#include "Generators/Generator.h"
#include "Pythia8/Pythia.h"
#include <functional>
#include "Generators/GeneratorPythia8Param.h"
 
namespace o2
{
namespace eventgen
{
 
/*****************************************************************/
/*****************************************************************/
class GeneratorPythia8 : public Generator
{
 
 public:
  GeneratorPythia8();
  GeneratorPythia8(Pythia8GenConfig const&);
  GeneratorPythia8(const Char_t* name, const Char_t* title = "ALICEo2 Pythia8 Generator");
  ~GeneratorPythia8() override = default;
 
  Bool_t Init() override;
  Bool_t generateEvent() override;
  Bool_t importParticles() override { return importParticles(mPythia.event); };
  void setConfig(std::string val) { mConfig = val; };
  void setHooksFileName(std::string val) { mHooksFileName = val; };
  void setHooksFuncName(std::string val) { mHooksFuncName = val; };
  void setUserHooks(Pythia8::UserHooks* hooks);
  bool readString(std::string val) { return mPythia.readString(val, true); };
  bool readFile(std::string val) { return mPythia.readFile(val, true); };
  void getNcoll(int& nColl)
  {
    getNcoll(mPythia.info, nColl);
  };
  void getNpart(int& nPart)
  {
    getNpart(mPythia.info, nPart);
  };
  void getNpart(int& nProtonProj, int& nNeutronProj, int& nProtonTarg, int& nNeutronTarg)
  {
    getNpart(mPythia.info, nProtonProj, nNeutronProj, nProtonTarg, nNeutronTarg);
  };
  void getNremn(int& nProtonProj, int& nNeutronProj, int& nProtonTarg, int& nNeutronTarg)
  {
    getNremn(mPythia.event, nProtonProj, nNeutronProj, nProtonTarg, nNeutronTarg);
  };
  void getNfreeSpec(int& nFreenProj, int& nFreepProj, int& nFreenTarg, int& nFreepTarg)
  {
    getNfreeSpec(mPythia.info, nFreenProj, nFreepProj, nFreenTarg, nFreepTarg);
  };
 
  typedef std::function<bool(const Pythia8::Particle&)> UserFilterFcn;
 
  bool setInitialSeed(long seed);
 
 protected:
  GeneratorPythia8(const GeneratorPythia8&);
  GeneratorPythia8& operator=(const GeneratorPythia8&);
 
  typedef UserFilterFcn Select;
  typedef std::vector<int> (*GetRelatives)(const Pythia8::Particle&);
  typedef void (*SetRelatives)(Pythia8::Particle&, int, int);
  typedef std::pair<int, int> (*FirstLastRelative)(const Pythia8::Particle&);
  void updateHeader(o2::dataformats::MCEventHeader* eventHeader) override;
  Bool_t importParticles(Pythia8::Event& event);
  void pruneEvent(Pythia8::Event& event, Select select);
  void investigateRelatives(Pythia8::Event& event,           // Event
                            const std::vector<int>& old2New, // Map from old to new idx
                            size_t index,                    // Current particle
                            std::vector<bool>& done,         // cache flag
                            GetRelatives getter,             // get relatives
                            SetRelatives setter,             // set relatives
                            FirstLastRelative firstLast,     // get first and last relative
                            const std::string& what,         // what are we looking for
                            const std::string& ind = "");    // logging indent
  void selectFromAncestor(int ancestor, Pythia8::Event& inputEvent, Pythia8::Event& outputEvent);
  void getNcoll(const Pythia8::Info& info, int& nColl);
  void getNpart(const Pythia8::Info& info, int& nPart);
  void getNpart(const Pythia8::Info& info, int& nProtonProj, int& nNeutronProj, int& nProtonTarg, int& nNeutronTarg);
  void getNremn(const Pythia8::Event& event, int& nProtonProj, int& nNeutronProj, int& nProtonTarg, int& nNeutronTarg);
  void getNfreeSpec(const Pythia8::Info& info, int& nFreenProj, int& nFreepProj, int& nFreenTarg, int& nFreepTarg);
  void seedGenerator();
 
  // Hyperloop flag
  const bool mIsHyperloop = Generator::isHyperloop();
 
  // Show banner only when not running in Hyperloop
  Pythia8::Pythia mPythia{/*Default*/ "../share/Pythia8/xmldoc", /*banner*/ !mIsHyperloop}; 
 
  std::string mConfig;
  std::string mHooksFileName;
  std::string mHooksFuncName;
  UserFilterFcn mUserFilterFcn = [](Pythia8::Particle const&) -> bool { return true; };
  void initUserFilterCallback();
 
  bool mApplyPruning = false;
  bool mIsInitialized = false; // if Init function has been called
  long mInitialRNGSeed = -1;   // initial seed for Pythia random number state;
                               // will be transported to Pythia in the Init function through the Pythia::readString("Random:seed") mechanism.
                               // Value of -1 means unitialized; 0 will be time-dependent and values >1 <= MAX_SEED concrete reproducible seeding
  Pythia8GenConfig mGenConfig; // configuration object
 
  static std::atomic<int> Pythia8InstanceCounter;
  int mThisPythia8InstanceID = 0;
 
  constexpr static long MAX_SEED = 900000000;
 
  ClassDefOverride(GeneratorPythia8, 1);
 
}; 
/*****************************************************************/
/*****************************************************************/
 
} // namespace eventgen
} // namespace o2
 
#endif /* ALICEO2_EVENTGEN_GENERATORPYTHIA8_H_ */
//
// EOF
//