SeedClusterRemoverPhase2.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "DataFormats/Phase2TrackerCluster/interface/Phase2TrackerCluster1D.h"
#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"

#include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h"
#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h"
#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/ContainerMask.h"

#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"

#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
#include "Geometry/CommonDetUnit/interface/GeomDetType.h"

//
// class decleration
//

class SeedClusterRemoverPhase2 : public edm::stream::EDProducer<> {

  public:
    SeedClusterRemoverPhase2(const edm::ParameterSet& iConfig) ;
    void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override ;
  private:
    bool doOuterTracker_, doPixel_;
    bool mergeOld_;
    typedef edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > PixelMaskContainer;
    typedef edm::ContainerMask<edmNew::DetSetVector<Phase2TrackerCluster1D> > Phase2OTMaskContainer;
    edm::EDGetTokenT<edmNew::DetSetVector<SiPixelCluster> > pixelClusters_;
    edm::EDGetTokenT<edmNew::DetSetVector<Phase2TrackerCluster1D> > phase2OTClusters_;
    edm::EDGetTokenT<PixelMaskContainer> oldPxlMaskToken_;
    edm::EDGetTokenT<Phase2OTMaskContainer> oldPh2OTMaskToken_;
    edm::EDGetTokenT<TrajectorySeedCollection> trajectories_;

    std::vector<uint8_t> pixels, OTs;                // avoid unneed alloc/dealloc of this
    edm::ProductID pixelSourceProdID, outerTrackerSourceProdID; // ProdIDs refs must point to (for consistency tests)

    inline void process(const TrackingRecHit *hit, float chi2, const TrackerGeometry* tg);

    std::vector<bool> collectedOuterTrackers_;
    std::vector<bool> collectedPixels_;
};


using namespace std;
using namespace edm;

SeedClusterRemoverPhase2::SeedClusterRemoverPhase2(const ParameterSet& iConfig):
    doOuterTracker_(iConfig.existsAs<bool>("doOuterTracker") ? iConfig.getParameter<bool>("doOuterTracker") : true),
    doPixel_(iConfig.existsAs<bool>("doPixel") ? iConfig.getParameter<bool>("doPixel") : true),
    mergeOld_(iConfig.exists("oldClusterRemovalInfo"))
{
  produces<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > >();
  produces<edm::ContainerMask<edmNew::DetSetVector<Phase2TrackerCluster1D> > >();
  
  trajectories_ = consumes<TrajectorySeedCollection>(iConfig.getParameter<InputTag>("trajectories"));
  if (doPixel_) pixelClusters_ = consumes<edmNew::DetSetVector<SiPixelCluster> >(iConfig.getParameter<InputTag>("pixelClusters"));
  if (doOuterTracker_) phase2OTClusters_ = consumes<edmNew::DetSetVector<Phase2TrackerCluster1D> >(iConfig.getParameter<InputTag>("phase2OTClusters"));
  if (mergeOld_) {
    oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
    oldPh2OTMaskToken_ = consumes<Phase2OTMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
  }
}


void SeedClusterRemoverPhase2::process(const TrackingRecHit *hit, float chi2, const TrackerGeometry* tg) {

  DetId detid = hit->geographicalId(); 
  uint32_t subdet = detid.subdetId();

  assert(subdet > 0);

  const type_info &hitType = typeid(*hit);
  if (hitType == typeid(SiPixelRecHit)) {

    if(!doPixel_) return;

    const SiPixelRecHit *pixelHit = static_cast<const SiPixelRecHit *>(hit);
    SiPixelRecHit::ClusterRef cluster = pixelHit->cluster();
    LogDebug("SeedClusterRemoverPhase2") << "Plain Pixel RecHit in det " << detid.rawId();

    if (cluster.id() != pixelSourceProdID) throw cms::Exception("Inconsistent Data") << 
            "SeedClusterRemoverPhase2: pixel cluster ref from Product ID = " << cluster.id() << 
            " does not match with source cluster collection (ID = " << pixelSourceProdID << ")\n.";

    assert(cluster.id() == pixelSourceProdID);

    // mark as used
    pixels[cluster.key()] = false;
    
    assert(collectedPixels_.size() > cluster.key());
    collectedPixels_[cluster.key()]=true;
      
  } else if (hitType == typeid(Phase2TrackerRecHit1D)) {

    if(!doOuterTracker_) return;

    const Phase2TrackerRecHit1D *ph2OThit = static_cast<const Phase2TrackerRecHit1D*>(hit);
    LogDebug("SeedClusterRemoverPhase2") << "Plain Phase2TrackerRecHit1D in det " << detid.rawId();

    Phase2TrackerRecHit1D::CluRef cluster = ph2OThit->cluster();
    if (cluster.id() != outerTrackerSourceProdID) throw cms::Exception("Inconsistent Data") <<
      "SeedClusterRemoverPhase2: strip cluster ref from Product ID = " << cluster.id() <<
      " does not match with source cluster collection (ID = " << outerTrackerSourceProdID << ")\n.";
  
    assert(cluster.id() == outerTrackerSourceProdID);

    OTs[cluster.key()] = false;
    assert(collectedOuterTrackers_.size() > cluster.key());
    collectedOuterTrackers_[cluster.key()]=true;
  
  } else throw cms::Exception("NOT IMPLEMENTED") << "I received a hit that was neither SiPixelRecHit nor Phase2TrackerRecHit1D but " << hitType.name() << " on detid " << detid.rawId() << "\n";

  
}

void
SeedClusterRemoverPhase2::produce(Event& iEvent, const EventSetup& iSetup)
{
    ProductID pixelOldProdID, stripOldProdID;

    edm::ESHandle<TrackerGeometry> tgh;
    iSetup.get<TrackerDigiGeometryRecord>().get("",tgh);  //is it correct to use "" ?

    Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
    if (doPixel_) {
        iEvent.getByToken(pixelClusters_, pixelClusters);
        pixelSourceProdID = pixelClusters.id();
    }
    LogDebug("SeedClusterRemoverPhase2") << "Read pixel with id " << pixelSourceProdID << std::endl;

    Handle<edmNew::DetSetVector<Phase2TrackerCluster1D> > phase2OTClusters;
    if (doOuterTracker_) {
        iEvent.getByToken(phase2OTClusters_, phase2OTClusters);
        outerTrackerSourceProdID = phase2OTClusters.id();
    }
    LogDebug("SeedClusterRemoverPhase2") << "Read OT cluster with id " << outerTrackerSourceProdID << std::endl;


    if (doOuterTracker_) {
      OTs.resize(phase2OTClusters->dataSize()); fill(OTs.begin(), OTs.end(), true);
    }
    if (doPixel_) {
      pixels.resize(pixelClusters->dataSize()); fill(pixels.begin(), pixels.end(), true);
    }
    if(mergeOld_) {
      edm::Handle<PixelMaskContainer> oldPxlMask;
      edm::Handle<Phase2OTMaskContainer> oldPh2OTMask;
      iEvent.getByToken(oldPxlMaskToken_ ,oldPxlMask);
      iEvent.getByToken(oldPh2OTMaskToken_ ,oldPh2OTMask);
      LogDebug("SeedClusterRemoverPhase2") << "to merge in, "<<oldPh2OTMask->size()<<" strp and "<<oldPxlMask->size()<<" pxl";
      oldPh2OTMask->copyMaskTo(collectedOuterTrackers_);
      oldPxlMask->copyMaskTo(collectedPixels_);
      assert(phase2OTClusters->dataSize()>=collectedOuterTrackers_.size());
      collectedOuterTrackers_.resize(phase2OTClusters->dataSize(),false);  // for ondemand
    }else {
      collectedOuterTrackers_.resize(phase2OTClusters->dataSize(), false);
      collectedPixels_.resize(pixelClusters->dataSize(), false);
    } 


    edm::Handle<TrajectorySeedCollection> seeds;
    iEvent.getByToken(trajectories_,seeds);

    for (auto const & seed : (*seeds) ){
      auto hits=seed.recHits();
      auto hit=hits.first;
      for (;hit!=hits.second;++hit){
    if (!hit->isValid()) continue;
    process( &(*hit), 0. , tgh.product());
      }
    }
      
    
    pixels.clear(); OTs.clear(); 

      
    LogDebug("SeedClusterRemoverPhase2")<<"total strip to skip: "<<std::count(collectedOuterTrackers_.begin(),collectedOuterTrackers_.end(),true);
    iEvent.put(std::make_unique<Phase2OTMaskContainer>(edm::RefProd<edmNew::DetSetVector<Phase2TrackerCluster1D> >(phase2OTClusters),collectedOuterTrackers_));

    LogDebug("SeedClusterRemoverPhase2")<<"total pxl to skip: "<<std::count(collectedPixels_.begin(),collectedPixels_.end(),true);
    iEvent.put(std::make_unique<PixelMaskContainer>(edm::RefProd<edmNew::DetSetVector<SiPixelCluster> >(pixelClusters),collectedPixels_));
      
    collectedOuterTrackers_.clear();
    collectedPixels_.clear();    

}

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