VertexState.h

Go to the documentation of this file.

#ifndef RecoVertex_VertexPrimitives_VertexState_H
#define RecoVertex_VertexPrimitives_VertexState_H
 
#include "RecoVertex/VertexPrimitives/interface/BasicVertexState.h"
#include "RecoVertex/VertexPrimitives/interface/BasicSingleVertexState.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include <vector>
 
class VertexState final : private BasicVertexState::Proxy {
  using Base = BasicVertexState::Proxy;
  using BSVS = BasicSingleVertexState;
 
public:
  VertexState() {}
  VertexState(VertexState const&) = default;
  VertexState(VertexState&&) = default;
  VertexState& operator=(const VertexState&) = default;
  VertexState& operator=(VertexState&&) = default;
 
  // template<typename... Args>
  //  VertexState(Args && ...args) :
  //  Base ( new BSVS ( std::forward<Args>(args)...)){}
 
  explicit VertexState(BasicVertexState* p) : Base(p) {}
 
  explicit VertexState(const reco::BeamSpot& beamSpot)
      : Base(new BSVS(
            GlobalPoint(Basic3DVector<float>(beamSpot.position())), GlobalError(beamSpot.rotatedCovariance3D()), 1.0)) {
  }
 
  VertexState(const GlobalPoint& pos, const GlobalError& posErr, const double& weightInMix = 1.0)
      : Base(new BSVS(pos, posErr, weightInMix)) {}
 
  VertexState(const GlobalPoint& pos, const GlobalWeight& posWeight, const double& weightInMix = 1.0)
      : Base(new BSVS(pos, posWeight, weightInMix)) {}
 
  VertexState(const AlgebraicVector3& weightTimesPosition,
              const GlobalWeight& posWeight,
              const double& weightInMix = 1.0)
      : Base(new BSVS(weightTimesPosition, posWeight, weightInMix)) {}
 
  // with time
  VertexState(const GlobalPoint& pos, const double time, const GlobalError& posTimeErr, const double& weightInMix = 1.0)
      : Base(new BSVS(pos, time, posTimeErr, weightInMix)) {}
 
  VertexState(const GlobalPoint& pos,
              const double time,
              const GlobalWeight& posTimeWeight,
              const double& weightInMix = 1.0)
      : Base(new BSVS(pos, time, posTimeWeight, weightInMix)) {}
 
  VertexState(const AlgebraicVector4& weightTimesPosition,
              const GlobalWeight& posTimeWeight,
              const double& weightInMix = 1.0)
      : Base(new BSVS(weightTimesPosition, posTimeWeight, weightInMix)) {}
 
  //3D covariance matrices (backwards compatible)
  GlobalPoint position() const { return data().position(); }
 
  GlobalError error() const { return data().error(); }
 
  // with time, full cov
  GlobalError error4D() const { return data().error4D(); }
 
  GlobalWeight weight() const { return data().weight(); }
 
  GlobalWeight weight4D() const { return data().weight4D(); }
 
  double time() const { return data().time(); }
 
  double timeError() const { return data().timeError(); }
 
  AlgebraicVector3 weightTimesPosition() const { return data().weightTimesPosition(); }
 
  AlgebraicVector4 weightTimesPosition4D() const { return data().weightTimesPosition4D(); }
 
  double weightInMixture() const { return data().weightInMixture(); }
 
  //   RefCountedVertexSeed seedWithoutTracks() const
  //   {
  //     return data().seedWithoutTracks();
  //   }
 
  std::vector<VertexState> components() const { return data().components(); }
 
  bool isValid() const { return Base::isValid() && data().isValid(); }
 
  bool is4D() const { return data().is4D(); }
};
 
#endif