AdaptiveVertexFitter Class Reference

#include <AdaptiveVertexFitter.h>

Inheritance diagram for AdaptiveVertexFitter:

Public Types
typedef ReferenceCountingPointer < LinearizedTrackState< 5 > >	RefCountedLinearizedTrackState
typedef ReferenceCountingPointer < VertexTrack< 5 > >	RefCountedVertexTrack

Public Member Functions
	AdaptiveVertexFitter (const AnnealingSchedule &ann=GeometricAnnealing(), const LinearizationPointFinder &linP=DefaultLinearizationPointFinder(), const VertexUpdator< 5 > &updator=KalmanVertexUpdator< 5 >(), const VertexTrackCompatibilityEstimator< 5 > &estor=KalmanVertexTrackCompatibilityEstimator< 5 >(), const VertexSmoother< 5 > &smoother=DummyVertexSmoother< 5 >(), const AbstractLTSFactory< 5 > &ltsf=LinearizedTrackStateFactory())
	AdaptiveVertexFitter (const AdaptiveVertexFitter &original)
AdaptiveVertexFitter *	clone () const
void	gsfIntermediarySmoothing (bool sm)
bool	gsfIntermediarySmoothing () const
void	setParameters (double maxshift=0.0001, double maxlpshift=0.1, unsigned maxstep=30, double weightthreshold=.001)
void	setParameters (const edm::ParameterSet &)
void	setWeightThreshold (float w)
virtual CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &) const
virtual CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &) const
virtual CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &, const reco::BeamSpot &spot) const
virtual CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &, const GlobalPoint &linPoint) const
virtual CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &, const GlobalPoint &priorPos, const GlobalError &priorError) const
virtual CachingVertex< 5 >	vertex (const std::vector< reco::TransientTrack > &tracks, const reco::BeamSpot &beamSpot) const
virtual CachingVertex< 5 >	vertex (const std::vector< RefCountedVertexTrack > &, const GlobalPoint &priorPos, const GlobalError &priorError) const
virtual	~AdaptiveVertexFitter ()
Public Member Functions inherited from VertexFitter< 5 >
virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks) const =0
virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks, const reco::BeamSpot &spot) const =0
virtual CachingVertex< N >	vertex (const std::vector< typename CachingVertex< N >::RefCountedVertexTrack > &tracks, const GlobalPoint &priorPos, const GlobalError &priorError) const =0
	VertexFitter ()
virtual	~VertexFitter ()

Private Member Functions
CachingVertex< 5 >	fit (const std::vector< RefCountedVertexTrack > &tracks, const VertexState &priorSeed, bool withPrior) const
double	getWeight (float chi2) const
std::vector < RefCountedVertexTrack >	linearizeTracks (const std::vector< reco::TransientTrack > &, const VertexState &) const
std::vector < RefCountedVertexTrack >	reLinearizeTracks (const std::vector< RefCountedVertexTrack > &tracks, const CachingVertex< 5 > &vertex) const
std::vector < RefCountedVertexTrack >	reWeightTracks (const std::vector< RefCountedLinearizedTrackState > &, const CachingVertex< 5 > &seed) const
std::vector < RefCountedVertexTrack >	reWeightTracks (const std::vector< RefCountedVertexTrack > &, const CachingVertex< 5 > &seed) const
std::vector < RefCountedVertexTrack >	weightTracks (const std::vector< RefCountedLinearizedTrackState > &, const VertexState &seed) const

Private Attributes
bool	gsfIntermediarySmoothing_
int	mctr_
AnnealingSchedule *	theAssProbComputer
VertexTrackCompatibilityEstimator< 5 > *	theComp
LinearizationPointFinder *	theLinP
const AbstractLTSFactory< 5 > *	theLinTrkFactory
double	theMaxLPShift
double	theMaxShift
int	theMaxStep
int	theNr
VertexSmoother< 5 > *	theSmoother
VertexUpdator< 5 > *	theUpdator
double	theWeightThreshold

Detailed Description

An iterative reweighted fitter. Very robust, very adaptive.

See CMS Note 2007/008.

Exceptions VertexException( "Supplied fewer than two tracks" ) VertexException( "fewer than 2 significant tracks (w>threshold)" )

Definition at line 29 of file AdaptiveVertexFitter.h.

Member Typedef Documentation

typedef ReferenceCountingPointer<LinearizedTrackState<5> > AdaptiveVertexFitter::RefCountedLinearizedTrackState

Definition at line 34 of file AdaptiveVertexFitter.h.

typedef ReferenceCountingPointer<VertexTrack<5> > AdaptiveVertexFitter::RefCountedVertexTrack

Definition at line 33 of file AdaptiveVertexFitter.h.

Constructor & Destructor Documentation

AdaptiveVertexFitter::AdaptiveVertexFitter	(	const AnnealingSchedule &	ann = GeometricAnnealing(),
		const LinearizationPointFinder &	linP = DefaultLinearizationPointFinder(),
		const VertexUpdator< 5 > &	updator = KalmanVertexUpdator<5>(),
		const VertexTrackCompatibilityEstimator< 5 > &	estor = KalmanVertexTrackCompatibilityEstimator<5>(),
		const VertexSmoother< 5 > &	smoother = DummyVertexSmoother<5>(),
		const AbstractLTSFactory< 5 > &	ltsf = LinearizedTrackStateFactory()
	)

Reimplemented constructors to use any kind of linearisation point finder, vertex updator and smoother. If no smoother is to be used, do not specify an instance for it.

Definition at line 98 of file AdaptiveVertexFitter.cc.

References setParameters().

Referenced by clone().

                                           :
    theNr(0),
    theLinP(linP.clone()), theUpdator( updator.clone()),
    theSmoother ( smoother.clone() ), theAssProbComputer( ann.clone() ),
    theComp ( crit.clone() ), theLinTrkFactory ( ltsf.clone() ),
    gsfIntermediarySmoothing_(false)
{
  setParameters();
}

AdaptiveVertexFitter::AdaptiveVertexFitter

(

const AdaptiveVertexFitter &

original

)

Definition at line 120 of file AdaptiveVertexFitter.cc.

                                                          :
    theMaxShift ( o.theMaxShift ), theMaxLPShift ( o.theMaxLPShift ),
    theMaxStep ( o.theMaxStep ), theWeightThreshold ( o.theWeightThreshold ),
    theNr ( o.theNr ),
    theLinP ( o.theLinP->clone() ), theUpdator ( o.theUpdator->clone() ),
    theSmoother ( o.theSmoother->clone() ),
    theAssProbComputer ( o.theAssProbComputer->clone() ),
    theComp ( o.theComp->clone() ),
    theLinTrkFactory ( o.theLinTrkFactory->clone() ),
    gsfIntermediarySmoothing_(o.gsfIntermediarySmoothing_)
{}

AdaptiveVertexFitter::~AdaptiveVertexFitter ( )

virtual

Definition at line 132 of file AdaptiveVertexFitter.cc.

References theAssProbComputer, theComp, theLinP, theLinTrkFactory, theSmoother, and theUpdator.

{
  delete theLinP;
  delete theUpdator;
  delete theSmoother;
  delete theAssProbComputer;
  delete theComp;
  delete theLinTrkFactory;
}

Member Function Documentation

AdaptiveVertexFitter * AdaptiveVertexFitter::clone ( void  ) const

virtual

Fit vertex out of a VertexSeed

Implements VertexFitter< 5 >.

Definition at line 372 of file AdaptiveVertexFitter.cc.

References AdaptiveVertexFitter().

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter().

{
  return new AdaptiveVertexFitter( * this );
}

CachingVertex< 5 > AdaptiveVertexFitter::fit ( const std::vector< RefCountedVertexTrack > &  tracks, const VertexState &  priorSeed, bool  withPrior  ) const

private

perform the fit

Definition at line 522 of file AdaptiveVertexFitter.cc.

References VertexUpdator< N >::add(), AnnealingSchedule::anneal(), AnnealingSchedule::currentTemp(), VertexState::error(), mergeVDriftHistosByStation::file, getId(), gsfIntermediarySmoothing_, i, AnnealingSchedule::isAnnealed(), CachingVertex< N >::isValid(), LogDebug, m, mag(), PV3DBase< T, PVType, FrameType >::perp(), VertexState::position(), CachingVertex< N >::position(), reLinearizeTracks(), AnnealingSchedule::resetAnnealing(), reWeightTracks(), VertexSmoother< N >::smooth(), launcher::step, theAssProbComputer, theMaxLPShift, theMaxShift, theMaxStep, theSmoother, theUpdator, theWeightThreshold, transverse(), AnnealingSchedule::weight(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by vertex().

{
  // cout << "[AdaptiveVertexFit] fit with " << tracks.size() << endl;
  theAssProbComputer->resetAnnealing();

  vector<RefCountedVertexTrack> initialTracks;
  GlobalPoint priorVertexPosition = priorSeed.position();
  GlobalError priorVertexError = priorSeed.error();

  CachingVertex<5> returnVertex( priorVertexPosition,priorVertexError,
                              initialTracks,0);
  if (withPrior)
  {
    returnVertex = CachingVertex<5>(priorVertexPosition,priorVertexError,
                    priorVertexPosition,priorVertexError,initialTracks,0);
  }

  // vector<RefCountedVertexTrack> globalVTracks = tracks;
  // sort the tracks, according to distance to seed!
  vector<RefCountedVertexTrack> globalVTracks ( tracks.size() );

  partial_sort_copy ( tracks.begin(), tracks.end(), 
      globalVTracks.begin(), globalVTracks.end(), DistanceToRefPoint ( priorSeed.position() ) );

  // main loop through all the VTracks
  int lpStep = 0; int step = 0;

  CachingVertex<5> initialVertex = returnVertex;

  GlobalPoint newPosition = priorVertexPosition;
  GlobalPoint previousPosition = newPosition;

  int ns_trks=0; // number of significant tracks.
  // If we have only two significant tracks, we return an invalid vertex

  // cout << "[AdaptiveVertexFit] start " << tracks.size() << endl;
  /*
  for ( vector< RefCountedVertexTrack >::const_iterator 
        i=globalVTracks.begin(); i!=globalVTracks.end() ; ++i )
  {
    cout << "  " << (**i).linearizedTrack()->track().initialFreeState().momentum() << endl;
  }*/
  do {
    ns_trks=0;
    CachingVertex<5> fVertex = initialVertex;
    // cout << "[AdaptiveVertexFit] step " << step << " at " << fVertex.position() << endl;
    if ((previousPosition - newPosition).transverse() > theMaxLPShift)
    {
      // relinearize and reweight.
      // (reLinearizeTracks also reweights tracks)
      // cout << "[AdaptiveVertexFit] relinearize at " << returnVertex.position() << endl;
      if (gsfIntermediarySmoothing_) returnVertex = theSmoother->smooth(returnVertex);
      globalVTracks = reLinearizeTracks( globalVTracks, returnVertex );
      lpStep++;
    } else if (step) {
      // reweight, if it is not the first step
      // cout << "[AdaptiveVertexFit] reweight at " << returnVertex.position() << endl;
      if (gsfIntermediarySmoothing_) returnVertex = theSmoother->smooth(returnVertex);
      globalVTracks = reWeightTracks( globalVTracks, returnVertex );
    }
    // cout << "[AdaptiveVertexFit] relinarized, reweighted" << endl;
    // update sequentially the vertex estimate
    CachingVertex<5> nVertex;
    for(vector<RefCountedVertexTrack>::const_iterator i
          = globalVTracks.begin(); i != globalVTracks.end(); i++)
    {
      if ((**i).weight() > 0.) nVertex = theUpdator->add( fVertex, *i );
    else  nVertex = fVertex;
      if (nVertex.isValid()) {
        if ( (**i).weight() >= theWeightThreshold )
        {
          ns_trks++;
        };

        if ( fabs ( nVertex.position().z() ) > 10000. ||
             nVertex.position().perp()>120.)
        {
          // were more than 100 m off!!
          LogInfo ("AdaptiveVertexFitter" ) << "Vertex candidate just took off to " << nVertex.position()
                        << "! Will discard this update!";
//      //<< "track pt was " << (**i).linearizedTrack()->track().pt()
//                       << "track momentum was " << (**i).linearizedTrack()->track().initialFreeState().momentum()
//                       << "track position was " << (**i).linearizedTrack()->track().initialFreeState().position()
//                       << "track chi2 was " << (**i).linearizedTrack()->track().chi2()
//                       << "track ndof was " << (**i).linearizedTrack()->track().ndof()
//                       << "track w was " << (**i).weight()
//                       << "track schi2 was " << (**i).smoothedChi2();
        } else {
            fVertex = nVertex;
        }
      } else {
        LogInfo("RecoVertex/AdaptiveVertexFitter") 
          << "The updator returned an invalid vertex when adding track "
          << i-globalVTracks.begin() 
            << ".\n Your vertex might just have lost one good track.";
      };
    }
    previousPosition = newPosition;
    newPosition = fVertex.position();
    returnVertex = fVertex;
    theAssProbComputer->anneal();
    step++;
    if ( step >= theMaxStep ) break;

  } while (
      // repeat as long as
      // - vertex moved too much or
      // - we're not yet annealed
         ( ((previousPosition - newPosition).mag() > theMaxShift) ||
           (!(theAssProbComputer->isAnnealed()) ) ) ) ;

  if ( theWeightThreshold > 0. &&  ns_trks < 2 && !withPrior ) 
  {
    LogDebug("AdaptiveVertexFitter") 
      << "fewer than two significant tracks (w>" << theWeightThreshold << ")."
      << " Fitted vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  }

  #ifdef STORE_WEIGHTS
  map < string, dataharvester::MultiType > m;
  m["chi2"]=chi2;
  m["w"]=theAssProbComputer->weight(chi2);
  m["T"]=theAssProbComputer->currentTemp();
  m["n"]=iter;
  m["id"]=getId ( *i );
  m["pos"]="final";
  dataharvester::Writer::file("w.txt").save ( m );
  #endif
  // cout << "[AdaptiveVertexFit] /fit" << endl;
  return theSmoother->smooth( returnVertex );
}

double AdaptiveVertexFitter::getWeight ( float  chi2 ) const

private

Definition at line 377 of file AdaptiveVertexFitter.cc.

References alignCSCRings::e, theAssProbComputer, AnnealingSchedule::weight(), and CommonMethods::weight().

Referenced by reWeightTracks(), and weightTracks().

{
  double weight = theAssProbComputer->weight(chi2);

  if ( weight > 1.0 )
  {
    LogInfo("RecoVertex/AdaptiveVertexFitter") << "Weight " << weight << " > 1.0!";
    weight=1.0;
  };

  if ( weight < 1e-20 )
  {
    // LogInfo("RecoVertex/AdaptiveVertexFitter") << "Weight " << weight << " < 0.0!";
    weight=1e-20;
  };
  return weight;
}

void AdaptiveVertexFitter::gsfIntermediarySmoothing ( bool  sm )

inline

Definition at line 141 of file AdaptiveVertexFitter.h.

References gsfIntermediarySmoothing_.

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter().

{ gsfIntermediarySmoothing_ = sm; }

bool AdaptiveVertexFitter::gsfIntermediarySmoothing ( ) const

inline

Definition at line 143 of file AdaptiveVertexFitter.h.

References gsfIntermediarySmoothing_.

{ return gsfIntermediarySmoothing_;}

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::linearizeTracks ( const std::vector< reco::TransientTrack > &  tracks, const VertexState &  seed  ) const

private

Linearize tracks, for the first time in the iteration.

Construct a container of VertexTrack from a set of reco::TransientTracks. As this is the first iteration of the adaptive fit, the initial error does not enter in the computation of the weights. This is to avoid that all tracks get the same weight when using a very large initial error matrix.

Definition at line 317 of file AdaptiveVertexFitter.cc.

References alignCSCRings::e, cppFunctionSkipper::exception, i, AbstractLTSFactory< N >::linearizedTrackState(), VertexState::position(), theLinTrkFactory, and weightTracks().

Referenced by vertex().

{
  const GlobalPoint & linP ( seed.position() );
  vector<RefCountedLinearizedTrackState> lTracks;
  for(vector<reco::TransientTrack>::const_iterator i = tracks.begin();
      i != tracks.end(); ++i )
  {
    try {
      RefCountedLinearizedTrackState lTrData
        = theLinTrkFactory->linearizedTrackState(linP, *i);
      lTracks.push_back(lTrData);
    } catch ( exception & e ) {
      LogInfo("RecoVertex/AdaptiveVertexFitter") 
        << "Exception " << e.what() << " in ::linearizeTracks."
        << "Your future vertex has just lost a track.";
    };
  }
  return weightTracks(lTracks, seed );
}

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reLinearizeTracks ( const std::vector< RefCountedVertexTrack > &  tracks, const CachingVertex< 5 > &  vertex  ) const

private

Construct new a container of VertexTrack with a new linearization point and vertex seed, from an existing set of VertexTrack, from which only the recTracks will be used.

Parameters

tracks	The original container of VertexTracks, from which the reco::TransientTracks will be extracted.
vertex	The seed to use for the VertexTracks. This position will also be used as the new linearization point.

Returns

The container of VertexTracks which are to be used in the next fit.

Construct new a container of VertexTrack with a new linearization point and vertex seed, from an existing set of VertexTrack, from which only the recTracks will be used.

Definition at line 344 of file AdaptiveVertexFitter.cc.

References alignCSCRings::e, cppFunctionSkipper::exception, i, AbstractLTSFactory< N >::linearizedTrackState(), VertexState::position(), reWeightTracks(), theLinTrkFactory, and CachingVertex< N >::vertexState().

Referenced by fit().

{
  VertexState seed = vertex.vertexState();
  GlobalPoint linP = seed.position();
  vector<RefCountedLinearizedTrackState> lTracks;
  for(vector<RefCountedVertexTrack>::const_iterator i = tracks.begin();
    i != tracks.end(); i++)
  {
    try {
      RefCountedLinearizedTrackState lTrData
        = theLinTrkFactory->linearizedTrackState( linP, (**i).linearizedTrack()->track() );
      /*
      RefCountedLinearizedTrackState lTrData =
              (**i).linearizedTrack()->stateWithNewLinearizationPoint(linP);
              */
      lTracks.push_back(lTrData);
    } catch ( exception & e ) {
      LogInfo("RecoVertex/AdaptiveVertexFitter") 
        << "Exception " << e.what() << " in ::relinearizeTracks. "
        << "Will not relinearize this track.";
      lTracks.push_back ( (**i).linearizedTrack() );
    };
  };
  return reWeightTracks(lTracks, vertex );
}

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reWeightTracks ( const std::vector< RefCountedLinearizedTrackState > &  lTracks, const CachingVertex< 5 > &  seed  ) const

private

Construct a new container of VertexTracks with new weights accounting for vertex error, from an existing set of LinearizedTracks.

Definition at line 396 of file AdaptiveVertexFitter.cc.

References AnnealingSchedule::currentTemp(), VertexTrackCompatibilityEstimator< N >::estimate(), mergeVDriftHistosByStation::file, getId(), getWeight(), i, m, CachingVertex< N >::position(), python.multivaluedict::sort(), theAssProbComputer, theComp, theNr, CachingVertex< N >::vertexState(), VertexTrackFactory< N >::vertexTrack(), AnnealingSchedule::weight(), and CommonMethods::weight().

Referenced by fit(), reLinearizeTracks(), and reWeightTracks().

{
  VertexState seed = vertex.vertexState();
  // cout << "[AdaptiveVertexFitter] now reweight around " << seed.position() << endl;
  theNr++;
  // GlobalPoint pos = seed.position();

  vector<RefCountedVertexTrack> finalTracks;
  VertexTrackFactory<5> vTrackFactory;
  #ifdef STORE_WEIGHTS
  iter++;
  #endif
  for(vector<RefCountedLinearizedTrackState>::const_iterator i
        = lTracks.begin(); i != lTracks.end(); i++)
  {
    double weight=0.;
    // cout << "[AdaptiveVertexFitter] estimate " << endl;
    pair < bool, double > chi2Res ( false, 0. );
    try {
      chi2Res =  theComp->estimate ( vertex, *i );
    } catch ( ... ) {};
    // cout << "[AdaptiveVertexFitter] /estimate " << endl;
    if (!chi2Res.first) {
      // cout << "[AdaptiveVertexFitter] aie... vertex candidate is at  " << vertex.position() << endl;
      LogInfo("AdaptiveVertexFitter" ) << "When reweighting, chi2<0. Will add this track with w=0.";
      // edm::LogInfo("AdaptiveVertexFitter" ) << "pt=" << (**i).track().pt();
    }else {
      weight = getWeight ( chi2Res.second );
    }
    
    RefCountedVertexTrack vTrData
       = vTrackFactory.vertexTrack(*i, seed, weight );

    #ifdef STORE_WEIGHTS
    map < string, dataharvester::MultiType > m;
    m["chi2"]=chi2;
    m["w"]=theAssProbComputer->weight(chi2);
    m["T"]=theAssProbComputer->currentTemp();
    m["n"]=iter;
    m["pos"]="reweight";
    m["id"]=getId ( *i );
    dataharvester::Writer::file("w.txt").save ( m );
    #endif

    finalTracks.push_back(vTrData);
  }
  sort ( finalTracks.begin(), finalTracks.end(), 
         DistanceToRefPoint ( vertex.position() ) );
  // cout << "[AdaptiveVertexFitter] /now reweight" << endl;
  return finalTracks;
}

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::reWeightTracks ( const std::vector< RefCountedVertexTrack > &  tracks, const CachingVertex< 5 > &  seed  ) const

private

Construct new a container of VertexTracks with new weights accounting for vertex error, from an existing set of VertexTracks. From these the LinearizedTracks will be reused.

Construct new a container of VertexTrack with new weights accounting for vertex error, from an existing set of VertexTracks. From these the LinearizedTracks will be reused.

Definition at line 502 of file AdaptiveVertexFitter.cc.

References i, and reWeightTracks().

{
  vector<RefCountedLinearizedTrackState> lTracks;
  for(vector<RefCountedVertexTrack>::const_iterator i = tracks.begin();
    i != tracks.end(); i++)
  {
    lTracks.push_back((**i).linearizedTrack());
  }

  return reWeightTracks(lTracks, seed);
}

void AdaptiveVertexFitter::setParameters	(	double	maxshift = 0.0001,
		double	maxlpshift = 0.1,
		unsigned	maxstep = 30,
		double	weightthreshold = .001
	)

Reads the configurable parameters.

Parameters

maxshift	if the vertex moves further than this (in cm), then we re-iterate.
maxlpshift	if the vertex moves further than this, then we re-linearize the tracks.
maxstep	that's the maximum of iterations that we allow for.
weightthreshold	that's the minimum track weight for a track to be considered "significant". If fewer than two tracks are significant, an exception is thrown.

Definition at line 142 of file AdaptiveVertexFitter.cc.

References theMaxLPShift, theMaxShift, theMaxStep, and theWeightThreshold.

Referenced by AdaptiveGsfVertexFitter::AdaptiveGsfVertexFitter(), AdaptiveVertexFitter(), ConfigurableAdaptiveFitter::configure(), and setParameters().

{
  theMaxShift = maxshift;
  theMaxLPShift = maxlpshift;
  theMaxStep = maxstep;
  theWeightThreshold=weightthreshold;
}

void AdaptiveVertexFitter::setParameters

(

const edm::ParameterSet &

s

)

Sets parameters. The following parameters are expected: maxshift, maxlpshift, maxstep, weightthreshold

Definition at line 152 of file AdaptiveVertexFitter.cc.

References edm::ParameterSet::getParameter(), and setParameters().

{
    setParameters ( s.getParameter<double>("maxshift"),
                    s.getParameter<double>("maxlpshift"),
                    s.getParameter<int>("maxstep"),
                    s.getParameter<double>("weightthreshold") );
}

void AdaptiveVertexFitter::setWeightThreshold

(

float

w

)

Set the weight threshold should be used only to find (once) a good value FIXME this should disappear in the final version

Definition at line 114 of file AdaptiveVertexFitter.cc.

References theWeightThreshold, and w().

Referenced by AdaptiveVertexReconstructor::setupFitters().

{
  theWeightThreshold=w;
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< reco::TransientTrack > &  unstracks ) const

virtual

Method returning the fitted vertex, from a container of reco::TransientTracks. The linearization point will be searched with the given LP finder. No prior vertex position will be used in the vertex fit.

Returns

The fitted vertex

Implements VertexFitter< 5 >.

Definition at line 161 of file AdaptiveVertexFitter.cc.

References fit(), LinearizationPointFinder::getLinearizationPoint(), linearizeTracks(), python.multivaluedict::sort(), theLinP, and testEve_cfg::tracks.

Referenced by NuclearVertexBuilder::FillVertexWithAdaptVtxFitter(), V0Fitter::fitAll(), PFDisplacedVertexFinder::fitVertexFromSeed(), PrimaryVertexAnalyzer4PU::getSimEvents(), InclusiveVertexFinder::produce(), TrackVertexArbitration::trackVertexArbitrator(), AdaptiveGsfVertexFitter::vertex(), and AdaptiveVertexReconstructor::vertices().

{
  if ( unstracks.size() < 2 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied fewer than two tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  vector < reco::TransientTrack > tracks = unstracks;
  sort ( tracks.begin(), tracks.end(), CompareTwoTracks() );
  // Linearization Point
  GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
  // Initial vertex seed, with a very large error matrix
  VertexState lseed (linP, linPointError() );
  vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, lseed);

  VertexState seed (linP, fitError() );
  return fit(vtContainer, seed, false);
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< RefCountedVertexTrack > &  tracks ) const

virtual

Method returning the fitted vertex, from a container of VertexTracks. For the first loop, the LinearizedTrack contained in the VertexTracks will be used. If subsequent loops are needed, the new VertexTracks will be created with the last estimate of the vertex as linearization point. No prior vertex position will be used in the vertex fit.

Returns

The fitted vertex

Definition at line 182 of file AdaptiveVertexFitter.cc.

References fit().

{
  if ( tracks.size() < 2 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied fewer than two tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  // Initial vertex seed, with a very small weight matrix
  GlobalPoint linP = tracks[0]->linearizedTrack()->linearizationPoint();
  VertexState seed (linP, fitError() );
  return fit(tracks, seed, false);
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< RefCountedVertexTrack > &  tracks, const reco::BeamSpot &  spot  ) const

virtual

Same as above, only now also with BeamSpot constraint.

Definition at line 197 of file AdaptiveVertexFitter.cc.

References fit().

{
  if ( tracks.size() < 1 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied no tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  VertexState beamSpotState(spot);
  return fit(tracks, beamSpotState, true );
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< reco::TransientTrack > &  tracks, const GlobalPoint &  linPoint  ) const

virtual

Fit vertex out of a std::vector of reco::TransientTracks. Uses the specified linearization point.

Fit vertex out of a set of reco::TransientTracks. Uses the specified linearization point.

Implements VertexFitter< 5 >.

Definition at line 215 of file AdaptiveVertexFitter.cc.

References fit(), and linearizeTracks().

{
  if ( tracks.size() < 2 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied fewer than two tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  // Initial vertex seed, with a very large error matrix
  VertexState seed (linPoint, linPointError() );
  vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, seed);
  VertexState fitseed (linPoint, fitError() );
  return fit(vtContainer, fitseed, false);
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< reco::TransientTrack > &  tracks, const GlobalPoint &  priorPos, const GlobalError &  priorError  ) const

virtual

Fit vertex out of a set of reco::TransientTracks. Uses the position as both the linearization point AND as prior estimate of the vertex position. The error is used for the weight of the prior estimate.

Implements VertexFitter< 5 >.

Definition at line 272 of file AdaptiveVertexFitter.cc.

References fit(), and linearizeTracks().

{
  if ( tracks.size() < 1 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied no tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  VertexState seed (priorPos, priorError);
  vector<RefCountedVertexTrack> vtContainer = linearizeTracks(tracks, seed);
  return fit( vtContainer, seed, true );
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< reco::TransientTrack > &  tracks, const reco::BeamSpot &  beamSpot  ) const

virtual

Fit vertex out of a set of TransientTracks. The specified BeamSpot will be used as priot, but NOT for the linearization. The specified LinearizationPointFinder will be used to find the linearization point.

Implements VertexFitter< 5 >.

Definition at line 237 of file AdaptiveVertexFitter.cc.

References fit(), LinearizationPointFinder::getLinearizationPoint(), linearizeTracks(), python.multivaluedict::sort(), theLinP, and testEve_cfg::tracks.

{
  if ( unstracks.size() < 1 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied no tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };

  VertexState beamSpotState(beamSpot);
  vector<RefCountedVertexTrack> vtContainer;

  vector < reco::TransientTrack > tracks = unstracks;
  sort ( tracks.begin(), tracks.end(), CompareTwoTracks() );

  if (tracks.size() > 1) {
    // Linearization Point search if there are more than 1 track
    GlobalPoint linP = theLinP->getLinearizationPoint(tracks);
    VertexState lpState(linP, linPointError() );
    vtContainer = linearizeTracks(tracks, lpState);
  } else {
    // otherwise take the beamspot position.
    vtContainer = linearizeTracks(tracks, beamSpotState);
  }

  return fit(vtContainer, beamSpotState, true);
}

CachingVertex< 5 > AdaptiveVertexFitter::vertex ( const std::vector< RefCountedVertexTrack > &  tracks, const GlobalPoint &  priorPos, const GlobalError &  priorError  ) const

virtual

Fit vertex out of a set of VertexTracks Uses the position and error for the prior estimate of the vertex. This position is not used to relinearize the tracks.

Definition at line 293 of file AdaptiveVertexFitter.cc.

References fit().

{
  if ( tracks.size() < 1 )
  {
    LogError("RecoVertex|AdaptiveVertexFitter")
      << "Supplied no tracks. Vertex is invalid.";
    return CachingVertex<5>(); // return invalid vertex
  };
  VertexState seed (priorPos, priorError);
  return fit(tracks, seed, true);
}

vector< AdaptiveVertexFitter::RefCountedVertexTrack > AdaptiveVertexFitter::weightTracks ( const std::vector< RefCountedLinearizedTrackState > &  lTracks, const VertexState &  seed  ) const

private

Weight the tracks, for the first time, using KalmanChiSquare.

track weighting, as opposed to re-weighting, must always be done with a reset annealer!

Definition at line 451 of file AdaptiveVertexFitter.cc.

References AnnealingSchedule::currentTemp(), VertexTrackCompatibilityEstimator< N >::estimate(), mergeVDriftHistosByStation::file, getId(), getWeight(), i, m, AnnealingSchedule::resetAnnealing(), theAssProbComputer, theComp, theNr, VertexTrackFactory< N >::vertexTrack(), AnnealingSchedule::weight(), and CommonMethods::weight().

Referenced by linearizeTracks().

{
  theNr++;
  CachingVertex<5> seedvtx ( seed, vector<RefCountedVertexTrack> (), 0. );
  theAssProbComputer->resetAnnealing();

  vector<RefCountedVertexTrack> finalTracks;
  VertexTrackFactory<5> vTrackFactory;
  #ifdef STORE_WEIGHTS
  iter++;
  #endif
  for(vector<RefCountedLinearizedTrackState>::const_iterator i
        = lTracks.begin(); i != lTracks.end(); i++)
  {

    double weight = 0.;
    pair<bool, double> chi2Res = theComp->estimate ( seedvtx, *i );
    if (!chi2Res.first) {
      // cout << "[AdaptiveVertexFitter] Aiee! " << endl;
      LogInfo ("AdaptiveVertexFitter" ) << "When weighting a track, chi2 calculation failed;"
                                           << " will add with w=0.";
    } else {
      weight = getWeight ( chi2Res.second );
    }
    RefCountedVertexTrack vTrData
       = vTrackFactory.vertexTrack(*i, seed, weight );
    #ifdef STORE_WEIGHTS
    map < string, dataharvester::MultiType > m;
    m["chi2"]=chi2;
    m["w"]=theAssProbComputer->weight(chi2);
    m["T"]=theAssProbComputer->currentTemp();
    m["n"]=iter;
    m["id"]=getId ( *i );
    m["pos"]="weight";
    dataharvester::Writer::file("w.txt").save ( m );
    #endif
    finalTracks.push_back(vTrData);
  }
  return finalTracks;
}

Member Data Documentation

bool AdaptiveVertexFitter::gsfIntermediarySmoothing_

private

Definition at line 215 of file AdaptiveVertexFitter.h.

Referenced by fit(), and gsfIntermediarySmoothing().

int AdaptiveVertexFitter::mctr_

mutableprivate

Definition at line 216 of file AdaptiveVertexFitter.h.

AnnealingSchedule* AdaptiveVertexFitter::theAssProbComputer

private

Definition at line 212 of file AdaptiveVertexFitter.h.

Referenced by fit(), getWeight(), reWeightTracks(), weightTracks(), and ~AdaptiveVertexFitter().

VertexTrackCompatibilityEstimator<5>* AdaptiveVertexFitter::theComp

private

Definition at line 213 of file AdaptiveVertexFitter.h.

Referenced by reWeightTracks(), weightTracks(), and ~AdaptiveVertexFitter().

LinearizationPointFinder* AdaptiveVertexFitter::theLinP

private

Definition at line 209 of file AdaptiveVertexFitter.h.

Referenced by vertex(), and ~AdaptiveVertexFitter().

const AbstractLTSFactory<5>* AdaptiveVertexFitter::theLinTrkFactory

private

Definition at line 214 of file AdaptiveVertexFitter.h.

Referenced by linearizeTracks(), reLinearizeTracks(), and ~AdaptiveVertexFitter().

double AdaptiveVertexFitter::theMaxLPShift

private

Definition at line 204 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

double AdaptiveVertexFitter::theMaxShift

private

Definition at line 203 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

int AdaptiveVertexFitter::theMaxStep

private

Definition at line 205 of file AdaptiveVertexFitter.h.

Referenced by fit(), and setParameters().

int AdaptiveVertexFitter::theNr

mutableprivate

Definition at line 207 of file AdaptiveVertexFitter.h.

Referenced by reWeightTracks(), and weightTracks().

VertexSmoother<5>* AdaptiveVertexFitter::theSmoother

private

Definition at line 211 of file AdaptiveVertexFitter.h.

Referenced by fit(), and ~AdaptiveVertexFitter().

VertexUpdator<5>* AdaptiveVertexFitter::theUpdator

private

Definition at line 210 of file AdaptiveVertexFitter.h.

Referenced by fit(), and ~AdaptiveVertexFitter().

double AdaptiveVertexFitter::theWeightThreshold

private

Definition at line 206 of file AdaptiveVertexFitter.h.

Referenced by fit(), setParameters(), and setWeightThreshold().