#include <CSCHitFromWireOnly.h>

Public Types
typedef std::vector< int >	ChannelContainer

Public Member Functions
bool	addToCluster (const CSCWireDigi &digi)

	CSCHitFromWireOnly (const edm::ParameterSet &ps)

float	findWireHitPosition ()

void	makeWireCluster (const CSCWireDigi &digi)

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

void	setConditions (const CSCRecoConditions *reco)

	~CSCHitFromWireOnly ()

Public Attributes
CSCDetId	id_

const CSCLayer *	layer_

const CSCLayerGeometry *	layergeom_

Private Member Functions
bool	isDeadWG (const CSCDetId &id, int WG)

Private Attributes
int	deltaT
	To fill BX + wiregroup in CSCWireHit. More...

const CSCRecoConditions *	recoConditions_
	Hold pointer to current conditions data. More...

int	theLastChannel

int	theTime

bool	useReducedWireTime

std::vector< CSCWireDigi >	wire_cluster

std::vector< int >	wire_in_cluster

std::vector< int >	wire_in_clusterAndBX

std::vector< float >	wire_spacing

int	wireTimeWindow_high

int	wireTimeWindow_low

Detailed Description

Search for hits within the wire groups. For each of these hits, try forming clusters by looking at adjacent wiregroup. Form a wire Hit out of these clusters by finding the center-of-mass position of the hit in terms of the wire #. The DetId, wire hit position, and peaking time are stored in a CSCWireHit collection.

To keep wire hits only so they can be used in segment building. Only the DetId and wiregroup # are stored in a CSCWireHit collection

Author: Dominique Fortin - UCR; Stoyan Stoynev - Northwestern

Definition at line 36 of file CSCHitFromWireOnly.h.

Member Typedef Documentation

typedef std::vector<int> CSCHitFromWireOnly::ChannelContainer

Definition at line 38 of file CSCHitFromWireOnly.h.

Constructor & Destructor Documentation

CSCHitFromWireOnly::CSCHitFromWireOnly ( const edm::ParameterSet & ps )

explicit

Definition at line 20 of file CSCHitFromWireOnly.cc.

References deltaT, edm::ParameterSet::getParameter(), useReducedWireTime, wireTimeWindow_high, and wireTimeWindow_low.

                                                                 : recoConditions_(nullptr) {
   deltaT = ps.getParameter<int>("CSCWireClusterDeltaT");
   useReducedWireTime = ps.getParameter<bool>("CSCUseReducedWireTimeWindow");
   wireTimeWindow_low = ps.getParameter<int>("CSCWireTimeWindowLow");
   wireTimeWindow_high = ps.getParameter<int>("CSCWireTimeWindowHigh");
 
   //clusterSize            = ps.getParameter<int>("CSCWireClusterMaxSize");
 }

CSCHitFromWireOnly::~CSCHitFromWireOnly ( )

Definition at line 29 of file CSCHitFromWireOnly.cc.

29 {}

Member Function Documentation

bool CSCHitFromWireOnly::addToCluster ( const CSCWireDigi & digi )

Definition at line 139 of file CSCHitFromWireOnly.cc.

References funct::abs(), deltaT, CSCWireDigi::getTimeBin(), CSCWireDigi::getWireGroup(), theLastChannel, theTime, and wire_cluster.

Referenced by runWire().

                                                              {
   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;
 }

float CSCHitFromWireOnly::findWireHitPosition ( )

BX to WireHit

Definition at line 159 of file CSCHitFromWireOnly.cc.

References CSCWireDigi::getBXandWireGroup(), CSCWireDigi::getWireGroup(), mps_fire::i, wire_cluster, wire_in_cluster, wire_in_clusterAndBX, and y.

Referenced by runWire().

                                               {
   // 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
	)

private

Definition at line 180 of file CSCHitFromWireOnly.cc.

References CSCRecoConditions::badWireWord(), and recoConditions_.

Referenced by runWire().

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

void CSCHitFromWireOnly::makeWireCluster ( const CSCWireDigi & digi )

BX to wire

Definition at line 130 of file CSCHitFromWireOnly.cc.

References CSCWireDigi::getTimeBin(), CSCWireDigi::getWireGroup(), theLastChannel, theTime, wire_cluster, wire_in_cluster, and wire_in_clusterAndBX.

Referenced by runWire().

                                                                 {
   wire_cluster.clear();
   wire_in_cluster.clear();
   wire_in_clusterAndBX.clear();  
   theLastChannel = digi.getWireGroup();
   theTime = digi.getTimeBin();
   wire_cluster.push_back(digi);
 }

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

BX

Print statement (!!!to control WireHit content!!!) BX

Definition at line 31 of file CSCHitFromWireOnly.cc.

References addToCluster(), findWireHitPosition(), CSCLayer::geometry(), CSCWireDigi::getWireGroup(), gpuClustering::id, id_, isDeadWG(), phase1PixelTopology::layer, layer_, layergeom_, makeWireCluster(), theTime, useReducedWireTime, wire_cluster, wire_in_cluster, wire_in_clusterAndBX, wireTimeWindow_high, and wireTimeWindow_low.

Referenced by CSCRecHitDBuilder::build().

                                                                                               {
   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);
 
         if (!useReducedWireTime) {
           hitsInLayer.push_back(whit);
         } else if (theTime >= wireTimeWindow_low && theTime <= wireTimeWindow_high) {
           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);
 
       if (!useReducedWireTime) {
         hitsInLayer.push_back(whit);
       } else if (theTime >= wireTimeWindow_low && theTime <= wireTimeWindow_high) {
         hitsInLayer.push_back(whit);
       }
 
       n_wgroup++;
     }
   }
 
   /*
       for(std::vector<CSCWireHit>::const_iterator itWHit=hitsInLayer.begin(); itWHit!=hitsInLayer.end(); ++itWHit){
          (*itWHit).print(); 
          }  
   */
 
   return hitsInLayer;
 }