PhotonCore.h

Go to the documentation of this file.

#ifndef EgammaCandidates_PhotonCore_h
#define EgammaCandidates_PhotonCore_h

#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/EgammaCandidates/interface/PhotonCoreFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/ElectronSeed.h"
#include "DataFormats/EgammaReco/interface/ElectronSeedFwd.h"


namespace reco {

  class PhotonCore  {
  public:
    //    PhotonCore() { }

    PhotonCore(const reco::SuperClusterRef & scl ):  superCluster_(scl), isPFlowPhoton_(false), isStandardPhoton_(true) { }

    // while for building photons from pf I would use the default constructor 
    PhotonCore(): isPFlowPhoton_(false), isStandardPhoton_(false) { }
    // followed by the setters of the provenance and of the Ref to the wanted supercluster
    // at that point if in PF you have found a photon which correspond to a standard SC yuo can 
    // set both supercluster and the two flags to true
    // if you have found an object which does not have a standard SC associated you set only the
    // one from pflow. 
    // How does this sound ? 


    virtual ~PhotonCore() { }

    PhotonCore* clone() const { return new PhotonCore( * this ); }

    void setSuperCluster( const reco::SuperClusterRef & r ) { superCluster_ = r; }
    void setParentSuperCluster( const reco::SuperClusterRef & r ) { parentSuperCluster_ = r; }
    void addConversion( const reco::ConversionRef & r ) { conversions_.push_back(r); }
    void addOneLegConversion( const reco::ConversionRef & r ) { conversionsOneLeg_.push_back(r); }
    void addElectronPixelSeed( const reco::ElectronSeedRef & r ) { electronSeed_.push_back(r) ; }
    void setPFlowPhoton( const bool prov) {  isPFlowPhoton_ = prov; }
    void setStandardPhoton( const bool prov) { isStandardPhoton_ = prov; }


    reco::SuperClusterRef superCluster() const { return superCluster_;}
    reco::SuperClusterRef parentSuperCluster() const { return parentSuperCluster_;}

    // which returns the pfSuperCluster only if the standard supeclsuter is not null
    // But I had udnerstood from you when we spke last time that we wish to be free
    // to have both SCs available. Or not ? 

    reco::ConversionRefVector conversions() const {return conversions_;} 
    reco::ConversionRefVector conversionsOneLeg() const {return conversionsOneLeg_;} 

    void setConversions(const reco::ConversionRefVector &conversions) { conversions_ = conversions; }
    void setConversionsOneLeg(const reco::ConversionRefVector &conversions) { conversionsOneLeg_ = conversions; }
    
    reco::ElectronSeedRefVector electronPixelSeeds() const {return electronSeed_;}
    bool isPFlowPhoton() const {return isPFlowPhoton_;} 
    bool isStandardPhoton() const {return isStandardPhoton_;}

  private:

    reco::SuperClusterRef superCluster_;
    // vector of references to Conversions
    reco::ConversionRefVector  conversions_;
    //vector of references for 1-leg
    reco::ConversionRefVector  conversionsOneLeg_;
    // vector of references to ElectronPixelSeeds
    reco::ElectronSeedRefVector  electronSeed_;
    reco::SuperClusterRef parentSuperCluster_;
    bool  isPFlowPhoton_;
    bool  isStandardPhoton_;

  };

  
}

#endif