#include <TPCGeoAlg.h>

Public Member Functions
	TPCGeoAlg ()

	~TPCGeoAlg ()

double	MinX () const

double	MinY () const

double	MinZ () const

double	MaxX () const

double	MaxY () const

double	MaxZ () const

double	CpaWidth () const

bool	InFiducial (geo::Point_t point, double fiducial)

bool	InFiducial (geo::Point_t point, double fiducial, double fiducialTop)

bool	InFiducial (geo::Point_t point, double minXCut, double minYCut, double minZCut, double maxXCut, double maxYCut, double maxZCut)

bool	InsideTPC (geo::Point_t point, const geo::TPCGeo &tpc, double buffer=0.)

int	DetectedInTPC (std::vector< art::Ptr< recob::Hit >> hits)

int	DriftDirectionFromHits (std::vector< art::Ptr< recob::Hit >> hits)

std::pair< double, double >	XLimitsFromHits (std::vector< art::Ptr< recob::Hit >> hits)

double	MinDistToWall (geo::Point_t point)

bool	InVolume (const simb::MCParticle &particle)

bool	IsContained (const simb::MCParticle &particle)

bool	EntersVolume (const simb::MCParticle &particle)

bool	CrossesVolume (const simb::MCParticle &particle)

bool	CrossesApa (const simb::MCParticle &particle)

std::pair< TVector3, TVector3 >	CrossingPoints (const simb::MCParticle &particle)

double	TpcLength (const simb::MCParticle &particle)

Private Attributes
double	fMinX

double	fMinY

double	fMinZ

double	fMaxX

double	fMaxY

double	fMaxZ

double	fCpaWidth

geo::GeometryCore const *	fGeometryService

Detailed Description

Definition at line 35 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.h.

Constructor & Destructor Documentation

sbnd::TPCGeoAlg::TPCGeoAlg ( )

Definition at line 6 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                     {
 
   fMinX = 99999;
   fMinY = 99999;
   fMinZ = 99999;
   fMaxX = -99999;
   fMaxY = -99999;
   fMaxZ = -99999;
   fCpaWidth = 0;
 
   fGeometryService = lar::providerFrom<geo::Geometry>();
 
   for(size_t cryo_i = 0; cryo_i < fGeometryService->Ncryostats(); cryo_i++){
     const geo::CryostatGeo& cryostat = fGeometryService->Cryostat(cryo_i);
 
     for (size_t tpc_i = 0; tpc_i < cryostat.NTPC(); tpc_i++)
     {
       const geo::TPCGeo& tpcg = cryostat.TPC(tpc_i);
       if (tpcg.MinX() < fMinX) fMinX = tpcg.MinX();
       if (tpcg.MaxX() > fMaxX) fMaxX = tpcg.MaxX();
       if (tpcg.MinY() < fMinY) fMinY = tpcg.MinY();
       if (tpcg.MaxY() > fMaxY) fMaxY = tpcg.MaxY();
       if (tpcg.MinZ() < fMinZ) fMinZ = tpcg.MinZ();
       if (tpcg.MaxZ() > fMaxZ) fMaxZ = tpcg.MaxZ();
       fCpaWidth = std::min(std::abs(tpcg.MinX()), std::abs(tpcg.MaxX()));
     }
   }
 }

sbnd::TPCGeoAlg::~TPCGeoAlg ( )

Definition at line 36 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                      {
 
 }

Member Function Documentation

double sbnd::TPCGeoAlg::CpaWidth ( ) const

Definition at line 66 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                 {
   return fCpaWidth;
 }

bool sbnd::TPCGeoAlg::CrossesApa ( const simb::MCParticle & particle )

Definition at line 236 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                         {
   for(size_t i = 0; i < particle.NumberTrajectoryPoints()-1; i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     double x1 = particle.Vx(i+1); 
     double y1 = particle.Vy(i+1);
     double z1 = particle.Vz(i+1);
     if(y >= fMinY && z >= fMinZ && y <= fMaxY && z <= fMaxZ
        && y1 >= fMinY && z1 >= fMinZ && y1 <= fMaxY && z1 <= fMaxZ){
       if(x <= fMinX && x1 >= fMinX) return true;
       if(x >= fMinX && x1 <= fMinX) return true;
       if(x <= fMaxX && x1 >= fMaxX) return true;
       if(x >= fMaxX && x1 <= fMaxX) return true;
     }
   }
   return false;
 }

bool sbnd::TPCGeoAlg::CrossesVolume ( const simb::MCParticle & particle )

Definition at line 216 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                            {
   bool enters = false;
   bool startOutside = false;
   bool endOutside = false;
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x > fMinX && y > fMinY && z > fMinZ && x < fMaxX && y < fMaxY && z < fMaxZ){
       enters = true;
     }
     else if(i == 0) startOutside = true;
     else if(i == particle.NumberTrajectoryPoints()-1) endOutside = true;
   }
   if(startOutside && enters && endOutside) return true;
   return false;
 }

std::pair< TVector3, TVector3 > sbnd::TPCGeoAlg::CrossingPoints ( const simb::MCParticle & particle )

Definition at line 255 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                                    {
   bool first = true;
   TVector3 start (-99999, -99999, -99999);
   TVector3 end (-99999, -99999, -99999);
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x > fMinX && y > fMinY && z > fMinZ && x < fMaxX && y < fMaxY && z < fMaxZ){
       if(first){
         first = false;
         start.SetXYZ(x, y, z);
       }
       end.SetXYZ(x, y, z);
     }
   }
   return std::make_pair(start, end);
 }

int sbnd::TPCGeoAlg::DetectedInTPC ( std::vector< art::Ptr< recob::Hit >> hits )

Definition at line 100 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                             {
   // Return tpc of hit collection or -1 if in multiple
   if(hits.size() == 0) return -1;
   int tpc = hits[0]->WireID().TPC;
   for(size_t i = 0; i < hits.size(); i++){
     if((int)hits[i]->WireID().TPC != tpc) return -1;
   }
   return tpc;
 }

int sbnd::TPCGeoAlg::DriftDirectionFromHits ( std::vector< art::Ptr< recob::Hit >> hits )

Definition at line 111 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                      {
   // If there are no hits then return 0
   if(hits.size() == 0) return 0;
   
   // If the track is stitched (in multiple TPCs) return 0
   if(DetectedInTPC(hits) == -1) return 0;
 
   // Work out the drift direction
   geo::TPCID tpcID = hits[0]->WireID().asTPCID();
   const geo::TPCGeo& tpcGeo = fGeometryService->GetElement(tpcID);
   double driftDirection = tpcGeo.DetectDriftDirection();
   if(std::abs(driftDirection) != 1) driftDirection = 0;
   return driftDirection;
 }

bool sbnd::TPCGeoAlg::EntersVolume ( const simb::MCParticle & particle )

Definition at line 196 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                           {
   bool enters = false;
   bool startOutside = false;
   bool endOutside = false;
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x > fMinX && y > fMinY && z > fMinZ && x < fMaxX && y < fMaxY && z < fMaxZ){
       enters = true;
     }
     else if(i == 0) startOutside = true;
     else if(i == particle.NumberTrajectoryPoints()-1) endOutside = true;
   }
   if(enters && (startOutside || endOutside)) return true;
   return false;
 }

bool sbnd::TPCGeoAlg::InFiducial	(	geo::Point_t	point,
		double	fiducial
	)

Definition at line 72 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                            {
   return InFiducial(point, fiducial, fiducial);
 }

bool sbnd::TPCGeoAlg::InFiducial	(	geo::Point_t	point,
		double	fiducial,
		double	fiducialTop
	)

Definition at line 76 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                                {
   return InFiducial(point, fiducial, fiducial, fiducial, fiducial, fiducialTop, fiducial);
 }

bool sbnd::TPCGeoAlg::InFiducial	(	geo::Point_t	point,
		double	minXCut,
		double	minYCut,
		double	minZCut,
		double	maxXCut,
		double	maxYCut,
		double	maxZCut
	)

Definition at line 80 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                           {
   
   double xmin = fMinX + minXCut;
   double xmax = fMaxX - maxXCut;
   double ymin = fMinY + minYCut;
   double ymax = fMaxY - maxYCut;
   double zmin = fMinZ + minZCut;
   double zmax = fMaxZ - maxZCut;
 
   double x = point.X();
   double y = point.Y();
   double z = point.Z();
   if(x>xmin && x<xmax && y>ymin && y<ymax && z>zmin && z<zmax) return true;
 
   return false;
 }

bool sbnd::TPCGeoAlg::InsideTPC	(	geo::Point_t	point,
		const geo::TPCGeo &	tpc,
		double	buffer = `0.`
	)

Definition at line 141 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                               {
   if(point.X() < (tpc.MinX()-buffer) || point.X() > (tpc.MaxX()+buffer)
       || point.Y() < (tpc.MinY()-buffer) || point.Y() > (tpc.MaxY()+buffer)
       || point.Z() < (tpc.MinZ()-buffer) || point.Z() > (tpc.MaxZ()+buffer)) return false;
   return true;
 }

bool sbnd::TPCGeoAlg::InVolume ( const simb::MCParticle & particle )

Definition at line 168 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                       {
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x > fMinX && y > fMinY && z > fMinZ && x < fMaxX && y < fMaxY && z < fMaxZ){
       return true;
     }
   }
   return false;
 }

bool sbnd::TPCGeoAlg::IsContained ( const simb::MCParticle & particle )

Definition at line 182 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                          {
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x < fMinX || y < fMinY || z < fMinZ || x > fMaxX || y > fMaxY || z > fMaxZ){
       return false;
     }
   }
   return true;
 }

double sbnd::TPCGeoAlg::MaxX ( ) const

Definition at line 54 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMaxX;
 }

double sbnd::TPCGeoAlg::MaxY ( ) const

Definition at line 58 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMaxY;
 }

double sbnd::TPCGeoAlg::MaxZ ( ) const

Definition at line 62 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMaxZ;
 }

double sbnd::TPCGeoAlg::MinDistToWall ( geo::Point_t point )

Definition at line 149 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                {
 
   std::vector<double> dists;
   
   dists.push_back(std::abs(point.X() - fMinX));
   dists.push_back(std::abs(point.X() - fMaxX));
   dists.push_back(std::abs(point.Y() - fMinY));
   dists.push_back(std::abs(point.Y() - fMaxY));
   dists.push_back(std::abs(point.Z() - fMinZ));
   dists.push_back(std::abs(point.Z() - fMaxZ));
 
   std::sort(dists.begin(), dists.end());
 
   return dists[0];
 
 }

double sbnd::TPCGeoAlg::MinX ( ) const

Definition at line 42 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMinX;
 }

double sbnd::TPCGeoAlg::MinY ( ) const

Definition at line 46 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMinY;
 }

double sbnd::TPCGeoAlg::MinZ ( ) const

Definition at line 50 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                             {
   return fMinZ;
 }

double sbnd::TPCGeoAlg::TpcLength ( const simb::MCParticle & particle )

Definition at line 274 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                          {
   bool first = true;
   double length = 0;
   TVector3 point, disp;
   for(size_t i = 0; i < particle.NumberTrajectoryPoints(); i++){
     double x = particle.Vx(i); 
     double y = particle.Vy(i);
     double z = particle.Vz(i);
     if(x > fMinX && y > fMinY && z > fMinZ && x < fMaxX && y < fMaxY && z < fMaxZ){
       point.SetXYZ(x, y, z);
       if(!first){
         disp -= point;
         length += disp.Mag();
       }
       first = false;
       disp = point;
     }
   }
   return length;
 }

std::pair< double, double > sbnd::TPCGeoAlg::XLimitsFromHits ( std::vector< art::Ptr< recob::Hit >> hits )

Definition at line 127 of file sbndcode/sbndcode/Geometry/GeometryWrappers/TPCGeoAlg.cc.

                                                                                   {
   // If there are no hits then return 0
   if(hits.size() == 0) return std::make_pair(0, 0);
   
   // If the track is stitched (in multiple TPCs) return 0
   if(DetectedInTPC(hits) == -1) return std::make_pair(0, 0);
 
   // Work out the drift direction
   geo::TPCID tpcID = hits[0]->WireID().asTPCID();
   const geo::TPCGeo& tpcGeo = fGeometryService->GetElement(tpcID);
   return std::make_pair(tpcGeo.MinX(), tpcGeo.MaxX());
 }