PHG4Reco.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHG4Reco.h

// Tell emacs that this is a C++ source
//  -*- C++ -*-.
#ifndef G4MAIN_PHG4RECO_H
#define G4MAIN_PHG4RECO_H

#include <g4decayer/EDecayType.hh>

#include <fun4all/SubsysReco.h>

#include <phfield/PHFieldConfig.h>

#include <list>
#include <string>  // for string

// Forward declerations
class G4RunManager;
class G4TBMagneticFieldSetup;
class G4UImanager;
class G4UImessenger;
class G4VisManager;
class PHCompositeNode;
class PHG4DisplayAction;
class PHG4PhenixDetector;
class PHG4PhenixEventAction;
class PHG4PhenixStackingAction;
class PHG4PhenixSteppingAction;
class PHG4PhenixTrackingAction;
class PHG4PrimaryGeneratorAction;
class PHG4Subsystem;
class PHG4UIsession;

class PHG4Reco : public SubsysReco
{
 public:
  PHG4Reco(const std::string &name = "PHG4RECO");

  ~PHG4Reco() override;

  int Init(PHCompositeNode *) override;

  int InitRun(PHCompositeNode *topNode) override;

  int process_event(PHCompositeNode *) override;

  int ResetEvent(PHCompositeNode *) override;

  void Print(const std::string &what = std::string()) const override;

  void registerSubsystem(PHG4Subsystem *subsystem)
  {
    m_SubsystemList.push_back(subsystem);
  }

  int ApplyCommand(const std::string &cmd);

  int StartGui();

  int InitField(PHCompositeNode *topNode);

  void set_field(const float tesla)
  {
    m_MagneticField = tesla;
  }

  void set_field_map(const std::string &fmap, const PHFieldConfig::FieldConfigTypes dim)
  {
    m_FieldMapFile = fmap;
    m_FieldConfigType = dim;
  }

  void set_field_rescale(const float rescale) { m_MagneticFieldRescale = rescale; }

  void set_decayer_active(bool b) { m_ActiveDecayerFlag = b; }
  void set_force_decay(EDecayType force_decay_type)
  {
    m_ActiveDecayerFlag = true;
    m_ActiveForceDecayFlag = true;
    m_ForceDecayType = force_decay_type;
  }

  void save_DST_geometry(bool b) { m_SaveDstGeometryFlag = b; }
  void SetWorldSizeX(const double sx) { m_WorldSize[0] = sx; }
  void SetWorldSizeY(const double sy) { m_WorldSize[1] = sy; }
  void SetWorldSizeZ(const double sz) { m_WorldSize[2] = sz; }
  double GetWorldSizeX() const { return m_WorldSize[0]; }
  double GetWorldSizeY() const { return m_WorldSize[1]; }
  double GetWorldSizeZ() const { return m_WorldSize[2]; }
  void SetWorldShape(const std::string &s) { m_WorldShape = s; }
  void SetWorldMaterial(const std::string &s) { m_WorldMaterial = s; }
  void SetPhysicsList(const std::string &s) { m_PhysicsList = s; }
  void set_rapidity_coverage(const double eta);

  int setupInputEventNodeReader(PHCompositeNode *);

  static void G4Seed(const unsigned int i);

  PHG4Subsystem *getSubsystem(const std::string &name);
  PHG4DisplayAction *GetDisplayAction() { return m_DisplayAction; }
  void Dump_GDML(const std::string &filename);
  void Dump_G4_GDML(const std::string &filename);

  void G4Verbosity(const int i);

  void setDisableUserActions(bool b = true) { m_disableUserActions = b; }
  void ApplyDisplayAction();

 private:
  static void g4guithread(void *ptr);
  int InitUImanager();
  void DefineMaterials();
  void DefineRegions();

  float m_MagneticField = 0.;
  float m_MagneticFieldRescale;
  double m_WorldSize[3];

  G4TBMagneticFieldSetup *m_Field;

  G4RunManager *m_RunManager;

  PHG4UIsession *m_UISession;

  PHG4PhenixDetector *m_Detector;

  PHG4PhenixEventAction *m_EventAction;

  PHG4PhenixStackingAction *m_StackingAction = nullptr;

  PHG4PhenixSteppingAction *m_SteppingAction;

  PHG4PhenixTrackingAction *m_TrackingAction;


  PHG4DisplayAction *m_DisplayAction;

  PHG4PrimaryGeneratorAction *m_GeneratorAction;

  std::list<PHG4Subsystem *> m_SubsystemList;

  // visualization
  G4VisManager *m_VisManager;

  // Message interface to Fun4All
  G4UImessenger *m_Fun4AllMessenger;

  // for the G4 cmd line interface
  G4UImanager *m_UImanager;
  double m_EtaCoverage;
  PHFieldConfig::FieldConfigTypes m_FieldConfigType;
  std::string m_FieldMapFile;
  std::string m_WorldShape;
  std::string m_WorldMaterial;
  std::string m_PhysicsList;

  // settings for the external Pythia6 decayer
  bool m_ActiveDecayerFlag;     //< turn on/off decayer
  bool m_ActiveForceDecayFlag;  //< turn on/off force decay channels
  EDecayType m_ForceDecayType;  //< forced decay channel setting

  bool m_SaveDstGeometryFlag;
  bool m_disableUserActions;
};

#endif