FP420ClusterMain.cc

Go to the documentation of this file.

// File: FP420ClusterMain.cc
// Date: 12.2006
// Description: FP420ClusterMain for FP420
// Modifications: 
#include <vector>
#include <iostream>
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESHandle.h"

#include "RecoRomanPot/RecoFP420/interface/FP420ClusterMain.h"
#include "DataFormats/FP420Digi/interface/HDigiFP420.h"
#include "DataFormats/FP420Cluster/interface/ClusterFP420.h"
#include "RecoRomanPot/RecoFP420/interface/ClusterProducerFP420.h"
#include "RecoRomanPot/RecoFP420/interface/ClusterNoiseFP420.h"

#include "CLHEP/Random/RandFlat.h"

using namespace std;


FP420ClusterMain::FP420ClusterMain(const edm::ParameterSet& conf, int dn, int sn, int pn, int rn):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;


  theFP420NumberingScheme = new FP420NumberingScheme();


  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() {
  if ( threeThreshold_ != 0 ) {
    delete threeThreshold_;
  }
}


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

{
  // 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 = theFP420NumberingScheme->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 = theFP420NumberingScheme->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_
}