SimPhotons.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_SIMULATION_SIMPHOTONS_H
#define LARDATAOBJ_SIMULATION_SIMPHOTONS_H

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_optical_vectors.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h"

// C/C++ standard libraries
#include <limits> // std::numeric_limits<>
#include <map>
#include <string>
#include <vector>

// -----------------------------------------------------------------------------
// forward declarations
namespace sim {
  struct OnePhoton;
  class SimPhotons;
  class SimPhotonsLite;
  class SimPhotonsCollection;

  bool operator<(OnePhoton const&, OnePhoton const&);

} // namespace sim

// -----------------------------------------------------------------------------
struct sim::OnePhoton {

  geo::Point_t InitialPosition;

  geo::OpticalPoint_t FinalLocalPosition;

  float Time{std::numeric_limits<float>::min()};

  float Energy{0.0};

  int MotherTrackID{std::numeric_limits<int>::min()};

  bool SetInSD{true};

}; // sim::OnePhoton

// -----------------------------------------------------------------------------
class sim::SimPhotonsLite {
public:
  SimPhotonsLite() = default;

  SimPhotonsLite(int chan) : OpChannel(chan) {}

  int OpChannel; 

  std::map<int, int> DetectedPhotons;

  SimPhotonsLite& operator+=(const SimPhotonsLite& rhs);

  SimPhotonsLite operator+(const SimPhotonsLite& rhs) const;

  bool operator==(const SimPhotonsLite& other) const;

}; // sim::SimPhotonsLite

// -----------------------------------------------------------------------------
class sim::SimPhotons : public std::vector<sim::OnePhoton> {

public:
  int fOpChannel; 

  // --- BEGIN -- Vector types -------------------------------------------------

  typedef std::vector<OnePhoton> list_type;
  typedef list_type::value_type value_type;
  typedef list_type::iterator iterator;
  typedef list_type::const_iterator const_iterator;
  typedef list_type::reverse_iterator reverse_iterator;
  typedef list_type::const_reverse_iterator const_reverse_iterator;
  typedef list_type::size_type size_type;
  typedef list_type::difference_type difference_type;

  // --- END -- Vector types ---------------------------------------------------

  SimPhotons() = default;

  SimPhotons(int chan) : fOpChannel(chan) {}

  int OpChannel() const;

  void SetChannel(int ch);

  SimPhotons& operator+=(const SimPhotons& rhs);

  SimPhotons operator+(const SimPhotons& rhs) const;

  bool operator==(const SimPhotons& other) const;

}; // sim::SimPhotons

// -----------------------------------------------------------------------------
class sim::SimPhotonsCollection : public std::map<int, sim::SimPhotons> {

  std::string fTheSDName; 

public:
  // --- BEGIN -- Vector types -------------------------------------------------
  typedef std::map<int, SimPhotons> list_type;
  typedef list_type::key_type key_type;
  typedef list_type::mapped_type mapped_type;
  typedef list_type::value_type value_type;
  typedef list_type::iterator iterator;
  typedef list_type::const_iterator const_iterator;
  typedef list_type::reverse_iterator reverse_iterator;
  typedef list_type::const_reverse_iterator const_reverse_iterator;
  typedef list_type::size_type size_type;
  typedef list_type::difference_type difference_type;
  typedef list_type::key_compare key_compare;
  typedef list_type::allocator_type allocator_type;

  // --- END -- Vector types ---------------------------------------------------

  SimPhotonsCollection() = default;

  std::string const& GetSDName() const;

  void SetSDName(std::string const& TheSDName);

}; // sim::SimPhotonsCollection

// =============================================================================
// ===  Inline implementations
// =============================================================================
// -----------------------------------------------------------------------------
// ---  sim::OnePhoton
// -----------------------------------------------------------------------------
inline bool sim::operator<(OnePhoton const& a, OnePhoton const& b)
{
  if (a.Time < b.Time) return true;
  if (a.Time > b.Time) return false;

  return (a.MotherTrackID < b.MotherTrackID);
} // sim::operator< (OnePhoton const&, OnePhoton const&)

// -----------------------------------------------------------------------------
// ---  sim::SimPhotonsLite
// -----------------------------------------------------------------------------
inline bool sim::SimPhotonsLite::operator==(const sim::SimPhotonsLite& other) const
{
  return OpChannel == other.OpChannel;
}

// -----------------------------------------------------------------------------
// ---  sim::SimPhotons
// -----------------------------------------------------------------------------

inline int sim::SimPhotons::OpChannel() const
{
  return fOpChannel;
}

inline void sim::SimPhotons::SetChannel(int ch)
{
  fOpChannel = ch;
}

inline bool sim::SimPhotons::operator==(const sim::SimPhotons& other) const
{
  return OpChannel() == other.OpChannel();
}

// -----------------------------------------------------------------------------
// ---  sim::SimPhotonsCollection
// -----------------------------------------------------------------------------

inline std::string const& sim::SimPhotonsCollection::GetSDName() const
{
  return fTheSDName;
}

inline void sim::SimPhotonsCollection::SetSDName(std::string const& TheSDName)
{
  fTheSDName = TheSDName;
}

// -----------------------------------------------------------------------------

#endif // LARDATAOBJ_SIMULATION_SIMPHOTONS_H