mkfit Namespace Reference

Typedefs
using	HitVec = std::vector< Hit >
using	TrackVec = std::vector< Track >

Functions
template<typename Traits , typename HitCollection >
edm::ProductID	convertHits (const Traits &traits, const HitCollection &hits, mkfit::HitVec &mkFitHits, std::vector< TrackingRecHit const * > &clusterIndexToHit, std::vector< float > &clusterChargeVec, const TrackerTopology &ttopo, const TransientTrackingRecHitBuilder &ttrhBuilder, const MkFitGeometry &mkFitGeom)
void	createPhase1TrackerGeometry (TrackerInfo &ti, IterationsInfo &ii, bool verbose)

Typedef Documentation

HitVec

using mkfit::HitVec = typedef std::vector<Hit>

Definition at line 11 of file MkFitHitWrapper.h.

TrackVec

typedef std::vector< Track > mkfit::TrackVec

Definition at line 8 of file MkFitOutputWrapper.h.

Function Documentation

convertHits()

template<typename Traits , typename HitCollection >

edm::ProductID mkfit::convertHits	(	const Traits &	traits,
		const HitCollection &	hits,
		mkfit::HitVec &	mkFitHits,
		std::vector< TrackingRecHit const * > &	clusterIndexToHit,
		std::vector< float > &	clusterChargeVec,
		const TrackerTopology &	ttopo,
		const TransientTrackingRecHitBuilder &	ttrhBuilder,
		const MkFitGeometry &	mkFitGeom
	)

Definition at line 25 of file convertHits.h.

                                                             {
    if (hits.empty())
      return edm::ProductID{};
 
    edm::ProductID clusterID;
    {
      const auto& lastClusterRef = hits.data().back().firstClusterRef();
      clusterID = lastClusterRef.id();
      if (lastClusterRef.index() >= mkFitHits.size()) {
        auto const size = lastClusterRef.index();
        mkFitHits.resize(size);
        clusterIndexToHit.resize(size, nullptr);
        if constexpr (Traits::applyCCC()) {
          clusterChargeVec.resize(size, -1.f);
        }
      }
    }
 
    for (const auto& detset : hits) {
      const DetId detid = detset.detId();
      const auto ilay = mkFitGeom.mkFitLayerNumber(detid);
 
      for (const auto& hit : detset) {
        const auto charge = traits.clusterCharge(hit, detid);
        if (!traits.passCCC(charge))
          continue;
 
        const auto& gpos = hit.globalPosition();
        SVector3 pos(gpos.x(), gpos.y(), gpos.z());
        const auto& gerr = hit.globalPositionError();
        SMatrixSym33 err;
        err.At(0, 0) = gerr.cxx();
        err.At(1, 1) = gerr.cyy();
        err.At(2, 2) = gerr.czz();
        err.At(0, 1) = gerr.cyx();
        err.At(0, 2) = gerr.czx();
        err.At(1, 2) = gerr.czy();
 
        auto clusterRef = hit.firstClusterRef();
        if UNLIKELY (clusterRef.id() != clusterID) {
          throw cms::Exception("LogicError")
              << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID
              << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId();
        }
        const auto clusterIndex = clusterRef.index();
        LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << detid.subdetId()
                                      << " layer " << ttopo.layer(detid) << " isStereo " << ttopo.isStereo(detid)
                                      << " zplus "
                                      << " index " << clusterIndex << " ilay " << ilay;
 
        if UNLIKELY (clusterIndex >= mkFitHits.size()) {
          mkFitHits.resize(clusterIndex + 1);
          clusterIndexToHit.resize(clusterIndex + 1, nullptr);
          if constexpr (Traits::applyCCC()) {
            clusterChargeVec.resize(clusterIndex + 1, -1.f);
          }
        }
        mkFitHits[clusterIndex] = mkfit::Hit(pos, err);
        clusterIndexToHit[clusterIndex] = &hit;
        if constexpr (Traits::applyCCC()) {
          clusterChargeVec[clusterIndex] = charge;
        }
 
        const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId());
        traits.setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge);
      }
    }
    return clusterID;
  }

References ALCARECOTkAlJpsiMuMu_cff::charge, submitPVResolutionJobs::err, Exception, f, hfClusterShapes_cfi::hits, edm::ProductID::id(), TrackerTopology::isStereo(), TrackerTopology::layer(), LogTrace, MkFitGeometry::mkFitLayerNumber(), DetId::rawId(), findQualityFiles::size, DetId::subdetId(), MkFitGeometry::uniqueIdInLayer(), and UNLIKELY.

Referenced by MkFitSiPixelHitConverter::produce(), and MkFitSiStripHitConverter::produce().

createPhase1TrackerGeometry()

void mkfit::createPhase1TrackerGeometry	(	TrackerInfo &	ti,
		IterationsInfo &	ii,
		bool	verbose
	)

Definition at line 179 of file createPhase1TrackerGeometry.cc.

                                                                                      {
    // TODO: these writes to global variables need to be removed
    Config::nTotalLayers = 18 + 2 * 27;
 
    Config::useCMSGeom = true;
 
    Config::finding_requires_propagation_to_hit_pos = true;
    Config::finding_inter_layer_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
    Config::finding_intra_layer_pflags = PropagationFlags(PF_none);
    Config::backward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
    Config::forward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material);
    Config::seed_fit_pflags = PropagationFlags(PF_none);
    Config::pca_prop_pflags = PropagationFlags(PF_none);
 
    ti.set_eta_regions(0.9, 1.7, 2.45, false);
    ti.create_layers(18, 27, 27);
 
    ii.resize(10);
    ii[0].set_iteration_index_and_track_algorithm(0, (int)TrackBase::TrackAlgorithm::initialStep);
    ii[0].set_num_regions_layers(5, 72);
 
    createPhase1TrackerGeometryAutoGen(ti, ii);
 
    setupSteeringParamsIter0(ii[0]);
    ii[0].m_partition_seeds = partitionSeeds0;
 
    ii[1].Clone(ii[0]);
    ii[1].set_iteration_index_and_track_algorithm(1, (int)TrackBase::TrackAlgorithm::highPtTripletStep);
 
    ii[2].Clone(ii[0]);
    ii[2].set_iteration_index_and_track_algorithm(2, (int)TrackBase::TrackAlgorithm::lowPtQuadStep);
 
    ii[3].Clone(ii[0]);
    ii[3].set_iteration_index_and_track_algorithm(3, (int)TrackBase::TrackAlgorithm::lowPtTripletStep);
 
    ii[4].Clone(ii[0]);
    ii[4].set_iteration_index_and_track_algorithm(4, (int)TrackBase::TrackAlgorithm::detachedQuadStep);
 
    ii[5].Clone(ii[0]);
    ii[5].set_iteration_index_and_track_algorithm(5, (int)TrackBase::TrackAlgorithm::detachedTripletStep);
 
    ii[6].Clone(ii[0]);
    ii[6].set_iteration_index_and_track_algorithm(6, (int)TrackBase::TrackAlgorithm::mixedTripletStep);
 
    ii[7].Clone(ii[0]);
    ii[7].set_iteration_index_and_track_algorithm(7, (int)TrackBase::TrackAlgorithm::pixelLessStep);
 
    ii[8].Clone(ii[0]);
    ii[8].set_iteration_index_and_track_algorithm(8, (int)TrackBase::TrackAlgorithm::tobTecStep);
 
    ii[9].Clone(ii[0]);
    ii[9].set_iteration_index_and_track_algorithm(9, (int)TrackBase::TrackAlgorithm::pixelPairStep);
 
    // for iters [7] and [8]: investing in maxCand & stop condition (for time) + QF and Dupl. cleaning (for quality)
 
    // TODO: replace with MessageLogger
    if (verbose) {
      printf("==========================================================================================\n");
      printf("Phase1 tracker -- Create_TrackerInfo finished\n");
      printf("==========================================================================================\n");
      for (auto &i : ti.m_layers)
        i.print_layer();
      printf("==========================================================================================\n");
    }
  }

References DetachedQuadStep_cff::detachedQuadStep, DetachedTripletStep_cff::detachedTripletStep, HighPtTripletStep_cff::highPtTripletStep, mps_fire::i, cuy::ii, InitialStep_cff::initialStep, LowPtQuadStep_cff::lowPtQuadStep, LowPtTripletStep_cff::lowPtTripletStep, MixedTripletStep_cff::mixedTripletStep, PixelLessStep_cff::pixelLessStep, PixelPairStep_cff::pixelPairStep, TobTecStep_cff::tobTecStep, and verbose.

Referenced by MkFitGeometryESProducer::produce().