CMS 3D CMS Logo
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Attributes

reco::Conversion Class Reference

#include <DataFormats/EgammaCandidates/interface/Conversion.h>

List of all members.

Public Types

enum  ConversionAlgorithm {
  undefined = 0, ecalSeeded = 1, trackerOnly = 2, mixed = 3,
  pflow = 4, algoSize = 5
}
enum  ConversionQuality {
  generalTracksOnly = 0, arbitratedEcalSeeded = 1, arbitratedMerged = 2, arbitratedMergedEcalGeneral = 3,
  highPurity = 8, highEfficiency = 9, ecalMatched1Track = 10, ecalMatched2Track = 11
}

Public Member Functions

ConversionAlgorithm algo () const
std::string algoName () const
const std::vector
< reco::CaloClusterPtr > & 		bcMatchingWithTracks () const
reco::CaloClusterPtrVector caloCluster () const
 Pointer to CaloCluster (foe Egamma Conversions it points to a SuperCluster)
Conversion * clone () const
 returns a clone of the candidate
 Conversion (const reco::CaloClusterPtrVector clu, const std::vector< reco::TrackRef > tr, const reco::Vertex &convVtx, ConversionAlgorithm=undefined)
 Conversion (const reco::CaloClusterPtrVector clu, const std::vector< edm::RefToBase< reco::Track > > tr, const std::vector< math::XYZPoint > trackPositionAtEcal, const reco::Vertex &convVtx, const std::vector< reco::CaloClusterPtr > &matchingBC, const float DCA, const std::vector< math::XYZPoint > &innPoint, const std::vector< math::XYZVector > &trackPin, const std::vector< math::XYZVector > &trackPout, const std::vector< uint8_t > nHitsBeforeVtx, const std::vector< Measurement1DFloat > &dlClosestHitToVtx, uint8_t nSharedHits, const float mva, ConversionAlgorithm=undefined)
 Conversion (const reco::CaloClusterPtrVector clu, const std::vector< edm::RefToBase< reco::Track > > tr, const reco::Vertex &convVtx, ConversionAlgorithm=undefined)
 Conversion ()
 Conversion (const reco::CaloClusterPtrVector clu, const std::vector< reco::TrackRef > tr, const std::vector< math::XYZPoint > trackPositionAtEcal, const reco::Vertex &convVtx, const std::vector< reco::CaloClusterPtr > &matchingBC, const float DCA, const std::vector< math::XYZPoint > &innPoint, const std::vector< math::XYZVector > &trackPin, const std::vector< math::XYZVector > &trackPout, const float mva, ConversionAlgorithm=undefined)
const reco::Vertex & conversionVertex () const
 returns the reco conversion vertex
double dEtaTracksAtEcal () const
double distOfMinimumApproach () const
const std::vector
< Measurement1DFloat > & 		dlClosestHitToVtx () const
 Vector of signed decay length with uncertainty from nearest hit on track to the conversion vtx positions.
double dPhiTracksAtEcal () const
double dPhiTracksAtVtx () const
const std::vector
< math::XYZPoint > & 		ecalImpactPosition () const
double EoverP () const
double EoverPrefittedTracks () const
bool isConverted () const
 Bool flagging objects having track size >0.
double MVAout () const
 get the value of the TMVA output
const std::vector< uint8_t > & nHitsBeforeVtx () const
 Vector of the number of hits before the vertex along each track trajector.
uint8_t nSharedHits () const
 number of shared hits btw the two track
unsigned int nTracks () const
 Number of tracks= 0,1,2.
double pairCotThetaSeparation () const
 Delta cot(Theta) where Theta is the angle in the (y,z) plane between the two tracks. Original tracks are used.
double pairInvariantMass () const
 if nTracks=2 returns the pair invariant mass. Original tracks are used here
math::XYZVector pairMomentum () const
 Conversion tracks momentum from the tracks inner momentum.
bool quality (ConversionQuality q) const
math::XYZTLorentzVectorD refittedPair4Momentum () const
 Conversion track pair 4-momentum from the tracks refitted with vertex constraint.
math::XYZVector refittedPairMomentum () const
 Conversion tracks momentum from the tracks refitted with vertex constraint.
void setConversionAlgorithm (const ConversionAlgorithm a, bool set=true)
 Conversion Track algorithm/provenance.
void setMatchingSuperCluster (const reco::CaloClusterPtrVector &sc)
void setMVAout (const float &mva)
 set the value of the TMVA output
void setQuality (ConversionQuality q, bool b)
std::vector< edm::RefToBase
< reco::Track > > 		tracks () const
 vector of track to base references
const std::vector
< math::XYZPoint > & 		tracksInnerPosition () const
 Vector containing the position of the innermost hit of each track.
const std::vector
< math::XYZVector > & 		tracksPin () const
 Vector of track momentum measured at the innermost hit.
const std::vector
< math::XYZVector > & 		tracksPout () const
 Vector of track momentum measured at the outermost hit.
std::vector< double > tracksSigned_d0 () const
 signed transverse impact parameter for each track
double zOfPrimaryVertexFromTracks () const
 z coordinate of the photon origin calculated from the track-pair direction and the position of the vertex
virtual ~Conversion ()
 destructor

Static Public Member Functions

static ConversionAlgorithm algoByName (const std::string &name)
static std::string algoName (ConversionAlgorithm)

Static Public Attributes

static const std::string algoNames [] = { "undefined","ecalSeeded","trackerOnly","mixed"}

Private Attributes

uint8_t algorithm_
 conversion algorithm/provenance
reco::CaloClusterPtrVector caloCluster_
 vector pointer to a/multiple seed CaloCluster(s)
std::vector< Measurement1DFloat > dlClosestHitToVtx_
 signed decay length and uncertainty from nearest hit on track to conversion vertex
std::vector< uint8_t > nHitsBeforeVtx_
 number of hits before the vertex on each trackerOnly
uint8_t nSharedHits_
 number of shared hits between tracks
uint16_t qualityMask_
reco::Vertex theConversionVertex_
 Fitted Kalman conversion vertex.
std::vector< reco::CaloClusterPtr > theMatchingBCs_
 Clusters mathing the tracks (these are not the seeds)
float theMinDistOfApproach_
 Distance of min approach of the two tracks.
float theMVAout_
 TMVA output.
std::vector< math::XYZPoint > thePositionAtEcal_
 position at the ECAl surface of the track extrapolation
std::vector< math::XYZPoint > theTrackInnerPosition_
 P_in of tracks.
std::vector< math::XYZVector > theTrackPin_
 P_in of tracks.
std::vector< math::XYZVector > theTrackPout_
 P_out of tracks.
std::vector< reco::TrackRef > tracks_
 vector of Track references
std::vector< edm::RefToBase
< reco::Track > > 		trackToBaseRefs_
 vector Track RefToBase

Detailed Description

Author:
N.Marinelli University of Notre Dame, US
Version:
Id:
Conversion.h,v 1.19 2011/01/18 12:40:40 nancy Exp

Definition at line 24 of file Conversion.h.

Member Enumeration Documentation

enum reco::Conversion::ConversionAlgorithm
Enumerator:
undefined 
ecalSeeded 
trackerOnly 
mixed 
pflow 
algoSize 

Definition at line 27 of file Conversion.h.

                               {undefined=0, 
                                ecalSeeded=1, 
                                trackerOnly=2, 
                                mixed=3, 
                                pflow=4,
                                algoSize=5};
enum reco::Conversion::ConversionQuality
Enumerator:
generalTracksOnly 
arbitratedEcalSeeded 
arbitratedMerged 
arbitratedMergedEcalGeneral 
highPurity 
highEfficiency 
ecalMatched1Track 
ecalMatched2Track 

Definition at line 34 of file Conversion.h.

                             {generalTracksOnly=0, 
                              arbitratedEcalSeeded=1, 
                              arbitratedMerged=2,
                              arbitratedMergedEcalGeneral=3,
                              highPurity=8, 
                              highEfficiency=9,
                              ecalMatched1Track=10,
                              ecalMatched2Track=11};

Constructor & Destructor Documentation

Conversion::Conversion ( )

Definition at line 143 of file Conversion.cc.

References algorithm_, nSharedHits_, qualityMask_, theMinDistOfApproach_, theMVAout_, thePositionAtEcal_, theTrackInnerPosition_, theTrackPin_, and theTrackPout_.

Referenced by clone().

                       { 

  algorithm_=0;
  qualityMask_=0;
  theMinDistOfApproach_ = 9999.;
  nSharedHits_ = 0;
  theMVAout_ = 9999.;
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));
    
}
Conversion::Conversion ( const reco::CaloClusterPtrVector  clu,
const std::vector< edm::RefToBase< reco::Track > >  tr,
const std::vector< math::XYZPoint >  trackPositionAtEcal,
const reco::Vertex &  convVtx,
const std::vector< reco::CaloClusterPtr > &  matchingBC,
const float  DCA,
const std::vector< math::XYZPoint > &  innPoint,
const std::vector< math::XYZVector > &  trackPin,
const std::vector< math::XYZVector > &  trackPout,
const std::vector< uint8_t >  nHitsBeforeVtx,
const std::vector< Measurement1DFloat > &  dlClosestHitToVtx,
uint8_t  nSharedHits,
const float  mva,
ConversionAlgorithm  algo = undefined 
)

Definition at line 51 of file Conversion.cc.

                                                  :  
                         

  caloCluster_(sc), trackToBaseRefs_(tr), 
  thePositionAtEcal_(trackPositionAtEcal), 
  theConversionVertex_(convVtx), 
  theMatchingBCs_(matchingBC), 
  theMinDistOfApproach_(DCA),
  theTrackInnerPosition_(innPoint),
  theTrackPin_(trackPin),
  theTrackPout_(trackPout),
  nHitsBeforeVtx_(nHitsBeforeVtx),
  dlClosestHitToVtx_(dlClosestHitToVtx),
  nSharedHits_(nSharedHits),
  theMVAout_(mva),
  algorithm_(algo),
  qualityMask_(0)
 { 
   
 }
Conversion::Conversion ( const reco::CaloClusterPtrVector  clu,
const std::vector< reco::TrackRef >  tr,
const std::vector< math::XYZPoint >  trackPositionAtEcal,
const reco::Vertex &  convVtx,
const std::vector< reco::CaloClusterPtr > &  matchingBC,
const float  DCA,
const std::vector< math::XYZPoint > &  innPoint,
const std::vector< math::XYZVector > &  trackPin,
const std::vector< math::XYZVector > &  trackPout,
const float  mva,
ConversionAlgorithm  algo = undefined 
)

Definition at line 19 of file Conversion.cc.

                                                  :  
                         

  caloCluster_(sc), tracks_(tr), 
  thePositionAtEcal_(trackPositionAtEcal), 
  theConversionVertex_(convVtx), 
  theMatchingBCs_(matchingBC), 
  theMinDistOfApproach_(DCA),
  theTrackInnerPosition_(innPoint),
  theTrackPin_(trackPin),
  theTrackPout_(trackPout),
  nSharedHits_(0),  
  theMVAout_(mva),
  algorithm_(algo),
  qualityMask_(0)
 { 
   
 }
Conversion::Conversion ( const reco::CaloClusterPtrVector  clu,
const std::vector< reco::TrackRef >  tr,
const reco::Vertex &  convVtx,
ConversionAlgorithm  algo = undefined 
)

Definition at line 88 of file Conversion.cc.

References theMinDistOfApproach_, theMVAout_, thePositionAtEcal_, theTrackInnerPosition_, theTrackPin_, and theTrackPout_.

                                                  :  
  caloCluster_(sc), tracks_(tr), 
  theConversionVertex_(convVtx),
  nSharedHits_(0),
  algorithm_(algo),
  qualityMask_(0)
 { 


  theMinDistOfApproach_ = 9999.;
  theMVAout_ = 9999.;
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));

   
 }
Conversion::Conversion ( const reco::CaloClusterPtrVector  clu,
const std::vector< edm::RefToBase< reco::Track > >  tr,
const reco::Vertex &  convVtx,
ConversionAlgorithm  algo = undefined 
)

Definition at line 115 of file Conversion.cc.

References theMinDistOfApproach_, theMVAout_, thePositionAtEcal_, theTrackInnerPosition_, theTrackPin_, and theTrackPout_.

                                                  :  
  caloCluster_(sc), trackToBaseRefs_(tr), 
  theConversionVertex_(convVtx), 
  nSharedHits_(0),
  algorithm_(algo),
  qualityMask_(0)
 { 


  theMinDistOfApproach_ = 9999.;
  theMVAout_ = 9999.;
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  thePositionAtEcal_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackInnerPosition_.push_back(math::XYZPoint(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPin_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));
  theTrackPout_.push_back(math::XYZVector(0.,0.,0.));

   
 }
Conversion::~Conversion ( ) [virtual]

destructor

Definition at line 162 of file Conversion.cc.

{ }

Member Function Documentation

Conversion::ConversionAlgorithm reco::Conversion::algo ( ) const [inline]

Definition at line 210 of file Conversion.h.

References algorithm_.

                                                                {
      return (ConversionAlgorithm) algorithm_;
    }
Conversion::ConversionAlgorithm Conversion::algoByName ( const std::string &  name) [static]

Definition at line 167 of file Conversion.cc.

References algoNames, algoSize, spr::find(), getHLTprescales::index, findQualityFiles::size, and undefined.

Referenced by TrackerOnlyConversionProducer::buildCollection(), and ConvertedPhotonProducer::buildCollections().

                                                                         {
  ConversionAlgorithm size = algoSize;
  int index = std::find(algoNames, algoNames+size, name)-algoNames;
  if(index == size) return undefined;

  return ConversionAlgorithm(index);
}
std::string reco::Conversion::algoName ( ) const [inline]

Definition at line 215 of file Conversion.h.

References algorithm_, ecalSeeded, mixed, trackerOnly, and undefined.

                                               {
            
      switch(algorithm_)
        {
        case undefined: return "undefined";
        case ecalSeeded: return "ecalSeeded";
        case trackerOnly: return "trackerOnly";
        case mixed: return "mixed";

        }
      return "undefined";
    }
std::string reco::Conversion::algoName ( ConversionAlgorithm  a) [inline, static]

Definition at line 228 of file Conversion.h.

References algoNames, and algoSize.

                                                              {
      if(int(a) < int(algoSize) && int(a)>0) return algoNames[int(a)];
      return "undefined";
    }
const std::vector<reco::CaloClusterPtr>& reco::Conversion::bcMatchingWithTracks ( ) const [inline]

Definition at line 142 of file Conversion.h.

References theMatchingBCs_.

Referenced by dEtaTracksAtEcal(), and dPhiTracksAtEcal().

{ return theMatchingBCs_;}
reco::CaloClusterPtrVector reco::Conversion::caloCluster ( ) const [inline]

Pointer to CaloCluster (foe Egamma Conversions it points to a SuperCluster)

Definition at line 96 of file Conversion.h.

References caloCluster_.

Referenced by EoverP(), and EoverPrefittedTracks().

{return caloCluster_ ;}
Conversion * Conversion::clone ( void  ) const

returns a clone of the candidate

Definition at line 175 of file Conversion.cc.

References Conversion().

Referenced by ConvertedPhotonProducer::cleanCollections().

                                     { 
  return new Conversion( * this ); 
}
const reco::Vertex& reco::Conversion::conversionVertex ( ) const [inline]

returns the reco conversion vertex

Definition at line 100 of file Conversion.h.

References theConversionVertex_.

Referenced by TkConvValidator::analyze(), refittedPair4Momentum(), refittedPairMomentum(), FWConvTrackHitsDetailView::setTextInfo(), and zOfPrimaryVertexFromTracks().

{ return theConversionVertex_ ; }
double Conversion::dEtaTracksAtEcal ( ) const

Definition at line 381 of file Conversion.cc.

References bcMatchingWithTracks(), ecalImpactPosition(), nTracks(), and query::result.

                                            {
  double result=-99.;


  if ( nTracks()==2 && bcMatchingWithTracks()[0].isNonnull() && bcMatchingWithTracks()[1].isNonnull() ) {

    result =ecalImpactPosition()[0].eta() - ecalImpactPosition()[1].eta();

  }



  return result;


}
double reco::Conversion::distOfMinimumApproach ( ) const [inline]

Definition at line 130 of file Conversion.h.

References theMinDistOfApproach_.

Referenced by TkConvValidator::analyze(), and FWConvTrackHitsDetailView::setTextInfo().

{return  theMinDistOfApproach_;}
const std::vector<Measurement1DFloat>& reco::Conversion::dlClosestHitToVtx ( ) const [inline]

Vector of signed decay length with uncertainty from nearest hit on track to the conversion vtx positions.

Definition at line 154 of file Conversion.h.

References dlClosestHitToVtx_.

{ return dlClosestHitToVtx_; }
double Conversion::dPhiTracksAtEcal ( ) const

Definition at line 356 of file Conversion.cc.

References bcMatchingWithTracks(), ecalImpactPosition(), nTracks(), pi, and query::result.

                                            {
  double result =-99.;
  
  if (  nTracks()==2  && bcMatchingWithTracks()[0].isNonnull() && bcMatchingWithTracks()[1].isNonnull() ) {
    
    float recoPhi1 = ecalImpactPosition()[0].phi();
    if( recoPhi1   > pi)  { recoPhi1 = recoPhi1 - twopi;}
    if( recoPhi1  < -pi)  { recoPhi1 = recoPhi1 + twopi;}

    float recoPhi2 = ecalImpactPosition()[1].phi();
    if( recoPhi2   > pi)  { recoPhi2 = recoPhi2 - twopi;}
    if( recoPhi2  < -pi)  { recoPhi2 = recoPhi2 + twopi;}

    result = recoPhi1 -recoPhi2;

    if( result   > pi)  { result = result - twopi;}
    if( result  < -pi)  { result = result + twopi;}

  }

  return result;


}
double Conversion::dPhiTracksAtVtx ( ) const

Definition at line 343 of file Conversion.cc.

References nTracks(), pi, query::result, and tracksPin().

Referenced by TkConvValidator::analyze(), and FWConvTrackHitsDetailView::setTextInfo().

                                           {
  double result=-99;
  if  ( nTracks()==2 ) {
    result = tracksPin()[0].phi() - tracksPin()[1].phi();
    if( result   > pi)  { result = result - twopi;}
    if( result  < -pi)  { result = result + twopi;}
  }

  return result;


}
const std::vector<math::XYZPoint>& reco::Conversion::ecalImpactPosition ( ) const [inline]

The following are variables provided per each track positions of the track extrapolation at the ECAL front face

Definition at line 140 of file Conversion.h.

References thePositionAtEcal_.

Referenced by dEtaTracksAtEcal(), and dPhiTracksAtEcal().

{return thePositionAtEcal_;}
double Conversion::EoverP ( ) const

Super Cluster energy divided by track pair momentum if Standard seeding method. If a pointer to two (or more clusters) is stored in the conversion, this method returns the energy sum of clusters divided by the track pair momentum Track innermost momentum is used here

Definition at line 288 of file Conversion.cc.

References caloCluster(), i, nTracks(), pairMomentum(), findQualityFiles::size, edm::PtrVectorBase::size(), and mathSSE::sqrt().

Referenced by ConversionLikelihoodCalculator::calculateLikelihood().

                                  {


  double ep=-99.;

  if ( nTracks() > 0  ) {
    unsigned int size= this->caloCluster().size();
    float etot=0.;
    for ( unsigned int i=0; i<size; i++) {
      etot+= caloCluster()[i]->energy();
    }
    if (this->pairMomentum().Mag2() !=0) ep= etot/sqrt(this->pairMomentum().Mag2());
  }



  return ep;  

}
double Conversion::EoverPrefittedTracks ( ) const

Super Cluster energy divided by track pair momentum if Standard seeing method. If a pointer to two (or more clusters) is stored in the conversion, this method returns the energy sum of clusters divided by the track pair momentum Track momentum refitted with vertex constraint is used

Definition at line 310 of file Conversion.cc.

References caloCluster(), i, nTracks(), refittedPairMomentum(), findQualityFiles::size, edm::PtrVectorBase::size(), and mathSSE::sqrt().

                                                {


  double ep=-99.;
 
  if ( nTracks() > 0  ) {
    unsigned int size= this->caloCluster().size();
    float etot=0.;
    for ( unsigned int i=0; i<size; i++) {
      etot+= caloCluster()[i]->energy();
    }
    if (this->refittedPairMomentum().Mag2() !=0) ep= etot/sqrt(this->refittedPairMomentum().Mag2());
  }



  return ep;  

}
bool Conversion::isConverted ( ) const

Bool flagging objects having track size >0.

Definition at line 196 of file Conversion.cc.

References nTracks().

                                   {
  
  if ( this->nTracks() == 2 ) 
    return true;
  else
    return false;
}
double reco::Conversion::MVAout ( ) const [inline]

get the value of the TMVA output

Definition at line 108 of file Conversion.h.

References theMVAout_.

{ return theMVAout_;}
const std::vector<uint8_t>& reco::Conversion::nHitsBeforeVtx ( ) const [inline]

Vector of the number of hits before the vertex along each track trajector.

Definition at line 152 of file Conversion.h.

References nHitsBeforeVtx_.

{ return nHitsBeforeVtx_; }
uint8_t reco::Conversion::nSharedHits ( ) const [inline]

number of shared hits btw the two track

Definition at line 156 of file Conversion.h.

References nSharedHits_.

{ return nSharedHits_; }
unsigned int reco::Conversion::nTracks ( ) const [inline]

Number of tracks= 0,1,2.

Definition at line 104 of file Conversion.h.

References tracks().

Referenced by FWConvTrackHitsDetailView::build(), ConversionLikelihoodCalculator::calculateLikelihood(), dEtaTracksAtEcal(), dPhiTracksAtEcal(), dPhiTracksAtVtx(), EoverP(), EoverPrefittedTracks(), isConverted(), pairCotThetaSeparation(), pairInvariantMass(), pairMomentum(), FWConversionProxyBuilder::requestCommon(), and tracksSigned_d0().

{return  tracks().size(); }
double Conversion::pairCotThetaSeparation ( ) const

Delta cot(Theta) where Theta is the angle in the (y,z) plane between the two tracks. Original tracks are used.

Definition at line 238 of file Conversion.cc.

References nTracks(), funct::tan(), and tracksPin().

Referenced by TkConvValidator::analyze(), ConversionLikelihoodCalculator::calculateLikelihood(), and FWConvTrackHitsDetailView::setTextInfo().

                                                  {
  double dCotTheta=-99.;
  
  if ( nTracks()==2 ) {
    double theta1=this->tracksPin()[0].Theta();
    double theta2=this->tracksPin()[1].Theta();
    dCotTheta =  1./tan(theta1) - 1./tan(theta2) ;
  }

  return dCotTheta;

}
double Conversion::pairInvariantMass ( ) const

if nTracks=2 returns the pair invariant mass. Original tracks are used here

Definition at line 219 of file Conversion.cc.

References ExpressReco_HICollisions_FallBack::e, nTracks(), mathSSE::sqrt(), and tracksPin().

Referenced by TkConvValidator::analyze().

                                          {
  double invMass=-99.;
  const float mElec= 0.000511;
  if ( nTracks()==2 ) {
    double px= tracksPin()[0].x() +  tracksPin()[1].x();
    double py= tracksPin()[0].y() +  tracksPin()[1].y();
    double pz= tracksPin()[0].z() +  tracksPin()[1].z();
    double mom1= tracksPin()[0].Mag2();
    double mom2= tracksPin()[1].Mag2();
    double e = sqrt( mom1+ mElec*mElec ) + sqrt( mom2 + mElec*mElec );
    invMass= ( e*e - px*px -py*py - pz*pz);
    if ( invMass>0) invMass = sqrt(invMass);
    else 
      invMass = -1;
  }
  
  return invMass;
}
math::XYZVector Conversion::pairMomentum ( ) const

Conversion tracks momentum from the tracks inner momentum.

Definition at line 252 of file Conversion.cc.

References nTracks(), and tracksPin().

Referenced by EoverP(), FWConversionProxyBuilder::requestCommon(), FWConvTrackHitsDetailView::setTextInfo(), and zOfPrimaryVertexFromTracks().

                                               {
  
  if ( nTracks()==2 ) {
    return this->tracksPin()[0] +  this->tracksPin()[1];
  }
  return math::XYZVector(0.,0.,0.);



}
bool reco::Conversion::quality ( ConversionQuality  q) const [inline]

Definition at line 168 of file Conversion.h.

References lumiQueryAPI::q, and qualityMask_.

Referenced by TkConvValidator::analyze().

{ return  (qualityMask_ & (1<<q))>>q; }
math::XYZTLorentzVectorD Conversion::refittedPair4Momentum ( ) const

Conversion track pair 4-momentum from the tracks refitted with vertex constraint.

Definition at line 264 of file Conversion.cc.

References conversionVertex(), reco::Vertex::p4(), and p4.

Referenced by refittedPairMomentum().

                                                                {

  math::XYZTLorentzVectorD p4;
  if ( this->conversionVertex().isValid() ) 
    p4 = this->conversionVertex().p4( 0.000511, 0.5);

  return p4;


}
math::XYZVector Conversion::refittedPairMomentum ( ) const

Conversion tracks momentum from the tracks refitted with vertex constraint.

Definition at line 277 of file Conversion.cc.

References conversionVertex(), and refittedPair4Momentum().

Referenced by TkConvValidator::analyze(), and EoverPrefittedTracks().

                                                       {

  if (  this->conversionVertex().isValid() ) {
    return this->refittedPair4Momentum().Vect();
  }
  return math::XYZVector(0.,0.,0.);

}
void reco::Conversion::setConversionAlgorithm ( const ConversionAlgorithm  a,
bool  set = true 
) [inline]

Conversion Track algorithm/provenance.

Definition at line 162 of file Conversion.h.

References a, algorithm_, and undefined.

{ if (set) algorithm_=a; else algorithm_=undefined;}
void reco::Conversion::setMatchingSuperCluster ( const reco::CaloClusterPtrVector &  sc) [inline]

Definition at line 159 of file Conversion.h.

References caloCluster_.

{ caloCluster_= sc;}
void reco::Conversion::setMVAout ( const float &  mva) [inline]

set the value of the TMVA output

Definition at line 106 of file Conversion.h.

References theMVAout_.

Referenced by ConvertedPhotonProducer::buildCollections().

{ theMVAout_=mva;}
void reco::Conversion::setQuality ( ConversionQuality  q,
bool  b 
) [inline]

Definition at line 233 of file Conversion.h.

References lumiQueryAPI::q, and qualityMask_.

Referenced by TrackerOnlyConversionProducer::buildCollection().

                                                                 {
      if (b)//regular OR if setting value to true
        qualityMask_ |= (1<<q) ;
      else // doing "half-XOR" if unsetting value
        qualityMask_ &= (~(1<<q));

    }
std::vector< edm::RefToBase< reco::Track > > Conversion::tracks ( void  ) const

vector of track to base references

Definition at line 180 of file Conversion.cc.

References tracks_, and trackToBaseRefs_.

Referenced by TkConvValidator::analyze(), FWConvTrackHitsDetailView::build(), ConversionLikelihoodCalculator::calculateLikelihood(), SoftConversionProducer::NotAlreadyIn(), nTracks(), FWConvTrackHitsDetailView::setTextInfo(), and tracksSigned_d0().

                                                              { 
  if (trackToBaseRefs_.size() ==0 ) {
 
    for (std::vector<reco::TrackRef>::const_iterator ref=tracks_.begin(); ref!=tracks_.end(); ref++ ) 
      {
        edm::RefToBase<reco::Track> tt(*ref);
        trackToBaseRefs_.push_back(tt);
        
      }  
  }

  return trackToBaseRefs_;
}
const std::vector<math::XYZPoint>& reco::Conversion::tracksInnerPosition ( ) const [inline]

Vector containing the position of the innermost hit of each track.

Definition at line 146 of file Conversion.h.

References theTrackInnerPosition_.

{return theTrackInnerPosition_;}
const std::vector<math::XYZVector>& reco::Conversion::tracksPin ( ) const [inline]

Vector of track momentum measured at the innermost hit.

Definition at line 150 of file Conversion.h.

References theTrackPin_.

Referenced by ConversionLikelihoodCalculator::calculateLikelihood(), dPhiTracksAtVtx(), pairCotThetaSeparation(), pairInvariantMass(), and pairMomentum().

{return theTrackPin_;}
const std::vector<math::XYZVector>& reco::Conversion::tracksPout ( ) const [inline]

Vector of track momentum measured at the outermost hit.

Definition at line 148 of file Conversion.h.

References theTrackPout_.

{return theTrackPout_;}
std::vector< double > Conversion::tracksSigned_d0 ( ) const

signed transverse impact parameter for each track

Definition at line 332 of file Conversion.cc.

References DeDxDiscriminatorTools::charge(), debug_cff::d0, i, nTracks(), query::result, and tracks().

                                                      {
  std::vector<double> result;

  for (unsigned int i=0; i< nTracks(); i++)   
    result.push_back(tracks()[i]->d0()* tracks()[i]->charge()) ;

  return result;


}
double Conversion::zOfPrimaryVertexFromTracks ( ) const

z coordinate of the photon origin calculated from the track-pair direction and the position of the vertex

Definition at line 205 of file Conversion.cc.

References conversionVertex(), pairMomentum(), perp2(), reco::Vertex::position(), position, mathSSE::sqrt(), funct::tan(), and theta().

Referenced by TkConvValidator::analyze(), and FWConversionProxyBuilder::requestCommon().

                                                       {
  double theZOfPrimaryVertexFromTracks=-9999.;
  
  if ( this->conversionVertex().isValid() && sqrt(this->conversionVertex().position().perp2()) !=0 ) {
    float theta=this->pairMomentum().Theta();
    theZOfPrimaryVertexFromTracks = this->conversionVertex().position().z()  - sqrt(this->conversionVertex().position().perp2())*(1./tan(theta));
    
  }

  return  theZOfPrimaryVertexFromTracks;

}

Member Data Documentation

std::string const Conversion::algoNames = { "undefined","ecalSeeded","trackerOnly","mixed"} [static]

Definition at line 43 of file Conversion.h.

Referenced by algoByName(), and algoName().

uint8_t reco::Conversion::algorithm_ [private]

conversion algorithm/provenance

Definition at line 204 of file Conversion.h.

Referenced by algo(), algoName(), Conversion(), and setConversionAlgorithm().

reco::CaloClusterPtrVector reco::Conversion::caloCluster_ [private]

vector pointer to a/multiple seed CaloCluster(s)

Definition at line 176 of file Conversion.h.

Referenced by caloCluster(), and setMatchingSuperCluster().

std::vector<Measurement1DFloat> reco::Conversion::dlClosestHitToVtx_ [private]

signed decay length and uncertainty from nearest hit on track to conversion vertex

Definition at line 198 of file Conversion.h.

Referenced by dlClosestHitToVtx().

std::vector<uint8_t> reco::Conversion::nHitsBeforeVtx_ [private]

number of hits before the vertex on each trackerOnly

Definition at line 196 of file Conversion.h.

Referenced by nHitsBeforeVtx().

uint8_t reco::Conversion::nSharedHits_ [private]

number of shared hits between tracks

Definition at line 200 of file Conversion.h.

Referenced by Conversion(), and nSharedHits().

uint16_t reco::Conversion::qualityMask_ [private]

Definition at line 205 of file Conversion.h.

Referenced by Conversion(), quality(), and setQuality().

reco::Vertex reco::Conversion::theConversionVertex_ [private]

Fitted Kalman conversion vertex.

Definition at line 184 of file Conversion.h.

Referenced by conversionVertex().

std::vector<reco::CaloClusterPtr> reco::Conversion::theMatchingBCs_ [private]

Clusters mathing the tracks (these are not the seeds)

Definition at line 186 of file Conversion.h.

Referenced by bcMatchingWithTracks().

float reco::Conversion::theMinDistOfApproach_ [private]

Distance of min approach of the two tracks.

Definition at line 188 of file Conversion.h.

Referenced by Conversion(), and distOfMinimumApproach().

float reco::Conversion::theMVAout_ [private]

TMVA output.

Definition at line 202 of file Conversion.h.

Referenced by Conversion(), MVAout(), and setMVAout().

std::vector<math::XYZPoint> reco::Conversion::thePositionAtEcal_ [private]

position at the ECAl surface of the track extrapolation

Definition at line 182 of file Conversion.h.

Referenced by Conversion(), and ecalImpactPosition().

std::vector<math::XYZPoint> reco::Conversion::theTrackInnerPosition_ [private]

P_in of tracks.

Definition at line 190 of file Conversion.h.

Referenced by Conversion(), and tracksInnerPosition().

std::vector<math::XYZVector> reco::Conversion::theTrackPin_ [private]

P_in of tracks.

Definition at line 192 of file Conversion.h.

Referenced by Conversion(), and tracksPin().

std::vector<math::XYZVector> reco::Conversion::theTrackPout_ [private]

P_out of tracks.

Definition at line 194 of file Conversion.h.

Referenced by Conversion(), and tracksPout().

std::vector<reco::TrackRef> reco::Conversion::tracks_ [private]

vector of Track references

Definition at line 178 of file Conversion.h.

Referenced by tracks().

std::vector<edm::RefToBase<reco::Track> > reco::Conversion::trackToBaseRefs_ [mutable, private]

vector Track RefToBase

Definition at line 180 of file Conversion.h.

Referenced by tracks().

Generated for CMSSW Reference Manual by doxygen 1.7.3