MultiVertexFitter Class Reference

#include <MultiVertexFitter.h>

Public Types
typedef std::map< int, double >	SeedToWeightMap
typedef std::map< reco::TransientTrack, SeedToWeightMap >	TrackAndSeedToWeightMap
typedef std::pair< reco::TransientTrack, float >	TrackAndWeight

Public Member Functions
	MultiVertexFitter (const AnnealingSchedule &sched=DefaultMVFAnnealing(), const LinearizationPointFinder &seeder=DefaultLinearizationPointFinder(), float revive_below=-1.)
	MultiVertexFitter (const MultiVertexFitter &)
std::vector< CachingVertex< 5 > >	vertices (const std::vector< std::vector< reco::TransientTrack > > &, const std::vector< reco::TransientTrack > &primaries=std::vector< reco::TransientTrack >())
std::vector< CachingVertex< 5 > >	vertices (const std::vector< std::vector< TrackAndWeight > > &, const std::vector< reco::TransientTrack > &primaries=std::vector< reco::TransientTrack >())
std::vector< CachingVertex< 5 > >	vertices (const std::vector< CachingVertex< 5 > > &, const std::vector< reco::TransientTrack > &primaries=std::vector< reco::TransientTrack >())
std::vector< CachingVertex< 5 > >	vertices (const std::vector< TransientVertex > &, const std::vector< reco::TransientTrack > &primaries=std::vector< reco::TransientTrack >())
	~MultiVertexFitter ()

Private Types
typedef ReferenceCountingPointer< LinearizedTrackState< 5 > >	RefCountedLinearizedTrackState
typedef CachingVertex< 5 >::RefCountedVertexTrack	RefCountedVertexTrack

Private Member Functions
void	clear ()
void	createPrimaries (const std::vector< reco::TransientTrack > &tracks)
void	createSeed (const std::vector< reco::TransientTrack > &tracks)
void	createSeed (const std::vector< TrackAndWeight > &tracks)
std::vector< CachingVertex< 5 > >	fit ()
void	lostVertexClaimer ()
void	printSeeds () const
void	printWeights () const
void	printWeights (const reco::TransientTrack &) const
void	resetSeedNr ()
int	seedNr ()
bool	updateSeeds ()
void	updateWeights ()

Private Attributes
AnnealingSchedule *	theAssComp
LinTrackCache	theCache
std::set< reco::TransientTrack >	thePrimaries
float	theReviveBelow
LinearizationPointFinder *	theSeeder
std::vector< reco::TransientTrack >	theTracks
int	theVertexStateNr
std::vector< std::pair< int, CachingVertex< 5 > > >	theVertexStates
TrackAndSeedToWeightMap	theWeights

Detailed Description

fits n vertices in parallel, associating weights for every track-vertex std::pair. The special constructor's arguments take precedence over the SimpleConfigurables.

SimpleConfigurables:

MultiVertexFitter:Debug = 0 MultiVertexFitter:DisplacementLimit = 0.00001 MultiVertexFitter:MaxIterations = 30 MultiVertexFitter:ClaimLostVertices = true MultiVertexFitter:MinimumWeightFraction = 1e-6 MultiVertexFitter:ReviveBelow = 0.3 MultiVertexFitter:DiscardLightWeights = true

Definition at line 15 of file MultiVertexFitter.h.

Member Typedef Documentation

RefCountedLinearizedTrackState

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

private

Definition at line 100 of file MultiVertexFitter.h.

RefCountedVertexTrack

typedef CachingVertex<5>::RefCountedVertexTrack MultiVertexFitter::RefCountedVertexTrack

private

Definition at line 99 of file MultiVertexFitter.h.

SeedToWeightMap

typedef std::map<int, double> MultiVertexFitter::SeedToWeightMap

Definition at line 42 of file MultiVertexFitter.h.

TrackAndSeedToWeightMap

typedef std::map<reco::TransientTrack, SeedToWeightMap> MultiVertexFitter::TrackAndSeedToWeightMap

Definition at line 43 of file MultiVertexFitter.h.

TrackAndWeight

typedef std::pair<reco::TransientTrack, float> MultiVertexFitter::TrackAndWeight

Definition at line 41 of file MultiVertexFitter.h.

Constructor & Destructor Documentation

MultiVertexFitter() [1/2]

MultiVertexFitter::MultiVertexFitter	(	const AnnealingSchedule &	sched = DefaultMVFAnnealing(),
		const LinearizationPointFinder &	seeder = DefaultLinearizationPointFinder(),
		float	revive_below = -1.
	)

Definition at line 266 of file MultiVertexFitter.cc.

    : theVertexStateNr(0), theReviveBelow(revive_below), theAssComp(ann.clone()), theSeeder(seeder.clone()) {}

MultiVertexFitter() [2/2]

MultiVertexFitter::MultiVertexFitter

(

const MultiVertexFitter &

o

)

Definition at line 271 of file MultiVertexFitter.cc.

    : theVertexStateNr(o.theVertexStateNr),
      theReviveBelow(o.theReviveBelow),
      theAssComp(o.theAssComp->clone()),
      theSeeder(o.theSeeder->clone()) {}

~MultiVertexFitter()

MultiVertexFitter::~MultiVertexFitter

(

)

Definition at line 277 of file MultiVertexFitter.cc.

References theAssComp, and theSeeder.

                                      {
  delete theAssComp;
  delete theSeeder;
}

Member Function Documentation

clear()

void MultiVertexFitter::clear ( void  )

private

Definition at line 79 of file MultiVertexFitter.cc.

                              {
  theAssComp->resetAnnealing();
  theTracks.clear();
  thePrimaries.clear();
  theVertexStates.clear();
  theWeights.clear();
  theCache.clear();
}

createPrimaries()

void MultiVertexFitter::createPrimaries ( const std::vector< reco::TransientTrack > &  tracks )

private

Definition at line 103 of file MultiVertexFitter.cc.

References mps_fire::i, and DiMuonV_cfg::tracks.

                                                                                   {
  // cout << "[MultiVertexFitter] creating primaries: ";
  for (vector<reco::TransientTrack>::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
    thePrimaries.insert(*i);
    // cout << i->id() << "  ";
  }
  // cout << endl;
}

createSeed() [1/2]

void MultiVertexFitter::createSeed ( const std::vector< reco::TransientTrack > &  tracks )

private

Definition at line 91 of file MultiVertexFitter.cc.

References HLT_2024v11_cff::track, DiMuonV_cfg::tracks, and L1BJetProducer_cff::vtx.

                                                                       {
  if (tracks.size() > 1) {
    CachingVertex<5> vtx = createSeedFromLinPt(theSeeder->getLinearizationPoint(tracks));
    int snr = seedNr();
    theVertexStates.push_back(pair<int, CachingVertex<5> >(snr, vtx));
    for (vector<TransientTrack>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
      theWeights[*track][snr] = 1.;
      theTracks.push_back(*track);
    };
  };
}

createSeed() [2/2]

void MultiVertexFitter::createSeed ( const std::vector< TrackAndWeight > &  tracks )

private

Definition at line 116 of file MultiVertexFitter.cc.

References gather_cfg::cout, submitPVResolutionJobs::err, mps_fire::i, jetUpdater_cfi::sort, HLT_2024v11_cff::track, DiMuonV_cfg::tracks, KalmanVertexFitter::vertex(), VertexTrackFactory< N >::vertexTrack(), L1BJetProducer_cff::vtx, and mps_merge::weight.

                                                                       {
  // create initial seed for every bundle
  vector<RefCountedVertexTrack> newTracks;

  for (vector<TrackAndWeight>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
    double weight = validWeight(track->second);
    const GlobalPoint &pos = track->first.impactPointState().globalPosition();
    GlobalError err;  // FIXME
    VertexState realseed(pos, err);

    RefCountedLinearizedTrackState lTrData = theCache.linTrack(pos, track->first);

    VertexTrackFactory<5> vTrackFactory;
    RefCountedVertexTrack vTrData = vTrackFactory.vertexTrack(lTrData, realseed, weight);
    newTracks.push_back(vTrData);
  };

  if (newTracks.size() > 1) {
    CachingVertex<5> vtx = KalmanVertexFitter().vertex(newTracks);
    int snr = seedNr();
    theVertexStates.push_back(pair<int, CachingVertex<5> >(snr, vtx));

    // We initialise the weights with the original
    // user supplied weights.
    for (vector<TrackAndWeight>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
      if (thePrimaries.count(track->first)) {
        /*
        cout << "[MultiVertexFitter] " << track->first.id() << " is a primary."
             << " setting weight for state " << theVertexStates[0].first
             << " to " << track->second
             << endl;
             */
        theWeights[track->first][theVertexStates[0].first] = track->second;
        continue;
      };
      float weight = track->second;
      if (weight > 1.0) {
        cout << "[MultiVertexFitter] error weight " << weight << " > 1.0 given." << endl;
        cout << "[MultiVertexFitter] will revert to 1.0" << endl;
        weight = 1.0;
      };
      if (weight < 0.0) {
        cout << "[MultiVertexFitter] error weight " << weight << " < 0.0 given." << endl;
        cout << "[MultiVertexFitter] will revert to 0.0" << endl;
        weight = 0.0;
      };
      theWeights[track->first][snr] = weight;
      theTracks.push_back(track->first);
    };
  };

  // this thing will actually have to discard tracks
  // that have been submitted - attached to a different vertex - already.
  // sort ( theTracks.begin(), theTracks.end(), CompareRaveTracks() );
  sort(theTracks.begin(), theTracks.end());
  for (vector<TransientTrack>::iterator i = theTracks.begin(); i < theTracks.end(); ++i) {
    if (i != theTracks.begin()) {
      if ((*i) == (*(i - 1))) {
        theTracks.erase(i);
      };
    };
  };
}

fit()

vector< CachingVertex< 5 > > MultiVertexFitter::fit ( void  )

private

Definition at line 474 of file MultiVertexFitter.cc.

References AnnealingSchedule::anneal(), gather_cfg::cout, dqmiodatasetharvest::ctr, mps_fire::i, AnnealingSchedule::isAnnealed(), printWeights(), resetSeedNr(), runTheMatrix::ret, theAssComp, theVertexStates, updateSeeds(), trackerHitRTTI::vector, and verbose.

Referenced by trackingPlots.Iteration::modules().

                                                 {
  if (verbose() & 2)
    printWeights();
  int ctr = 1;
  static const int ctr_max = 50; /* SimpleConfigurable<int>(100,
      "MultiVertexFitter:MaxIterations").value(); */
  while (updateSeeds() || !(theAssComp->isAnnealed())) {
    if (++ctr >= ctr_max)
      break;
    theAssComp->anneal();
    // lostVertexClaimer(); // was a silly(?) idea to "revive" vertex candidates.
    resetSeedNr();
  };

  if (verbose()) {
    cout << "[MultiVertexFitter] number of iterations: " << ctr << endl;
    cout << "[MultiVertexFitter] remaining seeds: " << theVertexStates.size() << endl;
    printWeights();
  };

  vector<CachingVertex<5> > ret;
  for (vector<pair<int, CachingVertex<5> > >::const_iterator i = theVertexStates.begin(); i != theVertexStates.end();
       ++i) {
    ret.push_back(i->second);
  };

  return ret;
}

lostVertexClaimer()

void MultiVertexFitter::lostVertexClaimer ( )

private

Definition at line 541 of file MultiVertexFitter.cc.

References gather_cfg::cout, mps_fire::i, printWeights(), theReviveBelow, theTracks, theVertexStates, theWeights, trackerHitRTTI::vector, and verbose.

                                          {
  if (!(theReviveBelow < 0.))
    return;
  // this experimental method is used to get almost lost vertices
  // back into the play by upweighting vertices with very low total weights

  bool has_revived = false;
  // find out about total weight
  for (vector<pair<int, CachingVertex<5> > >::const_iterator i = theVertexStates.begin(); i != theVertexStates.end();
       ++i) {
    double totweight = 0.;
    for (vector<TransientTrack>::const_iterator trk = theTracks.begin(); trk != theTracks.end(); ++trk) {
      totweight += theWeights[*trk][i->first];
    };

    /*
    cout << "[MultiVertexFitter] vertex seed " << TransientVertexNamer().name(*i)
         << " total weight=" << totweight << endl;*/

    if (totweight < theReviveBelow && totweight > 0.0) {
      cout << "[MultiVertexFitter] now trying to revive vertex"
           << " revive_below=" << theReviveBelow << endl;
      has_revived = true;
      for (vector<TransientTrack>::const_iterator trk = theTracks.begin(); trk != theTracks.end(); ++trk) {
        theWeights[*trk][i->first] /= totweight;
      };
    };
  };
  if (has_revived && verbose())
    printWeights();
}

printSeeds()

void MultiVertexFitter::printSeeds ( ) const

private

Definition at line 530 of file MultiVertexFitter.cc.

References gather_cfg::cout.

Referenced by updateSeeds().

                                         {
  cout << endl << "Seed table: " << endl << "=====================" << endl;
  /*
  for ( vector < pair < int, CachingVertex<5> > >::const_iterator seed=theVertexStates.begin();
        seed!=theVertexStates.end(); ++seed )
  {
    cout << "  Vertex[" << TransientVertexNamer().name(seed->second) << "] at "
         << seed->second.position() << endl;
  };*/
}

printWeights() [1/2]

void MultiVertexFitter::printWeights ( ) const

private

Definition at line 520 of file MultiVertexFitter.cc.

References gather_cfg::cout, thePrimaries, and theTracks.

Referenced by fit(), lostVertexClaimer(), and updateWeights().

                                           {
  cout << endl << "Weight table: " << endl << "=================" << endl;
  for (set<TransientTrack>::const_iterator trk = thePrimaries.begin(); trk != thePrimaries.end(); ++trk) {
    printWeights(*trk);
  };
  for (vector<TransientTrack>::const_iterator trk = theTracks.begin(); trk != theTracks.end(); ++trk) {
    printWeights(*trk);
  };
}

printWeights() [2/2]

void MultiVertexFitter::printWeights ( const reco::TransientTrack &  t ) const

private

Definition at line 503 of file MultiVertexFitter.cc.

References a, b, gather_cfg::cout, fileCollector::seed, submitPVValidationJobs::t, theVertexStates, theWeights, heppy_batch::val, and trackerHitRTTI::vector.

                                                                      {
  // cout << "Trk " << t.id();
  for (vector<pair<int, CachingVertex<5> > >::const_iterator seed = theVertexStates.begin();
       seed != theVertexStates.end();
       ++seed) {
    double val = 0;
    auto a = theWeights.find(t);
    if (a != theWeights.end()) {
      auto b = a->second.find(seed->first);
      if (b != a->second.end())
        val = b->second;
    }
    cout << "  -- Vertex[" << seed->first << "] with " << setw(12) << setprecision(3) << val;
  };
  cout << endl;
}

resetSeedNr()

void MultiVertexFitter::resetSeedNr ( )

private

Definition at line 114 of file MultiVertexFitter.cc.

Referenced by fit().

{ theVertexStateNr = 0; }

seedNr()

int MultiVertexFitter::seedNr ( )

private

Definition at line 112 of file MultiVertexFitter.cc.

Referenced by updateSeeds().

{ return theVertexStateNr++; }

updateSeeds()

bool MultiVertexFitter::updateSeeds ( )

private

Definition at line 356 of file MultiVertexFitter.cc.

References gather_cfg::cout, MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, geometryDiff::file, mps_fire::i, LinTrackCache::linTrack(), mag(), CachingVertex< N >::position(), printSeeds(), fileCollector::seed, seedNr(), theCache, thePrimaries, theTracks, theVertexStates, theWeights, HLT_2024v11_cff::track, updateWeights(), trackerHitRTTI::vector, verbose, KalmanVertexFitter::vertex(), and VertexTrackFactory< N >::vertexTrack().

Referenced by fit().

                                    {
  double max_disp = 0.;
  // need to fit with the right weights.
  // also trigger an updateWeights.
  // if the seeds dont move much we return true

  vector<pair<int, CachingVertex<5> > > newSeeds;

  for (vector<pair<int, CachingVertex<5> > >::const_iterator seed = theVertexStates.begin();
       seed != theVertexStates.end();
       ++seed) {
    // for each seed get the tracks with the right weights.
    // TransientVertex rv = seed->second;
    // const GlobalPoint & seedpos = seed->second.position();
    int snr = seed->first;
    VertexState realseed(seed->second.position(), seed->second.error());

    double totweight = 0.;
    for (vector<TransientTrack>::const_iterator track = theTracks.begin(); track != theTracks.end(); ++track) {
      totweight += theWeights[*track][snr];
    };

    int nr_good_trks = 0;  // how many tracks above weight limit
    // we count those tracks, because that way
    // we can discard lightweights if there are enough tracks
    // and not discard the lightweights if that would give us
    // fewer than two tracks ( we would loose a seed, then ).
    if (discardLightWeights()) {
      for (vector<TransientTrack>::const_iterator track = theTracks.begin(); track != theTracks.end(); ++track) {
        if (theWeights[*track][snr] > totweight * minWeightFraction()) {
          nr_good_trks++;
        };
      };
    };

    vector<RefCountedVertexTrack> newTracks;
    for (vector<TransientTrack>::const_iterator track = theTracks.begin(); track != theTracks.end(); ++track) {
      double weight = validWeight(theWeights[*track][snr]);
      // Now we add a track, if
      // a. we consider all tracks or
      // b. we discard the lightweights but the track's weight is high enough or
      // c. we discard the lightweights but there arent enough good tracks,
      //    so we add all lightweights again (too expensive to figure out
      //    which lightweights are the most important)
      if (!discardLightWeights() || weight > minWeightFraction() * totweight || nr_good_trks < 2) {
        // if the linearization point didnt move too much,
        // we take the old LinTrackState.
        // Otherwise we relinearize.

        RefCountedLinearizedTrackState lTrData = theCache.linTrack(seed->second.position(), *track);

        VertexTrackFactory<5> vTrackFactory;
        RefCountedVertexTrack vTrData = vTrackFactory.vertexTrack(lTrData, realseed, weight);
        newTracks.push_back(vTrData);
      };
    };

    for (set<TransientTrack>::const_iterator track = thePrimaries.begin(); track != thePrimaries.end(); ++track) {
      double weight = validWeight(theWeights[*track][snr]);

      RefCountedLinearizedTrackState lTrData = theCache.linTrack(seed->second.position(), *track);

      VertexTrackFactory<5> vTrackFactory;
      RefCountedVertexTrack vTrData = vTrackFactory.vertexTrack(lTrData, realseed, weight);
      newTracks.push_back(vTrData);
    };

    try {
      if (newTracks.size() < 2) {
        throw VertexException("less than two tracks in vector");
      };

      if (verbose()) {
        cout << "[MultiVertexFitter] now fitting with Kalman: ";
        for (vector<RefCountedVertexTrack>::const_iterator i = newTracks.begin(); i != newTracks.end(); ++i) {
          cout << (**i).weight() << " ";
        };
        cout << endl;
      };

      if (newTracks.size() > 1) {
        KalmanVertexFitter fitter;
        // warning! first track determines lin pt!
        CachingVertex<5> newVertex = fitter.vertex(newTracks);
        int snr = seedNr();
        double disp = (newVertex.position() - seed->second.position()).mag();
        if (disp > max_disp)
          max_disp = disp;
        newSeeds.push_back(pair<int, CachingVertex<5> >(snr, newVertex));
      };
    } catch (exception &e) {
      cout << "[MultiVertexFitter] exception: " << e.what() << endl;
    }
  };

  // now discard all old seeds and weights, compute new ones.
  theVertexStates.clear();
  theWeights.clear();
  theVertexStates = newSeeds;
#ifdef MVFHarvestingDebug
  for (vector<CachingVertex<5> >::const_iterator i = theVertexStates.begin(); i != theVertexStates.end(); ++i)
    PrimitivesHarvester::file()->save(*i);
#endif
  updateWeights();

  static const double disp_limit = 1e-4; /* SimpleConfigurable<double>
    (0.0001, "MultiVertexFitter:DisplacementLimit" ).value(); */

  if (verbose() & 2) {
    printSeeds();
    cout << "[MultiVertexFitter] max displacement in this iteration: " << max_disp << endl;
  };
  if (max_disp < disp_limit)
    return false;
  return true;
}

updateWeights()

void MultiVertexFitter::updateWeights ( )

private

add the primary only tracks to primary vertex only.

now add "free tracks" to all vertices

Definition at line 282 of file MultiVertexFitter.cc.

References gather_cfg::cout, AnnealingSchedule::cutoff(), KalmanVertexTrackCompatibilityEstimator< N >::estimate(), nano_mu_digi_cff::float, LinTrackCache::linTrack(), AnnealingSchedule::phi(), printWeights(), mps_fire::result, fileCollector::seed, theAssComp, theCache, thePrimaries, theTracks, theVertexStates, theWeights, trackerHitRTTI::vector, verbose, w(), and mps_merge::weight.

Referenced by updateSeeds().

                                      {
  theWeights.clear();
  if (verbose() & 4) {
    cout << "[MultiVertexFitter] Start weight update." << endl;
  };

  KalmanVertexTrackCompatibilityEstimator<5> theComp;

  for (set<TransientTrack>::const_iterator trk = thePrimaries.begin(); trk != thePrimaries.end(); ++trk) {
    int seednr = theVertexStates[0].first;
    CachingVertex<5> seed = theVertexStates[0].second;
    pair<bool, double> result = theComp.estimate(seed, theCache.linTrack(seed.position(), *trk));
    double weight = 0.;
    if (result.first)
      weight = theAssComp->phi(result.second);
    theWeights[*trk][seednr] = weight;  // FIXME maybe "hard" 1.0 or "soft" weight?
  }

  for (vector<TransientTrack>::const_iterator trk = theTracks.begin(); trk != theTracks.end(); ++trk) {
    double tot_weight = theAssComp->phi(theAssComp->cutoff() * theAssComp->cutoff());

    for (vector<pair<int, CachingVertex<5> > >::const_iterator seed = theVertexStates.begin();
         seed != theVertexStates.end();
         ++seed) {
      pair<bool, double> result = theComp.estimate(seed->second, theCache.linTrack(seed->second.position(), *trk));
      double weight = 0.;
      if (result.first)
        weight = theAssComp->phi(result.second);
      tot_weight += weight;
      theWeights[*trk][seed->first] = weight;
      /* cout << "[MultiVertexFitter] w[" << TransientTrackNamer().name(*trk)
           << "," << seed->position() << "] = " << weight << endl;*/
    };

    // normalize to sum of all weights of one track equals 1.
    // (if we include the "cutoff", as well)
    if (tot_weight > 0.0) {
      for (vector<pair<int, CachingVertex<5> > >::const_iterator seed = theVertexStates.begin();
           seed != theVertexStates.end();
           ++seed) {
        double normedweight = theWeights[*trk][seed->first] / tot_weight;
        if (normedweight > 1.0) {
          cout << "[MultiVertexFitter] he? w["  // << TransientTrackNamer().name(*trk)
               << "," << seed->second.position() << "] = " << normedweight << " totw=" << tot_weight << endl;
          normedweight = 1.0;
        };
        if (normedweight < 0.0) {
          cout << "[MultiVertexFitter] he? weight=" << normedweight << " totw=" << tot_weight << endl;
          normedweight = 0.0;
        };
        theWeights[*trk][seed->first] = normedweight;
      };
    } else {
      // total weight equals zero? restart, with uniform distribution!
      cout << "[MultiVertexFitter] track found with no assignment - ";
      cout << "will assign uniformly." << endl;
      float w = .5 / (float)theVertexStates.size();
      for (vector<pair<int, CachingVertex<5> > >::const_iterator seed = theVertexStates.begin();
           seed != theVertexStates.end();
           ++seed) {
        theWeights[*trk][seed->first] = w;
      };
    };
  };
  if (verbose() & 2)
    printWeights();
}

vertices() [1/4]

vector< CachingVertex< 5 > > MultiVertexFitter::vertices	(	const std::vector< std::vector< reco::TransientTrack > > &	tracks,
		const std::vector< reco::TransientTrack > &	primaries = std::vector<reco::TransientTrack>()
	)

Supply simple clusters of reco::TransientTracks. primaries: supply tracks which are hard coded to the primary vertex.

Definition at line 233 of file MultiVertexFitter.cc.

References l1ct::clear(), geometryDiff::file, l1tPhase2CaloJetEmulator_cfi::fit, mps_fire::i, DiMuonV_cfg::tracks, trackerHitRTTI::vector, and verbose.

Referenced by MultiVertexReconstructor::vertices().

                                                                                               {
  clear();
  createPrimaries(primaries);

  for (vector<vector<TransientTrack> >::const_iterator cluster = tracks.begin(); cluster != tracks.end(); ++cluster) {
    createSeed(*cluster);
  };
  if (verbose()) {
    printSeeds();
  };
#ifdef MVFHarvestingDebug
  for (vector<CachingVertex<5> >::const_iterator i = theVertexStates.begin(); i != theVertexStates.end(); ++i)
    PrimitivesHarvester::file()->save(*i);
#endif
  return fit();
}

vertices() [2/4]

vector< CachingVertex< 5 > > MultiVertexFitter::vertices	(	const std::vector< std::vector< TrackAndWeight > > &	tracks,
		const std::vector< reco::TransientTrack > &	primaries = std::vector<reco::TransientTrack>()
	)

Supply clusters of tracks with weights, association weights of the other vertices is considered zero. FIXME weights are currently ignored. primaries: supply tracks which are hard coded to the primary vertex.

Definition at line 251 of file MultiVertexFitter.cc.

References l1ct::clear(), l1tPhase2CaloJetEmulator_cfi::fit, DiMuonV_cfg::tracks, trackerHitRTTI::vector, and verbose.

                                                                                               {
  clear();
  createPrimaries(primaries);

  for (vector<vector<TrackAndWeight> >::const_iterator cluster = tracks.begin(); cluster != tracks.end(); ++cluster) {
    createSeed(*cluster);
  };
  if (verbose()) {
    printSeeds();
  };

  return fit();
}

vertices() [3/4]

vector< CachingVertex< 5 > > MultiVertexFitter::vertices	(	const std::vector< CachingVertex< 5 > > &	initials,
		const std::vector< reco::TransientTrack > &	primaries = std::vector<reco::TransientTrack>()
	)

Supply full CachingVertices; CachingVertices are the first seeds. primaries: supply tracks which are hard coded to the primary vertex.

Definition at line 202 of file MultiVertexFitter.cc.

References l1ct::clear(), gather_cfg::cout, geometryDiff::file, l1tPhase2CaloJetEmulator_cfi::fit, mps_fire::i, TransientVertex::originalTracks(), hltEgammaHLTExtra_cfi::trks, trackerHitRTTI::vector, and L1BJetProducer_cff::vtx.

                                                                                               {
  clear();
  createPrimaries(primaries);
  // FIXME if initials size < 1 return sth that includes the primaries
  if (initials.empty())
    return initials;
  for (vector<CachingVertex<5> >::const_iterator vtx = initials.begin(); vtx != initials.end(); ++vtx) {
    int snr = seedNr();
    theVertexStates.push_back(pair<int, CachingVertex<5> >(snr, *vtx));
    TransientVertex rvtx = *vtx;
    const vector<TransientTrack> &trks = rvtx.originalTracks();
    for (vector<TransientTrack>::const_iterator trk = trks.begin(); trk != trks.end(); ++trk) {
      if (!(thePrimaries.count(*trk))) {
        // cout << "[MultiVertexFitter] free track " << trk->id() << endl;
        theTracks.push_back(*trk);
      } else {
        // cout << "[MultiVertexFitter " << trk->id() << " is not free." << endl;
      }
      cout << "[MultiVertexFitter] error! track weight currently set to one"
           << " FIXME!!!" << endl;
      theWeights[*trk][snr] = 1.0;
    };
  };
#ifdef MVFHarvestingDebug
  for (vector<CachingVertex<5> >::const_iterator i = theVertexStates.begin(); i != theVertexStates.end(); ++i)
    PrimitivesHarvester::file()->save(*i);
#endif
  return fit();
}

vertices() [4/4]

vector< CachingVertex< 5 > > MultiVertexFitter::vertices	(	const std::vector< TransientVertex > &	vtces,
		const std::vector< reco::TransientTrack > &	primaries = std::vector<reco::TransientTrack>()
	)

Same as above.

Definition at line 180 of file MultiVertexFitter.cc.

References MillePedeFileConverter_cfg::e, createJobs::tmp, hltEgammaHLTExtra_cfi::trks, AlignmentTracksFromVertexSelector_cfi::vertices, L1BJetProducer_cff::vtx, and w().

                                                                                               {
  // FIXME if vtces.size < 1 return sth that includes the primaries
  if (vtces.empty()) {
    return vector<CachingVertex<5> >();
  };
  vector<vector<TrackAndWeight> > bundles;
  for (vector<TransientVertex>::const_iterator vtx = vtces.begin(); vtx != vtces.end(); ++vtx) {
    vector<TransientTrack> trks = vtx->originalTracks();
    vector<TrackAndWeight> tnws;
    for (vector<TransientTrack>::const_iterator trk = trks.begin(); trk != trks.end(); ++trk) {
      float w = vtx->trackWeight(*trk);
      if (w > 1e-5) {
        TrackAndWeight tmp(*trk, w);
        tnws.push_back(tmp);
      };
    };
    bundles.push_back(tnws);
  };
  return vertices(bundles, primaries);
}

Member Data Documentation

theAssComp

AnnealingSchedule* MultiVertexFitter::theAssComp

private

Definition at line 110 of file MultiVertexFitter.h.

Referenced by fit(), updateWeights(), and ~MultiVertexFitter().

theCache

LinTrackCache MultiVertexFitter::theCache

private

Definition at line 113 of file MultiVertexFitter.h.

Referenced by updateSeeds(), and updateWeights().

thePrimaries

std::set<reco::TransientTrack> MultiVertexFitter::thePrimaries

private

Definition at line 109 of file MultiVertexFitter.h.

Referenced by printWeights(), updateSeeds(), and updateWeights().

theReviveBelow

float MultiVertexFitter::theReviveBelow

private

Definition at line 107 of file MultiVertexFitter.h.

Referenced by lostVertexClaimer().

theSeeder

LinearizationPointFinder* MultiVertexFitter::theSeeder

private

Definition at line 111 of file MultiVertexFitter.h.

Referenced by ~MultiVertexFitter().

theTracks

std::vector<reco::TransientTrack> MultiVertexFitter::theTracks

private

Definition at line 108 of file MultiVertexFitter.h.

Referenced by lostVertexClaimer(), printWeights(), updateSeeds(), and updateWeights().

theVertexStateNr

int MultiVertexFitter::theVertexStateNr

private

Definition at line 106 of file MultiVertexFitter.h.

theVertexStates

std::vector<std::pair<int, CachingVertex<5> > > MultiVertexFitter::theVertexStates

private

Definition at line 105 of file MultiVertexFitter.h.

Referenced by fit(), lostVertexClaimer(), printWeights(), updateSeeds(), and updateWeights().

theWeights

TrackAndSeedToWeightMap MultiVertexFitter::theWeights

private

Definition at line 112 of file MultiVertexFitter.h.

Referenced by lostVertexClaimer(), printWeights(), updateSeeds(), and updateWeights().