|
|
|
#include <CSCHitFromStripOnly.h>
Public Types | |
| typedef std::vector< CSCStripData > | PulseHeightMap |
Public Member Functions | |
| CSCHitFromStripOnly (const edm::ParameterSet &ps) | |
| std::vector< CSCStripHit > | runStrip (const CSCDetId &id, const CSCLayer *layer, const CSCStripDigiCollection::Range &rstripd) |
| void | setConditions (const CSCRecoConditions *reco) |
| ~CSCHitFromStripOnly () | |
Private Member Functions | |
| void | fillPulseHeights (const CSCStripDigiCollection::Range &rstripd) |
| Store SCA pulseheight information from strips in digis of one layer. | |
| float | findHitOnStripPosition (const std::vector< CSCStripHitData > &data, const int ¢erStrip) |
| Find position of hit in strip cluster in terms of strip #. | |
| void | findMaxima (const CSCDetId &id) |
| Find local maxima. | |
| bool | isDeadStrip (const CSCDetId &id, int centralStrip) |
| Is the strip 'bad'? | |
| bool | isNearDeadStrip (const CSCDetId &id, int centralStrip) |
| Is either neighbour 'bad'? | |
| bool | isPeakOK (int iStrip, float heightCluster) |
| float | makeCluster (int centerStrip) |
| Make clusters using local maxima. | |
| CSCStripHitData | makeStripData (int centerStrip, int offset) |
Private Attributes | |
| CSCPedestalChoice * | calcped_ |
| int | clusterSize |
| float | gainWeight [80] |
| CSCDetId | id_ |
| const CSCLayer * | layer_ |
| unsigned | nstrips_ |
| const CSCRecoConditions * | recoConditions_ |
| std::vector< float > | strips_adc |
| std::vector< float > | strips_adcRaw |
| std::vector< int > | theClosestMaximum |
| std::vector< int > | theConsecutiveStrips |
| std::vector< int > | theMaxima |
| PulseHeightMap | thePulseHeightMap |
| std::vector< int > | theStrips |
| float | theThresholdForAPeak |
| float | theThresholdForCluster |
| int | tmax_cluster |
| bool | useCalib |
Static Private Attributes | |
| static const int | theClusterSize = 3 |
below)
Search for strip with ADC output exceeding theThresholdForAPeak. For each of these strips, build a cluster of strip of size theClusterSize (typically 5 strips). Finally, make a Strip Hit out of these clusters by finding the center-of-mass position of the hit The DetId, strip hit position, and peaking time are stored in a CSCStripHit collection.
Be careful with the ME_1/a chambers: the 48 strips are ganged into 16 channels, Each channel contains signals from three strips, each separated by 16 strips from the next.
Definition at line 33 of file CSCHitFromStripOnly.h.
| typedef std::vector<CSCStripData> CSCHitFromStripOnly::PulseHeightMap |
Definition at line 38 of file CSCHitFromStripOnly.h.
| CSCHitFromStripOnly::CSCHitFromStripOnly | ( | const edm::ParameterSet & | ps | ) | [explicit] |
Definition at line 22 of file CSCHitFromStripOnly.cc.
References calcped_, edm::ParameterSet::getParameter(), LogTrace, theThresholdForAPeak, theThresholdForCluster, and useCalib.
: recoConditions_(0), calcped_(0) { useCalib = ps.getParameter<bool>("CSCUseCalibrations"); bool useStaticPedestals = ps.getParameter<bool>("CSCUseStaticPedestals"); int noOfTimeBinsForDynamicPed = ps.getParameter<int>("CSCNoOfTimeBinsForDynamicPedestal"); theThresholdForAPeak = ps.getParameter<double>("CSCStripPeakThreshold"); theThresholdForCluster = ps.getParameter<double>("CSCStripClusterChargeCut"); LogTrace("CSCRecHit") << "[CSCHitFromStripOnly] CSCUseStaticPedestals = " << useStaticPedestals; if ( !useStaticPedestals ) LogTrace("CSCRecHit") << "[CSCHitFromStripOnly] CSCNoOfTimeBinsForDynamicPedestal = " << noOfTimeBinsForDynamicPed; if ( useStaticPedestals ) { calcped_ = new CSCStaticPedestal(); } else { if ( noOfTimeBinsForDynamicPed == 1 ) { calcped_ = new CSCDynamicPedestal1(); } else { calcped_ = new CSCDynamicPedestal2(); // NORMAL DEFAULT! } } }
| CSCHitFromStripOnly::~CSCHitFromStripOnly | ( | ) |
| void CSCHitFromStripOnly::fillPulseHeights | ( | const CSCStripDigiCollection::Range & | rstripd | ) | [private] |
Store SCA pulseheight information from strips in digis of one layer.
Definition at line 334 of file CSCHitFromStripOnly.cc.
References calcped_, filterCSVwithJSON::copy, gainWeight, id_, j, CSCPedestalChoice::pedestal(), recoConditions_, CSCDetId::ring(), thePulseHeightMap, tmax, and useCalib.
Referenced by runStrip().
{
// Loop over strip digis in one CSCLayer and fill PulseHeightMap with pedestal-subtracted
// SCA pulse heights.
thePulseHeightMap.clear();
thePulseHeightMap.resize(100); //@@ WHY NOT JUST 80?
// for storing sca pulseheights once they may no longer be integer (e.g. after ped subtraction)
std::vector<float> sca;
sca.reserve(8);
for ( CSCStripDigiCollection::const_iterator it = rstripd.first; it != rstripd.second; ++it ) {
int thisChannel = (*it).getStrip();
std::vector<int> scaRaw = (*it).getADCCounts();
sca.clear();
// Fill sca from scaRaw, implicitly converting to float
std::copy( scaRaw.begin(), scaRaw.end(), std::back_inserter( sca ));
//@@ Find bin with largest pulseheight (_before_ ped subtraction - shouldn't matter, right?)
int tmax = std::max_element( sca.begin(), sca.end() ) - sca.begin(); // counts from 0
// get pedestal - calculated as appropriate - for this sca pulse
float ped = calcped_->pedestal(sca, recoConditions_, id_, thisChannel );
// subtract the pedestal (from BOTH sets of sca pulseheights)
std::for_each( sca.begin(), sca.end(), CSCSubtractPedestal( ped ) );
std::for_each( scaRaw.begin(), scaRaw.end(), CSCSubtractPedestal( ped ) );
//@@ Max in first 3 or last time bins is unacceptable, if so set to zero (why?)
float phmax = 0.;
if ( tmax > 2 && tmax < 7 ) {
phmax = sca[tmax];
}
// Fill the map, possibly apply gains from cond data, and unfold ME1A channels
// (To apply gains use CSCStripData::op*= which scales only the non-raw sca ph's;
// but note that both sca & scaRaw are pedestal-subtracted.)
if ( id_.ring() != 4 ) { // non-ME1a
thePulseHeightMap[thisChannel-1] = CSCStripData( thisChannel, phmax, tmax, scaRaw, sca );
if ( useCalib ) thePulseHeightMap[thisChannel-1] *= gainWeight[thisChannel-1];
}
else { // ME1a, so unfold its 16 channels to its 48 strips
for ( int j = 0; j < 3; ++j ) {
thePulseHeightMap[thisChannel-1+16*j] = CSCStripData( thisChannel+16*j, phmax, tmax, scaRaw, sca );
if ( useCalib ) thePulseHeightMap[thisChannel-1+16*j] *= gainWeight[thisChannel-1];
}
}
}
}
| float CSCHitFromStripOnly::findHitOnStripPosition | ( | const std::vector< CSCStripHitData > & | data, |
| const int & | centerStrip | ||
| ) | [private] |
Find position of hit in strip cluster in terms of strip #.
Definition at line 479 of file CSCHitFromStripOnly.cc.
References filterCSVwithJSON::copy, i, LogTrace, strip(), strips_adc, and strips_adcRaw.
Referenced by makeCluster().
{
float strippos = -1.;
if ( data.size() < 1 ) return strippos;
// biggestStrip is strip with largest pulse height
// Use pointer subtraction
int biggestStrip = max_element(data.begin(), data.end()) - data.begin();
strippos = data[biggestStrip].strip() * 1.;
// If more than one strip: use centroid to find center of cluster
// but only use time bin == tmax (otherwise, bias centroid).
float sum = 0.;
float sum_w= 0.;
float stripLeft = 0.;
float stripRight = 0.;
std::vector<float> w(4);
std::vector<float> wRaw(4);
for ( size_t i = 0; i != data.size(); ++i ) {
w = data[i].ph();
wRaw = data[i].phRaw();
// (Require ADC to be > 0.)
// No later studies suggest that this only do harm
/*
for ( size_t j = 0; j != w.size(); ++j ) {
if ( w[j] < 0. ) w[j] = 0.001;
}
*/
if (i == data.size()/2 -1) stripLeft = w[1];
if (i == data.size()/2 +1) stripRight = w[1];
// Fill the data members
std::copy( w.begin(), w.end(), std::back_inserter(strips_adc));
std::copy( wRaw.begin(), wRaw.end(), std::back_inserter(strips_adcRaw));
if ( data[i].strip() < 1 ){
LogTrace("CSCRecHit") << "problem in indexing of strip, strip id is: " << data[i].strip();
}
sum_w += w[1];
sum += w[1] * data[i].strip();
}
if ( sum_w > 0.) strippos = sum / sum_w;
return strippos;
}
| void CSCHitFromStripOnly::findMaxima | ( | const CSCDetId & | id | ) | [private] |
Find local maxima.
Definition at line 393 of file CSCHitFromStripOnly.cc.
References i, isDeadStrip(), isPeakOK(), j, gen::k, prof2calltree::l, theClosestMaximum, theConsecutiveStrips, theMaxima, and thePulseHeightMap.
Referenced by runStrip().
{
theMaxima.clear();
theConsecutiveStrips.clear();
theClosestMaximum.clear();
for ( size_t i=0; i!=thePulseHeightMap.size(); ++i ) {
// sum 3 strips so that hits between strips are not suppressed
float heightCluster = 0.;
bool maximumFound = false;
// Left edge of chamber
if(!isDeadStrip(id, i+1)){ // is it i or i+1
if ( i == 0 ) {
heightCluster = thePulseHeightMap[i].phmax()+thePulseHeightMap[i+1].phmax();
// Have found a strip Hit if...
if(thePulseHeightMap[i].phmax() >= thePulseHeightMap[i+1].phmax() &&
isPeakOK(i,heightCluster)){
theMaxima.push_back(i);
maximumFound = true;
}
// Right edge of chamber
} else if ( i == thePulseHeightMap.size()-1) {
heightCluster = thePulseHeightMap[i-1].phmax()+thePulseHeightMap[i].phmax();
// Have found a strip Hit if...
if(thePulseHeightMap[i].phmax() > thePulseHeightMap[i-1].phmax() &&
isPeakOK(i,heightCluster)){
theMaxima.push_back(i);
maximumFound = true;
}
// Any other strips
} else {
heightCluster = thePulseHeightMap[i-1].phmax()+thePulseHeightMap[i].phmax()+thePulseHeightMap[i+1].phmax();
// Have found a strip Hit if...
if(thePulseHeightMap[i].phmax() > thePulseHeightMap[i-1].phmax() &&
thePulseHeightMap[i].phmax() >= thePulseHeightMap[i+1].phmax() &&
isPeakOK(i,heightCluster)){
theMaxima.push_back(i);
maximumFound = true;
}
}
}
//---- Consecutive strips with charge (real cluster); if too wide - measurement is not accurate
if(maximumFound){
int numberOfConsecutiveStrips = 1;
float testThreshold = 10.;//---- ADC counts;
//---- this is not XTalk corrected so it is correct in first approximation only
int j = 0;
for(int l = 0; l<8; ++l){
if(j<0) edm::LogWarning("FailedStripCountingWrongConsecutiveStripNumber") << "This should never occur!!! Contact CSC expert!";
++j;
bool signalPresent = false;
for(int k = 0; k<2; ++k){
j*= -1;//---- check from left and right
int anotherConsecutiveStrip = i+j;
if(anotherConsecutiveStrip>=0 && anotherConsecutiveStrip<int( thePulseHeightMap.size() )){
if(thePulseHeightMap[anotherConsecutiveStrip].phmax()>testThreshold){
++numberOfConsecutiveStrips;
signalPresent = true;
}
}
}
if(!signalPresent){
break;
}
}
theConsecutiveStrips.push_back(numberOfConsecutiveStrips);
}
}
}
| bool CSCHitFromStripOnly::isDeadStrip | ( | const CSCDetId & | id, |
| int | centralStrip | ||
| ) | [private] |
Is the strip 'bad'?
Definition at line 542 of file CSCHitFromStripOnly.cc.
References CSCRecoConditions::badStrip(), and recoConditions_.
Referenced by findMaxima(), and runStrip().
{
return recoConditions_->badStrip( id, centralStrip );
}
| bool CSCHitFromStripOnly::isNearDeadStrip | ( | const CSCDetId & | id, |
| int | centralStrip | ||
| ) | [private] |
Is either neighbour 'bad'?
Definition at line 534 of file CSCHitFromStripOnly.cc.
References CSCRecoConditions::nearBadStrip(), and recoConditions_.
{
//@@ Tim says: not sure I understand this properly... but just moved code to CSCRecoConditions
// where it can handle the conversion from strip to channel etc.
return recoConditions_->nearBadStrip( id, centralStrip );
}
| bool CSCHitFromStripOnly::isPeakOK | ( | int | iStrip, |
| float | heightCluster | ||
| ) | [private] |
Definition at line 465 of file CSCHitFromStripOnly.cc.
References i, thePulseHeightMap, theThresholdForAPeak, and theThresholdForCluster.
Referenced by findMaxima().
{
int i = iStrip;
bool peakOK = ( thePulseHeightMap[i].phmax()>theThresholdForAPeak &&
heightCluster > theThresholdForCluster &&
// ... and proper peak time; note that the values below are used elsewhere in this file;
// they should become parameters or at least constants defined in appropriate place
thePulseHeightMap[i].tmax() > 2 && thePulseHeightMap[i].tmax() < 7);
return peakOK;
}
| float CSCHitFromStripOnly::makeCluster | ( | int | centerStrip | ) | [private] |
Make clusters using local maxima.
Definition at line 199 of file CSCHitFromStripOnly.cc.
References clusterSize, runTheMatrix::data, findHitOnStripPosition(), i, makeStripData(), nstrips_, theClusterSize, and theStrips.
Referenced by runStrip().
{
float strippos = -1.;
clusterSize = theClusterSize;
std::vector<CSCStripHitData> stripDataV;
// We only want to use strip position in terms of strip # for the strip hit. //@@ What other choice is there?
// If the cluster size is such that you go beyond the edge of detector, shrink cluster appropriately
for ( int i = 1; i < theClusterSize/2 + 1; ++i ) {
if ( centerStrip - i < 1 || centerStrip + i > int(nstrips_) ) {
// Shrink cluster size, but keep it an odd number of strips.
clusterSize = 2*i - 1;
}
}
for ( int i = -clusterSize/2; i <= clusterSize/2; ++i ) {
CSCStripHitData data = makeStripData(centerStrip, i);
stripDataV.push_back( data );
theStrips.push_back( centerStrip + i );
}
strippos = findHitOnStripPosition( stripDataV, centerStrip );
return strippos;
}
| CSCStripHitData CSCHitFromStripOnly::makeStripData | ( | int | centerStrip, |
| int | offset | ||
| ) | [private] |
makeStripData
Definition at line 230 of file CSCHitFromStripOnly.cc.
References ecalMGPA::adc(), begin, clusterSize, filterCSVwithJSON::copy, spr::find(), i, gen::k, LogTrace, min, evf::evtn::offset(), theMaxima, thePulseHeightMap, tmax, and tmax_cluster.
Referenced by makeCluster().
{
CSCStripHitData prelimData;
int thisStrip = centerStrip+offset;
int tmax = thePulseHeightMap[centerStrip-1].tmax();
tmax_cluster = tmax;
std::vector<float> adc(4);
std::vector<float> adcRaw(4);
// Fill adc & adcRaw
int istart = tmax-1;
int istop = std::min( tmax+2, 7 ) ; // there are only time bins 0-7
adc[3] = 0.1; // in case it isn't filled
if ( tmax > 2 && tmax < 7 ) { // for time bins 3-6
int ibin = thisStrip-1;
std::copy( thePulseHeightMap[ibin].ph().begin()+istart,
thePulseHeightMap[ibin].ph().begin()+istop+1, adc.begin() );
std::copy( thePulseHeightMap[ibin].phRaw().begin()+istart,
thePulseHeightMap[ibin].phRaw().begin()+istop+1, adcRaw.begin() );
}
else {
adc[0] = 0.1;
adc[1] = 0.1;
adc[2] = 0.1;
adc[3] = 0.1;
adcRaw = adc;
LogTrace("CSCRecHit") << "[CSCHitFromStripOnly::makeStripData] Tmax out of range: contact CSC expert!";
}
if ( offset == 0 ) {
prelimData = CSCStripHitData(thisStrip, tmax_cluster, adcRaw, adc);
} else {
int sign = offset>0 ? 1 : -1;
// If there's another maximum that would like to use part of this cluster,
// it gets shared in proportion to the height of the maxima
for ( int i = 1; i <= clusterSize/2; ++i ) {
// Find the direction of the offset
int testStrip = thisStrip + sign*i;
std::vector<int>::iterator otherMax = find(theMaxima.begin(), theMaxima.end(), testStrip-1);
// No other maxima found, so just store
if ( otherMax == theMaxima.end() ) {
prelimData = CSCStripHitData(thisStrip, tmax_cluster, adcRaw, adc); }
else {
// Another maximum found - share
std::vector<float> adc1(4);
std::vector<float> adcRaw1(4);
std::vector<float> adc2(4);
std::vector<float> adcRaw2(4);
// In case we only copy (below) into 3 of the 4 bins i.e. when istart=5, istop=7
adc1[3] = 0.1;
adc2[3] = 0.1;
adcRaw1[3] = 0.1;
adcRaw2[3] = 0.1;
// Fill adcN with content of time bins tmax-1 to tmax+2 (if it exists!)
if ( tmax > 2 && tmax < 7 ) { // for time bin tmax from 3-6
int ibin = testStrip-1;
int jbin = centerStrip-1;
std::copy(thePulseHeightMap[ibin].ph().begin()+istart,
thePulseHeightMap[ibin].ph().begin()+istop+1, adc1.begin());
std::copy(thePulseHeightMap[ibin].phRaw().begin()+istart,
thePulseHeightMap[ibin].phRaw().begin()+istop+1, adcRaw1.begin());
std::copy(thePulseHeightMap[jbin].ph().begin()+istart,
thePulseHeightMap[jbin].ph().begin()+istop+1, adc2.begin());
std::copy(thePulseHeightMap[jbin].phRaw().begin()+istart,
thePulseHeightMap[jbin].phRaw().begin()+istop+1, adcRaw2.begin());
}
else {
adc1.assign(4, 0.1);
adcRaw1 = adc1;
adc2.assign(4, 0.1);
adcRaw2 = adc2;
}
// Scale shared strip B ('adc') by ratio of peak of ADC counts from central strip A ('adc2')
// to sum of A and neighbouring maxima C ('adc1')
for (size_t k = 0; k < 4; ++k){
if(adc1[k]>0 && adc2[k]>0) adc[k] = adc[k] * adc2[k] / ( adc1[k]+adc2[k] );
if(adcRaw1[k]>0 && adcRaw2[k]>0) adcRaw[k] = adcRaw[k] * adcRaw2[k] / ( adcRaw1[k]+adcRaw2[k] );
}
prelimData = CSCStripHitData(thisStrip, tmax_cluster, adcRaw, adc);
}
}
}
return prelimData;
}
| std::vector< CSCStripHit > CSCHitFromStripOnly::runStrip | ( | const CSCDetId & | id, |
| const CSCLayer * | layer, | ||
| const CSCStripDigiCollection::Range & | rstripd | ||
| ) |
fact (20.10.09);
L1A (Begin looping) Attempt to redefine theStrips, to encode L1A phase bits
L1A (end Looping)
L1A
Print statement (!!!to control StripHit content!!!) LA1
Definition at line 61 of file CSCHitFromStripOnly.cc.
References CSCLayer::chamber(), clusterSize, fillPulseHeights(), findMaxima(), gainWeight, ExpressReco_HICollisions_FallBack::id, id_, isDeadStrip(), layer_, makeCluster(), CSCChamberSpecs::nStrips(), nstrips_, recoConditions_, CSCDetId::ring(), CSCChamber::specs(), strips_adc, strips_adcRaw, CSCRecoConditions::stripWeights(), theClosestMaximum, theClusterSize, theConsecutiveStrips, theMaxima, theStrips, tmax_cluster, and useCalib.
Referenced by CSCRecHitDBuilder::build().
{
std::vector<CSCStripHit> hitsInLayer;
// cache layer info for ease of access
id_ = id;
layer_ = layer;
nstrips_ = layer->chamber()->specs()->nStrips();
tmax_cluster = 5;
// Get gain correction weights for all strips in layer, and cache in gainWeight.
// They're used in fillPulseHeights below.
if ( useCalib ) {
recoConditions_->stripWeights( id, gainWeight );
}
// Store pulseheights from SCA and find maxima (potential hits)
fillPulseHeights( rstripd );
findMaxima(id);
// Make a Strip Hit out of each strip local maximum
for ( size_t imax = 0; imax != theMaxima.size(); ++imax ) {
// Initialize parameters entering the CSCStripHit
clusterSize = theClusterSize;
theStrips.clear();
strips_adc.clear();
strips_adcRaw.clear();
// makeCluster calls findHitOnStripPosition to determine the centroid position
// Remember, the array starts at 0, but the stripId starts at 1...
float strippos = makeCluster( theMaxima[imax]+1 );
//if ( strippos < 0 || tmax_cluster < 3 ){
// the strippos (as calculated here) is not used later on in
// with the negative charges allowed it can become negative
if ( tmax_cluster < 3 ){
theClosestMaximum.push_back(99); // to keep proper vector size
continue;
}
//---- If two maxima are too close the error assigned will be width/sqrt(12) - see CSCXonStrip_MatchGatti.cc
int maximum_to_left = 99; //---- If there is one maximum - the distance is set to 99 (strips)
int maximum_to_right = 99;
if(imax<theMaxima.size()-1){
maximum_to_right = theMaxima.at(imax+1) - theMaxima.at(imax);
}
if(imax>0 ){
maximum_to_left = theMaxima.at(imax-1) - theMaxima.at(imax);
}
if(fabs(maximum_to_right) < fabs(maximum_to_left)){
theClosestMaximum.push_back(maximum_to_right);
}
else{
theClosestMaximum.push_back(maximum_to_left);
}
//---- Check if a neighbouring strip is a dead strip
//bool deadStrip = isNearDeadStrip(id, theMaxima.at(imax));
bool deadStripL = isDeadStrip(id, theMaxima.at(imax)-1);
bool deadStripR = isDeadStrip(id, theMaxima.at(imax)+1);
short int aDeadStrip = 0;
if(!deadStripL && !deadStripR){
aDeadStrip = 0;
}
else if(deadStripL && deadStripR){
aDeadStrip = 255;
}
else{
if(deadStripL){
aDeadStrip = theMaxima.at(imax)-1;
}
else{
aDeadStrip = theMaxima.at(imax)+1;
}
}
//std::cout << " Size of theStrips from SCSHitFromStripOnly: " << theStrips.size() << std::endl;
std::vector<int> theL1AStrips;
for(int ila=0; ila<(int)theStrips.size(); ila++){
bool stripMatchCounter=false;
for ( CSCStripDigiCollection::const_iterator itl1 = rstripd.first; itl1 != rstripd.second; ++itl1 ) {
int stripNproto = (*itl1).getStrip();
if(id_.ring() != 4){
if(theStrips[ila]==stripNproto){
stripMatchCounter=true;
std::vector<int> L1AP=(*itl1).getL1APhase();
int L1AbitOnPlace=0;
for(int iBit=0; iBit<(int)L1AP.size(); iBit++){
L1AbitOnPlace=L1AbitOnPlace|(L1AP[iBit] << (15-iBit));
}
theL1AStrips.push_back(theStrips[ila] | L1AbitOnPlace);
}
}
else{
for(int tripl=0; tripl<3; ++tripl){
if(theStrips[ila]==(stripNproto+tripl*16)){
stripMatchCounter=true;
std::vector<int> L1AP=(*itl1).getL1APhase();
int L1AbitOnPlace=0;
for(int iBit=0; iBit<(int)L1AP.size(); iBit++){
L1AbitOnPlace=L1AbitOnPlace|(L1AP[iBit] << (15-iBit));
}
theL1AStrips.push_back(theStrips[ila] | L1AbitOnPlace);
}
}
}
}
if(!stripMatchCounter){
theL1AStrips.push_back(theStrips[ila]);
}
}
CSCStripHit striphit( id, strippos, tmax_cluster, theL1AStrips, strips_adc, strips_adcRaw,
theConsecutiveStrips.at(imax), theClosestMaximum.at(imax), aDeadStrip);
hitsInLayer.push_back( striphit );
}
/*
for(std::vector<CSCStripHit>::const_iterator itSHit=hitsInLayer.begin(); itSHit!=hitsInLayer.end(); ++itSHit){
(*itSHit).print();
}
*/
return hitsInLayer;
}
| void CSCHitFromStripOnly::setConditions | ( | const CSCRecoConditions * | reco | ) | [inline] |
Definition at line 46 of file CSCHitFromStripOnly.h.
References dt_offlineAnalysis_common_cff::reco, and recoConditions_.
Referenced by CSCRecHitDBuilder::setConditions().
{
recoConditions_ = reco;
}
CSCPedestalChoice* CSCHitFromStripOnly::calcped_ [private] |
Definition at line 89 of file CSCHitFromStripOnly.h.
Referenced by CSCHitFromStripOnly(), fillPulseHeights(), and ~CSCHitFromStripOnly().
int CSCHitFromStripOnly::clusterSize [private] |
Definition at line 107 of file CSCHitFromStripOnly.h.
Referenced by makeCluster(), makeStripData(), and runStrip().
float CSCHitFromStripOnly::gainWeight[80] [private] |
Definition at line 86 of file CSCHitFromStripOnly.h.
Referenced by fillPulseHeights(), and runStrip().
CSCDetId CSCHitFromStripOnly::id_ [private] |
Definition at line 80 of file CSCHitFromStripOnly.h.
Referenced by fillPulseHeights(), and runStrip().
const CSCLayer* CSCHitFromStripOnly::layer_ [private] |
Definition at line 81 of file CSCHitFromStripOnly.h.
Referenced by runStrip().
unsigned CSCHitFromStripOnly::nstrips_ [private] |
Definition at line 84 of file CSCHitFromStripOnly.h.
Referenced by makeCluster(), and runStrip().
const CSCRecoConditions* CSCHitFromStripOnly::recoConditions_ [private] |
Definition at line 82 of file CSCHitFromStripOnly.h.
Referenced by fillPulseHeights(), isDeadStrip(), isNearDeadStrip(), runStrip(), and setConditions().
std::vector<float> CSCHitFromStripOnly::strips_adc [private] |
Definition at line 108 of file CSCHitFromStripOnly.h.
Referenced by findHitOnStripPosition(), and runStrip().
std::vector<float> CSCHitFromStripOnly::strips_adcRaw [private] |
Definition at line 109 of file CSCHitFromStripOnly.h.
Referenced by findHitOnStripPosition(), and runStrip().
std::vector<int> CSCHitFromStripOnly::theClosestMaximum [private] |
Definition at line 103 of file CSCHitFromStripOnly.h.
Referenced by findMaxima(), and runStrip().
const int CSCHitFromStripOnly::theClusterSize = 3 [static, private] |
Definition at line 93 of file CSCHitFromStripOnly.h.
Referenced by makeCluster(), and runStrip().
std::vector<int> CSCHitFromStripOnly::theConsecutiveStrips [private] |
Definition at line 102 of file CSCHitFromStripOnly.h.
Referenced by findMaxima(), and runStrip().
std::vector<int> CSCHitFromStripOnly::theMaxima [private] |
Definition at line 101 of file CSCHitFromStripOnly.h.
Referenced by findMaxima(), makeStripData(), and runStrip().
Definition at line 99 of file CSCHitFromStripOnly.h.
Referenced by fillPulseHeights(), findMaxima(), isPeakOK(), and makeStripData().
std::vector<int> CSCHitFromStripOnly::theStrips [private] |
Definition at line 110 of file CSCHitFromStripOnly.h.
Referenced by makeCluster(), and runStrip().
float CSCHitFromStripOnly::theThresholdForAPeak [private] |
Definition at line 94 of file CSCHitFromStripOnly.h.
Referenced by CSCHitFromStripOnly(), and isPeakOK().
float CSCHitFromStripOnly::theThresholdForCluster [private] |
Definition at line 95 of file CSCHitFromStripOnly.h.
Referenced by CSCHitFromStripOnly(), and isPeakOK().
int CSCHitFromStripOnly::tmax_cluster [private] |
Definition at line 106 of file CSCHitFromStripOnly.h.
Referenced by makeStripData(), and runStrip().
bool CSCHitFromStripOnly::useCalib [private] |
Definition at line 92 of file CSCHitFromStripOnly.h.
Referenced by CSCHitFromStripOnly(), fillPulseHeights(), and runStrip().
1.7.3