GlobalCosmicMuonTrajectoryBuilder Class Reference

#include <GlobalCosmicMuonTrajectoryBuilder.h>

Inheritance diagram for GlobalCosmicMuonTrajectoryBuilder:

Public Types
typedef MuonTransientTrackingRecHit::ConstMuonRecHitContainer	ConstMuonRecHitContainer
typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer	ConstMuonRecHitPointer
typedef TransientTrackingRecHit::ConstRecHitContainer	ConstRecHitContainer
typedef TransientTrackingRecHit::ConstRecHitPointer	ConstRecHitPointer
typedef MuonTransientTrackingRecHit::MuonRecHitContainer	MuonRecHitContainer
typedef MuonTransientTrackingRecHit::MuonRecHitPointer	MuonRecHitPointer
typedef TransientTrackingRecHit::RecHitContainer	RecHitContainer
typedef TransientTrackingRecHit::RecHitPointer	RecHitPointer
typedef std::pair< const Trajectory *, reco::TrackRef >	TrackCand
Public Types inherited from MuonTrajectoryBuilder
typedef MuonCandidate::CandidateContainer	CandidateContainer
typedef std::pair< const Trajectory *, reco::TrackRef >	TrackCand
typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Public Member Functions
	GlobalCosmicMuonTrajectoryBuilder (const edm::ParameterSet &, const MuonServiceProxy *service, edm::ConsumesCollector &iC)
	Constructor. More...
std::vector< TrackCand >	match (const TrackCand &, const edm::Handle< reco::TrackCollection > &)
	check if tk and muon Tracks are matched More...
const Propagator *	propagator () const
void	setEvent (const edm::Event &) override
	pass the Event to the algo at each event More...
TrajectoryContainer	trajectories (const TrajectorySeed &) override
	dummy implementation, unused in this class More...
CandidateContainer	trajectories (const TrackCand &) override
	choose tk Track and build combined trajectories More...
	~GlobalCosmicMuonTrajectoryBuilder () override
	Destructor. More...
Public Member Functions inherited from MuonTrajectoryBuilder
	MuonTrajectoryBuilder ()
	constructor More...
virtual	~MuonTrajectoryBuilder ()
	destructor More...

Private Member Functions
ConstRecHitContainer	getTransientRecHits (const reco::Track &) const
bool	isTraversing (const reco::Track &tk) const
CosmicMuonSmoother *	smoother () const
void	sortHits (ConstRecHitContainer &, ConstRecHitContainer &, ConstRecHitContainer &)
const CosmicMuonUtilities *	utilities () const

Private Attributes
const std::vector< Trajectory > *	allTrackerTrajs
std::string	category_
edm::ESHandle< TransientTrackingRecHitBuilder >	theMuonRecHitBuilder
const edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theMuonRecHitBuilderToken
std::string	thePropagatorName
const MuonServiceProxy *	theService
CosmicMuonSmoother *	theSmoother
edm::EDGetTokenT< reco::TrackCollection >	theTkTrackToken
edm::ESHandle< TransientTrackingRecHitBuilder >	theTrackerRecHitBuilder
const edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theTrackerRecHitBuilderToken
edm::Handle< reco::TrackCollection >	theTrackerTracks
GlobalMuonTrackMatcher *	theTrackMatcher
bool	tkTrajsAvailable

Detailed Description

Definition at line 37 of file GlobalCosmicMuonTrajectoryBuilder.h.

Member Typedef Documentation

ConstMuonRecHitContainer

typedef MuonTransientTrackingRecHit::ConstMuonRecHitContainer GlobalCosmicMuonTrajectoryBuilder::ConstMuonRecHitContainer

Definition at line 47 of file GlobalCosmicMuonTrajectoryBuilder.h.

ConstMuonRecHitPointer

typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer GlobalCosmicMuonTrajectoryBuilder::ConstMuonRecHitPointer

Definition at line 45 of file GlobalCosmicMuonTrajectoryBuilder.h.

ConstRecHitContainer

typedef TransientTrackingRecHit::ConstRecHitContainer GlobalCosmicMuonTrajectoryBuilder::ConstRecHitContainer

Definition at line 40 of file GlobalCosmicMuonTrajectoryBuilder.h.

ConstRecHitPointer

typedef TransientTrackingRecHit::ConstRecHitPointer GlobalCosmicMuonTrajectoryBuilder::ConstRecHitPointer

Definition at line 42 of file GlobalCosmicMuonTrajectoryBuilder.h.

MuonRecHitContainer

typedef MuonTransientTrackingRecHit::MuonRecHitContainer GlobalCosmicMuonTrajectoryBuilder::MuonRecHitContainer

Definition at line 46 of file GlobalCosmicMuonTrajectoryBuilder.h.

MuonRecHitPointer

typedef MuonTransientTrackingRecHit::MuonRecHitPointer GlobalCosmicMuonTrajectoryBuilder::MuonRecHitPointer

Definition at line 44 of file GlobalCosmicMuonTrajectoryBuilder.h.

RecHitContainer

typedef TransientTrackingRecHit::RecHitContainer GlobalCosmicMuonTrajectoryBuilder::RecHitContainer

Definition at line 39 of file GlobalCosmicMuonTrajectoryBuilder.h.

RecHitPointer

typedef TransientTrackingRecHit::RecHitPointer GlobalCosmicMuonTrajectoryBuilder::RecHitPointer

Definition at line 41 of file GlobalCosmicMuonTrajectoryBuilder.h.

TrackCand

typedef std::pair<const Trajectory*, reco::TrackRef> GlobalCosmicMuonTrajectoryBuilder::TrackCand

Definition at line 48 of file GlobalCosmicMuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

GlobalCosmicMuonTrajectoryBuilder()

GlobalCosmicMuonTrajectoryBuilder::GlobalCosmicMuonTrajectoryBuilder	(	const edm::ParameterSet &	par,
		const MuonServiceProxy *	service,
		edm::ConsumesCollector &	iC
	)

Constructor.

Definition at line 29 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References category_, edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), HLT_2022v11_cff::GlobalMuonTrackMatcher, thePropagatorName, theService, theSmoother, theTkTrackToken, and theTrackMatcher.

    : theService(service),
      theTrackerRecHitBuilderToken(
          iC.esConsumes(edm::ESInputTag("", par.getParameter<string>("TrackerRecHitBuilder")))),
      theMuonRecHitBuilderToken(iC.esConsumes(edm::ESInputTag("", par.getParameter<string>("MuonRecHitBuilder")))) {
  ParameterSet smootherPSet = par.getParameter<ParameterSet>("SmootherParameters");
  theSmoother = new CosmicMuonSmoother(smootherPSet, theService);

  ParameterSet trackMatcherPSet = par.getParameter<ParameterSet>("GlobalMuonTrackMatcher");
  theTrackMatcher = new GlobalMuonTrackMatcher(trackMatcherPSet, theService);

  theTkTrackToken = iC.consumes<reco::TrackCollection>(par.getParameter<InputTag>("TkTrackCollectionLabel"));

  thePropagatorName = par.getParameter<string>("Propagator");
  category_ = "Muon|RecoMuon|CosmicMuon|GlobalCosmicMuonTrajectoryBuilder";
}

~GlobalCosmicMuonTrajectoryBuilder()

GlobalCosmicMuonTrajectoryBuilder::~GlobalCosmicMuonTrajectoryBuilder ( )

override

Destructor.

Definition at line 52 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References theSmoother, and theTrackMatcher.

                                                                      {
  if (theSmoother)
    delete theSmoother;
  if (theTrackMatcher)
    delete theTrackMatcher;
}

Member Function Documentation

getTransientRecHits()

TransientTrackingRecHit::ConstRecHitContainer GlobalCosmicMuonTrajectoryBuilder::getTransientRecHits ( const reco::Track &  track ) const

private

Definition at line 317 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References TransientTrackingRecHitBuilder::build(), category_, runTheMatrix::const, DetId::det(), trajectoryStateTransform::innerStateOnSurface(), TrajectoryStateOnSurface::isValid(), LogTrace, DetId::Muon, edm::ESHandle< T >::product(), mps_fire::result, theMuonRecHitBuilder, thePropagatorName, theService, theTrackerRecHitBuilder, HLT_2022v11_cff::track, and DetId::Tracker.

Referenced by trajectories().

                                  {
  TransientTrackingRecHit::ConstRecHitContainer result;

  auto hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(theTrackerRecHitBuilder.product())->cloner();
  TrajectoryStateOnSurface currTsos = trajectoryStateTransform::innerStateOnSurface(
      track, *theService->trackingGeometry(), &*theService->magneticField());
  for (trackingRecHit_iterator hit = track.recHitsBegin(); hit != track.recHitsEnd(); ++hit) {
    if ((*hit)->isValid()) {
      DetId recoid = (*hit)->geographicalId();
      if (recoid.det() == DetId::Tracker) {
        TrajectoryStateOnSurface predTsos =
            theService->propagator(thePropagatorName)
                ->propagate(currTsos, theService->trackingGeometry()->idToDet(recoid)->surface());
        LogTrace(category_) << "predtsos " << predTsos.isValid();
        if (predTsos.isValid()) {
          currTsos = predTsos;
          result.emplace_back(hitCloner(**hit, predTsos));
        }
      } else if (recoid.det() == DetId::Muon) {
        result.push_back(theMuonRecHitBuilder->build(&**hit));
      }
    }
  }
  return result;
}

isTraversing()

bool GlobalCosmicMuonTrajectoryBuilder::isTraversing ( const reco::Track &  tk ) const

private

Definition at line 467 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References align_cfg::firstValid, PV3DBase< T, PVType, FrameType >::mag(), position, theService, HLT_2022v11_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by match().

                                                                                 {
  trackingRecHit_iterator firstValid;
  for (trackingRecHit_iterator hit = track.recHitsBegin(); hit != track.recHitsEnd(); ++hit) {
    if ((*hit)->isValid()) {
      firstValid = hit;
      break;
    }
  }

  trackingRecHit_iterator lastValid;
  for (trackingRecHit_iterator hit = track.recHitsEnd() - 1; hit != track.recHitsBegin() - 1; --hit) {
    if ((*hit)->isValid()) {
      lastValid = hit;
      break;
    }
  }

  GlobalPoint posFirst = theService->trackingGeometry()->idToDet((*firstValid)->geographicalId())->position();

  GlobalPoint posLast = theService->trackingGeometry()->idToDet((*lastValid)->geographicalId())->position();

  GlobalPoint middle(
      (posFirst.x() + posLast.x()) / 2, (posFirst.y() + posLast.y()) / 2, (posFirst.z() + posLast.z()) / 2);

  if ((middle.mag() < posFirst.mag()) && (middle.mag() < posLast.mag())) {
    return true;
  }
  return false;
}

match()

std::vector< GlobalCosmicMuonTrajectoryBuilder::TrackCand > GlobalCosmicMuonTrajectoryBuilder::match	(	const TrackCand &	mu,
		const edm::Handle< reco::TrackCollection > &	tktracks
	)

check if tk and muon Tracks are matched

Definition at line 344 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References PV3DBase< T, PVType, FrameType >::basicVector(), deltar::bestMatch(), category_, Basic3DVector< T >::dot(), MillePedeFileConverter_cfg::e, TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, trajectoryStateTransform::innerStateOnSurface(), isTraversing(), runTheMatrix::keep, LogTrace, PV3DBase< T, PVType, FrameType >::mag(), mag(), GlobalMuonTrackMatcher::match(), amptDefaultParameters_cff::mu, trajectoryStateTransform::outerStateOnSurface(), quality, mps_fire::result, theService, theTrackerTracks, and theTrackMatcher.

Referenced by trajectories().

                                                                         {
  std::vector<TrackCand> result;

  TrajectoryStateOnSurface innerTsos = trajectoryStateTransform::innerStateOnSurface(
      *(mu.second), *theService->trackingGeometry(), &*theService->magneticField());
  TrajectoryStateOnSurface outerTsos = trajectoryStateTransform::outerStateOnSurface(
      *(mu.second), *theService->trackingGeometry(), &*theService->magneticField());
  //build tracker TrackCands and pick the best match if size greater than 2
  vector<TrackCand> tkTrackCands;
  for (reco::TrackCollection::size_type i = 0; i < theTrackerTracks->size(); ++i) {
    reco::TrackRef tkTrack(theTrackerTracks, i);
    TrackCand tkCand = TrackCand((Trajectory*)nullptr, tkTrack);
    tkTrackCands.push_back(tkCand);
    LogTrace(category_) << "chisq is " << theTrackMatcher->match(mu, tkCand, 0, 0);
    LogTrace(category_) << "d is " << theTrackMatcher->match(mu, tkCand, 1, 0);
    LogTrace(category_) << "r_pos is " << theTrackMatcher->match(mu, tkCand, 2, 0);
  }

  // now if only 1 tracker tracks, return it
  if (tkTrackCands.size() <= 1) {
    return tkTrackCands;
  }

  // if there're many tracker tracks

  // if muon is only on one side
  GlobalPoint innerPos = innerTsos.globalPosition();
  GlobalPoint outerPos = outerTsos.globalPosition();

  if ((innerPos.basicVector().dot(innerTsos.globalMomentum().basicVector()) *
           outerPos.basicVector().dot(outerTsos.globalMomentum().basicVector()) >
       0)) {
    GlobalPoint geoInnerPos = (innerPos.mag() < outerPos.mag()) ? innerPos : outerPos;
    LogTrace(category_) << "geoInnerPos Mu " << geoInnerPos << endl;

    // if there're tracker tracks totally on the other half
    // and there're tracker tracks on the same half
    // remove the tracks on the other half
    for (vector<TrackCand>::const_iterator itkCand = tkTrackCands.begin(); itkCand != tkTrackCands.end(); ++itkCand) {
      reco::TrackRef tkTrack = itkCand->second;

      GlobalPoint tkInnerPos(tkTrack->innerPosition().x(), tkTrack->innerPosition().y(), tkTrack->innerPosition().z());
      GlobalPoint tkOuterPos(tkTrack->outerPosition().x(), tkTrack->outerPosition().y(), tkTrack->outerPosition().z());
      LogTrace(category_) << "tkTrack " << tkInnerPos << " " << tkOuterPos << endl;

      float closetDistance11 = (geoInnerPos - tkInnerPos).mag();
      float closetDistance12 = (geoInnerPos - tkOuterPos).mag();
      float closetDistance1 = (closetDistance11 < closetDistance12) ? closetDistance11 : closetDistance12;
      LogTrace(category_) << "closetDistance1 " << closetDistance1 << endl;

      if (true || !isTraversing(*tkTrack)) {
        bool keep = true;
        for (vector<TrackCand>::const_iterator itkCand2 = tkTrackCands.begin(); itkCand2 != tkTrackCands.end();
             ++itkCand2) {
          if (itkCand2 == itkCand)
            continue;
          reco::TrackRef tkTrack2 = itkCand2->second;

          GlobalPoint tkInnerPos2(
              tkTrack2->innerPosition().x(), tkTrack2->innerPosition().y(), tkTrack2->innerPosition().z());
          GlobalPoint tkOuterPos2(
              tkTrack2->outerPosition().x(), tkTrack2->outerPosition().y(), tkTrack2->outerPosition().z());
          LogTrace(category_) << "tkTrack2 " << tkInnerPos2 << " " << tkOuterPos2 << endl;

          float farthestDistance21 = (geoInnerPos - tkInnerPos2).mag();
          float farthestDistance22 = (geoInnerPos - tkOuterPos2).mag();
          float farthestDistance2 = (farthestDistance21 > farthestDistance22) ? farthestDistance21 : farthestDistance22;
          LogTrace(category_) << "farthestDistance2 " << farthestDistance2 << endl;

          if (closetDistance1 > farthestDistance2 - 1e-3) {
            keep = false;
            break;
          }
        }
        if (keep)
          result.push_back(*itkCand);
        else
          LogTrace(category_) << "The Track is on different hemisphere" << endl;
      } else {
        result.push_back(*itkCand);
      }
    }
    if (result.empty()) {
      //if all tk tracks on the other side, still keep them
      result = tkTrackCands;
    }
  } else {  // muon is traversing
    result = tkTrackCands;
  }

  // match muCand to tkTrackCands
  vector<TrackCand> matched_trackerTracks = theTrackMatcher->match(mu, result);

  LogTrace(category_) << "TrackMatcher found " << matched_trackerTracks.size() << "tracker tracks matched";

  //now pick the best matched one
  if (matched_trackerTracks.size() < 2) {
    return matched_trackerTracks;
  } else {
    // in case of more than 1 tkTrack,
    // select the best-one based on distance (matchOption==1)
    // at innermost Mu hit surface. (surfaceOption == 0)
    result.clear();
    TrackCand bestMatch;

    double quality = 1e6;
    double max_quality = 1e6;
    for (vector<TrackCand>::const_iterator iter = matched_trackerTracks.begin(); iter != matched_trackerTracks.end();
         iter++) {
      quality = theTrackMatcher->match(mu, *iter, 1, 0);
      LogTrace(category_) << " quality of tracker track is " << quality;
      if (quality < max_quality) {
        max_quality = quality;
        bestMatch = (*iter);
      }
    }
    LogTrace(category_) << " Picked tracker track with quality " << max_quality;
    result.push_back(bestMatch);
    return result;
  }
}

propagator()

const Propagator* GlobalCosmicMuonTrajectoryBuilder::propagator ( ) const

inline

Definition at line 61 of file GlobalCosmicMuonTrajectoryBuilder.h.

References MuonServiceProxy::propagator(), thePropagatorName, and theService.

{ return &*theService->propagator(thePropagatorName); }

setEvent()

void GlobalCosmicMuonTrajectoryBuilder::setEvent ( const edm::Event &  event )

overridevirtual

pass the Event to the algo at each event

Implements MuonTrajectoryBuilder.

Definition at line 62 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References theMuonRecHitBuilder, theMuonRecHitBuilderToken, theService, theTkTrackToken, theTrackerRecHitBuilder, theTrackerRecHitBuilderToken, and theTrackerTracks.

                                                                      {
  event.getByToken(theTkTrackToken, theTrackerTracks);

  //  edm::Handle<std::vector<Trajectory> > handleTrackerTrajs;
  //  if ( event.getByLabel(theTkTrackLabel,handleTrackerTrajs) && handleTrackerTrajs.isValid() ) {
  //      tkTrajsAvailable = true;
  //      allTrackerTrajs = &*handleTrackerTrajs;
  //      LogInfo("GlobalCosmicMuonTrajectoryBuilder")
  //    << "Tk Trajectories Found! " << endl;
  //  } else {
  //      LogInfo("GlobalCosmicMuonTrajectoryBuilder")
  //    << "No Tk Trajectories Found! " << endl;
  //      tkTrajsAvailable = false;
  //  }

  theTrackerRecHitBuilder = theService->eventSetup().getHandle(theTrackerRecHitBuilderToken);
  theMuonRecHitBuilder = theService->eventSetup().getHandle(theMuonRecHitBuilderToken);
}

smoother()

CosmicMuonSmoother* GlobalCosmicMuonTrajectoryBuilder::smoother ( ) const

inlineprivate

Definition at line 76 of file GlobalCosmicMuonTrajectoryBuilder.h.

References theSmoother.

Referenced by utilities().

{ return theSmoother; }

sortHits()

void GlobalCosmicMuonTrajectoryBuilder::sortHits ( ConstRecHitContainer &  hits, ConstRecHitContainer &  muonHits, ConstRecHitContainer &  tkHits  )

private

Definition at line 209 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References category_, hfClusterShapes_cfi::hits, LogTrace, mag(), PV3DBase< T, PVType, FrameType >::perp(), groupFilesInBlocks::reverse, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by trajectories().

                                                                               {
  if (tkHits.empty()) {
    LogTrace(category_) << "No valid tracker hits";
    return;
  }
  if (muonHits.empty()) {
    LogTrace(category_) << "No valid muon hits";
    return;
  }

  ConstRecHitContainer::const_iterator frontTkHit = tkHits.begin();
  ConstRecHitContainer::const_iterator backTkHit = tkHits.end() - 1;
  while (!(*frontTkHit)->isValid() && frontTkHit != backTkHit) {
    frontTkHit++;
  }
  while (!(*backTkHit)->isValid() && backTkHit != frontTkHit) {
    backTkHit--;
  }

  ConstRecHitContainer::const_iterator frontMuHit = muonHits.begin();
  ConstRecHitContainer::const_iterator backMuHit = muonHits.end() - 1;
  while (!(*frontMuHit)->isValid() && frontMuHit != backMuHit) {
    frontMuHit++;
  }
  while (!(*backMuHit)->isValid() && backMuHit != frontMuHit) {
    backMuHit--;
  }

  if (frontTkHit == backTkHit) {
    LogTrace(category_) << "No valid tracker hits";
    return;
  }
  if (frontMuHit == backMuHit) {
    LogTrace(category_) << "No valid muon hits";
    return;
  }

  GlobalPoint frontTkPos = (*frontTkHit)->globalPosition();
  GlobalPoint backTkPos = (*backTkHit)->globalPosition();

  GlobalPoint frontMuPos = (*frontMuHit)->globalPosition();
  GlobalPoint backMuPos = (*backMuHit)->globalPosition();

  //sort hits going from higher to lower positions
  if (frontTkPos.y() < backTkPos.y()) {  //check if tk hits order same direction
    reverse(tkHits.begin(), tkHits.end());
  }

  if (frontMuPos.y() < backMuPos.y()) {
    reverse(muonHits.begin(), muonHits.end());
  }

  //  LogTrace(category_)<< "tkHits after sort: "<<tkHits.size()<<endl;;
  //  LogTrace(category_) <<utilities()->print(tkHits)<<endl;
  //  LogTrace(category_) << "== End of tkHits == "<<endl;

  //  LogTrace(category_)<< "muonHits after sort: "<<muonHits.size()<<endl;;
  //  LogTrace(category_) <<utilities()->print(muonHits)<<endl;
  //  LogTrace(category_)<< "== End of muonHits == "<<endl;

  //separate muon hits into 2 different hemisphere
  ConstRecHitContainer::iterator middlepoint = muonHits.begin();
  bool insertInMiddle = false;

  for (ConstRecHitContainer::iterator ihit = muonHits.begin(); ihit != muonHits.end() - 1; ihit++) {
    GlobalPoint ipos = (*ihit)->globalPosition();
    GlobalPoint nextpos = (*(ihit + 1))->globalPosition();
    if ((ipos - nextpos).mag() < 100.0)
      continue;

    GlobalPoint middle((ipos.x() + nextpos.x()) / 2, (ipos.y() + nextpos.y()) / 2, (ipos.z() + nextpos.z()) / 2);
    LogTrace(category_) << "ipos " << ipos << "nextpos" << nextpos << " middle " << middle << endl;
    if ((middle.perp() < ipos.perp()) && (middle.perp() < nextpos.perp())) {
      LogTrace(category_) << "found middlepoint" << endl;
      middlepoint = ihit;
      insertInMiddle = true;
      break;
    }
  }

  //insert track hits in correct order
  if (insertInMiddle) {  //if tk hits should be sandwich
    GlobalPoint jointpointpos = (*middlepoint)->globalPosition();
    LogTrace(category_) << "jointpoint " << jointpointpos << endl;
    if ((frontTkPos - jointpointpos).mag() >
        (backTkPos - jointpointpos).mag()) {  //check if tk hits order same direction
      reverse(tkHits.begin(), tkHits.end());
    }
    muonHits.insert(middlepoint + 1, tkHits.begin(), tkHits.end());
    hits = muonHits;
  } else {                                  // append at one end
    if (frontTkPos.y() < frontMuPos.y()) {  //insert at the end
      LogTrace(category_) << "insert at the end " << frontTkPos << frontMuPos << endl;

      hits = muonHits;
      hits.insert(hits.end(), tkHits.begin(), tkHits.end());
    } else {  //insert at the beginning
      LogTrace(category_) << "insert at the beginning " << frontTkPos << frontMuPos << endl;
      hits = tkHits;
      hits.insert(hits.end(), muonHits.begin(), muonHits.end());
    }
  }
}

trajectories() [1/2]

TrajectoryContainer GlobalCosmicMuonTrajectoryBuilder::trajectories ( const TrajectorySeed &  )

inlineoverridevirtual

dummy implementation, unused in this class

Implements MuonTrajectoryBuilder.

Definition at line 59 of file GlobalCosmicMuonTrajectoryBuilder.h.

{ return TrajectoryContainer{}; }

trajectories() [2/2]

MuonCandidate::CandidateContainer GlobalCosmicMuonTrajectoryBuilder::trajectories ( const TrackCand &  muCand )

overridevirtual

choose tk Track and build combined trajectories

Implements MuonTrajectoryBuilder.

Definition at line 84 of file GlobalCosmicMuonTrajectoryBuilder.cc.

References category_, CosmicMuonSmoother::fit(), getTransientRecHits(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, trajectoryStateTransform::innerStateOnSurface(), edm::Ref< C, T, F >::isNull(), TrajectoryStateOnSurface::isValid(), edm::HandleBase::isValid(), LogTrace, match(), muonTagProbeFilters_cff::matched, eostools::move(), trajectoryStateTransform::outerStateOnSurface(), PV3DBase< T, PVType, FrameType >::perp(), mps_fire::result, groupFilesInBlocks::reverse, fileCollector::seed, sortHits(), theService, theSmoother, theTrackerTracks, CosmicMuonSmoother::trajectories(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                       {
  MuonCandidate::CandidateContainer result;

  if (!theTrackerTracks.isValid()) {
    LogTrace(category_) << "Tracker Track collection is invalid!!!";
    return result;
  }

  LogTrace(category_) << "Found " << theTrackerTracks->size() << " tracker Tracks";
  if (theTrackerTracks->empty())
    return result;

  vector<TrackCand> matched = match(muCand, theTrackerTracks);

  LogTrace(category_) << "TrackMatcher found " << matched.size() << "tracker tracks matched";

  if (matched.empty())
    return result;
  reco::TrackRef tkTrack = matched.front().second;

  if (tkTrack.isNull())
    return result;
  reco::TrackRef muTrack = muCand.second;

  ConstRecHitContainer muRecHits;

  if (muCand.first == nullptr || !muCand.first->isValid()) {
    muRecHits = getTransientRecHits(*muTrack);
  } else {
    muRecHits = muCand.first->recHits();
  }

  LogTrace(category_) << "mu RecHits: " << muRecHits.size();

  ConstRecHitContainer tkRecHits = getTransientRecHits(*tkTrack);

  //  if ( !tkTrajsAvailable ) {
  //     tkRecHits = getTransientRecHits(*tkTrack);
  //  } else {
  //     tkRecHits = allTrackerTrajs->front().recHits();
  //  }

  ConstRecHitContainer hits;  //= tkRecHits;
  LogTrace(category_) << "tk RecHits: " << tkRecHits.size();

  //  hits.insert(hits.end(), muRecHits.begin(), muRecHits.end());
  //  stable_sort(hits.begin(), hits.end(), DecreasingGlobalY());

  sortHits(hits, muRecHits, tkRecHits);

  //  LogTrace(category_)<< "Used RecHits after sort: "<<hits.size()<<endl;;
  //  LogTrace(category_) <<utilities()->print(hits)<<endl;
  //  LogTrace(category_) << "== End of Used RecHits == "<<endl;

  TrajectoryStateOnSurface muonState1 = trajectoryStateTransform::innerStateOnSurface(
      *muTrack, *theService->trackingGeometry(), &*theService->magneticField());
  TrajectoryStateOnSurface tkState1 = trajectoryStateTransform::innerStateOnSurface(
      *tkTrack, *theService->trackingGeometry(), &*theService->magneticField());

  TrajectoryStateOnSurface muonState2 = trajectoryStateTransform::outerStateOnSurface(
      *muTrack, *theService->trackingGeometry(), &*theService->magneticField());
  TrajectoryStateOnSurface tkState2 = trajectoryStateTransform::outerStateOnSurface(
      *tkTrack, *theService->trackingGeometry(), &*theService->magneticField());

  TrajectoryStateOnSurface firstState1 =
      (muonState1.globalPosition().y() > tkState1.globalPosition().y()) ? muonState1 : tkState1;
  TrajectoryStateOnSurface firstState2 =
      (muonState2.globalPosition().y() > tkState2.globalPosition().y()) ? muonState2 : tkState2;

  TrajectoryStateOnSurface firstState =
      (firstState1.globalPosition().y() > firstState2.globalPosition().y()) ? firstState1 : firstState2;

  GlobalPoint front, back;
  if (!hits.empty()) {
    front = hits.front()->globalPosition();
    back = hits.back()->globalPosition();
    if ((front.perp() < 130 && fabs(front.z()) < 300) || (back.perp() < 130 && fabs(back.z()) < 300)) {
      if (hits.front()->globalPosition().perp() > hits.back()->globalPosition().perp())
        reverse(hits.begin(), hits.end());
      tkState1 = trajectoryStateTransform::innerStateOnSurface(
          *tkTrack, *theService->trackingGeometry(), &*theService->magneticField());
      tkState2 = trajectoryStateTransform::outerStateOnSurface(
          *tkTrack, *theService->trackingGeometry(), &*theService->magneticField());
      firstState = (tkState1.globalPosition().perp() < tkState2.globalPosition().perp()) ? tkState1 : tkState2;
    }
  }
  if (!firstState.isValid())
    return result;
  LogTrace(category_) << "firstTSOS pos: " << firstState.globalPosition() << "mom: " << firstState.globalMomentum();

  // begin refitting

  TrajectorySeed seed;
  vector<Trajectory> refitted = theSmoother->trajectories(seed, hits, firstState);

  if (refitted.empty()) {
    LogTrace(category_) << "smoothing trajectories fail";
    refitted = theSmoother->fit(seed, hits, firstState);  //FIXME
  }

  if (refitted.empty()) {
    LogTrace(category_) << "refit fail";
    return result;
  }

  auto myTraj = std::make_unique<Trajectory>(refitted.front());

  const std::vector<TrajectoryMeasurement>& mytms = myTraj->measurements();
  LogTrace(category_) << "measurements in final trajectory " << mytms.size();
  LogTrace(category_) << "Orignally there are " << tkTrack->found() << " tk rhs and " << muTrack->found() << " mu rhs.";

  if (mytms.size() <= tkTrack->found()) {
    LogTrace(category_) << "insufficient measurements. skip... ";
    return result;
  }

  result.push_back(std::make_unique<MuonCandidate>(std::move(myTraj), muTrack, tkTrack));
  LogTrace(category_) << "final global cosmic muon: ";
  for (std::vector<TrajectoryMeasurement>::const_iterator itm = mytms.begin(); itm != mytms.end(); ++itm) {
    LogTrace(category_) << "updated pos " << itm->updatedState().globalPosition() << "mom "
                        << itm->updatedState().globalMomentum();
  }
  return result;
}

utilities()

const CosmicMuonUtilities* GlobalCosmicMuonTrajectoryBuilder::utilities ( ) const

inlineprivate

Definition at line 78 of file GlobalCosmicMuonTrajectoryBuilder.h.

References smoother(), and CosmicMuonSmoother::utilities().

{ return smoother()->utilities(); }

Member Data Documentation

allTrackerTrajs

const std::vector<Trajectory>* GlobalCosmicMuonTrajectoryBuilder::allTrackerTrajs

private

Definition at line 101 of file GlobalCosmicMuonTrajectoryBuilder.h.

category_

std::string GlobalCosmicMuonTrajectoryBuilder::category_

private

Definition at line 103 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by getTransientRecHits(), GlobalCosmicMuonTrajectoryBuilder(), match(), sortHits(), and trajectories().

theMuonRecHitBuilder

edm::ESHandle<TransientTrackingRecHitBuilder> GlobalCosmicMuonTrajectoryBuilder::theMuonRecHitBuilder

private

Definition at line 95 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by getTransientRecHits(), and setEvent().

theMuonRecHitBuilderToken

const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> GlobalCosmicMuonTrajectoryBuilder::theMuonRecHitBuilderToken

private

Definition at line 94 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by setEvent().

thePropagatorName

std::string GlobalCosmicMuonTrajectoryBuilder::thePropagatorName

private

Definition at line 88 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by getTransientRecHits(), GlobalCosmicMuonTrajectoryBuilder(), and propagator().

theService

const MuonServiceProxy* GlobalCosmicMuonTrajectoryBuilder::theService

private

Definition at line 82 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by getTransientRecHits(), GlobalCosmicMuonTrajectoryBuilder(), isTraversing(), match(), propagator(), setEvent(), and trajectories().

theSmoother

CosmicMuonSmoother* GlobalCosmicMuonTrajectoryBuilder::theSmoother

private

Definition at line 84 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by GlobalCosmicMuonTrajectoryBuilder(), smoother(), trajectories(), and ~GlobalCosmicMuonTrajectoryBuilder().

theTkTrackToken

edm::EDGetTokenT<reco::TrackCollection> GlobalCosmicMuonTrajectoryBuilder::theTkTrackToken

private

Definition at line 89 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by GlobalCosmicMuonTrajectoryBuilder(), and setEvent().

theTrackerRecHitBuilder

edm::ESHandle<TransientTrackingRecHitBuilder> GlobalCosmicMuonTrajectoryBuilder::theTrackerRecHitBuilder

private

Definition at line 92 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by getTransientRecHits(), and setEvent().

theTrackerRecHitBuilderToken

const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> GlobalCosmicMuonTrajectoryBuilder::theTrackerRecHitBuilderToken

private

Definition at line 91 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by setEvent().

theTrackerTracks

edm::Handle<reco::TrackCollection> GlobalCosmicMuonTrajectoryBuilder::theTrackerTracks

private

Definition at line 97 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by match(), setEvent(), and trajectories().

theTrackMatcher

GlobalMuonTrackMatcher* GlobalCosmicMuonTrajectoryBuilder::theTrackMatcher

private

Definition at line 86 of file GlobalCosmicMuonTrajectoryBuilder.h.

Referenced by GlobalCosmicMuonTrajectoryBuilder(), match(), and ~GlobalCosmicMuonTrajectoryBuilder().

tkTrajsAvailable

bool GlobalCosmicMuonTrajectoryBuilder::tkTrajsAvailable

private

Definition at line 99 of file GlobalCosmicMuonTrajectoryBuilder.h.