CMSSW Reference Manual

FP420ClusterMain::FP420ClusterMain	(	const edm::ParameterSet &	conf,
		int	dn,
		int	sn,
		int	pn
	)

Definition at line 23 of file FP420ClusterMain.cc.

References BadElectrodeProbability_, ChannelThreshold, clusterMode_, ClusterThreshold, conf_, GenMuonPlsPt100GeV_cfg::cout, dn0, ElectronPerADC_, ENC_, lat::endl(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), ldriftX, ldriftY, MaxVoidsInCluster, moduleThicknessX, moduleThicknessY, numStripsX, numStripsXW, numStripsY, numStripsYW, pitchX, pitchY, pn0, SeedThreshold, sn0, Thick300, threeThreshold_, UseNoiseBadElectrodeFlagFromDB_, validClusterizer_, verbosity, and xytype.

00023                                                                                      :conf_(conf),dn0(dn),sn0(sn),pn0(pn)  { 
00024   
00025   verbosity         = conf_.getUntrackedParameter<int>("VerbosityLevel");
00026   ElectronPerADC_   = conf_.getParameter<double>("ElectronFP420PerAdc");
00027   clusterMode_      = conf_.getParameter<std::string>("ClusterModeFP420");
00028   ChannelThreshold  = conf_.getParameter<double>("ChannelFP420Threshold");//6
00029   SeedThreshold     = conf_.getParameter<double>("SeedFP420Threshold");//7
00030   ClusterThreshold  = conf_.getParameter<double>("ClusterFP420Threshold");//7
00031   MaxVoidsInCluster = conf_.getParameter<int>("MaxVoidsFP420InCluster");//1
00032   
00033   if (verbosity > 0) {
00034     std::cout << "FP420ClusterMain constructor: ElectronPerADC = " << ElectronPerADC_ << std::endl;
00035     std::cout << " clusterMode = " << clusterMode_ << std::endl;
00036     std::cout << " ChannelThreshold = " << ChannelThreshold << std::endl;
00037     std::cout << " SeedThreshold = " << SeedThreshold << std::endl;
00038     std::cout << " ClusterThreshold = " << ClusterThreshold << std::endl;
00039     std::cout << " MaxVoidsInCluster = " << MaxVoidsInCluster << std::endl;
00040   }
00041   xytype=2;// only X types of planes
00042   ENC_ = 960.;    // 
00043   Thick300 = 0.300;
00044   BadElectrodeProbability_ = 0.002;
00045   //UseNoiseBadElectrodeFlagFromDB_ = true;
00046   UseNoiseBadElectrodeFlagFromDB_ = false;
00047   //
00048   // pitches and ldriftes:
00049   //
00050   ldriftX = 0.050; 
00051   ldriftY = 0.050;// was 0.040
00052   pitchY= 0.050;// was 0.040
00053   pitchX= 0.050;
00054   moduleThicknessY = 0.250; // mm
00055   moduleThicknessX = 0.250; // mm
00056   numStripsY = 201;        // Y plate number of strips:200*0.050=10mm (xytype=1)
00057   numStripsX = 401;        // X plate number of strips:400*0.050=20mm (xytype=2)
00058   numStripsYW = 51;        // Y plate number of W strips:50 *0.400=20mm (xytype=1) - W have ortogonal projection
00059   numStripsXW = 26;        // X plate number of W strips:25 *0.400=10mm (xytype=2) - W have ortogonal projection
00060   
00061   //  sn0 = 4;
00062   //  pn0 = 9;
00063   if (verbosity > 1) {
00064     std::cout << "FP420ClusterMain constructor: sn0 = " << sn0 << " pn0=" << pn0 << " dn0=" << dn0 << std::endl;
00065     std::cout << "FP420ClusterMain constructor: ENC = " << ENC_ << std::endl;
00066     std::cout << " Thick300 = " << Thick300 << std::endl;
00067     std::cout << " BadElectrodeProbability = " << BadElectrodeProbability_ << std::endl;
00068     std::cout << " ldriftX = " << ldriftX << " ldriftY = " << ldriftY << std::endl;
00069     std::cout << " pitchY = " << pitchY << " pitchX = " << pitchX << std::endl;
00070     std::cout << " numStripsY = " << numStripsY << " numStripsX = " << numStripsX << std::endl;
00071     std::cout << " moduleThicknessY = " << moduleThicknessY << " moduleThicknessX = " << moduleThicknessX << std::endl;
00072   }
00073   
00074   if (UseNoiseBadElectrodeFlagFromDB_==false){    
00075     if (verbosity > 0) {
00076       std::cout << "using a SingleNoiseValue and good electrode flags" << std::endl;
00077     }
00078   } else {
00079     if (verbosity > 0) {
00080       std::cout << "using Noise and BadElectrode flags accessed from DB" << std::endl;
00081     }
00082   }
00083   
00084   if ( clusterMode_ == "ClusterProducerFP420" ) {
00085     
00086     
00087     //    ChannelThreshold    = 6.0;// was 2.6.0 7 18
00088     //   SeedThreshold       = 7.0;//was 3.7.0  8 20
00089     // ClusterThreshold    = 7.0;// was 2. 7.0 8 20
00090     // MaxVoidsInCluster   = 1; 
00091     threeThreshold_ = new ClusterProducerFP420(ChannelThreshold,
00092                                                SeedThreshold,
00093                                                ClusterThreshold,
00094                                                MaxVoidsInCluster);
00095     validClusterizer_ = true;
00096   } else {
00097     std::cout << "ERROR:FP420ClusterMain: No valid clusterizer selected" << std::endl;
00098     validClusterizer_ = false;
00099   }
00100 }

FP420ClusterMain::~FP420ClusterMain ( )

Definition at line 102 of file FP420ClusterMain.cc.

References threeThreshold_.

00102                                     {
00103   if ( threeThreshold_ != 0 ) {
00104     delete threeThreshold_;
00105   }
00106 }

void FP420ClusterMain::run	(	edm::Handle< DigiCollectionFP420 > &	input,
		std::auto_ptr< ClusterCollectionFP420 > &	soutput,
		std::vector< ClusterNoiseFP420 > &	noise
	)

Runs the algorithm.

Definition at line 111 of file FP420ClusterMain.cc.

References ClusterFP420::amplitudes(), BadElectrodeProbability_, ClusterFP420::barycenter(), ClusterFP420::barycenterW(), ClusterProducerFP420::clusterizeDetUnitPixels(), clusterMode_, GenMuonPlsPt100GeV_cfg::cout, dn0, ElectronPerADC_, ENC_, lat::endl(), first, ClusterFP420::firstStrip(), i, ldrift, ldriftX, ldriftY, moduleThickness, moduleThicknessX, moduleThicknessY, numStrips, numStripsX, numStripsXW, numStripsY, numStripsYW, pitch, pitchX, pitchY, pn0, ClusterNoiseFP420::ElectrodData::setData(), sn0, Thick300, threeThreshold_, UseNoiseBadElectrodeFlagFromDB_, validClusterizer_, verbosity, and xytype.

Referenced by cms::ClusterizerFP420::produce().

00114 {
00115   // unpack from iu:
00116   //  int  sScale = 20, zScale=2;
00117   //  int  sector = (iu-1)/sScale + 1 ;
00118   //  int  zmodule = (iu - (sector - 1)*sScale - 1) /zScale + 1 ;
00119   //  int  zside = iu - (sector - 1)*sScale - (zmodule - 1)*zScale ;
00120   
00121     if (verbosity > 0) {
00122       std::cout << "FP420ClusterMain: OK1" << std::endl;
00123     }
00124   if ( validClusterizer_ ) {
00125     
00126     int number_detunits          = 0;
00127     int number_localelectroderechits = 0;
00128     
00129     // get vector of detunit ids
00130     //    const std::vector<unsigned int> detIDs = input->detIDs();
00131     
00132     // to be used in put (besause of 0 in cluster collection for: 1) 1st cluster and 2) case of no cluster)
00133     // ignore 0, but to save info for 1st cluster record it second time on place 1   .
00134     
00135     bool first = true;
00136     // loop over detunits
00137     for (int det=1; det<dn0; det++) {
00138       for (int sector=1; sector<sn0; sector++) {
00139         for (int zmodule=1; zmodule<pn0; zmodule++) {
00140           for (int zside=1; zside<3; zside++) {
00141             int sScale = 2*(pn0-1), dScale = 2*(pn0-1)*(sn0-1);
00142             //  int det= 1;
00143             //      int index = CaloNumberingPacker::packCastorIndex(det,zside, sector, zmodule);
00144             //      int index = FP420NumberingScheme::packFP420Index(det, zside, sector, zmodule);
00145             // intindex is a continues numbering of FP420
00146             int zScale=2;  unsigned int detID = dScale*(det - 1)+sScale*(sector - 1)+zScale*(zmodule - 1)+zside;
00147             // int zScale=10;   unsigned int intindex = sScale*(sector - 1)+zScale*(zside - 1)+zmodule;
00148             if (verbosity > 0) {
00149               std::cout << " FP420ClusterMain:1 run loop   index no  iu = " << detID  << std::endl;
00150             }     
00151             // Y:
00152             if (xytype ==1) {
00153               numStrips = numStripsY*numStripsYW;  
00154               moduleThickness = moduleThicknessY; 
00155               pitch= pitchY;
00156               ldrift = ldriftX;
00157             }
00158             // X:
00159             if (xytype ==2) {
00160               numStrips = numStripsX*numStripsXW;  
00161               moduleThickness = moduleThicknessX; 
00162               pitch= pitchX;
00163               ldrift = ldriftY;
00164             }
00165             
00166             
00167             //    for ( std::vector<unsigned int>::const_iterator detunit_iterator = detIDs.begin(); detunit_iterator != detIDs.end(); ++detunit_iterator ) {
00168             //      unsigned int detID = *detunit_iterator;
00169             ++number_detunits;
00170             
00171             //   .
00172             //   GET DIGI collection  !!!!
00173             //   .
00174             //    const DigiCollectionFP420::Range digiRange = input->get(detID);
00175             DigiCollectionFP420::Range digiRange;
00176             std::vector<HDigiFP420> dcollector;
00177             // if (dcollector.size()>0){
00178             if (verbosity > 0) {
00179               std::cout << " FP420ClusterMain:2 number_detunits = " << number_detunits  << std::endl;
00180             }     
00181             digiRange = input->get(detID);
00182             //digiRange = input.get(detID);
00183             // }
00184             
00185             if (verbosity > 0) {
00186               std::cout << " FP420ClusterMain: input->get DONE " << std::endl;
00187             }     
00188             
00189             DigiCollectionFP420::ContainerIterator sort_begin = digiRange.first;
00190             DigiCollectionFP420::ContainerIterator sort_end = digiRange.second;
00191             for ( ;sort_begin != sort_end; ++sort_begin ) {
00192               dcollector.push_back(*sort_begin);
00193             } // for
00194             if (dcollector.size()>0) {
00195               
00196               DigiCollectionFP420::ContainerIterator digiRangeIteratorBegin = digiRange.first;
00197               DigiCollectionFP420::ContainerIterator digiRangeIteratorEnd   = digiRange.second;
00198               if (verbosity > 0) {
00199                 std::cout << " FP420ClusterMain: channel Begin = " << (digiRangeIteratorBegin)->channel()  << std::endl;
00200                 std::cout << " FP420ClusterMain: channel end = " << (digiRangeIteratorEnd-1)->channel()  << std::endl;
00201               }     
00202               if (verbosity > 0) {
00203                 std::cout << " FP420ClusterMain:3 noise treatment  " << std::endl;
00204               }   
00205               if ( clusterMode_ == "ClusterProducerFP420" ) {
00206                 
00207                 std::vector<ClusterFP420> collector;
00208                 //          vector<ClusterFP420> collector;
00209                 
00210                 if (UseNoiseBadElectrodeFlagFromDB_==false){      
00211                   
00212                   //Case of SingleValueNoise flags for all electrodes of a Detector
00213                   
00214                   
00215                   //float noise = ENC_*ldrift/Thick300/ElectronPerADC_;//Noise is proportional to charge collection path 
00216                   float noise = ENC_*moduleThickness/Thick300/ElectronPerADC_;//Noise is proportional to moduleThickness
00217                   
00218                   //vector<float> noiseVec(numElectrodes,noise);            
00219                   //Construct a ElectrodNoiseVector ( in order to be compliant with the DB access)
00220                   ElectrodNoiseVector vnoise;
00221                   ClusterNoiseFP420::ElectrodData theElectrodData;                 
00222                   
00223                   if (verbosity > 0) {
00224                     std::cout << " FP420ClusterMain:4 numStrips = " << numStrips  << std::endl;
00225                   }       
00226                   for(int electrode=0; electrode < numStrips; ++electrode){
00227                     //   discard  randomly  bad  electrode with probability BadElectrodeProbability_
00228                     bool badFlag= RandFlat::shoot(1.) < BadElectrodeProbability_ ? true : false;
00229                     theElectrodData.setData(noise,badFlag);
00230                     vnoise.push_back(theElectrodData);// fill vector vnoise
00231                   } // for
00232                   
00233                   if (verbosity > 0) {
00234                     std::cout << " FP420ClusterMain:5 BadElectrodeProbability added " << std::endl;
00235                   }       
00236                   //clusterizeDetUnit   or    clusterizeDetUnitPixels      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
00237                   collector.clear();
00238                   //          std::vector<ClusterFP420> collector;
00239                   //  collector = threeThreshold_->clusterizeDetUnit(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise);
00240                   //   if (dcollector.size()>0){
00241                   collector = threeThreshold_->clusterizeDetUnitPixels(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise,xytype);
00242                   //   }
00243                   if (verbosity > 0) {
00244                     std::cout << " FP420ClusterMain:6 threeThreshold OK " << std::endl;
00245                   }       
00246                   
00247                   
00248                 } else {
00249                   //Case of Noise and BadElectrode flags access from DB
00250                   /*
00251                     const ElectrodNoiseVector& vnoise = electrodnoise->getElectrodNoiseVector(detID);
00252                     
00253                     if (vnoise.size() <= 0) {
00254                     std::cout << "WARNING requested Noise Vector for detID " << detID << " that isn't in map " << std::endl; 
00255                     continue;
00256                     }
00257                     collector.clear();
00258                     collector = threeThreshold_->clusterizeDetUnit(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise);
00259                   */
00260                   
00261                   
00262                 }// if (UseNoiseBadElectrodeFlagFromDB
00263                 
00264                 if (collector.size()>0){
00265                   ClusterCollectionFP420::Range inputRange;
00266                   inputRange.first = collector.begin();
00267                   inputRange.second = collector.end();
00268                   
00269                   if (verbosity > 0) {
00270                     std::cout << " FP420ClusterMain:7 collector.size()>0 " << std::endl;
00271                   }       
00272                   if ( first ) {
00273                     // use it only if ClusterCollectionFP420 is the ClusterCollection of one event, otherwise, do not use (loose 1st cl. of 1st event only)
00274                     first = false;
00275                     unsigned int detID0 = 0;
00276                     if (verbosity > 0) {
00277                       std::cout << " FP420ClusterMain:8 first soutput->put " << std::endl;
00278                     }     
00279                     soutput->put(inputRange,detID0); // !!! put into adress 0 for detID which will not be used never
00280                   } //if ( first ) 
00281                   
00282                   // !!! put
00283                   if (verbosity > 0) {
00284                     std::cout << " FP420ClusterMain:9 soutput->put " << std::endl;
00285                   }       
00286                   soutput->put(inputRange,detID);
00287                   
00288                   number_localelectroderechits += collector.size();
00289                 } // if (collector.size
00290               }// if ( clusterMode
00291               if (verbosity > 0) {
00292                 std::cout << "[FP420ClusterMain] execution in mode " << clusterMode_ << " generating " << number_localelectroderechits << " ClusterFP420s in " << number_detunits << " DetUnits." << std::endl; 
00293               }//if (verb
00294             }// if (dcollector.siz
00295           }//for
00296         }//for
00297       }//for
00298     }//for
00299     
00300     if (verbosity > 0) {
00301       //     check of access to the collector:
00302       for (int det=1; det<dn0; det++) {
00303         for (int sector=1; sector<sn0; sector++) {
00304           for (int zmodule=1; zmodule<pn0; zmodule++) {
00305             for (int zside=1; zside<3; zside++) {
00306               int sScale = 2*(pn0-1), dScale = 2*(pn0-1)*(sn0-1);
00307               int zScale=2;  unsigned int iu = dScale*(det - 1)+sScale*(sector - 1)+zScale*(zmodule - 1)+zside;
00308               // int zScale=10; unsigned int intindex = sScale*(sector - 1)+zScale*(zside - 1)+zmodule;
00309               std::vector<ClusterFP420> collector;
00310               collector.clear();
00311               ClusterCollectionFP420::Range outputRange;
00312               outputRange = soutput->get(iu);
00313               // fill output in collector vector (for may be sorting? or other checks)
00314               ClusterCollectionFP420::ContainerIterator sort_begin = outputRange.first;
00315               ClusterCollectionFP420::ContainerIterator sort_end = outputRange.second;
00316               for ( ;sort_begin != sort_end; ++sort_begin ) {
00317                 collector.push_back(*sort_begin);
00318               } // for
00319               std::cout <<" ===" << std::endl;
00320               std::cout <<" ===" << std::endl;
00321               std::cout <<" =========== FP420ClusterMain:check: iu= " << iu <<    " zside = " << zside << std::endl;
00322               std::cout <<"  ======renew collector size = " << collector.size() << std::endl;
00323               std::cout <<" ===" << std::endl;
00324               std::cout <<" ===" << std::endl;
00325               vector<ClusterFP420>::const_iterator simHitIter = collector.begin();
00326               vector<ClusterFP420>::const_iterator simHitIterEnd = collector.end();
00327               // loop in #clusters
00328               for (;simHitIter != simHitIterEnd; ++simHitIter) {
00329                 const ClusterFP420 icluster = *simHitIter;
00330                 //   if(icluster.amplitudes().size()>390) {
00331                 std::cout << " ===== size of cluster= " << icluster.amplitudes().size() << std::endl;
00332                 std::cout <<" ===" << std::endl;
00333                 std::cout << " ===== firstStrip = " << icluster.firstStrip() << "  barycenter = " << icluster.barycenter() << "  barycenterW = " << icluster.barycenterW() << std::endl;
00334                 std::cout <<" ===" << std::endl;
00335                 for(unsigned int i = 0; i < icluster.amplitudes().size(); i++ ) {
00336                   std::cout <<  "i = " << i << "   amplitudes = "  << icluster.amplitudes()[i] << std::endl;
00337                 }// for ampl
00338                 std::cout <<" ===" << std::endl;
00339                 std::cout <<" ===" << std::endl;
00340                 std::cout <<" =======================" << std::endl;
00341                 //  }// if(icluster.amplitudes().size()>390
00342               }//for cl
00343               
00344               /* 
00345                  for (DigitalMapType::const_iterator i=collector.begin(); i!=collector.end(); i++) {
00346                  std::cout << "DigitizerFP420:check: HDigiFP420::  " << std::endl;
00347                  std::cout << " strip number is as (*i).first  = " << (*i).first << "  adc is in (*i).second  = " << (*i).second << std::endl;
00348                  }
00349               */
00350               
00351               //==================================
00352               
00353             }   // for
00354           }   // for
00355         }   // for
00356       }   // for
00357       
00358       //     end of check of access to the strip collection
00359       std::cout <<"=======            FP420ClusterMain:                    end of check     " << std::endl;
00360       
00361     }// if (verbosit
00362     
00363     
00364     
00365   }// if ( validClusterizer_
00366 }

double FP420ClusterMain::BadElectrodeProbability_ [private]

Definition at line 59 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ChannelThreshold [private]

Definition at line 63 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain().

std::string FP420ClusterMain::clusterMode_ [private]

Definition at line 50 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ClusterThreshold [private]

Definition at line 65 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain().

edm::ParameterSet FP420ClusterMain::conf_ [private]

Definition at line 53 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain().

int FP420ClusterMain::dn0 [private]

Definition at line 84 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ElectronPerADC_ [private]

Definition at line 57 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ENC_ [private]

Definition at line 58 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ldrift [private]

Definition at line 70 of file FP420ClusterMain.h.

Referenced by run().

double FP420ClusterMain::ldriftX [private]

Definition at line 68 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::ldriftY [private]

Definition at line 69 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::MaxVoidsInCluster [private]

Definition at line 66 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain().

float FP420ClusterMain::moduleThickness [private]

Definition at line 76 of file FP420ClusterMain.h.

Referenced by run().

float FP420ClusterMain::moduleThicknessX [private]

Definition at line 74 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

float FP420ClusterMain::moduleThicknessY [private]

Definition at line 75 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::numStrips [private]

Definition at line 79 of file FP420ClusterMain.h.

Referenced by run().

int FP420ClusterMain::numStripsX [private]

Definition at line 77 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::numStripsXW [private]

Definition at line 77 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::numStripsY [private]

Definition at line 78 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::numStripsYW [private]

Definition at line 78 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::pitch [private]

Definition at line 73 of file FP420ClusterMain.h.

Referenced by run().

double FP420ClusterMain::pitchX [private]

Definition at line 71 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::pitchY [private]

Definition at line 72 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::pn0 [private]

Definition at line 88 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

double FP420ClusterMain::SeedThreshold [private]

Definition at line 64 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain().

int FP420ClusterMain::sn0 [private]

Definition at line 86 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

float FP420ClusterMain::Thick300 [private]

Definition at line 81 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

ClusterProducerFP420* FP420ClusterMain::threeThreshold_ [private]

Definition at line 49 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), run(), and ~FP420ClusterMain().

bool FP420ClusterMain::UseNoiseBadElectrodeFlagFromDB_ [private]

Definition at line 60 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

bool FP420ClusterMain::validClusterizer_ [private]

Definition at line 56 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::verbosity [private]

Definition at line 92 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

int FP420ClusterMain::xytype [private]

Definition at line 90 of file FP420ClusterMain.h.

Referenced by FP420ClusterMain(), and run().

FP420ClusterMain Class Reference

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	FP420ClusterMain (const edm::ParameterSet &conf, int dn, int sn, int pn)
void	run (edm::Handle< DigiCollectionFP420 > &input, std::auto_ptr< ClusterCollectionFP420 > &soutput, std::vector< ClusterNoiseFP420 > &noise)
	Runs the algorithm.
	~FP420ClusterMain ()
Private Attributes
double	BadElectrodeProbability_
double	ChannelThreshold
std::string	clusterMode_
double	ClusterThreshold
edm::ParameterSet	conf_
int	dn0
double	ElectronPerADC_
double	ENC_
double	ldrift
double	ldriftX
double	ldriftY
int	MaxVoidsInCluster
float	moduleThickness
float	moduleThicknessX
float	moduleThicknessY
int	numStrips
int	numStripsX
int	numStripsXW
int	numStripsY
int	numStripsYW
double	pitch
double	pitchX
double	pitchY
int	pn0
double	SeedThreshold
int	sn0
float	Thick300
ClusterProducerFP420 *	threeThreshold_
bool	UseNoiseBadElectrodeFlagFromDB_
bool	validClusterizer_
int	verbosity
int	xytype