TrackShowerSeparationAlg.h

Go to the documentation of this file.

// Class: TrackShowerSeparationAlg
// File:  TrackShowerSeparationAlg.h
// Author: Mike Wallbank (m.wallbank@sheffield.ac.uk), November 2015
//
// Track/shower separation class.
// Provides methods for removing hits associated with track-like
// objects.
// To be run after track reconstruction, before shower reconstruction.

#ifndef TrackShowerSeparationAlg_hxx
#define TrackShowerSeparationAlg_hxx

// Framework
#include "canvas/Persistency/Common/FindManyP.h"
#include "canvas/Persistency/Common/Ptr.h"
namespace fhicl {
  class ParameterSet;
}

// larsoft
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/Track.h"

// ROOT
#include "TMath.h"
#include "TVector3.h"

namespace shower {
  class TrackShowerSeparationAlg;
  class ReconTrack;
}

#include <algorithm>
#include <iterator>
#include <map>
#include <vector>

class shower::ReconTrack {
public:
  ReconTrack(int id)
  {
    fID = id;
    fTrack = false;
    fShower = false;
    fShowerTrack = false;
    fShowerCone = false;
  }

  // Setters
  void SetVertex(TVector3 vertex) { fVertex = vertex; }
  void SetEnd(TVector3 end) { fEnd = end; }
  void SetLength(double length) { fLength = length; }
  void SetVertexDir(TVector3 vertexDir) { fVertexDir = vertexDir; }
  void SetDirection(TVector3 direction) { fDirection = direction; }
  void SetHits(std::vector<art::Ptr<recob::Hit>> hits) { fHits = hits; }
  void SetSpacePoints(std::vector<art::Ptr<recob::SpacePoint>> spacePoints)
  {
    fSpacePoints = spacePoints;
  }

  void AddForwardTrack(int track)
  {
    if (std::find(fForwardConeTracks.begin(), fForwardConeTracks.end(), track) ==
        fForwardConeTracks.end())
      fForwardConeTracks.push_back(track);
  }
  void AddBackwardTrack(int track)
  {
    if (std::find(fBackwardConeTracks.begin(), fBackwardConeTracks.end(), track) ==
        fBackwardConeTracks.end())
      fBackwardConeTracks.push_back(track);
  }
  void AddShowerTrack(int track) { fShowerTracks.push_back(track); }

  void AddForwardSpacePoint(int spacePoint) { fForwardSpacePoints.push_back(spacePoint); }
  void AddBackwardSpacePoint(int spacePoint) { fBackwardSpacePoints.push_back(spacePoint); }
  void AddCylinderSpacePoint(int spacePoint) { fCylinderSpacePoints.push_back(spacePoint); }
  void AddSphereSpacePoint(int spacePoint) { fSphereSpacePoints.push_back(spacePoint); }
  void AddIsolationSpacePoint(int spacePoint, double distance)
  {
    fIsolationSpacePoints[spacePoint] = distance;
  }

  // Getters
  int ID() const { return fID; }
  TVector3 Vertex() const { return fVertex; }
  TVector3 End() const { return fEnd; }
  double Length() const { return fLength; }
  TVector3 VertexDirection() const { return fVertexDir; }
  TVector3 Direction() const { return fDirection; }
  const std::vector<art::Ptr<recob::Hit>>& Hits() const { return fHits; }
  const std::vector<art::Ptr<recob::SpacePoint>>& SpacePoints() const { return fSpacePoints; }

  void FlipTrack()
  {
    TVector3 tmp = fEnd;
    fEnd = fVertex;
    fVertex = tmp;
    fDirection *= -1;
  }

  void MakeShower()
  {
    if (fTrack)
      this->MakeShowerTrack();
    else
      this->MakeShowerCone();
  }
  void MakeShowerTrack()
  {
    fShower = true;
    fShowerTrack = true;
    fShowerCone = false;
    fTrack = false;
  }
  void MakeShowerCone()
  {
    fShower = true;
    fShowerCone = true;
    fShowerTrack = false;
    fTrack = false;
  }
  void MakeTrack()
  {
    fTrack = true;
    fShower = false;
    fShowerTrack = false;
    fShowerCone = false;
  }

  bool IsShower() const { return fShower; }
  bool IsShowerTrack() const { return fShowerTrack; }
  bool IsShowerCone() const { return fShowerCone; }
  bool IsTrack() const { return fTrack; }
  bool IsUndetermined() const { return !fTrack and !fShower; }

  int TrackConeSize() const
  {
    return (int)fForwardConeTracks.size() - (int)fBackwardConeTracks.size();
  }
  bool ShowerTrackCandidate() const { return TrackConeSize() > 5; }
  const std::vector<int>& ShowerTracks() const { return fShowerTracks; }
  const std::vector<int>& ForwardConeTracks() const { return fForwardConeTracks; }

  int ConeSize() const
  {
    return (int)fForwardSpacePoints.size() - (int)fBackwardSpacePoints.size();
  }
  int ForwardSpacePoints() const { return fForwardSpacePoints.size(); }
  int NumCylinderSpacePoints() const { return fCylinderSpacePoints.size(); }
  double CylinderSpacePointRatio() const
  {
    return (double)fCylinderSpacePoints.size() / (double)fSpacePoints.size();
  }
  int NumSphereSpacePoints() const { return fSphereSpacePoints.size(); }
  double SphereSpacePointDensity(double scale) const
  {
    return (double)fSphereSpacePoints.size() /
           (4 * TMath::Pi() * TMath::Power((scale * fLength / 2.), 3) / 3.);
  }
  double IsolationSpacePointDistance() const
  {
    std::vector<double> distances;
    std::transform(fIsolationSpacePoints.begin(),
                   fIsolationSpacePoints.end(),
                   std::back_inserter(distances),
                   [](const std::pair<int, double>& p) { return p.second; });
    return TMath::Mean(distances.begin(), distances.end());
  }

private:
  int fID;
  TVector3 fVertex;
  TVector3 fEnd;
  double fLength;
  TVector3 fVertexDir;
  TVector3 fDirection;
  std::vector<art::Ptr<recob::Hit>> fHits;
  std::vector<art::Ptr<recob::SpacePoint>> fSpacePoints;

  std::vector<int> fForwardConeTracks;
  std::vector<int> fBackwardConeTracks;
  std::vector<int> fShowerTracks;

  std::vector<int> fForwardSpacePoints;
  std::vector<int> fBackwardSpacePoints;
  std::vector<int> fCylinderSpacePoints;
  std::vector<int> fSphereSpacePoints;
  std::map<int, double> fIsolationSpacePoints;

  bool fShower;
  bool fShowerTrack;
  bool fShowerCone;
  bool fTrack;
};

class shower::TrackShowerSeparationAlg {
public:
  TrackShowerSeparationAlg(fhicl::ParameterSet const& pset);

  void reconfigure(fhicl::ParameterSet const& pset);

  std::vector<art::Ptr<recob::Hit>> SelectShowerHits(
    int event,
    const std::vector<art::Ptr<recob::Hit>>& hits,
    const std::vector<art::Ptr<recob::Track>>& tracks,
    const std::vector<art::Ptr<recob::SpacePoint>>& spacePoints,
    const art::FindManyP<recob::Hit>& fmht,
    const art::FindManyP<recob::Track>& fmth,
    const art::FindManyP<recob::SpacePoint>& fmspt,
    const art::FindManyP<recob::Track>& fmtsp) const;

private:
  std::vector<int> InitialTrackLikeSegment(
    std::map<int, std::unique_ptr<ReconTrack>>& reconTracks) const;

  TVector3 Gradient(const std::vector<TVector3>& points,
                    const std::unique_ptr<TVector3>& dir) const;

  TVector3 Gradient(const art::Ptr<recob::Track>& track) const;

  TVector3 Gradient(const std::vector<art::Ptr<recob::SpacePoint>>& spacePoints) const;

  TVector3 ProjPoint(const TVector3& point,
                     const TVector3& direction,
                     const TVector3& origin = TVector3(0, 0, 0)) const;

  TVector3 SpacePointPos(const art::Ptr<recob::SpacePoint>& spacePoint) const;

  double SpacePointsRMS(const std::vector<art::Ptr<recob::SpacePoint>>& spacePoints) const;

  // Parameters
  int fDebug;

  // Properties
  double fConeAngle;
  double fCylinderRadius;

  // Cuts
  double fTrackVertexCut;
  double fCylinderCut;
  double fShowerConeCut;
};

#endif