cmtool::CFAlgoWireOverlap Class Reference

#include "CFAlgoWireOverlap.h"

Inheritance diagram for cmtool::CFAlgoWireOverlap:

Public Member Functions
	CFAlgoWireOverlap ()
	Default constructor. More...
virtual	~CFAlgoWireOverlap ()
	Default destructor. More...
virtual float	Float (const std::vector< const cluster::ClusterParamsAlg * > &clusters)
virtual void	Report ()
virtual void	Reset ()
	Function to reset the algorithm instance, called together with manager's Reset() More...
void	SetVerbose (bool on)
	Function to set verbose output. More...
void	SetDebug (bool on)
	Function to set debug output. More...
void	SetUseAllPlanes (bool on)
	Function to set if _UseAllPlanes is on/off. More...
virtual void	EventBegin (const std::vector< cluster::ClusterParamsAlg > &clusters)
virtual void	EventEnd ()
virtual void	IterationBegin (const std::vector< cluster::ClusterParamsAlg > &clusters)
virtual void	IterationEnd ()
void	SetAnaFile (TFile *fout)
	Setter function for an output plot TFile pointer. More...

Protected Attributes
TFile *	_fout
	TFile pointer to an output file. More...

Private Attributes
double	_w2cm
double	_t2cm
bool	_verbose
bool	_debug
bool	_UseAllPlanes

Detailed Description

User implementation for CFloatAlgoBase class doxygen documentation!

Definition at line 27 of file CFAlgoWireOverlap.h.

Constructor & Destructor Documentation

cmtool::CFAlgoWireOverlap::CFAlgoWireOverlap

(

)

Default constructor.

Definition at line 10 of file CFAlgoWireOverlap.cxx.

References _t2cm, _w2cm, SetDebug(), SetUseAllPlanes(), SetVerbose(), util::GeometryUtilities::TimeToCm(), and util::GeometryUtilities::WireToCm().

                                       : CFloatAlgoBase()
  //-------------------------------------------------------
  {
    ::util::GeometryUtilities geou;
    _w2cm = geou.WireToCm();
    _t2cm = geou.TimeToCm();
    SetVerbose(false);
    SetDebug(false);
    SetUseAllPlanes(false); // Any plane combination OK
  }

virtual cmtool::CFAlgoWireOverlap::~CFAlgoWireOverlap ( )

inlinevirtual

Default destructor.

Definition at line 35 of file CFAlgoWireOverlap.h.

References Float(), Report(), and Reset().

{};

Member Function Documentation

virtual void cmtool::CMAlgoBase::EventBegin ( const std::vector< cluster::ClusterParamsAlg > &  clusters )

inlinevirtualinherited

Optional function: called at the beginning of 1st iteration. This is called per event.

Reimplemented in cmtool::CFAlgoArray, cmtool::CPAlgoArray, cmtool::CBAlgoArray, and cmtool::CBAlgoPolyShortestDist.

Definition at line 45 of file CMAlgoBase.h.

Referenced by cmtool::CMergeManager::EventBegin().

    { if(clusters.size()) return; }

virtual void cmtool::CMAlgoBase::EventEnd ( )

inlinevirtualinherited

Optional function: called at the end of event ... after the last merging iteration is over.

Reimplemented in cmtool::CFAlgoArray, cmtool::CPAlgoArray, and cmtool::CBAlgoArray.

Definition at line 51 of file CMAlgoBase.h.

Referenced by cmtool::CMatchManager::EventEnd(), and cmtool::CMergeManager::EventEnd().

    {return;}

float cmtool::CFAlgoWireOverlap::Float ( const std::vector< const cluster::ClusterParamsAlg * > &  clusters )

virtual

Core function: given a set of CPANs, return a float which indicates the compatibility the cluster combination.

Reimplemented from cmtool::CFloatAlgoBase.

Definition at line 28 of file CFAlgoWireOverlap.cxx.

References _debug, _UseAllPlanes, _verbose, _w2cm, Polygon2D::Area(), Polygon2D::Contained(), geo::GeometryCore::DetHalfHeight(), geo::GeometryCore::DetLength(), geo::GeometryCore::Nwires(), Polygon2D::Point(), s, Polygon2D::Size(), Polygon2D::UntanglePolygon(), and geo::GeometryCore::WireEndPoints().

Referenced by ~CFAlgoWireOverlap().

  {
    art::ServiceHandle<geo::Geometry> geo;
    // Code-block by Kazu starts
    // This ensures the algorithm works only if # clusters is > 2 (and not =2)
    // You may take out this block if you want to allow matching using clusters from only 2 planes.
    if (_UseAllPlanes) { if(clusters.size()==2) return -1; }
    // Code-block by Kazu ends

    //This algorithm now works for 3 planes: find 3Dstart point from first 2 planes and find
    //How well that agrees with 3rd plane's start point location.

    //So first, make sure clusters vector has more than 1 element.
    //If not, return -1. Algorithm does not make sense
    if ( clusters.size() == 1 )
      return -1;

    if (_verbose) { std::cout << "Number of clusters taken into account: " << clusters.size() << std::endl; }
    
    //Nomenclature:
    //Planes: U == 0; V == 1; Y == 2.

    //Get hits for all 3 clusters
    std::vector<std::vector<util::PxHit> > Hits(3, std::vector<util::PxHit>());

    for (size_t c=0; c < clusters.size(); c++)
      Hits.at( clusters.at(c)->Plane() ) = clusters.at(c)->GetHitVector();

    //std::vector<util::PxHit> hits0 = clusters.at(0)->GetHitVector();
    //std::vector<util::PxHit> hits1 = clusters.at(1)->GetHitVector();
    //std::vector<util::PxHit> hits2 = clusters.at(2)->GetHitVector();
    
    //Wire Range Vector. Entries 0,1,2 correspond to planes
    std::vector<int> StartWires;
    std::vector<int> EndWires;
    //loop over number of planes and pre-fill StartWires and EndWires
    for (int pl=0; pl < 3; pl++){
      StartWires.push_back(9999);
      EndWires.push_back(0);
    }

    for (size_t h=0; h < Hits.size(); h++){
      for ( auto& hit: Hits.at(h) ){
        if ( Hits.at(h).size() == 0 ){
          std::cout << "Need to insert fake hit ranges...";
        }
        else{
          if ( int(hit.w / _w2cm) < StartWires.at(h) ) { StartWires.at(h) = int(hit.w / _w2cm); }
          if ( int(hit.w / _w2cm) > EndWires.at(h) )   { EndWires.at(h)   = int(hit.w / _w2cm); }
        }
      }//for all hits in range
    }//for all hit-lists (i.e. for all clusters)

    //if one of the plane's wire-range is still [9999, 0] then replace it
    //with min/max wire number from that plane
    //This allows for easy 2-Plane matching: if we are ignoring one plane
    //completely by giving the wire-range for the whole plane the intersection
    //will effectively be the intersection of the other two planes
    for (size_t h=0; h < Hits.size(); h++){
      if ( StartWires.at(h) == 9999 ) { StartWires.at(h) = 1; }
      if ( EndWires.at(h) == 0 ) { EndWires.at(h) = geo->Nwires(h)-1; }
    }
    /*
    //Get Wire-Range for all 3 clusters
    int startWire0 = 9999, endWire0 = 0;
    int startWire1 = 9999, endWire1 = 0;
    int startWire2 = 9999, endWire2 = 0;
    for (auto& hit: hits0){
      if ( int(hit.w / _w2cm) < startWire0 ) { startWire0 = int(hit.w / _w2cm); }
      if ( int(hit.w / _w2cm) > endWire0 )   { endWire0   = int(hit.w / _w2cm); }
    }
    for (auto& hit: hits1){
      if ( int(hit.w / _w2cm) < startWire1 ) { startWire1 = int(hit.w / _w2cm); }
      if ( int(hit.w / _w2cm) > endWire1 )   { endWire1   = int(hit.w / _w2cm); }
    }
    for (auto& hit: hits2){
      if ( int(hit.w / _w2cm) < startWire2 ) { startWire2 = int(hit.w / _w2cm); }
      if ( int(hit.w / _w2cm) > endWire2 )   { endWire2   = int(hit.w / _w2cm); }
    }
    */
    //Now get start & end points of all these wires
    Double_t xyzStart0WireStart[3] = {0., 0., 0.}; //xyz array info of start point for smallest wire number on plane 0
    Double_t xyzStart0WireEnd[3]   = {0., 0., 0.}; 
    Double_t xyzEnd0WireStart[3] = {0., 0., 0.}; 
    Double_t xyzEnd0WireEnd[3]   = {0., 0., 0.}; 
    Double_t xyzStart1WireStart[3] = {0., 0., 0.}; //xyz array info of start point for smallest wire number on plane 1
    Double_t xyzStart1WireEnd[3]   = {0., 0., 0.}; 
    Double_t xyzEnd1WireStart[3] = {0., 0., 0.}; 
    Double_t xyzEnd1WireEnd[3]   = {0., 0., 0.}; 
    Double_t xyzStart2WireStart[3] = {0., 0., 0.}; //xyz array info of start point for smallest wire number on plane 2
    Double_t xyzStart2WireEnd[3]   = {0., 0., 0.}; 
    Double_t xyzEnd2WireStart[3] = {0., 0., 0.}; 
    Double_t xyzEnd2WireEnd[3]   = {0., 0., 0.}; 

    if (_debug) {
      std::cout << "Wire Ranges:" << std::endl;
      std::cout << "U-Plane: [ " << StartWires.at(0) << ", " << EndWires.at(0) << "]" << std::endl;
      std::cout << "V-Plane: [ " << StartWires.at(1) << ", " << EndWires.at(1) << "]" << std::endl;
      std::cout << "Y-Plane: [ " << StartWires.at(2) << ", " << EndWires.at(2) << "]" << std::endl;
      std::cout << std::endl;
    }
    /*
    geo->WireEndPoints(0, StartWires.at(0), xyzStart0WireStart, xyzStart0WireEnd);
    geo->WireEndPoints(0, EndWires.at(0), xyzEnd0WireStart, xyzEnd0WireEnd);
    geo->WireEndPoints(1, StartWires.at(1), xyzStart1WireStart, xyzStart1WireEnd);
    geo->WireEndPoints(1, EndWires.at(1), xyzEnd1WireStart, xyzEnd1WireEnd);
    geo->WireEndPoints(2, StartWires.at(2), xyzStart2WireStart, xyzStart2WireEnd);
    geo->WireEndPoints(2, EndWires.at(2), xyzEnd2WireStart, xyzEnd2WireEnd);
    */
    geo->WireEndPoints(0, 0, 0, StartWires.at(0), xyzStart0WireStart, xyzStart0WireEnd);
    geo->WireEndPoints(0, 0, 0, EndWires.at(0), xyzEnd0WireStart, xyzEnd0WireEnd);
    geo->WireEndPoints(0, 0, 1, StartWires.at(1), xyzStart1WireStart, xyzStart1WireEnd);
    geo->WireEndPoints(0, 0, 1, EndWires.at(1), xyzEnd1WireStart, xyzEnd1WireEnd);
    geo->WireEndPoints(0, 0, 2, StartWires.at(2), xyzStart2WireStart, xyzStart2WireEnd);
    geo->WireEndPoints(0, 0, 2, EndWires.at(2), xyzEnd2WireStart, xyzEnd2WireEnd);

    //check that z-positions for plane2 are the same...if not error!
    //if ( xyzStart2WireStart[2] != xyzStart2WireEnd[2] ) { std::cout << "Y-wire does not have same Z start and end..." << std::endl; }
    double zMin = xyzStart2WireStart[2];
    //if ( xyzEnd2WireStart[2] != xyzEnd2WireEnd[2] ) { std::cout << "Y-wire does not have same Z start and end..." << std::endl; }
    double zMax = xyzEnd2WireStart[2];

    //Plane U == Plane 0
    //Plane V == Plane 1
    //Plane Y == Plane 2

    //Each line can be described by function y = s*z + b (x,y,z coordinates same as uBooNE coord.)
    //Slopes known: Pl0 is +60 clockwise from vertical. Pl1 is -60, counterclockwise from vertical. Looking at TPC with beam from left
    double slopeU = tan(30*3.14/180.);
    double slopeV = tan(-30*3.14/180.);

    //Find intercepts:
    double bUup = xyzStart0WireStart[1] - xyzStart0WireStart[2] * slopeU; 
    double bUdn   = xyzEnd0WireStart[1] - xyzEnd0WireStart[2] * slopeU; 
    double bVdn = xyzStart1WireStart[1] - xyzStart1WireStart[2] * slopeV; 
    double bVup   = xyzEnd1WireStart[1] - xyzEnd1WireStart[2] * slopeV; 
    //make sure we know which line is above which
    if ( bUup < bUdn ) { std::cout << "Uup and Udn are mixed up!" << std::endl; }
    if ( bVdn > bVup ) { std::cout << "Vup and Vdn are mixed up!" << std::endl; }
    //Pl2 lines are vertical...slope is infinite and no intercept.

    //Find intercepts of U wire-ranges with Y plane (easy since vertical)
    //For now assume wire-ranges go to infinity, worry about TPC constraints later

    //Plug in Y-plane zMin and zMax coordinates into equations for U/V wire lines
    double VdnZmin = slopeV * zMin + bVdn; 
    double VdnZmax = slopeV * zMax + bVdn; 
    double VupZmin = slopeV * zMin + bVup; 
    double VupZmax = slopeV * zMax + bVup; 
    double UdnZmin = slopeU * zMin + bUdn; 
    double UdnZmax = slopeU * zMax + bUdn; 
    double UupZmin = slopeU * zMin + bUup; 
    double UupZmax = slopeU * zMax + bUup;

    if (_debug){
      std::cout << "Y-Plane and U-Plane points [Z,Y]:" << std::endl;
      std::cout << "\t\t[ " << zMin << ", " << UdnZmin << "]" << std::endl;
      std::cout << "\t\t[ " << zMin << ", " << UupZmin << "]" << std::endl;
      std::cout << "\t\t[ " << zMax << ", " << UupZmax << "]" << std::endl;
      std::cout << "\t\t[ " << zMax << ", " << UdnZmax << "]" << std::endl;
      std::cout << "Y-Plane and V-Plane points [Z,Y]:" << std::endl;
      std::cout << "\t\t[ " << zMin << ", " << VdnZmin << "]" << std::endl;
      std::cout << "\t\t[ " << zMin << ", " << VupZmin << "]" << std::endl;
      std::cout << "\t\t[ " << zMax << ", " << VupZmax << "]" << std::endl;
      std::cout << "\t\t[ " << zMax << ", " << VdnZmax << "]" << std::endl;
    }
    //We now have Two polygons:
    //One is the intersection of Y-Plane wires with U-Plane wires
    //The other the intersection of planes Y and V.
    //The intersection points of these two polygons is the 
    //overall intersection Area of the 3 clusters on the Y-Z plane.

    //Go through all segment intersections. If one is found add to 
    //list of points.
    //Create a list of points for polygon
    std::vector< std::pair<float,float> > WireIntersection;
    double zInt; // temporary holder for z-intersection point of oblique sides
    //Check: Vup and Uup, Vup and Uright, Vup and Uleft, Vup and Udn.
    //Intersection between Vup and Uup: if within zMin, zMax then ok!
    zInt = (bUup-bVup)/(slopeV-slopeU);
    if ( (zInt > zMin) and (zInt < zMax) )
      WireIntersection.push_back( std::make_pair( zInt, slopeV*zInt+bVup ) );
    //Intersection between Vup and Uright:
    if ( (VupZmax < UupZmax) and (VupZmax > UdnZmax) )
      WireIntersection.push_back( std::make_pair( zMax, VupZmax ) );
    //Intersection between Vup and Uleft:
    if ( (VupZmin < UupZmin) and ( VupZmin > UdnZmin) )
      WireIntersection.push_back( std::make_pair( zMin, VupZmin ) );
    //Intersection between Vup and Udn:
    zInt = (bUdn-bVup)/(slopeV-slopeU);
    if ( (zInt > zMin) and (zInt < zMax) )
      WireIntersection.push_back( std::make_pair( zInt, slopeV*zInt+bVup ) );
    
    //Check: Vdn and Uup, Uright, Uleft, Udn:
    //Intersection between Vdn and Uup:
    zInt = (bUup-bVdn)/(slopeV-slopeU);
    if ( (zInt > zMin) and (zInt < zMax) )
      WireIntersection.push_back( std::make_pair( zInt, slopeV*zInt+bVdn ) );
    //Intersection between Vdn and Uright:
    if ( (VdnZmax < UupZmax) and (VdnZmax > UdnZmax) )
      WireIntersection.push_back( std::make_pair( zMax, VdnZmax ) );
    //Intersection between Vdn and Uleft:
    if ( (VdnZmin < UupZmin) and ( VdnZmin > UdnZmin) )
      WireIntersection.push_back( std::make_pair( zMin, VdnZmin ) );
    //Intersection between Vdn and Udn:
    zInt = (bUdn-bVdn)/(slopeV-slopeU);
    if ( (zInt > zMin) and (zInt < zMax) )
      WireIntersection.push_back( std::make_pair( zInt, slopeV*zInt+bVdn ) );
      
    //Check: Vright and Uup, Udn:
    //Intersection between Vright and Uup:
    if ( (UupZmax < VupZmax) and ( UupZmax > VdnZmax) )
      WireIntersection.push_back( std::make_pair( zMax, UupZmax ) );
    //Intersection between Vright and Udn:
    if ( (UdnZmax < VupZmax) and ( UdnZmax > VdnZmax) )
      WireIntersection.push_back( std::make_pair( zMax, UdnZmax ) );

    //Check Vleft and Uup, Udn:
    //Intersection between Vleft and Uup:
    if ( (UupZmin < VupZmin) and ( UupZmin > VdnZmin) )
      WireIntersection.push_back( std::make_pair( zMin, UupZmin ) );
    //Intersection between Vleft and Udn:
    if ( (UdnZmin < VupZmin) and ( UdnZmin > VdnZmin) )
      WireIntersection.push_back( std::make_pair( zMin, UdnZmin ) );

    //If length is 0 then no intersection...return -1
    if ( WireIntersection.size() == 0 ){
      if (_verbose) { std::cout << "No intersection..." << std::endl << std::endl; }
      return -1;
    }

    //Now our polygon is complete...
    //need to disentangle in case points added in incorrect order
    //then calculate area
    Polygon2D WirePolygon(WireIntersection);    
    //Variable to hold final output Area
    double PolyArea = -1;
    //Check order
    WirePolygon.UntanglePolygon();

    //Create a Polygon for the Y-Z TPC Plane
    std::vector< std::pair<float,float> > TPCCorners;
    TPCCorners.push_back( std::make_pair(0., -geo->DetHalfHeight()) );
    TPCCorners.push_back( std::make_pair(geo->DetLength(), -geo->DetHalfHeight()) );
    TPCCorners.push_back( std::make_pair(geo->DetLength(), geo->DetHalfHeight()) );
    TPCCorners.push_back( std::make_pair(0., geo->DetHalfHeight()) );
    Polygon2D TPCPolygon(TPCCorners);
    if (TPCPolygon.Contained(WirePolygon) ){
      if (_verbose) {
        std::cout << "Wire Overlap contained in TPC" << std::endl;
        std::cout << "Intersection Polygon Coordinates [Z,Y]: " << std::endl;
        for (unsigned int s=0; s < WirePolygon.Size(); s++)
          std::cout << "\t\t[ " << WirePolygon.Point(s).first << ", " << WirePolygon.Point(s).second << "]" << std::endl;
        std::cout << std::endl;
      }
      PolyArea = WirePolygon.Area();
    }
    else {
      if (_verbose) {
        std::cout << "Wire overlap not fully contained in TPC" << std::endl;
        std::cout << "Intersection Polygon Coordinates [Z,Y]: " << std::endl;
        for (unsigned int s=0; s < WirePolygon.Size(); s++)
          std::cout << "\t\t[ " << WirePolygon.Point(s).first << ", " << WirePolygon.Point(s).second << "]" << std::endl;
        std::cout << std::endl;
      }
      //product polygon should be the intersection of WirePolygon and TPCPolygon
        Polygon2D IntersectionPolygon(TPCPolygon, WirePolygon);
        PolyArea = IntersectionPolygon.Area();
    }

    //return polygon area -> larger = better!
    if (_verbose) { std::cout << "Intersection area: " << PolyArea << std::endl << std::endl; }    
    return  PolyArea;
  }

virtual void cmtool::CMAlgoBase::IterationBegin ( const std::vector< cluster::ClusterParamsAlg > &  clusters )

inlinevirtualinherited

Optional function: called at the beggining of each iteration over all pairs of clusters. This provides all clusters' information in case the algorithm need them. Note this is called per iteration which may be more than once per event.

Reimplemented in cmtool::CFAlgoArray, cmtool::CPAlgoArray, and cmtool::CBAlgoArray.

Definition at line 59 of file CMAlgoBase.h.

Referenced by cmtool::CMatchManager::EventBegin(), cmtool::CMatchManager::IterationBegin(), and cmtool::CMergeManager::IterationBegin().

    { if(clusters.size()) return;}

virtual void cmtool::CMAlgoBase::IterationEnd ( )

inlinevirtualinherited

Optional function: called at the end of each iteration over all pairs of clusters.

Reimplemented in cmtool::CFAlgoArray, cmtool::CPAlgoArray, and cmtool::CBAlgoArray.

Definition at line 65 of file CMAlgoBase.h.

Referenced by cmtool::CMatchManager::IterationEnd(), and cmtool::CMergeManager::IterationEnd().

    {return; }

void cmtool::CFAlgoWireOverlap::Report ( )

virtual

Optional function: called after each iterative approach if a manager class is run with verbosity level <= kPerIteration. Maybe useful for debugging.

Reimplemented from cmtool::CMAlgoBase.

Definition at line 305 of file CFAlgoWireOverlap.cxx.

Referenced by ~CFAlgoWireOverlap().

  {

  }

void cmtool::CFAlgoWireOverlap::Reset ( )

virtual

Function to reset the algorithm instance, called together with manager's Reset()

Reimplemented from cmtool::CMAlgoBase.

Definition at line 22 of file CFAlgoWireOverlap.cxx.

Referenced by ~CFAlgoWireOverlap().

  {
  }

void cmtool::CMAlgoBase::SetAnaFile ( TFile *  fout )

inlineinherited

Setter function for an output plot TFile pointer.

Definition at line 77 of file CMAlgoBase.h.

References cmtool::CMAlgoBase::_fout.

Referenced by cmtool::CMergeManager::EventBegin().

{ _fout = fout; }

void cmtool::CFAlgoWireOverlap::SetDebug ( bool  on )

inline

Function to set debug output.

Definition at line 62 of file CFAlgoWireOverlap.h.

References _debug.

Referenced by CFAlgoWireOverlap().

{ _debug = on; }

void cmtool::CFAlgoWireOverlap::SetUseAllPlanes ( bool  on )

inline

Function to set if _UseAllPlanes is on/off.

Definition at line 65 of file CFAlgoWireOverlap.h.

References _UseAllPlanes.

Referenced by CFAlgoWireOverlap().

{ _UseAllPlanes = on; }

void cmtool::CFAlgoWireOverlap::SetVerbose ( bool  on )

inlinevirtual

Function to set verbose output.

Reimplemented from cmtool::CMAlgoBase.

Definition at line 59 of file CFAlgoWireOverlap.h.

References _verbose.

Referenced by CFAlgoWireOverlap().

{ _verbose = on; }

Member Data Documentation

bool cmtool::CFAlgoWireOverlap::_debug

private

Definition at line 71 of file CFAlgoWireOverlap.h.

Referenced by Float(), and SetDebug().

TFile* cmtool::CMAlgoBase::_fout

protectedinherited

TFile pointer to an output file.

Definition at line 85 of file CMAlgoBase.h.

Referenced by cmtool::CMAlgoBase::CMAlgoBase(), and cmtool::CMAlgoBase::SetAnaFile().

double cmtool::CFAlgoWireOverlap::_t2cm

private

Definition at line 69 of file CFAlgoWireOverlap.h.

Referenced by CFAlgoWireOverlap().

bool cmtool::CFAlgoWireOverlap::_UseAllPlanes

private

Definition at line 72 of file CFAlgoWireOverlap.h.

Referenced by Float(), and SetUseAllPlanes().

bool cmtool::CFAlgoWireOverlap::_verbose

private

Definition at line 70 of file CFAlgoWireOverlap.h.

Referenced by Float(), and SetVerbose().

double cmtool::CFAlgoWireOverlap::_w2cm

private

Definition at line 69 of file CFAlgoWireOverlap.h.

Referenced by CFAlgoWireOverlap(), and Float().

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/CMTool/CMTAlgMatch/CFAlgoWireOverlap.h
• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/CMTool/CMTAlgMatch/CFAlgoWireOverlap.cxx