#include <MultiTrajectoryStateAssembler.h>

Public Member Functions
void	addInvalidState (const double)
	Adds (the weight of an) invalid state to the list. More...

void	addState (const TrajectoryStateOnSurface)

TrajectoryStateOnSurface	combinedState ()

TrajectoryStateOnSurface	combinedState (const float weight)

	MultiTrajectoryStateAssembler ()

Private Types
typedef std::vector< TrajectoryStateOnSurface >	MultiTSOS

typedef TrajectoryStateOnSurface	TSOS

Private Member Functions
void	addStateVector (const MultiTSOS &)

bool	invalidCombinedState () const
	Checks status of combined state. More...

bool	prepareCombinedState ()
	Preparation of combined state (cleaning & sorting) More...

void	removeSmallWeights ()

void	removeWrongPz ()
	Removes states with local p_z != average p_z. More...

TrajectoryStateOnSurface	reweightedCombinedState (const double) const

Private Attributes
bool	combinationDone

float	minFractionalWeight

float	minValidFraction

bool	sortStates

double	theInvalidWeightSum

bool	thePzError

MultiTSOS	theStates

double	theValidWeightSum

Detailed Description

Collects trajectory states and returns a MultiTrajectoryState.

Definition at line 13 of file MultiTrajectoryStateAssembler.h.

Member Typedef Documentation

◆ MultiTSOS

typedef std::vector<TrajectoryStateOnSurface> MultiTrajectoryStateAssembler::MultiTSOS

private

Definition at line 16 of file MultiTrajectoryStateAssembler.h.

◆ TSOS

typedef TrajectoryStateOnSurface MultiTrajectoryStateAssembler::TSOS

private

Definition at line 15 of file MultiTrajectoryStateAssembler.h.

Constructor & Destructor Documentation

◆ MultiTrajectoryStateAssembler()

MultiTrajectoryStateAssembler::MultiTrajectoryStateAssembler ( )

Definition at line 8 of file MultiTrajectoryStateAssembler.cc.

References minFractionalWeight, minValidFraction, and sortStates.

     : combinationDone(false), thePzError(false), theValidWeightSum(0.), theInvalidWeightSum(0.) {
   //
   // parameters (could be configurable)
   //
   sortStates = false;
   minValidFraction = 0.01;
   minFractionalWeight = 1.e-6;  // 4;
 }

Member Function Documentation

◆ addInvalidState()

void MultiTrajectoryStateAssembler::addInvalidState ( const double weight )

Adds (the weight of an) invalid state to the list.

Definition at line 65 of file MultiTrajectoryStateAssembler.cc.

References theInvalidWeightSum, and mps_merge::weight.

                                                                        {
   //
   // change status of combination (contains at least one invalid state)
   //
   theInvalidWeightSum += weight;
 }

◆ addState()

void MultiTrajectoryStateAssembler::addState ( const TrajectoryStateOnSurface tsos )

Adds a new TrajectoryStateOnSurface to the list of components

Definition at line 18 of file MultiTrajectoryStateAssembler.cc.

References addStateVector(), combinationDone, makeMuonMisalignmentScenario::components, Exception, and TrajectoryStateOnSurface::isValid().

                                                                                 {
   //
   // refuse to add states after combination has been done
   //
   if (combinationDone)
     throw cms::Exception("LogicError") << "MultiTrajectoryStateAssembler: trying to add states after combination";
   //
   // Verify validity of state to be added
   //
   if (!tsos.isValid())
     throw cms::Exception("LogicError") << "MultiTrajectoryStateAssembler: trying to add invalid state";
   //
   // Add components (i.e. state to be added can be single or multi state)
   //
   GetComponents comps(tsos);
   MultiTSOS components(comps());
   addStateVector(components);
 }

◆ addStateVector()

void MultiTrajectoryStateAssembler::addStateVector ( const MultiTSOS & states )

private

Adds a vector of trajectory states to the list of components

Definition at line 37 of file MultiTrajectoryStateAssembler.cc.

References combinationDone, Exception, mps_fire::i, thePzError, theStates, and theValidWeightSum.

Referenced by addState().

                                                                           {
   //
   // refuse to add states after combination has been done
   //
   if (combinationDone)
     throw cms::Exception("LogicError") << "MultiTrajectoryStateAssembler: trying to add states after combination";
   //
   // sum up weights (all components are supposed to be valid!!!) and
   // check for consistent pz
   //
   double sum(0.);
   double pzFirst = theStates.empty() ? 0. : theStates.front().localParameters().pzSign();
   for (MultiTSOS::const_iterator i = states.begin(); i != states.end(); i++) {
     if (!(i->isValid()))
       throw cms::Exception("LogicError") << "MultiTrajectoryStateAssembler: trying to add invalid state";
     // weights
     sum += i->weight();
     // check on p_z
     if (!theStates.empty() && pzFirst * i->localParameters().pzSign() < 0.)
       thePzError = true;
   }
   theValidWeightSum += sum;
   //
   // add to vector of states
   //
   theStates.insert(theStates.end(), states.begin(), states.end());
 }

◆ combinedState() [1/2]

TrajectoryStateOnSurface MultiTrajectoryStateAssembler::combinedState ( )

Returns the resulting MultiTrajectoryState with weight = sum of all valid components.

Definition at line 72 of file MultiTrajectoryStateAssembler.cc.

References prepareCombinedState(), reweightedCombinedState(), theInvalidWeightSum, theStates, and theValidWeightSum.

                                                                       {
   //
   // Prepare resulting state vector
   //
   if (!prepareCombinedState())
     return TSOS();
   //
   // If invalid states in input: use reweighting
   //
   if (theInvalidWeightSum > 0.)
     return reweightedCombinedState(theValidWeightSum + theInvalidWeightSum);
   //
   // Return new multi state without reweighting
   //
   return TSOS((BasicTrajectoryState *)(new BasicMultiTrajectoryState(theStates)));
 }

◆ combinedState() [2/2]

TrajectoryStateOnSurface MultiTrajectoryStateAssembler::combinedState ( const float weight )

Returns the resulting MultiTrajectoryState renormalised to specified weight.

Definition at line 89 of file MultiTrajectoryStateAssembler.cc.

References prepareCombinedState(), and reweightedCombinedState().

                                                                                            {
   //
   // Prepare resulting state vector
   //
   if (!prepareCombinedState())
     return TSOS();
   //
   // return reweighted state
   //
   return reweightedCombinedState(newWeight);
 }

◆ invalidCombinedState()

bool MultiTrajectoryStateAssembler::invalidCombinedState ( ) const

inlineprivate

Checks status of combined state.

Definition at line 47 of file MultiTrajectoryStateAssembler.h.

References theStates.

Referenced by prepareCombinedState(), and reweightedCombinedState().

                                            {
     //
     // Protect against empty combination (no valid input state)
     //
     return theStates.empty();
   }

◆ prepareCombinedState()

bool MultiTrajectoryStateAssembler::prepareCombinedState ( )

private

Preparation of combined state (cleaning & sorting)

Definition at line 101 of file MultiTrajectoryStateAssembler.cc.

References combinationDone, invalidCombinedState(), minValidFraction, removeSmallWeights(), removeWrongPz(), jetUpdater_cfi::sort, sortStates, theInvalidWeightSum, thePzError, theStates, and theValidWeightSum.

Referenced by combinedState().

                                                          {
   //
   // Protect against empty combination (no valid input state)
   //
   if (invalidCombinedState())
     return false;
   //
   // Check for states with wrong pz
   //
   if (thePzError)
     removeWrongPz();
   //
   // Check for minimum fraction of valid states
   //
   double allWeights(theValidWeightSum + theInvalidWeightSum);
   if (theInvalidWeightSum > 0. && theValidWeightSum < minValidFraction * allWeights)
     return false;
   //
   // remaining part to be done only once
   //
   if (combinationDone)
     return true;
   combinationDone = true;
   //
   // Remove states with negligible weights
   //
   removeSmallWeights();
   if (invalidCombinedState())
     return false;
   //
   // Sort output by weights?
   //
   if (sortStates)
     sort(theStates.begin(), theStates.end(), TrajectoryStateLessWeight());
 
   return true;
 }

◆ removeSmallWeights()

void MultiTrajectoryStateAssembler::removeSmallWeights ( )

private

Removes states with negligible weight (no renormalisation of total weight!).

Definition at line 166 of file MultiTrajectoryStateAssembler.cc.

References minFractionalWeight, alignCSCRings::s, theInvalidWeightSum, theStates, theValidWeightSum, and generateEDF::totalWeight.

Referenced by prepareCombinedState().

                                                        {
   //
   // check total weight
   //
   auto totalWeight(theInvalidWeightSum + theValidWeightSum);
   if (totalWeight == 0.) {
     theStates.clear();
     return;
   }
   theStates.erase(
       std::remove_if(theStates.begin(),
                      theStates.end(),
                      [&](MultiTSOS::value_type const &s) { return s.weight() < minFractionalWeight * totalWeight; }),
       theStates.end());
 }

◆ removeWrongPz()

void MultiTrajectoryStateAssembler::removeWrongPz ( )

private

Removes states with local p_z != average p_z.

Definition at line 182 of file MultiTrajectoryStateAssembler.cc.

References LogDebug, theInvalidWeightSum, theStates, and theValidWeightSum.

Referenced by prepareCombinedState().

                                                   {
   LogDebug("GsfTrackFitters") << "MultiTrajectoryStateAssembler: found at least one state with inconsistent pz\n"
                               << "  #state / weights before cleaning = " << theStates.size() << " / "
                               << theValidWeightSum << " / " << theInvalidWeightSum;
   //
   // Calculate average pz
   //
   double meanPz(0.);
   for (auto const &is : theStates)
     meanPz += is.weight() * is.localParameters().pzSign();
   meanPz /= theValidWeightSum;
   //
   // Now keep only states compatible with the average pz
   //
   theValidWeightSum = 0.;
   MultiTSOS oldStates(theStates);
   theStates.clear();
   for (auto const &is : oldStates) {
     if (meanPz * is.localParameters().pzSign() >= 0.) {
       theValidWeightSum += is.weight();
       theStates.push_back(is);
     } else {
       theInvalidWeightSum += is.weight();
       LogDebug("GsfTrackFitters") << "removing  weight / pz / global position = " << is.weight() << " "
                                   << is.localParameters().pzSign() << " " << is.globalPosition();
     }
   }
   LogDebug("GsfTrackFitters") << "  #state / weights after cleaning = " << theStates.size() << " / "
                               << theValidWeightSum << " / " << theInvalidWeightSum;
 }

◆ reweightedCombinedState()

TrajectoryStateOnSurface MultiTrajectoryStateAssembler::reweightedCombinedState ( const double newWeight ) const

private

Returns the resulting MultiTrajectoryState with user-supplied total weight.

Definition at line 139 of file MultiTrajectoryStateAssembler.cc.

References DQMScaleToClient_cfi::factor, invalidCombinedState(), theStates, and theValidWeightSum.

Referenced by combinedState().

                                                                                                             {
   //
   // check status
   //
   if (invalidCombinedState())
     return TSOS();
   //
   // scaling factor
   //
   double factor = theValidWeightSum > 0. ? newWeight / theValidWeightSum : 1;
   //
   // create new vector of states & combined state
   //
   MultiTSOS reweightedStates;
   reweightedStates.reserve(theStates.size());
   for (auto const &is : theStates) {
     auto oldWeight = is.weight();
     reweightedStates.emplace_back(factor * oldWeight,
                                   is.localParameters(),
                                   is.localError(),
                                   is.surface(),
                                   &(is.globalParameters().magneticField()),
                                   is.surfaceSide());
   }
   return TSOS((BasicTrajectoryState *)(new BasicMultiTrajectoryState(reweightedStates)));
 }