MultiGaussianStateTransform.cc

Go to the documentation of this file.

#include "TrackingTools/GsfTools/interface/MultiGaussianStateTransform.h"
#include "TrackingTools/GsfTools/interface/GetComponents.h"
#include "TrackingTools/GsfTools/interface/MultiGaussianState1D.h"
#include "DataFormats/TrackReco/interface/TrackExtraFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackExtraFwd.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "FWCore/Utilities/interface/Exception.h"

MultiGaussianState<MultiGaussianStateTransform::N>
MultiGaussianStateTransform::outerMultiState (const reco::GsfTrack& tk)
{
  const reco::GsfTrackExtraRef& extra(tk.gsfExtra());
  return multiState(extra->outerStateLocalParameters(),
            extra->outerStateCovariances(),
            extra->outerStateWeights());
}

MultiGaussianState<MultiGaussianStateTransform::N>
MultiGaussianStateTransform::innerMultiState (const reco::GsfTrack& tk)
{
  const reco::GsfTrackExtraRef& extra(tk.gsfExtra());
  return multiState(extra->innerStateLocalParameters(),
           extra->innerStateCovariances(),
           extra->innerStateWeights());
}

MultiGaussianState1D
MultiGaussianStateTransform::outerMultiState1D (const reco::GsfTrack& tk,
                        unsigned int index)
{
  if ( index>=N )  
    throw cms::Exception("LogicError") << "MultiGaussianStateTransform: index out of range";

  const reco::GsfTrackExtraRef& extra(tk.gsfExtra());
  return multiState1D(extra->outerStateLocalParameters(),
              extra->outerStateCovariances(),
              extra->outerStateWeights(),
              index);
}

MultiGaussianState1D
MultiGaussianStateTransform::innerMultiState1D (const reco::GsfTrack& tk,
                        unsigned int index)
{
  if ( index>=N )  
    throw cms::Exception("LogicError") << "MultiGaussianStateTransform: index out of range";

  const reco::GsfTrackExtraRef& extra(tk.gsfExtra());
  return multiState1D(extra->innerStateLocalParameters(),
              extra->innerStateCovariances(),
              extra->innerStateWeights(),
              index);
}

MultiGaussianState<MultiGaussianStateTransform::N> 
MultiGaussianStateTransform::multiState (const std::vector<MultiGaussianState<N>::Vector>& parameters,
                     const std::vector<MultiGaussianState<N>::Matrix>& covariances,
                     const std::vector<double>& weights)
{
  unsigned int nc = parameters.size();
  MultiGaussianState<N>::SingleStateContainer components;
  components.reserve(nc);
  for ( unsigned int i=0; i<nc; ++i ) {
    MultiGaussianState<N>::SingleStatePtr 
      sgs(new MultiGaussianState<N>::SingleState(parameters[i],covariances[i],weights[i]));
    components.push_back(sgs);
  }
  return MultiGaussianState<N>(components);
}

MultiGaussianState1D
MultiGaussianStateTransform::multiState1D (const std::vector<MultiGaussianState<N>::Vector>& parameters,
                       const std::vector<MultiGaussianState<N>::Matrix>& covariances,
                       const std::vector<double>& weights, unsigned int index)
{
  unsigned int nc = parameters.size();
  MultiGaussianState1D::SingleState1dContainer components;
  components.reserve(nc);
  for ( unsigned int i=0; i<nc; ++i ) {
    components.push_back(SingleGaussianState1D(parameters[i](index),
                           covariances[i](index,index),
                           weights[i]));
  }
  return MultiGaussianState1D(components);
}

MultiGaussianState<5> 
MultiGaussianStateTransform::multiState (const TrajectoryStateOnSurface tsos)
{
  GetComponents comps(tsos);
  auto const & tsosComponents = comps();
  MultiGaussianState<5>::SingleStateContainer components;
  components.reserve(tsosComponents.size());
  for (auto i=tsosComponents.begin();
    i!=tsosComponents.end(); ++i ) {
    MultiGaussianState<5>::SingleStatePtr 
      sgs(new MultiGaussianState<5>::SingleState(i->localParameters().vector(),
                         i->localError().matrix(),
                         i->weight()));
    components.push_back(sgs);
  }
  return MultiGaussianState<5>(components);
}

MultiGaussianState1D
MultiGaussianStateTransform::multiState1D (const TrajectoryStateOnSurface tsos,
                       unsigned int index)
{
  if ( index>=N )  
    throw cms::Exception("LogicError") << "MultiGaussianStateTransform: index out of range";
  GetComponents comps(tsos);
  auto const & tsosComponents = comps();
  MultiGaussianState1D::SingleState1dContainer components;
  components.reserve(tsosComponents.size());
  for (auto i=tsosComponents.begin();
    i!=tsosComponents.end(); ++i ) {
    components.push_back(SingleGaussianState1D(i->localParameters().vector()(index),
                           i->localError().matrix()(index,index),
                           i->weight()));
  }
  return MultiGaussianState1D(components);
}

TrajectoryStateOnSurface
MultiGaussianStateTransform::tsosFromSingleState (const SingleGaussianState<5>& singleState,
                          const TrajectoryStateOnSurface refTsos)
{
  const LocalTrajectoryParameters& refPars(refTsos.localParameters());
  double pzSign = refPars.pzSign();
  bool charged = refPars.charge()!=0;
  LocalTrajectoryParameters pars(singleState.mean(),pzSign,charged);
  LocalTrajectoryError errs(singleState.covariance());
  // return state (doesn't use weight of the single state)
  return TrajectoryStateOnSurface(pars,errs,refTsos.surface(),refTsos.magneticField());
}