CaloRawClusterEval.h

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

#ifndef G4EVAL_CALORAWCLUSTEREVAL_H
#define G4EVAL_CALORAWCLUSTEREVAL_H

#include "CaloRawTowerEval.h"
#include "CaloTruthEval.h"

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

class PHCompositeNode;
class PHG4Hit;
class PHG4Particle;
class PHG4Shower;
class RawClusterContainer;
class RawCluster;
class RawTowerContainer;

class CaloRawClusterEval
{
 public:
  CaloRawClusterEval(PHCompositeNode* topNode, const std::string& caloname);
  virtual ~CaloRawClusterEval();

  int get_caloid() { return get_truth_eval()->get_caloid(); }

  void next_event(PHCompositeNode* topNode);

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

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

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

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

  CaloTruthEval* get_truth_eval() { return _towereval.get_truth_eval(); }

  CaloRawTowerEval* get_rawtower_eval() { return &_towereval; }

  // ---reduced sim node or better----------------------------------------------

  bool has_reduced_node_pointers();

  // shower interface

  std::set<PHG4Shower*> all_truth_primary_showers(RawCluster* cluster);

  PHG4Shower* max_truth_primary_shower_by_energy(RawCluster* cluster);

  std::set<RawCluster*> all_clusters_from(PHG4Shower* primary);

  RawCluster* best_cluster_from(PHG4Shower* primary);

  float get_energy_contribution(RawCluster* cluster, PHG4Shower* primary);

  // particle interface

  std::set<PHG4Particle*> all_truth_primary_particles(RawCluster* cluster);

  PHG4Particle* max_truth_primary_particle_by_energy(RawCluster* cluster);

  std::set<RawCluster*> all_clusters_from(PHG4Particle* primary);

  RawCluster* best_cluster_from(PHG4Particle* primary);

  float get_energy_contribution(RawCluster* cluster, PHG4Particle* primary);

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

  bool has_full_node_pointers();

  std::set<PHG4Hit*> all_truth_hits(RawCluster* cluster);

 private:
  void get_node_pointers(PHCompositeNode* topNode);

  std::string _caloname;
  CaloRawTowerEval _towereval;
  RawClusterContainer* _clusters = nullptr;
  RawTowerContainer* _towers = nullptr;

  bool _strict = false;
  int _verbosity = 1;
  unsigned int _errors = 0;

  bool _do_cache = true;
  std::map<RawCluster*, std::set<PHG4Shower*> > _cache_all_truth_primary_showers;
  std::map<RawCluster*, PHG4Shower*> _cache_max_truth_primary_shower_by_energy;
  std::map<PHG4Shower*, std::set<RawCluster*> > _cache_all_clusters_from_primary_shower;
  std::map<PHG4Shower*, RawCluster*> _cache_best_cluster_from_primary_shower;
  std::map<std::pair<RawCluster*, PHG4Shower*>, float> _cache_get_energy_contribution_primary_shower;

  std::map<RawCluster*, std::set<PHG4Particle*> > _cache_all_truth_primary_particles;
  std::map<RawCluster*, PHG4Particle*> _cache_max_truth_primary_particle_by_energy;
  std::map<PHG4Particle*, std::set<RawCluster*> > _cache_all_clusters_from_primary_particle;
  std::map<PHG4Particle*, RawCluster*> _cache_best_cluster_from_primary_particle;
  std::map<std::pair<RawCluster*, PHG4Particle*>, float> _cache_get_energy_contribution_primary_particle;

  std::map<RawCluster*, std::set<PHG4Hit*> > _cache_all_truth_hits;
};

#endif  // G4EVAL_CALORAWCLUSTEREVAL_H