VertexCompatibleWithBeam.cc

Go to the documentation of this file.

#include "RecoVertex/VertexTools/interface/VertexCompatibleWithBeam.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"
#include "RecoVertex/VertexTools/interface/VertexDistance.h"
 
using namespace reco;
 
VertexCompatibleWithBeam::VertexCompatibleWithBeam(const VertexDistance& d, float cut)
    : theDistance(d.clone()), theCut(cut) {
  BeamSpot beamSpot;
  theBeam = VertexState(beamSpot);
}
 
VertexCompatibleWithBeam::VertexCompatibleWithBeam(const VertexDistance& d, float cut, const BeamSpot& beamSpot)
    : theDistance(d.clone()), theCut(cut), theBeam(beamSpot) {}
 
VertexCompatibleWithBeam::VertexCompatibleWithBeam(const VertexCompatibleWithBeam& other)
    : theDistance((*other.theDistance).clone()), theCut(other.theCut), theBeam(other.theBeam) {}
 
VertexCompatibleWithBeam::~VertexCompatibleWithBeam() { delete theDistance; }
 
VertexCompatibleWithBeam& VertexCompatibleWithBeam::operator=(const VertexCompatibleWithBeam& other) {
  if (this == &other)
    return *this;
 
  theDistance = (*other.theDistance).clone();
  theCut = other.theCut;
  theBeam = other.theBeam;
  return *this;
}
 
void VertexCompatibleWithBeam::setBeamSpot(const BeamSpot& beamSpot) { theBeam = VertexState(beamSpot); }
 
bool VertexCompatibleWithBeam::operator()(const reco::Vertex& v) const {
  GlobalPoint p(Basic3DVector<float>(v.position()));
  VertexState vs(p, GlobalError(v.covariance()));
  return (theDistance->distance(vs, theBeam).value() < theCut);
}
 
float VertexCompatibleWithBeam::distanceToBeam(const reco::Vertex& v) const {
  GlobalPoint p(Basic3DVector<float>(v.position()));
  VertexState vs(p, GlobalError(v.covariance()));
  return theDistance->distance(vs, theBeam).value();
}
 
float VertexCompatibleWithBeam::distanceToBeam(const reco::Vertex& v, const VertexState& bs) const {
  GlobalPoint p(Basic3DVector<float>(v.position()));
  VertexState vs(p, GlobalError(v.covariance()));
  return theDistance->distance(vs, bs).value();
}
 
bool VertexCompatibleWithBeam::operator()(const reco::Vertex& v, const VertexState& bs) const {
  GlobalPoint p(Basic3DVector<float>(v.position()));
  VertexState vs(p, GlobalError(v.covariance()));
  return (theDistance->distance(vs, bs).value() < theCut);
}