CSCRecHitDBuilder.cc

Go to the documentation of this file.

// This is CSCRecHitDBuilder.cc

#include <RecoLocalMuon/CSCRecHitD/src/CSCRecHitDBuilder.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCHitFromStripOnly.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCHitFromWireOnly.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCMake2DRecHit.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCWireHitCollection.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCStripHitCollection.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCRangeMapForRecHit.h>
 
#include <Geometry/CSCGeometry/interface/CSCChamberSpecs.h>
#include <Geometry/CSCGeometry/interface/CSCLayer.h>
#include <Geometry/CSCGeometry/interface/CSCGeometry.h>

#include <DataFormats/MuonDetId/interface/CSCDetId.h>

#include <CondFormats/CSCObjects/interface/CSCDBGains.h>
#include <CondFormats/DataRecord/interface/CSCDBGainsRcd.h>
#include <CondFormats/CSCObjects/interface/CSCDBCrosstalk.h>
#include <CondFormats/DataRecord/interface/CSCDBCrosstalkRcd.h>
#include <CondFormats/CSCObjects/interface/CSCDBNoiseMatrix.h>
#include <CondFormats/DataRecord/interface/CSCDBNoiseMatrixRcd.h>

#include <FWCore/Utilities/interface/Exception.h>
#include <FWCore/MessageLogger/interface/MessageLogger.h> 

#include <iostream>
#include <cassert>

CSCRecHitDBuilder::CSCRecHitDBuilder( const edm::ParameterSet& ps ) : geom_(0) {
  
  // Receives ParameterSet percolated down from EDProducer  

  useCalib               = ps.getParameter<bool>("CSCUseCalibrations");  
  stripWireDeltaT        = ps.getParameter<int>("CSCstripWireDeltaTime");
  
  hitsFromStripOnly_     = new CSCHitFromStripOnly( ps ); 
  hitsFromWireOnly_      = new CSCHitFromWireOnly( ps );  
  make2DHits_            = new CSCMake2DRecHit( ps );
}


CSCRecHitDBuilder::~CSCRecHitDBuilder() {
  delete hitsFromStripOnly_;
  delete hitsFromWireOnly_;
  delete make2DHits_;   
}


void CSCRecHitDBuilder::build( const CSCStripDigiCollection* stripdc, const CSCWireDigiCollection* wiredc,
                               CSCRecHit2DCollection& oc ) {
  LogTrace("CSCRecHitDBuilder") << "[CSCRecHitDBuilder] build entered";

  if ( !geom_ ) throw cms::Exception("MissingGeometry") << "[CSCRecHitDBuilder::getLayer] Missing geometry" << std::endl;




  //  create 2-D hits by looking at superposition of strip and wire hit in a layer
  //
  // N.B.  I've sorted the hits from layer 1-6 always, so can test if there are "holes", 
  // that is layers without hits for a given chamber.

  // Vector to store rechit within layer
  std::vector<CSCRecHit2D> hitsInLayer;

  int layer_idx     = 0;
  int hits_in_layer = 0;
  CSCDetId old_id; 

  
  for ( CSCStripDigiCollection::DigiRangeIterator it = stripdc->begin(); it != stripdc->end(); ++it ){
    const CSCDetId& id = (*it).first;
    const CSCLayer* layer = getLayer( id );
    const CSCStripDigiCollection::Range& rstripd = (*it).second;
    
    // Skip if no strip digis in this layer
    if ( rstripd.second == rstripd.first ) continue;

    const CSCDetId& sDetId = id;
 
    // This is used to test for gaps in layers and needs to be initialized here 
    if ( layer_idx == 0 ) {
      old_id = sDetId;
    }


    CSCDetId compId = sDetId;
    CSCWireDigiCollection::Range rwired = wiredc->get( sDetId );
    // Skip if no wire digis in this layer
    // But for ME11, real wire digis are labelled as belonging to ME1b, so that's where ME1a must look
    // (We try ME1a - above - anyway, because simulated wire digis are labelled as ME1a.)
    if ( rwired.second == rwired.first ) {
      if ( sDetId.station()!=1 || sDetId.ring()!=4 ){
        continue; // not ME1a, skip to next layer
      }
      // So if ME1a has no wire digis (always the case for data) make the
      // wire digi ID point to ME1b. This is what is compared to the
      // strip digi ID below (and not used anywhere else). 
      // Later, rechits use the strip digi ID for construction.
      
      // It is ME1a but no wire digis there, so try ME1b...
      int endcap  = sDetId.endcap();
      int chamber = sDetId.chamber();
      int layer   = sDetId.layer();
      CSCDetId idw( endcap, 1, 1, chamber, layer ); // Set idw to same layer in ME1b
      compId = idw;
      rwired = wiredc->get( compId );
    }
 
    // Fill bad channel bitsets for this layer
    recoConditions_->fillBadChannelWords( id );
    
    // Build strip hits for this layer
    std::vector<CSCStripHit> const & cscStripHit = hitsFromStripOnly_->runStrip( id, layer, rstripd);

    if (cscStripHit.empty()) continue;

    hitsInLayer.clear();
    hits_in_layer = 0;
 
   
    // now build collection of wire only hits !  
    std::vector<CSCWireHit> const & cscWireHit = hitsFromWireOnly_->runWire(compId, layer, rwired);

   
    
    // Build 2D hit for all possible strip-wire pairs 
    // overlapping within this layer
    
    LogTrace("CSCRecHitBuilder")<< "[CSCRecHitDBuilder] found " << cscStripHit.size() << " strip and " 
                << cscWireHit.size()  << " wire hits in layer " << sDetId;
    
    for (auto const & s_hit : cscStripHit) {
      for (auto const & w_hit : cscWireHit) {
    CSCRecHit2D rechit = make2DHits_->hitFromStripAndWire(sDetId, layer, w_hit, s_hit);
    
    bool isInFiducial = make2DHits_->isHitInFiducial( layer, rechit );
    if ( isInFiducial ) {
      hitsInLayer.push_back( rechit );
      hits_in_layer++;
    }
      }
    }

  
  

    LogTrace("CSCRecHitDBuilder") << "[CSCRecHitDBuilder] " << hits_in_layer << " rechits found in layer " << sDetId;
    // std::cout << "[CSCRecHitDBuilder] " << hits_in_layer << " rechits found in layer " << sDetId << std::endl;
    
    // output vector of 2D rechits to collection
    if (hits_in_layer > 0) {
      oc.put( sDetId, hitsInLayer.begin(), hitsInLayer.end() );
      hitsInLayer.clear();
    }
    hits_in_layer = 0;
    layer_idx++;
    old_id = sDetId;
  }

  LogTrace("CSCRecHitDBuilder") << "[CSCRecHitDBuilder] " << oc.size() << " 2d rechits created in this event.";

}


const CSCLayer* CSCRecHitDBuilder::getLayer( const CSCDetId& detId )  {
  return geom_->layer(detId);
}


void CSCRecHitDBuilder::setConditions( CSCRecoConditions* reco ) {
  recoConditions_ = reco;
  hitsFromStripOnly_->setConditions( reco );
  hitsFromWireOnly_->setConditions( reco );
  make2DHits_->setConditions( reco );  
}