PHPythia8.h

Go to the documentation of this file.

#ifndef __PHPYTHIA8_H__
#define __PHPYTHIA8_H__
 
#include <fun4all/SubsysReco.h>
#include <phhepmc/PHHepMCGenHelper.h>
 
#ifndef __CINT__
#include <Pythia8/Pythia.h>
#endif
 
#ifndef __CINT__
#include <gsl/gsl_rng.h>
#endif
 
#include <iostream>
#include <string>
 
class PHCompositeNode;
class PHHepMCGenEvent;
class PHHepMCFilter;
class PHGenIntegral;
class PHPy8GenTrigger;
 
namespace HepMC
{
  class GenEvent;
  class Pythia8ToHepMC;
};
 
namespace Pythia8
{
  class Pythia;
};
 
class PHPythia8 : public SubsysReco
{
 public:
  PHPythia8(const std::string &name = "PHPythia8");
  virtual ~PHPythia8();
 
  int Init(PHCompositeNode *topNode);
  int process_event(PHCompositeNode *topNode);
  int ResetEvent(PHCompositeNode *topNode);
  int End(PHCompositeNode *topNode);
 
  void set_config_file(const char *cfg_file)
  {
    if (cfg_file) _configFile = cfg_file;
  }
 
  void print_config() const;
 
  void register_trigger(PHPy8GenTrigger *theTrigger);
  void set_trigger_OR()
  {
    _triggersOR = true;
    _triggersAND = false;
  }  // default true
  void set_trigger_AND()
  {
    _triggersAND = true;
    _triggersOR = false;
  }
 
  void process_string(std::string s) { _commands.push_back(s); }
  void beam_vertex_parameters(double beamX,
                              double beamY,
                              double beamZ,
                              double beamXsigma,
                              double beamYsigma,
                              double beamZsigma)
  {
    set_vertex_distribution_mean(beamX, beamY, beamZ, 0);
    set_vertex_distribution_width(beamXsigma, beamYsigma, beamZsigma, 0);
  }
 
  void set_vertex_distribution_function(PHHepMCGenHelper::VTXFUNC x, PHHepMCGenHelper::VTXFUNC y, PHHepMCGenHelper::VTXFUNC z, PHHepMCGenHelper::VTXFUNC t)
  {
    hepmc_helper.set_vertex_distribution_function(x, y, z, t);
  }
 
  void set_vertex_distribution_mean(const double x, const double y, const double z, const double t)
  {
    hepmc_helper.set_vertex_distribution_mean(x, y, z, t);
  }
 
  void set_vertex_distribution_width(const double x, const double y, const double z, const double t)
  {
    hepmc_helper.set_vertex_distribution_width(x, y, z, t);
  }
  //
  void set_reuse_vertex(int src_embedding_id)
  {
    hepmc_helper.set_reuse_vertex(src_embedding_id);
  }
 
  void enableLegacyVtxGen()
  {
    _legacy_vertexgenerator=true;
    hepmc_helper.enableLegacyVtxGen();
  }
  double get_LegacyPARatio()
  {
    return hepmc_helper.get_LegacyPARatio();
  }
 
 
  int get_embedding_id() const { return hepmc_helper.get_embedding_id(); }
  //
  void set_embedding_id(int id) { hepmc_helper.set_embedding_id(id); }
  void save_integrated_luminosity(const bool b) { _save_integrated_luminosity = b; }
 private:
  int read_config(const char *cfg_file = 0);
  int read_config_hybrid (const char *cfg_file1 = 0, const char *cfg_file2 =0);
  int create_node_tree(PHCompositeNode *topNode);
  double percent_diff(const double a, const double b) { return abs((a - b) / a); }
  int _eventcount;
 
  // event selection
  std::vector<PHPy8GenTrigger *> _registeredTriggers;
  bool _triggersOR;
  bool _triggersAND;
 
  // PYTHIA
#ifndef __CINT__
  Pythia8::Pythia *_pythia;
  Pythia8::Pythia *ppGen;    
  Pythia8::Pythia *pnGen;    
#endif
 
  std::string _configFile;
  std::vector<std::string> _commands;
  
 
  // HepMC
  HepMC::Pythia8ToHepMC *_pythiaToHepMC;
 
  PHHepMCGenHelper hepmc_helper;
 
  bool _save_integrated_luminosity;
 
  PHGenIntegral *_integral_node;
 
  bool _legacy_vertexgenerator;
};
 
#endif /* __PHPYTHIA8_H__ */