CSCHitFromWireOnly.cc

Go to the documentation of this file.

/* This is CSCHitFromWireOnly
 *
 * Finds wiregroup with hits, and fill in CSCWireHitCollection
 * which includes only DetId and wiregroup #
 *
 */

#include <RecoLocalMuon/CSCRecHitD/src/CSCHitFromWireOnly.h>
#include <RecoLocalMuon/CSCRecHitD/src/CSCWireHit.h>

#include <Geometry/CSCGeometry/interface/CSCLayer.h>
#include <Geometry/CSCGeometry/interface/CSCLayerGeometry.h>

#include <DataFormats/CSCDigi/interface/CSCWireDigi.h>

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

#include <iostream>


CSCHitFromWireOnly::CSCHitFromWireOnly( const edm::ParameterSet& ps ) : recoConditions_(0){
  
  deltaT                 = ps.getParameter<int>("CSCWireClusterDeltaT");
  //clusterSize            = ps.getParameter<int>("CSCWireClusterMaxSize");
}


CSCHitFromWireOnly::~CSCHitFromWireOnly(){}


std::vector<CSCWireHit> CSCHitFromWireOnly::runWire( const CSCDetId& id, const CSCLayer* layer, const CSCWireDigiCollection::Range& rwired ) {
  
  std::vector<CSCWireHit> hitsInLayer;

  id_        = id;
  layer_ = layer;
  layergeom_ = layer->geometry();
  bool any_digis = true;
  int n_wgroup = 0;


  // Loop over wire digi collection
  for ( CSCWireDigiCollection::const_iterator it = rwired.first; it != rwired.second; ++it ) {
    
    const CSCWireDigi wdigi = *it;

    if(isDeadWG( id, wdigi.getWireGroup())){     
      continue;      
    }
    if ( any_digis ) {
      any_digis = false;
      makeWireCluster( wdigi );
      n_wgroup = 1;
    } else {
      if ( !addToCluster( wdigi ) ) {
          // Make Wire Hit from cluster, delete old cluster and start new one
    float whit_pos = findWireHitPosition();
        bool deadWG_left = isDeadWG( id, wire_in_cluster.at(0) -1 ); 
    bool deadWG_right = isDeadWG( id, wire_in_cluster.at(wire_in_cluster.size()-1) + 1);
    short int aDeadWG = 0;
    if(!deadWG_left && !deadWG_right){
      aDeadWG = 0;
    }
    else if(deadWG_left && deadWG_right){
      aDeadWG = 255;
    }
    else{
      if(deadWG_left){
        aDeadWG = wire_in_cluster.at(0) -1;
      }
      else{
        aDeadWG = wire_in_cluster.at(wire_in_cluster.size()-1) + 1;
      }
    }
       // Set time bins for wire hit as the time bins of the central wire digi, lower of central two if an even number of digis.
      std::vector <int> timeBinsOn=wire_cluster[n_wgroup/2].getTimeBinsOn();
      //CSCWireHit whit(id, whit_pos, wire_in_clusterAndBX, theTime, isDeadWGAround, timeBinsOn );
      CSCWireHit whit(id, whit_pos, wire_in_clusterAndBX, theTime, aDeadWG, timeBinsOn );
      hitsInLayer.push_back( whit );    
      makeWireCluster( wdigi );
      n_wgroup = 1;
      } else {
          n_wgroup++;
      }
    }
    // Don't forget to fill last wire hit !!!
    if ( rwired.second - it == 1) {           
      float whit_pos = findWireHitPosition();
      bool deadWG_left = isDeadWG( id, wire_in_cluster.at(0) -1 ); 
      bool deadWG_right = isDeadWG( id, wire_in_cluster.at(wire_in_cluster.size()-1) + 1); 
      short int aDeadWG = 0;
      if(!deadWG_left && !deadWG_right){
        aDeadWG = 0;
      }
      else if(deadWG_left && deadWG_right){
        aDeadWG = 255;
      }
      else{
        if(deadWG_left){
          aDeadWG = wire_in_cluster.at(0) -1;
        }
        else{
          aDeadWG = wire_in_cluster.at(wire_in_cluster.size()-1) + 1;
        }
      }
      std::vector <int> timeBinsOn=wire_cluster[n_wgroup/2].getTimeBinsOn();
      //CSCWireHit whit(id, whit_pos, wire_in_clusterAndBX, theTime, isDeadWGAround, timeBinsOn );
      CSCWireHit whit(id, whit_pos, wire_in_clusterAndBX, theTime, aDeadWG, timeBinsOn );
      hitsInLayer.push_back( whit );
      n_wgroup++;
    }
  }

  /*
      for(std::vector<CSCWireHit>::const_iterator itWHit=hitsInLayer.begin(); itWHit!=hitsInLayer.end(); ++itWHit){
         (*itWHit).print(); 
         }  
  */

  return hitsInLayer;
}


void CSCHitFromWireOnly::makeWireCluster(const CSCWireDigi & digi) {
  wire_cluster.clear();
  wire_in_cluster.clear();
  wire_in_clusterAndBX.clear(); 
  theLastChannel  = digi.getWireGroup();
  theTime         = digi.getTimeBin();
  wire_cluster.push_back( digi );
}


bool CSCHitFromWireOnly::addToCluster(const CSCWireDigi & digi) {

  
  int iwg = digi.getWireGroup();
  
  if ( iwg == theLastChannel ){
    return true;  // Same wire group but different tbin -> ignore
  }
  else{
    if ( (iwg == theLastChannel+1) && (abs(digi.getTimeBin()-theTime)<= deltaT) ) {
      theLastChannel = iwg;
      wire_cluster.push_back( digi );
      return true;
    }
  }
  
  return false;
}


/* findWireHitPosition
 *
 * This position is expressed in terms of wire #... is a float since it may be a fraction.
 */
float CSCHitFromWireOnly::findWireHitPosition() {
  
  // Again use center of mass to determine position of wire hit
  // To do so, need to know wire spacing and # of wires
  
  float y = 0.0;
  
  for ( unsigned i = 0; i < wire_cluster.size(); ++i ) {
    CSCWireDigi wdigi = wire_cluster[i];
    int wgroup = wdigi.getWireGroup();
    wire_in_cluster.push_back( wgroup );
    int wgroupAndBX = wdigi.getBXandWireGroup(); 
    //std::cout << " wgroupAndBX: " << std::hex << wgroupAndBX << std::dec << std::endl;
    wire_in_clusterAndBX.push_back( wgroupAndBX ); 
    y += float( wgroup );
  }       

  float wiregpos = y /wire_cluster.size() ;

  return wiregpos;

}

bool CSCHitFromWireOnly::isDeadWG(const CSCDetId& id, int WG){

  const std::bitset<112> & deadWG = recoConditions_->badWireWord( id );
  bool isDead = false;
  if(WG>-1 && WG<112){
    isDead = deadWG.test(WG);
  }
  return isDead;
}