ticl::TracksterLinkingbySkeletons Class Reference

#include <TracksterLinkingbySkeletons.h>

Inheritance diagram for ticl::TracksterLinkingbySkeletons:

Public Member Functions
bool	areCompatible (const ticl::Trackster &myTrackster, const ticl::Trackster &otherTrackster, const std::array< ticl::Vector, 3 > &mySkeleton, const std::array< ticl::Vector, 3 > &otherSkeleton)
std::array< ticl::Vector, 3 >	findSkeletonNodes (const ticl::Trackster &trackster, float lower_percentage, float upper_percentage, const std::vector< reco::CaloCluster > &layerClusters, const hgcal::RecHitTools &rhtools)
void	initialize (const HGCalDDDConstants *hgcons, const hgcal::RecHitTools rhtools, const edm::ESHandle< MagneticField > bfieldH, const edm::ESHandle< Propagator > propH) override
void	linkTracksters (const Inputs &input, std::vector< Trackster > &resultTracksters, std::vector< std::vector< unsigned int >> &linkedResultTracksters, std::vector< std::vector< unsigned int >> &linkedTracksterIdToInputTracksterId) override
	TracksterLinkingbySkeletons (const edm::ParameterSet &conf, edm::ConsumesCollector iC, cms::Ort::ONNXRuntime const *onnxRuntime=nullptr)
	~TracksterLinkingbySkeletons () override
Public Member Functions inherited from ticl::TracksterLinkingAlgoBase
virtual void	setEvent (edm::Event &iEvent, edm::EventSetup const &iEventSetup)
	TracksterLinkingAlgoBase (const edm::ParameterSet &conf, edm::ConsumesCollector, cms::Ort::ONNXRuntime const *onnxRuntime=nullptr)
virtual	~TracksterLinkingAlgoBase ()

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)
Static Public Member Functions inherited from ticl::TracksterLinkingAlgoBase
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Private Types
using	Vector = ticl::Trackster::Vector

Private Member Functions
void	buildLayers ()
void	dumpLinksFound (std::vector< std::vector< unsigned >> &resultCollection, const char *label) const

Private Attributes
edm::ESHandle< MagneticField >	bfield_
std::vector< double >	cylinder_radius_sqr_
float	del_
float	dot_prod_th_
std::unique_ptr< GeomDet >	firstDisk_ [2]
const HGCalDDDConstants *	hgcons_
std::unique_ptr< GeomDet >	interfaceDisk_ [2]
std::vector< double >	max_distance_projective_sqr_
std::vector< double >	max_distance_projective_sqr_closest_points_
std::vector< double >	max_z_distance_closest_points_
std::vector< double >	min_distance_z_
unsigned int	min_num_lcs_
float	min_trackster_energy_
float	pca_quality_th_
edm::ESHandle< Propagator >	propagator_
hgcal::RecHitTools	rhtools_
float	timing_quality_threshold_

Additional Inherited Members
Protected Attributes inherited from ticl::TracksterLinkingAlgoBase
int	algo_verbosity_
cms::Ort::ONNXRuntime const *	onnxRuntime_

Detailed Description

Definition at line 24 of file TracksterLinkingbySkeletons.h.

Member Typedef Documentation

Vector

using ticl::TracksterLinkingbySkeletons::Vector = ticl::Trackster::Vector

private

Definition at line 69 of file TracksterLinkingbySkeletons.h.

Constructor & Destructor Documentation

TracksterLinkingbySkeletons()

TracksterLinkingbySkeletons::TracksterLinkingbySkeletons	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector	iC,
		cms::Ort::ONNXRuntime const *	onnxRuntime = nullptr
	)

Definition at line 53 of file TracksterLinkingbySkeletons.cc.

    : TracksterLinkingAlgoBase(conf, iC),
      timing_quality_threshold_(conf.getParameter<double>("track_time_quality_threshold")),
      del_(conf.getParameter<double>("wind")),
      min_num_lcs_(conf.getParameter<unsigned int>("min_num_lcs")),
      min_trackster_energy_(conf.getParameter<double>("min_trackster_energy")),
      pca_quality_th_(conf.getParameter<double>("pca_quality_th")),
      dot_prod_th_(conf.getParameter<double>("dot_prod_th")),
      max_distance_projective_sqr_(conf.getParameter<std::vector<double>>("max_distance_projective_sqr")),
      min_distance_z_(conf.getParameter<std::vector<double>>("min_distance_z")),
      max_distance_projective_sqr_closest_points_(
          conf.getParameter<std::vector<double>>("max_distance_projective_sqr_closest_points")),
      max_z_distance_closest_points_(conf.getParameter<std::vector<double>>("max_z_distance_closest_points")),
      cylinder_radius_sqr_(conf.getParameter<std::vector<double>>("cylinder_radius_sqr"))

{}

~TracksterLinkingbySkeletons()

ticl::TracksterLinkingbySkeletons::~TracksterLinkingbySkeletons ( )

inlineoverride

Definition at line 30 of file TracksterLinkingbySkeletons.h.

{}

Member Function Documentation

areCompatible()

bool TracksterLinkingbySkeletons::areCompatible	(	const ticl::Trackster &	myTrackster,
		const ticl::Trackster &	otherTrackster,
		const std::array< ticl::Vector, 3 > &	mySkeleton,
		const std::array< ticl::Vector, 3 > &	otherSkeleton
	)

Definition at line 201 of file TracksterLinkingbySkeletons.cc.

References funct::abs(), cylinder_radius_sqr_, ztail::d, dot_prod_th_, hgcal::RecHitTools::getPositionLayer(), mps_fire::i, isInCylinder(), dqmiolumiharvest::j, hgcal::RecHitTools::lastLayerEE(), LogDebug, WZElectronSkims53X_cff::max, max_distance_projective_sqr_, max_distance_projective_sqr_closest_points_, max_z_distance_closest_points_, min_distance_z_, min_num_lcs_, min_trackster_energy_, pca_quality_th_, ticl::Trackster::raw_energy(), rhtools_, ticl::Trackster::vertices(), and beamSpotPI::Z.

Referenced by linkTracksters().

                                                                                              {
  //do not start links from small/bad tracksters
  float zVal_interface = rhtools_.getPositionLayer(rhtools_.lastLayerEE()).z();
  if (!isGoodTrackster(myTrackster, mySkeleton, min_num_lcs_, min_trackster_energy_, pca_quality_th_)) {
    LogDebug("TracksterLinkingbySkeletons") << "Inner Trackster with energy " << myTrackster.raw_energy() << " Num LCs "
                                            << myTrackster.vertices().size() << " NOT GOOD " << std::endl;
    return false;
  } else {
    LogDebug("TracksterLinkingbySkeletons") << "Inner Trackster wi energy " << myTrackster.raw_energy() << " Num LCs "
                                            << myTrackster.vertices().size() << " IS GOOD " << std::endl;
    float proj_distance = projective_distance(mySkeleton[1], otherSkeleton[1]);
    auto isEE = mySkeleton[1].z() <= zVal_interface ? 0 : 1;
    bool areAlignedInProjectiveSpace = proj_distance < max_distance_projective_sqr_[isEE];
    LogDebug("TracksterLinkingbySkeletons")
        << "\t Trying to compare with outer Trackster with energy " << otherTrackster.raw_energy() << " Num LCS "
        << otherTrackster.vertices().size() << " Projective distance " << proj_distance << " areAlignedProjective "
        << areAlignedInProjectiveSpace << " TH " << max_distance_projective_sqr_[isEE] << std::endl;
    //check if otherTrackster is good
    if (isGoodTrackster(otherTrackster, otherSkeleton, min_num_lcs_, min_trackster_energy_, pca_quality_th_)) {
      // if both tracksters are good, then we can check the projective distance between the barycenters.
      // if the barycenters are aligned, then we check that the two skeletons are aligned
      if (areAlignedInProjectiveSpace) {
        auto dotProdSkeletons =
            ((mySkeleton[2] - mySkeleton[0]).Unit()).Dot((otherSkeleton[2] - otherSkeleton[0]).Unit());
        bool alignedSkeletons = dotProdSkeletons > dot_prod_th_;
        LogDebug("TracksterLinkingbySkeletons")
            << "\t Outer Trackster is Good, checking for skeleton alignment " << alignedSkeletons << " dotProd "
            << dotProdSkeletons << " Threshold " << dot_prod_th_ << std::endl;
        if (alignedSkeletons)
          LogDebug("TracksterLinkingbySkeletons") << "\t\t Linked! " << std::endl;
        return alignedSkeletons;
      } else {
        // we measure the distance between the two closest nodes in the two skeletons
        LogDebug("TracksterLinkingbySkeletons")
            << "\t Outer Trackster is not aligned,  check skeletons distances " << std::endl;
        int myClosestPoint = -1;
        int otherClosestPoint = -1;
        float minDistance_z = std::numeric_limits<float>::max();
        for (int i = 0; i < 3; i++) {
          for (int j = 0; j < 3; j++) {
            float dist_z = std::abs(mySkeleton[i].Z() - otherSkeleton[j].Z());
            if (dist_z < minDistance_z) {
              myClosestPoint = i;
              otherClosestPoint = j;
              minDistance_z = dist_z;
            }
          }
        }
        if (minDistance_z < min_distance_z_[isEE]) {
          LogDebug("TracksterLinkingbySkeletons")
              << "\t Trackster have distance in Z " << minDistance_z
              << "Checking if they are aligned in projective space "
              << projective_distance(mySkeleton[myClosestPoint], otherSkeleton[otherClosestPoint]) << " TH "
              << max_distance_projective_sqr_[isEE] << std::endl;
          if (projective_distance(mySkeleton[myClosestPoint], otherSkeleton[otherClosestPoint]) <
              max_distance_projective_sqr_[isEE]) {
            LogDebug("TracksterLinkingbySkeletons") << "\t\t Linked! " << std::endl;
          }
          return projective_distance(mySkeleton[myClosestPoint], otherSkeleton[otherClosestPoint]) <
                 max_distance_projective_sqr_[isEE];
        } else {
          LogDebug("TracksterLinkingbySkeletons") << "\t\t Not Linked Distance Z " << minDistance_z << std::endl;
          return false;
        }
      }
    } else {
      LogDebug("TracksterLinkingbySkeletons")
          << "\t Outer Trackster is NOT GOOD,  check projective space alignment " << areAlignedInProjectiveSpace
          << " proj_distance " << max_distance_projective_sqr_[isEE] << std::endl;
      if (areAlignedInProjectiveSpace) {
        LogDebug("TracksterLinkingbySkeletons") << "\t\t Linked! " << std::endl;
        return true;
      } else {
        LogDebug("TracksterLinkingbySkeletons")
            << "\t Not aligned in projective space, check distance between closest points in the two skeletons "
            << std::endl;
        // we measure the distance between the two closest nodes in the two skeletons
        int myClosestPoint = -1;
        int otherClosestPoint = -1;
        float minDistance_z = std::numeric_limits<float>::max();
        // we skip the innermost node of mySkeleton
        for (int i = 1; i < 3; i++) {
          for (int j = 0; j < 3; j++) {
            float dist_z = std::abs(mySkeleton[i].Z() - otherSkeleton[j].Z());
            if (dist_z < minDistance_z) {
              myClosestPoint = i;
              otherClosestPoint = j;
              minDistance_z = dist_z;
            }
          }
        }
        float d = projective_distance(mySkeleton[myClosestPoint], otherSkeleton[otherClosestPoint]);
        LogDebug("TracksterLinkingbySkeletons")
            << "\t\t Distance between closest points " << d << " TH " << 10.f << " Z Distance " << minDistance_z
            << " TH " << max_distance_projective_sqr_closest_points_[isEE] << std::endl;
        if (d < max_distance_projective_sqr_closest_points_[isEE] and
            minDistance_z < max_z_distance_closest_points_[isEE]) {
          LogDebug("TracksterLinkingbySkeletons") << "\t\t\t Linked! " << d << std::endl;
          return true;
        } else {
          LogDebug("TracksterLinkingbySkeletons") << "Distance between closest point " << d << " Distance in z "
                                                  << max_z_distance_closest_points_[isEE] << std::endl;
          bool isInCyl = isInCylinder(mySkeleton, otherSkeleton, cylinder_radius_sqr_[isEE]);
          LogDebug("TracksterLinkingbySkeletons") << "Two Points are in Cylinder  " << isInCyl << std::endl;
          if (isInCyl) {
            LogDebug("TracksterLinkingbySkeletons") << "\t\t\t Linked! " << d << std::endl;
          }
          return isInCyl;
        }
      }
    }
  }
}

buildLayers()

void TracksterLinkingbySkeletons::buildLayers ( )

private

Definition at line 72 of file TracksterLinkingbySkeletons.cc.

References Disk::build(), firstDisk_, hgcal::RecHitTools::getPositionLayer(), hgcons_, interfaceDisk_, hgcal::RecHitTools::lastLayerEE(), HGCalDDDConstants::rangeR(), rhtools_, and HGCalDDDConstants::waferZ().

Referenced by initialize().

                                              {
  // build disks at HGCal front & EM-Had interface for track propagation

  float zVal = hgcons_->waferZ(1, true);
  std::pair<float, float> rMinMax = hgcons_->rangeR(zVal, true);

  float zVal_interface = rhtools_.getPositionLayer(rhtools_.lastLayerEE()).z();
  std::pair<float, float> rMinMax_interface = hgcons_->rangeR(zVal_interface, true);

  for (int iSide = 0; iSide < 2; ++iSide) {
    float zSide = (iSide == 0) ? (-1. * zVal) : zVal;
    firstDisk_[iSide] =
        std::make_unique<GeomDet>(Disk::build(Disk::PositionType(0, 0, zSide),
                                              Disk::RotationType(),
                                              SimpleDiskBounds(rMinMax.first, rMinMax.second, zSide - 0.5, zSide + 0.5))
                                      .get());

    zSide = (iSide == 0) ? (-1. * zVal_interface) : zVal_interface;
    interfaceDisk_[iSide] = std::make_unique<GeomDet>(
        Disk::build(Disk::PositionType(0, 0, zSide),
                    Disk::RotationType(),
                    SimpleDiskBounds(rMinMax_interface.first, rMinMax_interface.second, zSide - 0.5, zSide + 0.5))
            .get());
  }
}

dumpLinksFound()

void ticl::TracksterLinkingbySkeletons::dumpLinksFound ( std::vector< std::vector< unsigned >> &  resultCollection, const char *  label  ) const

private

fillPSetDescription()

static void ticl::TracksterLinkingbySkeletons::fillPSetDescription ( edm::ParameterSetDescription &  iDesc )

inlinestatic

Definition at line 53 of file TracksterLinkingbySkeletons.h.

References edm::ParameterSetDescription::add(), and ticl::TracksterLinkingAlgoBase::fillPSetDescription().

                                                                       {
      iDesc.add<double>("track_time_quality_threshold", 0.5);
      iDesc.add<double>("wind", 0.036);
      iDesc.add<unsigned int>("min_num_lcs", 7);
      iDesc.add<double>("min_trackster_energy", 10.);
      iDesc.add<double>("pca_quality_th", 0.85);
      iDesc.add<double>("dot_prod_th", 0.97);
      iDesc.add<std::vector<double>>("max_distance_projective_sqr", {60., 60.});
      iDesc.add<std::vector<double>>("min_distance_z", {30., 30.});
      iDesc.add<std::vector<double>>("max_distance_projective_sqr_closest_points", {60., 60.});
      iDesc.add<std::vector<double>>("max_z_distance_closest_points", {35., 35.});
      iDesc.add<std::vector<double>>("cylinder_radius_sqr", {9., 9.});
      TracksterLinkingAlgoBase::fillPSetDescription(iDesc);
    }

findSkeletonNodes()

std::array< ticl::Vector, 3 > TracksterLinkingbySkeletons::findSkeletonNodes	(	const ticl::Trackster &	trackster,
		float	lower_percentage,
		float	upper_percentage,
		const std::vector< reco::CaloCluster > &	layerClusters,
		const hgcal::RecHitTools &	rhtools
	)

Definition at line 110 of file TracksterLinkingbySkeletons.cc.

References funct::abs(), ticl::Trackster::barycenter(), ticl::Trackster::eigenvectors(), dqmdumpme::first, hgcal::RecHitTools::getLayerWithOffset(), mps_fire::i, reco::helper::VirtualJetProducerHelper::intersection(), dqmiolumiharvest::j, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, ticl::Trackster::raw_energy(), jetUpdater_cfi::sort, submitPVValidationJobs::t, findQualityFiles::v, AlignmentTracksFromVertexSelector_cfi::vertices, and ticl::Trackster::vertices().

Referenced by linkTracksters().

                                     {
  auto const &vertices = trackster.vertices();
  auto const trackster_raw_energy = trackster.raw_energy();
  // sort vertices by layerId
  std::vector<unsigned int> sortedVertices(vertices);
  std::sort(sortedVertices.begin(), sortedVertices.end(), [&layerClusters](unsigned int i, unsigned int j) {
    return std::abs(layerClusters[i].z()) < std::abs(layerClusters[j].z());
  });

  // now loop over sortedVertices and find the layerId that contains the lower_percentage of the energy
  // and the layerId that contains the upper_percentage of the energy
  float cumulativeEnergyFraction = 0.f;
  int innerLayerId = rhtools.getLayerWithOffset(layerClusters[sortedVertices[0]].hitsAndFractions()[0].first);
  float innerLayerZ = layerClusters[sortedVertices[0]].z();
  int outerLayerId = rhtools.getLayerWithOffset(layerClusters[sortedVertices.back()].hitsAndFractions()[0].first);
  float outerLayerZ = layerClusters[sortedVertices.back()].z();
  bool foundInnerLayer = false;
  bool foundOuterLayer = false;
  for (auto const &v : sortedVertices) {
    auto const &lc = layerClusters[v];
    auto const &n_lay = rhtools.getLayerWithOffset(lc.hitsAndFractions()[0].first);
    cumulativeEnergyFraction += lc.energy() / trackster_raw_energy;
    if (cumulativeEnergyFraction >= lower_percentage and not foundInnerLayer) {
      innerLayerId = n_lay;
      innerLayerZ = lc.z();
      foundInnerLayer = true;
    }
    if (cumulativeEnergyFraction >= upper_percentage and not foundOuterLayer) {
      outerLayerId = n_lay;
      outerLayerZ = lc.z();
      foundOuterLayer = true;
    }
  }
  std::array<ticl::Vector, 3> skeleton;
  int minimumDistanceInLayers = 4;
  if (outerLayerId - innerLayerId < minimumDistanceInLayers) {
    skeleton = {{trackster.barycenter(), trackster.barycenter(), trackster.barycenter()}};
  } else {
    auto intersectLineWithSurface = [](float surfaceZ, const Vector &origin, const Vector &direction) -> Vector {
      auto const t = (surfaceZ - origin.Z()) / direction.Z();
      auto const iX = t * direction.X() + origin.X();
      auto const iY = t * direction.Y() + origin.Y();
      auto const iZ = surfaceZ;
      const Vector intersection(iX, iY, iZ);
      return intersection;
    };

    auto const &t0_p1 = trackster.barycenter();
    auto const t0_p0 = intersectLineWithSurface(innerLayerZ, t0_p1, trackster.eigenvectors(0));
    auto const t0_p2 = intersectLineWithSurface(outerLayerZ, t0_p1, trackster.eigenvectors(0));
    skeleton = {{t0_p0, t0_p1, t0_p2}};
    std::sort(skeleton.begin(), skeleton.end(), [](Vector &v1, Vector &v2) { return v1.Z() < v2.Z(); });
  }

  return skeleton;
}

initialize()

void TracksterLinkingbySkeletons::initialize ( const HGCalDDDConstants *  hgcons, const hgcal::RecHitTools  rhtools, const edm::ESHandle< MagneticField >  bfieldH, const edm::ESHandle< Propagator >  propH  )

overridevirtual

Implements ticl::TracksterLinkingAlgoBase.

Definition at line 98 of file TracksterLinkingbySkeletons.cc.

References bfield_, buildLayers(), hgcons_, propagator_, and rhtools_.

                                                                                  {
  hgcons_ = hgcons;
  rhtools_ = rhtools;
  buildLayers();

  bfield_ = bfieldH;
  propagator_ = propH;
}

linkTracksters()

void TracksterLinkingbySkeletons::linkTracksters ( const Inputs &  input, std::vector< Trackster > &  resultTracksters, std::vector< std::vector< unsigned int >> &  linkedResultTracksters, std::vector< std::vector< unsigned int >> &  linkedTracksterIdToInputTracksterId  )

overridevirtual

Implements ticl::TracksterLinkingAlgoBase.

Definition at line 318 of file TracksterLinkingbySkeletons.cc.

References funct::abs(), areCompatible(), ticl::Trackster::barycenter(), AlCaHLTBitMon_QueryRunRegistry::comp, makeMuonMisalignmentScenario::components, del_, egammaIdentification::eta_max, egammaIdentification::eta_min, findSkeletonNodes(), TICLGraph::findSubComponents(), mps_fire::i, input, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, WZElectronSkims53X_cff::max, ticl::TileConstants::maxEta, ticl::Trackster::mergeTracksters(), SiStripPI::min, min_num_lcs_, min_trackster_energy_, ticl::TileConstants::minEta, create_idmaps::n, ticl::TileConstants::nPhiBins, or, pca_quality_th_, rhtools_, jetUpdater_cfi::sort, HGCalTileIndex::tileIndex(), and HitToTracksterAssociation_cfi::tracksters.

                                                                             {
  const auto &tracksters = input.tracksters;
  const auto &layerClusters = input.layerClusters;

  // sort tracksters by energy
  std::vector<unsigned int> sortedTracksters(tracksters.size());
  std::iota(sortedTracksters.begin(), sortedTracksters.end(), 0);
  std::sort(sortedTracksters.begin(), sortedTracksters.end(), [&tracksters](unsigned int i, unsigned int j) {
    return tracksters[i].raw_energy() > tracksters[j].raw_energy();
  });
  // fill tiles for trackster linking
  // tile 0 for negative eta
  // tile 1 for positive eta
  std::array<TICLLayerTile, 2> tracksterTile;
  // loop over tracksters sorted by energy and calculate skeletons
  // fill tiles for trackster linking
  std::vector<std::array<ticl::Vector, 3>> skeletons(tracksters.size());
  for (auto const t_idx : sortedTracksters) {
    const auto &trackster = tracksters[t_idx];
    skeletons[t_idx] = findSkeletonNodes(tracksters[t_idx], 0.1, 0.9, layerClusters, rhtools_);
    tracksterTile[trackster.barycenter().eta() > 0.f].fill(
        trackster.barycenter().eta(), trackster.barycenter().phi(), t_idx);
  }
  std::vector<int> maskReceivedLink(tracksters.size(), 1);
  std::vector<int> isRootTracksters(tracksters.size(), 1);

  std::vector<Node> allNodes;
  for (size_t it = 0; it < tracksters.size(); ++it) {
    allNodes.emplace_back(it);
  }

  // loop over tracksters sorted by energy and link them
  for (auto const &t_idx : sortedTracksters) {
    auto const &trackster = tracksters[t_idx];
    auto const &skeleton = skeletons[t_idx];

    auto const bary = trackster.barycenter();
    float eta_min = std::max(abs(bary.eta()) - del_, TileConstants::minEta);
    float eta_max = std::min(abs(bary.eta()) + del_, TileConstants::maxEta);
    int tileIndex = bary.eta() > 0.f;
    const auto &tiles = tracksterTile[tileIndex];
    std::array<int, 4> search_box = tiles.searchBoxEtaPhi(eta_min, eta_max, bary.phi() - del_, bary.phi() + del_);
    if (search_box[2] > search_box[3]) {
      search_box[3] += TileConstants::nPhiBins;
    }

    for (int eta_i = search_box[0]; eta_i <= search_box[1]; ++eta_i) {
      for (int phi_i = search_box[2]; phi_i <= search_box[3]; ++phi_i) {
        auto &neighbours = tiles[tiles.globalBin(eta_i, (phi_i % TileConstants::nPhiBins))];
        for (auto n : neighbours) {
          if (t_idx == n)
            continue;
          if (maskReceivedLink[n] == 0 or allNodes[t_idx].isInnerNeighbour(n))
            continue;
          if (isGoodTrackster(trackster, skeleton, min_num_lcs_, min_trackster_energy_, pca_quality_th_)) {
            LogDebug("TracksterLinkingbySkeletons")
                << "Trying to Link Trackster " << t_idx << " With Trackster " << n << std::endl;
            if (areCompatible(trackster, tracksters[n], skeleton, skeletons[n])) {
              LogDebug("TracksterLinkingbySkeletons")
                  << "\t==== LINK: Trackster " << t_idx << " Linked with Trackster " << n << std::endl;
              maskReceivedLink[n] = 0;
              allNodes[t_idx].addOuterNeighbour(n);
              allNodes[n].addInnerNeighbour(t_idx);
              isRootTracksters[n] = 0;
            }
          }
        }
      }
    }
  }

  LogDebug("TracksterLinkingbySkeletons") << "****************  FINAL GRAPH **********************" << std::endl;
  for (auto const &node : allNodes) {
    if (isRootTracksters[node.getId()]) {
      LogDebug("TracksterLinkingbySkeletons")
          << "ISROOT "
          << " Node " << node.getId() << " position " << tracksters[node.getId()].barycenter() << " energy "
          << tracksters[node.getId()].raw_energy() << std::endl;
    } else {
      LogDebug("TracksterLinkingbySkeletons")
          << "Node " << node.getId() << " position " << tracksters[node.getId()].barycenter() << " energy "
          << tracksters[node.getId()].raw_energy() << std::endl;
    }
  }
  LogDebug("TracksterLinkingbySkeletons") << "********************************************************" << std::endl;

  TICLGraph graph(allNodes, isRootTracksters);

  int ic = 0;
  auto const &components = graph.findSubComponents();
  linkedTracksterIdToInputTracksterId.resize(components.size());
  for (auto const &comp : components) {
    LogDebug("TracksterLinkingbySkeletons") << "Component " << ic << " Node: ";
    std::vector<unsigned int> linkedTracksters;
    Trackster outTrackster;
    if (comp.size() == 1) {
      if (input.tracksters[comp[0]].vertices().size() <= 3) {
        continue;
      }
    }
    for (auto const &node : comp) {
      LogDebug("TracksterLinkingbySkeletons") << node << " ";
      linkedTracksterIdToInputTracksterId[ic].push_back(node);
      outTrackster.mergeTracksters(input.tracksters[node]);
    }
    linkedTracksters.push_back(resultTracksters.size());
    resultTracksters.push_back(outTrackster);
    linkedResultTracksters.push_back(linkedTracksters);
    LogDebug("TracksterLinkingbySkeletons") << "\n";
    ++ic;
  }
}  // linkTracksters

Member Data Documentation

bfield_

edm::ESHandle<MagneticField> ticl::TracksterLinkingbySkeletons::bfield_

private

Definition at line 94 of file TracksterLinkingbySkeletons.h.

Referenced by initialize().

cylinder_radius_sqr_

std::vector<double> ticl::TracksterLinkingbySkeletons::cylinder_radius_sqr_

private

Definition at line 85 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

del_

float ticl::TracksterLinkingbySkeletons::del_

private

Definition at line 76 of file TracksterLinkingbySkeletons.h.

Referenced by linkTracksters().

dot_prod_th_

float ticl::TracksterLinkingbySkeletons::dot_prod_th_

private

Definition at line 80 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

firstDisk_

std::unique_ptr<GeomDet> ticl::TracksterLinkingbySkeletons::firstDisk_[2]

private

Definition at line 89 of file TracksterLinkingbySkeletons.h.

Referenced by buildLayers().

hgcons_

const HGCalDDDConstants* ticl::TracksterLinkingbySkeletons::hgcons_

private

Definition at line 87 of file TracksterLinkingbySkeletons.h.

Referenced by buildLayers(), and initialize().

interfaceDisk_

std::unique_ptr<GeomDet> ticl::TracksterLinkingbySkeletons::interfaceDisk_[2]

private

Definition at line 90 of file TracksterLinkingbySkeletons.h.

Referenced by buildLayers().

max_distance_projective_sqr_

std::vector<double> ticl::TracksterLinkingbySkeletons::max_distance_projective_sqr_

private

Definition at line 81 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

max_distance_projective_sqr_closest_points_

std::vector<double> ticl::TracksterLinkingbySkeletons::max_distance_projective_sqr_closest_points_

private

Definition at line 83 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

max_z_distance_closest_points_

std::vector<double> ticl::TracksterLinkingbySkeletons::max_z_distance_closest_points_

private

Definition at line 84 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

min_distance_z_

std::vector<double> ticl::TracksterLinkingbySkeletons::min_distance_z_

private

Definition at line 82 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible().

min_num_lcs_

unsigned int ticl::TracksterLinkingbySkeletons::min_num_lcs_

private

Definition at line 77 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible(), and linkTracksters().

min_trackster_energy_

float ticl::TracksterLinkingbySkeletons::min_trackster_energy_

private

Definition at line 78 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible(), and linkTracksters().

pca_quality_th_

float ticl::TracksterLinkingbySkeletons::pca_quality_th_

private

Definition at line 79 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible(), and linkTracksters().

propagator_

edm::ESHandle<Propagator> ticl::TracksterLinkingbySkeletons::propagator_

private

Definition at line 95 of file TracksterLinkingbySkeletons.h.

Referenced by initialize().

rhtools_

hgcal::RecHitTools ticl::TracksterLinkingbySkeletons::rhtools_

private

Definition at line 92 of file TracksterLinkingbySkeletons.h.

Referenced by areCompatible(), buildLayers(), initialize(), and linkTracksters().

timing_quality_threshold_

float ticl::TracksterLinkingbySkeletons::timing_quality_threshold_

private

Definition at line 75 of file TracksterLinkingbySkeletons.h.