nnet::TrainingDataAlg Class Reference

#include "PointIdAlg.h"

Inheritance diagram for nnet::TrainingDataAlg:

Classes
struct	Config
struct	WireDrift

Public Types
enum	EMask { kNone = 0, kPdgMask = 0x00000FFF, kTypeMask = 0x0000F000, kVtxMask = 0xFFFF0000 }
enum	ETrkType { kDelta = 0x1000, kMichel = 0x2000, kPriEl = 0x4000, kPriMu = 0x8000 }
enum	EVtxId {   kNuNC = 0x0010000, kNuCC = 0x0020000, kNuPri = 0x0040000, kNuE = 0x0100000,   kNuMu = 0x0200000, kNuTau = 0x0400000, kHadr = 0x1000000, kPi0 = 0x2000000,   kDecay = 0x4000000, kConv = 0x8000000, kElectronEnd = 0x10000000, kElastic = 0x20000000,   kInelastic = 0x40000000 }
enum	EDownscaleMode { kMax = 1, kMaxMean = 2, kMean = 3 }

Public Member Functions
	TrainingDataAlg (const fhicl::ParameterSet &pset)
	TrainingDataAlg (const Config &config)
	~TrainingDataAlg () override
void	reconfigure (const Config &config)
bool	saveSimInfo () const
bool	setEventData (const art::Event &event, detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, unsigned int plane, unsigned int tpc, unsigned int cryo)
bool	setDataEventData (const art::Event &event, detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, unsigned int plane, unsigned int tpc, unsigned int cryo)
bool	findCrop (float max_e_cut, unsigned int &w0, unsigned int &w1, unsigned int &d0, unsigned int &d1) const
double	getEdepTot () const
std::vector< float > const &	wireEdep (size_t widx) const
std::vector< int > const &	wirePdg (size_t widx) const
bool	setWireDriftData (const detinfo::DetectorClocksData &clock_data, const detinfo::DetectorPropertiesData &det_prop, const std::vector< recob::Wire > &wires, unsigned int plane, unsigned int tpc, unsigned int cryo)
std::vector< float > const &	wireData (size_t widx) const
std::vector< std::vector< float > >	getPatch (size_t wire, float drift, size_t patchSizeW, size_t patchSizeD) const
float	getPixelOrZero (int wire, int drift) const
double	getAdcSum () const
size_t	getAdcArea () const
float	poolMax (int wire, int drift, size_t r=0) const
	Pool max value in a patch around the wire/drift pixel. More...
unsigned int	Cryo () const
	Pool sum of pixels in a patch around the wire/drift pixel. More...
unsigned int	TPC () const
unsigned int	Plane () const
unsigned int	NWires () const
unsigned int	NScaledDrifts () const
unsigned int	NCachedDrifts () const
unsigned int	DriftWindow () const
float	ZeroLevel () const
	Level of zero ADC after scaling. More...
double	LifetimeCorrection (detinfo::DetectorClocksData const &clock_data, detinfo::DetectorPropertiesData const &det_prop, double tick) const

Protected Member Functions
img::DataProviderAlgView	resizeView (detinfo::DetectorClocksData const &clock_data, detinfo::DetectorPropertiesData const &det_prop, size_t wires, size_t drifts) override
std::vector< float >	downscaleMax (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscaleMaxMean (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscaleMean (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscale (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
size_t	getDriftIndex (float drift) const
std::optional< std::vector< float > >	setWireData (std::vector< float > const &adc, size_t wireIdx) const
bool	patchFromDownsampledView (size_t wire, float drift, size_t size_w, size_t size_d, std::vector< std::vector< float >> &patch) const
bool	patchFromOriginalView (size_t wire, float drift, size_t size_w, size_t size_d, std::vector< std::vector< float >> &patch) const

Protected Attributes
DataProviderAlgView	fAlgView
EDownscaleMode	fDownscaleMode
size_t	fDriftWindow
bool	fDownscaleFullView
float	fDriftWindowInv
calo::CalorimetryAlg	fCalorimetryAlg
geo::Geometry const *	fGeometry
geo::WireReadoutGeom const *	fWireReadoutGeom

Private Member Functions
WireDrift	getProjection (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TLorentzVector &tvec, unsigned int plane) const
bool	setWireEdepsAndLabels (std::vector< float > const &edeps, std::vector< int > const &pdgs, size_t wireIdx)
void	collectVtxFlags (std::unordered_map< size_t, std::unordered_map< int, int >> &wireToDriftToVtxFlags, detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const std::unordered_map< int, const simb::MCParticle * > &particleMap, unsigned int plane) const
bool	isElectronEnd (const simb::MCParticle &particle, const std::unordered_map< int, const simb::MCParticle * > &particleMap) const
bool	isMuonDecaying (const simb::MCParticle &particle, const std::unordered_map< int, const simb::MCParticle * > &particleMap) const

Static Private Member Functions
static float	particleRange2 (const simb::MCParticle &particle)

Private Attributes
double	fEdepTot
std::vector< std::vector< float > >	fWireDriftEdep
std::vector< std::vector< int > >	fWireDriftPdg
art::InputTag	fWireProducerLabel
art::InputTag	fHitProducerLabel
art::InputTag	fTrackModuleLabel
art::InputTag	fSimulationProducerLabel
art::InputTag	fSimChannelProducerLabel
bool	fSaveVtxFlags
bool	fSaveSimInfo
unsigned int	fAdcDelay
std::vector< size_t >	fEventsPerBin

Detailed Description

Definition at line 192 of file PointIdAlg.h.

Member Enumeration Documentation

enum img::DataProviderAlg::EDownscaleMode

inherited

Enumerator
kMax
kMaxMean
kMean

Definition at line 62 of file DataProviderAlg.h.

{ kMax = 1, kMaxMean = 2, kMean = 3 };

enum nnet::TrainingDataAlg::EMask

Enumerator
kNone
kPdgMask
kTypeMask
kVtxMask

Definition at line 194 of file PointIdAlg.h.

             {
    kNone = 0,
    kPdgMask = 0x00000FFF,  // pdg code mask
    kTypeMask = 0x0000F000, // track type mask
    kVtxMask = 0xFFFF0000   // vertex flags
  };

enum nnet::TrainingDataAlg::ETrkType

Enumerator
kDelta
kMichel
kPriEl
kPriMu

Definition at line 201 of file PointIdAlg.h.

                {
    kDelta = 0x1000,  // delta electron
    kMichel = 0x2000, // Michel electron
    kPriEl = 0x4000,  // primary electron
    kPriMu = 0x8000   // primary muon
  };

enum nnet::TrainingDataAlg::EVtxId

Enumerator
kNuNC
kNuCC
kNuPri
kNuE
kNuMu
kNuTau
kHadr
kPi0
kDecay
kConv
kElectronEnd
kElastic
kInelastic

Definition at line 208 of file PointIdAlg.h.

              {
    kNuNC = 0x0010000,
    kNuCC = 0x0020000,
    kNuPri = 0x0040000, // nu interaction type
    kNuE = 0x0100000,
    kNuMu = 0x0200000,
    kNuTau = 0x0400000,        // nu flavor
    kHadr = 0x1000000,         // hadronic inelastic scattering
    kPi0 = 0x2000000,          // pi0 produced in this vertex
    kDecay = 0x4000000,        // point of particle decay
    kConv = 0x8000000,         // gamma conversion
    kElectronEnd = 0x10000000, // clear end of an electron
    kElastic = 0x20000000,     // Elastic scattering
    kInelastic = 0x40000000    // Inelastic scattering
  };

Constructor & Destructor Documentation

nnet::TrainingDataAlg::TrainingDataAlg ( const fhicl::ParameterSet &  pset )

inline

Definition at line 248 of file PointIdAlg.h.

    : TrainingDataAlg(fhicl::Table<Config>(pset, {})())
  {}

nnet::TrainingDataAlg::TrainingDataAlg

(

const Config &

config

)

Definition at line 348 of file PointIdAlg.cxx.

References fSaveSimInfo, fSimChannelProducerLabel, fSimulationProducerLabel, art::InputTag::label(), and ~TrainingDataAlg().

  : img::DataProviderAlg(config)
  , fEdepTot(0)
  , fWireProducerLabel(config.WireLabel())
  , fHitProducerLabel(config.HitLabel())
  , fTrackModuleLabel(config.TrackLabel())
  , fSimulationProducerLabel(config.SimulationLabel())
  , fSimChannelProducerLabel(config.SimChannelLabel())
  , fSaveVtxFlags(config.SaveVtxFlags())
  , fAdcDelay(config.AdcDelayTicks())
  , fEventsPerBin(100, 0)
{
  // If no sim channel producer is set then make it the same as the simulation label
  if (fSimChannelProducerLabel.label().empty()) fSimChannelProducerLabel = fSimulationProducerLabel;

  fSaveSimInfo = !fSimulationProducerLabel.label().empty();
}

nnet::TrainingDataAlg::~TrainingDataAlg ( )

overridedefault

Referenced by TrainingDataAlg().

Member Function Documentation

void nnet::TrainingDataAlg::collectVtxFlags ( std::unordered_map< size_t, std::unordered_map< int, int >> &  wireToDriftToVtxFlags, detinfo::DetectorClocksData const &  clockData, detinfo::DetectorPropertiesData const &  detProp, const std::unordered_map< int, const simb::MCParticle * > &  particleMap, unsigned int  plane  ) const

private

Definition at line 564 of file PointIdAlg.cxx.

References util::abs(), simb::MCTrajectory::at(), img::DataProviderAlg::Cryo(), d, getProjection(), isElectronEnd(), isMuonDecaying(), kConv, kDecay, kElastic, kElectronEnd, simb::MCTrajectory::KeyToProcess(), kHadr, kInelastic, kNone, kNuPri, kPi0, img::DataProviderAlg::TPC(), and simb::MCTrajectory::TrajectoryProcesses().

Referenced by setEventData().

{
  for (auto const& p : particleMap) {
    auto const& particle = *p.second;

    double ekStart = 1000. * (particle.E() - particle.Mass());
    double ekEnd = 1000. * (particle.EndE() - particle.Mass());
    int pdg = abs(particle.PdgCode());
    int flagsStart = nnet::TrainingDataAlg::kNone;
    int flagsEnd = nnet::TrainingDataAlg::kNone;

    switch (pdg) {
    case 22:                                                     // gamma
      if ((particle.EndProcess() == "conv") && (ekStart > 40.0)) // conversion, gamma > 40MeV
      {
        flagsEnd = nnet::TrainingDataAlg::kConv;
      }
      break;

    case 11: // e+/-
      if (isElectronEnd(particle, particleMap)) { flagsEnd = nnet::TrainingDataAlg::kElectronEnd; }
      break;

    case 13: // mu+/-
      if (isMuonDecaying(particle, particleMap)) { flagsEnd = nnet::TrainingDataAlg::kDecay; }
      break;

    case 111: // pi0
      flagsStart = nnet::TrainingDataAlg::kPi0;
      break;

    case 321:  // K+/-
    case 211:  // pi+/-
    case 2212: // proton
      if (ekStart > 50.0) {
        if (particle.Mother() != 0) {
          auto search = particleMap.find(particle.Mother());
          if (search != particleMap.end()) {
            auto const& mother = *((*search).second);
            int m_pdg = abs(mother.PdgCode());
            unsigned int nSec = mother.NumberDaughters();
            unsigned int nVisible = 0;
            if (nSec > 1) {
              for (size_t d = 0; d < nSec; ++d) {
                auto d_search = particleMap.find(mother.Daughter(d));
                if (d_search != particleMap.end()) {
                  auto const& daughter = *((*d_search).second);
                  int d_pdg = abs(daughter.PdgCode());
                  if (((d_pdg == 2212) || (d_pdg == 211) || (d_pdg == 321)) &&
                      (1000. * (daughter.E() - daughter.Mass()) > 50.0)) {
                    ++nVisible;
                  }
                }
              }
            }
            // hadron with Ek > 50MeV (so well visible) and
            // produced by another hadron (but not neutron, so not single track from nothing) or
            // at least secondary hadrons with Ek > 50MeV (so this is a good kink or V-like)
            if (((m_pdg != pdg) && (m_pdg != 2112)) || ((m_pdg != 2112) && (nVisible > 0)) ||
                ((m_pdg == 2112) && (nVisible > 1))) {
              flagsStart = nnet::TrainingDataAlg::kHadr;
            }
          }
        }

        if (particle.EndProcess() == "FastScintillation") // potential decay at rest
        {
          unsigned int nSec = particle.NumberDaughters();
          for (size_t d = 0; d < nSec; ++d) {
            auto d_search = particleMap.find(particle.Daughter(d));
            if (d_search != particleMap.end()) {
              auto const& daughter = *((*d_search).second);
              int d_pdg = abs(daughter.PdgCode());
              if ((pdg == 321) && (d_pdg == 13)) {
                flagsEnd = nnet::TrainingDataAlg::kDecay;
                break;
              }
              if ((pdg == 211) && (d_pdg == 13)) {
                flagsEnd = nnet::TrainingDataAlg::kDecay;
                break;
              }
            }
          }
        }

        if ((particle.EndProcess() == "Decay") && (ekEnd > 200.0)) // decay in flight
        {
          unsigned int nSec = particle.NumberDaughters();
          for (size_t d = 0; d < nSec; ++d) {
            auto d_search = particleMap.find(particle.Daughter(d));
            if (d_search != particleMap.end()) {
              auto const& daughter = *((*d_search).second);
              int d_pdg = abs(daughter.PdgCode());
              if ((pdg == 321) && (d_pdg == 13)) {
                flagsEnd = nnet::TrainingDataAlg::kHadr;
                break;
              }
              if ((pdg == 211) && (d_pdg == 13)) {
                flagsEnd = nnet::TrainingDataAlg::kHadr;
                break;
              }
            }
          }
        }
      }
      break;

    default: continue;
    }

    if (particle.Process() == "primary") { flagsStart |= nnet::TrainingDataAlg::kNuPri; }

    if (flagsStart != nnet::TrainingDataAlg::kNone) {
      auto wd = getProjection(clockData, detProp, particle.Position(), plane);

      if ((wd.TPC == TPC()) && (wd.Cryo == Cryo())) {
        wireToDriftToVtxFlags[wd.Wire][wd.Drift] |= flagsStart;
      }
    }
    if (flagsEnd != nnet::TrainingDataAlg::kNone) {
      auto wd = getProjection(clockData, detProp, particle.EndPosition(), plane);
      if ((wd.TPC == TPC()) && (wd.Cryo == Cryo())) {
        wireToDriftToVtxFlags[wd.Wire][wd.Drift] |= flagsEnd;
      }
    }

    //TY: check elastic/inelastic scattering
    if (pdg == 321 || pdg == 211 || pdg == 2212) {
      simb::MCTrajectory truetraj = particle.Trajectory();
      auto thisTrajectoryProcessMap1 = truetraj.TrajectoryProcesses();
      if (thisTrajectoryProcessMap1.size()) {
        for (auto const& couple1 : thisTrajectoryProcessMap1) {
          if ((truetraj.KeyToProcess(couple1.second)).find("Elastic") != std::string::npos) {
            auto wd = getProjection(clockData, detProp, truetraj.at(couple1.first).first, plane);
            if ((wd.TPC == TPC()) && (wd.Cryo == Cryo())) {
              wireToDriftToVtxFlags[wd.Wire][wd.Drift] |= nnet::TrainingDataAlg::kElastic;
            }
          }
          if ((truetraj.KeyToProcess(couple1.second)).find("Inelastic") != std::string::npos) {
            auto wd = getProjection(clockData, detProp, truetraj.at(couple1.first).first, plane);
            if ((wd.TPC == TPC()) && (wd.Cryo == Cryo())) {
              wireToDriftToVtxFlags[wd.Wire][wd.Drift] |= nnet::TrainingDataAlg::kInelastic;
            }
          }
        }
      }
    }
  }
}

unsigned int img::DataProviderAlg::Cryo ( ) const

inlineinherited

Pool sum of pixels in a patch around the wire/drift pixel.

Definition at line 159 of file DataProviderAlg.h.

Referenced by collectVtxFlags().

{ return fCryo; }

std::vector<float> img::DataProviderAlg::downscale ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

inlineprotectedinherited

Definition at line 196 of file DataProviderAlg.h.

References img::DataProviderAlg::kMax, img::DataProviderAlg::kMaxMean, and img::DataProviderAlg::kMean.

Referenced by img::DataProviderAlg::patchFromOriginalView(), and img::DataProviderAlg::setWireData().

  {
    switch (fDownscaleMode) {
    case img::DataProviderAlg::kMean: return downscaleMean(dst_size, adc, tick0);
    case img::DataProviderAlg::kMaxMean: return downscaleMaxMean(dst_size, adc, tick0);
    case img::DataProviderAlg::kMax: return downscaleMax(dst_size, adc, tick0);
    }
    throw cet::exception("img::DataProviderAlg") << "Downscale mode not supported." << std::endl;
  }

std::vector< float > img::DataProviderAlg::downscaleMax ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protectedinherited

Definition at line 193 of file DataProviderAlg.cxx.

References img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDriftWindow, img::DataProviderAlgView::fLifetimeCorrFactors, and img::DataProviderAlg::scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;

    float max_adc = adc[k0] * fAlgView.fLifetimeCorrFactors[k0 + tick0];
    for (size_t k = k0 + 1; k < k1; ++k) {
      float ak = adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
      if (ak > max_adc) max_adc = ak;
    }
    result[i] = max_adc;
  }
  scaleAdcSamples(result);
  return result;
}

std::vector< float > img::DataProviderAlg::downscaleMaxMean ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protectedinherited

Definition at line 214 of file DataProviderAlg.cxx.

References img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDriftWindow, img::DataProviderAlgView::fLifetimeCorrFactors, n, and img::DataProviderAlg::scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;
    size_t max_idx = k0;
    float max_adc = adc[k0] * fAlgView.fLifetimeCorrFactors[k0 + tick0];
    for (size_t k = k0 + 1; k < k1; ++k) {
      float ak = adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
      if (ak > max_adc) {
        max_adc = ak;
        max_idx = k;
      }
    }

    size_t n = 1;
    if (max_idx > 0) {
      max_adc += adc[max_idx - 1] * fAlgView.fLifetimeCorrFactors[max_idx - 1 + tick0];
      n++;
    }
    if (max_idx + 1 < adc.size()) {
      max_adc += adc[max_idx + 1] * fAlgView.fLifetimeCorrFactors[max_idx + 1 + tick0];
      n++;
    }

    result[i] = max_adc / n;
  }
  scaleAdcSamples(result);
  return result;
}

std::vector< float > img::DataProviderAlg::downscaleMean ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protectedinherited

Definition at line 249 of file DataProviderAlg.cxx.

References img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDriftWindow, img::DataProviderAlg::fDriftWindowInv, img::DataProviderAlgView::fLifetimeCorrFactors, and img::DataProviderAlg::scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;

    float sum_adc = 0;
    for (size_t k = k0; k < k1; ++k) {
      if (k + tick0 < fAlgView.fLifetimeCorrFactors.size())
        sum_adc += adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
    }
    result[i] = sum_adc * fDriftWindowInv;
  }
  scaleAdcSamples(result);
  return result;
}

unsigned int img::DataProviderAlg::DriftWindow ( ) const

inlineinherited

Definition at line 166 of file DataProviderAlg.h.

{ return fDriftWindow; }

bool nnet::TrainingDataAlg::findCrop	(	float	max_e_cut,
		unsigned int &	w0,
		unsigned int &	w1,
		unsigned int &	d0,
		unsigned int &	d1
	)		const

Definition at line 1026 of file PointIdAlg.cxx.

References d, and fWireDriftEdep.

Referenced by nnet::PointIdTrainingData::analyze().

{
  if (fWireDriftEdep.empty() || fWireDriftEdep.front().empty()) return false;

  float max_cut = 0.25 * max_e_cut;

  w0 = 0;
  float cut = 0;
  while (w0 < fWireDriftEdep.size()) {
    for (auto const d : fWireDriftEdep[w0])
      cut += d;
    if (cut < max_cut)
      w0++;
    else
      break;
  }
  w1 = fWireDriftEdep.size() - 1;
  cut = 0;
  while (w1 > w0) {
    for (auto const d : fWireDriftEdep[w1])
      cut += d;
    if (cut < max_cut)
      w1--;
    else
      break;
  }
  w1++;

  d0 = 0;
  cut = 0;
  while (d0 < fWireDriftEdep.front().size()) {
    for (size_t i = w0; i < w1; ++i)
      cut += fWireDriftEdep[i][d0];
    if (cut < max_cut)
      d0++;
    else
      break;
  }
  d1 = fWireDriftEdep.front().size() - 1;
  cut = 0;
  while (d1 > d0) {
    for (size_t i = w0; i < w1; ++i)
      cut += fWireDriftEdep[i][d1];
    if (cut < max_cut)
      d1--;
    else
      break;
  }
  d1++;

  unsigned int margin = 20;
  if ((w1 - w0 > 8) && (d1 - d0 > 8)) {
    if (w0 < margin)
      w0 = 0;
    else
      w0 -= margin;

    if (w1 > fWireDriftEdep.size() - margin)
      w1 = fWireDriftEdep.size();
    else
      w1 += margin;

    if (d0 < margin)
      d0 = 0;
    else
      d0 -= margin;

    if (d1 > fWireDriftEdep.front().size() - margin)
      d1 = fWireDriftEdep.front().size();
    else
      d1 += margin;

    return true;
  }
  else
    return false;
}

size_t img::DataProviderAlg::getAdcArea ( ) const

inlineinherited

Definition at line 151 of file DataProviderAlg.h.

References r.

{ return fAdcAreaOverThr; }

double img::DataProviderAlg::getAdcSum ( ) const

inlineinherited

Definition at line 150 of file DataProviderAlg.h.

{ return fAdcSumOverThr; }

size_t img::DataProviderAlg::getDriftIndex ( float  drift ) const

inlineprotectedinherited

Definition at line 208 of file DataProviderAlg.h.

References lar::dump::vector().

Referenced by img::DataProviderAlg::poolMax().

  {
    if (fDownscaleFullView)
      return (size_t)(drift * fDriftWindowInv);
    else
      return (size_t)drift;
  }

double nnet::TrainingDataAlg::getEdepTot ( ) const

inline

Definition at line 282 of file PointIdAlg.h.

{ return fEdepTot; } // [GeV]

std::vector<std::vector<float> > img::DataProviderAlg::getPatch ( size_t  wire, float  drift, size_t  patchSizeW, size_t  patchSizeD  ) const

inlineinherited

Return patch of data centered on the wire and drift, witht the size in (downscaled) pixels givent with patchSizeW and patchSizeD. Pad with the zero-level calue if patch extends beyond the event projection.

Definition at line 120 of file DataProviderAlg.h.

  {
    bool ok = false;
    std::vector<std::vector<float>> patch;
    if (fDownscaleFullView) {
      ok = patchFromDownsampledView(wire, drift, patchSizeW, patchSizeD, patch);
    }
    else {
      ok = patchFromOriginalView(wire, drift, patchSizeW, patchSizeD, patch);
    }

    if (ok) return patch;
    throw cet::exception("img::DataProviderAlg") << "Patch filling failed." << std::endl;
  }

float img::DataProviderAlg::getPixelOrZero ( int  wire, int  drift  ) const

inlineinherited

Return value from the ADC buffer, or zero if coordinates are out of the view; will scale the drift according to the downscale settings.

Definition at line 140 of file DataProviderAlg.h.

  {
    size_t didx = getDriftIndex(drift), widx = (size_t)wire;

    if ((widx < fAlgView.fWireDriftData.size()) && (didx < fAlgView.fNCachedDrifts)) {
      return fAlgView.fWireDriftData[widx][didx];
    }
    return 0;
  }

nnet::TrainingDataAlg::WireDrift nnet::TrainingDataAlg::getProjection ( detinfo::DetectorClocksData const &  clockData, detinfo::DetectorPropertiesData const &  detProp, const TLorentzVector &  tvec, unsigned int  plane  ) const

private

Definition at line 436 of file PointIdAlg.cxx.

References detinfo::DetectorPropertiesData::ConvertXToTicks(), nnet::TrainingDataAlg::WireDrift::Cryo, nnet::TrainingDataAlg::WireDrift::Drift, geo::TPCGeo::DriftAxisWithSign(), detinfo::DetectorPropertiesData::DriftVelocity(), e, img::DataProviderAlg::fGeometry, geo::GeometryCore::FindTPCAtPosition(), img::DataProviderAlg::fWireReadoutGeom, geo::CryostatID::isValid, geo::PlaneGeo::NearestWireID(), geo::Negative, geo::WireReadoutGeom::Plane(), pmtana::sign(), nnet::TrainingDataAlg::WireDrift::TPC, geo::GeometryCore::TPC(), nnet::TrainingDataAlg::WireDrift::Wire, geo::WireID::Wire, and geo::X.

Referenced by collectVtxFlags().

{
  nnet::TrainingDataAlg::WireDrift wd;
  wd.Wire = 0;
  wd.Drift = 0;
  wd.TPC = -1;
  wd.Cryo = -1;

  try {
    geo::Point_t vtx{tvec.X(), tvec.Y(), tvec.Z()};
    if (fGeometry->FindTPCAtPosition(vtx).isValid) {
      geo::TPCID tpcid = fGeometry->FindTPCAtPosition(vtx);

      // correct for the time offset
      float dx = tvec.T() * 1.e-3 * detProp.DriftVelocity();
      auto const [axis, sign] = fGeometry->TPC(tpcid).DriftAxisWithSign();
      if (axis != geo::Coordinate::X) {
        throw cet::exception("nnet::TrainingDataAlg") << "drift direction is not X." << std::endl;
      }
      if (sign == geo::DriftSign::Negative) { dx *= -1; }
      vtx.SetX(tvec.X() + dx);

      geo::PlaneID const planeID{tpcid, plane};
      wd.Wire = fWireReadoutGeom->Plane(planeID).NearestWireID(vtx).Wire;
      wd.Drift = detProp.ConvertXToTicks(vtx.X(), planeID);
      wd.TPC = planeID.TPC;
      wd.Cryo = planeID.Cryostat;
    }
  }
  catch (const geo::InvalidWireError& e) {
    mf::LogWarning("TrainingDataAlg")
      << "Vertex projection out of wire planes, just skipping this vertex.";
  }
  catch (...) {
    mf::LogWarning("TrainingDataAlg") << "Vertex projection out of wire planes, skip MC vertex.";
  }
  return wd;
}

bool nnet::TrainingDataAlg::isElectronEnd ( const simb::MCParticle &  particle, const std::unordered_map< int, const simb::MCParticle * > &  particleMap  ) const

private

Definition at line 480 of file PointIdAlg.cxx.

References util::abs(), d, simb::MCParticle::Daughter(), simb::MCParticle::NumberDaughters(), particleRange2(), and simb::MCParticle::PdgCode().

Referenced by collectVtxFlags().

{
  const float minElectronLength2 = 2.5 * 2.5;
  const float maxDeltaLength2 = 0.15 * 0.15;

  int pdg = abs(particle.PdgCode());
  if (pdg != 11) return false; // should be applied only to electrons

  size_t nSec = particle.NumberDaughters();
  for (size_t d = 0; d < nSec; ++d) {
    auto d_search = particleMap.find(particle.Daughter(d));
    if (d_search != particleMap.end()) {
      auto const& daughter = *((*d_search).second);
      int d_pdg = abs(daughter.PdgCode());
      if (d_pdg != 22) { return false; } // not the end of the shower
    }
  }

  float trkLength2 = 0;
  auto const* p = &particle;
  bool branching = false;
  while (!branching) {
    trkLength2 += particleRange2(*p);
    auto m_search = particleMap.find(p->Mother());
    if (m_search != particleMap.end()) {
      p = (*m_search).second;
      int m_pdg = abs(p->PdgCode());
      if (m_pdg == 11) {
        nSec = p->NumberDaughters();
        size_t ne = 0;
        for (size_t d = 0; d < nSec; ++d) {
          auto d_search = particleMap.find(p->Daughter(d));
          if (d_search != particleMap.end()) {
            auto const& daughter = *((*d_search).second);
            int d_pdg = abs(daughter.PdgCode());
            if (d_pdg == 11) {
              if (particleRange2(daughter) > maxDeltaLength2) { ne++; }
            }
          }
        }
        if (ne > 1) { branching = true; }
      }
      else
        break;
    }
    else
      break;
  }

  return (trkLength2 > minElectronLength2);
}

bool nnet::TrainingDataAlg::isMuonDecaying ( const simb::MCParticle &  particle, const std::unordered_map< int, const simb::MCParticle * > &  particleMap  ) const

private

Definition at line 534 of file PointIdAlg.cxx.

References util::abs(), d, simb::MCParticle::Daughter(), simb::MCParticle::EndProcess(), simb::MCParticle::NumberDaughters(), and simb::MCParticle::PdgCode().

Referenced by collectVtxFlags().

{
  bool hasElectron = false, hasNuMu = false, hasNuE = false;

  int pdg = abs(particle.PdgCode());
  //if ((pdg == 13) && (particle.EndProcess() == "FastScintillation" || particle.EndProcess() == "Decay" || particle.EndProcess() == "muMinusCaptureAtRest")) // potential muon decay at rest
  if ((pdg == 13) && (particle.EndProcess() == "FastScintillation" ||
                      particle.EndProcess() == "Decay")) // potential muon decay at rest
  {
    unsigned int nSec = particle.NumberDaughters();
    for (size_t d = 0; d < nSec; ++d) {
      auto d_search = particleMap.find(particle.Daughter(d));
      if (d_search != particleMap.end()) {
        auto const& daughter = *((*d_search).second);
        int d_pdg = abs(daughter.PdgCode());
        if (d_pdg == 11)
          hasElectron = true;
        else if (d_pdg == 14)
          hasNuMu = true;
        else if (d_pdg == 12)
          hasNuE = true;
      }
    }
  }

  return (hasElectron && hasNuMu && hasNuE);
}

double img::DataProviderAlg::LifetimeCorrection ( detinfo::DetectorClocksData const &  clock_data, detinfo::DetectorPropertiesData const &  det_prop, double  tick  ) const

inlineinherited

Definition at line 171 of file DataProviderAlg.h.

  {
    return fCalorimetryAlg.LifetimeCorrection(clock_data, det_prop, tick);
  }

unsigned int img::DataProviderAlg::NCachedDrifts ( ) const

inlineinherited

Definition at line 165 of file DataProviderAlg.h.

{ return fAlgView.fNCachedDrifts; }

unsigned int img::DataProviderAlg::NScaledDrifts ( ) const

inlineinherited

Definition at line 164 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fNScaledDrifts; }

unsigned int img::DataProviderAlg::NWires ( ) const

inlineinherited

Definition at line 163 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fNWires; }

static float nnet::TrainingDataAlg::particleRange2 ( const simb::MCParticle &  particle )

inlinestaticprivate

Definition at line 317 of file PointIdAlg.h.

References simb::MCParticle::EndX(), simb::MCParticle::EndY(), simb::MCParticle::EndZ(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), and simb::MCParticle::Vz().

Referenced by isElectronEnd().

  {
    float dx = particle.EndX() - particle.Vx();
    float dy = particle.EndY() - particle.Vy();
    float dz = particle.EndZ() - particle.Vz();
    return dx * dx + dy * dy + dz * dz;
  }

bool img::DataProviderAlg::patchFromDownsampledView ( size_t  wire, float  drift, size_t  size_w, size_t  size_d, std::vector< std::vector< float >> &  patch  ) const

protectedinherited

Definition at line 436 of file DataProviderAlg.cxx.

References d, img::DataProviderAlg::fAdcZero, img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDriftWindow, trkf::fill(), img::DataProviderAlgView::fWireDriftData, and w.

{
  int halfSizeW = size_w / 2;
  int halfSizeD = size_d / 2;

  int w0 = wire - halfSizeW;
  int w1 = wire + halfSizeW;

  size_t sd = (size_t)(drift / fDriftWindow);
  int d0 = sd - halfSizeD;
  int d1 = sd + halfSizeD;

  int wsize = fAlgView.fWireDriftData.size();
  for (int w = w0, wpatch = 0; w < w1; ++w, ++wpatch) {
    auto& dst = patch[wpatch];
    if ((w >= 0) && (w < wsize)) {
      auto& src = fAlgView.fWireDriftData[w];
      int dsize = src.size();
      for (int d = d0, dpatch = 0; d < d1; ++d, ++dpatch) {
        if ((d >= 0) && (d < dsize)) { dst[dpatch] = src[d]; }
        else {
          dst[dpatch] = fAdcZero;
        }
      }
    }
    else {
      std::fill(dst.begin(), dst.end(), fAdcZero);
    }
  }

  return true;
}

bool img::DataProviderAlg::patchFromOriginalView ( size_t  wire, float  drift, size_t  size_w, size_t  size_d, std::vector< std::vector< float >> &  patch  ) const

protectedinherited

Definition at line 473 of file DataProviderAlg.cxx.

References d, img::DataProviderAlg::downscale(), img::DataProviderAlg::fAdcZero, img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDriftWindow, trkf::fill(), img::DataProviderAlgView::fWireDriftData, util::size(), tmp, and w.

{
  int dsize = fDriftWindow * size_d;
  int halfSizeW = size_w / 2;
  int halfSizeD = dsize / 2;

  int w0 = wire - halfSizeW;
  int w1 = wire + halfSizeW;

  int d0 = int(drift) - halfSizeD;
  int d1 = int(drift) + halfSizeD;

  if (d0 < 0) d0 = 0;

  std::vector<float> tmp(dsize);
  int wsize = fAlgView.fWireDriftData.size();
  for (int w = w0, wpatch = 0; w < w1; ++w, ++wpatch) {
    if ((w >= 0) && (w < wsize)) {
      auto& src = fAlgView.fWireDriftData[w];
      int src_size = src.size();
      for (int d = d0, dpatch = 0; d < d1; ++d, ++dpatch) {
        if ((d >= 0) && (d < src_size)) { tmp[dpatch] = src[d]; }
        else {
          tmp[dpatch] = fAdcZero;
        }
      }
    }
    else {
      std::fill(tmp.begin(), tmp.end(), fAdcZero);
    }
    patch[wpatch] = downscale(patch[wpatch].size(), tmp, d0);
  }

  return true;
}

unsigned int img::DataProviderAlg::Plane ( ) const

inlineinherited

Definition at line 161 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::setWireDriftData(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{ return fPlane; }

float img::DataProviderAlg::poolMax ( int  wire, int  drift, size_t  r = 0  ) const

inherited

Pool max value in a patch around the wire/drift pixel.

Definition at line 142 of file DataProviderAlg.cxx.

References col, d, img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDownscaleFullView, img::DataProviderAlg::fDriftWindow, img::DataProviderAlgView::fNCachedDrifts, img::DataProviderAlgView::fNWires, img::DataProviderAlgView::fWireDriftData, img::DataProviderAlg::getDriftIndex(), r, and w.

Referenced by pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{
  size_t rw = r, rd = r;
  if (!fDownscaleFullView) { rd *= fDriftWindow; }

  size_t didx = getDriftIndex(drift);
  int d0 = didx - rd;
  if (d0 < 0) { d0 = 0; }
  int d1 = didx + rd;
  if (d1 >= (int)fAlgView.fNCachedDrifts) { d1 = fAlgView.fNCachedDrifts - 1; }

  int w0 = wire - rw;
  if (w0 < 0) { w0 = 0; }
  int w1 = wire + rw;
  if (w1 >= (int)fAlgView.fNWires) { w1 = fAlgView.fNWires - 1; }

  float adc, max_adc = 0;
  for (int w = w0; w <= w1; ++w) {
    auto const* col = fAlgView.fWireDriftData[w].data();
    for (int d = d0; d <= d1; ++d) {
      adc = col[d];
      if (adc > max_adc) { max_adc = adc; }
    }
  }

  return max_adc;
}

void nnet::TrainingDataAlg::reconfigure

(

const Config &

config

)

img::DataProviderAlgView nnet::TrainingDataAlg::resizeView ( detinfo::DetectorClocksData const &  clock_data, detinfo::DetectorPropertiesData const &  det_prop, size_t  wires, size_t  drifts  )

overrideprotectedvirtual

Reimplemented from img::DataProviderAlg.

Definition at line 370 of file PointIdAlg.cxx.

References trkf::fill(), fWireDriftEdep, fWireDriftPdg, img::DataProviderAlg::resizeView(), and w.

{
  auto view = img::DataProviderAlg::resizeView(clock_data, det_prop, wires, drifts);

  fWireDriftEdep.resize(wires);
  for (auto& w : fWireDriftEdep) {
    w.resize(view.fNCachedDrifts);
    std::fill(w.begin(), w.end(), 0.0F);
  }

  fWireDriftPdg.resize(wires);
  for (auto& w : fWireDriftPdg) {
    w.resize(view.fNCachedDrifts);
    std::fill(w.begin(), w.end(), 0);
  }
  return view;
}

bool nnet::TrainingDataAlg::saveSimInfo ( ) const

inline

Definition at line 258 of file PointIdAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fSaveSimInfo; }

bool nnet::TrainingDataAlg::setDataEventData	(	const art::Event &	event,
		detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 720 of file PointIdAlg.cxx.

References larg4::dist(), img::DataProviderAlg::fAlgView, fEventsPerBin, fHitProducerLabel, art::fill_ptr_vector(), img::DataProviderAlgView::fNDrifts, fTrackModuleLabel, fWireProducerLabel, art::ProductRetriever::getByLabel(), img::DataProviderAlg::setWireDriftData(), and setWireEdepsAndLabels().

{

  art::Handle<std::vector<recob::Wire>> wireHandle;
  std::vector<art::Ptr<recob::Wire>> Wirelist;

  if (event.getByLabel(fWireProducerLabel, wireHandle)) art::fill_ptr_vector(Wirelist, wireHandle);

  if (!setWireDriftData(clockData, detProp, *wireHandle, plane, tpc, cryo)) {
    mf::LogError("TrainingDataAlg") << "Wire data not set.";
    return false;
  }

  // Hit info
  art::Handle<std::vector<recob::Hit>> HitHandle;
  std::vector<art::Ptr<recob::Hit>> Hitlist;

  if (event.getByLabel(fHitProducerLabel, HitHandle)) art::fill_ptr_vector(Hitlist, HitHandle);

  // Track info
  art::Handle<std::vector<recob::Track>> TrackHandle;
  std::vector<art::Ptr<recob::Track>> Tracklist;

  if (event.getByLabel(fTrackModuleLabel, TrackHandle))
    art::fill_ptr_vector(Tracklist, TrackHandle);

  art::FindManyP<recob::Track> ass_trk_hits(HitHandle, event, fTrackModuleLabel);

  // Loop over wires (sorry about hard coded value) to fill in 1) pdg and 2) charge depo
  for (size_t widx = 0; widx < 240; ++widx) {

    std::vector<float> labels_deposit(fAlgView.fNDrifts, 0); // full-drift-length buffers
    std::vector<int> labels_pdg(fAlgView.fNDrifts, 0);

    // First, the charge depo
    for (size_t subwidx = 0; subwidx < Wirelist.size(); ++subwidx) {
      if (widx + 240 == Wirelist[subwidx]->Channel()) {
        labels_deposit = Wirelist[subwidx]->Signal();
        break;
      }
    }

    // Second, the pdg code
    // This code finds the angle of the track and records
    //  events based on its angle to try to get an isometric sample
    //  instead of just a bunch of straight tracks

    // Meta code:
    // For each hit:
    //  find farthest hit from point
    //  then find farthest hit from THAT one
    //  should be start and end of track, then just use trig

    for (size_t iHit = 0; iHit < Hitlist.size(); ++iHit) {

      if (Hitlist[iHit]->Channel() != widx + 240) { continue; }
      if (Hitlist[iHit]->View() != 1) { continue; }

      // Make sure there is a track association
      if (ass_trk_hits.at(iHit).size() == 0) { continue; }

      // Not sure about this
      // Cutting on length to not just get a bunch of shower stubs
      // Might add a lot of bias though
      if (ass_trk_hits.at(iHit)[0]->Length() < 5) { continue; }

      // Search for farest hit from this one
      int far_index = 0;
      double far_dist = 0;

      for (size_t jHit = 0; jHit < Hitlist.size(); ++jHit) {
        if (jHit == iHit) { continue; }
        if (Hitlist[jHit]->View() != 1) { continue; }

        if (ass_trk_hits.at(jHit).size() == 0) { continue; }
        if (ass_trk_hits.at(jHit)[0]->ID() != ass_trk_hits.at(iHit)[0]->ID()) { continue; }

        double dist = sqrt((Hitlist[iHit]->Channel() - Hitlist[jHit]->Channel()) *
                             (Hitlist[iHit]->Channel() - Hitlist[jHit]->Channel()) +
                           (Hitlist[iHit]->PeakTime() - Hitlist[jHit]->PeakTime()) *
                             (Hitlist[iHit]->PeakTime() - Hitlist[jHit]->PeakTime()));

        if (far_dist < dist) {
          far_dist = dist;
          far_index = jHit;
        }
      }

      // Search for the other end of the track
      int other_end = 0;
      int other_dist = 0;

      for (size_t jHit = 0; jHit < Hitlist.size(); ++jHit) {
        if (jHit == iHit or int(jHit) == far_index) { continue; }
        if (Hitlist[jHit]->View() != 1) { continue; }

        if (ass_trk_hits.at(jHit).size() == 0) { continue; }
        if (ass_trk_hits.at(jHit)[0]->ID() != ass_trk_hits.at(iHit)[0]->ID()) { continue; }

        double dist = sqrt((Hitlist[far_index]->Channel() - Hitlist[jHit]->Channel()) *
                             (Hitlist[far_index]->Channel() - Hitlist[jHit]->Channel()) +
                           (Hitlist[far_index]->PeakTime() - Hitlist[jHit]->PeakTime()) *
                             (Hitlist[far_index]->PeakTime() - Hitlist[jHit]->PeakTime()));

        if (other_dist < dist) {
          other_dist = dist;
          other_end = jHit;
        }
      }

      // We have the end points now
      double del_wire = double(Hitlist[other_end]->Channel() - Hitlist[far_index]->Channel());
      double del_time = double(Hitlist[other_end]->PeakTime() - Hitlist[far_index]->PeakTime());
      double hypo = sqrt(del_wire * del_wire + del_time * del_time);

      if (hypo == 0) { continue; } // Should never happen, but doing it anyway

      double cosser = TMath::Abs(del_wire / hypo);
      double norm_ang = TMath::ACos(cosser) * 2 / TMath::Pi();

      // Using fEventsPerBin to keep track of number of hits per angle (normalized to 0 to 1)

      int binner = int(norm_ang * fEventsPerBin.size());
      if (binner >= (int)fEventsPerBin.size()) {
        binner = fEventsPerBin.size() - 1;
      } // Dealing with rounding errors

      // So we should get a total of 5000 * 100 = 50,000 if we use the whole set
      if (fEventsPerBin[binner] > 5000) { continue; }
      fEventsPerBin[binner]++;

      // If survives everything, saves the pdg
      labels_pdg[Hitlist[iHit]->PeakTime()] = 211; // Same as pion for now
    }

    setWireEdepsAndLabels(labels_deposit, labels_pdg, widx);

  } // for each Wire

  return true;
}

bool nnet::TrainingDataAlg::setEventData	(	const art::Event &	event,
		detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 867 of file PointIdAlg.cxx.

References util::abs(), collectVtxFlags(), energy, fAdcDelay, img::DataProviderAlg::fAlgView, fEdepTot, img::DataProviderAlgView::fNDrifts, img::DataProviderAlgView::fNWires, fSaveSimInfo, fSaveVtxFlags, fSimChannelProducerLabel, fSimulationProducerLabel, img::DataProviderAlgView::fWireChannels, fWireProducerLabel, sim::LArG4Parameters::GeVToElectrons(), raw::InvalidChannelID, art::Event::isRealData(), kDelta, kMichel, kPdgMask, kPriEl, kPriMu, kTypeMask, img::DataProviderAlg::setWireDriftData(), setWireEdepsAndLabels(), and detinfo::DetectorClocksData::TPCTDC2Tick().

Referenced by nnet::PointIdTrainingData::analyze().

{
  art::ValidHandle<std::vector<recob::Wire>> wireHandle =
    event.getValidHandle<std::vector<recob::Wire>>(fWireProducerLabel);

  if (!setWireDriftData(clockData, detProp, *wireHandle, plane, tpc, cryo)) {
    mf::LogError("TrainingDataAlg") << "Wire data not set.";
    return false;
  }

  if (!fSaveSimInfo || event.isRealData()) {
    mf::LogInfo("TrainingDataAlg") << "Skip MC simulation info.";
    return true;
  }

  art::ServiceHandle<sim::LArG4Parameters const> larParameters;
  double electronsToGeV = 1. / larParameters->GeVToElectrons();

  auto particleHandle =
    event.getValidHandle<std::vector<simb::MCParticle>>(fSimulationProducerLabel);

  auto simChannelHandle =
    event.getValidHandle<std::vector<sim::SimChannel>>(fSimChannelProducerLabel);

  std::unordered_map<int, const simb::MCParticle*> particleMap;
  for (auto const& particle : *particleHandle) {
    particleMap[particle.TrackId()] = &particle;
  }

  std::unordered_map<size_t, std::unordered_map<int, int>> wireToDriftToVtxFlags;
  if (fSaveVtxFlags) collectVtxFlags(wireToDriftToVtxFlags, clockData, detProp, particleMap, plane);

  fEdepTot = 0;

  std::map<int, int> trackToPDG;
  for (size_t widx = 0; widx < fAlgView.fNWires; ++widx) {
    auto wireChannelNumber = fAlgView.fWireChannels[widx];
    if (wireChannelNumber == raw::InvalidChannelID) continue;

    std::vector<float> labels_deposit(fAlgView.fNDrifts, 0); // full-drift-length buffers,
    std::vector<int> labels_pdg(labels_deposit.size(), 0);   // both of the same size,
    int labels_size = labels_deposit.size();                 // cached as int for comparisons below

    std::map<int, std::map<int, double>> timeToTrackToCharge;
    for (auto const& channel : *simChannelHandle) {
      if (channel.Channel() != wireChannelNumber) continue;

      auto const& timeSlices = channel.TDCIDEMap();
      for (auto const& timeSlice : timeSlices) {
        int time = timeSlice.first;

        auto const& energyDeposits = timeSlice.second;
        for (auto const& energyDeposit : energyDeposits) {
          int pdg = 0;
          int tid = energyDeposit.trackID;
          if (tid < 0) // negative tid means it is EM activity, and -tid is the mother
          {
            pdg = 11;
            tid = -tid;

            auto search = particleMap.find(tid);
            if (search == particleMap.end()) {
              mf::LogWarning("TrainingDataAlg") << "PARTICLE NOT FOUND";
              continue;
            }
            auto const& mother = *((*search).second); // mother particle of this EM
            int mPdg = abs(mother.PdgCode());
            if ((mPdg == 13) || (mPdg == 211) || (mPdg == 2212)) {
              if (energyDeposit.numElectrons > 10)
                pdg |= nnet::TrainingDataAlg::kDelta; // tag delta ray
            }
          }
          else {
            auto search = particleMap.find(tid);
            if (search == particleMap.end()) {
              mf::LogWarning("TrainingDataAlg") << "PARTICLE NOT FOUND";
              continue;
            }
            auto const& particle = *((*search).second);
            pdg = abs(particle.PdgCode());

            if (particle.Process() == "primary") {
              if (pdg == 11) {
                pdg |= nnet::TrainingDataAlg::kPriEl; // tag primary
              }
              else if (pdg == 13) {
                pdg |= nnet::TrainingDataAlg::kPriMu; // tag primary
              }
            }

            /*
            auto msearch = particleMap.find(particle.Mother());
            if (msearch != particleMap.end()) {
              auto const& mother = *((*msearch).second);
              if (pdg == 11) // electron, check if it is Michel
              {
                if (nnet::TrainingDataAlg::isMuonDecaying(mother, particleMap)) {
                  std::cout<<particle.Process()<<std::endl;
                  pdg |= nnet::TrainingDataAlg::kMichel; // tag Michel
                }
              }
            }
            */
            if (pdg == 11) { // electron, check if it is Michel or delta ray
              if (particle.Process() == "Decay") {
                pdg |= nnet::TrainingDataAlg::kMichel; // tag Michel
              }
              else if (particle.Process() == "muIoni") {
                pdg |= nnet::TrainingDataAlg::kDelta; // tag delta ray
              }
            }
          }

          trackToPDG[energyDeposit.trackID] = pdg;

          double energy = energyDeposit.numElectrons * electronsToGeV;
          timeToTrackToCharge[time][energyDeposit.trackID] += energy;
          fEdepTot += energy;

        } // loop over energy deposits
      }   // loop over time slices
    }     // for each SimChannel

    int type_pdg_mask = nnet::TrainingDataAlg::kTypeMask | nnet::TrainingDataAlg::kPdgMask;
    for (auto const& ttc : timeToTrackToCharge) {
      float max_deposit = 0.0;
      int max_pdg = 0;
      for (auto const& tc : ttc.second) {

        if (tc.second > max_deposit) {
          max_deposit = tc.second;
          max_pdg = trackToPDG[tc.first];
        }
      }

      int tick_idx = clockData.TPCTDC2Tick(ttc.first) + fAdcDelay;

      if (tick_idx < labels_size && tick_idx >= 0) {
        labels_deposit[tick_idx] = max_deposit;
        labels_pdg[tick_idx] = max_pdg & type_pdg_mask;
      }
    }

    for (auto const& drift_flags : wireToDriftToVtxFlags[widx]) {
      int drift = drift_flags.first, flags = drift_flags.second;
      if ((drift >= 0) && (drift < labels_size)) { labels_pdg[drift] |= flags; }
    }
    setWireEdepsAndLabels(labels_deposit, labels_pdg, widx);
  } // for each Wire

  return true;
}

std::optional< std::vector< float > > img::DataProviderAlg::setWireData ( std::vector< float > const &  adc, size_t  wireIdx  ) const

protectedinherited

Definition at line 270 of file DataProviderAlg.cxx.

References img::DataProviderAlg::downscale(), img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDownscaleFullView, and img::DataProviderAlgView::fWireDriftData.

Referenced by img::DataProviderAlg::setWireDriftData().

{
  if (wireIdx >= fAlgView.fWireDriftData.size()) { return std::nullopt; }
  auto& wData = fAlgView.fWireDriftData[wireIdx];

  if (fDownscaleFullView) {
    if (!adc.empty()) { return downscale(wData.size(), adc, 0); }
    return std::nullopt;
  }
  if (adc.empty()) { return std::nullopt; }
  if (adc.size() <= wData.size()) { return adc; }
  return std::vector<float>(adc.begin(), adc.begin() + wData.size());
}

bool img::DataProviderAlg::setWireDriftData ( const detinfo::DetectorClocksData &  clock_data, const detinfo::DetectorPropertiesData &  det_prop, const std::vector< recob::Wire > &  wires, unsigned int  plane, unsigned int  tpc, unsigned int  cryo  )

inherited

Definition at line 286 of file DataProviderAlg.cxx.

References img::DataProviderAlg::addCoherentNoise(), img::DataProviderAlg::addWhiteNoise(), img::DataProviderAlg::applyBlur(), geo::WireReadoutGeom::ChannelToWire(), img::DataProviderAlg::fAdcAreaOverThr, img::DataProviderAlg::fAdcSumOverThr, img::DataProviderAlg::fAdcSumThr, img::DataProviderAlg::fAlgView, img::DataProviderAlg::fCryo, img::DataProviderAlg::fPlane, img::DataProviderAlg::fTPC, img::DataProviderAlgView::fWireChannels, img::DataProviderAlgView::fWireDriftData, img::DataProviderAlg::fWireReadoutGeom, detinfo::DetectorPropertiesData::NumberTimeSamples(), geo::WireReadoutGeom::Nwires(), img::DataProviderAlg::Plane(), img::DataProviderAlg::resizeView(), and img::DataProviderAlg::setWireData().

Referenced by nnet::ParticleDecayId::DetectDecay(), nnet::EmTrackClusterId2out::produce(), nnet::EmTrackClusterId::produce(), nnet::EmTrackMichelId::produce(), setDataEventData(), and setEventData().

{
  mf::LogInfo("DataProviderAlg") << "Create image for cryo:" << cryo << " tpc:" << tpc
                                 << " plane:" << plane;

  fCryo = cryo;
  fTPC = tpc;
  fPlane = plane;

  fAdcSumOverThr = 0;
  fAdcAreaOverThr = 0;

  size_t nwires = fWireReadoutGeom->Nwires({cryo, tpc, plane});
  size_t ndrifts = det_prop.NumberTimeSamples();

  fAlgView = resizeView(clock_data, det_prop, nwires, ndrifts);

  auto const& channelStatus =
    art::ServiceHandle<lariov::ChannelStatusService const>()->GetProvider();

  bool allWrong = true;
  for (auto const& wire : wires) {
    auto wireChannelNumber = wire.Channel();
    if (!channelStatus.IsGood(wireChannelNumber)) { continue; }

    size_t w_idx = 0;
    for (auto const& id : fWireReadoutGeom->ChannelToWire(wireChannelNumber)) {
      if ((id.Plane == plane) && (id.TPC == tpc) && (id.Cryostat == cryo)) {
        w_idx = id.Wire;

        auto adc = wire.Signal();
        if (adc.size() < ndrifts) {
          mf::LogWarning("DataProviderAlg") << "Wire ADC vector size lower than NumberTimeSamples.";
          continue; // not critical, maybe other wires are OK, so continue
        }
        auto wire_data = setWireData(adc, w_idx);
        if (!wire_data) {
          mf::LogWarning("DataProviderAlg") << "Wire data not set.";
          continue; // also not critical, try to set other wires
        }
        fAlgView.fWireDriftData[w_idx] = *wire_data;
        for (auto v : adc) {
          if (v >= fAdcSumThr) {
            fAdcSumOverThr += v;
            fAdcAreaOverThr++;
          }
        }

        fAlgView.fWireChannels[w_idx] = wireChannelNumber;
        allWrong = false;
      }
    }
  }
  if (allWrong) {
    mf::LogError("DataProviderAlg")
      << "Wires data not set in the cryo:" << cryo << " tpc:" << tpc << " plane:" << plane;
    return false;
  }

  applyBlur();
  addWhiteNoise();
  addCoherentNoise();

  return true;
}

bool nnet::TrainingDataAlg::setWireEdepsAndLabels ( std::vector< float > const &  edeps, std::vector< int > const &  pdgs, size_t  wireIdx  )

private

Definition at line 393 of file PointIdAlg.cxx.

References img::DataProviderAlg::fAlgView, img::DataProviderAlg::fDownscaleFullView, img::DataProviderAlg::fDriftWindow, img::DataProviderAlgView::fNCachedDrifts, fSaveVtxFlags, fWireDriftEdep, fWireDriftPdg, kPdgMask, kTypeMask, and kVtxMask.

Referenced by setDataEventData(), and setEventData().

{
  if ((wireIdx >= fWireDriftEdep.size()) || (edeps.size() != pdgs.size())) { return false; }

  size_t dstep = 1;
  if (fDownscaleFullView) { dstep = fDriftWindow; }

  if (edeps.size() / dstep > fAlgView.fNCachedDrifts) { return false; }

  auto& wEdep = fWireDriftEdep[wireIdx];
  auto& wPdg = fWireDriftPdg[wireIdx];

  for (size_t i = 0; i < fAlgView.fNCachedDrifts; ++i) {
    size_t i0 = i * dstep;
    size_t i1 = (i + 1) * dstep;

    int best_pdg = pdgs[i0] & nnet::TrainingDataAlg::kPdgMask;
    int vtx_flags = pdgs[i0] & nnet::TrainingDataAlg::kVtxMask;
    int type_flags = pdgs[i0] & nnet::TrainingDataAlg::kTypeMask;
    float max_edep = edeps[i0];
    for (size_t k = i0 + 1; k < i1; ++k) {
      float ek = edeps[k];
      if (ek > max_edep) {
        max_edep = ek;
        best_pdg = pdgs[k] & nnet::TrainingDataAlg::kPdgMask; // remember best matching pdg
      }
      type_flags |= pdgs[k] & nnet::TrainingDataAlg::kTypeMask; // accumulate track type flags
      vtx_flags |= pdgs[k] & nnet::TrainingDataAlg::kVtxMask;   // accumulate all vtx flags
    }

    wEdep[i] = max_edep;

    best_pdg |= type_flags;
    if (fSaveVtxFlags) best_pdg |= vtx_flags;
    wPdg[i] = best_pdg;
  }

  return true;
}

unsigned int img::DataProviderAlg::TPC ( ) const

inlineinherited

Definition at line 160 of file DataProviderAlg.h.

Referenced by collectVtxFlags().

{ return fTPC; }

std::vector<float> const& img::DataProviderAlg::wireData ( size_t  widx ) const

inlineinherited

Definition at line 115 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fWireDriftData[widx]; }

std::vector<float> const& nnet::TrainingDataAlg::wireEdep ( size_t  widx ) const

inline

Definition at line 283 of file PointIdAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fWireDriftEdep[widx]; }

std::vector<int> const& nnet::TrainingDataAlg::wirePdg ( size_t  widx ) const

inline

Definition at line 284 of file PointIdAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fWireDriftPdg[widx]; }

float img::DataProviderAlg::ZeroLevel ( ) const

inlineinherited

Level of zero ADC after scaling.

Definition at line 169 of file DataProviderAlg.h.

{ return fAdcZero; }

Member Data Documentation

unsigned int nnet::TrainingDataAlg::fAdcDelay

private

Definition at line 342 of file PointIdAlg.h.

Referenced by setEventData().

DataProviderAlgView img::DataProviderAlg::fAlgView

protectedinherited

Definition at line 179 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::addCoherentNoise(), img::DataProviderAlg::addWhiteNoise(), img::DataProviderAlg::applyBlur(), img::DataProviderAlg::downscaleMax(), img::DataProviderAlg::downscaleMaxMean(), img::DataProviderAlg::downscaleMean(), nnet::PointIdAlg::isInsideFiducialRegion(), img::DataProviderAlg::patchFromDownsampledView(), img::DataProviderAlg::patchFromOriginalView(), img::DataProviderAlg::poolMax(), setDataEventData(), setEventData(), img::DataProviderAlg::setWireData(), img::DataProviderAlg::setWireDriftData(), and setWireEdepsAndLabels().

calo::CalorimetryAlg img::DataProviderAlg::fCalorimetryAlg

protectedinherited

Definition at line 236 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::DataProviderAlg(), and img::DataProviderAlg::resizeView().

bool img::DataProviderAlg::fDownscaleFullView

protectedinherited

Definition at line 184 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::addCoherentNoise(), img::DataProviderAlg::addWhiteNoise(), img::DataProviderAlg::DataProviderAlg(), nnet::PointIdAlg::isCurrentPatch(), nnet::PointIdAlg::isSamePatch(), img::DataProviderAlg::poolMax(), img::DataProviderAlg::resizeView(), img::DataProviderAlg::setWireData(), and setWireEdepsAndLabels().

EDownscaleMode img::DataProviderAlg::fDownscaleMode

protectedinherited

Definition at line 180 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::DataProviderAlg().

size_t img::DataProviderAlg::fDriftWindow

protectedinherited

Definition at line 183 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::addCoherentNoise(), img::DataProviderAlg::addWhiteNoise(), img::DataProviderAlg::DataProviderAlg(), img::DataProviderAlg::downscaleMax(), img::DataProviderAlg::downscaleMaxMean(), img::DataProviderAlg::downscaleMean(), nnet::PointIdAlg::isCurrentPatch(), nnet::PointIdAlg::isInsideFiducialRegion(), nnet::PointIdAlg::isSamePatch(), img::DataProviderAlg::patchFromDownsampledView(), img::DataProviderAlg::patchFromOriginalView(), img::DataProviderAlg::poolMax(), img::DataProviderAlg::resizeView(), and setWireEdepsAndLabels().

float img::DataProviderAlg::fDriftWindowInv

protectedinherited

Definition at line 185 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::DataProviderAlg(), and img::DataProviderAlg::downscaleMean().

double nnet::TrainingDataAlg::fEdepTot

private

Definition at line 330 of file PointIdAlg.h.

Referenced by setEventData().

std::vector<size_t> nnet::TrainingDataAlg::fEventsPerBin

private

Definition at line 344 of file PointIdAlg.h.

Referenced by setDataEventData().

geo::Geometry const* img::DataProviderAlg::fGeometry

protectedinherited

Definition at line 239 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::DataProviderAlg(), and getProjection().

art::InputTag nnet::TrainingDataAlg::fHitProducerLabel

private

Definition at line 335 of file PointIdAlg.h.

Referenced by setDataEventData().

bool nnet::TrainingDataAlg::fSaveSimInfo

private

Definition at line 340 of file PointIdAlg.h.

Referenced by setEventData(), and TrainingDataAlg().

bool nnet::TrainingDataAlg::fSaveVtxFlags

private

Definition at line 339 of file PointIdAlg.h.

Referenced by setEventData(), and setWireEdepsAndLabels().

art::InputTag nnet::TrainingDataAlg::fSimChannelProducerLabel

private

Definition at line 338 of file PointIdAlg.h.

Referenced by setEventData(), and TrainingDataAlg().

art::InputTag nnet::TrainingDataAlg::fSimulationProducerLabel

private

Definition at line 337 of file PointIdAlg.h.

Referenced by setEventData(), and TrainingDataAlg().

art::InputTag nnet::TrainingDataAlg::fTrackModuleLabel

private

Definition at line 336 of file PointIdAlg.h.

Referenced by setDataEventData().

std::vector<std::vector<float> > nnet::TrainingDataAlg::fWireDriftEdep

private

Definition at line 331 of file PointIdAlg.h.

Referenced by findCrop(), resizeView(), and setWireEdepsAndLabels().

std::vector<std::vector<int> > nnet::TrainingDataAlg::fWireDriftPdg

private

Definition at line 332 of file PointIdAlg.h.

Referenced by resizeView(), and setWireEdepsAndLabels().

art::InputTag nnet::TrainingDataAlg::fWireProducerLabel

private

Definition at line 334 of file PointIdAlg.h.

Referenced by setDataEventData(), and setEventData().

geo::WireReadoutGeom const* img::DataProviderAlg::fWireReadoutGeom

protectedinherited

Definition at line 240 of file DataProviderAlg.h.

Referenced by img::DataProviderAlg::DataProviderAlg(), getProjection(), and img::DataProviderAlg::setWireDriftData().

---

The documentation for this class was generated from the following files:

• larrecodnn/v10_01_05/source/larrecodnn/ImagePatternAlgs/Tensorflow/PointIdAlg/PointIdAlg.h
• larrecodnn/v10_01_05/source/larrecodnn/ImagePatternAlgs/Tensorflow/PointIdAlg/PointIdAlg.cxx