DumpSimPhotons_module.cc

Go to the documentation of this file.

// lar libraries
#include "larcorealg/CoreUtils/SortByPointers.h" // util::makePointerVector()
#include "lardataobj/Simulation/SimPhotons.h"

// framework libraries
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/types/Atom.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

namespace sim {
  class DumpSimPhotons;
} // namespace sim

namespace {
  using namespace fhicl;

  struct Config {
    using Name = fhicl::Name;
    using Comment = fhicl::Comment;

    fhicl::Atom<art::InputTag> InputPhotons{
      Name("InputPhotons"),
      Comment("data product with the SimPhotons to be dumped")};

    fhicl::Atom<std::string> OutputCategory{
      Name("OutputCategory"),
      Comment("name of the output stream (managed by the message facility)"),
      "DumpSimPhotons" /* default value */
    };

  }; // struct Config

  struct OnePhotonSorter {

    bool operator()(sim::OnePhoton const& a, sim::OnePhoton const& b) const
    {
      auto res = cmp(a.Time, b.Time);
      if (res < 0) return true;
      if (res > 0) return false;

      res = cmp(a.MotherTrackID, b.MotherTrackID);
      if (res < 0) return true;
      if (res > 0) return false;

      res = cmp(a.Energy, b.Energy);
      if (res < 0) return true;
      if (res > 0) return false;

      res = cmp(a.InitialPosition.Z(), b.InitialPosition.Z());
      if (res < 0) return true;
      if (res > 0) return false;

      res = cmp(a.InitialPosition.Y(), b.InitialPosition.Y());
      if (res < 0) return true;
      if (res > 0) return false;

      res = cmp(a.InitialPosition.X(), b.InitialPosition.X());
      if (res < 0) return true;
      if (res > 0) return false;

      return false; //
    }               // operator()

    bool operator()(sim::OnePhoton const* a, sim::OnePhoton const* b) const
    {
      return operator()(*a, *b);
    }

    // TODO when C++20 is supported, this becomes `return a <=> b;`
    template <typename T, typename U>
    static int cmp(T const& a, U const& b)
    {
      if (a < b) return -1;
      if (a == b)
        return 0;
      else
        return +1;
    }

  }; // struct OnePhotonSorter

} // local namespace

class sim::DumpSimPhotons : public art::EDAnalyzer {
public:
  // type to enable module parameters description by art
  using Parameters = art::EDAnalyzer::Table<Config>;

  explicit DumpSimPhotons(Parameters const& config);

  // Plugins should not be copied or assigned.
  DumpSimPhotons(DumpSimPhotons const&) = delete;
  DumpSimPhotons(DumpSimPhotons&&) = delete;
  DumpSimPhotons& operator=(DumpSimPhotons const&) = delete;
  DumpSimPhotons& operator=(DumpSimPhotons&&) = delete;

  // Operates on the event
  void analyze(art::Event const& event) override;

  template <typename Stream>
  void DumpElement(Stream&& out,
                   sim::SimPhotons const& simphotons,
                   std::string indent = "",
                   bool bIndentFirst = true) const;

  template <typename Stream>
  void DumpOnePhoton(Stream&& out, sim::OnePhoton const& photon) const;

private:
  art::InputTag fInputPhotons; 
  std::string fOutputCategory; 

}; // class sim::DumpSimPhotons

//------------------------------------------------------------------------------
//---  module implementation
//---
//------------------------------------------------------------------------------
sim::DumpSimPhotons::DumpSimPhotons(Parameters const& config)
  : EDAnalyzer(config)
  , fInputPhotons(config().InputPhotons())
  , fOutputCategory(config().OutputCategory())
{}

//------------------------------------------------------------------------------
template <typename Stream>
void sim::DumpSimPhotons::DumpOnePhoton(Stream&& out, sim::OnePhoton const& onephoton) const
{
  out << "E=" << onephoton.Energy << " t=" << onephoton.Time << " from "
      << onephoton.InitialPosition << " cm"
      << " to " << onephoton.FinalLocalPosition << " cm";
  if (onephoton.SetInSD) out << " [in SD]"; // in sensitive detector?
  out << " from track ID=" << onephoton.MotherTrackID;
} // sim::DumpSimPhotons::DumpOnePhoton()

//------------------------------------------------------------------------------
template <typename Stream>
void sim::DumpSimPhotons::DumpElement(Stream&& out,
                                      sim::SimPhotons const& simphotons,
                                      std::string indent /* = "" */,
                                      bool bIndentFirst /* = true */
) const
{
  if (bIndentFirst) out << indent;
  out << "channel=" << simphotons.OpChannel() << " has ";
  if (simphotons.empty()) { out << simphotons.size() << " no photons"; }
  else {
    out << simphotons.size() << " photons:";

    auto sortedPhotonPtrs = util::makePointerVector(simphotons);
    std::sort(sortedPhotonPtrs.begin(), sortedPhotonPtrs.end(), OnePhotonSorter());

    for (auto const* onephoton : sortedPhotonPtrs) {
      out << "\n" << indent << "  ";
      DumpOnePhoton(out, *onephoton);
    } // for
  }

} // sim::DumpSimPhotons::DumpSimPhotons()

//------------------------------------------------------------------------------
void sim::DumpSimPhotons::analyze(art::Event const& event)
{

  // get the particles from the event
  auto const& SimPhotons = *(event.getValidHandle<std::vector<sim::SimPhotons>>(fInputPhotons));

  mf::LogVerbatim(fOutputCategory)
    << "Event " << event.id() << " : data product '" << fInputPhotons.encode() << "' contains "
    << SimPhotons.size() << " SimPhotons";

  unsigned int iPhoton = 0;
  for (sim::SimPhotons const& photons : SimPhotons) {

    mf::LogVerbatim log(fOutputCategory);
    // a bit of a header
    log << "[#" << (iPhoton++) << "] ";
    DumpElement(log, photons, "  ", false);

  }                                         // for
  mf::LogVerbatim(fOutputCategory) << "\n"; // just an empty line

} // sim::DumpSimPhotons::analyze()

//------------------------------------------------------------------------------
DEFINE_ART_MODULE(sim::DumpSimPhotons)

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