CandUtils/interface/makeCompositeCandidate.h

0001 #ifndef CandUtils_makeCompositeCandidate_h
0002 #define CandUtils_makeCompositeCandidate_h
0003 #include "DataFormats/Candidate/interface/CompositeCandidate.h"
0004 #include "DataFormats/Candidate/interface/CompositePtrCandidate.h"
0005 #include "DataFormats/Candidate/interface/ShallowCloneCandidate.h"
0006 #include <memory>
0007
0008 namespace helpers {
0009   struct CompositeCandidateMaker {
0010     CompositeCandidateMaker(std::unique_ptr<reco::CompositeCandidate> cmp) : cmp_(std::move(cmp)) {}
0011     void addDaughter(const reco::Candidate& dau) { cmp_->addDaughter(dau); }
0012     template <typename S>
0013     std::unique_ptr<reco::Candidate> operator[](const S& setup) {
0014       setup.set(*cmp_);
0015       return release();
0016     }
0017
0018   private:
0019     std::unique_ptr<reco::CompositeCandidate> cmp_;
0020     std::unique_ptr<reco::Candidate> release() {
0021       std::unique_ptr<reco::Candidate> ret(cmp_.get());
0022       cmp_.release();
0023       return ret;
0024     }
0025   };
0026
0027   struct CompositePtrCandidateMaker {
0028     CompositePtrCandidateMaker(std::unique_ptr<reco::CompositePtrCandidate> cmp) : cmp_(std::move(cmp)) {}
0029     void addDaughter(const reco::CandidatePtr& dau) { cmp_->addDaughter(dau); }
0030     template <typename S>
0031     std::unique_ptr<reco::Candidate> operator[](const S& setup) {
0032       setup.set(*cmp_);
0033       return release();
0034     }
0035
0036   private:
0037     std::unique_ptr<reco::CompositePtrCandidate> cmp_;
0038     std::unique_ptr<reco::Candidate> release() {
0039       std::unique_ptr<reco::Candidate> ret(cmp_.get());
0040       cmp_.release();
0041       return ret;
0042     }
0043   };
0044 }  // namespace helpers

0045
0046 helpers::CompositeCandidateMaker makeCompositeCandidate(const reco::Candidate& c1, const reco::Candidate& c2);
0047
0048 helpers::CompositeCandidateMaker makeCompositeCandidate(const reco::Candidate& c1,
0049                                                         const reco::Candidate& c2,
0050                                                         const reco::Candidate& c3);
0051
0052 helpers::CompositeCandidateMaker makeCompositeCandidate(const reco::Candidate& c1,
0053                                                         const reco::Candidate& c2,
0054                                                         const reco::Candidate& c3);
0055
0056 helpers::CompositeCandidateMaker makeCompositeCandidate(const reco::Candidate& c1,
0057                                                         const reco::Candidate& c2,
0058                                                         const reco::Candidate& c3,
0059                                                         const reco::Candidate& c4);
0060
0061 template <typename C>
0062 helpers::CompositeCandidateMaker makeCompositeCandidate(const typename C::const_iterator& begin,
0063                                                         const typename C::const_iterator& end) {
0064   helpers::CompositeCandidateMaker cmp(std::make_unique<reco::CompositeCandidate>());
0065   for (typename C::const_iterator i = begin; i != end; ++i)
0066     cmp.addDaughter(*i);
0067   return cmp;
0068 }
0069
0070 helpers::CompositeCandidateMaker makeCompositeCandidateWithRefsToMaster(const reco::CandidateRef& c1,
0071                                                                         const reco::CandidateRef& c2);
0072
0073 helpers::CompositeCandidateMaker makeCompositeCandidateWithRefsToMaster(const reco::CandidateRef& c1,
0074                                                                         const reco::CandidateRef& c2,
0075                                                                         const reco::CandidateRef& c3);
0076
0077 helpers::CompositeCandidateMaker makeCompositeCandidateWithRefsToMaster(const reco::CandidateRef& c1,
0078                                                                         const reco::CandidateRef& c2,
0079                                                                         const reco::CandidateRef& c3,
0080                                                                         const reco::CandidateRef& c4);
0081
0082 template <typename C>
0083 helpers::CompositeCandidateMaker makeCompositeCandidateWithRefsToMaster(const typename C::const_iterator& begin,
0084                                                                         const typename C::const_iterator& end) {
0085   helpers::CompositeCandidateMaker cmp(std::make_unique<reco::CompositeCandidate>());
0086   for (typename C::const_iterator i = begin; i != end; ++i)
0087     cmp.addDaughter(ShallowCloneCandidate(CandidateBaseRef(*i)));
0088   return cmp;
0089 }
0090
0091 helpers::CompositePtrCandidateMaker makeCompositePtrCandidate(const reco::CandidatePtr& c1,
0092                                                               const reco::CandidatePtr& c2);
0093
0094 helpers::CompositePtrCandidateMaker makeCompositePtrCandidate(const reco::CandidatePtr& c1,
0095                                                               const reco::CandidatePtr& c2,
0096                                                               const reco::CandidatePtr& c3);
0097
0098 helpers::CompositePtrCandidateMaker makeCompositePtrCandidate(const reco::CandidatePtr& c1,
0099                                                               const reco::CandidatePtr& c2,
0100                                                               const reco::CandidatePtr& c3);
0101
0102 helpers::CompositePtrCandidateMaker makeCompositePtrCandidate(const reco::CandidatePtr& c1,
0103                                                               const reco::CandidatePtr& c2,
0104                                                               const reco::CandidatePtr& c3,
0105                                                               const reco::CandidatePtr& c4);
0106
0107 #endif