pizero Namespace Reference

Classes
class	Cone
class	PiZeroProcess
class	ShowerProcess

Functions
double	ClosestDistanceToPoint (const TVector3 &p, const TVector3 &lineStart, const TVector3 &lineDir)
TVector3	ClosestPoint (const TVector3 &a, const TVector3 &adir, const TVector3 &b, const TVector3 &bdir)
TVector3	ClosestPoint (const recob::Shower *showerA, const recob::Shower *showerB)
double	ClosestDistance (const TVector3 &a, const TVector3 &adir, const TVector3 &b, const TVector3 &bdir)
double	ClosestDistance (const recob::Shower *showerA, const recob::Shower *showerB)
std::vector< PiZeroProcess >	findPiZeros (const art::Event &evt, std::string showerLabel="pandoraShower", std::string trackLabel="pandoraTrack")

Function Documentation

double pizero::ClosestDistance ( const TVector3 &  a, const TVector3 &  adir, const TVector3 &  b, const TVector3 &  bdir  )

inline

Definition at line 67 of file PiZeroProcess.h.

                                                                  {
  // Find unit vector perpendicular to both a and b.
  const TVector3 unit = adir.Cross(bdir) * (1.0 / adir.Cross(bdir).Mag());
  // Project difference vector on perpendicular vector.
  return abs((a - b).Dot(unit));
}

double pizero::ClosestDistance ( const recob::Shower *  showerA, const recob::Shower *  showerB  )

inline

Definition at line 74 of file PiZeroProcess.h.

                                                     {
  // Check whether the intersection is behind both showers.
  const TVector3 candidate =
    ClosestPoint(showerA->ShowerStart(), showerA->Direction(),
                 showerB->ShowerStart(), showerB->Direction());
  const TVector3 startPlusDirA = showerA->ShowerStart() + showerA->Direction();
  const TVector3 startPlusDirB = showerB->ShowerStart() + showerB->Direction();
  const TVector3 startMinusDirA = showerA->ShowerStart() - showerA->Direction();
  const TVector3 startMinusDirB = showerB->ShowerStart() - showerB->Direction();
  if((startPlusDirA-candidate).Mag() < (startMinusDirA-candidate).Mag() ||
     (startPlusDirB-candidate).Mag() < (startMinusDirB-candidate).Mag()) {
    return -1;
  }

  return ClosestDistance(showerA->ShowerStart(), showerA->Direction(),
                                 showerB->ShowerStart(), showerB->Direction());
}

double pizero::ClosestDistanceToPoint ( const TVector3 &  p, const TVector3 &  lineStart, const TVector3 &  lineDir  )

inline

Definition at line 30 of file PiZeroProcess.h.

                                                                      {
  // Difference vector between line start and point.
  const TVector3 diff = p - lineStart;
  // Get line projection onto difference vector.
  const TVector3 proj = lineDir * diff.Dot(lineDir) * (1.0 / lineDir.Mag2());
  // The difference between the difference and projection vectors is
  // called the rejection vector and returns the closest distance.
  return (diff - proj).Mag();
}

TVector3 pizero::ClosestPoint ( const TVector3 &  a, const TVector3 &  adir, const TVector3 &  b, const TVector3 &  bdir  )

inline

Definition at line 42 of file PiZeroProcess.h.

                                                               {
  TVector3 result(-99999., -99999., -99999.);
  // Deal with both vectors being parallel.
  if (adir != bdir) {
    const TVector3 n1 = adir.Cross(bdir.Cross(adir));
    const TVector3 n2 = bdir.Cross(adir.Cross(bdir));
    const TVector3 c1 = a + adir * ((b - a).Dot(n2) / adir.Dot(n2));
    const TVector3 c2 = b + bdir * ((a - b).Dot(n1) / bdir.Dot(n1));

    result = c1 + 0.5 * (c2 - c1);
  }

  return result;
}

TVector3 pizero::ClosestPoint ( const recob::Shower *  showerA, const recob::Shower *  showerB  )

inline

Definition at line 57 of file PiZeroProcess.h.

                                                  {
  const TVector3 candidate =
    ClosestPoint(showerA->ShowerStart(), showerA->Direction(),
                 showerB->ShowerStart(), showerB->Direction());

  return candidate;
}

std::vector<PiZeroProcess> pizero::findPiZeros	(	const art::Event &	evt,
		std::string	showerLabel = "pandoraShower",
		std::string	trackLabel = "pandoraTrack"
	)

Definition at line 303 of file PiZeroProcess.h.

                                                                                  {
  std::vector<PiZeroProcess> result;

  // Get the event's showers.
  auto showerHandle = evt.getHandle<std::vector<recob::Shower>>(showerLabel);
  if (!showerHandle || showerHandle->size() < 2) return result;

  // Find showers close to each other.
  double showerDistThreshold = 50; // 50 cm is too far.
  std::vector<std::pair<const recob::Shower*, const recob::Shower*>> showerPairs;
  for(unsigned si = 0; si < showerHandle->size()-1; ++si) {
    for(unsigned ssi = si+1; ssi < showerHandle->size(); ++ssi) {
      const recob::Shower* shower1 = &showerHandle->at(si);
      const recob::Shower* shower2 = &showerHandle->at(ssi);
      if((shower1->ShowerStart() - shower2->ShowerStart()).Mag() < showerDistThreshold) {
        showerPairs.push_back(std::make_pair(shower1, shower2));
      }
    }
  }
  std::cout << showerPairs.size() << " shower pairs.\n";

  // Of shower pairs in vicinity of each other, find those that point to a single vertex.

  // TODO: Finish this function. Place outside of class to make vector of all pizero candidates?

  return result;
}