PackedGenParticle.cc

Go to the documentation of this file.

#include "DataFormats/PatCandidates/interface/PackedGenParticle.h"
#include "DataFormats/Math/interface/libminifloat.h"
#include "DataFormats/Math/interface/deltaPhi.h"



void pat::PackedGenParticle::pack(bool unpackAfterwards) {
    packedPt_  =  MiniFloatConverter::float32to16(p4_.load()->Pt());
    packedY_ =  int16_t(p4_.load()->Rapidity()/6.0f*std::numeric_limits<int16_t>::max());
    packedPhi_ =  int16_t(p4_.load()->Phi()/3.2f*std::numeric_limits<int16_t>::max());
    packedM_   =  MiniFloatConverter::float32to16(p4_.load()->M());
    if (unpackAfterwards) {
      delete p4_.exchange(nullptr);
      delete p4c_.exchange(nullptr);
      unpack(); // force the values to match with the packed ones
    }
}


void pat::PackedGenParticle::unpack() const {
    float y = int16_t(packedY_)*6.0f/std::numeric_limits<int16_t>::max();
    float pt=MiniFloatConverter::float16to32(packedPt_);
    float m=MiniFloatConverter::float16to32(packedM_);
    float pz = std::tanh(y)*std::sqrt((m*m+pt*pt)/(1.-std::tanh(y)*std::tanh(y)));
    float eta = 0;
    if(pt != 0.) {
      eta = std::asinh(pz/pt);
    }
    double shift = (pt<1. ? 0.1*pt : 0.1/pt); // shift particle phi to break degeneracies in angular separations
    double sign = ( ( int(pt*10) % 2 == 0 ) ? 1 : -1 ); // introduce a pseudo-random sign of the shift
    double phi = int16_t(packedPhi_)*3.2f/std::numeric_limits<int16_t>::max() + sign*shift*3.2/std::numeric_limits<int16_t>::max();
    auto p4 = std::make_unique<PolarLorentzVector>(pt,eta,phi,m);
    PolarLorentzVector* expectp4 = nullptr;
    if(p4_.compare_exchange_strong(expectp4,p4.get())) {
      p4.release();
    }
    auto p4c = std::make_unique<LorentzVector>(*p4_);
    LorentzVector* expectp4c = nullptr;
    if(p4c_.compare_exchange_strong(expectp4c,p4c.get())) {
      p4c.release();
    }
}

pat::PackedGenParticle::~PackedGenParticle() {
  delete p4_.load();
  delete p4c_.load();
 }


float pat::PackedGenParticle::dxy(const Point &p) const {
    unpack();
    return -(vertex_.X()-p.X()) * std::sin(float(p4_.load()->Phi())) + (vertex_.Y()-p.Y()) * std::cos(float(p4_.load()->Phi()));
}
float pat::PackedGenParticle::dz(const Point &p) const {
    unpack();
    return (vertex_.Z()-p.X())  - ((vertex_.X()-p.X()) * std::cos(float(p4_.load()->Phi())) + (vertex_.Y()-p.Y()) * std::sin(float(p4_.load()->Phi()))) * p4_.load()->Pz()/p4_.load()->Pt();
}



const reco::CandidateBaseRef & pat::PackedGenParticle::masterClone() const {
  throw cms::Exception("Invalid Reference")
    << "this Candidate has no master clone reference."
    << "Can't call masterClone() method.\n";
}

bool pat::PackedGenParticle::hasMasterClone() const {
  return false;
}

bool pat::PackedGenParticle::hasMasterClonePtr() const {
  return false;
}


const reco::CandidatePtr & pat::PackedGenParticle::masterClonePtr() const {
  throw cms::Exception("Invalid Reference")
    << "this Candidate has no master clone ptr."
    << "Can't call masterClonePtr() method.\n";
}

size_t pat::PackedGenParticle::numberOfDaughters() const { 
  return 0; 
}

size_t pat::PackedGenParticle::numberOfMothers() const { 
  if(motherRef().isNonnull())   return 1; 
  return 0;
}

bool pat::PackedGenParticle::overlap( const reco::Candidate & o ) const { 
  return  p4() == o.p4() && vertex() == o.vertex() && charge() == o.charge();
//  return  p4() == o.p4() && charge() == o.charge();
}

const reco::Candidate * pat::PackedGenParticle::daughter( size_type ) const {
  return nullptr;
}

const reco::Candidate * pat::PackedGenParticle::mother( size_type ) const {
  return motherRef().get();
}

const reco::Candidate * pat::PackedGenParticle::daughter(const std::string&) const {
  throw edm::Exception(edm::errors::UnimplementedFeature)
    << "This Candidate type does not implement daughter(std::string). "
    << "Please use CompositeCandidate or NamedCompositeCandidate.\n";
}

reco::Candidate * pat::PackedGenParticle::daughter(const std::string&) {
  throw edm::Exception(edm::errors::UnimplementedFeature)
    << "This Candidate type does not implement daughter(std::string). "
    << "Please use CompositeCandidate or NamedCompositeCandidate.\n";
}



reco::Candidate * pat::PackedGenParticle::daughter( size_type ) {
  return nullptr;
}

double pat::PackedGenParticle::vertexChi2() const {
  return 0;
}

double pat::PackedGenParticle::vertexNdof() const {
  return 0;
}

double pat::PackedGenParticle::vertexNormalizedChi2() const {
  return 0;
}

double pat::PackedGenParticle::vertexCovariance(int i, int j) const {
  throw edm::Exception(edm::errors::UnimplementedFeature)
    << "reco::ConcreteCandidate does not implement vertex covariant matrix.\n";
}

void pat::PackedGenParticle::fillVertexCovariance(CovarianceMatrix & err) const {
  throw edm::Exception(edm::errors::UnimplementedFeature)
    << "reco::ConcreteCandidate does not implement vertex covariant matrix.\n";
}

bool pat::PackedGenParticle::isElectron() const { return false; }

bool pat::PackedGenParticle::isMuon() const { return false; }

bool pat::PackedGenParticle::isGlobalMuon() const { return false; }

bool pat::PackedGenParticle::isStandAloneMuon() const { return false; }

bool pat::PackedGenParticle::isTrackerMuon() const { return false; }

bool pat::PackedGenParticle::isCaloMuon() const { return false; }

bool pat::PackedGenParticle::isPhoton() const { return false; }

bool pat::PackedGenParticle::isConvertedPhoton() const { return false; }

bool pat::PackedGenParticle::isJet() const { return false; }

bool pat::PackedGenParticle::longLived() const {return false;}

bool pat::PackedGenParticle::massConstraint() const {return false;}