/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/CommonTools/CandAlgos/interface/NamedCandCombiner.h

Go to the documentation of this file.

#ifndef CandAlgos_NamedCandCombiner_h
#define CandAlgos_NamedCandCombiner_h

#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "CommonTools/CandUtils/interface/NamedCandCombiner.h"
#include "CommonTools/CandAlgos/interface/decayParser.h"
#include "CommonTools/Utilities/interface/StringCutObjectSelector.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "CommonTools/UtilAlgos/interface/ParameterAdapter.h"
#include "CommonTools/UtilAlgos/interface/EventSetupInitTrait.h"
#include "CommonTools/Utilities/interface/cutParser.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Candidate/interface/NamedCompositeCandidate.h"
#include "DataFormats/Candidate/interface/NamedCompositeCandidateFwd.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include <string>
#include <vector>
#include <algorithm>

namespace edm {
  class ParameterSet;
}

namespace reco {
  namespace modules {

    struct NamedCandCombinerBase : public edm::EDProducer {
      NamedCandCombinerBase( const edm::ParameterSet & cfg ) :
        setLongLived_(false), 
        setMassConstraint_(false),
        setPdgId_(false) {
        using namespace cand::parser;
        using namespace std;
        string decay(cfg.getParameter<string>("decay"));
        if(decayParser(decay, labels_))
          for(vector<ConjInfo>::iterator label = labels_.begin();
               label != labels_.end(); ++label)
        if(label->mode_ == ConjInfo::kPlus)
          dauCharge_.push_back( 1 );
        else if (label->mode_ == ConjInfo::kMinus)
          dauCharge_.push_back(-1);
        else
          dauCharge_.push_back(0);
        else
          throw edm::Exception(edm::errors::Configuration,
                               "failed to parse \"" + decay + "\"");
        
        int lists = labels_.size();
        if(lists != 2 && lists != 3)
          throw edm::Exception(edm::errors::LogicError,
                               "invalid number of collections");
        bool found;
        const string setLongLived("setLongLived");
        vector<string> vBoolParams = cfg.getParameterNamesForType<bool>();
        found = find(vBoolParams.begin(), vBoolParams.end(), setLongLived) != vBoolParams.end();
        if(found) setLongLived_ = cfg.getParameter<bool>("setLongLived");
        const string setMassConstraint("setMassConstraint");
        found = find(vBoolParams.begin(), vBoolParams.end(), setMassConstraint) != vBoolParams.end();
        if(found) setMassConstraint_ = cfg.getParameter<bool>("setMassConstraint");
        const string setPdgId("setPdgId");
        vector<string> vIntParams = cfg.getParameterNamesForType<int>();
        found = find(vIntParams.begin(), vIntParams.end(), setPdgId) != vIntParams.end();
        if(found) { setPdgId_ = true; pdgId_ = cfg.getParameter<int>("setPdgId"); }

        name_ = cfg.getParameter<std::string>( "name" );
        roles_= cfg.getParameter<std::vector<std::string> > ( "roles" );
      }
    protected:
      std::vector<cand::parser::ConjInfo> labels_;
      std::vector<int> dauCharge_;
      bool setLongLived_;
      bool setMassConstraint_;
      bool setPdgId_;
      int pdgId_;
      std::string name_;
      // Name of the roles
      std::vector<std::string> roles_;
    };
    
    template<typename Selector, 
             typename PairSelector = AnyPairSelector,
             typename Cloner = ::combiner::helpers::NormalClone, 
             typename Setup = AddFourMomenta,
             typename Init = typename ::reco::modules::EventSetupInit<Setup>::type         
            >
    class NamedCandCombiner : public NamedCandCombinerBase {
      public:
      explicit NamedCandCombiner( const edm::ParameterSet & cfg ) :
        NamedCandCombinerBase( cfg ),
        combiner_( name_,
                   reco::modules::make<Selector>( cfg ), 
                   reco::modules::make<PairSelector>( cfg ),
                   Setup( cfg ), 
                   cfg.existsAs<bool>("checkCharge")  ? cfg.getParameter<bool>("checkCharge")  : true, 
                   cfg.existsAs<bool>("checkOverlap") ? cfg.getParameter<bool>("checkOverlap") : true, 
                   dauCharge_ ) {
        produces<reco::NamedCompositeCandidateCollection>();
      }
      virtual ~NamedCandCombiner() { }

    private:
      void produce(edm::Event& evt, const edm::EventSetup& es) {
        using namespace std;
        using namespace reco;
        Init::init(combiner_.setup(), evt, es);
        int n = labels_.size();
        std::vector<edm::Handle<CandidateView> > colls(n);
        for(int i = 0; i < n; ++i) {
          evt.getByLabel(labels_[i].tag_, colls[i]);
        }
        std::vector<CandidatePtrVector> cv;
        for(typename std::vector<edm::Handle<CandidateView> >::const_iterator c = colls.begin();
            c != colls.end(); ++ c) {
          CandidatePtrVector r;
          CandidateView::size_type n_view = (*c)->size();
          for ( CandidateView::size_type iview = 0; iview < n_view; ++iview ) {
            CandidatePtr ri( *c, iview );
            r.push_back( ri );
          }
          cv.push_back(r);
        }
        std::auto_ptr<NamedCompositeCandidateCollection> out = combiner_.combine(cv, roles_);
        if(setLongLived_ || setMassConstraint_ || setPdgId_) {
          typename NamedCompositeCandidateCollection::iterator i = out->begin(), e = out->end();
          for(; i != e; ++i) {
            i->setName( name_ );
            i->setRoles( roles_ );
            i->applyRoles();
            if(setLongLived_) i->setLongLived();
            if(setMassConstraint_) i->setMassConstraint();
            if(setPdgId_) i->setPdgId(pdgId_);
          }
        }
        evt.put(out);
      }
      ::NamedCandCombiner<Selector, PairSelector, Cloner, Setup> combiner_;
    };

  }
}

#endif