ana::SBNOsc::Histograms Struct Reference

#include <Histograms.h>

Inheritance diagram for ana::SBNOsc::Histograms:

Public Member Functions
void	Initialize (const geo::GeometryCore *geometry, const sbnd::CRTGeoAlg &crt_geo, const Cuts &cuts, const std::string &prefix, const std::vector< std::string > &track_histo_types, const std::vector< std::string > &track_profile_types, const std::vector< std::tuple< unsigned, float, float >> &track_profile_xranges)
void	Fill (const numu::RecoEvent &event, const event::Event &core, const Cuts &cutmaker, const std::vector< numu::TrackSelector > &selectors, const std::vector< numu::TrackFunction > &xfunctions, bool fill_all_tracks=true)
Public Member Functions inherited from ana::SBNOsc::HistoList
void	Scale (double scale)
void	Add (const HistoList &other)
void	Write ()
void	StoreHisto (TH1 *histo)
void	Merge (const HistoList &merge)

Static Public Member Functions
static std::string	mode2Str (const numu::InteractionMode &mode)

Public Attributes
InteractionHistos	fInteraction [nHistos][nModes]
	all the interaction histograms More...
std::vector< TrackHistos >	fAllTracks
	Track histograms for all tracks. More...
std::vector< std::array < TrackHistos, Cuts::nCuts > >	fPrimaryTracks
	Track histograms for priamry tracks in a candidate neutrino interaction. More...
std::vector< std::vector < std::array< TrackProfiles, Cuts::nCuts > > >	fPrimaryTrackProfiles
	Profile histograms for primary tracks. More...
std::array< CosmicHistos, 4 >	fCosmic
std::array< CRTHistos, Cuts::nCuts >	fCRTs
Public Attributes inherited from ana::SBNOsc::HistoList
std::vector< TH1 * >	fAllHistos
std::vector< TDirectory * >	fLocations

Static Public Attributes
static const unsigned	nHistos = Cuts::nCuts + Cuts::nTruthCuts
static const unsigned	nModes = 8
	number of interaction modes More...
static constexpr numu::InteractionMode	allModes [nModes]
	List of all interaction modes. More...
static constexpr std::array < const char *, nHistos >	histoNames = concat(Cuts::truthCutNames, Cuts::cutNames)
	Names of histograms. More...

Detailed Description

Set of Track and Interaction histos for all modes/cuts/sub-types

Definition at line 46 of file Histograms.h.

Member Function Documentation

void ana::SBNOsc::Histograms::Fill	(	const numu::RecoEvent &	event,
		const event::Event &	core,
		const Cuts &	cutmaker,
		const std::vector< numu::TrackSelector > &	selectors,
		const std::vector< numu::TrackFunction > &	xfunctions,
		bool	fill_all_tracks = true
	)

Fill all of the histograms with an event

Parameters

event	The reconstructed event information
core	The sbncode core event information
cuts	The configured Cuts classes
fill_all_tracks	Whether to fill all track histograms or just the primary track histograms

Definition at line 14 of file Histograms.cc.

                                             { 

  if (event.type == numu::fOverlay) {
    fCosmic[0].Fill(event.particles);
    if (cutmaker.PassFlashTrigger(event)) {
      fCosmic[1].Fill(event.particles);
    }
  }
  else {
    std::cout << "Filling Cosmic!\n";
    fCosmic[2].Fill(event.particles);
    if (cutmaker.PassFlashTrigger(event)) {
      fCosmic[3].Fill(event.particles);
    }
  }

  numu::TrueParticle bad;

  if (fill_all_tracks) {
    for (const auto &track_pair: event.tracks) {
      const numu::RecoTrack &track = track_pair.second;
      for (unsigned i = 0; i < fAllTracks.size(); i++) {
        const numu::TrueParticle &part = (track.match.has_match) ? event.particles.at(track.match.mcparticle_id) : bad;
        bool select = selectors[i](track, part, event.type);
        if (select) {
          fAllTracks[i].Fill(track, event.particles);
        }
      }
    }
  }

  for (unsigned i = 0; i < event.reco.size(); i++) {
    std::array<bool, Cuts::nCuts> cuts = cutmaker.ProcessRecoCuts(event, i);
    const numu::RecoInteraction &interaction = event.reco[i];


    if (event.tracks.size() > (unsigned)interaction.slice.primary_track_index) {
      const numu::RecoTrack &track = event.tracks.at(interaction.slice.primary_track_index);

      for (unsigned cut_i = 0; cut_i < Cuts::nCuts; cut_i++) {
        if (cuts[cut_i] && cutmaker.HasCRTHitMatch(track)) {
          std::cout << "Filling CRT Histo!\n";
          fCRTs[cut_i].Fill(track.crt_match.hit);
        }
      }

      for (unsigned j = 0; j < fPrimaryTracks.size(); j++) { 
        const numu::TrueParticle &part = (track.match.has_match) ? event.particles.at(track.match.mcparticle_id) : bad;
        bool select = selectors[i](track, part, event.type);
        if (select) {
          for (unsigned cut_i = 0; cut_i < Cuts::nCuts; cut_i++) {
            if (cuts[cut_i]) {
              fPrimaryTracks[j][cut_i].Fill(track, event.particles);
              for (unsigned k = 0; k < xfunctions.size(); k++) {
                const numu::TrueParticle &part = (track.match.has_match) ? event.particles.at(track.match.mcparticle_id) : bad;
                uscript::Value x = xfunctions[k](&track, &part, (unsigned*)&event.type);
                assert(IS_NUMBER(x));
                fPrimaryTrackProfiles[j][k][cut_i].Fill(AS_NUMBER(x), 
                                                        track, event);
              }
            }
          }
        }
      }
    }

    // fill histos
    for (size_t cut_i=0; cut_i < Cuts::nCuts; cut_i++) {
      int mode = interaction.match.mode; 
      if (cuts[cut_i]) {
        fInteraction[cut_i+Cuts::nTruthCuts][mode].Fill(event.reco[i], 
                                                        event, 
                                                        core.truth);
        fInteraction[cut_i+Cuts::nTruthCuts][numu::mAll].Fill(event.reco[i], 
                                                              event, 
                                                              core.truth);
      }
    }
  }

  for (unsigned i = 0; i < core.truth.size(); i++) {
    std::array<bool, Cuts::nTruthCuts> cuts = cutmaker.ProcessTruthCuts(event, core, i); 
    for (int cut_i = 0; cut_i < Cuts::nTruthCuts; cut_i++) {
      int mode = numu::GetMode(core.truth[i]);
      if (cuts[cut_i]) {
        fInteraction[cut_i][mode].Fill(core.truth[i], i, event);
        fInteraction[cut_i][numu::mAll].Fill(core.truth[i], i, event);
      }
    }
  }
}

void ana::SBNOsc::Histograms::Initialize	(	const geo::GeometryCore *	geometry,
		const sbnd::CRTGeoAlg &	crt_geo,
		const Cuts &	cuts,
		const std::string &	prefix,
		const std::vector< std::string > &	track_histo_types,
		const std::vector< std::string > &	track_profile_types,
		const std::vector< std::tuple< unsigned, float, float >> &	track_profile_xranges
	)

Definition at line 111 of file Histograms.cc.

                                                                            {

  double max_length = SBNRecoUtils::MaxLength(geometry);
  geo::BoxBoundedGeo detector = SBNRecoUtils::DetectorVolume(geometry);
  std::vector<double> tagger_volume = crt_geo.CRTLimits();

  std::cout << "Limits: " << tagger_volume[0] << " " << tagger_volume[3] << " " << tagger_volume[1] << " " << tagger_volume[4] << " " << tagger_volume[2] << " " << tagger_volume[5] << std::endl;

  // make new directory for histograms
  TDirectory *d_top = gDirectory->mkdir("histograms");

  if (prefix.size() != 0) {
    d_top = d_top->mkdir(prefix.c_str());
    d_top->cd();
  }

  d_top->mkdir("cosmic");

  d_top->mkdir("cosmic/outtime");
  d_top->cd("cosmic/outtime");
  fCosmic[0].Initialize("", detector);
  d_top->cd();

  d_top->mkdir("cosmic/outtime_trig");
  d_top->cd("cosmic/outtime_trig");
  fCosmic[1].Initialize("", detector);
  d_top->cd();

  d_top->mkdir("cosmic/intime");
  d_top->cd("cosmic/intime");
  fCosmic[2].Initialize("", detector);
  d_top->cd();

  d_top->mkdir("cosmic/intime_trig");
  d_top->cd("cosmic/intime_trig");
  fCosmic[3].Initialize("", detector);
  d_top->cd();

  std::vector<std::string> cut_order = cuts.CutOrder();
  std::vector<std::string> truth_cut_order = cuts.TruthCutOrder();

  d_top->mkdir("interaction");
  for (unsigned i = 0; i < Histograms::nHistos; i++) {
    for (const auto mode: Histograms::allModes) {
      std::string cut_name = (i < truth_cut_order.size()) ? truth_cut_order[i] : cut_order[i - truth_cut_order.size()];
      std::string postfix = mode2Str(mode) + prefix + cut_name;
      std::string dirname = "interaction/" + mode2Str(mode) + "/" + cut_name;
      d_top->mkdir(dirname.c_str());
      d_top->cd(dirname.c_str());
      fInteraction[i][mode].Initialize("", detector, tagger_volume); 
      d_top->cd();
    }
  }

  d_top->mkdir("crt");
  for (unsigned cut_i = 0; cut_i < Cuts::nCuts; cut_i++) {
    std::string dirname = "crt/" + cut_order[cut_i];
    d_top->mkdir(dirname.c_str());
    d_top->cd(dirname.c_str());
    fCRTs[cut_i].Initialize("", tagger_volume);
    d_top->cd();
  }

  fAllTracks.reserve(track_histo_types.size());
  fPrimaryTracks.reserve(track_histo_types.size());

  d_top->mkdir("ptrack");
  d_top->mkdir("alltrack");
  for (unsigned i = 0; i < track_histo_types.size(); i++) {
    fAllTracks.emplace_back();
    fPrimaryTracks.emplace_back();
    fPrimaryTrackProfiles.emplace_back();

    std::string dirname = track_histo_types[i];
    std::string all_dirname = "alltrack/" + dirname;
    
    d_top->mkdir(all_dirname.c_str());
    d_top->cd(all_dirname.c_str());
    fAllTracks[i].Initialize("", detector, max_length);
    d_top->cd();
    for (unsigned j = 0; j < Cuts::nCuts; j++) {
      std::string p_dirname = "ptrack/" + dirname + cut_order[j];
      d_top->mkdir(p_dirname.c_str());
      d_top->cd(p_dirname.c_str());
      fPrimaryTracks[i][j].Initialize("", detector, max_length);
      d_top->cd();

      for (unsigned k = 0; k < track_profile_types.size(); k++) {
        if (j == 0) fPrimaryTrackProfiles[i].emplace_back();
        unsigned n_bin;
        float xlo, xhi;
        std::tie(n_bin, xlo, xhi) = track_profile_xranges[k];
        std::string p_profile_dirname = "ptrack/" + dirname + cut_order[j] + "/profile_" + track_profile_types[k];
        d_top->mkdir(p_profile_dirname.c_str());
        d_top->cd(p_profile_dirname.c_str());
        fPrimaryTrackProfiles[i][k][j].Initialize("", n_bin, xlo, xhi);
        d_top->cd();
      } 

    }
  }


  for (unsigned i = 0; i < 4; i++) {
    Merge(fCosmic[i]);
  }
  for (unsigned i = 0; i < Histograms::nHistos; i++) {
    for (const auto mode: Histograms::allModes) {
      Merge(fInteraction[i][mode]);
    }
  }

  for (unsigned i = 0; i < Cuts::nCuts; i++) {
    Merge(fCRTs[i]);
  }

  for (unsigned i = 0; i < fAllTracks.size(); i++) {
    Merge(fAllTracks[i]);
    for (unsigned j = 0; j < Cuts::nCuts; j++) {
      Merge(fPrimaryTracks[i][j]);
      for (unsigned k = 0; k < track_profile_types.size(); k++) {
        Merge(fPrimaryTrackProfiles[i][k][j]);
      } 
    } 
  }

}

static std::string ana::SBNOsc::Histograms::mode2Str ( const numu::InteractionMode &  mode )

inlinestatic

Turn the InteractionMode enum into a string for (e.g.) histogram names.

Parameters

mode	The interaction mode to be converted

Returns

String representaiton of that mode

Definition at line 78 of file Histograms.h.

                                                             {
    switch (mode) {
      case numu::mCC: return "CC";
      case numu::mCCNonPrimary: return "CC-Other";
      case numu::mNC: return "NC";
      case numu::mNCNonPrimary: return "NC-Other";
      case numu::mCosmic: return "Cosmic";
      case numu::mIntimeCosmic: return "IntimeCosmic";
      case numu::mOther: return "Other";
      case numu::mAll: return "All";
    }
    return "";
  }

Member Data Documentation

constexpr numu::InteractionMode ana::SBNOsc::Histograms::allModes[nModes]

static

Initial value:

= 
    { numu::mCC, numu::mCCNonPrimary, 
      numu::mNC, numu::mNCNonPrimary, 
      numu::mCosmic, numu::mIntimeCosmic, 
      numu::mOther, numu::mAll }

List of all interaction modes.

Definition at line 93 of file Histograms.h.

std::vector<TrackHistos> ana::SBNOsc::Histograms::fAllTracks

Track histograms for all tracks.

Definition at line 105 of file Histograms.h.

std::array<CosmicHistos, 4> ana::SBNOsc::Histograms::fCosmic

Definition at line 108 of file Histograms.h.

std::array<CRTHistos, Cuts::nCuts> ana::SBNOsc::Histograms::fCRTs

Definition at line 110 of file Histograms.h.

InteractionHistos ana::SBNOsc::Histograms::fInteraction[nHistos][nModes]

all the interaction histograms

Definition at line 104 of file Histograms.h.

std::vector<std::vector<std::array<TrackProfiles, Cuts::nCuts> > > ana::SBNOsc::Histograms::fPrimaryTrackProfiles

Profile histograms for primary tracks.

Definition at line 107 of file Histograms.h.

std::vector<std::array<TrackHistos, Cuts::nCuts> > ana::SBNOsc::Histograms::fPrimaryTracks

Track histograms for priamry tracks in a candidate neutrino interaction.

Definition at line 106 of file Histograms.h.

constexpr std::array<const char *, nHistos> ana::SBNOsc::Histograms::histoNames = concat(Cuts::truthCutNames, Cuts::cutNames)

static

Names of histograms.

Definition at line 102 of file Histograms.h.

const unsigned ana::SBNOsc::Histograms::nHistos = Cuts::nCuts + Cuts::nTruthCuts

static

Definition at line 91 of file Histograms.h.

const unsigned ana::SBNOsc::Histograms::nModes = 8

static

number of interaction modes

Definition at line 92 of file Histograms.h.

---

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

• Histograms.h
• Histograms.cc