TracksClusteringFromDisplacedSeed Class Reference

#include <TracksClusteringFromDisplacedSeed.h>

Classes
struct	Cluster

Public Member Functions
std::vector< Cluster >	clusters (const reco::Vertex &pv, const std::vector< reco::TransientTrack > &selectedTracks)
	TracksClusteringFromDisplacedSeed (const edm::ParameterSet &params)

Private Member Functions
std::pair< std::vector< reco::TransientTrack >, GlobalPoint >	nearTracks (const reco::TransientTrack &seed, const std::vector< reco::TransientTrack > &tracks, const reco::Vertex &primaryVertex) const
bool	trackFilter (const reco::TrackRef &track) const

Private Attributes
double	clusterMaxDistance
double	clusterMaxSignificance
double	clusterMinAngleCosine
double	distanceRatio
double	max3DIPSignificance
double	max3DIPValue
double	maxTimeSignificance
double	min3DIPSignificance
double	min3DIPValue

Detailed Description

Definition at line 24 of file TracksClusteringFromDisplacedSeed.h.

Constructor & Destructor Documentation

TracksClusteringFromDisplacedSeed()

TracksClusteringFromDisplacedSeed::TracksClusteringFromDisplacedSeed

(

const edm::ParameterSet &

params

)

Definition at line 5 of file TracksClusteringFromDisplacedSeed.cc.

    :  //   maxNTracks(params.getParameter<unsigned int>("maxNTracks")),
      max3DIPSignificance(params.getParameter<double>("seedMax3DIPSignificance")),
      max3DIPValue(params.getParameter<double>("seedMax3DIPValue")),
      min3DIPSignificance(params.getParameter<double>("seedMin3DIPSignificance")),
      min3DIPValue(params.getParameter<double>("seedMin3DIPValue")),
      clusterMaxDistance(params.getParameter<double>("clusterMaxDistance")),
      clusterMaxSignificance(params.getParameter<double>("clusterMaxSignificance")),  //3
      distanceRatio(params.getParameter<double>("distanceRatio")),                    //was clusterScale/densityFactor
      clusterMinAngleCosine(params.getParameter<double>("clusterMinAngleCosine")),    //0.0
      maxTimeSignificance(params.getParameter<double>("maxTimeSignificance"))

{}

Member Function Documentation

clusters()

std::vector< TracksClusteringFromDisplacedSeed::Cluster > TracksClusteringFromDisplacedSeed::clusters	(	const reco::Vertex &	pv,
		const std::vector< reco::TransientTrack > &	selectedTracks
	)

Definition at line 100 of file TracksClusteringFromDisplacedSeed.cc.

References IPTools::absoluteImpactParameter3D(), gather_cfg::cout, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, max3DIPSignificance, max3DIPValue, min3DIPSignificance, min3DIPValue, nearTracks(), vertices_cff::ntracks, alignCSCRings::s, TracksClusteringFromDisplacedSeed::Cluster::seedingTrack, TracksClusteringFromDisplacedSeed::Cluster::seedPoint, HLT_2024v14_cff::seeds, TrackCollections2monitor_cff::selectedTracks, and TracksClusteringFromDisplacedSeed::Cluster::tracks.

                                                                               {
  using namespace reco;
  std::vector<TransientTrack> seeds;
  for (std::vector<TransientTrack>::const_iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++) {
    std::pair<bool, Measurement1D> ip = IPTools::absoluteImpactParameter3D(*it, pv);
    if (ip.first && ip.second.value() >= min3DIPValue && ip.second.significance() >= min3DIPSignificance &&
        ip.second.value() <= max3DIPValue && ip.second.significance() <= max3DIPSignificance) {
#ifdef VTXDEBUG
      std::cout << "new seed " << it - selectedTracks.begin() << " ref " << it->trackBaseRef().key() << " "
                << ip.second.value() << " " << ip.second.significance() << " "
                << it->track().hitPattern().trackerLayersWithMeasurement() << " " << it->track().pt() << " "
                << it->track().eta() << std::endl;
#endif
      seeds.push_back(*it);
    }
  }

  std::vector<Cluster> clusters;
  int i = 0;
  for (std::vector<TransientTrack>::const_iterator s = seeds.begin(); s != seeds.end(); ++s, ++i) {
#ifdef VTXDEBUG
    std::cout << "Seed N. " << i << std::endl;
#endif  // VTXDEBUG
    std::pair<std::vector<reco::TransientTrack>, GlobalPoint> ntracks = nearTracks(*s, selectedTracks, pv);
    //          std::cout << ntracks.first.size() << " " << ntracks.first.size()  << std::endl;
    //                if(ntracks.first.size() == 0 || ntracks.first.size() > maxNTracks ) continue;
    ntracks.first.push_back(*s);
    Cluster aCl;
    aCl.seedingTrack = *s;
    aCl.seedPoint = ntracks.second;
    aCl.tracks = ntracks.first;
    clusters.push_back(aCl);
  }

  return clusters;
}

nearTracks()

std::pair< std::vector< reco::TransientTrack >, GlobalPoint > TracksClusteringFromDisplacedSeed::nearTracks ( const reco::TransientTrack &  seed, const std::vector< reco::TransientTrack > &  tracks, const reco::Vertex &  primaryVertex  ) const

private

Definition at line 19 of file TracksClusteringFromDisplacedSeed.cc.

References funct::abs(), IPTools::absoluteImpactParameter3D(), TwoTrackMinimumDistance::calculate(), clusterMaxDistance, clusterMaxSignificance, clusterMinAngleCosine, gather_cfg::cout, CommonMethods::cp(), TwoTrackMinimumDistance::crossingPoint(), VertexDistance3D::distance(), TwoTrackMinimumDistance::distance(), HLT_2024v14_cff::distance, distanceRatio, Basic3DVector< T >::dot(), edm::isFinite(), visualization-live-secondInstance_cfg::m, mag(), maxTimeSignificance, TwoTrackMinimumDistance::points(), funct::pow(), BeamMonitor_cff::primaryVertex, MetAnalyzer::pv(), mps_fire::result, fileCollector::seed, mathSSE::sqrt(), DiMuonV_cfg::tracks, groupFilesInBlocks::tt, unit(), w(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by clusters().

                                           {
  VertexDistance3D distanceComputer;
  GlobalPoint pv(primaryVertex.position().x(), primaryVertex.position().y(), primaryVertex.position().z());
  std::vector<reco::TransientTrack> result;
  TwoTrackMinimumDistance dist;
  GlobalPoint seedingPoint;
  float sumWeights = 0;
  std::pair<bool, Measurement1D> ipSeed = IPTools::absoluteImpactParameter3D(seed, primaryVertex);
  float pvDistance = ipSeed.second.value();
  for (std::vector<reco::TransientTrack>::const_iterator tt = tracks.begin(); tt != tracks.end(); ++tt) {
    if (*tt == seed)
      continue;

    if (dist.calculate(tt->impactPointState(), seed.impactPointState())) {
      GlobalPoint ttPoint = dist.points().first;
      GlobalError ttPointErr = tt->impactPointState().cartesianError().position();
      GlobalPoint seedPosition = dist.points().second;
      GlobalError seedPositionErr = seed.impactPointState().cartesianError().position();
      Measurement1D m =
          distanceComputer.distance(VertexState(seedPosition, seedPositionErr), VertexState(ttPoint, ttPointErr));
      GlobalPoint cp(dist.crossingPoint());

      double timeSig = 0.;
      if (primaryVertex.covariance(3, 3) > 0. && edm::isFinite(seed.timeExt()) && edm::isFinite(tt->timeExt())) {
        // apply only if time available and being used in vertexing
        const double tError = std::sqrt(std::pow(seed.dtErrorExt(), 2) + std::pow(tt->dtErrorExt(), 2));
        timeSig = std::abs(seed.timeExt() - tt->timeExt()) / tError;
      }

      float distanceFromPV = (dist.points().second - pv).mag();
      float distance = dist.distance();
      GlobalVector trackDir2D(
          tt->impactPointState().globalDirection().x(), tt->impactPointState().globalDirection().y(), 0.);
      GlobalVector seedDir2D(
          seed.impactPointState().globalDirection().x(), seed.impactPointState().globalDirection().y(), 0.);
      //SK:UNUSED//    float dotprodTrackSeed2D = trackDir2D.unit().dot(seedDir2D.unit());

      float dotprodTrack = (dist.points().first - pv).unit().dot(tt->impactPointState().globalDirection().unit());
      float dotprodSeed = (dist.points().second - pv).unit().dot(seed.impactPointState().globalDirection().unit());

      float w = distanceFromPV * distanceFromPV / (pvDistance * distance);
      bool selected =
          (m.significance() < clusterMaxSignificance &&
           ((clusterMinAngleCosine > 0)
                ? (dotprodSeed > clusterMinAngleCosine)
                : (dotprodSeed < clusterMinAngleCosine)) &&  //Angles between PV-PCAonSeed vectors and seed directions
           ((clusterMinAngleCosine > 0)
                ? (dotprodTrack > clusterMinAngleCosine)
                : (dotprodTrack < clusterMinAngleCosine)) &&  //Angles between PV-PCAonTrack vectors and track directions
           //dotprodTrackSeed2D > clusterMinAngleCosine && //Angle between track and seed
           //distance*clusterScale*tracks.size() < (distanceFromPV+pvDistance)*(distanceFromPV+pvDistance)/pvDistance && // cut scaling with track density
           distance * distanceRatio < distanceFromPV &&  // cut scaling with track density
           distance < clusterMaxDistance &&
           timeSig < maxTimeSignificance);  // absolute distance cut

#ifdef VTXDEBUG
      std::cout << tt->trackBaseRef().key() << " :  " << (selected ? "+" : " ") << " " << m.significance() << " < "
                << clusterMaxSignificance << " &&  " << dotprodSeed << " > " << clusterMinAngleCosine << "  && "
                << dotprodTrack << " > " << clusterMinAngleCosine << "  && " << dotprodTrackSeed2D << " > "
                << clusterMinAngleCosine << "  &&  " << distance * distanceRatio << " < " << distanceFromPV
                << "  crossingtoPV: " << distanceFromPV << " dis*scal " << distance * distanceRatio << "  <  "
                << distanceFromPV << " dist: " << distance << " < " << clusterMaxDistance < < < <
          "timeSig: " << timeSig << std::endl;  // cut scaling with track density
#endif
      if (selected) {
        result.push_back(*tt);
        seedingPoint =
            GlobalPoint(cp.x() * w + seedingPoint.x(), cp.y() * w + seedingPoint.y(), cp.z() * w + seedingPoint.z());
        sumWeights += w;
      }
    }
  }

  seedingPoint =
      GlobalPoint(seedingPoint.x() / sumWeights, seedingPoint.y() / sumWeights, seedingPoint.z() / sumWeights);
  return std::pair<std::vector<reco::TransientTrack>, GlobalPoint>(result, seedingPoint);
}

trackFilter()

bool TracksClusteringFromDisplacedSeed::trackFilter ( const reco::TrackRef &  track ) const

private

Member Data Documentation

clusterMaxDistance

double TracksClusteringFromDisplacedSeed::clusterMaxDistance

private

Definition at line 46 of file TracksClusteringFromDisplacedSeed.h.

Referenced by nearTracks().

clusterMaxSignificance

double TracksClusteringFromDisplacedSeed::clusterMaxSignificance

private

Definition at line 47 of file TracksClusteringFromDisplacedSeed.h.

Referenced by nearTracks().

clusterMinAngleCosine

double TracksClusteringFromDisplacedSeed::clusterMinAngleCosine

private

Definition at line 49 of file TracksClusteringFromDisplacedSeed.h.

Referenced by nearTracks().

distanceRatio

double TracksClusteringFromDisplacedSeed::distanceRatio

private

Definition at line 48 of file TracksClusteringFromDisplacedSeed.h.

Referenced by nearTracks().

max3DIPSignificance

double TracksClusteringFromDisplacedSeed::max3DIPSignificance

private

Definition at line 42 of file TracksClusteringFromDisplacedSeed.h.

Referenced by clusters().

max3DIPValue

double TracksClusteringFromDisplacedSeed::max3DIPValue

private

Definition at line 43 of file TracksClusteringFromDisplacedSeed.h.

Referenced by clusters().

maxTimeSignificance

double TracksClusteringFromDisplacedSeed::maxTimeSignificance

private

Definition at line 50 of file TracksClusteringFromDisplacedSeed.h.

Referenced by nearTracks().

min3DIPSignificance

double TracksClusteringFromDisplacedSeed::min3DIPSignificance

private

Definition at line 44 of file TracksClusteringFromDisplacedSeed.h.

Referenced by clusters().

min3DIPValue

double TracksClusteringFromDisplacedSeed::min3DIPValue

private

Definition at line 45 of file TracksClusteringFromDisplacedSeed.h.

Referenced by clusters().