CosmicMuonSmoother Class Reference

#include <CosmicMuonSmoother.h>

Inheritance diagram for CosmicMuonSmoother:

Public Member Functions
CosmicMuonSmoother *	clone () const override
	CosmicMuonSmoother (const edm::ParameterSet &, const MuonServiceProxy *service)
const Chi2MeasurementEstimator *	estimator () const
std::vector< Trajectory >	fit (const Trajectory &) const
std::vector< Trajectory >	fit (const TrajectorySeed &seed, const ConstRecHitContainer &hits, const TrajectoryStateOnSurface &firstPredTsos) const
const Propagator *	propagatorAlong () const
const Propagator *	propagatorOpposite () const
void	setHitCloner (TkCloner const *hc) override
TrajectoryContainer	trajectories (const Trajectory &traj) const override
virtual TrajectoryContainer	trajectories (const TrajectorySeed &seed, const ConstRecHitContainer &hits, const TrajectoryStateOnSurface &firstPredTsos) const
	refit trajectory More...
Trajectory	trajectory (const Trajectory &) const override
const KFUpdator *	updator () const
const CosmicMuonUtilities *	utilities () const
	~CosmicMuonSmoother () override
Public Member Functions inherited from TrajectorySmoother
virtual	~TrajectorySmoother ()

Private Member Functions
TrajectoryStateOnSurface	initialState (const Trajectory &) const
std::vector< Trajectory >	smooth (const std::vector< Trajectory > &) const
std::vector< Trajectory >	smooth (const Trajectory &) const
void	sortHitsAlongMom (ConstRecHitContainer &hits, const TrajectoryStateOnSurface &) const

Private Attributes
std::string	category_
double	theErrorRescaling
const Chi2MeasurementEstimator *	theEstimator
std::string	thePropagatorAlongName
std::string	thePropagatorOppositeName
const MuonServiceProxy *	theService
const KFUpdator *	theUpdator
const CosmicMuonUtilities *	theUtilities

Additional Inherited Members
Public Types inherited from TrajectorySmoother
typedef std::vector< Trajectory >	TrajectoryContainer
typedef TrajectoryContainer::iterator	TrajectoryIterator

Detailed Description

Definition at line 38 of file CosmicMuonSmoother.h.

Constructor & Destructor Documentation

CosmicMuonSmoother()

CosmicMuonSmoother::CosmicMuonSmoother	(	const edm::ParameterSet &	par,
		const MuonServiceProxy *	service
	)

Definition at line 32 of file CosmicMuonSmoother.cc.

                                                                                               : theService(service) {
  theUpdator = new KFUpdator;
  theUtilities = new CosmicMuonUtilities;
  theEstimator = new Chi2MeasurementEstimator(200.0);
  thePropagatorAlongName = par.getParameter<string>("PropagatorAlong");
  thePropagatorOppositeName = par.getParameter<string>("PropagatorOpposite");
  theErrorRescaling = par.getParameter<double>("RescalingFactor");
 
  category_ = "Muon|RecoMuon|CosmicMuon|CosmicMuonSmoother";
}

References category_, Chi2MeasurementEstimator_cfi::Chi2MeasurementEstimator, edm::ParameterSet::getParameter(), theErrorRescaling, theEstimator, thePropagatorAlongName, thePropagatorOppositeName, theUpdator, and theUtilities.

Referenced by clone().

~CosmicMuonSmoother()

CosmicMuonSmoother::~CosmicMuonSmoother ( )

override

Definition at line 46 of file CosmicMuonSmoother.cc.

                                        {
  if (theUpdator)
    delete theUpdator;
  if (theUtilities)
    delete theUtilities;
  if (theEstimator)
    delete theEstimator;
}

References theEstimator, theUpdator, and theUtilities.

Member Function Documentation

clone()

CosmicMuonSmoother* CosmicMuonSmoother::clone ( void  ) const

inlineoverridevirtual

Implements TrajectorySmoother.

Definition at line 49 of file CosmicMuonSmoother.h.

{ return new CosmicMuonSmoother(*this); }

References CosmicMuonSmoother().

estimator()

const Chi2MeasurementEstimator* CosmicMuonSmoother::estimator ( void  ) const

inline

Definition at line 64 of file CosmicMuonSmoother.h.

{ return theEstimator; }

References theEstimator.

fit() [1/2]

vector< Trajectory > CosmicMuonSmoother::fit

(

const Trajectory &

t

)

const

Definition at line 93 of file CosmicMuonSmoother.cc.

                                                                    {
  if (t.empty())
    return vector<Trajectory>();
 
  LogTrace(category_) << "fit begin (trajectory) ";
 
  TrajectoryStateOnSurface firstTsos = initialState(t);
  if (!firstTsos.isValid()) {
    LogTrace(category_) << "Error: firstTsos invalid. ";
    return vector<Trajectory>();
  }
 
  LogTrace(category_) << "firstTsos: " << firstTsos;
 
  ConstRecHitContainer hits = t.recHits();
  LogTrace(category_) << "hits: " << hits.size();
  LogTrace(category_) << "hit front" << hits.front()->globalPosition() << " hit back" << hits.back()->globalPosition();
 
  sortHitsAlongMom(hits, firstTsos);
 
  LogTrace(category_) << "after sorting hit front" << hits.front()->globalPosition() << " hit back"
                      << hits.back()->globalPosition();
 
  return fit(t.seed(), hits, firstTsos);
}

References category_, hfClusterShapes_cfi::hits, initialState(), TrajectoryStateOnSurface::isValid(), LogTrace, sortHitsAlongMom(), and submitPVValidationJobs::t.

Referenced by CosmicMuonTrajectoryBuilder::flipTrajectory(), trackingPlots.Iteration::modules(), trajectories(), GlobalCosmicMuonTrajectoryBuilder::trajectories(), and trajectory().

fit() [2/2]

vector< Trajectory > CosmicMuonSmoother::fit	(	const TrajectorySeed &	seed,
		const ConstRecHitContainer &	hits,
		const TrajectoryStateOnSurface &	firstPredTsos
	)		const

Definition at line 122 of file CosmicMuonSmoother.cc.

                                                                                                {
  LogTrace(category_) << "fit begin (seed, hit, tsos).";
 
  if (hits.empty()) {
    LogTrace(category_) << "Error: empty hits container.";
    return vector<Trajectory>();
  }
 
  Trajectory myTraj(seed, alongMomentum);
 
  TrajectoryStateOnSurface predTsos(firstPredTsos);
  LogTrace(category_) << "first pred TSOS: " << predTsos;
 
  if (!predTsos.isValid()) {
    LogTrace(category_) << "Error: firstTsos invalid.";
    return vector<Trajectory>();
  }
  TrajectoryStateOnSurface currTsos;
 
  if (hits.front()->isValid()) {
    // FIXME  FIXME  CLONE !!!
    //  TrackingRecHit::RecHitPointer preciseHit = hits.front()->clone(predTsos);
    auto preciseHit = hits.front();
 
    LogTrace(category_) << "first hit is at det " << hits.front()->det()->surface().position();
 
    currTsos = theUpdator->update(predTsos, *preciseHit);
    if (!currTsos.isValid()) {
      edm::LogWarning(category_) << "an updated state is not valid. killing the trajectory.";
      return vector<Trajectory>();
    }
    myTraj.push(TrajectoryMeasurement(
        predTsos, currTsos, hits.front(), theEstimator->estimate(predTsos, *hits.front()).second));
    if (currTsos.isValid())
      LogTrace(category_) << "first curr TSOS: " << currTsos;
 
  } else {
    currTsos = predTsos;
    myTraj.push(TrajectoryMeasurement(predTsos, hits.front()));
  }
  //const TransientTrackingRecHit& firsthit = *hits.front();
 
  for (ConstRecHitContainer::const_iterator ihit = hits.begin() + 1; ihit != hits.end(); ++ihit) {
    if (!(**ihit).isValid()) {
      LogTrace(category_) << "Error: invalid hit.";
      continue;
    }
    if (currTsos.isValid() && currTsos.globalMomentum().mag2() > 1e-18f) {
      LogTrace(category_) << "current pos " << currTsos.globalPosition() << "mom " << currTsos.globalMomentum();
    } else {
      LogTrace(category_) << "current state invalid or momentum is too low";
      //logically, there's no way out: can't expect a valid result out of an invalid state
      LogTrace(category_) << "Input state is not valid. This loop over hits is doomed: breaking out";
      break;
    }
 
    predTsos = propagatorAlong()->propagate(currTsos, (**ihit).det()->surface());
    LogTrace(category_) << "predicted state propagate directly " << predTsos.isValid();
 
    if (!predTsos.isValid()) {
      LogTrace(category_) << "step-propagating from " << currTsos.globalPosition()
                          << " to position: " << (*ihit)->globalPosition();
      predTsos = theUtilities->stepPropagate(currTsos, (*ihit), *propagatorAlong());
    }
    if (!predTsos.isValid() && (fabs(theService->magneticField()->inTesla(GlobalPoint(0, 0, 0)).z()) < 0.01) &&
        (theService->propagator("StraightLinePropagator").isValid())) {
      LogTrace(category_) << "straight-line propagating from " << currTsos.globalPosition()
                          << " to position: " << (*ihit)->globalPosition();
      predTsos = theService->propagator("StraightLinePropagator")->propagate(currTsos, (**ihit).det()->surface());
    }
    if (predTsos.isValid()) {
      LogTrace(category_) << "predicted pos " << predTsos.globalPosition() << "mom " << predTsos.globalMomentum();
    } else {
      LogTrace(category_) << "predicted state invalid";
    }
    if (!predTsos.isValid() || predTsos.globalPosition().mag2() > 1.e12) {
      LogTrace(category_) << "Error: predTsos is still invalid or too far in forward fit.";
      //      return vector<Trajectory>();
      continue;
    } else if ((**ihit).isValid()) {
      // FIXME  FIXME  CLONE !!!
      // update  (FIXME!)
      // TransientTrackingRecHit::RecHitPointer preciseHit = (**ihit).clone(predTsos);
      auto preciseHit = *ihit;
 
      if (!preciseHit->isValid()) {
        currTsos = predTsos;
        myTraj.push(TrajectoryMeasurement(predTsos, *ihit));
      } else {
        currTsos = theUpdator->update(predTsos, *preciseHit);
        if (!currTsos.isValid()) {
          edm::LogWarning(category_) << "an updated state is not valid. killing the trajectory.";
          return vector<Trajectory>();
        }
        myTraj.push(TrajectoryMeasurement(
            predTsos, currTsos, preciseHit, theEstimator->estimate(predTsos, *preciseHit).second));
      }
    } else {
      currTsos = predTsos;
      myTraj.push(TrajectoryMeasurement(predTsos, *ihit));
    }
  }
 
  std::vector<TrajectoryMeasurement> mytms = myTraj.measurements();
  LogTrace(category_) << "fit result " << mytms.size();
  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 vector<Trajectory>(1, myTraj);
}

References alongMomentum, category_, MillePedeFileConverter_cfg::e, f, TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, TrajectoryStateOnSurface::isValid(), LogTrace, PV3DBase< T, PVType, FrameType >::mag2(), Trajectory::measurements(), Propagator::propagate(), propagatorAlong(), Trajectory::push(), edm::second(), fileCollector::seed, CosmicMuonUtilities::stepPropagate(), TrajectoryStateOnSurface::surface(), theEstimator, theService, theUpdator, theUtilities, and KFUpdator::update().

Referenced by trackingPlots.Iteration::modules().

initialState()

TrajectoryStateOnSurface CosmicMuonSmoother::initialState ( const Trajectory &  t ) const

private

Definition at line 402 of file CosmicMuonSmoother.cc.

                                                                                   {
  if (t.empty())
    return TrajectoryStateOnSurface();
 
  if (!t.firstMeasurement().updatedState().isValid() || !t.lastMeasurement().updatedState().isValid())
    return TrajectoryStateOnSurface();
 
  TrajectoryStateOnSurface result;
 
  bool beamhaloFlag = (t.firstMeasurement().updatedState().globalMomentum().eta() > 4.0 ||
                       t.lastMeasurement().updatedState().globalMomentum().eta() > 4.0);
 
  if (!beamhaloFlag) {  //initialState is the top one
    if (t.firstMeasurement().updatedState().globalPosition().y() >
        t.lastMeasurement().updatedState().globalPosition().y()) {
      result = t.firstMeasurement().updatedState();
    } else {
      result = t.lastMeasurement().updatedState();
    }
    if (result.globalMomentum().y() > 1.0)  //top tsos should pointing down
      theUtilities->reverseDirection(result, &*theService->magneticField());
  } else {
    if (t.firstMeasurement().updatedState().globalPosition().z() *
            t.lastMeasurement().updatedState().globalPosition().z() >
        0) {  //same side
      if (fabs(t.firstMeasurement().updatedState().globalPosition().z()) >
          fabs(t.lastMeasurement().updatedState().globalPosition().z())) {
        result = t.firstMeasurement().updatedState();
      } else {
        result = t.lastMeasurement().updatedState();
      }
    } else {  //different sides
 
      if (fabs(t.firstMeasurement().updatedState().globalPosition().eta()) >
          fabs(t.lastMeasurement().updatedState().globalPosition().eta())) {
        result = t.firstMeasurement().updatedState();
      } else {
        result = t.lastMeasurement().updatedState();
      }
    }
  }
 
  return result;
}

References mps_fire::result, CosmicMuonUtilities::reverseDirection(), submitPVValidationJobs::t, theService, and theUtilities.

Referenced by fit().

propagatorAlong()

const Propagator* CosmicMuonSmoother::propagatorAlong ( ) const

inline

Definition at line 56 of file CosmicMuonSmoother.h.

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

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

Referenced by fit().

propagatorOpposite()

const Propagator* CosmicMuonSmoother::propagatorOpposite ( ) const

inline

Definition at line 58 of file CosmicMuonSmoother.h.

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

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

Referenced by smooth().

setHitCloner()

void CosmicMuonSmoother::setHitCloner ( TkCloner const *  hc )

inlineoverridevirtual

Implements TrajectorySmoother.

Definition at line 71 of file CosmicMuonSmoother.h.

{}

smooth() [1/2]

vector< Trajectory > CosmicMuonSmoother::smooth ( const std::vector< Trajectory > &  tc ) const

private

Definition at line 240 of file CosmicMuonSmoother.cc.

                                                                                {
  vector<Trajectory> result;
 
  for (vector<Trajectory>::const_iterator it = tc.begin(); it != tc.end(); ++it) {
    vector<Trajectory> smoothed = smooth(*it);
    result.insert(result.end(), smoothed.begin(), smoothed.end());
  }
 
  return result;
}

References mps_fire::result.

Referenced by trajectories(), and trajectory().

smooth() [2/2]

vector< Trajectory > CosmicMuonSmoother::smooth ( const Trajectory &  t ) const

private

Definition at line 254 of file CosmicMuonSmoother.cc.

                                                                       {
  if (t.empty()) {
    LogTrace(category_) << "Error: smooth: empty trajectory.";
    return vector<Trajectory>();
  }
 
  Trajectory myTraj(t.seed(), oppositeToMomentum);
 
  vector<TrajectoryMeasurement> avtm = t.measurements();
 
  if (avtm.size() < 2) {
    LogTrace(category_) << "Error: smooth: too little TM. ";
    return vector<Trajectory>();
  }
 
  TrajectoryStateOnSurface predTsos = avtm.back().forwardPredictedState();
  predTsos.rescaleError(theErrorRescaling);
 
  if (!predTsos.isValid()) {
    LogTrace(category_) << "Error: smooth: first TSOS from back invalid. ";
    return vector<Trajectory>();
  }
 
  TrajectoryStateOnSurface currTsos;
 
  // first smoothed TrajectoryMeasurement is last fitted
  if (avtm.back().recHit()->isValid()) {
    currTsos = theUpdator->update(predTsos, (*avtm.back().recHit()));
    if (!currTsos.isValid()) {
      edm::LogWarning(category_) << "an updated state is not valid. killing the trajectory.";
      return vector<Trajectory>();
    }
    myTraj.push(TrajectoryMeasurement(avtm.back().forwardPredictedState(),
                                      predTsos,
                                      avtm.back().updatedState(),
                                      avtm.back().recHit(),
                                      avtm.back().estimate()  //,
                                      /*avtm.back().layer()*/),
                avtm.back().estimate());
 
  } else {
    currTsos = predTsos;
    myTraj.push(TrajectoryMeasurement(avtm.back().forwardPredictedState(),
                                      avtm.back().recHit()  //,
                                      /*avtm.back().layer()*/));
  }
 
  TrajectoryStateCombiner combiner;
 
  for (vector<TrajectoryMeasurement>::reverse_iterator itm = avtm.rbegin() + 1; itm != avtm.rend() - 1; ++itm) {
    if (currTsos.isValid()) {
      LogTrace(category_) << "current pos " << currTsos.globalPosition() << "mom " << currTsos.globalMomentum();
    } else {
      LogTrace(category_) << "current state invalid";
    }
 
    predTsos = propagatorOpposite()->propagate(currTsos, (*itm).recHit()->det()->surface());
 
    if (!predTsos.isValid()) {
      LogTrace(category_) << "step-propagating from " << currTsos.globalPosition()
                          << " to position: " << (*itm).recHit()->globalPosition();
      predTsos = theUtilities->stepPropagate(currTsos, (*itm).recHit(), *propagatorOpposite());
    }
    if (predTsos.isValid()) {
      LogTrace(category_) << "predicted pos " << predTsos.globalPosition() << "mom " << predTsos.globalMomentum();
    } else {
      LogTrace(category_) << "predicted state invalid";
    }
 
    if (!predTsos.isValid()) {
      LogTrace(category_) << "Error: predTsos is still invalid backward smooth.";
      return vector<Trajectory>();
      //  continue;
    } else if ((*itm).recHit()->isValid()) {
      //update
      currTsos = theUpdator->update(predTsos, (*(*itm).recHit()));
      if (!currTsos.isValid()) {
        edm::LogWarning(category_) << "an updated state is not valid. killing the trajectory.";
        return vector<Trajectory>();
      }
      TrajectoryStateOnSurface combTsos = combiner(predTsos, (*itm).forwardPredictedState());
      if (!combTsos.isValid()) {
        LogTrace(category_) << "Error: smooth: combining pred TSOS failed. ";
        return vector<Trajectory>();
      }
 
      TrajectoryStateOnSurface smooTsos = combiner((*itm).updatedState(), predTsos);
 
      if (!smooTsos.isValid()) {
        LogTrace(category_) << "Error: smooth: combining smooth TSOS failed. ";
        return vector<Trajectory>();
      }
 
      myTraj.push(TrajectoryMeasurement((*itm).forwardPredictedState(),
                                        predTsos,
                                        smooTsos,
                                        (*itm).recHit(),
                                        theEstimator->estimate(combTsos, (*(*itm).recHit())).second  //,
                                        /*(*itm).layer()*/),
                  (*itm).estimate());
    } else {
      currTsos = predTsos;
      TrajectoryStateOnSurface combTsos = combiner(predTsos, (*itm).forwardPredictedState());
 
      if (!combTsos.isValid()) {
        LogTrace(category_) << "Error: smooth: combining TSOS failed. ";
        return vector<Trajectory>();
      }
 
      myTraj.push(TrajectoryMeasurement((*itm).forwardPredictedState(),
                                        predTsos,
                                        combTsos,
                                        (*itm).recHit()  //,
                                        /*(*itm).layer()*/));
    }
  }
 
  // last smoothed TrajectoryMeasurement is last filtered
  predTsos = propagatorOpposite()->propagate(currTsos, avtm.front().recHit()->det()->surface());
 
  if (!predTsos.isValid()) {
    LogTrace(category_) << "Error: last predict TSOS failed, use original one. ";
    //    return vector<Trajectory>();
    myTraj.push(TrajectoryMeasurement(avtm.front().forwardPredictedState(), avtm.front().recHit()));
  } else {
    if (avtm.front().recHit()->isValid()) {
      //update
      currTsos = theUpdator->update(predTsos, (*avtm.front().recHit()));
      if (currTsos.isValid())
        myTraj.push(TrajectoryMeasurement(avtm.front().forwardPredictedState(),
                                          predTsos,
                                          currTsos,
                                          avtm.front().recHit(),
                                          theEstimator->estimate(predTsos, (*avtm.front().recHit())).second  //,
                                          /*avtm.front().layer()*/),
                    avtm.front().estimate());
    }
  }
  LogTrace(category_) << "myTraj foundHits. " << myTraj.foundHits();
 
  if (myTraj.foundHits() >= 3)
    return vector<Trajectory>(1, myTraj);
  else {
    LogTrace(category_) << "Error: smooth: No enough hits in trajctory. ";
    return vector<Trajectory>();
  }
}

References category_, heavyFlavorValidationHarvestingSequence_cff::combiner, TrajectoryMeasurement::estimate(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), LogTrace, oppositeToMomentum, Propagator::propagate(), propagatorOpposite(), TrajectoryStateOnSurface::rescaleError(), CosmicMuonUtilities::stepPropagate(), TrajectoryStateOnSurface::surface(), submitPVValidationJobs::t, theErrorRescaling, theEstimator, theUpdator, theUtilities, and KFUpdator::update().

sortHitsAlongMom()

void CosmicMuonSmoother::sortHitsAlongMom ( ConstRecHitContainer &  hits, const TrajectoryStateOnSurface &  tsos  ) const

private

Definition at line 447 of file CosmicMuonSmoother.cc.

                                                                                                                {
  if (hits.size() < 2)
    return;
  float dis1 = (hits.front()->globalPosition() - tsos.globalPosition()).mag();
  float dis2 = (hits.back()->globalPosition() - tsos.globalPosition()).mag();
 
  if (dis1 > dis2)
    std::reverse(hits.begin(), hits.end());
 
  return;
}

References TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, mag(), and groupFilesInBlocks::reverse.

Referenced by fit().

trajectories() [1/2]

TrajectoryContainer CosmicMuonSmoother::trajectories ( const Trajectory &  traj ) const

inlineoverridevirtual

Reimplemented from TrajectorySmoother.

Definition at line 45 of file CosmicMuonSmoother.h.

                                                                          {
    return TrajectorySmoother::trajectories(traj);
  }

References TrajectorySmoother::trajectories().

Referenced by CosmicMuonTrajectoryBuilder::estimateDirection(), CosmicMuonTrajectoryBuilder::trajectories(), and GlobalCosmicMuonTrajectoryBuilder::trajectories().

trajectories() [2/2]

std::vector< Trajectory > CosmicMuonSmoother::trajectories ( const TrajectorySeed &  seed, const ConstRecHitContainer &  hits, const TrajectoryStateOnSurface &  firstPredTsos  ) const

virtual

refit trajectory

Definition at line 69 of file CosmicMuonSmoother.cc.

                                                                                                              {
  if (hits.empty() || !firstPredTsos.isValid())
    return vector<Trajectory>();
 
  LogTrace(category_) << "trajectory begin (seed hits tsos)";
 
  TrajectoryStateOnSurface firstTsos = firstPredTsos;
  firstTsos.rescaleError(theErrorRescaling);
 
  LogTrace(category_) << "first TSOS: " << firstTsos;
 
  vector<Trajectory> fitted = fit(seed, hits, firstTsos);
  LogTrace(category_) << "fitted: " << fitted.size();
  vector<Trajectory> smoothed = smooth(fitted);
  LogTrace(category_) << "smoothed: " << smoothed.size();
 
  return smoothed;
}

References category_, fit(), hfClusterShapes_cfi::hits, TrajectoryStateOnSurface::isValid(), LogTrace, TrajectoryStateOnSurface::rescaleError(), fileCollector::seed, smooth(), and theErrorRescaling.

trajectory()

Trajectory CosmicMuonSmoother::trajectory ( const Trajectory &  t ) const

overridevirtual

Implements TrajectorySmoother.

Definition at line 58 of file CosmicMuonSmoother.cc.

                                                                   {
  std::vector<Trajectory>&& fitted = fit(t);
  if (fitted.empty())
    return Trajectory();
  std::vector<Trajectory>&& smoothed = smooth(fitted);
  return smoothed.empty() ? Trajectory() : smoothed.front();
}

References fit(), smooth(), and submitPVValidationJobs::t.

updator()

const KFUpdator* CosmicMuonSmoother::updator ( ) const

inline

Definition at line 60 of file CosmicMuonSmoother.h.

{ return theUpdator; }

References theUpdator.

utilities()

const CosmicMuonUtilities* CosmicMuonSmoother::utilities ( ) const

inline

Definition at line 62 of file CosmicMuonSmoother.h.

{ return theUtilities; }

References theUtilities.

Referenced by CosmicMuonTrajectoryBuilder::utilities(), and GlobalCosmicMuonTrajectoryBuilder::utilities().

Member Data Documentation

category_

std::string CosmicMuonSmoother::category_

private

Definition at line 90 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), fit(), smooth(), and trajectories().

theErrorRescaling

double CosmicMuonSmoother::theErrorRescaling

private

Definition at line 89 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), smooth(), and trajectories().

theEstimator

const Chi2MeasurementEstimator* CosmicMuonSmoother::theEstimator

private

Definition at line 82 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), estimator(), fit(), smooth(), and ~CosmicMuonSmoother().

thePropagatorAlongName

std::string CosmicMuonSmoother::thePropagatorAlongName

private

Definition at line 87 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), and propagatorAlong().

thePropagatorOppositeName

std::string CosmicMuonSmoother::thePropagatorOppositeName

private

Definition at line 88 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), and propagatorOpposite().

theService

const MuonServiceProxy* CosmicMuonSmoother::theService

private

Definition at line 85 of file CosmicMuonSmoother.h.

Referenced by fit(), initialState(), propagatorAlong(), and propagatorOpposite().

theUpdator

const KFUpdator* CosmicMuonSmoother::theUpdator

private

Definition at line 81 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), fit(), smooth(), updator(), and ~CosmicMuonSmoother().

theUtilities

const CosmicMuonUtilities* CosmicMuonSmoother::theUtilities

private

Definition at line 83 of file CosmicMuonSmoother.h.

Referenced by CosmicMuonSmoother(), fit(), initialState(), smooth(), utilities(), and ~CosmicMuonSmoother().