All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
sbn::PCAngleKinkTree Class Reference
Inheritance diagram for sbn::PCAngleKinkTree:

Public Member Functions

 PCAngleKinkTree (fhicl::ParameterSet const &p)
 
 PCAngleKinkTree (PCAngleKinkTree const &)=delete
 
 PCAngleKinkTree (PCAngleKinkTree &&)=delete
 
PCAngleKinkTreeoperator= (PCAngleKinkTree const &)=delete
 
PCAngleKinkTreeoperator= (PCAngleKinkTree &&)=delete
 
void analyze (art::Event const &e) override
 
void respondToOpenInputFile (const art::FileBlock &fb)
 

Private Member Functions

void Clear ()
 
void FillTruth (const simb::MCParticle &trueParticle, const std::vector< art::Ptr< simb::MCParticle >> &allParticles)
 
void FillTrueScatter (TLorentzVector pos, TLorentzVector mom0, TLorentzVector mom1, bool elastic)
 
void FillAngles (const recob::PFParticle &particle, const std::vector< art::Ptr< sbn::PCAnglePlane >> &angles)
 
void FillParticle (const recob::PFParticle &particle)
 
void FillMeta (const art::Event &evt)
 
void FillKinks (const recob::PFParticle &particle, const std::vector< art::Ptr< sbn::PCAngleKink >> &kinks)
 
void MatchKinks ()
 
void MatchPlaneKinks (unsigned Plane, std::vector< int > &scatter_match_plane, std::vector< float > &scatter_dist_plane, const std::vector< float > &scatterW, const std::vector< float > &reco_kinkT, const std::vector< float > &reco_kinkW)
 

Private Attributes

std::vector< std::string > fPFParticleTags
 
std::vector< std::string > fAngleTags
 
std::vector< std::string > fKinkTags
 
float fAngleCut
 
bool fRequireReco
 
TTree * _tree
 
std::vector< sbn::PCAngle > fPCAngleU
 
std::vector< sbn::PCAngle > fPCAngleV
 
std::vector< sbn::PCAngle > fPCAngleY
 
std::vector< int > fPCAngleUGen
 
std::vector< int > fPCAngleVGen
 
std::vector< int > fPCAngleYGen
 
std::vector< int > fPCAngleUID
 
std::vector< int > fPCAngleVID
 
std::vector< int > fPCAngleYID
 
std::vector< float > fTrajX
 
std::vector< float > fTrajY
 
std::vector< float > fTrajZ
 
std::vector< float > fTrajPU
 
std::vector< float > fTrajPV
 
std::vector< float > fTrajPY
 
std::vector< float > fTrajPT
 
std::vector< float > fScatterX
 
std::vector< float > fScatterY
 
std::vector< float > fScatterZ
 
std::vector< float > fScatterM1X
 
std::vector< float > fScatterM1Y
 
std::vector< float > fScatterM1Z
 
std::vector< float > fScatterM1P
 
std::vector< float > fScatterM0X
 
std::vector< float > fScatterM0Y
 
std::vector< float > fScatterM0Z
 
std::vector< float > fScatterM0P
 
std::vector< float > fScatterPU
 
std::vector< float > fScatterPV
 
std::vector< float > fScatterPY
 
std::vector< float > fScatterPT
 
std::vector< float > fScatterMag
 
std::vector< float > fScatterMagU
 
std::vector< float > fScatterMagV
 
std::vector< float > fScatterMagY
 
std::vector< bool > fScatterIsElastic
 
std::vector< int > fScatterMatchU
 
std::vector< float > fScatterMatchDistU
 
std::vector< int > fScatterMatchV
 
std::vector< float > fScatterMatchDistV
 
std::vector< int > fScatterMatchY
 
std::vector< float > fScatterMatchDistY
 
std::vector< float > fKinkTimeMaxU
 
std::vector< float > fKinkWireMaxU
 
std::vector< float > fKinkTimeLoU
 
std::vector< float > fKinkWireLoU
 
std::vector< float > fKinkTimeHiU
 
std::vector< float > fKinkWireHiU
 
std::vector< float > fKinkEstAngleU
 
std::vector< float > fKinkMaxAngleU
 
std::vector< float > fKinkLoHiAngleU
 
std::vector< float > fKinkFitAngleU
 
std::vector< float > fKinkFitPitchU
 
std::vector< float > fKinkFitChi2U
 
std::vector< float > fKinkTimeMaxV
 
std::vector< float > fKinkWireMaxV
 
std::vector< float > fKinkTimeLoV
 
std::vector< float > fKinkWireLoV
 
std::vector< float > fKinkTimeHiV
 
std::vector< float > fKinkWireHiV
 
std::vector< float > fKinkEstAngleV
 
std::vector< float > fKinkMaxAngleV
 
std::vector< float > fKinkLoHiAngleV
 
std::vector< float > fKinkFitAngleV
 
std::vector< float > fKinkFitPitchV
 
std::vector< float > fKinkFitChi2V
 
std::vector< float > fKinkTimeMaxY
 
std::vector< float > fKinkWireMaxY
 
std::vector< float > fKinkTimeLoY
 
std::vector< float > fKinkWireLoY
 
std::vector< float > fKinkTimeHiY
 
std::vector< float > fKinkWireHiY
 
std::vector< float > fKinkEstAngleY
 
std::vector< float > fKinkMaxAngleY
 
std::vector< float > fKinkLoHiAngleY
 
std::vector< float > fKinkFitAngleY
 
std::vector< float > fKinkFitPitchY
 
std::vector< float > fKinkFitChi2Y
 
int fTruePDG
 
float fTrueE
 
float fTrueP
 
float fTrueEndE
 
float fTrueEndP
 
bool fTrueEndScatter
 
int fIEvt
 
int fIFile
 
int fEvt
 
int fPFPID
 

Detailed Description

Definition at line 42 of file PCAngleKinkTree_module.cc.

Constructor & Destructor Documentation

sbn::PCAngleKinkTree::PCAngleKinkTree ( fhicl::ParameterSet const &  p)
explicit

Definition at line 199 of file PCAngleKinkTree_module.cc.

200  : EDAnalyzer{p}, // ,
201  fPFParticleTags(p.get<std::vector<std::string>>("ParticleTags")),
202  fAngleTags(p.get<std::vector<std::string>>("AngleTags")),
203  fKinkTags(p.get<std::vector<std::string>>("KinkTags")),
204  fAngleCut(p.get<float>("AngleCut", 5.)),
205  fRequireReco(p.get<bool>("RequireReco", false))
206  // More initializers here.
207 {
208  fIEvt = 0;
209  fIFile = 0;
210  art::ServiceHandle<art::TFileService> tfs;
211 
212  _tree = tfs->make<TTree>("PCAngleKinkAnalyzer", "kink_tree");
213 
214  _tree->Branch("pcangle_u", &fPCAngleU);
215  _tree->Branch("pcangle_v", &fPCAngleV);
216  _tree->Branch("pcangle_y", &fPCAngleY);
217 
218  _tree->Branch("pcangle_u_id", &fPCAngleUID);
219  _tree->Branch("pcangle_v_id", &fPCAngleVID);
220  _tree->Branch("pcangle_y_id", &fPCAngleYID);
221 
222  _tree->Branch("pcangle_u_gen", &fPCAngleUGen);
223  _tree->Branch("pcangle_v_gen", &fPCAngleVGen);
224  _tree->Branch("pcangle_y_gen", &fPCAngleYGen);
225 
226  _tree->Branch("kink_time_max_u", &fKinkTimeMaxU);
227  _tree->Branch("kink_wire_max_u", &fKinkWireMaxU);
228  _tree->Branch("kink_time_lo_u", &fKinkTimeLoU);
229  _tree->Branch("kink_wire_lo_u", &fKinkWireLoU);
230  _tree->Branch("kink_time_hi_u", &fKinkTimeHiU);
231  _tree->Branch("kink_wire_hi_u", &fKinkWireHiU);
232  _tree->Branch("kink_est_angle_u", &fKinkEstAngleU);
233  _tree->Branch("kink_max_angle_u", &fKinkMaxAngleU);
234  _tree->Branch("kink_lohi_angle_u", &fKinkLoHiAngleU);
235  _tree->Branch("kink_fit_angle_u", &fKinkFitAngleU);
236  _tree->Branch("kink_fit_pitch_u", &fKinkFitPitchU);
237  _tree->Branch("kink_fit_chi2_u", &fKinkFitChi2U);
238 
239  _tree->Branch("kink_time_max_v", &fKinkTimeMaxV);
240  _tree->Branch("kink_wire_max_v", &fKinkWireMaxV);
241  _tree->Branch("kink_time_lo_v", &fKinkTimeLoV);
242  _tree->Branch("kink_wire_lo_v", &fKinkWireLoV);
243  _tree->Branch("kink_time_hi_v", &fKinkTimeHiV);
244  _tree->Branch("kink_wire_hi_v", &fKinkWireHiV);
245  _tree->Branch("kink_est_angle_v", &fKinkEstAngleV);
246  _tree->Branch("kink_max_angle_v", &fKinkMaxAngleV);
247  _tree->Branch("kink_lohi_angle_v", &fKinkLoHiAngleV);
248  _tree->Branch("kink_fit_angle_v", &fKinkFitAngleV);
249  _tree->Branch("kink_fit_pitch_v", &fKinkFitPitchV);
250  _tree->Branch("kink_fit_chi2_v", &fKinkFitChi2V);
251 
252  _tree->Branch("kink_time_max_y", &fKinkTimeMaxY);
253  _tree->Branch("kink_wire_max_y", &fKinkWireMaxY);
254  _tree->Branch("kink_time_lo_y", &fKinkTimeLoY);
255  _tree->Branch("kink_wire_lo_y", &fKinkWireLoY);
256  _tree->Branch("kink_time_hi_y", &fKinkTimeHiY);
257  _tree->Branch("kink_wire_hi_y", &fKinkWireHiY);
258  _tree->Branch("kink_est_angle_y", &fKinkEstAngleY);
259  _tree->Branch("kink_max_angle_y", &fKinkMaxAngleY);
260  _tree->Branch("kink_lohi_angle_y", &fKinkLoHiAngleY);
261  _tree->Branch("kink_fit_angle_y", &fKinkFitAngleY);
262  _tree->Branch("kink_fit_pitch_y", &fKinkFitPitchY);
263  _tree->Branch("kink_fit_chi2_y", &fKinkFitChi2Y);
264 
265  _tree->Branch("traj_x", &fTrajX);
266  _tree->Branch("traj_y", &fTrajY);
267  _tree->Branch("traj_z", &fTrajZ);
268  _tree->Branch("traj_pu", &fTrajPU);
269  _tree->Branch("traj_pv", &fTrajPV);
270  _tree->Branch("traj_py", &fTrajPY);
271  _tree->Branch("traj_pt", &fTrajPT);
272 
273  _tree->Branch("scatter_mom1_x", &fScatterM1X);
274  _tree->Branch("scatter_mom1_y", &fScatterM1Y);
275  _tree->Branch("scatter_mom1_z", &fScatterM1Z);
276  _tree->Branch("scatter_mom1_p", &fScatterM1P);
277  _tree->Branch("scatter_mom0_x", &fScatterM0X);
278  _tree->Branch("scatter_mom0_y", &fScatterM0Y);
279  _tree->Branch("scatter_mom0_z", &fScatterM0Z);
280  _tree->Branch("scatter_mom0_p", &fScatterM0P);
281 
282  _tree->Branch("scatter_x", &fScatterX);
283  _tree->Branch("scatter_y", &fScatterY);
284  _tree->Branch("scatter_z", &fScatterZ);
285  _tree->Branch("scatter_pu", &fScatterPU);
286  _tree->Branch("scatter_pv", &fScatterPV);
287  _tree->Branch("scatter_py", &fScatterPY);
288  _tree->Branch("scatter_pt", &fScatterPT);
289 
290  _tree->Branch("scatter_mag", &fScatterMag);
291  _tree->Branch("scatter_mag_u", &fScatterMagU);
292  _tree->Branch("scatter_mag_v", &fScatterMagV);
293  _tree->Branch("scatter_mag_y", &fScatterMagY);
294 
295  _tree->Branch("scatter_is_elastic", &fScatterIsElastic);
296 
297  _tree->Branch("scatter_match_u", &fScatterMatchU);
298  _tree->Branch("scatter_match_dist_u", &fScatterMatchDistU);
299  _tree->Branch("scatter_match_v", &fScatterMatchV);
300  _tree->Branch("scatter_match_dist_v", &fScatterMatchDistV);
301  _tree->Branch("scatter_match_y", &fScatterMatchY);
302  _tree->Branch("scatter_match_dist_y", &fScatterMatchDistY);
303 
304  _tree->Branch("true_pdg", &fTruePDG, "true_pdg/i");
305  _tree->Branch("true_p", &fTrueP, "true_p/F");
306  _tree->Branch("true_e", &fTrueE, "true_e/F");
307  _tree->Branch("true_end_p", &fTrueEndP, "true_end_p/F");
308  _tree->Branch("true_end_e", &fTrueEndE, "true_end_e/F");
309  _tree->Branch("true_end_scatter", &fTrueEndScatter, "true_end_scatter/O");
310 
311  _tree->Branch("ifile", &fIFile, "ifile/i");
312  _tree->Branch("ievt", &fIEvt, "ievt/i");
313  _tree->Branch("evt", &fEvt, "evt/i");
314  _tree->Branch("pfpid", &fPFPID, "pfpid/i");
315 }
std::vector< int > fPCAngleVGen
std::vector< float > fKinkWireHiU
std::vector< float > fScatterMatchDistV
std::vector< float > fKinkTimeHiU
std::vector< sbn::PCAngle > fPCAngleV
std::vector< float > fScatterMag
std::vector< float > fScatterPU
std::vector< std::string > fKinkTags
std::vector< float > fScatterMagU
std::vector< int > fScatterMatchU
std::vector< float > fKinkFitChi2Y
std::vector< float > fScatterMagV
std::vector< float > fScatterM1Y
std::vector< int > fScatterMatchY
std::vector< float > fKinkWireHiV
std::vector< float > fKinkWireHiY
pdgs p
Definition: selectors.fcl:22
std::vector< int > fScatterMatchV
std::vector< float > fTrajPT
std::vector< float > fScatterY
std::vector< float > fKinkWireLoU
std::vector< float > fKinkFitAngleY
std::vector< float > fScatterM0Z
std::vector< float > fKinkTimeLoU
std::vector< float > fKinkTimeMaxV
std::vector< float > fKinkEstAngleU
std::vector< float > fKinkLoHiAngleU
std::vector< float > fKinkTimeLoV
std::vector< float > fKinkMaxAngleY
std::vector< sbn::PCAngle > fPCAngleU
std::vector< int > fPCAngleVID
std::vector< int > fPCAngleYID
std::vector< std::string > fPFParticleTags
std::vector< float > fScatterMatchDistY
std::vector< float > fTrajPU
std::vector< float > fKinkFitPitchV
std::vector< float > fScatterMatchDistU
std::vector< float > fKinkFitPitchU
std::vector< float > fTrajZ
std::vector< float > fKinkTimeHiY
std::vector< float > fKinkFitAngleV
std::vector< float > fKinkLoHiAngleV
std::vector< float > fTrajY
std::vector< float > fKinkFitChi2U
std::vector< float > fKinkTimeLoY
std::vector< float > fKinkFitChi2V
std::vector< float > fScatterM0Y
std::vector< float > fScatterM0X
std::vector< float > fScatterMagY
std::vector< float > fKinkFitPitchY
std::vector< float > fKinkWireMaxU
std::vector< float > fKinkWireMaxV
std::vector< sbn::PCAngle > fPCAngleY
std::vector< float > fScatterPT
std::vector< float > fKinkEstAngleY
std::vector< float > fKinkWireLoV
std::vector< float > fScatterM1Z
std::vector< int > fPCAngleUID
std::vector< float > fKinkLoHiAngleY
std::vector< float > fScatterM0P
std::vector< float > fKinkTimeMaxY
std::vector< float > fScatterPV
std::vector< float > fTrajPY
std::vector< bool > fScatterIsElastic
std::vector< float > fKinkTimeMaxU
std::vector< float > fKinkFitAngleU
std::vector< float > fKinkWireLoY
art::ServiceHandle< art::TFileService > tfs
std::vector< float > fScatterZ
std::vector< float > fScatterPY
std::vector< float > fTrajPV
std::vector< float > fScatterM1X
std::vector< float > fKinkEstAngleV
std::vector< float > fKinkMaxAngleV
std::vector< std::string > fAngleTags
std::vector< float > fKinkTimeHiV
std::vector< float > fScatterM1P
std::vector< int > fPCAngleUGen
std::vector< float > fKinkWireMaxY
std::vector< float > fTrajX
std::vector< float > fScatterX
std::vector< float > fKinkMaxAngleU
std::vector< int > fPCAngleYGen
sbn::PCAngleKinkTree::PCAngleKinkTree ( PCAngleKinkTree const &  )
delete
sbn::PCAngleKinkTree::PCAngleKinkTree ( PCAngleKinkTree &&  )
delete

Member Function Documentation

void sbn::PCAngleKinkTree::analyze ( art::Event const &  e)
override

Definition at line 666 of file PCAngleKinkTree_module.cc.

667 {
668  // service data
669  art::ServiceHandle<cheat::BackTrackerService> bt;
670  auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
671 
672  // input data
673  std::vector<std::vector<art::Ptr<recob::PFParticle>>> particleList;
674  std::vector<art::FindManyP<sbn::PCAnglePlane>> particleAngleList;
675  std::vector<art::FindManyP<sbn::PCAngleKink>> particleKinkList;
676  std::vector<art::FindManyP<recob::Cluster>> particleClusterList;
677 
678  for (unsigned i = 0; i < fPFParticleTags.size(); i++) {
679  art::Handle<std::vector<recob::PFParticle>> pfparticle_handle;
680  evt.getByLabel(fPFParticleTags.at(i), pfparticle_handle);
681  particleList.emplace_back();
682  art::fill_ptr_vector(particleList.back(), pfparticle_handle);
683  particleAngleList.emplace_back(particleList.back(), evt, fAngleTags.at(i));
684  particleKinkList.emplace_back(particleList.back(), evt, fKinkTags.at(i));
685  particleClusterList.emplace_back(particleList.back(), evt, fPFParticleTags.at(i));
686  }
687 
688  // flatten
689  std::vector<art::Ptr<recob::PFParticle>> particles;
690  std::vector<std::vector<art::Ptr<sbn::PCAnglePlane>>> particleAngles;
691  std::vector<std::vector<art::Ptr<sbn::PCAngleKink>>> particleKinks;
692  std::vector<std::vector<art::Ptr<recob::Cluster>>> particleClusters;
693  std::vector<std::vector<art::Ptr<recob::Hit>>> particleHits;
694 
695  for (unsigned i = 0; i < particleList.size(); i++) {
696  particles.insert(particles.end(), particleList[i].begin(), particleList[i].end());
697 
698  for (unsigned j = 0; j < particleList[i].size(); j++) {
699  particleAngles.push_back(particleAngleList[i].at(j));
700  particleKinks.push_back(particleKinkList[i].at(j));
701  particleClusters.push_back(particleClusterList[i].at(j));
702 
703  particleHits.emplace_back();
704  art::FindManyP<recob::Hit> clusterHits(particleClusters.back(), evt, fPFParticleTags.at(i));
705  for (unsigned i_clus = 0; i_clus < particleClusters.back().size(); i_clus++) {
706  particleHits.back().insert(particleHits.back().end(), clusterHits.at(i_clus).begin(), clusterHits.at(i_clus).end());
707  }
708  }
709  }
710 
711  // also get truth stuff
712  art::Handle<std::vector<simb::MCParticle>> trueParticleHandle;
713  evt.getByLabel("largeant", trueParticleHandle);
714  std::vector<art::Ptr<simb::MCParticle>> trueParticles;
715  art::fill_ptr_vector(trueParticles, trueParticleHandle);
716 
717  std::vector<unsigned> primary;
718  // get the primary particles
719  for (unsigned i_mcpart = 0; i_mcpart < trueParticles.size(); i_mcpart++) {
720  if (trueParticles[i_mcpart]->Process() == "primary") {
721  primary.push_back(i_mcpart);
722  }
723  }
724 
725  // process true
726  for (unsigned i_mcpart: primary) {
727  const art::Ptr<simb::MCParticle> &truep = trueParticles[i_mcpart];
728 
729  // setup
730  Clear();
731  FillMeta(evt);
732 
733  // Fill truth stuff
734  FillTruth(*truep, trueParticles);
735 
736  // look up the deposited energy of the true particle
737  // get all the IDE's of the truth track
738  const std::vector<const sim::IDE*> mcparticle_ides = bt->TrackIdToSimIDEs_Ps(truep->TrackId());
739  // sum it up
740  float mcparticle_energy = 0.;
741  for (auto const &ide: mcparticle_ides) {
742  mcparticle_energy += ide->energy;
743  }
744 
745  // process
746  // Fid Reco match
747  int i_reco_match = -1;
748  for (unsigned i_part = 0; i_part < particles.size(); i_part++) {
749  const std::vector<art::Ptr<recob::Hit>> &hits = particleHits[i_part];
750 
751  std::vector<std::pair<int, float>> matches = CAFRecoUtils::AllTrueParticleIDEnergyMatches(clock_data, hits, true);
752  int match_id = matches.size() ? std::max_element(matches.begin(), matches.end(),
753  [](const auto &a, const auto &b) { return a.second < b.second; })->first : -1;
754  float matchE = matches.size() ? std::max_element(matches.begin(), matches.end(),
755  [](const auto &a, const auto &b) { return a.second < b.second; })->second : -1;
756  float totalE = std::accumulate(matches.begin(), matches.end(), 0.,
757  [](auto const &a, auto const &b) { return a + b.second;});
758 
759  if (match_id == truep->TrackId() && matchE / mcparticle_energy > 0.5 && matchE / totalE > 0.5) {
760  i_reco_match = i_part;
761  break;
762  }
763  }
764 
765  // fill reco stuff if we found a reco PFParticle
766  if (i_reco_match >= 0) {
767  const recob::PFParticle &particle = *particles[i_reco_match];
768  const std::vector<art::Ptr<sbn::PCAnglePlane>> &angle = particleAngles[i_reco_match];
769  const std::vector<art::Ptr<sbn::PCAngleKink>> &kinks = particleKinks[i_reco_match];
770  // fill stuff
771  FillParticle(particle);
772  FillAngles(particle, angle);
773  FillKinks(particle, kinks);
774  MatchKinks();
775  }
776 
777  // skip this if we needed a reco match
778  if (i_reco_match < 0 && fRequireReco) continue;
779 
780  // Save the entry in the TTree
781  _tree->Fill();
782  }
783 }
std::vector< std::string > fKinkTags
void FillParticle(const recob::PFParticle &particle)
void FillTruth(const simb::MCParticle &trueParticle, const std::vector< art::Ptr< simb::MCParticle >> &allParticles)
process_name gaushit a
void FillKinks(const recob::PFParticle &particle, const std::vector< art::Ptr< sbn::PCAngleKink >> &kinks)
std::vector< std::pair< int, float > > AllTrueParticleIDEnergyMatches(const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits, bool rollup_unsaved_ids=1)
std::vector< std::string > fPFParticleTags
void FillMeta(const art::Event &evt)
Hierarchical representation of particle flow.
Definition: PFParticle.h:44
finds tracks best matching by angle
TCEvent evt
Definition: DataStructs.cxx:8
void FillAngles(const recob::PFParticle &particle, const std::vector< art::Ptr< sbn::PCAnglePlane >> &angles)
std::vector< std::string > fAngleTags
void sbn::PCAngleKinkTree::Clear ( )
private

Definition at line 317 of file PCAngleKinkTree_module.cc.

317  {
318  fPCAngleU.clear();
319  fPCAngleV.clear();
320  fPCAngleY.clear();
321 
322  fPCAngleUID.clear();
323  fPCAngleVID.clear();
324  fPCAngleYID.clear();
325 
326  fPCAngleUGen.clear();
327  fPCAngleVGen.clear();
328  fPCAngleYGen.clear();
329 
330  fKinkTimeMaxU.clear();
331  fKinkWireMaxU.clear();
332  fKinkTimeLoU.clear();
333  fKinkWireLoU.clear();
334  fKinkTimeHiU.clear();
335  fKinkWireHiU.clear();
336  fKinkEstAngleU.clear();
337  fKinkMaxAngleU.clear();
338  fKinkLoHiAngleU.clear();
339  fKinkFitAngleU.clear();
340  fKinkFitPitchU.clear();
341  fKinkFitChi2U.clear();
342 
343  fKinkTimeMaxV.clear();
344  fKinkWireMaxV.clear();
345  fKinkTimeLoV.clear();
346  fKinkWireLoV.clear();
347  fKinkTimeHiV.clear();
348  fKinkWireHiV.clear();
349  fKinkEstAngleV.clear();
350  fKinkMaxAngleV.clear();
351  fKinkLoHiAngleV.clear();
352  fKinkFitAngleV.clear();
353  fKinkFitPitchV.clear();
354  fKinkFitChi2V.clear();
355 
356  fKinkTimeMaxY.clear();
357  fKinkWireMaxY.clear();
358  fKinkTimeLoY.clear();
359  fKinkWireLoY.clear();
360  fKinkTimeHiY.clear();
361  fKinkWireHiY.clear();
362  fKinkEstAngleY.clear();
363  fKinkMaxAngleY.clear();
364  fKinkLoHiAngleY.clear();
365  fKinkFitAngleY.clear();
366  fKinkFitPitchY.clear();
367  fKinkFitChi2Y.clear();
368 
369  fTrajX.clear();
370  fTrajY.clear();
371  fTrajZ.clear();
372 
373  fTrajPU.clear();
374  fTrajPV.clear();
375  fTrajPY.clear();
376  fTrajPT.clear();
377 
378  fScatterM1X.clear();
379  fScatterM1Y.clear();
380  fScatterM1Z.clear();
381  fScatterM1P.clear();
382  fScatterM0X.clear();
383  fScatterM0Y.clear();
384  fScatterM0Z.clear();
385  fScatterM0P.clear();
386 
387  fScatterX.clear();
388  fScatterY.clear();
389  fScatterZ.clear();
390 
391  fScatterMag.clear();
392  fScatterMagU.clear();
393  fScatterMagV.clear();
394  fScatterMagY.clear();
395 
396  fScatterIsElastic.clear();
397 
398  fScatterMatchU.clear();
399  fScatterMatchDistU.clear();
400  fScatterMatchV.clear();
401  fScatterMatchDistV.clear();
402  fScatterMatchY.clear();
403  fScatterMatchDistY.clear();
404 
405  fScatterPU.clear();
406  fScatterPV.clear();
407  fScatterPY.clear();
408  fScatterPT.clear();
409 
410  fTruePDG = 0;
411  fTrueE = 0;
412  fTrueP = 0;
413  fTrueEndE = 0;
414  fTrueEndP = 0;
415 
416  fEvt = 0;
417 
418  fPFPID = -1;
419  fTrueEndScatter = false;
420 }
std::vector< int > fPCAngleVGen
std::vector< float > fKinkWireHiU
std::vector< float > fScatterMatchDistV
std::vector< float > fKinkTimeHiU
std::vector< sbn::PCAngle > fPCAngleV
std::vector< float > fScatterMag
std::vector< float > fScatterPU
std::vector< float > fScatterMagU
std::vector< int > fScatterMatchU
std::vector< float > fKinkFitChi2Y
std::vector< float > fScatterMagV
std::vector< float > fScatterM1Y
std::vector< int > fScatterMatchY
std::vector< float > fKinkWireHiV
std::vector< float > fKinkWireHiY
std::vector< int > fScatterMatchV
std::vector< float > fTrajPT
std::vector< float > fScatterY
std::vector< float > fKinkWireLoU
std::vector< float > fKinkFitAngleY
std::vector< float > fScatterM0Z
std::vector< float > fKinkTimeLoU
std::vector< float > fKinkTimeMaxV
std::vector< float > fKinkEstAngleU
std::vector< float > fKinkLoHiAngleU
std::vector< float > fKinkTimeLoV
std::vector< float > fKinkMaxAngleY
std::vector< sbn::PCAngle > fPCAngleU
std::vector< int > fPCAngleVID
std::vector< int > fPCAngleYID
std::vector< float > fScatterMatchDistY
std::vector< float > fTrajPU
std::vector< float > fKinkFitPitchV
std::vector< float > fScatterMatchDistU
std::vector< float > fKinkFitPitchU
std::vector< float > fTrajZ
std::vector< float > fKinkTimeHiY
std::vector< float > fKinkFitAngleV
std::vector< float > fKinkLoHiAngleV
std::vector< float > fTrajY
std::vector< float > fKinkFitChi2U
std::vector< float > fKinkTimeLoY
std::vector< float > fKinkFitChi2V
std::vector< float > fScatterM0Y
std::vector< float > fScatterM0X
std::vector< float > fScatterMagY
std::vector< float > fKinkFitPitchY
std::vector< float > fKinkWireMaxU
std::vector< float > fKinkWireMaxV
std::vector< sbn::PCAngle > fPCAngleY
std::vector< float > fScatterPT
std::vector< float > fKinkEstAngleY
std::vector< float > fKinkWireLoV
std::vector< float > fScatterM1Z
std::vector< int > fPCAngleUID
std::vector< float > fKinkLoHiAngleY
std::vector< float > fScatterM0P
std::vector< float > fKinkTimeMaxY
std::vector< float > fScatterPV
std::vector< float > fTrajPY
std::vector< bool > fScatterIsElastic
std::vector< float > fKinkTimeMaxU
std::vector< float > fKinkFitAngleU
std::vector< float > fKinkWireLoY
std::vector< float > fScatterZ
std::vector< float > fScatterPY
std::vector< float > fTrajPV
std::vector< float > fScatterM1X
std::vector< float > fKinkEstAngleV
std::vector< float > fKinkMaxAngleV
std::vector< float > fKinkTimeHiV
std::vector< float > fScatterM1P
std::vector< int > fPCAngleUGen
std::vector< float > fKinkWireMaxY
std::vector< float > fTrajX
std::vector< float > fScatterX
std::vector< float > fKinkMaxAngleU
std::vector< int > fPCAngleYGen
void sbn::PCAngleKinkTree::FillAngles ( const recob::PFParticle particle,
const std::vector< art::Ptr< sbn::PCAnglePlane >> &  angles 
)
private

Definition at line 602 of file PCAngleKinkTree_module.cc.

602  {
603  for (unsigned i_angle = 0; i_angle < angles.size(); i_angle++) {
604  const sbn::PCAnglePlane &angle = *angles[i_angle];
605  if (angle.plane.Plane == 0) {
606  for (unsigned i = 0; i < angle.angles.size(); i++) {
607  for (const sbn::PCAngle &a: angle.angles[i]) {
608  fPCAngleU.push_back(a);
609  fPCAngleUID.push_back(angle.branchIDs[i]);
610  fPCAngleUGen.push_back(angle.generations[i]);
611  }
612  }
613  }
614  else if (angle.plane.Plane == 1) {
615  for (unsigned i = 0; i < angle.angles.size(); i++) {
616  for (const sbn::PCAngle &a: angle.angles[i]) {
617  fPCAngleV.push_back(a);
618  fPCAngleVID.push_back(angle.branchIDs[i]);
619  fPCAngleVGen.push_back(angle.generations[i]);
620  }
621  }
622  }
623  else if (angle.plane.Plane == 2) {
624  for (unsigned i = 0; i < angle.angles.size(); i++) {
625  for (const sbn::PCAngle &a: angle.angles[i]) {
626  fPCAngleY.push_back(a);
627  fPCAngleYID.push_back(angle.branchIDs[i]);
628  fPCAngleYGen.push_back(angle.generations[i]);
629  }
630  }
631  }
632  }
633 }
std::vector< int > fPCAngleVGen
std::vector< sbn::PCAngle > fPCAngleV
process_name gaushit a
std::vector< sbn::PCAngle > fPCAngleU
std::vector< int > fPCAngleVID
std::vector< int > fPCAngleYID
std::vector< sbn::PCAngle > fPCAngleY
std::vector< int > fPCAngleUID
finds tracks best matching by angle
std::vector< int > fPCAngleUGen
std::vector< int > fPCAngleYGen
void sbn::PCAngleKinkTree::FillKinks ( const recob::PFParticle particle,
const std::vector< art::Ptr< sbn::PCAngleKink >> &  kinks 
)
private

Definition at line 549 of file PCAngleKinkTree_module.cc.

549  {
550  for (unsigned i_kink = 0; i_kink < kinks.size(); i_kink++) {
551  const sbn::PCAngleKink &kink = *kinks[i_kink];
552  unsigned plane_no = kink.maxWire.Plane;
553  if (plane_no == 0) {
554  fKinkTimeMaxU.push_back(kink.position_max[0]);
555  fKinkWireMaxU.push_back(kink.position_max[1]);
556  fKinkTimeLoU.push_back(kink.position_lo[0]);
557  fKinkWireLoU.push_back(kink.position_lo[1]);
558  fKinkTimeHiU.push_back(kink.position_hi[0]);
559  fKinkWireHiU.push_back(kink.position_hi[1]);
560  fKinkEstAngleU.push_back(kink.est_angle);
561  fKinkMaxAngleU.push_back(kink.max_angle);
562  fKinkLoHiAngleU.push_back(M_PI - sbnpca::VecAngle(kink.vec_lo_at_halfmax_lo, kink.vec_hi_at_halfmax_hi));
563  fKinkFitAngleU.push_back(kink.fit_angle);
564  fKinkFitPitchU.push_back(kink.fit_pitch);
565  fKinkFitChi2U.push_back(kink.fit_chi2);
566  }
567  else if (plane_no == 1) {
568  fKinkTimeMaxV.push_back(kink.position_max[0]);
569  fKinkWireMaxV.push_back(kink.position_max[1]);
570  fKinkTimeLoV.push_back(kink.position_lo[0]);
571  fKinkWireLoV.push_back(kink.position_lo[1]);
572  fKinkTimeHiV.push_back(kink.position_hi[0]);
573  fKinkWireHiV.push_back(kink.position_hi[1]);
574  fKinkEstAngleV.push_back(kink.est_angle);
575  fKinkMaxAngleV.push_back(kink.max_angle);
576  fKinkLoHiAngleV.push_back(M_PI - sbnpca::VecAngle(kink.vec_lo_at_halfmax_lo, kink.vec_hi_at_halfmax_hi));
577  fKinkFitAngleV.push_back(kink.fit_angle);
578  fKinkFitPitchV.push_back(kink.fit_pitch);
579  fKinkFitChi2V.push_back(kink.fit_chi2);
580  }
581  else if (plane_no == 2) {
582  fKinkTimeMaxY.push_back(kink.position_max[0]);
583  fKinkWireMaxY.push_back(kink.position_max[1]);
584  fKinkTimeLoY.push_back(kink.position_lo[0]);
585  fKinkWireLoY.push_back(kink.position_lo[1]);
586  fKinkTimeHiY.push_back(kink.position_hi[0]);
587  fKinkWireHiY.push_back(kink.position_hi[1]);
588  fKinkEstAngleY.push_back(kink.est_angle);
589  fKinkMaxAngleY.push_back(kink.max_angle);
590  fKinkLoHiAngleY.push_back(M_PI - sbnpca::VecAngle(kink.vec_lo_at_halfmax_lo, kink.vec_hi_at_halfmax_hi));
591  fKinkFitAngleY.push_back(kink.fit_angle);
592  fKinkFitPitchY.push_back(kink.fit_pitch);
593  fKinkFitChi2Y.push_back(kink.fit_chi2);
594  }
595  }
596 }
std::vector< float > fKinkWireHiU
std::vector< float > fKinkTimeHiU
std::vector< float > fKinkFitChi2Y
std::vector< float > fKinkWireHiV
std::vector< float > fKinkWireHiY
std::vector< float > fKinkWireLoU
std::vector< float > fKinkFitAngleY
std::vector< float > fKinkTimeLoU
std::vector< float > fKinkTimeMaxV
std::vector< float > fKinkEstAngleU
std::vector< float > fKinkLoHiAngleU
std::vector< float > fKinkTimeLoV
std::vector< float > fKinkMaxAngleY
std::vector< float > fKinkFitPitchV
std::vector< float > fKinkFitPitchU
std::vector< float > fKinkTimeHiY
float VecAngle(std::array< float, 2 > A, std::array< float, 2 > B)
Definition: PCA.cc:5
std::vector< float > fKinkFitAngleV
std::vector< float > fKinkLoHiAngleV
std::vector< float > fKinkFitChi2U
std::vector< float > fKinkTimeLoY
std::vector< float > fKinkFitChi2V
std::vector< float > fKinkFitPitchY
std::vector< float > fKinkWireMaxU
std::vector< float > fKinkWireMaxV
std::vector< float > fKinkEstAngleY
std::vector< float > fKinkWireLoV
std::vector< float > fKinkLoHiAngleY
std::vector< float > fKinkTimeMaxY
std::vector< float > fKinkTimeMaxU
std::vector< float > fKinkFitAngleU
std::vector< float > fKinkWireLoY
std::vector< float > fKinkEstAngleV
std::vector< float > fKinkMaxAngleV
std::vector< float > fKinkTimeHiV
std::vector< float > fKinkWireMaxY
std::vector< float > fKinkMaxAngleU
void sbn::PCAngleKinkTree::FillMeta ( const art::Event &  evt)
private

Definition at line 422 of file PCAngleKinkTree_module.cc.

422  {
423  fEvt = evt.event();
424  fIEvt += 1;
425 }
unsigned int event
Definition: DataStructs.h:634
TCEvent evt
Definition: DataStructs.cxx:8
void sbn::PCAngleKinkTree::FillParticle ( const recob::PFParticle particle)
private

Definition at line 598 of file PCAngleKinkTree_module.cc.

598  {
599  fPFPID = particle.Self();
600 }
size_t Self() const
Returns the index of this particle.
Definition: PFParticle.h:92
void sbn::PCAngleKinkTree::FillTrueScatter ( TLorentzVector  pos,
TLorentzVector  mom0,
TLorentzVector  mom1,
bool  elastic 
)
private

Definition at line 427 of file PCAngleKinkTree_module.cc.

427  {
428  const geo::GeometryCore *geo = lar::providerFrom<geo::Geometry>();
429 
430  // make sure contained in a TPC
431  double posarr[3];
432  pos.Vect().GetXYZ(posarr);
433  geo::TPCID tpc = geo->FindTPCAtPosition(posarr);
434  if (tpc.TPC == geo::TPCID::InvalidID) return;
435 
436  // angle in degree
437  float angle = mom1.Vect().Angle(mom0.Vect());
438  if (!elastic) {
439  std::cout << "Parent momentum: " << mom0.Px() << " " << mom0.Py() << " " << mom0.Pz() << std::endl;
440  std::cout << "Child momentum: " << mom1.Px() << " " << mom1.Py() << " " << mom1.Pz() << std::endl;
441  std::cout << "angle: " << angle << std::endl;
442  }
443 
444  if (angle*(180. / M_PI) < fAngleCut) return;
445 
446  fScatterM1X.push_back(mom1.Px());
447  fScatterM1Y.push_back(mom1.Py());
448  fScatterM1Z.push_back(mom1.Pz());
449  fScatterM1P.push_back(mom1.P());
450 
451  fScatterM0X.push_back(mom0.Px());
452  fScatterM0Y.push_back(mom0.Py());
453  fScatterM0Z.push_back(mom0.Pz());
454  fScatterM0P.push_back(mom0.P());
455 
456  fScatterX.push_back(pos.X());
457  fScatterY.push_back(pos.Y());
458  fScatterZ.push_back(pos.Z());
459 
460  fScatterPU.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 0, 0, 0) * geo->WirePitch());
461  fScatterPV.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 1, 0, 0) * geo->WirePitch());
462  fScatterPY.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 2, 0, 0) * geo->WirePitch());
463  fScatterPT.push_back(pos.X());
464 
465  fScatterMag.push_back(angle);
466 
467  // project the angle onto each wire-plane
468  double scatter_wireplane[3];
469  for (unsigned i_plane = 0; i_plane < 3; i_plane++) {
470  geo::PlaneID plane(tpc, i_plane);
471  double wire_angle_tovert = geo->WireAngleToVertical(geo->View(plane), plane);
472  TVector3 v0(mom0.Px(),
473  sin(wire_angle_tovert) * mom0.Pz() + cos(wire_angle_tovert) * mom0.Py(), 0.);
474  TVector3 v1(mom1.Px(),
475  sin(wire_angle_tovert) * mom1.Pz() + cos(wire_angle_tovert) * mom1.Py(), 0.);
476  if (v0.Mag() < 1e-6 || v1.Mag() < 1e-6) scatter_wireplane[i_plane] = 0.;
477  else scatter_wireplane[i_plane] = v1.Unit().Angle(v0.Unit());
478  }
479  fScatterMagU.push_back(scatter_wireplane[0]);
480  fScatterMagV.push_back(scatter_wireplane[1]);
481  fScatterMagY.push_back(scatter_wireplane[2]);
482 
483  fScatterIsElastic.push_back(elastic);
484 }
geo::Length_t WireCoordinate(double YPos, double ZPos, geo::PlaneID const &planeid) const
Returns the index of the nearest wire to the specified position.
std::vector< float > fScatterMag
std::vector< float > fScatterPU
std::vector< float > fScatterMagU
static constexpr TPCID_t InvalidID
Special code for an invalid ID.
Definition: geo_types.h:403
std::vector< float > fScatterMagV
std::vector< float > fScatterM1Y
The data type to uniquely identify a Plane.
Definition: geo_types.h:472
std::vector< float > fScatterY
std::vector< float > fScatterM0Z
geo::Length_t WirePitch(geo::PlaneID const &planeid) const
Returns the distance between two consecutive wires.
geo::TPCID FindTPCAtPosition(double const worldLoc[3]) const
Returns the ID of the TPC at specified location.
The data type to uniquely identify a TPC.
Definition: geo_types.h:386
Description of geometry of one entire detector.
View_t View(geo::PlaneID const &pid) const
Returns the view (wire orientation) on the channels of specified TPC plane.
std::vector< float > fScatterM0Y
std::vector< float > fScatterM0X
std::vector< float > fScatterMagY
std::vector< float > fScatterPT
std::vector< float > fScatterM1Z
std::vector< float > fScatterM0P
std::vector< float > fScatterPV
do i e
std::vector< bool > fScatterIsElastic
finds tracks best matching by angle
std::vector< float > fScatterZ
std::vector< float > fScatterPY
TPCID_t TPC
Index of the TPC within its cryostat.
Definition: geo_types.h:406
std::vector< float > fScatterM1X
double WireAngleToVertical(geo::View_t view, geo::TPCID const &tpcid) const
Returns the angle of the wires in the specified view from vertical.
BEGIN_PROLOG could also be cout
std::vector< float > fScatterM1P
std::vector< float > fScatterX
void sbn::PCAngleKinkTree::FillTruth ( const simb::MCParticle &  trueParticle,
const std::vector< art::Ptr< simb::MCParticle >> &  allParticles 
)
private

Definition at line 486 of file PCAngleKinkTree_module.cc.

486  {
487  const geo::GeometryCore *geo = lar::providerFrom<geo::Geometry>();
488 
489  // save simple stuff
490  fTruePDG = trueParticle.PdgCode();
491  fTrueE = trueParticle.Momentum().E();
492  fTrueP = trueParticle.Momentum().P();
493 
494  fTrueEndP = trueParticle.EndMomentum().P();
495  fTrueEndE = trueParticle.EndMomentum().E();
496 
497  bool scatters = !(trueParticle.EndProcess() == "Decay" ||
498  trueParticle.EndProcess() == "CoupledTransportation" ||
499  trueParticle.EndProcess() == "FastScintillation" ||
500  trueParticle.EndProcess() == "muMinusCaptureAtRest" ||
501  trueParticle.EndProcess() == "LArVoxelReadoutScoringProcess");
502  fTrueEndScatter = scatters;
503 
504  // save the particle trajectory
505  for (unsigned i_traj = 0; i_traj < trueParticle.NumberTrajectoryPoints(); i_traj ++) {
506  TLorentzVector pos = trueParticle.Position(i_traj);
507  TLorentzVector mom = trueParticle.Momentum(i_traj);
508 
509  fTrajX.push_back(pos.X());
510  fTrajY.push_back(pos.Y());
511  fTrajZ.push_back(pos.Z());
512 
513  fTrajPU.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 0, 0, 0) * geo->WirePitch());
514  fTrajPV.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 1, 0, 0) * geo->WirePitch());
515  fTrajPY.push_back(geo->WireCoordinate(pos.Y(), pos.Z(), 2, 0, 0) * geo->WirePitch());
516  fTrajPT.push_back(pos.X());
517 
518  // also find any elastic scatters
519  if (i_traj > 1) {
520  FillTrueScatter(trueParticle.Position(i_traj), trueParticle.Momentum(i_traj-1), trueParticle.Momentum(i_traj), true);
521  }
522  }
523 
524  // also save inelastic scatters at the end of the track
525  if (scatters && trueParticle.NumberTrajectoryPoints() > 1) {
526  for (int i_daughter = 0; i_daughter < trueParticle.NumberDaughters(); i_daughter++) {
527  int daughterID = trueParticle.Daughter(i_daughter);
528  int daughter_ind = -1;
529  for (unsigned i = 0; i < allParticles.size(); i++) {
530  if (allParticles[i]->TrackId() == daughterID) {
531  daughter_ind = i;
532  break;
533  }
534  }
535 
536  if (daughter_ind >= 0) {
537  const simb::MCParticle &daughter = *allParticles[daughter_ind];
538  int pdg = abs(daughter.PdgCode());
539  if (pdg == 211 || pdg == 2112) { // daughter tracks
540  FillTrueScatter(trueParticle.EndPosition(), trueParticle.Momentum(trueParticle.NumberTrajectoryPoints() - 2), daughter.Momentum(), false);
541  }
542  }
543 
544  }
545  }
546 
547 }
geo::Length_t WireCoordinate(double YPos, double ZPos, geo::PlaneID const &planeid) const
Returns the index of the nearest wire to the specified position.
var pdg
Definition: selectors.fcl:14
std::vector< float > fTrajPT
geo::Length_t WirePitch(geo::PlaneID const &planeid) const
Returns the distance between two consecutive wires.
T abs(T value)
std::vector< float > fTrajPU
std::vector< float > fTrajZ
void FillTrueScatter(TLorentzVector pos, TLorentzVector mom0, TLorentzVector mom1, bool elastic)
Description of geometry of one entire detector.
std::vector< float > fTrajY
std::vector< float > fTrajPY
std::vector< float > fTrajPV
std::vector< float > fTrajX
void sbn::PCAngleKinkTree::MatchKinks ( )
private

Definition at line 660 of file PCAngleKinkTree_module.cc.

660  {
664 }
std::vector< float > fScatterMatchDistV
std::vector< float > fScatterPU
std::vector< int > fScatterMatchU
void MatchPlaneKinks(unsigned Plane, std::vector< int > &scatter_match_plane, std::vector< float > &scatter_dist_plane, const std::vector< float > &scatterW, const std::vector< float > &reco_kinkT, const std::vector< float > &reco_kinkW)
std::vector< int > fScatterMatchY
std::vector< int > fScatterMatchV
std::vector< float > fKinkTimeMaxV
std::vector< float > fScatterMatchDistY
std::vector< float > fScatterMatchDistU
std::vector< float > fKinkWireMaxU
std::vector< float > fKinkWireMaxV
std::vector< float > fKinkTimeMaxY
std::vector< float > fScatterPV
std::vector< float > fKinkTimeMaxU
std::vector< float > fScatterPY
std::vector< float > fKinkWireMaxY
void sbn::PCAngleKinkTree::MatchPlaneKinks ( unsigned  Plane,
std::vector< int > &  scatter_match_plane,
std::vector< float > &  scatter_dist_plane,
const std::vector< float > &  scatterW,
const std::vector< float > &  reco_kinkT,
const std::vector< float > &  reco_kinkW 
)
private

Definition at line 636 of file PCAngleKinkTree_module.cc.

641  {
642 
643  for (unsigned i = 0; i < scatterW.size(); i++) {
644  TVector3 true_scatter(fScatterPT[i], scatterW[i], 0.);
645  float min_dist = 100000000.;
646  int min_ind = -1;
647  for (unsigned j = 0; j < reco_kinkT.size(); j++) {
648  TVector3 reco_kink(reco_kinkT[j], reco_kinkW[j], 0.);
649  if ((true_scatter - reco_kink).Mag() < min_dist) {
650  min_dist = (true_scatter - reco_kink).Mag();
651  min_ind = j;
652  }
653  }
654  scatter_match_plane.push_back(min_ind);
655  scatter_dist_plane.push_back(min_dist);
656  }
657 }
std::vector< float > fScatterPT
PCAngleKinkTree& sbn::PCAngleKinkTree::operator= ( PCAngleKinkTree const &  )
delete
PCAngleKinkTree& sbn::PCAngleKinkTree::operator= ( PCAngleKinkTree &&  )
delete
void sbn::PCAngleKinkTree::respondToOpenInputFile ( const art::FileBlock &  fb)
inline

Definition at line 58 of file PCAngleKinkTree_module.cc.

58  {
59  (void) fb;
60  fIFile += 1;
61  }
j template void())
Definition: json.hpp:3108

Member Data Documentation

TTree* sbn::PCAngleKinkTree::_tree
private

Definition at line 89 of file PCAngleKinkTree_module.cc.

float sbn::PCAngleKinkTree::fAngleCut
private

Definition at line 85 of file PCAngleKinkTree_module.cc.

std::vector<std::string> sbn::PCAngleKinkTree::fAngleTags
private

Definition at line 83 of file PCAngleKinkTree_module.cc.

int sbn::PCAngleKinkTree::fEvt
private

Definition at line 195 of file PCAngleKinkTree_module.cc.

int sbn::PCAngleKinkTree::fIEvt
private

Definition at line 193 of file PCAngleKinkTree_module.cc.

int sbn::PCAngleKinkTree::fIFile
private

Definition at line 194 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkEstAngleU
private

Definition at line 153 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkEstAngleV
private

Definition at line 166 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkEstAngleY
private

Definition at line 179 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitAngleU
private

Definition at line 156 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitAngleV
private

Definition at line 169 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitAngleY
private

Definition at line 182 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitChi2U
private

Definition at line 158 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitChi2V
private

Definition at line 171 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitChi2Y
private

Definition at line 184 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitPitchU
private

Definition at line 157 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitPitchV
private

Definition at line 170 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkFitPitchY
private

Definition at line 183 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkLoHiAngleU
private

Definition at line 155 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkLoHiAngleV
private

Definition at line 168 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkLoHiAngleY
private

Definition at line 181 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkMaxAngleU
private

Definition at line 154 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkMaxAngleV
private

Definition at line 167 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkMaxAngleY
private

Definition at line 180 of file PCAngleKinkTree_module.cc.

std::vector<std::string> sbn::PCAngleKinkTree::fKinkTags
private

Definition at line 84 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeHiU
private

Definition at line 151 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeHiV
private

Definition at line 164 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeHiY
private

Definition at line 177 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeLoU
private

Definition at line 149 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeLoV
private

Definition at line 162 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeLoY
private

Definition at line 175 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeMaxU
private

Definition at line 147 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeMaxV
private

Definition at line 160 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkTimeMaxY
private

Definition at line 173 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireHiU
private

Definition at line 152 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireHiV
private

Definition at line 165 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireHiY
private

Definition at line 178 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireLoU
private

Definition at line 150 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireLoV
private

Definition at line 163 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireLoY
private

Definition at line 176 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireMaxU
private

Definition at line 148 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireMaxV
private

Definition at line 161 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fKinkWireMaxY
private

Definition at line 174 of file PCAngleKinkTree_module.cc.

std::vector<sbn::PCAngle> sbn::PCAngleKinkTree::fPCAngleU
private

Definition at line 92 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleUGen
private

Definition at line 96 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleUID
private

Definition at line 100 of file PCAngleKinkTree_module.cc.

std::vector<sbn::PCAngle> sbn::PCAngleKinkTree::fPCAngleV
private

Definition at line 93 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleVGen
private

Definition at line 97 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleVID
private

Definition at line 101 of file PCAngleKinkTree_module.cc.

std::vector<sbn::PCAngle> sbn::PCAngleKinkTree::fPCAngleY
private

Definition at line 94 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleYGen
private

Definition at line 98 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fPCAngleYID
private

Definition at line 102 of file PCAngleKinkTree_module.cc.

std::vector<std::string> sbn::PCAngleKinkTree::fPFParticleTags
private

Definition at line 82 of file PCAngleKinkTree_module.cc.

int sbn::PCAngleKinkTree::fPFPID
private

Definition at line 196 of file PCAngleKinkTree_module.cc.

bool sbn::PCAngleKinkTree::fRequireReco
private

Definition at line 86 of file PCAngleKinkTree_module.cc.

std::vector<bool> sbn::PCAngleKinkTree::fScatterIsElastic
private

Definition at line 136 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM0P
private

Definition at line 124 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM0X
private

Definition at line 121 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM0Y
private

Definition at line 122 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM0Z
private

Definition at line 123 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM1P
private

Definition at line 120 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM1X
private

Definition at line 117 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM1Y
private

Definition at line 118 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterM1Z
private

Definition at line 119 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMag
private

Definition at line 131 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMagU
private

Definition at line 132 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMagV
private

Definition at line 133 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMagY
private

Definition at line 134 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMatchDistU
private

Definition at line 140 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMatchDistV
private

Definition at line 142 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterMatchDistY
private

Definition at line 144 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fScatterMatchU
private

Definition at line 139 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fScatterMatchV
private

Definition at line 141 of file PCAngleKinkTree_module.cc.

std::vector<int> sbn::PCAngleKinkTree::fScatterMatchY
private

Definition at line 143 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterPT
private

Definition at line 129 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterPU
private

Definition at line 126 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterPV
private

Definition at line 127 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterPY
private

Definition at line 128 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterX
private

Definition at line 113 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterY
private

Definition at line 114 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fScatterZ
private

Definition at line 115 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajPT
private

Definition at line 111 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajPU
private

Definition at line 108 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajPV
private

Definition at line 109 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajPY
private

Definition at line 110 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajX
private

Definition at line 104 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajY
private

Definition at line 105 of file PCAngleKinkTree_module.cc.

std::vector<float> sbn::PCAngleKinkTree::fTrajZ
private

Definition at line 106 of file PCAngleKinkTree_module.cc.

float sbn::PCAngleKinkTree::fTrueE
private

Definition at line 187 of file PCAngleKinkTree_module.cc.

float sbn::PCAngleKinkTree::fTrueEndE
private

Definition at line 189 of file PCAngleKinkTree_module.cc.

float sbn::PCAngleKinkTree::fTrueEndP
private

Definition at line 190 of file PCAngleKinkTree_module.cc.

bool sbn::PCAngleKinkTree::fTrueEndScatter
private

Definition at line 191 of file PCAngleKinkTree_module.cc.

float sbn::PCAngleKinkTree::fTrueP
private

Definition at line 188 of file PCAngleKinkTree_module.cc.

int sbn::PCAngleKinkTree::fTruePDG
private

Definition at line 186 of file PCAngleKinkTree_module.cc.


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