TrajectorySegmentBuilder Class Reference

#include <TrajectorySegmentBuilder.h>

Public Member Functions
TempTrajectoryContainer	segments (const TSOS startingState)
	new segments within layer More...
	TrajectorySegmentBuilder (const LayerMeasurements *theInputLayerMeasurements, const DetLayer &layer, const Propagator &propagator, const TrajectoryStateUpdator &updator, const MeasurementEstimator &estimator, bool lockHits, bool bestHitOnly, int maxCand)
	constructor from layer and helper objects More...
	~TrajectorySegmentBuilder ()
	destructor More...

Private Types
typedef TransientTrackingRecHit::ConstRecHitContainer	ConstRecHitContainer
typedef TransientTrackingRecHit::ConstRecHitPointer	ConstRecHitPointer
typedef FreeTrajectoryState	FTS
typedef std::vector< TempTrajectory >	TempTrajectoryContainer
typedef TrajectoryMeasurement	TM
typedef TrajectoryMeasurementGroup	TMG
typedef std::vector< Trajectory >	TrajectoryContainer
typedef TrajectoryStateOnSurface	TSOS

Private Member Functions
std::vector< TempTrajectory >	addGroup (TempTrajectory const &traj, std::vector< TrajectoryMeasurementGroup >::const_iterator begin, std::vector< TrajectoryMeasurementGroup >::const_iterator end)
void	cleanCandidates (std::vector< TempTrajectory > &candidates) const
	clean a set of candidates More...
void	lockMeasurement (const TM &measurement)
	mark a hit as used More...
std::vector< TrajectoryMeasurement >	redoMeasurements (const TempTrajectory &traj, const DetGroup &detGroup) const
	retrieve compatible hits from a DetGroup More...
std::vector< TrajectoryMeasurement >	unlockedMeasurements (const std::vector< TM > &measurements) const
	get list of unused hits More...
void	updateCandidates (TempTrajectory const &traj, const std::vector< TM > &measurements, TempTrajectoryContainer &candidates)
	creation of new candidates from a segment and a collection of hits More...
void	updateCandidatesWithBestHit (TempTrajectory const &traj, TM measurements, TempTrajectoryContainer &candidates)
	creation of a new candidate from a segment and the best hit out of a collection More...
void	updateTrajectory (TempTrajectory &traj, TM tm) const
	update of a trajectory with a hit More...
void	updateWithInvalidHit (TempTrajectory &traj, const std::vector< TMG > &groups, TempTrajectoryContainer &candidates) const

Private Attributes
bool	theBestHitOnly
bool	theDbgFlg
const MeasurementEstimator &	theEstimator
const Propagator &	theFullPropagator
const Propagator &	theGeomPropagator
const DetLayer &	theLayer
const LayerMeasurements *	theLayerMeasurements
ConstRecHitContainer	theLockedHits
bool	theLockHits
int	theMaxCand
const TrajectoryStateUpdator &	theUpdator

Detailed Description

Definition at line 31 of file TrajectorySegmentBuilder.h.

Member Typedef Documentation

ConstRecHitContainer

typedef TransientTrackingRecHit::ConstRecHitContainer TrajectorySegmentBuilder::ConstRecHitContainer

private

Definition at line 40 of file TrajectorySegmentBuilder.h.

ConstRecHitPointer

typedef TransientTrackingRecHit::ConstRecHitPointer TrajectorySegmentBuilder::ConstRecHitPointer

private

Definition at line 41 of file TrajectorySegmentBuilder.h.

FTS

typedef FreeTrajectoryState TrajectorySegmentBuilder::FTS

private

Definition at line 34 of file TrajectorySegmentBuilder.h.

TempTrajectoryContainer

typedef std::vector<TempTrajectory> TrajectorySegmentBuilder::TempTrajectoryContainer

private

Definition at line 39 of file TrajectorySegmentBuilder.h.

TM

typedef TrajectoryMeasurement TrajectorySegmentBuilder::TM

private

Definition at line 36 of file TrajectorySegmentBuilder.h.

TMG

typedef TrajectoryMeasurementGroup TrajectorySegmentBuilder::TMG

private

Definition at line 37 of file TrajectorySegmentBuilder.h.

TrajectoryContainer

typedef std::vector<Trajectory> TrajectorySegmentBuilder::TrajectoryContainer

private

Definition at line 38 of file TrajectorySegmentBuilder.h.

TSOS

typedef TrajectoryStateOnSurface TrajectorySegmentBuilder::TSOS

private

Definition at line 35 of file TrajectorySegmentBuilder.h.

Constructor & Destructor Documentation

TrajectorySegmentBuilder()

TrajectorySegmentBuilder::TrajectorySegmentBuilder ( const LayerMeasurements *  theInputLayerMeasurements, const DetLayer &  layer, const Propagator &  propagator, const TrajectoryStateUpdator &  updator, const MeasurementEstimator &  estimator, bool  lockHits, bool  bestHitOnly, int  maxCand  )

inline

constructor from layer and helper objects

Definition at line 45 of file TrajectorySegmentBuilder.h.

      : theLayerMeasurements(theInputLayerMeasurements),
        theLayer(layer),
        theFullPropagator(propagator),
        theUpdator(updator),
        theEstimator(estimator),
        theGeomPropagator(propagator),
        //     theGeomPropagator(propagator.propagationDirection()),
        theLockHits(lockHits),
        theBestHitOnly(bestHitOnly),
        theMaxCand(maxCand) {}

~TrajectorySegmentBuilder()

TrajectorySegmentBuilder::~TrajectorySegmentBuilder ( )

inline

destructor

Definition at line 65 of file TrajectorySegmentBuilder.h.

{}

Member Function Documentation

addGroup()

TrajectorySegmentBuilder::TempTrajectoryContainer TrajectorySegmentBuilder::addGroup ( TempTrajectory const &  traj, std::vector< TrajectoryMeasurementGroup >::const_iterator  begin, std::vector< TrajectoryMeasurementGroup >::const_iterator  end  )

private

Definition at line 215 of file TrajectorySegmentBuilder.cc.

References gather_cfg::cout, cmsutils::bqueue< T >::empty(), TempTrajectory::empty(), TempTrajectory::measurements(), eostools::move(), runTheMatrix::ret, cmsutils::bqueue< T >::size(), submitPVValidationJobs::t, and UNLIKELY.

                                                                                                                    {
  vector<TempTrajectory> ret;
  if (begin == end) {
    //std::cout << "TrajectorySegmentBuilder::addGroup" << " traj.empty()=" << traj.empty() << "EMPTY" << std::endl;
    if UNLIKELY (theDbgFlg)
      cout << "TSB::addGroup : no groups left" << endl;
    if (!traj.empty())
      ret.push_back(traj);
    return ret;
  }

  if UNLIKELY (theDbgFlg)
    cout << "TSB::addGroup : traj.size() = " << traj.measurements().size() << " first group at "
         << &(*begin)
         //        << " nr. of candidates = " << candidates.size()
         << endl;

  TempTrajectoryContainer updatedTrajectories;
  updatedTrajectories.reserve(2);
  if (traj.measurements().empty()) {
    if (theMaxCand == 1) {
      auto&& firstMeasurements = unlockedMeasurements(begin->measurements());
      if (!firstMeasurements.empty())
        updateCandidatesWithBestHit(traj, std::move(firstMeasurements.front()), updatedTrajectories);
    } else {
      updateCandidates(traj, begin->measurements(), updatedTrajectories);
    }
    if UNLIKELY (theDbgFlg)
      cout << "TSB::addGroup : updating with first group - " << updatedTrajectories.size() << " trajectories" << endl;
  } else {
    auto&& meas = redoMeasurements(traj, begin->detGroup());
    if (!meas.empty()) {
      if (theBestHitOnly) {
        updateCandidatesWithBestHit(traj, std::move(meas.front()), updatedTrajectories);
      } else {
        updateCandidates(traj, meas, updatedTrajectories);
      }
      if UNLIKELY (theDbgFlg)
        cout << "TSB::addGroup : updating" << updatedTrajectories.size() << " trajectories-1" << endl;
    }
  }
  // keep old trajectory
  //
  updatedTrajectories.push_back(traj);

  if (begin + 1 != end) {
    ret.reserve(4);  // a good upper bound
    for (auto const& ut : updatedTrajectories) {
      if UNLIKELY (theDbgFlg)
        cout << "TSB::addGroup : trying to extend candidate at " << &ut << " size " << ut.measurements().size() << endl;
      vector<TempTrajectory>&& finalTrajectories = addGroup(ut, begin + 1, end);
      if UNLIKELY (theDbgFlg)
        cout << "TSB::addGroup : " << finalTrajectories.size() << " finalised candidates before cleaning" << endl;
      //B.M. to be ported later
      // V.I. only mark invalidate
      cleanCandidates(finalTrajectories);

      if UNLIKELY (theDbgFlg) {
        int ntf = 0;
        for (auto const& t : finalTrajectories)
          if (t.isValid())
            ++ntf;
        cout << "TSB::addGroup : got " << ntf << " finalised candidates" << endl;
      }

      for (auto& t : finalTrajectories)
        if (t.isValid())
          ret.push_back(std::move(t));

      //        ret.insert(ret.end(),make_move_iterator(finalTrajectories.begin()),
      //       make_move_iterator(finalTrajectories.end()));
    }
  } else {
    ret.reserve(updatedTrajectories.size());
    for (auto& t : updatedTrajectories)
      if (!t.empty())
        ret.push_back(std::move(t));
  }

  //std::cout << "TrajectorySegmentBuilder::addGroup" <<
  //             " traj.empty()=" << traj.empty() <<
  //             " end-begin=" << (end-begin)  <<
  //             " #updated=" << updatedTrajectories.size() <<
  //             " #result=" << ret.size() << std::endl;
  return ret;
}

cleanCandidates()

void TrajectorySegmentBuilder::cleanCandidates ( std::vector< TempTrajectory > &  candidates ) const

private

clean a set of candidates

Definition at line 472 of file TrajectorySegmentBuilder.cc.

References TrackingRecHit::all, HLT_2023v12_cff::candidates, newFWLiteAna::found, mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, dqmiolumiharvest::j, lessByFoundHits(), cmsutils::bqueue< T >::rbegin(), cmsutils::bqueue< T >::rend(), and jetUpdater_cfi::sort.

                                                                                       {
  //
  // remove candidates which are subsets of others
  // assumptions: no invalid hits and no duplicates
  //
  if (candidates.size() <= 1)
    return;
  //RecHitEqualByChannels recHitEqual(false,true);
  //
  const int NC = candidates.size();
  int index[NC];
  for (int i = 0; i != NC; ++i)
    index[i] = i;
  std::sort(index, index + NC, [&candidates](int i, int j) { return lessByFoundHits(candidates[i], candidates[j]); });
  //   cout << "SortedCandidates.foundHits";
  //   for (auto i1 : index)
  //     cout << " " << candidates[i1].foundHits();
  //   cout << endl;
  //
  for (auto i1 = index; i1 != index + NC - 1; ++i1) {
    // get measurements of candidate to be checked
    const TempTrajectory::DataContainer& measurements1 = candidates[*i1].measurements();
    for (auto i2 = i1 + 1; i2 != index + NC; ++i2) {
      // no duplicates: two candidates of same size are different
      if (candidates[*i2].foundHits() == candidates[*i1].foundHits())
        continue;
      // get measurements of "reference"
      const TempTrajectory::DataContainer& measurements2 = candidates[*i2].measurements();
      //
      // use the fact that TMs are ordered:
      // start search in trajectory#1 from last hit match found
      //
      bool allFound(true);
      TempTrajectory::DataContainer::const_iterator from2 = measurements2.rbegin(), im2end = measurements2.rend();
      for (TempTrajectory::DataContainer::const_iterator im1 = measurements1.rbegin(), im1end = measurements1.rend();
           im1 != im1end;
           --im1) {
        // redundant protection - segments should not contain invalid RecHits
        // assert( im1->recHit()->isValid());
        bool found(false);
        for (TempTrajectory::DataContainer::const_iterator im2 = from2; im2 != im2end; --im2) {
          // redundant protection - segments should not contain invalid RecHits
          // assert (im2->recHit()->isValid());
          if (im1->recHitR().hit()->sharesInput(im2->recHitR().hit(), TrackingRecHit::all)) {
            found = true;
            from2 = im2;
            --from2;
            break;
          }
        }
        if (!found) {
          allFound = false;
          break;
        }
      }
      if (allFound) {
        candidates[*i1].invalidate();
        statCount.invalid();
      }
    }
  }
}

lockMeasurement()

void TrajectorySegmentBuilder::lockMeasurement ( const TM &  measurement )

private

mark a hit as used

Definition at line 469 of file TrajectorySegmentBuilder.cc.

References TrajectoryMeasurement::recHit().

{ theLockedHits.push_back(measurement.recHit()); }

redoMeasurements()

vector< TrajectoryMeasurement > TrajectorySegmentBuilder::redoMeasurements ( const TempTrajectory &  traj, const DetGroup &  detGroup  ) const

private

retrieve compatible hits from a DetGroup

Definition at line 332 of file TrajectorySegmentBuilder.cc.

References tracking::TempMeasurements::clear(), gather_cfg::cout, tracking::TempMeasurements::distances, tracking::TempMeasurements::hits, mps_fire::i, GeomDetCompatibilityChecker::isCompatible(), TempTrajectory::lastMeasurement(), MeasurementDetWithData::measurements(), eostools::move(), mps_fire::result, tracking::TempMeasurements::size(), jetUpdater_cfi::sort, UNLIKELY, and TrajectoryMeasurement::updatedState().

                                                                                                         {
  vector<TM> result;
  //
  // loop over all dets
  //
  if UNLIKELY (theDbgFlg)
    cout << "TSB::redoMeasurements : nr. of measurements / group =";

  tracking::TempMeasurements tmps;

  for (auto const& det : detGroup) {
    pair<bool, TrajectoryStateOnSurface> compat = GeomDetCompatibilityChecker().isCompatible(
        det.det(), traj.lastMeasurement().updatedState(), theGeomPropagator, theEstimator);

    if UNLIKELY (theDbgFlg && !compat.first)
      std::cout << " 0";

    if (!compat.first)
      continue;

    MeasurementDetWithData mdet = theLayerMeasurements->idToDet(det.det()->geographicalId());
    // verify also that first (and only!) not be inactive..
    if (mdet.measurements(compat.second, theEstimator, tmps) && tmps.hits[0]->isValid())
      for (std::size_t i = 0; i != tmps.size(); ++i)
        result.emplace_back(compat.second, std::move(tmps.hits[i]), tmps.distances[i], &theLayer);

    if UNLIKELY (theDbgFlg)
      std::cout << " " << tmps.size();
    tmps.clear();
  }

  if UNLIKELY (theDbgFlg)
    cout << endl;

  std::sort(result.begin(), result.end(), TrajMeasLessEstim());

  return result;
}

segments()

TrajectorySegmentBuilder::TempTrajectoryContainer TrajectorySegmentBuilder::segments

(

const TSOS

startingState

)

new segments within layer

Definition at line 65 of file TrajectorySegmentBuilder.cc.

References HLT_2023v12_cff::candidates, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), gather_cfg::cout, LIKELY, TrajectoryStateOnSurface::localError(), visualization-live-secondInstance_cfg::m, LocalTrajectoryError::matrix(), Skims_PA_cff::name, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::ntot, HLT_2023v12_cff::truncate, and UNLIKELY.

                                                                                                           {
  //
  // create empty trajectory
  //
  theLockedHits.clear();
  TempTrajectory startingTrajectory(theFullPropagator.propagationDirection(), 0);
  //
  // get measurement groups
  //
  auto&& measGroups =
      theLayerMeasurements->groupedMeasurements(theLayer, startingState, theFullPropagator, theEstimator);

#ifdef DBG_TSB
  cout << "TSB: number of measurement groups = " << measGroups.size() << endl;
  //  theDbgFlg = measGroups.size()>1;
  theDbgFlg = true;
#else
  theDbgFlg = false;
#endif

#ifdef TSB_TRUNCATE
  //  V.I. to me makes things slower...

  //
  // check number of combinations
  //
  constexpr long long MAXCOMB = 100000000;
  long long ncomb(1);
  int ngrp(0);
  bool truncate(false);
  for (auto const& gr : measGroups) {
    ++ngrp;
    int nhit(0);
    for (auto const& m : gr.measurements())
      if LIKELY (m.recHitR().isValid())
        nhit++;

    if (nhit > 1)
      ncomb *= nhit;
    if UNLIKELY (ncomb > MAXCOMB) {
      edm::LogInfo("TrajectorySegmentBuilder")
          << " found " << measGroups.size() << " groups and more than " << static_cast<unsigned int>(MAXCOMB)
          << " combinations - limiting to " << (ngrp - 1) << " groups";
      truncate = true;

      statCount.truncated();

      break;
    }
  }
  //   cout << "Groups / combinations = " << measGroups.size() << " " << ncomb << endl;
  if UNLIKELY (truncate && ngrp > 0)
    measGroups.resize(ngrp - 1);

#endif

#ifdef DBG_TSB
  if (theDbgFlg) {
    int ntot(1);
    for (vector<TMG>::const_iterator ig = measGroups.begin(); ig != measGroups.end(); ++ig) {
      int ngrp(0);
      const vector<TM>& measurements = ig->measurements();
      for (vector<TM>::const_iterator im = measurements.begin(); im != measurements.end(); ++im) {
        if (im->recHit()->isValid())
          ngrp++;
      }
      cout << " " << ngrp;
      if (ngrp > 0)
        ntot *= ngrp;
    }
    cout << endl;
    cout << "TrajectorySegmentBuilder::partialTrajectories:: det ids & hit types / group" << endl;
    for (vector<TMG>::const_iterator ig = measGroups.begin(); ig != measGroups.end(); ++ig) {
      const vector<TM>& measurements = ig->measurements();
      for (vector<TM>::const_iterator im = measurements.begin(); im != measurements.end(); ++im) {
        if (im != measurements.begin())
          cout << " / ";
        if (im->recHit()->det())
          cout << im->recHit()->det()->geographicalId().rawId() << " " << im->recHit()->getType();
        else
          cout << "no det";
      }
      cout << endl;
    }

    //   if ( measGroups.size()>4 ) {
    cout << typeid(theLayer).name() << endl;
    cout << startingState.localError().matrix() << endl;
    //     for (vector<TMG>::const_iterator ig=measGroups.begin();
    //   ig!=measGroups.end(); ig++) {
    //       cout << "Nr. of measurements = " << ig->measurements().size() << endl;
    //       const DetGroup& dg = ig->detGroup();
    //       for ( DetGroup::const_iterator id=dg.begin();
    //      id!=dg.end(); id++ ) {
    //  GlobalPoint p(id->det()->position());
    //  GlobalVector v(id->det()->toGlobal(LocalVector(0.,0.,1.)));
    //  cout << p.perp() << " " << p.phi() << " " << p.z() << " ; "
    //       << v.phi() << " " << v.z() << endl;
    //       }
    //     }
    //   }
  }
#endif

  TempTrajectoryContainer candidates = addGroup(startingTrajectory, measGroups.begin(), measGroups.end());

  if UNLIKELY (theDbgFlg)
    cout << "TSB: back with " << candidates.size() << " candidates" << endl;

  //
  // add invalid hit - try to get first detector hit by the extrapolation
  //

  updateWithInvalidHit(startingTrajectory, measGroups, candidates);

  if UNLIKELY (theDbgFlg)
    cout << "TSB: " << candidates.size() << " candidates after invalid hit" << endl;

  statCount.incr(measGroups.size(), candidates.size(), theLockedHits.size());

  theLockedHits.clear();

  return candidates;
}

unlockedMeasurements()

vector< TrajectoryMeasurement > TrajectorySegmentBuilder::unlockedMeasurements ( const std::vector< TM > &  measurements ) const

private

get list of unused hits

Definition at line 442 of file TrajectorySegmentBuilder.cc.

References TrackingRecHit::all, newFWLiteAna::found, h, LIKELY, visualization-live-secondInstance_cfg::m, mps_fire::result, and UNLIKELY.

                                                                                                                 {
  //   if ( !theLockHits )  return measurements;

  vector<TM> result;
  result.reserve(measurements.size());

  //RecHitEqualByChannels recHitEqual(false,true);

  for (auto const& m : measurements) {
    auto const& testHit = m.recHitR();
    if UNLIKELY (!testHit.isValid())
      continue;
    bool found(false);
    if LIKELY (theLockHits) {
      for (auto const& h : theLockedHits) {
        if (h->hit()->sharesInput(testHit.hit(), TrackingRecHit::all)) {
          found = true;
          break;
        }
      }
    }
    if LIKELY (!found)
      result.push_back(m);
  }
  return result;
}

updateCandidates()

void TrajectorySegmentBuilder::updateCandidates ( TempTrajectory const &  traj, const std::vector< TM > &  measurements, TempTrajectoryContainer &  candidates  )

private

creation of new candidates from a segment and a collection of hits

Definition at line 304 of file TrajectorySegmentBuilder.cc.

References HLT_2023v12_cff::candidates.

                                                                                     {
  //
  // generate updated candidates with all valid hits
  //
  for (auto im = measurements.begin(); im != measurements.end(); ++im) {
    if (im->recHit()->isValid()) {
      candidates.push_back(traj);
      updateTrajectory(candidates.back(), *im);
      if (theLockHits)
        lockMeasurement(*im);
    }
  }
}

updateCandidatesWithBestHit()

void TrajectorySegmentBuilder::updateCandidatesWithBestHit ( TempTrajectory const &  traj, TM  measurements, TempTrajectoryContainer &  candidates  )

private

creation of a new candidate from a segment and the best hit out of a collection

Definition at line 320 of file TrajectorySegmentBuilder.cc.

References HLT_2023v12_cff::candidates, and eostools::move().

                                                                                                {
  // here we arrive with only valid hits and sorted.
  //so the best is the first!

  if (theLockHits)
    lockMeasurement(measurement);
  candidates.push_back(traj);
  updateTrajectory(candidates.back(), std::move(measurement));
}

updateTrajectory()

void TrajectorySegmentBuilder::updateTrajectory ( TempTrajectory &  traj, TM  tm  ) const

private

update of a trajectory with a hit

Definition at line 190 of file TrajectorySegmentBuilder.cc.

References TempTrajectory::emplace(), TrajectoryMeasurement::estimate(), TrajectoryMeasurement::layer(), eostools::move(), TrajectoryMeasurement::predictedState(), and TrajectoryMeasurement::recHit().

                                                                                 {
  auto&& predictedState = tm.predictedState();
  auto&& hit = tm.recHit();

  if (hit->isValid()) {
    auto&& upState = theUpdator.update(predictedState, *hit);
    traj.emplace(predictedState, std::move(upState), hit, tm.estimate(), tm.layer());

    //     TrajectoryMeasurement tm(traj.lastMeasurement());
    //     if ( tm.updatedState().isValid() ) {
    //       if ( !hit.det().surface()->bounds().inside(tm.updatedState().localPosition(),
    //                      tm.updatedState().localError().positionError(),3.f) ) {
    //  cout << "Incompatibility after update for det at " << hit.det().position() << ":" << endl;
    //  cout << tm.predictedState().localPosition() << " "
    //       << tm.predictedState().localError().positionError() << endl;
    //  cout << hit.localPosition() << " " << hit.localPositionError() << endl;
    //  cout << tm.updatedState().localPosition() << " "
    //       << tm.updatedState().localError().positionError() << endl;
    //       }
    //     }
  } else {
    traj.emplace(predictedState, hit, 0, tm.layer());
  }
}

updateWithInvalidHit()

void TrajectorySegmentBuilder::updateWithInvalidHit ( TempTrajectory &  traj, const std::vector< TMG > &  groups, TempTrajectoryContainer &  candidates  ) const

private

Definition at line 372 of file TrajectorySegmentBuilder.cc.

References HLT_2023v12_cff::candidates, gather_cfg::cout, align_cfg::iteration, LIKELY, TrackingRecHit::missing, UNLIKELY, and TrackingRecHit::valid.

                                                                                               {
  //
  // first try to find an inactive hit with dets crossed by the prediction,
  //   then take any inactive hit
  //
  // loop over groups
  for (int iteration = 0; iteration < 2; iteration++) {
    for (auto const& gr : groups) {
      auto const& measurements = gr.measurements();
      for (auto im = measurements.rbegin(); im != measurements.rend(); ++im) {
        auto const& hit = im->recHitR();
        if ((hit.getType() == TrackingRecHit::valid) || (hit.getType() == TrackingRecHit::missing))
          continue;
        //
        // check, if the extrapolation traverses the Det or
        // if 2nd iteration
        //
        if (hit.det()) {
          auto const& predState = im->predictedState();
          if (iteration > 0 ||
              (predState.isValid() && hit.det()->surface().bounds().inside(predState.localPosition()))) {
            // add the hit
            candidates.push_back(traj);
            updateTrajectory(candidates.back(), *im);
            if UNLIKELY (theDbgFlg)
              cout << "TrajectorySegmentBuilder::updateWithInvalidHit "
                   << "added inactive hit" << endl;
            return;
          }
        }
      }
    }
  }
  //
  // No suitable inactive hit: add a missing one
  //
  for (int iteration = 0; iteration < 2; iteration++) {
    //
    // loop over groups
    //
    for (auto const& gr : groups) {
      auto const& measurements = gr.measurements();
      for (auto im = measurements.rbegin(); im != measurements.rend(); ++im) {
        // only use invalid hits
        auto const& hit = im->recHitR();
        if LIKELY (hit.isValid())
          continue;

        // check, if the extrapolation traverses the Det
        auto const& predState = im->predictedState();
        if (iteration > 0 || (predState.isValid() && hit.surface()->bounds().inside(predState.localPosition()))) {
          // add invalid hit
          candidates.push_back(traj);
          updateTrajectory(candidates.back(), *im);
          return;
        }
      }
    }
    if UNLIKELY (theDbgFlg && iteration == 0)
      cout << "TrajectorySegmentBuilder::updateWithInvalidHit: "
           << " did not find invalid hit on 1st iteration" << endl;
  }

  if UNLIKELY (theDbgFlg)
    cout << "TrajectorySegmentBuilder::updateWithInvalidHit: "
         << " did not find invalid hit" << endl;
}

Member Data Documentation

theBestHitOnly

bool TrajectorySegmentBuilder::theBestHitOnly

private

Definition at line 116 of file TrajectorySegmentBuilder.h.

theDbgFlg

bool TrajectorySegmentBuilder::theDbgFlg

private

Definition at line 120 of file TrajectorySegmentBuilder.h.

theEstimator

const MeasurementEstimator& TrajectorySegmentBuilder::theEstimator

private

Definition at line 111 of file TrajectorySegmentBuilder.h.

theFullPropagator

const Propagator& TrajectorySegmentBuilder::theFullPropagator

private

Definition at line 109 of file TrajectorySegmentBuilder.h.

theGeomPropagator

const Propagator& TrajectorySegmentBuilder::theGeomPropagator

private

Definition at line 113 of file TrajectorySegmentBuilder.h.

theLayer

const DetLayer& TrajectorySegmentBuilder::theLayer

private

Definition at line 108 of file TrajectorySegmentBuilder.h.

theLayerMeasurements

const LayerMeasurements* TrajectorySegmentBuilder::theLayerMeasurements

private

Definition at line 107 of file TrajectorySegmentBuilder.h.

theLockedHits

ConstRecHitContainer TrajectorySegmentBuilder::theLockedHits

private

Definition at line 118 of file TrajectorySegmentBuilder.h.

theLockHits

bool TrajectorySegmentBuilder::theLockHits

private

Definition at line 115 of file TrajectorySegmentBuilder.h.

theMaxCand

int TrajectorySegmentBuilder::theMaxCand

private

Definition at line 117 of file TrajectorySegmentBuilder.h.

theUpdator

const TrajectoryStateUpdator& TrajectorySegmentBuilder::theUpdator

private

Definition at line 110 of file TrajectorySegmentBuilder.h.