Incorporate Trackless Pions

ccpion_common.h

@@ -8,14 +8,19 @@
 
 std::string GetPlaylistFile(std::string plist, bool is_mc,
                             bool use_xrootd = true) {
+  // small sample with michel branches
+  // /pnfs/minerva/persistent/users/granados/MADtuplas/merged/mc/Michel/ME1A/MasterAnaDev_mc_AnaTuple_run00110000_Playlist.root 
+  // /pnfs/minerva/persistent/users/granados/MADtuplas/merged/data/Michel/
+  // /pnfs/minerva/persistent/users/granados/MADtuplas/merged/20220101/mc/ME1A/
+  // /pnfs/minerva/persistent/users/granados/MADtuplas/merged/data/Michel/ME1A/ 
+  // /minerva/data/users/bmesserl/MECCCHpip_ana_plists/20220101/
+
   // const std::string processing_date = "20200713"; // new short tracking branches
-  const std::string processing_date = "20211115";  // new recoil energy branches
-  //  const std::string processing_date = "test"; // For test with small MAD tuplas
+  // const std::string processing_date = "20211012"; // new recoil energy branches
+  const std::string processing_date = "20220101"; // includes mehreen's michel branches
   const std::string is_mc_str = is_mc ? "mc" : "data";
   std::transform(plist.begin(), plist.end(), plist.begin(), ::toupper);
-  std::string topdir =
-      is_mc ? "/minerva/data/users/granados/MAD_ana_plists/"
-            : "/minerva/data/users/granados/MAD_ana_plists/";  // correct merging method
+  std::string topdir = "/minerva/data/users/bmesserl/MECCCHpip_ana_plists/";
   topdir += processing_date;
   std::string playlist_file =
       use_xrootd ? Form("%s/%s_%s_xrootd_plist.txt", topdir.c_str(),

includes/CCPiEvent.cxx

@@ -3,8 +3,8 @@
 
 #include "CCPiEvent.h"
 
-#include "Cuts.h"              // kCutsVector
-#include "Michel.h"            // class Michel, typdef MichelMap
+#include "Cuts.h"    // kCutsVector
+#include "Michel.h"  // class endpoint::Michel, typdef endpoint::MichelMap, endpoint::GetQualityMichels
 #include "common_functions.h"  // GetVar, HasVar
 
 //==============================================================================
@@ -18,9 +18,7 @@ CCPiEvent::CCPiEvent(const bool is_mc, const bool is_truth,
       m_signal_definition(signal_definition),
       m_universe(universe),
       m_reco_pion_candidate_idxs(),
-      m_highest_energy_pion_idx(-300)
-// m_reco_pion_candidate_idxs_sideband()
-{
+      m_highest_energy_pion_idx(-300) {
   m_is_signal = is_mc ? IsSignal(*universe, signal_definition) : false;
   m_weight = is_mc ? universe->GetWeight() : 1.;
   m_w_type = is_mc ? GetWSidebandType(*universe, signal_definition,
@@ -31,16 +29,9 @@ CCPiEvent::CCPiEvent(const bool is_mc, const bool is_truth,
 //==============================================================================
 // Helper Functions
 //==============================================================================
-// Used in analysis pipeline
-bool PassesCuts(CCPiEvent& e, bool& is_w_sideband) {
-  return PassesCuts(*e.m_universe, e.m_reco_pion_candidate_idxs, e.m_is_mc,
-                    e.m_signal_definition, is_w_sideband);
-}
-
-// Only used for studies -- not used in analysis pipeline
-bool PassesCuts(CCPiEvent& e, std::vector<ECuts> cuts) {
-  return PassesCuts(*e.m_universe, e.m_reco_pion_candidate_idxs, e.m_is_mc,
-                    e.m_signal_definition, cuts);
+// return tuple {passes_all_cuts, is_w_sideband, pion_candidate_idxs}
+std::tuple<bool, bool, std::vector<int>> PassesCuts(const CCPiEvent& e) {
+  return PassesCuts(*e.m_universe, e.m_is_mc, e.m_signal_definition);
 }
 
 SignalBackgroundType GetSignalBackgroundType(const CCPiEvent& e) {
@@ -102,28 +93,6 @@ void ccpi_event::FillRecoEvent(const CCPiEvent& event,
       FillMigration(event, variables, std::string("pimuAngle"));
     if (HasVar(variables, "PT") && HasVar(variables, "PT_true"))
       FillMigration(event, variables, std::string("PT"));
-    if (HasVar(variables, "thetaZ") && HasVar(variables, "thetaZ_true"))
-      FillMigration(event, variables, std::string("thetaZ"));
-    if (HasVar(variables, "Pxpi") && HasVar(variables, "Pxpi_true"))
-      FillMigration(event, variables, std::string("Pxpi"));
-    if (HasVar(variables, "Pypi") && HasVar(variables, "Pypi_true"))
-      FillMigration(event, variables, std::string("Pypi"));
-    if (HasVar(variables, "Pzpi") && HasVar(variables, "Pzpi_true"))
-      FillMigration(event, variables, std::string("Pzpi"));
-    if (HasVar(variables, "PxMu") && HasVar(variables, "PxMu_true"))
-      FillMigration(event, variables, std::string("PxMu"));
-    if (HasVar(variables, "PyMu") && HasVar(variables, "PyMu_true"))
-      FillMigration(event, variables, std::string("PyMu"));
-    if (HasVar(variables, "PzMu") && HasVar(variables, "PzMu_true"))
-      FillMigration(event, variables, std::string("PzMu"));
-    if (HasVar(variables, "PxNu") && HasVar(variables, "PxNu_true"))
-      FillMigration(event, variables, std::string("PxNu"));
-    if (HasVar(variables, "PyNu") && HasVar(variables, "PyNu_true"))
-      FillMigration(event, variables, std::string("PyNu"));
-    if (HasVar(variables, "PzNu") && HasVar(variables, "PzNu_true"))
-      FillMigration(event, variables, std::string("PzNu"));
-    if (HasVar(variables, "Ppi") && HasVar(variables, "Ppi_true"))
-      FillMigration(event, variables, std::string("Ppi"));
   }
 }
 
@@ -321,12 +290,14 @@ void ccpi_event::FillWSideband_Study(CCPiEvent& event,
   }
 }
 
+// Like FillCutVars, this function loops through cuts and calls PassesCut.
+// Michel containers updated as we go, but thrown away at the end.
 void ccpi_event::FillCounters(
     const CCPiEvent& event,
     const std::pair<EventCount*, EventCount*>& counters) {
   EventCount* signal = counters.first;
   EventCount* bg = event.m_is_mc ? counters.second : nullptr;
-  MichelMap dummy1, dummy2;
+  endpoint::MichelMap dummy1, dummy2;
   bool pass = true;
   // Purity and efficiency
   for (auto i_cut : kCutsVector) {
@@ -348,6 +319,38 @@ void ccpi_event::FillCounters(
   }  // cuts
 }
 
+std::pair<EventCount, EventCount> ccpi_event::FillCounters(
+    const CCPiEvent& event, const EventCount& s, const EventCount& b) {
+  EventCount signal = s;
+  EventCount bg = b;
+
+  endpoint::MichelMap endpoint_michels;
+  trackless::MichelEvent vtx_michels;
+  bool pass = true;
+  for (auto i_cut : kCutsVector) {
+    if (event.m_is_truth != IsPrecut(i_cut)) continue;
+
+    bool passes_this_cut = true;
+    std::tie(passes_this_cut, endpoint_michels, vtx_michels) =
+        PassesCut(*event.m_universe, i_cut, event.m_is_mc,
+                  event.m_signal_definition, endpoint_michels, vtx_michels);
+
+    pass = pass && passes_this_cut;
+
+    if (!pass) continue;
+
+    if (!event.m_is_mc) {
+      signal[i_cut] += event.m_weight;  // selected data
+    } else {
+      if (event.m_is_signal)
+        signal[i_cut] += event.m_weight;  // selected mc signal
+      else
+        bg[i_cut] += event.m_weight;  // selected mc bg
+    }
+  }  // cuts loop
+  return {signal, bg};
+}
+
 void ccpi_event::FillCutVars(CCPiEvent& event,
                              const std::vector<Variable*>& variables) {
   const CVUniverse* universe = event.m_universe;
@@ -357,10 +360,10 @@ void ccpi_event::FillCutVars(CCPiEvent& event,
 
   if (universe->ShortName() != "cv") return;
 
-  MichelMap endpoint_michels;
+  endpoint::MichelMap endpoint_michels;
   endpoint_michels.clear();
 
-  MichelMap vertex_mich;
+  endpoint::MichelMap vertex_mich;
   vertex_mich.clear();
 
   // loop cuts
@@ -409,7 +412,7 @@ void ccpi_event::FillCutVars(CCPiEvent& event,
     }
     // N michels
     if (next_cut == kAtLeastOneMichel && HasVar(variables, "michel_count")) {
-      double fill_val = GetQualityMichels(*universe).size();
+      double fill_val = endpoint::GetQualityMichels(*universe).size();
       FillStackedHists(event, GetVar(variables, "michel_count"), fill_val);
       // if (fill_val == 0 && event.m_is_signal)
       //  universe->PrintArachneLink();
@@ -483,7 +486,7 @@ void ccpi_event::FillCutVars(CCPiEvent& event,
       if (HasVar(variables, "adphi"))
         FillStackedHists(event, GetVar(variables, "adphi"));
       if (HasVar(variables, "pimuAngle"))
-        FillStackedHists(event, GetVar(variables, "pimuAngle"));       
+        FillStackedHists(event, GetVar(variables, "pimuAngle"));
       if (HasVar(variables, "PT"))
         FillStackedHists(event, GetVar(variables, "PT"));
     }
@@ -550,4 +553,25 @@ void ccpi_event::FillStackedHists(const CCPiEvent& event, Variable* v,
       ->Fill(fill_val, event.m_weight);
 }
 
+//==============================================================================
+// BEING DEPRECATED
+//==============================================================================
+
+// Used in analysis pipeline
+// Uses PassesCuts v2. Does check w sideband, but fills by reference instead of
+// returning its results. v3 is the future.
+bool PassesCuts(CCPiEvent& e, bool& is_w_sideband) {
+  return PassesCuts(*e.m_universe, e.m_reco_pion_candidate_idxs, e.m_is_mc,
+                    e.m_signal_definition, is_w_sideband);
+}
+
+// Uses PassesCuts v1.
+// No longer used anywhere. Doesn't check w sideband while looping all cuts.
+// Nothing wrong with it per se. Checking the w sideband is just practically
+// free. v3 of PassesCuts is the future, anyways.
+bool PassesCuts(CCPiEvent& e, std::vector<ECuts> cuts) {
+  return PassesCuts(*e.m_universe, e.m_reco_pion_candidate_idxs, e.m_is_mc,
+                    e.m_signal_definition, cuts);
+}
+
 #endif  // CCPiEvent_cxx

includes/CCPiEvent.h

@@ -50,8 +50,7 @@ struct CCPiEvent {
 
 // Helper Functions
 // bool IsWSideband(CCPiEvent&);
-bool PassesCuts(CCPiEvent&, bool& is_w_sideband);
-bool PassesCuts(CCPiEvent& e, std::vector<ECuts> cuts = kCutsVector);
+std::tuple<bool, bool, std::vector<int>> PassesCuts(const CCPiEvent&);
 RecoPionIdx GetHighestEnergyPionCandidateIndex(const CCPiEvent&);
 SignalBackgroundType GetSignalBackgroundType(const CCPiEvent&);
 
@@ -70,11 +69,20 @@ void FillMigration(const CCPiEvent&, const std::vector<Variable*>&,
 void FillWSideband_Study(CCPiEvent&, std::vector<Variable*>);
 void FillCounters(const CCPiEvent&,
                   const std::pair<EventCount*, EventCount*>& counters);
+std::pair<EventCount, EventCount> FillCounters(const CCPiEvent&,
+                                               const EventCount& signal,
+                                               const EventCount& bg);
 void FillCutVars(CCPiEvent&, const std::vector<Variable*>&);
 void FillStackedHists(const CCPiEvent&,
                       const std::vector<Variable*>&);  // all variables
 void FillStackedHists(const CCPiEvent&, Variable*,
                       const double fill_value = -999.);  // Single variable
 }  // namespace ccpi_event
 
+//==============================================================================
+// BEING DEPRECATED
+//==============================================================================
+bool PassesCuts(CCPiEvent&, bool& is_w_sideband);
+bool PassesCuts(CCPiEvent&, std::vector<ECuts> cuts);
+
 #endif  // CCPiEvent

includes/CVUniverse.cxx

@@ -268,21 +268,22 @@ double CVUniverse::GetThetapiDeg(RecoPionIdx hadron) const {
 }
 
 double CVUniverse::GetTpi(RecoPionIdx hadron) const {
-  if (hadron == -1) {
-    std::cerr << "CVU::GetTpi: pion_idx = -1.\n"
-                 "In the future this will be the code for a vertex pion.\n";
-    throw hadron;
+  // We have a pion associated with a track -- prefer this to a Mehreen vertex pion
+  if (hadron != -1) {
+    // return (GetVecElem("MasterAnaDev_hadron_pion_E", hadron)
+    //          - CCNuPionIncConsts::CHARGED_PION_MASS)/0.96;
+    double Epi = GetVecElem("MasterAnaDev_pion_E", hadron);
+    if (Epi == 0) {
+      return GetTpiMBR(hadron);  // TODO maybe do from momentum instead
+                                 // Not sure what this fail mode means.
+      // std::cout << "CVUniverse::GetTpi: warning Epi < 0\n";
+      // return 0;
+    }
+    return Epi - CCNuPionIncConsts::CHARGED_PION_MASS;
   }
-  // return (GetVecElem("MasterAnaDev_hadron_pion_E", hadron)
-  //          - CCNuPionIncConsts::CHARGED_PION_MASS)/0.96;
-  double Epi = GetVecElem("MasterAnaDev_pion_E", hadron);
-  if (Epi == 0) {
-    return GetTpiMBR(hadron);  // TODO maybe do from momentum instead
-                               // Not sure what this fail mode means.
-    // std::cout << "CVUniverse::GetTpi: warning Epi < 0\n";
-    // return 0;
+  else {
+    return GetTpiMehreen();
   }
-  return Epi - CCNuPionIncConsts::CHARGED_PION_MASS;
 }
 
 double CVUniverse::GetTpiMBR(RecoPionIdx hadron) const {

includes/CVUniverse.h

@@ -5,13 +5,15 @@
 
 #include "Binning.h"    // CCPi::GetBinning for ehad_nopi
 #include "Constants.h"  // CCNuPionIncConsts, CCNuPionIncShifts, Reco/TruePionIdx
+#include "MichelEvent.h" // a data/container struct
 #include "PlotUtils/ChainWrapper.h"
 #include "PlotUtils/MinervaUniverse.h"
 
 class CVUniverse : public PlotUtils::MinervaUniverse {
  private:
   // Pion Candidates - clear these when SetEntry is called
   std::vector<RecoPionIdx> m_pion_candidates;
+  trackless::MichelEvent m_vtx_michels;
 
  public:
 #include "PlotUtils/MichelFunctions.h"
@@ -33,14 +35,21 @@ class CVUniverse : public PlotUtils::MinervaUniverse {
   virtual double GetDummyHadVar(const int x) const;
 
   // No stale cache!
-  virtual void OnNewEntry() override { m_pion_candidates.clear(); }
+  virtual void OnNewEntry() override { m_pion_candidates.clear(); m_vtx_michels = trackless::MichelEvent();}
 
   // Get and set pion candidates
   TruePionIdx GetHighestEnergyTruePionIndex() const;
   int GetHighestEnergyPionCandidateIndex(const std::vector<int>& pions) const;
   std::vector<RecoPionIdx> GetPionCandidates() const;
   void SetPionCandidates(std::vector<RecoPionIdx> c);
 
+  void SetVtxMichels(const trackless::MichelEvent& m) {
+     m_vtx_michels = m;
+  }
+  trackless::MichelEvent GetVtxMichels() const {
+    return m_vtx_michels;
+  }
+
   //==============================================================================
   // Analysis Variables
   //==============================================================================
@@ -52,7 +61,7 @@ class CVUniverse : public PlotUtils::MinervaUniverse {
   virtual double GetThetamuDeg() const;
 
   // event-wide
-  virtual double GetEhad() const;
+  virtual double GetEhad() const; // relies on member m_pion_candidates
   virtual double GetEnu() const;
   virtual double GetQ2() const;
   virtual double GetWexp() const;
@@ -75,6 +84,7 @@ class CVUniverse : public PlotUtils::MinervaUniverse {
   virtual double GetTpiMBR(RecoPionIdx) const;
   virtual double GetpimuAngle(RecoPionIdx) const;
   virtual double Gett(RecoPionIdx) const;
+  virtual double GetTpiMehreen() { return 0; }
 
   //==============================================================================
   // Truth
@@ -205,6 +215,44 @@ class CVUniverse : public PlotUtils::MinervaUniverse {
   double Calct(const double epi, const double emu, const double pzpi,
                const double pzmu, const double pxpi, const double pxmu,
                const double pypi, const double pymu) const;
+
+  // Mehreen
+  virtual double GetTpiMehreen() const { return 0; }
+  ROOT::Math::XYZTVector GetVertex() const
+  {
+    ROOT::Math::XYZTVector result;
+    result.SetCoordinates(GetVec<double>("vtx").data());
+    return result;
+  }
+  virtual double thetaWRTBeam(double x, double y, double z) const {
+      double pyp = -1.0 *sin( MinervaUnits::numi_beam_angle_rad)*z + cos( MinervaUnits::numi_beam_angle_rad )*y;
+      double pzp = cos( MinervaUnits::numi_beam_angle_rad )*z + sin( MinervaUnits::numi_beam_angle_rad )*y;
+      double denom2 = pow(x,2) + pow(pyp,2) + pow(pzp,2);
+      if( 0. == denom2 ) return -9999.;
+      else return acos(pzp / sqrt(denom2) );
+  } 
+  virtual int GetNMichels() const{
+      return GetInt("FittedMichel_michel_fitPass_sz");
+  }
+  virtual int GetNTruePions() const{
+      return GetInt("FittedMichel_all_piontrajectory_trackID_sz");
+  }
+  virtual double GetTrueTpi() const {
+     int nFSpi = GetNTruePions();
+     double pionKE = 9999.;
+     for (int i = 0; i < nFSpi; i++){
+         int pdg = GetVecElem("FittedMichel_all_piontrajectory_pdg", i);
+         int pitrackid = GetVecElem("FittedMichel_all_piontrajectory_ParentID", i);
+
+         double energy = GetVecElem("FittedMichel_all_piontrajectory_energy",i);
+         double p = GetVecElem("FittedMichel_all_piontrajectory_momentum", i);
+         double mass = sqrt(pow(energy,2) - pow(p, 2));
+         double tpi = energy - mass;
+         if (tpi <= pionKE) pionKE = tpi;
+      }
+
+      return pionKE;
+  }
 };
 
 #endif  // CVUniverse_H