---

Jet.cc

Go to the documentation of this file.

//
// $Id: Jet.cc,v 1.25.2.4 2009/02/17 18:49:04 rwolf Exp $
//

#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/RecoCandidate/interface/RecoCaloTowerCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

using namespace pat;


Jet::Jet() :
  PATObject<JetType>(JetType()),
  embeddedCaloTowers_(false),
  partonFlavour_(0), 
  jetCharge_(0.)
{
}

Jet::Jet(const JetType & aJet) :
  PATObject<JetType>(aJet),
  embeddedCaloTowers_(false),
  partonFlavour_(0), 
  jetCharge_(0.0)
{
  tryImportSpecific(aJet);
}

Jet::Jet(const edm::Ptr<JetType> & aJetRef) :
  PATObject<JetType>(aJetRef),
  embeddedCaloTowers_(false),
  partonFlavour_(0), 
  jetCharge_(0.0)
{
  tryImportSpecific(*aJetRef);
}

Jet::Jet(const edm::RefToBase<JetType> & aJetRef) :
  PATObject<JetType>(aJetRef),
  embeddedCaloTowers_(false),
  partonFlavour_(0), 
  jetCharge_(0.0)
{
  tryImportSpecific(*aJetRef);
}

void Jet::tryImportSpecific(const JetType &source) {
    const std::type_info & type = typeid(source);
    if (type == typeid(reco::CaloJet)) {
        specificCalo_.push_back( (static_cast<const reco::CaloJet &>(source)).getSpecific() );
    } else if (type == typeid(reco::PFJet)) {
        specificPF_.push_back( (static_cast<const reco::PFJet &>(source)).getSpecific() );
    }
}

Jet::~Jet() {
}


CaloTowerPtr Jet::getCaloConstituent (unsigned fIndex) const {
    if (embeddedCaloTowers_) {
        return (fIndex < caloTowers_.size() ? CaloTowerPtr(&caloTowers_, fIndex) : CaloTowerPtr());
    } else {
            Constituent dau = daughterPtr (fIndex);
            const CaloTower* towerCandidate = dynamic_cast <const CaloTower*> (dau.get());
            if (towerCandidate) {
              return edm::Ptr<CaloTower> (dau.id(), towerCandidate, dau.key() );
            } 
            else {
                throw cms::Exception("Invalid Constituent") << "CaloJet constituent is not of CaloTowere type";
            }

    } 
   
   return CaloTowerPtr ();
}

std::vector<CaloTowerPtr> Jet::getCaloConstituents () const {
  std::vector<CaloTowerPtr> result;
  for (unsigned i = 0;  i <  numberOfDaughters (); i++) result.push_back (getCaloConstituent (i));
  return result;
}


const reco::PFCandidate* Jet::getPFCandidate (const reco::Candidate* fConstituent) {
  if (!fConstituent) return 0;
  const reco::Candidate* base = fConstituent;
  if (fConstituent->hasMasterClone ())
    base = fConstituent->masterClone().get();
  if (!base) return 0; // not in the event
  const reco::PFCandidate* candidate = dynamic_cast <const reco::PFCandidate*> (base);
  if (!candidate) {
    throw cms::Exception("Invalid Constituent") << "Jet constituent is not of PFCandidate type."
                                                << "Actual type is " << typeid (*base).name();
  }
  return candidate;
}

const reco::PFCandidate* Jet::getPFConstituent (unsigned fIndex) const {
  return getPFCandidate (daughter (fIndex));
}

std::vector <const reco::PFCandidate*> Jet::getPFConstituents () const {
  std::vector <const reco::PFCandidate*> result;
  for (unsigned i = 0;  i <  numberOfDaughters (); i++) result.push_back (getPFConstituent (i));
  return result;
}

const reco::GenJet * Jet::genJet() const {
  return (genJet_.size() > 0 ? &genJet_.front() : 0);
}

int Jet::partonFlavour() const {
  return partonFlavour_;
}

const std::vector<std::pair<std::string, float> > & Jet::getPairDiscri() const {
   return pairDiscriVector_;
}

float Jet::bDiscriminator(const std::string & aLabel) const {
  float discriminator = -1000.;
  const std::string & theLabel = ((aLabel == "" || aLabel == "default")) ? "trackCountingHighEffBJetTags" : aLabel;
  for(unsigned int i=0; i!=pairDiscriVector_.size(); i++){
    if(pairDiscriVector_[i].first == theLabel){
      discriminator = pairDiscriVector_[i].second;
    }
  }
  return discriminator;
}

const reco::BaseTagInfo * Jet::tagInfo(const std::string &label) const {
    std::vector<std::string>::const_iterator it = std::find(tagInfoLabels_.begin(), tagInfoLabels_.end(), label);
    if (it != tagInfoLabels_.end()) {
        return & tagInfos_[it - tagInfoLabels_.begin()];
    }
    return 0;
}
template<typename T> 
const T *  Jet::tagInfoByType() const {
    for (size_t i = 0, n = tagInfos_.size(); i < n; ++i) {
        if ( typeid(tagInfos_[i]) == typeid(T) )
             return static_cast<const T *>(&tagInfos_[i]);
    }
    return 0;
}

const reco::TrackIPTagInfo * 
Jet::tagInfoTrackIP(const std::string &label) const {
    return (label.empty() ? tagInfoByType<reco::TrackIPTagInfo>() 
                          : dynamic_cast<const reco::TrackIPTagInfo *>(tagInfo(label)) );
}

const reco::SoftLeptonTagInfo * 
Jet::tagInfoSoftLepton(const std::string &label) const {
    return (label.empty() ? tagInfoByType<reco::SoftLeptonTagInfo>()
                          : dynamic_cast<const reco::SoftLeptonTagInfo *>(tagInfo(label)) );
}

const reco::SecondaryVertexTagInfo * 
Jet::tagInfoSecondaryVertex(const std::string &label) const {
    return (label.empty() ? tagInfoByType<reco::SecondaryVertexTagInfo>()
                          : dynamic_cast<const reco::SecondaryVertexTagInfo *>(tagInfo(label)) );
}

void
Jet::addTagInfo(const std::string &label, const edm::Ptr<reco::BaseTagInfo> &info) {
    addTagInfo(label, *info);
}

void
Jet::addTagInfo(const std::string &label, const reco::BaseTagInfo &info) {
    std::string::size_type idx = label.find("TagInfos");
    if (idx == std::string::npos) {
        tagInfoLabels_.push_back(label);
    } else {
        tagInfoLabels_.push_back(label.substr(0,idx));
    }
    tagInfos_.push_back(info.clone());
}

float Jet::jetCharge() const {
  return jetCharge_;
}

const reco::TrackRefVector & Jet::associatedTracks() const {
  return associatedTracks_;
}

void Jet::setAssociatedTracks(const reco::TrackRefVector &tracks) {
    associatedTracks_ = tracks;
}

void Jet::setCaloTowers(const std::vector<CaloTowerPtr> & caloTowers) {
  for(unsigned int i = 0; i < caloTowers.size(); ++i) {
    caloTowers_.push_back(*caloTowers.at(i));
  }
  // possibly, if we really want to squeeze out bytes, we could clear the
  // daughters when the calotowers are embedded. The methods of the
  // CompositePtrCandidate that access this daughters would be srewed up though.
  // this->clearDaughters();
  embeddedCaloTowers_ = true;
}

void Jet::setGenJet(const reco::GenJet & gj) {
  genJet_.clear();
  genJet_.push_back(gj);
}

void Jet::setPartonFlavour(int partonFl) {
  partonFlavour_ = partonFl;
}

void Jet::setCorrFactors(const JetCorrFactors & jetCorrF) {
  jetEnergyCorrections_.clear();
  jetEnergyCorrections_.push_back(jetCorrF);
  activeJetCorrIndex_ = 0;
}

void Jet::addCorrFactors(const JetCorrFactors & jetCorrF) {
  jetEnergyCorrections_.push_back(jetCorrF);
}

void Jet::setCorrStep(JetCorrFactors::CorrStep step) {
  jetEnergyCorrectionStep_ = step;
  setP4(corrFactors_()->correction( step ) * p4());
}

Jet Jet::correctedJet(const std::string &step, const std::string &flavour) const {
    Jet ret(*this);
    ret.setP4(p4() * corrFactors_()->correction(corrFactors_()->corrStep(step, flavour), jetEnergyCorrectionStep_));
    ret.jetEnergyCorrectionStep_ = corrFactors_()->corrStep(step, flavour);
    return ret;
}

Jet Jet::correctedJet(const JetCorrFactors::CorrStep &step) const {
    Jet ret(*this);
    ret.setP4(p4() * corrFactors_()->correction(step, jetEnergyCorrectionStep_));
    ret.jetEnergyCorrectionStep_ = step;
    return ret;
}

Jet Jet::correctedJet(const std::string &step, const std::string &flavour, const std::string &set) const {
    Jet ret(*this);
    const JetCorrFactors * jetCorrFac = corrFactors_(set);
    if (!jetCorrFac)
      throw cms::Exception("InvalidRequest") 
        << "invalid JetCorrectionModule label '" << set 
        << "' requested in Jet::correctedJet!";
    ret.setP4(p4() * jetCorrFac->correction(jetCorrFac->corrStep(step, flavour), jetEnergyCorrectionStep_));
    ret.jetEnergyCorrectionStep_ = jetCorrFac->corrStep(step, flavour);
    return ret;
}

Jet Jet::correctedJet(const JetCorrFactors::CorrStep &step, const std::string &set) const {
    Jet ret(*this);
    const JetCorrFactors * jetCorrFac = corrFactors_(set);
    if (!jetCorrFac)
      throw cms::Exception("InvalidRequest") 
        << "invalid JetCorrectionModule label '" << set 
        << "' requested in Jet::correctedJet!";
    ret.setP4(p4() * jetCorrFac->correction(step, jetEnergyCorrectionStep_));
    ret.jetEnergyCorrectionStep_ = step;
    return ret;
}

bool Jet::hasCorrFactorSet(const std::string &set) const 
{
  for (std::vector<pat::JetCorrFactors>::const_iterator it=jetEnergyCorrections_.begin();
       it!=jetEnergyCorrections_.end(); ++it)
    if (it->getLabel()==set)
      return true;
  return false;      
}

const JetCorrFactors * Jet::corrFactors_(const std::string &set) const 
{
  const JetCorrFactors * result = 0;
  for (std::vector<pat::JetCorrFactors>::const_iterator it=jetEnergyCorrections_.begin();
       it!=jetEnergyCorrections_.end(); ++it)
    if (it->getLabel()==set){
      result = &(*it);
      break;
    }  
  return result;      
}

const JetCorrFactors * Jet::corrFactors_() const {
  return &jetEnergyCorrections_.at( activeJetCorrIndex_ );
}

std::string Jet::corrStep() const { 
  return corrFactors_()->corrStep( jetEnergyCorrectionStep_ ); 
}

std::string Jet::corrFlavour() const {
  return corrFactors_()->flavour( jetEnergyCorrectionStep_ ); 
}

float Jet::corrFactor(const std::string &step, const std::string &flavour) const {
  return corrFactors_()->correction(corrFactors_()->corrStep(step, flavour), jetEnergyCorrectionStep_);
}

float Jet::corrFactor(const std::string &step, const std::string &flavour, const std::string &set) const {
  const JetCorrFactors * jetCorrFac = corrFactors_(set);
  if (!jetCorrFac) 
  throw cms::Exception("InvalidRequest") 
        << "invalid JetCorrectionModule label '" << set << "' requested in Jet::jetCorrFactor!"<<std::endl;;
  return jetCorrFac->correction(jetCorrFac->corrStep(step, flavour), jetEnergyCorrectionStep_);
}

const std::vector<std::string> Jet::corrFactorSetLabels() const
{
  std::vector<std::string> result;
  for (std::vector<pat::JetCorrFactors>::const_iterator it=jetEnergyCorrections_.begin();
       it!=jetEnergyCorrections_.end(); ++it)
    result.push_back(it->getLabel());
  return result;      
}

void Jet::addBDiscriminatorPair(const std::pair<std::string, float> & thePair) {
  pairDiscriVector_.push_back(thePair);
}

void Jet::setJetCharge(float jetCharge) {
  jetCharge_ = jetCharge;
}

---