NamedCompositeCandidate.h

Go to the documentation of this file.

#ifndef Candidate_NamedCompositeCandidate_H
#define Candidate_NamedCompositeCandidate_H
#include "DataFormats/Candidate/interface/CompositeCandidate.h"
#include <memory>
#include "DataFormats/Candidate/interface/iterator_imp_specific.h"
#include "DataFormats/Candidate/interface/NamedCompositeCandidateFwd.h"
#include <string>
#include <map>

namespace reco {

  class NamedCompositeCandidate : public CompositeCandidate {
  public:
    typedef std::vector<std::string>                   role_collection;

    NamedCompositeCandidate(std::string name="") : CompositeCandidate(), name_(name) { }
    NamedCompositeCandidate(std::string name,
                const role_collection & roles  ) : 
      CompositeCandidate(), name_(name), roles_(roles) { }
    NamedCompositeCandidate( std::string name, 
                 const role_collection & roles,
                 Charge q, const LorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
                 int pdgId = 0, int status = 0, bool integerCharge = true ) :
      CompositeCandidate( q, p4, vtx, pdgId, status, integerCharge ), 
      name_ (name), roles_(roles) { }
    NamedCompositeCandidate( std::string name, 
                 const role_collection & roles, 
                 const Candidate & p );
 
    virtual ~NamedCompositeCandidate();
    virtual NamedCompositeCandidate * clone() const;
    // get name
    std::string             name() const { return name_; }
    // set name
    void                    setName( std::string n ) { name_ = n; }
    // get roles
    const NamedCompositeCandidate::role_collection & roles() const { return roles_;}
    // set roles
    void                    setRoles( const NamedCompositeCandidate::role_collection & roles ) { roles_.clear(); roles_ = roles; }
    // Get candidate based on role
    virtual Candidate *       daughter(const std::string& s );
    virtual const Candidate * daughter(const std::string& s ) const;
    // Get candidate based on index
    virtual Candidate *       daughter( size_type i ) { return CompositeCandidate::daughter(i); }
    virtual const Candidate * daughter( size_type i ) const  { return CompositeCandidate::daughter(i); }
    // Add daughters
    void                    addDaughter( const Candidate &, const std::string&s );
    void                    addDaughter( std::auto_ptr<Candidate>, const std::string& s );
    // Clear daughters and roles
    void                    clearDaughters() { CompositeCandidate::clearDaughters(); }
    void                    clearRoles() { roles_.clear(); }
    // Apply the roles to the objects
    void                    applyRoles();
  private:
    std::string      name_;
    role_collection  roles_;
  };

}

#endif