EcalRawToRecHitRoI.h

Go to the documentation of this file.

#ifndef EventFilter_EcalRawToRecHitRoI_H
#define EventFilter_EcalRawToRecHitRoI_H

#include <FWCore/Framework/interface/EDProducer.h>
                                                                                             
#include <DataFormats/Common/interface/Handle.h>
#include <FWCore/Framework/interface/ESHandle.h>
#include <FWCore/Framework/interface/Event.h>
#include <FWCore/Framework/interface/EDProducer.h>
#include <FWCore/MessageLogger/interface/MessageLogger.h>
#include <FWCore/ParameterSet/interface/ParameterSet.h>

#include "Geometry/EcalMapping/interface/EcalElectronicsMapping.h"
#include "Geometry/EcalMapping/interface/ESElectronicsMapper.h"

#include "CondFormats/L1TObjects/interface/L1CaloGeometry.h"
#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Common/interface/View.h"
                                                                                             
#include <iostream>
#include <string>
#include <vector>

#include "DataFormats/Common/interface/LazyGetter.h"
#include "DataFormats/Common/interface/RefGetter.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"

//additionnal stuff to be more precise with candidates
//#include "MagneticField/Engine/interface/MagneticField.h"
#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/GeomPropagators/interface/StateOnTrackerBound.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include <FWCore/Framework/interface/EventSetup.h>

class EcalRawToRecHitRoI : public edm::EDProducer {

  typedef edm::LazyGetter<EcalRecHit> EcalRecHitLazyGetter;
  typedef edm::RefGetter<EcalRecHit> EcalRecHitRefGetter;

public:

    EcalRawToRecHitRoI(const edm::ParameterSet& pset);
    virtual ~EcalRawToRecHitRoI();
    void produce(edm::Event & e, const edm::EventSetup& c);

 private:

    void Egamma(edm::Event& e, const edm::EventSetup& es, std::vector<int>& FEDs);
    void Muon(edm::Event& e, const edm::EventSetup& es, std::vector<int>& FEDs);
    void Jet(edm::Event& e, const edm::EventSetup& es, std::vector<int>& FEDs);
    void Cand(edm::Event& e, const edm::EventSetup& es, std::vector<int>& FEDs);


        edm::InputTag sourceTag_;
    bool do_es_;
    edm::InputTag sourceTag_es_;
    std::string esinstance_;
   
    const EcalElectronicsMapping* TheMapping;
    const ESElectronicsMapper *TheESMapping;

        class CalUnpackJobPSet {
    public:
      CalUnpackJobPSet(){}
      CalUnpackJobPSet(edm::ParameterSet &cfg){
        Source = cfg.getParameter<edm::InputTag>("Source");
        Ptmin = cfg.getParameter<double>("Ptmin");
        regionEtaMargin = cfg.getParameter<double>("regionEtaMargin");
        regionPhiMargin = cfg.getParameter<double>("regionPhiMargin");
      }
      edm::InputTag Source;
      double Ptmin;
      double regionEtaMargin;
      double regionPhiMargin;
    };

    bool EGamma_;
        class EmJobPSet : public CalUnpackJobPSet {
        public:
          EmJobPSet(edm::ParameterSet &cfg) : CalUnpackJobPSet(cfg){}
            ~EmJobPSet(){}
        };
        void Egamma_OneL1EmCollection(const edm::Handle< l1extra::L1EmParticleCollection > emColl,
                                      const EmJobPSet & ejpset,
                                      const edm::ESHandle< L1CaloGeometry > & l1CaloGeom,
                                      std::vector<int> & FEDs);
    std::vector< EmJobPSet > EmSource_;
    
    bool Muon_ ;
    class MuJobPSet : public CalUnpackJobPSet {
    public:
      MuJobPSet(){}
      MuJobPSet(edm::ParameterSet &cfg) : CalUnpackJobPSet(cfg), epsilon(0.01) {}
        ~MuJobPSet(){}
        double epsilon;
    };
    MuJobPSet MuonSource_;

    bool Jet_ ;
    class JetJobPSet :public CalUnpackJobPSet {
        public:
          JetJobPSet(edm::ParameterSet &cfg) : CalUnpackJobPSet(cfg), epsilon(0.01) {}
        ~JetJobPSet(){}
        double epsilon;
        };
    void Jet_OneL1JetCollection(const edm::Handle< l1extra::L1JetParticleCollection > jetColl,
                                    const JetJobPSet & jjpset,
                                    std::vector<int> & feds);
    std::vector< JetJobPSet > JetSource_;

    bool Candidate_;
    class CandJobPSet : public CalUnpackJobPSet {
    public:
      enum CTYPE { view, candidate, chargedcandidate, l1muon, l1jet };
      CandJobPSet(edm::ParameterSet &cfg);
      ~CandJobPSet(){}
      double epsilon;
      bool bePrecise;
      std::string propagatorNameToBePrecise;
      CTYPE cType;
    };
    template <typename CollectionType> void OneCandCollection(const edm::Event& e,
                                  const edm::EventSetup& es,
                                  const CandJobPSet & cjpset,
                                  std::vector<int> & feds);

    std::vector< CandJobPSet > CandSource_;

    bool All_;

    void ListOfFEDS(double etaLow, double etaHigh, double phiLow,
            double phiHigh, double etamargin, double phimargin,
            std::vector<int>& FEDs);
    
    void unique(std::vector<int>& FEDs){
      std::sort(FEDs.begin(),FEDs.end());
      std::vector<int>::iterator n_end = std::unique(FEDs.begin(),FEDs.end());
      FEDs.erase(n_end,FEDs.end());}
    std::string dumpFEDs(const std::vector<int>& FEDs);
};

template <typename CollectionType> void EcalRawToRecHitRoI::OneCandCollection(const edm::Event& e,
                                          const edm::EventSetup& es,
                                          const CandJobPSet & cjpset,
                                          std::vector<int> & feds){
  const std::string category ="EcalRawToRecHit|Cand";
  
  edm::Handle<CollectionType> candColl;
  e.getByLabel(cjpset.Source, candColl);
  if (candColl.failedToGet()) {
    edm::LogError("IncorrectConfiguration")<<"could not get: "<<cjpset.Source<<" of type: "<<cjpset.cType;
    return;
  }

  typename CollectionType::const_iterator it = candColl->begin();
  typename CollectionType::const_iterator end= candColl->end();

  StateOnTrackerBound * onBounds=0;
  edm::ESHandle<Propagator> propH;
  if (cjpset.bePrecise){
    //      grab a propagator from ES
    es.get<TrackingComponentsRecord>().get(cjpset.propagatorNameToBePrecise, propH);
    //      make the extrapolator object
    onBounds = new StateOnTrackerBound(propH.product());
  }
  
  for (; it!=end;++it){
    double pt    =  it->pt();
    double eta   =  it->eta();
    double phi   =  it->phi();
    if (cjpset.bePrecise){
      //      starting FTS
      GlobalPoint point(it->vx(),it->vy(),it->vz());
      GlobalVector vector(it->px(),it->py(),it->pz());

      if (point.mag()==0 && vector.mag()==0){
        edm::LogWarning("IncorrectRecHit")<<" state of candidate is not valid. skipping.";
        continue;
      }

      FreeTrajectoryState fts(point, vector, it->charge(), propH->magneticField());
      //      final TSOS
      TrajectoryStateOnSurface out = (*onBounds)(fts);
      if (out.isValid()){
    vector=out.globalMomentum();
    point=out.globalPosition();
    //      be more precise
    pt= vector.perp();
    eta= point.eta();
    phi= point.phi();
      }
      else{edm::LogWarning("IncorrectRecHit")<<"I tried to be precise, but propagation failed. from:\n"<<fts;
    continue;}
    }
    
    LogDebug(category)<<" here is a candidate Seed  with (eta,phi) = " 
              <<eta << " " << phi << " and pt " << pt;
    if (pt < cjpset.Ptmin) continue;
    
    ListOfFEDS(eta, eta, phi-cjpset.epsilon, phi+cjpset.epsilon, cjpset.regionEtaMargin, cjpset.regionPhiMargin,feds);
  }
  if(cjpset.bePrecise){delete onBounds;}
}

#endif