numu Namespace Reference

Namespaces
	flat

Classes
struct	CRTMatch
struct	CRTHit
struct	FlashTriggerPrimitive
struct	FlashMatch
struct	RecoSlice
struct	RecoInteraction
struct	RecoEvent
struct	RecoParticle
struct	MCSFitResult
struct	RecoTrack
struct	TrueParticle
struct	TrackTruthMatch
struct	TruthMatch
class	MuonS2NStudy
class	MuPVertexStudy
class	NuMuEfficiencyStudy

Typedefs
using	TrackFunction = std::function< uscript::Value(const numu::RecoTrack *, const numu::TrueParticle *, const unsigned *)>
using	TrackSelector = std::function< bool(const numu::RecoTrack &, const numu::TrueParticle &, const unsigned &)>

Enumerations
enum	MCType { fUnknown =0, fOverlay =1, fIntimeCosmic =2, fCosmic =3 }
enum	InteractionMode {   mCC = 0, mCCNonPrimary = 1, mNC = 2, mNCNonPrimary = 3,   mCosmic = 4, mIntimeCosmic = 5, mOther = 6, mAll = 7 }
enum	TrackMode { tmOther = -1, tmCosmic = 1, tmNeutrino = 2 }
enum	Wall {   wNone =0, wTop =1, wBottom =2, wLeft =3,   wRight =4, wFront =5, wBack =6 }

Functions
float	dist2Match (const event::Interaction &truth, const std::vector< numu::RecoInteraction > &candidates)
float	trackMatchCompletion (unsigned truth_index, const numu::RecoEvent &event)
std::vector< std::string >	MultiplyNames (const std::vector< std::vector< std::string >> &strings, char join='_')
std::vector< TrackSelector >	MultiplyTrackSelectors (const std::vector< std::vector< std::string >> &track_function_strings)
int	SelectLongestTrack (const std::map< size_t, RecoTrack > &tracks, const RecoSlice &slice)
int	SelectLongestIDdMuon (const std::map< size_t, RecoTrack > &tracks, const RecoSlice &slice)
float	MeanTruncateddQdx (const anab::Calorimetry &calo)
float	TrackMomentum (const numu::RecoTrack &track)
float	RangeMomentum (const numu::RecoTrack &track)
float	MCSMomentum (const numu::RecoTrack &track)
TruthMatch	InteractionTruthMatch (const std::vector< event::Interaction > &truth, const std::map< size_t, numu::RecoTrack > &reco_tracks, const numu::RecoInteraction &reco)
void	CorrectMultiMatches (RecoEvent &event, std::vector< RecoInteraction > &recos)
InteractionMode	GetMode (const event::Interaction &truth)
std::vector < FlashTriggerPrimitive >	TriggerPrimitives (const std::vector< raw::OpDetWaveform > &waveforms, double tick_period, std::pair< double, double > &window, int thresh, bool is_sbnd)
bool	HasTrigger (const std::vector< FlashTriggerPrimitive > &primitives, int threshold, unsigned n_above_threshold)
std::vector< int >	TriggerThresholds (const std::vector< numu::FlashTriggerPrimitive > &primitives, unsigned size)

Typedef Documentation

using numu::TrackFunction = typedef std::function<uscript::Value (const numu::RecoTrack *, const numu::TrueParticle *, const unsigned *)>

Definition at line 12 of file DynamicSelector.h.

using numu::TrackSelector = typedef std::function<bool (const numu::RecoTrack &, const numu::TrueParticle &, const unsigned &)>

Definition at line 13 of file DynamicSelector.h.

Enumeration Type Documentation

enum numu::InteractionMode

Enum to hold each different typoe of reconstructed event

Enumerator
mCC
mCCNonPrimary
mNC
mNCNonPrimary
mCosmic
mIntimeCosmic
mOther
mAll

Definition at line 8 of file Mode.h.

                     {
  mCC = 0,  
  mCCNonPrimary = 1,
  mNC = 2, 
  mNCNonPrimary = 3,
  mCosmic = 4, 
  mIntimeCosmic = 5,
  mOther = 6,
  mAll = 7
};

enum numu::MCType

Enumerator
fUnknown
fOverlay
fIntimeCosmic
fCosmic

Definition at line 5 of file MCType.h.

            {
  fUnknown=0,
  fOverlay=1,
  fIntimeCosmic=2,
  fCosmic=3
};

enum numu::TrackMode

Enum to hold different types of tracks.

Enumerator
tmOther
tmCosmic
tmNeutrino

Definition at line 22 of file Mode.h.

               {
  tmOther = -1,
  tmCosmic = 1,
  tmNeutrino = 2
};

enum numu::Wall

Enumerator
wNone
wTop
wBottom
wLeft
wRight
wFront
wBack

Definition at line 10 of file TrueParticle.h.

          {
  wNone=0,
  wTop=1,
  wBottom=2,
  wLeft=3,
  wRight=4,
  wFront=5,
  wBack=6
};

Function Documentation

void numu::CorrectMultiMatches	(	numu::RecoEvent &	event,
		std::vector< RecoInteraction > &	recos
	)

Corrects a list of reco interaction objects when some are matched to the same truth neutrino interaction by making some of them non-primary

Parameters

event	The reconstructed event
recos	The list of reconstructed vertices. The "match" field of each RecoInteraction may be edited by this function

Definition at line 110 of file TruthMatch.cc.

                                                                                          {
  // check for no two reco matched to same truth
  std::map<int, unsigned> matched_vertices;
  for (unsigned reco_i = 0; reco_i < recos.size(); reco_i++) {
    numu::RecoInteraction &reco = recos[reco_i];
    unsigned set_i = reco_i; 

    numu::RecoTrack &primary_track = event.tracks.at(reco.slice.primary_track_index);

    if (primary_track.match.has_match && primary_track.match.is_primary && reco.match.mctruth_track_id >= 0) {
      if (matched_vertices.count(reco.match.mctruth_track_id)) {
        std::cout << "BAAAAAAAAD: two reco matched to same truth." << std::endl;
        std::cout << "This id: " << reco.match.mctruth_track_id << std::endl;
        for (const numu::RecoInteraction &reco: recos) {
          std::cout << "Interaction x: " << reco.position.X() << " match: " << reco.match.mctruth_track_id << " primary track pdg: " << primary_track.match.match_pdg << std::endl;
        }

        numu::RecoInteraction &other = recos[matched_vertices[reco.match.mctruth_track_id]];
        numu::RecoTrack &other_primary_track = event.tracks.at(other.slice.primary_track_index);

        float dist_reco = std::min( (primary_track.start - event.particles.at(primary_track.match.mcparticle_id).start).Mag(),
                                    (primary_track.end   - event.particles.at(primary_track.match.mcparticle_id).start).Mag());

        float dist_other = std::min( (other_primary_track.start - event.particles.at(other_primary_track.match.mcparticle_id).start).Mag(),
                                    (other_primary_track.end   - event.particles.at(other_primary_track.match.mcparticle_id).start).Mag());

        // Handle if one of the matched particles in not a muon
        if (abs(primary_track.match.match_pdg) != 13 && abs(other_primary_track.match.match_pdg) == 13) {
          set_i = matched_vertices[reco.match.mctruth_track_id];
          primary_track.match.is_primary = false; 
          std::cout << "Corrected -- matched track is non-muon\n";
        } 
        else if (abs(primary_track.match.match_pdg) == 13 && abs(other_primary_track.match.match_pdg) != 13) {
          other_primary_track.match.is_primary = false; 
          std::cout << "Corrected -- matched track is non-muon\n";
        } 
        // Handle both two different particles neither of which are muons
        else if (primary_track.match.mcparticle_id != other_primary_track.match.mcparticle_id) {
          std::cout << "Reco track 1 length: " << primary_track.length << " pdg: " << primary_track.match.match_pdg << std::endl; 
          std::cout << "Reco track 2 length: " << other_primary_track.length << " pdg: " << other_primary_track.match.match_pdg << std::endl; 
          if (primary_track.length > other_primary_track.length) {
            other_primary_track.match.is_primary = false;
            std::cout << "Corrected -- used longer track. Track 1 is primary.\n";
          }
          else {
            primary_track.match.is_primary = false;
            std::cout << "Corrected -- used longer track. Track 2 is primary.\n";
          }
        }
        // Handle if the priamry track was split in two
        else if (primary_track.match.mcparticle_id == other_primary_track.match.mcparticle_id) {
          std::cout << "Reco track 1 pos: " << primary_track.start.X() << " " << primary_track.start.Y() << " " << primary_track.start.Z() << " to: " << primary_track.end.X() << " " << primary_track.end.Y() << " " << primary_track.end.Z() << std::endl;
          std::cout << "Reco track 2 pos: " << other_primary_track.start.X() << " " << other_primary_track.start.Y() << " " << other_primary_track.start.Z() << " to: " << other_primary_track.end.X() << " " << other_primary_track.end.Y() << " " << other_primary_track.end.Z() << std::endl;
          TVector3 match_start = event.particles.at(other_primary_track.match.mcparticle_id).start;
          std::cout << "Match start pos: " << match_start.X() << " " << match_start.Y() << " " << match_start.Z() << std::endl;
          if (dist_reco <= dist_other) {
            std::cout << "Corrected -- split muon. Track 1 is primary.\n";
            other_primary_track.match.is_primary = false; 
          }
          else {
            std::cout << "Corrected -- split muon. Track 2 is primary.\n";
            set_i = matched_vertices[reco.match.mctruth_track_id];
            primary_track.match.is_primary = false; 
          }
        }
        else { 
          std::cout << "Unable to correct!\n";
          std::cerr << "Exiting on failure.\n";
          assert(false);
        }
      }
      matched_vertices[reco.match.mctruth_track_id] = set_i;
    } 
  }
}

float numu::dist2Match	(	const event::Interaction &	truth,
		const std::vector< numu::RecoInteraction > &	candidates
	)

Distance between one interation vertex and a list of candidate matching vertices

Parameters

truth	The true neutrino interaction to match
candidates	The list of candidate vertices matching to this one

Returns

The minimum distance between the list of candidates and the vertex

Definition at line 3 of file Derived.cc.

                                                                                                      {
  float dist = -1;
  for (const numu::RecoInteraction &candidate: candidates) {
    float this_dist = (candidate.position - truth.neutrino.position).Mag();
    if (dist < 0 || this_dist < dist) dist = this_dist;
  }
  return dist;

}

numu::InteractionMode numu::GetMode

(

const event::Interaction &

truth

)

Definition at line 5 of file TruthMatch.cc.

                                                               {
  if (truth.neutrino.iscc) return numu::mCC;
  else return numu::mNC;
}

bool numu::HasTrigger	(	const std::vector< FlashTriggerPrimitive > &	primitives,
		int	threshold,
		unsigned	n_above_threshold
	)

Definition at line 65 of file PMTTrigger.cc.

                                                                                                                       {
  if (n_above_threshold == 0) return true;

  std::map<int, std::vector<unsigned>> above_threshold;

  for (const numu::FlashTriggerPrimitive &primitive: primitives) {
    for (const numu::FlashTriggerPrimitive::Trig &trig: primitive.triggers) {
      if (trig.adc <= threshold) {
        above_threshold[trig.tdc].push_back(primitive.channel);
      }
    }
  }

  for (auto const &pair: above_threshold) {
    std::cout << "At time: " << pair.first << " above thresh: ";
    for (unsigned ch: pair.second) std::cout << ch << " ";
    std::cout << std::endl;
    if (pair.second.size() >= n_above_threshold) {
      return true;
    }
  }

  return false;
}

numu::TruthMatch numu::InteractionTruthMatch	(	const std::vector< event::Interaction > &	truth,
		const std::map< size_t, numu::RecoTrack > &	reco_tracks,
		const numu::RecoInteraction &	reco
	)

Returns the truth match interaction in a RecoInteraction

Parameters

truth	The list of true interactions in the event
reco_tracks	The set of reconstructed tracks in the event
reco	The reconstructed interaction in the event. The existing content of the reco.match instance does not affect the algorithm

Returns

The TruthMatch object for the RecoInteraction reco

Definition at line 10 of file TruthMatch.cc.

                                                                                                                                                                       {
  TruthMatch match;
  // Try to match against truth events
  // Vertices
  match.truth_vertex_distance = -1;
  for (int truth_i = 0; truth_i < truth.size(); truth_i++) {
    // find the closest vertex
    if (match.truth_vertex_distance < 0 || (truth[truth_i].neutrino.position - reco.position).Mag() < match.truth_vertex_distance) {
      match.truth_vertex_distance = (truth[truth_i].neutrino.position - reco.position).Mag();
      match.mctruth_vertex_id = truth_i;
    }
  }

  // TODO: better way to do matching
  // only keep match if distance is less than 5cm
  if (match.truth_vertex_distance < 0. || match.truth_vertex_distance > 5.) {
    std::cout << "Vertex not matched well.\n";
  }
  else {
      std::cout << "Vertex matched to neutrino.\n";
  }

  // Match to the primary track of the event
  match.mctruth_track_id = -1;
  if (reco.slice.primary_track_index >= 0) {
    const numu::TrackTruthMatch &ptrack_match = reco_tracks.at(reco.slice.primary_track_index).match;
    if (ptrack_match.has_match) {
      for (int truth_i = 0; truth_i < truth.size(); truth_i++) {
        if ((truth[truth_i].neutrino.position - ptrack_match.mctruth_vertex).Mag() < 1.) {
          match.mctruth_track_id = truth_i;
        }
      }
    }
    std::cout << "Primary track index: " << reco.slice.primary_track_index << std::endl;

    // return the interaction mode
    if (ptrack_match.has_match && ptrack_match.mctruth_origin == simb::Origin_t::kCosmicRay) {
      match.tmode = numu::tmCosmic;
      std::cout << "Track matched to cosmic.\n";
    }
    else if (ptrack_match.has_match && ptrack_match.mctruth_origin == simb::Origin_t::kBeamNeutrino) {
      match.tmode = numu::tmNeutrino;
      std::cout << "Track matched to neutrino.\n";
    }
    else if (ptrack_match.has_match) {
      match.tmode = numu::tmOther;
      std::cout << "Track matched to other: " << ptrack_match.mctruth_origin << std::endl;
      std::cout << "Match PDG: " << ptrack_match.match_pdg << std::endl;
      std::cout << "Match completion: " << ptrack_match.completion << std::endl;
      std::cout << "Is primary: " << ptrack_match.is_primary << std::endl;
      const numu::RecoTrack &track = reco_tracks.at(reco.slice.primary_track_index);
      std::cout << "reco start: " << track.start.X() << " " << track.start.Y() << " " << track.start.Z() << std::endl;
      std::cout << "reco end: " << track.end.X() << " " << track.end.Y() << " " << track.end.Z() << std::endl;
    }
    else {
      match.tmode = numu::tmOther;
      std::cout << "Track not matched.\n";
    }
  }
  else {
    match.tmode = numu::tmOther;
    std::cout << "No track to match.\n";
  }

  // Use the track to match the mode of the interaction
  if (reco.slice.primary_track_index >= 0 && 
    reco_tracks.at(reco.slice.primary_track_index).match.has_match) {
    const numu::TrackTruthMatch &ptrack_match = reco_tracks.at(reco.slice.primary_track_index).match;
    if (ptrack_match.mctruth_origin == simb::Origin_t::kBeamNeutrino && ptrack_match.mctruth_ccnc == simb::kCC) {
      if (ptrack_match.is_primary) {
        match.mode = numu::mCC;
      }
      else {
        match.mode = numu::mCCNonPrimary;
      }
    }
    else if (ptrack_match.mctruth_origin == simb::Origin_t::kBeamNeutrino && ptrack_match.mctruth_ccnc == simb::kNC) {
      if (ptrack_match.is_primary) {
        match.mode = numu::mNC;
      }
      else {
        match.mode = numu::mNCNonPrimary;
      }
    }
    else if (ptrack_match.mctruth_origin == simb::Origin_t::kCosmicRay) {
      match.mode = numu::mCosmic;
    }
    else {
      match.mode = numu::mOther;
    }
  }
  // **shrug**
  else {
    match.mode = numu::mOther;
  }
  match.has_match = true;

  return match;
}

float numu::MCSMomentum

(

const numu::RecoTrack &

track

)

Definition at line 20 of file TrackAlgo.cc.

                                                  {
  return track.mcs_muon.fwd_mcs_momentum;
}

float numu::MeanTruncateddQdx

(

const anab::Calorimetry &

calo

)

Definition at line 25 of file TrackAlgo.cc.

                                                         {
  // copy the dQdx list for partial sorting to find median
  std::vector<float> dQdx = calo.dQdx();

  // if no or only 1 calo points, then no dQdx
  if (dQdx.size() <= 1) return -9999.;

  // calculate the median
  float median = -1;
  if (dQdx.size() % 2 == 0 /* even */) {
    const auto median_lo = dQdx.begin() + dQdx.size()/2 - 1;
    const auto median_hi = dQdx.begin() + dQdx.size()/2;
    std::nth_element(dQdx.begin(), median_lo, dQdx.end());
    float median_lo_val = *median_lo;
    std::nth_element(dQdx.begin(), median_hi, dQdx.end());
    float median_hi_val = *median_hi;
    median = (median_lo_val + median_hi_val) / 2.;    
  }
  else /* odd */ {
    const auto median_ptr = dQdx.begin() + dQdx.size()/2;
    std::nth_element(dQdx.begin(), median_ptr, dQdx.end());
    median = *median_ptr;
  }

  // get the mean and variance
  float mean = std::accumulate(dQdx.begin(), dQdx.end(), 0.) / dQdx.size();  
  float var = 0.;
  for (float d: dQdx) {
    var += (d - mean) * (d - mean);
  }
  var = var / dQdx.size();

  // truncated mean
  float trunc_sum = 0.;
  unsigned n_point = 0;
  for (float d: dQdx) {
    if (var < (d - mean) * (d - mean)) {
      trunc_sum += d;
      n_point ++;
    }
  }
  // if no points available, return garbage
  if (n_point == 0) return -9999.;

  return trunc_sum / n_point;
}

std::vector< std::string > numu::MultiplyNames	(	const std::vector< std::vector< std::string >> &	strings,
		char	join = '_'
	)

Definition at line 25 of file DynamicSelector.cc.

                                                                                                  {
  std::vector<std::string> ret;
  std::vector<unsigned> indices (strings.size(), 0);
  do {
    std::string this_str;
    for (unsigned i = 0; i < indices.size(); i++) {
      this_str += strings[i][indices[i]] + join;
    }
    ret.push_back(this_str);
    Increment(indices, strings);
  } while (NotZero(indices));
  return ret;
}

std::vector< numu::TrackSelector > numu::MultiplyTrackSelectors

(

const std::vector< std::vector< std::string >> &

track_function_strings

)

Definition at line 39 of file DynamicSelector.cc.

                                                                                                                       {
  std::vector<numu::TrackSelector> ret;
  std::vector<std::vector<numu::TrackFunction>> track_functions;
  for (unsigned i = 0; i < track_function_strings.size(); i++) {
    track_functions.emplace_back();
    for (unsigned j = 0; j < track_function_strings[i].size(); j++) {
      track_functions[i].push_back(uscript::compile<numu::RecoTrack, numu::TrueParticle, unsigned>("track", "particle", "mctype", track_function_strings[i][j].c_str()));
    }
  }
  std::vector<unsigned> indices (track_functions.size(), 0);
  do {
    std::vector<numu::TrackFunction> functions;
    for (unsigned i = 0; i < indices.size(); i++) {
      functions.push_back(track_functions[i][indices[i]]);
    }
    ret.push_back(
      [functions](const numu::RecoTrack &track, const numu::TrueParticle &part, unsigned mctype) {
        for (const numu::TrackFunction &function: functions) {
          uscript::Value ret = function(&track, &part, &mctype);
          if (!ret) return false;
        }
        return true;
      });
    Increment(indices, track_functions);
  } while (NotZero(indices));
  return ret;
}

float numu::RangeMomentum

(

const numu::RecoTrack &

track

)

Definition at line 15 of file TrackAlgo.cc.

                                                    {
  return track.range_momentum_muon;
}

int numu::SelectLongestIDdMuon	(	const std::map< size_t, RecoTrack > &	tracks,
		const RecoSlice &	slice
	)

Algorithm to select the primary track – get the longest one that has a better particle ID for muon than proton

Parameters

tracks	All reconstructed tracks in the event
slice	The RecoSlice to select the primary track for

Returns

The ID of the primary track. Returns -1 if no such track exists.

Definition at line 22 of file PrimaryTrack.cc.

                                                                                                      {
  if (slice.primary_index < 0) return -1;

  const numu::RecoParticle &neutrino = slice.particles.at(slice.primary_index);
  double max_len = -1.;
  int ret = -1;
  for (size_t pfp_index: neutrino.daughters) {
    const numu::RecoParticle &daughter = slice.particles.at(pfp_index);
    if (tracks.count(daughter.ID)) {
      const numu::RecoTrack &track = tracks.at(daughter.ID);
      // muon ID: exiting or chi2 hypothesis smaller than proton
      if (!track.is_contained || track.chi2_muon < track.chi2_proton) {
        if (ret < 0 || track.length > max_len) {
          max_len = track.length;
          ret = daughter.ID;
        }
      }
    }
  }

  return ret;
}

int numu::SelectLongestTrack	(	const std::map< size_t, RecoTrack > &	tracks,
		const RecoSlice &	slice
	)

Algorithm to select the primary track – get the longest one

Parameters

tracks	All reconstructed tracks in the event
slice	The RecoSlice to select the primary track for

Returns

The ID of the primary track. Returns -1 if no such track exists.

Definition at line 3 of file PrimaryTrack.cc.

                                                                                                    {
  if (slice.primary_index < 0) return -1;

  const numu::RecoParticle &neutrino = slice.particles.at(slice.primary_index);
  double max_len = -1.;
  int ret = -1;
  for (size_t pfp_index: neutrino.daughters) {
    const numu::RecoParticle &daughter = slice.particles.at(pfp_index);
    if (tracks.count(daughter.ID)) {
      if (ret < 0 || tracks.at(daughter.ID).length > max_len) {
        max_len = tracks.at(daughter.ID).length;
        ret = daughter.ID;
      }
    }
  }

  return ret;
}

float numu::trackMatchCompletion	(	unsigned	truth_index,
		const numu::RecoEvent &	event
	)

Get the completon of a reconstructed track matching to a true track

Parameters

truth_index	The index of the true particle to match
event	The reconstructed event

Returns

The maximum completion of all reconstructed tracks to the true track. -1 if there is no matching reconstructed track

Definition at line 13 of file Derived.cc.

                                                                                 {
  for (const numu::RecoInteraction &reco: event.reco) {
    const numu::RecoTrack &primary_track = event.tracks.at(reco.slice.primary_track_index);
    if (reco.match.mctruth_track_id == truth_index && primary_track.match.is_primary) {
      return primary_track.match.completion; 
    }
  }
  return -1;
}

float numu::TrackMomentum

(

const numu::RecoTrack &

track

)

Definition at line 5 of file TrackAlgo.cc.

                                                    {
  if (track.is_contained) {
    return numu::RangeMomentum(track);
  }
  else {
    return numu::MCSMomentum(track);
  }
}

std::vector< numu::FlashTriggerPrimitive > numu::TriggerPrimitives	(	const std::vector< raw::OpDetWaveform > &	waveforms,
		double	tick_period,
		std::pair< double, double > &	window,
		int	thresh,
		bool	is_sbnd
	)

Definition at line 7 of file PMTTrigger.cc.

                                                                                                                                                                                        {
  std::vector<numu::FlashTriggerPrimitive> ret;

  opdet::sbndPDMapAlg mapalg;
  for (const raw::OpDetWaveform &wvf: waveforms) {
    // check if this is a PMT
    bool is_pmt = (!is_sbnd) || mapalg.isPDType(wvf.ChannelNumber(), "pmt");

    if (!is_pmt) continue;

    // look for any overlap with the enable window
    double waveform_start = wvf.TimeStamp();
    int waveform_index_start = std::max((int)((window.first - waveform_start) / tick_period), 0);
    int waveform_index_end = std::min((int)((window.second - waveform_start) / tick_period), (int) wvf.size());

    if (waveform_index_start < waveform_index_end) {
      numu::FlashTriggerPrimitive prim;
      prim.channel = wvf.ChannelNumber();
      for (int i = waveform_index_start; i < waveform_index_end; i++) {
        if (wvf[i] <= thresh) { // PMT waveforms go down
          FlashTriggerPrimitive::Trig this_trig {wvf[i], i + (int)((waveform_start - window.first) / tick_period)};
          prim.triggers.push_back(this_trig);
        }
      }
      ret.push_back(prim);
    }
  }
  return ret;
}

std::vector< int > numu::TriggerThresholds	(	const std::vector< numu::FlashTriggerPrimitive > &	primitives,
		unsigned	size
	)

Definition at line 37 of file PMTTrigger.cc.

                                                                                                            {
  std::map<int, std::vector<int>> trigs;
  for (const numu::FlashTriggerPrimitive &primitive: primitives) {
    for (const numu::FlashTriggerPrimitive::Trig &trig: primitive.triggers) {
      trigs[trig.tdc].push_back(trig.adc);
    }
  }

  std::map<int, std::pair<unsigned, int>> time_sorted;
  for (const auto &pair: trigs) {
    time_sorted[pair.first].first = pair.second.size();
    time_sorted[pair.first].second = *std::max_element(pair.second.begin(), pair.second.end());
  }

  std::vector<int> ret;
  for (unsigned i = 1; i <= size; i++) {
    int min = 8000;
    for (const auto &pair: time_sorted) {
      if (pair.second.first >= i) {
        if (pair.second.second < min) min = pair.second.second;
      }
    } 
    ret.push_back(min); 
  }

  return ret;
}