#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, 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 25 of file FP420ClusterMain.h.

Constructor & Destructor Documentation

◆ FP420ClusterMain()

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

Definition at line 22 of file FP420ClusterMain.cc.

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

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.

◆ ~FP420ClusterMain()

FP420ClusterMain::~FP420ClusterMain ( )

Definition at line 104 of file FP420ClusterMain.cc.

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

References threeThreshold_.

Member Function Documentation

◆ run()

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

Runs the algorithm.

Definition at line 112 of file FP420ClusterMain.cc.

 {
   // 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.empty()) {
               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.empty()) {
                   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_
 }