JetRecoEval.h

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

#ifndef G4EVAL_JETRECOEVAL_H
#define G4EVAL_JETRECOEVAL_H

#include "JetTruthEval.h"

#include <g4jets/Jet.h>

#include <map>
#include <set>
#include <string>
#include <utility>

class CaloEvalStack;

class JetMap;

class PHCompositeNode;

class PHG4Hit;
class PHG4Particle;
class PHG4Shower;

class RawClusterContainer;
class RawTowerContainer;

class SvtxEvalStack;
class SvtxTrackMap;

class JetRecoEval
{
 public:
  JetRecoEval(PHCompositeNode* topNode,
              const std::string& recojetname,
              const std::string& truthjetname);
  virtual ~JetRecoEval();

  void next_event(PHCompositeNode* topNode);

  void do_caching(bool do_cache)
  {
    _do_cache = do_cache;
    _jettrutheval.do_caching(do_cache);
  }

  void set_strict(bool strict)
  {
    _strict = strict;
    _jettrutheval.set_strict(strict);
  }

  unsigned int get_errors() { return _errors + _jettrutheval.get_errors(); }

  void set_verbosity(int verbosity)
  {
    _verbosity = verbosity;
    _jettrutheval.set_verbosity(verbosity);
  }

  JetTruthEval* get_truth_eval() { return &_jettrutheval; }

  SvtxEvalStack* get_svtx_eval_stack() { return _jettrutheval.get_svtx_eval_stack(); }

  CaloEvalStack* get_cemc_eval_stack() { return _jettrutheval.get_cemc_eval_stack(); }

  CaloEvalStack* get_hcalin_eval_stack() { return _jettrutheval.get_hcalin_eval_stack(); }

  CaloEvalStack* get_hcalout_eval_stack() { return _jettrutheval.get_hcalout_eval_stack(); }

  CaloEvalStack* get_femc_eval_stack() { return _jettrutheval.get_femc_eval_stack(); }

  CaloEvalStack* get_fhcal_eval_stack() { return _jettrutheval.get_fhcal_eval_stack(); }

  CaloEvalStack* get_eemc_eval_stack() { return _jettrutheval.get_eemc_eval_stack(); }
  // ---reduced sim node or better----------------------------------------------

  std::set<PHG4Shower*> all_truth_showers(Jet* recojet);

  std::set<PHG4Particle*> all_truth_particles(Jet* recojet);

  std::set<Jet*> all_truth_jets(Jet* recojet);

  Jet* max_truth_jet_by_energy(Jet* recojet);

  std::set<Jet*> all_jets_from(Jet* truthjet);

  Jet* best_jet_from(Jet* truthjet);

  Jet* unique_reco_jet_from_truth(Jet* truthjet);

  Jet* unique_truth_jet_from_reco(Jet* recojet);

  float get_energy_contribution(Jet* recojet, Jet* truthjet);

  float get_energy_contribution(Jet* recojet, Jet::SRC src);

  void set_track_nodename(const std::string& name);

  // ---full sim node required--------------------------------------------------

  std::set<PHG4Hit*> all_truth_hits(Jet* recojet);

 private:
  void get_node_pointers(PHCompositeNode* topNode);

  JetTruthEval _jettrutheval;
  std::string _recojetname;
  std::string _truthjetname;

  JetMap* _recojets;
  JetMap* _truthjets;

  SvtxTrackMap* _trackmap;
  RawTowerContainer* _cemctowers;
  RawClusterContainer* _cemcclusters;
  RawTowerContainer* _hcalintowers;
  RawClusterContainer* _hcalinclusters;
  RawTowerContainer* _hcalouttowers;
  RawClusterContainer* _hcaloutclusters;
  RawTowerContainer* _femctowers;
  RawClusterContainer* _femcclusters;
  RawTowerContainer* _fhcaltowers;
  RawClusterContainer* _fhcalclusters;
  RawTowerContainer* _eemctowers;
  RawClusterContainer* _eemcclusters;

  bool _strict;
  int _verbosity;
  unsigned int _errors;

  bool _do_cache;
  std::map<Jet*, std::set<PHG4Shower*> > _cache_all_truth_showers;
  std::map<Jet*, std::set<PHG4Particle*> > _cache_all_truth_particles;
  std::map<Jet*, std::set<Jet*> > _cache_all_truth_jets;
  std::map<Jet*, Jet*> _cache_max_truth_jet_by_energy;
  std::map<Jet*, std::set<Jet*> > _cache_all_jets_from;
  std::map<Jet*, Jet*> _cache_best_jet_from;
  std::map<std::pair<Jet*, Jet*>, float> _cache_get_energy_contribution;
  std::map<std::pair<Jet*, Jet::SRC>, float> _cache_get_energy_contribution_src;  
  std::map<Jet*, std::set<PHG4Hit*> > _cache_all_truth_hits;
  std::string m_TrackNodeName = "SvtxTrackMap";
};

#endif  // G4EVAL_JETRECOEVAL_H