MuIsoDepositProducer.cc

Go to the documentation of this file.

#include "RecoMuon/MuonIsolationProducers/plugins/MuIsoDepositProducer.h"

// Framework
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "DataFormats/Common/interface/Handle.h"

#include "FWCore/Framework/interface/ESHandle.h"

#include "DataFormats/RecoCandidate/interface/IsoDeposit.h"
#include "DataFormats/RecoCandidate/interface/IsoDepositFwd.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"


#include "RecoMuon/MuonIsolation/interface/Range.h"
#include "DataFormats/RecoCandidate/interface/IsoDepositDirection.h"

#include "PhysicsTools/IsolationAlgos/interface/IsoDepositExtractor.h"
#include "PhysicsTools/IsolationAlgos/interface/IsoDepositExtractorFactory.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <string>

using namespace edm;
using namespace std;
using namespace reco;
using namespace muonisolation;


MuIsoDepositProducer::MuIsoDepositProducer(const ParameterSet& par) :
  theConfig(par),
  theDepositNames(std::vector<std::string>(1,std::string())),
  theExtractor(0)
{
  LogDebug("RecoMuon|MuonIsolation")<<" MuIsoDepositProducer CTOR";

  edm::ParameterSet ioPSet = par.getParameter<edm::ParameterSet>("IOPSet");

  theInputType = ioPSet.getParameter<std::string>("InputType");
  theExtractForCandidate = ioPSet.getParameter<bool>("ExtractForCandidate");
  theMuonTrackRefType = ioPSet.getParameter<std::string>("MuonTrackRefType");
  theMuonCollectionTag = ioPSet.getParameter<edm::InputTag>("inputMuonCollection");
  theMultipleDepositsFlag = ioPSet.getParameter<bool>("MultipleDepositsFlag");



  if (theMultipleDepositsFlag){
    theDepositNames = par.getParameter<edm::ParameterSet>("ExtractorPSet")
      .getParameter<std::vector<std::string> >("DepositInstanceLabels");
  }

  for (unsigned int i = 0; i < theDepositNames.size(); ++i){
    std::string alias = theConfig.getParameter<std::string>("@module_label");
    if (theDepositNames[i] != "") alias += "_" + theDepositNames[i];
    produces<reco::IsoDepositMap>(theDepositNames[i]).setBranchAlias(alias);
  }

  if (!theExtractor) {
    edm::ParameterSet extractorPSet = theConfig.getParameter<edm::ParameterSet>("ExtractorPSet");
    std::string extractorName = extractorPSet.getParameter<std::string>("ComponentName");
    theExtractor = IsoDepositExtractorFactory::get()->create( extractorName, extractorPSet, consumesCollector());
    LogDebug(metname)<<" Load extractor..."<<extractorName;
  }


}

MuIsoDepositProducer::~MuIsoDepositProducer(){
  LogDebug("RecoMuon/MuIsoDepositProducer")<<" MuIsoDepositProducer DTOR";
  delete theExtractor;
}

void MuIsoDepositProducer::produce(Event& event, const EventSetup& eventSetup){
  std::string metname = "RecoMuon|MuonIsolationProducers|MuIsoDepositProducer";

  LogDebug(metname)<<" Muon Deposit producing..."
           <<" BEGINING OF EVENT " <<"================================";

  unsigned int nDeps = theMultipleDepositsFlag ? theDepositNames.size() : 1;



  // Take the muon container
  LogTrace(metname)<<" Taking the muons: "<<theMuonCollectionTag;
  Handle<View<Track> > tracks;
  Handle<View<RecoCandidate> > muons;
  Handle<View<Candidate> > cands;

  unsigned int nMuons = 0;

  bool readFromRecoTrack = theInputType == "TrackCollection";
  bool readFromRecoMuon = theInputType == "MuonCollection";
  bool readFromCandidateView = theInputType == "CandidateView";

  if (readFromRecoMuon){
    event.getByLabel(theMuonCollectionTag,muons);
    nMuons = muons->size();
    LogDebug(metname) <<"Got Muons of size "<<nMuons;

  }
  if (readFromRecoTrack){
    event.getByLabel(theMuonCollectionTag,tracks);
    nMuons = tracks->size();
    LogDebug(metname) <<"Got MuonTracks of size "<<nMuons;
  }
  if (readFromCandidateView || theExtractForCandidate){
    event.getByLabel(theMuonCollectionTag,cands);
    unsigned int nCands = cands->size();
    if (readFromRecoMuon && theExtractForCandidate){
      if (nMuons != nCands) edm::LogError(metname)<<"Inconsistent configuration or failure to read Candidate-muon view";
    }
        nMuons = nCands;
    LogDebug(metname)<< "Got candidate view with size "<<nMuons;
  }

  static const unsigned int MAX_DEPS=10;
  std::auto_ptr<reco::IsoDepositMap> depMaps[MAX_DEPS];

  if (nDeps >10 ) LogError(metname)<<"Unable to handle more than 10 input deposits";
  for (unsigned int i =0;i<nDeps; ++i){
    depMaps[i] =  std::auto_ptr<reco::IsoDepositMap>(new reco::IsoDepositMap());
  }

  if (nMuons > 0){

    std::vector<std::vector<IsoDeposit> > deps2D(nDeps, std::vector<IsoDeposit>(nMuons));

    for (unsigned int i=0; i<  nMuons; ++i) {
      TrackBaseRef muRef;
      if (readFromRecoMuon){
    if (theMuonTrackRefType == "track"){
      muRef = TrackBaseRef((*muons)[i].track());
    } else if (theMuonTrackRefType == "standAloneMuon"){
      muRef = TrackBaseRef((*muons)[i].standAloneMuon());
    } else if (theMuonTrackRefType == "combinedMuon"){
      muRef = TrackBaseRef((*muons)[i].combinedMuon());
    } else if (theMuonTrackRefType == "bestGlbTrkSta"){
      if (!(*muons)[i].combinedMuon().isNull()){
        muRef = TrackBaseRef((*muons)[i].combinedMuon());
      } else if (!(*muons)[i].track().isNull()){
        muRef = TrackBaseRef((*muons)[i].track());
      } else {
        muRef = TrackBaseRef((*muons)[i].standAloneMuon());
      }
    } else if (theMuonTrackRefType == "bestTrkSta"){
      if (!(*muons)[i].track().isNull()){
        muRef = TrackBaseRef((*muons)[i].track());
      } else {
        muRef = TrackBaseRef((*muons)[i].standAloneMuon());
      }
    }else {
      edm::LogWarning(metname)<<"Wrong track type is supplied: breaking";
      break;
    }
      } else if (readFromRecoTrack){
    muRef = TrackBaseRef(tracks, i);
      }

      if (! theMultipleDepositsFlag){
                if (readFromCandidateView || theExtractForCandidate) deps2D[0][i] = theExtractor->deposit(event, eventSetup, (*cands)[i]);
    else deps2D[0][i] = theExtractor->deposit(event, eventSetup, muRef);

      } else {
    std::vector<IsoDeposit> deps(nDeps);
                if (readFromCandidateView || theExtractForCandidate) deps = theExtractor->deposits(event, eventSetup, (*cands)[i]);
    else deps = theExtractor->deposits(event, eventSetup, muRef);
    for (unsigned int iDep =0; iDep<nDeps; ++iDep) {
      deps2D[iDep][i] = deps[iDep];
    }
      }
    }

    for (unsigned int iDep=0; iDep < nDeps; ++iDep){
      for (unsigned int iMu = 0; iMu< nMuons; ++iMu){
    LogTrace(metname)<<"Contents of "<<theDepositNames[iDep]
             <<" for a muon at index "<<iMu;
    LogTrace(metname)<<deps2D[iDep][iMu].print();
      }

      reco::IsoDepositMap::Filler filler(*depMaps[iDep]);

      if (readFromRecoMuon){
    filler.insert(muons, deps2D[iDep].begin(), deps2D[iDep].end());
      } else if (readFromRecoTrack){
    filler.insert(tracks, deps2D[iDep].begin(), deps2D[iDep].end());
      } else if (readFromCandidateView){
    filler.insert(cands, deps2D[iDep].begin(), deps2D[iDep].end());
      } else {
    edm::LogError(metname)<<"Inconsistent configuration: unknown type requested";
      }

      filler.fill();
    }
  }


  for (unsigned int iMap = 0; iMap < nDeps; ++iMap){
    LogTrace(metname)<<"About to put a deposit named "<<theDepositNames[iMap]
             <<" of size "<<depMaps[iMap]->size()
             <<" into edm::Event";
    event.put(depMaps[iMap], theDepositNames[iMap]);
  }

  LogTrace(metname) <<" END OF EVENT " <<"================================";
}

#include "FWCore/PluginManager/interface/ModuleDef.h"
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(MuIsoDepositProducer);