MergeSimSources_module.cc

Go to the documentation of this file.

// Class:       MergeSimSources
// Module Type: producer
// File:        MergeSimSources_module.cc
//
// Generated at Tue Feb 17 12:16:35 2015 by Wesley Ketchum using artmod
// from cetpkgsupport v1_08_02.

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Utilities/Exception.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/OptionalAtom.h"
#include "fhiclcpp/types/Sequence.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/FindOneP.h"

#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "MergeSimSources.h"
#include "larcorealg/CoreUtils/counter.h"
#include "larcorealg/CoreUtils/enumerate.h"
#include "larcorealg/CoreUtils/zip.h"
#include "lardataobj/Simulation/AuxDetHit.h"
#include "lardataobj/Simulation/GeneratedParticleInfo.h"
#include "lardataobj/Simulation/SimChannel.h"
#include "lardataobj/Simulation/SimEnergyDeposit.h"
#include "lardataobj/Simulation/SimPhotons.h"
#include "larsim/Simulation/LArG4Parameters.h"
#include "nusimdata/SimulationBase/MCParticle.h"
#include "nusimdata/SimulationBase/MCTruth.h"

namespace sim {
  class MergeSimSources;
}

class sim::MergeSimSources : public art::EDProducer {
public:
  struct Config {

    fhicl::Sequence<art::InputTag> InputSourcesLabels{
      fhicl::Name{"InputSourcesLabels"},
      fhicl::Comment{"label of the LArG4 products to merge"}};

    fhicl::Sequence<int> TrackIDOffsets{
      fhicl::Name{"TrackIDOffsets"},
      fhicl::Comment{"offset to add to the MC particles from each source"}};

    fhicl::Atom<bool> StoreReflected{
      fhicl::Name{"StoreReflected"},
      fhicl::Comment{"whether to merge also photons from reflections"},
      false // default
    };

    fhicl::Atom<bool> FillMCParticles{
      fhicl::Name{"FillMCParticles"},
      fhicl::Comment{"whether to merge MCParticle"},
      true // default
    };

    fhicl::Atom<bool> FillSimPhotons{
      fhicl::Name{"FillSimPhotons"},
      fhicl::Comment{"whether to merge SimPhotons"},
      true // default
    };

    fhicl::Atom<bool> FillSimChannels{
      fhicl::Name{"FillSimChannels"},
      fhicl::Comment{"whether to merge SimChannels"},
      true // default
    };

    fhicl::Atom<bool> FillAuxDetSimChannels{
      fhicl::Name{"FillAuxDetSimChannels"},
      fhicl::Comment{"whether to merge AuxDetSimChannels"},
      true // default
    };

    fhicl::OptionalAtom<bool> FillSimEnergyDeposits{
      fhicl::Name{"FillSimEnergyDeposits"},
      fhicl::Comment{"merges energy deposit collection; if omitted, follows LArG4Parmeters"}};

    fhicl::Sequence<std::string> EnergyDepositInstanceLabels{
      fhicl::Name{"EnergyDepositInstanceLabels"},
      fhicl::Comment{"labels of sim::SimEnergyDeposit collections to merge"},
      std::vector<std::string>{"TPCActive", "Other"} // default
    };

    fhicl::Atom<bool> FillAuxDetHits{
      fhicl::Name{"FillAuxDetHits"},
      fhicl::Comment{"whether to merge aux det hit collections"},
      false // default
    };

    fhicl::Sequence<std::string> AuxDetHitsInstanceLabels{
      fhicl::Name{"AuxDetHitsInstanceLabels"},
      fhicl::Comment{"labels of AuxDetHits collections to merge"},
      std::vector<std::string>{"LArG4DetectorServicevolAuxDetSensitiveCRTStripY",
                               "Other"} // default
    };

    fhicl::Atom<bool> FillParticleAncestryMaps{
      fhicl::Name{"FillParticleAncestryMaps"},
      fhicl::Comment{"whether to merge particle ancestry maps"},
      true};

  }; // struct Config

  using Parameters = art::EDProducer::Table<Config>;

  explicit MergeSimSources(Parameters const& config);

  // Required functions.
  void produce(art::Event& e) override;

private:
  std::vector<art::InputTag> const fInputSourcesLabels;
  std::vector<int> const fTrackIDOffsets;
  bool const fUseLitePhotons;
  bool const fStoreReflected;
  bool const fFillMCParticles;
  bool const fFillSimPhotons;
  bool const fFillSimChannels;
  bool const fFillAuxDetSimChannels;
  bool const fFillSimEnergyDeposits;
  std::vector<std::string> const fEnergyDepositionInstances;
  bool const fFillAuxDetHits;
  std::vector<std::string> const fAuxDetHitsInstanceLabels;
  bool const fFillParticleAncestryMaps;

  static std::string const ReflectedLabel;

  void dumpConfiguration() const;
};

namespace {

  template <typename Optional>
  std::optional<typename Optional::value_type> getOptionalValue(Optional const& parameter)
  {

    using Value_t = typename Optional::value_type;

    if (!parameter.hasValue()) return std::nullopt;

    Value_t value;
    parameter(value);
    return {value};

  } // getOptionalValue(Optional& parameter)

} // local namespace

std::string const sim::MergeSimSources::ReflectedLabel{"Reflected"};

sim::MergeSimSources::MergeSimSources(Parameters const& params)
  : EDProducer{params}
  , fInputSourcesLabels(params().InputSourcesLabels())
  , fTrackIDOffsets(params().TrackIDOffsets())
  , fUseLitePhotons(art::ServiceHandle<sim::LArG4Parameters const>()->UseLitePhotons())
  , fStoreReflected(params().StoreReflected())
  , fFillMCParticles(params().FillMCParticles())
  , fFillSimPhotons(params().FillSimPhotons())
  , fFillSimChannels(params().FillSimChannels())
  , fFillAuxDetSimChannels(params().FillAuxDetSimChannels())
  , fFillSimEnergyDeposits(
      getOptionalValue(params().FillSimEnergyDeposits)
        .value_or(art::ServiceHandle<sim::LArG4Parameters const>()->FillSimEnergyDeposits()))
  , fEnergyDepositionInstances(params().EnergyDepositInstanceLabels())
  , fFillAuxDetHits(params().FillAuxDetHits())
  , fAuxDetHitsInstanceLabels(params().AuxDetHitsInstanceLabels())
  , fFillParticleAncestryMaps(params().FillParticleAncestryMaps())
{

  if (fInputSourcesLabels.size() != fTrackIDOffsets.size()) {
    throw art::Exception(art::errors::Configuration)
      << "Unequal input vector sizes: InputSourcesLabels and TrackIDOffsets.\n";
  }

  for (art::InputTag const& tag : fInputSourcesLabels) {

    if (fFillMCParticles) {
      consumes<std::vector<simb::MCParticle>>(tag);
      consumes<art::Assns<simb::MCParticle, simb::MCTruth, sim::GeneratedParticleInfo>>(tag);
    }

    if (fFillSimChannels) { consumes<std::vector<sim::SimChannel>>(tag); }

    if (fFillAuxDetSimChannels) { consumes<std::vector<sim::AuxDetSimChannel>>(tag); }

    if (fFillSimPhotons) {
      if (!fUseLitePhotons)
        consumes<std::vector<sim::SimPhotons>>(tag);
      else
        consumes<std::vector<sim::SimPhotonsLite>>(tag);

      if (fStoreReflected) {
        art::InputTag const reflected_tag{tag.label(), ReflectedLabel};
        if (!fUseLitePhotons)
          consumes<std::vector<sim::SimPhotons>>(reflected_tag);
        else
          consumes<std::vector<sim::SimPhotonsLite>>(reflected_tag);
      }
    }

    if (fFillSimEnergyDeposits) {
      for (std::string const& edep_inst : fEnergyDepositionInstances) {
        art::InputTag const edep_tag{tag.label(), edep_inst};
        consumes<std::vector<sim::SimEnergyDeposit>>(edep_tag);
      }
    } // if fill energy deposits

    if (fFillAuxDetHits) {
      for (std::string const& auxdethit_inst : fAuxDetHitsInstanceLabels) {
        art::InputTag const auxdethit_tag{tag.label(), auxdethit_inst};
        consumes<std::vector<sim::AuxDetHit>>(auxdethit_tag);
      }
    }

    if (fFillParticleAncestryMaps) { consumes<sim::ParticleAncestryMap>(tag); }

  } // for input labels

  if (fFillMCParticles) {
    produces<std::vector<simb::MCParticle>>();
    produces<art::Assns<simb::MCTruth, simb::MCParticle, sim::GeneratedParticleInfo>>();
  }
  if (fFillSimChannels) { produces<std::vector<sim::SimChannel>>(); }
  if (fFillAuxDetSimChannels) { produces<std::vector<sim::AuxDetSimChannel>>(); }

  if (fFillSimPhotons) {
    if (!fUseLitePhotons)
      produces<std::vector<sim::SimPhotons>>();
    else
      produces<std::vector<sim::SimPhotonsLite>>();

    if (fStoreReflected) {
      if (!fUseLitePhotons)
        produces<std::vector<sim::SimPhotons>>(ReflectedLabel);
      else
        produces<std::vector<sim::SimPhotonsLite>>(ReflectedLabel);
    }
  }

  if (fFillSimEnergyDeposits) {
    for (std::string const& edep_inst : fEnergyDepositionInstances)
      produces<std::vector<sim::SimEnergyDeposit>>(edep_inst);
  } // if

  if (fFillAuxDetHits) {
    for (std::string const& auxdethit_inst : fAuxDetHitsInstanceLabels)
      produces<std::vector<sim::AuxDetHit>>(auxdethit_inst);
  }

  if (fFillParticleAncestryMaps) { produces<std::vector<sim::ParticleAncestryMap>>(); }

  dumpConfiguration();
}

void sim::MergeSimSources::produce(art::Event& e)
{

  auto partCol = std::make_unique<std::vector<simb::MCParticle>>();
  auto scCol = std::make_unique<std::vector<sim::SimChannel>>();
  auto PhotonCol = std::make_unique<std::vector<sim::SimPhotons>>();
  auto LitePhotonCol = std::make_unique<std::vector<sim::SimPhotonsLite>>();
  auto ReflPhotonCol = std::make_unique<std::vector<sim::SimPhotons>>();
  auto ReflLitePhotonCol = std::make_unique<std::vector<sim::SimPhotonsLite>>();
  auto tpassn =
    std::make_unique<art::Assns<simb::MCTruth, simb::MCParticle, sim::GeneratedParticleInfo>>();
  auto adCol = std::make_unique<std::vector<sim::AuxDetSimChannel>>();
  auto pamCol = std::make_unique<std::vector<sim::ParticleAncestryMap>>();

  using edeps_t = std::vector<sim::SimEnergyDeposit>;
  std::vector<edeps_t> edepCols;
  if (fFillSimEnergyDeposits) edepCols.resize(fEnergyDepositionInstances.size());

  using aux_det_hits_t = std::vector<sim::AuxDetHit>;
  std::vector<aux_det_hits_t> auxdethitCols;
  if (fFillAuxDetHits) auxdethitCols.resize(fAuxDetHitsInstanceLabels.size());

  MergeSimSourcesUtility MergeUtility{fTrackIDOffsets};

  for (auto const& [i_source, input_label] : util::enumerate(fInputSourcesLabels)) {

    if (fFillMCParticles) {
      art::PtrMaker<simb::MCParticle> const makePartPtr{e};
      auto const input_partCol = e.getValidHandle<std::vector<simb::MCParticle>>(input_label);
      MergeUtility.MergeMCParticles(*partCol, *input_partCol, i_source);

      //truth-->particle assoc stuff here
      const std::vector<size_t>& assocVectorPrimitive =
        MergeUtility.GetMCParticleListMap().at(i_source);
      art::FindOneP<simb::MCTruth, sim::GeneratedParticleInfo> mctAssn(
        input_partCol, e, input_label);
      for (auto const i_p : util::counter(mctAssn.size()))
        tpassn->addSingle(
          mctAssn.at(i_p), makePartPtr(assocVectorPrimitive[i_p]), mctAssn.data(i_p).ref());
    }

    if (fFillSimChannels) {
      auto const& input_scCol = e.getProduct<std::vector<sim::SimChannel>>(input_label);
      MergeUtility.MergeSimChannels(*scCol, input_scCol, i_source);
    }

    if (fFillAuxDetSimChannels) {
      auto const& input_adCol = e.getProduct<std::vector<sim::AuxDetSimChannel>>(input_label);
      MergeUtility.MergeAuxDetSimChannels(*adCol, input_adCol, i_source);
    }

    if (fFillSimPhotons) {
      if (!fUseLitePhotons) {
        auto const& input_PhotonCol = e.getProduct<std::vector<sim::SimPhotons>>(input_label);
        MergeUtility.MergeSimPhotons(*PhotonCol, input_PhotonCol);
      }
      else {
        auto const& input_LitePhotonCol =
          e.getProduct<std::vector<sim::SimPhotonsLite>>(input_label);
        MergeUtility.MergeSimPhotonsLite(*LitePhotonCol, input_LitePhotonCol);
      }

      if (fStoreReflected) {
        art::InputTag const input_reflected_label{input_label.label(), ReflectedLabel};
        if (!fUseLitePhotons) {
          auto const& input_PhotonCol =
            e.getProduct<std::vector<sim::SimPhotons>>(input_reflected_label);
          MergeUtility.MergeSimPhotons(*ReflPhotonCol, input_PhotonCol);
        }
        else {
          auto const& input_LitePhotonCol =
            e.getProduct<std::vector<sim::SimPhotonsLite>>(input_reflected_label);
          MergeUtility.MergeSimPhotonsLite(*ReflLitePhotonCol, input_LitePhotonCol);
        }
      }
    }

    if (fFillSimEnergyDeposits) {
      for (auto const& [edep_inst, edepCol] : util::zip(fEnergyDepositionInstances, edepCols)) {
        art::InputTag const edep_tag{input_label.label(), edep_inst};
        MergeUtility.MergeSimEnergyDeposits(edepCol, e.getProduct<edeps_t>(edep_tag), i_source);
      } // for edep
    }   // if fill energy depositions

    if (fFillAuxDetHits) {
      for (auto const& [auxdethit_inst, auxdethitCol] :
           util::zip(fAuxDetHitsInstanceLabels, auxdethitCols)) {
        art::InputTag const auxdethit_tag{input_label.label(), auxdethit_inst};
        MergeUtility.MergeAuxDetHits(
          auxdethitCol, e.getProduct<aux_det_hits_t>(auxdethit_tag), i_source);
      }

      if (fFillParticleAncestryMaps) {
        auto const& input_pamCol = e.getProduct<sim::ParticleAncestryMap>(input_label);
        MergeUtility.MergeParticleAncestryMaps(*pamCol, input_pamCol, i_source);
      }
    }
  }

  if (fFillMCParticles) {
    e.put(std::move(partCol));
    e.put(std::move(tpassn));
  }
  if (fFillSimChannels) { e.put(std::move(scCol)); }
  if (fFillAuxDetSimChannels) { e.put(std::move(adCol)); }
  if (fFillSimPhotons) {
    if (!fUseLitePhotons)
      e.put(std::move(PhotonCol));
    else
      e.put(std::move(LitePhotonCol));
    if (fStoreReflected) {
      if (!fUseLitePhotons)
        e.put(std::move(ReflPhotonCol), ReflectedLabel);
      else
        e.put(std::move(ReflLitePhotonCol), ReflectedLabel);
    }
  }

  if (fFillSimEnergyDeposits) {
    for (auto&& [edep_inst, edepCol] : util::zip(fEnergyDepositionInstances, edepCols)) {
      e.put(std::make_unique<edeps_t>(move(edepCol)), edep_inst);
    } // for
  }   // if fill energy deposits

  if (fFillAuxDetHits) {
    for (auto&& [auxdethit_inst, auxdethitCol] :
         util::zip(fAuxDetHitsInstanceLabels, auxdethitCols)) {
      e.put(std::make_unique<aux_det_hits_t>(move(auxdethitCol)), auxdethit_inst);
    }
  }

  if (fFillParticleAncestryMaps) { e.put(std::move(pamCol)); }
}

void sim::MergeSimSources::dumpConfiguration() const
{

  mf::LogInfo log("MergeSimSources");
  log << "Configuration:"
      << "\n - " << fInputSourcesLabels.size() << " input sources:";
  for (auto const& [i_source, tag, offset] :
       util::enumerate(fInputSourcesLabels, fTrackIDOffsets)) {
    log << "\n   [" << i_source << "] '" << tag.encode() << "' (ID offset: " << offset << ")";
  } // for
  if (fFillMCParticles) log << "\n - filling MCParticles";

  if (fFillSimChannels) log << "\n - filling SimChannels";

  if (fFillAuxDetSimChannels) log << "\n - filling AuxDetSimChannels";

  if (fFillSimPhotons) {
    log << "\n - filling Simulated Photons";
    if (fUseLitePhotons)
      log << "\n   - using photon summary (`SimPhotonsLite`)";
    else
      log << "\n   - using detailed photons (`SimPhotons`)";
    if (fStoreReflected) log << "\n   - also merging reflected light";
  }

  if (fFillSimEnergyDeposits) {
    log << "\n - filling simulated energy deposits (" << fEnergyDepositionInstances.size()
        << " labels:";
    for (std::string const& label : fEnergyDepositionInstances)
      log << " '" << label << "'";
    log << ")";
  }

  if (fFillAuxDetHits) {
    log << "\n - filling auxiliary detector hits (" << fAuxDetHitsInstanceLabels.size()
        << " labels:";
    for (std::string const& label : fAuxDetHitsInstanceLabels)
      log << " '" << label << "'";
    log << ")";
  }

  if (fFillParticleAncestryMaps) log << "\n - filling ParticleAncestryMaps";

} // sim::MergeSimSources::dumpConfiguration()

DEFINE_ART_MODULE(sim::MergeSimSources)