#include <FP420ClusterMain.h>

Public Member Functions
	FP420ClusterMain (const edm::ParameterSet &conf, int dn, int sn, int pn, int rn)

void	run (edm::Handle< DigiCollectionFP420 > &input, std::auto_ptr< ClusterCollectionFP420 > &soutput, std::vector< ClusterNoiseFP420 > &noise)
	Runs the algorithm. More...

	~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

int	rn0

double	SeedThreshold

int	sn0

float	Thick300

ClusterProducerFP420 *	threeThreshold_

bool	UseNoiseBadElectrodeFlagFromDB_

bool	validClusterizer_

int	verbosity

int	xytype

Detailed Description

Definition at line 26 of file FP420ClusterMain.h.

Constructor & Destructor Documentation

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

Definition at line 23 of file FP420ClusterMain.cc.

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

                                                                                              :conf_(conf),dn0(dn),sn0(sn),pn0(pn),rn0(rn)  { 
   
   verbosity         = conf_.getUntrackedParameter<int>("VerbosityLevel");
   ElectronPerADC_   = conf_.getParameter<double>("ElectronFP420PerAdc");
   clusterMode_      = conf_.getParameter<std::string>("ClusterModeFP420");
   ChannelThreshold  = conf_.getParameter<double>("ChannelFP420Threshold");//6
   SeedThreshold     = conf_.getParameter<double>("SeedFP420Threshold");//7
   ClusterThreshold  = conf_.getParameter<double>("ClusterFP420Threshold");//7
   MaxVoidsInCluster = conf_.getParameter<int>("MaxVoidsFP420InCluster");//1
   
   if (verbosity > 0) {
     std::cout << "FP420ClusterMain constructor: ElectronPerADC = " << ElectronPerADC_ << std::endl;
     std::cout << " clusterMode = " << clusterMode_ << std::endl;
     std::cout << " ChannelThreshold = " << ChannelThreshold << std::endl;
     std::cout << " SeedThreshold = " << SeedThreshold << std::endl;
     std::cout << " ClusterThreshold = " << ClusterThreshold << std::endl;
     std::cout << " MaxVoidsInCluster = " << MaxVoidsInCluster << std::endl;
   }
   xytype=2;// only X types of planes
   ENC_ = 960.;    // 
   Thick300 = 0.300;
   BadElectrodeProbability_ = 0.002;
   //UseNoiseBadElectrodeFlagFromDB_ = true;
   UseNoiseBadElectrodeFlagFromDB_ = false;
   //
   // pitches and ldriftes:
   //
   ldriftX = 0.050; 
   ldriftY = 0.050;// was 0.040
   pitchY= 0.050;// was 0.040
   pitchX= 0.050;
   moduleThicknessY = 0.250; // mm
   moduleThicknessX = 0.250; // mm
 
   //numStripsY = 200;        // Y plate number of strips:200*0.050=10mm (xytype=1)
   //numStripsX = 400;        // X plate number of strips:400*0.050=20mm (xytype=2)
   numStripsY = 144;        // Y plate number of strips:144*0.050=7.2mm (xytype=1)
   numStripsX = 160;        // X plate number of strips:160*0.050=8.0mm (xytype=2)
 
   //numStripsYW = 50;        // Y plate number of W strips:50 *0.400=20mm (xytype=1) - W have ortogonal projection
   //numStripsXW = 25;        // X plate number of W strips:25 *0.400=10mm (xytype=2) - W have ortogonal projection
   numStripsYW = 20;        // Y plate number of W strips:20 *0.400=8.0mm (xytype=1) - W have ortogonal projection
   numStripsXW = 18;        // X plate number of W strips:18 *0.400=7.2mm (xytype=2) - W have ortogonal projection
   
   //  sn0 = 4;
   //  pn0 = 9;
 
 
   if (verbosity > 1) {
     std::cout << "FP420ClusterMain constructor: sn0 = " << sn0 << " pn0=" << pn0 << " dn0=" << dn0 << " rn0=" << rn0 << std::endl;
     std::cout << "FP420ClusterMain constructor: ENC = " << ENC_ << std::endl;
     std::cout << " Thick300 = " << Thick300 << std::endl;
     std::cout << " BadElectrodeProbability = " << BadElectrodeProbability_ << std::endl;
     std::cout << " ldriftX = " << ldriftX << " ldriftY = " << ldriftY << std::endl;
     std::cout << " pitchY = " << pitchY << " pitchX = " << pitchX << std::endl;
     std::cout << " numStripsY = " << numStripsY << " numStripsX = " << numStripsX << std::endl;
     std::cout << " moduleThicknessY = " << moduleThicknessY << " moduleThicknessX = " << moduleThicknessX << std::endl;
   }
   
   if (UseNoiseBadElectrodeFlagFromDB_==false){    
     if (verbosity > 0) {
       std::cout << "using a SingleNoiseValue and good electrode flags" << std::endl;
     }
   } else {
     if (verbosity > 0) {
       std::cout << "using Noise and BadElectrode flags accessed from DB" << std::endl;
     }
   }
   
   if ( clusterMode_ == "ClusterProducerFP420" ) {
     
     
     //    ChannelThreshold    = 6.0;// was 2.6.0 7 18
     //   SeedThreshold       = 7.0;//was 3.7.0  8 20
     // ClusterThreshold    = 7.0;// was 2. 7.0 8 20
     // MaxVoidsInCluster   = 1; 
     threeThreshold_ = new ClusterProducerFP420(ChannelThreshold,
                            SeedThreshold,
                            ClusterThreshold,
                            MaxVoidsInCluster);
     validClusterizer_ = true;
   } else {
     std::cout << "ERROR:FP420ClusterMain: No valid clusterizer selected" << std::endl;
     validClusterizer_ = false;
   }
 }

FP420ClusterMain::~FP420ClusterMain ( )

Definition at line 110 of file FP420ClusterMain.cc.

References threeThreshold_.

                                     {
   if ( threeThreshold_ != 0 ) {
     delete threeThreshold_;
   }
 }

Member Function Documentation

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

Runs the algorithm.

Definition at line 119 of file FP420ClusterMain.cc.

References ClusterFP420::amplitudes(), BadElectrodeProbability_, ClusterFP420::barycenter(), ClusterFP420::barycenterW(), ClusterProducerFP420::clusterizeDetUnitPixels(), clusterMode_, gather_cfg::cout, dn0, ElectronPerADC_, ENC_, plotBeamSpotDB::first, ClusterFP420::firstStrip(), i, estimatePileup::inputRange, ldrift, ldriftX, ldriftY, moduleThickness, moduleThicknessX, moduleThicknessY, HLT_25ns10e33_v2_cff::noise, numStrips, numStripsX, numStripsXW, numStripsY, numStripsYW, FP420NumberingScheme::packMYIndex(), pitch, pitchX, pitchY, pn0, rn0, ClusterNoiseFP420::ElectrodData::setData(), sn0, Thick300, threeThreshold_, UseNoiseBadElectrodeFlagFromDB_, validClusterizer_, verbosity, xytype, and ecaldqm::zside().

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

 {
   // unpack from iu:
   //  int  sScale = 20, zScale=2;
   //  int  sector = (iu-1)/sScale + 1 ;
   //  int  zmodule = (iu - (sector - 1)*sScale - 1) /zScale + 1 ;
   //  int  zside = iu - (sector - 1)*sScale - (zmodule - 1)*zScale ;
   
     if (verbosity > 0) {
       std::cout << "FP420ClusterMain: OK1" << std::endl;
     }
   if ( validClusterizer_ ) {
     
     int number_detunits          = 0;
     int number_localelectroderechits = 0;
     
     // get vector of detunit ids
     //    const std::vector<unsigned int> detIDs = input->detIDs();
     
     // to be used in put (besause of 0 in cluster collection for: 1) 1st cluster and 2) case of no cluster)
     // ignore 0, but to save info for 1st cluster record it second time on place 1   .
     
     bool first = true;
     // loop over detunits
     for (int det=1; det<dn0; det++) {
       for (int sector=1; sector<sn0; sector++) {
     for (int zmodule=1; zmodule<pn0; zmodule++) {
       for (int zside=1; zside<rn0; zside++) {
         // intindex is a continues numbering of FP420
         unsigned int detID = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
         if (verbosity > 0) {
           std::cout << " FP420ClusterMain:1 run loop   index no  iu = " << detID  << std::endl;
         }     
         // Y:
         if (xytype ==1) {
           numStrips = numStripsY*numStripsYW;  
           moduleThickness = moduleThicknessY; 
           pitch= pitchY;
           ldrift = ldriftX;
         }
         // X:
         if (xytype ==2) {
           numStrips = numStripsX*numStripsXW;  
           moduleThickness = moduleThicknessX; 
           pitch= pitchX;
           ldrift = ldriftY;
         }
         
         
         //    for ( std::vector<unsigned int>::const_iterator detunit_iterator = detIDs.begin(); detunit_iterator != detIDs.end(); ++detunit_iterator ) {
         //      unsigned int detID = *detunit_iterator;
         ++number_detunits;
         
         //   .
         //   GET DIGI collection  !!!!
         //   .
         //    const DigiCollectionFP420::Range digiRange = input->get(detID);
         DigiCollectionFP420::Range digiRange;
         std::vector<HDigiFP420> dcollector;
         // if (dcollector.size()>0){
         if (verbosity > 0) {
           std::cout << " FP420ClusterMain:2 number_detunits = " << number_detunits  << std::endl;
         }     
         digiRange = input->get(detID);
         //digiRange = input.get(detID);
         // }
         
         if (verbosity > 0) {
           std::cout << " FP420ClusterMain: input->get DONE dcollector.size()=" << dcollector.size() << std::endl;
         }     
         
         DigiCollectionFP420::ContainerIterator sort_begin = digiRange.first;
         DigiCollectionFP420::ContainerIterator sort_end = digiRange.second;
         for ( ;sort_begin != sort_end; ++sort_begin ) {
           dcollector.push_back(*sort_begin);
         } // for
         if (dcollector.size()>0) {
           
           DigiCollectionFP420::ContainerIterator digiRangeIteratorBegin = digiRange.first;
           DigiCollectionFP420::ContainerIterator digiRangeIteratorEnd   = digiRange.second;
           if (verbosity > 0) {
         std::cout << " FP420ClusterMain: channel Begin = " << (digiRangeIteratorBegin)->channel()  << std::endl;
         std::cout << " FP420ClusterMain: channel end = " << (digiRangeIteratorEnd-1)->channel()  << std::endl;
           }     
           if (verbosity > 0) {
         std::cout << " FP420ClusterMain:3 noise treatment  " << std::endl;
           }   
           if ( clusterMode_ == "ClusterProducerFP420" ) {
         
         std::vector<ClusterFP420> collector;
         //      std::vector<ClusterFP420> collector;
         
         if (UseNoiseBadElectrodeFlagFromDB_==false){      
           
           //Case of SingleValueNoise flags for all electrodes of a Detector
           
           
           //float noise = ENC_*ldrift/Thick300/ElectronPerADC_;//Noise is proportional to charge collection path 
           float noise = ENC_*moduleThickness/Thick300/ElectronPerADC_;//Noise is proportional to moduleThickness
           
           //vector<float> noiseVec(numElectrodes,noise);        
           //Construct a ElectrodNoiseVector ( in order to be compliant with the DB access)
           ElectrodNoiseVector vnoise;
           ClusterNoiseFP420::ElectrodData theElectrodData;             
           
           if (verbosity > 0) {
             std::cout << " FP420ClusterMain:4 numStrips = " << numStrips  << std::endl;
           }   
           for(int electrode=0; electrode < numStrips; ++electrode){
             //   discard  randomly  bad  electrode with probability BadElectrodeProbability_
             bool badFlag= CLHEP::RandFlat::shoot(1.) < BadElectrodeProbability_ ? true : false;
             theElectrodData.setData(noise,badFlag);
             vnoise.push_back(theElectrodData);// fill vector vnoise
           } // for
           
           if (verbosity > 0) {
             std::cout << " FP420ClusterMain:5 BadElectrodeProbability added " << std::endl;
           }   
           //clusterizeDetUnit   or    clusterizeDetUnitPixels      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
           collector.clear();
           //          std::vector<ClusterFP420> collector;
           //  collector = threeThreshold_->clusterizeDetUnit(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise);
           //   if (dcollector.size()>0){
           collector = threeThreshold_->clusterizeDetUnitPixels(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise,xytype,verbosity);
           //   }
           if (verbosity > 0) {
             std::cout << " FP420ClusterMain:6 threeThreshold OK " << std::endl;
           }   
           
           
         } else {
           //Case of Noise and BadElectrode flags access from DB
           /*
             const ElectrodNoiseVector& vnoise = electrodnoise->getElectrodNoiseVector(detID);
             
             if (vnoise.size() <= 0) {
             std::cout << "WARNING requested Noise Vector for detID " << detID << " that isn't in map " << std::endl; 
             continue;
             }
             collector.clear();
             collector = threeThreshold_->clusterizeDetUnit(digiRangeIteratorBegin,digiRangeIteratorEnd,detID,vnoise);
           */
           
           
         }// if (UseNoiseBadElectrodeFlagFromDB
         
         if (collector.size()>0){
           ClusterCollectionFP420::Range inputRange;
           inputRange.first = collector.begin();
           inputRange.second = collector.end();
           
           if (verbosity > 0) {
             std::cout << " FP420ClusterMain:7 collector.size()>0 " << std::endl;
           }   
           if ( first ) {
             // use it only if ClusterCollectionFP420 is the ClusterCollection of one event, otherwise, do not use (loose 1st cl. of 1st event only)
             first = false;
             unsigned int detID0 = 0;
             if (verbosity > 0) {
               std::cout << " FP420ClusterMain:8 first soutput->put " << std::endl;
             }     
             soutput->put(inputRange,detID0); // !!! put into adress 0 for detID which will not be used never
           } //if ( first ) 
           
           // !!! put
           if (verbosity > 0) {
             std::cout << " FP420ClusterMain:9 soutput->put " << std::endl;
           }   
           soutput->put(inputRange,detID);
           
           number_localelectroderechits += collector.size();
         } // if (collector.size
           }// if ( clusterMode
           if (verbosity > 0) {
         std::cout << "[FP420ClusterMain] execution in mode " << clusterMode_ << " generating " << number_localelectroderechits << " ClusterFP420s in " << number_detunits << " DetUnits." << std::endl; 
           }//if (verb
         }// if (dcollector.siz
       }//for
     }//for
       }//for
     }//for
     
     if (verbosity == -50 ) {
 
       //     check of access to the collector:
       for (int det=1; det<dn0; det++) {
     for (int sector=1; sector<sn0; sector++) {
       for (int zmodule=1; zmodule<pn0; zmodule++) {
         for (int zside=1; zside<rn0; zside++) {
           // intindex is a continues numbering of FP420
           unsigned int iu = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
         std::cout <<" iu = " << iu <<" sector = " << sector <<" zmodule = " << zmodule <<" zside = " << zside << "  det=" << det << std::endl;
           std::vector<ClusterFP420> collector;
           collector.clear();
           ClusterCollectionFP420::Range outputRange;
           outputRange = soutput->get(iu);
           // fill output in collector vector (for may be sorting? or other checks)
           ClusterCollectionFP420::ContainerIterator sort_begin = outputRange.first;
           ClusterCollectionFP420::ContainerIterator sort_end = outputRange.second;
           for ( ;sort_begin != sort_end; ++sort_begin ) {
         collector.push_back(*sort_begin);
           } // for
           std::cout <<" ===" << std::endl;
           std::cout <<" ===" << std::endl;
           std::cout <<" =========== FP420ClusterMain:check: iu= " << iu <<    " zside = " << zside << std::endl;
           std::cout <<"  ======renew collector size = " << collector.size() << std::endl;
           std::cout <<" ===" << std::endl;
           std::cout <<" ===" << std::endl;
           std::vector<ClusterFP420>::const_iterator simHitIter = collector.begin();
           std::vector<ClusterFP420>::const_iterator simHitIterEnd = collector.end();
           // loop in #clusters
           for (;simHitIter != simHitIterEnd; ++simHitIter) {
         const ClusterFP420 icluster = *simHitIter;
         //   if(icluster.amplitudes().size()>390) {
         std::cout << " ===== size of cluster= " << icluster.amplitudes().size() << std::endl;
         std::cout <<" ===" << std::endl;
         std::cout << " ===== firstStrip = " << icluster.firstStrip() << "  barycenter = " << icluster.barycenter() << "  barycenterW = " << icluster.barycenterW() << std::endl;
         std::cout <<" ===" << std::endl;
         for(unsigned int i = 0; i < icluster.amplitudes().size(); i++ ) {
           std::cout <<  "i = " << i << "   amplitudes = "  << icluster.amplitudes()[i] << std::endl;
         }// for ampl
         std::cout <<" ===" << std::endl;
         std::cout <<" ===" << std::endl;
         std::cout <<" =======================" << std::endl;
         //  }// if(icluster.amplitudes().size()>390
           }//for cl
           
           /* 
          for (DigitalMapType::const_iterator i=collector.begin(); i!=collector.end(); i++) {
          std::cout << "DigitizerFP420:check: HDigiFP420::  " << std::endl;
          std::cout << " strip number is as (*i).first  = " << (*i).first << "  adc is in (*i).second  = " << (*i).second << std::endl;
          }
           */
           
           //==================================
           
         }   // for
       }   // for
     }   // for
       }   // for
       
       //     end of check of access to the strip collection
       std::cout <<"=======            FP420ClusterMain:                    end of check     " << std::endl;
       
     }// if (verbosit
     
     
     
   }// if ( validClusterizer_
 }