SiPixelDigitizerAlgorithm Class Reference

#include <SiPixelDigitizerAlgorithm.h>

Classes
class	Amplitude
class	CalParameters
class	EnergyDepositUnit
struct	PixelAging
struct	PixelEfficiencies
class	SignalPoint

Public Member Functions
void	accumulateSimHits (const std::vector< PSimHit >::const_iterator inputBegin, const std::vector< PSimHit >::const_iterator inputEnd, const size_t inputBeginGlobalIndex, const unsigned int tofBin, const PixelGeomDetUnit *pixdet, const GlobalVector &bfield, const TrackerTopology *tTopo, CLHEP::HepRandomEngine *)
void	calculateInstlumiFactor (PileupMixingContent *puInfo)
void	calculateInstlumiFactor (const std::vector< PileupSummaryInfo > &ps, int bunchSpacing)
void	digitize (const PixelGeomDetUnit *pixdet, std::vector< PixelDigi > &digis, std::vector< PixelDigiSimLink > &simlinks, const TrackerTopology *tTopo, CLHEP::HepRandomEngine *)
void	init (const edm::EventSetup &es)
void	init_DynIneffDB (const edm::EventSetup &, const unsigned int &)
void	initializeEvent ()
void	setSimAccumulator (const std::map< uint32_t, std::map< int, int > > &signalMap)
	SiPixelDigitizerAlgorithm (const edm::ParameterSet &conf)
	~SiPixelDigitizerAlgorithm ()

Private Types
typedef boost::multi_array< float, 2 >	array_2d
typedef GloballyPositioned< double >	Frame
typedef std::vector< edm::ParameterSet >	Parameters
typedef signal_map_type::const_iterator	signal_map_const_iterator
typedef signal_map_type::iterator	signal_map_iterator
typedef std::map< int, Amplitude, std::less< int > >	signal_map_type
typedef std::map< uint32_t, signal_map_type >	signalMaps

Private Member Functions
void	add_noise (const PixelGeomDetUnit *pixdet, float thePixelThreshold, CLHEP::HepRandomEngine *)
double	calcQ (float x) const
void	drift (const PSimHit &hit, const PixelGeomDetUnit *pixdet, const GlobalVector &bfield, const TrackerTopology *tTopo, const std::vector< EnergyDepositUnit > &ionization_points, std::vector< SignalPoint > &collection_points) const
LocalVector	DriftDirection (const PixelGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const
void	fluctuateEloss (int particleId, float momentum, float eloss, float length, int NumberOfSegments, float elossVector[], CLHEP::HepRandomEngine *) const
bool	hitSignalReweight (const PSimHit &hit, std::map< int, float, std::less< int > > &hit_signal, const size_t hitIndex, const unsigned int tofBin, const PixelTopology *topol, uint32_t detID, signal_map_type &theSignal, unsigned short int processType)
void	induce_signal (std::vector< PSimHit >::const_iterator inputBegin, std::vector< PSimHit >::const_iterator inputEnd, const PSimHit &hit, const size_t hitIndex, const unsigned int tofBin, const PixelGeomDetUnit *pixdet, const std::vector< SignalPoint > &collection_points)
std::map< int, CalParameters, std::less< int > >	initCal () const
void	make_digis (float thePixelThresholdInE, uint32_t detID, const PixelGeomDetUnit *pixdet, std::vector< PixelDigi > &digis, std::vector< PixelDigiSimLink > &simlinks, const TrackerTopology *tTopo) const
float	missCalibrate (uint32_t detID, const TrackerTopology *tTopo, const PixelGeomDetUnit *pixdet, int col, int row, float amp) const
void	module_killing_conf (uint32_t detID)
void	module_killing_DB (uint32_t detID)
float	pixel_aging (const PixelAging &aging, const PixelGeomDetUnit *pixdet, const TrackerTopology *tTopo) const
void	pixel_inefficiency (const PixelEfficiencies &eff, const PixelGeomDetUnit *pixdet, const TrackerTopology *tTopo, CLHEP::HepRandomEngine *)
void	pixel_inefficiency_db (uint32_t detID)
int	PixelTempRewgt2D (int id_gen, int id_rewgt, array_2d &cluster)
void	primary_ionization (const PSimHit &hit, std::vector< EnergyDepositUnit > &ionization_points, CLHEP::HepRandomEngine *) const
void	printCluster (array_2d &cluster)
void	printCluster (float arr[13+2][21+2])
void	printCluster (float arr[13][21])

Private Attributes
signalMaps	_signal
const bool	addChargeVCALSmearing
const bool	addNoise
const bool	addNoisyPixels
const bool	AddPixelAging
const bool	AddPixelInefficiency
const bool	addThresholdSmearing
const bool	alpha2Order
const float	BPix_p0
const float	BPix_p1
const float	BPix_p2
const float	BPix_p3
const std::map< int, CalParameters, std::less< int > >	calmap
const float	ClusterWidth
const SiPixel2DTemplateDBObject *	dbobject_den
const SiPixel2DTemplateDBObject *	dbobject_num
const Parameters	DeadModules
const float	Dist300
const bool	doMissCalibrate
const float	electronsPerVCAL
const float	electronsPerVCAL_L1
const float	electronsPerVCAL_L1_Offset
const float	electronsPerVCAL_Offset
const std::unique_ptr< SiG4UniversalFluctuation >	fluctuate
const bool	fluctuateCharge
const float	FPix_p0
const float	FPix_p1
const float	FPix_p2
const float	FPix_p3
edm::ESHandle< TrackerGeometry >	geom_
const float	GeVperElectron
int	IDden
int	IDnum
const bool	makeDigiSimLinks_
edm::ESHandle< SiPixelFedCablingMap >	map_
const int	NumberOfBarrelLayers
const int	NumberOfEndcapDisks
const PixelAging	pixelAging_
PixelEfficiencies	pixelEfficiencies_
const bool	PrintClusters
const bool	PrintTemplates
const float	Sigma0
edm::ESHandle< SiPixelQuality >	SiPixelBadModule_
edm::ESHandle< SiPixelDynamicInefficiency >	SiPixelDynamicInefficiency_
edm::ESHandle< SiPixelLorentzAngle >	SiPixelLorentzAngle_
const float	tanLorentzAnglePerTesla_BPix
const float	tanLorentzAnglePerTesla_FPix
SiPixelTemplate2D	templ2D
std::vector< SiPixelTemplateStore2D >	templateStores_
const int	theAdcFullScale
const int	theAdcFullScaleStack
const float	theElectronPerADC
const float	theGainSmearing
const float	theNoiseInElectrons
const std::unique_ptr< GaussianTailNoiseGenerator >	theNoiser
const float	theOffsetSmearing
const float	theReadoutNoise
const std::unique_ptr< SiPixelGainCalibrationOfflineSimService >	theSiPixelGainCalibrationService_
const float	theThresholdInE_BPix
const float	theThresholdInE_BPix_L1
const float	theThresholdInE_BPix_L2
const float	theThresholdInE_FPix
const double	theThresholdSmearing_BPix
const double	theThresholdSmearing_BPix_L1
const double	theThresholdSmearing_BPix_L2
const double	theThresholdSmearing_FPix
const float	theTofLowerCut
const float	theTofUpperCut
const double	tMax
std::vector< float >	track
const bool	use_deadmodule_DB_
const bool	use_ineff_from_db_
const bool	use_LorentzAngle_DB_
const bool	use_module_killing_
const bool	UseReweighting
std::vector< bool >	xdouble
std::vector< bool >	ydouble

Detailed Description

Definition at line 51 of file SiPixelDigitizerAlgorithm.h.

Member Typedef Documentation

typedef boost::multi_array<float, 2> SiPixelDigitizerAlgorithm::array_2d

private

Definition at line 294 of file SiPixelDigitizerAlgorithm.h.

typedef GloballyPositioned<double> SiPixelDigitizerAlgorithm::Frame

private

Definition at line 292 of file SiPixelDigitizerAlgorithm.h.

typedef std::vector<edm::ParameterSet> SiPixelDigitizerAlgorithm::Parameters

private

Definition at line 293 of file SiPixelDigitizerAlgorithm.h.

typedef signal_map_type::const_iterator SiPixelDigitizerAlgorithm::signal_map_const_iterator

private

Definition at line 290 of file SiPixelDigitizerAlgorithm.h.

typedef signal_map_type::iterator SiPixelDigitizerAlgorithm::signal_map_iterator

private

Definition at line 289 of file SiPixelDigitizerAlgorithm.h.

typedef std::map<int, Amplitude, std::less<int> > SiPixelDigitizerAlgorithm::signal_map_type

private

Definition at line 288 of file SiPixelDigitizerAlgorithm.h.

typedef std::map<uint32_t, signal_map_type> SiPixelDigitizerAlgorithm::signalMaps

private

Definition at line 291 of file SiPixelDigitizerAlgorithm.h.

Constructor & Destructor Documentation

SiPixelDigitizerAlgorithm::SiPixelDigitizerAlgorithm

(

const edm::ParameterSet &

conf

)

Definition at line 151 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelInefficiency, theAdcFullScale, theElectronPerADC, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, and tMax.

                                                                                :

  _signal(),
  makeDigiSimLinks_(conf.getUntrackedParameter<bool>("makeDigiSimLinks", true)),
  use_ineff_from_db_(conf.getParameter<bool>("useDB")),
  use_module_killing_(conf.getParameter<bool>("killModules")), // boolean to kill or not modules
  use_deadmodule_DB_(conf.getParameter<bool>("DeadModules_DB")), // boolean to access dead modules from DB
  use_LorentzAngle_DB_(conf.getParameter<bool>("LorentzAngle_DB")), // boolean to access Lorentz angle from DB

  DeadModules(use_deadmodule_DB_ ? Parameters() : conf.getParameter<Parameters>("DeadModules")), // get dead module from cfg file

  templ2D(templateStores_),
  xdouble(TXSIZE),
  ydouble(TYSIZE),
  IDnum(conf.exists("TemplateIDnumerator")?conf.getParameter<int>("TemplateIDnumerator"):0),
  IDden(conf.exists("TemplateIDdenominator")?conf.getParameter<int>("TemplateIDdenominator"):0),

  // Common pixel parameters
  // These are parameters which are not likely to be changed
  GeVperElectron(3.61E-09), // 1 electron(3.61eV, 1keV(277e, mod 9/06 d.k.
  Sigma0(0.00037),           // Charge diffusion constant 7->3.7
  Dist300(0.0300),          //   normalized to 300micron Silicon
  alpha2Order(conf.getParameter<bool>("Alpha2Order")),   // switch on/off of E.B effect
  ClusterWidth(3.),     // Charge integration spread on the collection plane

  // get external parameters:
  // To account for upgrade geometries do not assume the number 
  // of layers or disks.
  NumberOfBarrelLayers(conf.exists("NumPixelBarrel")?conf.getParameter<int>("NumPixelBarrel"):3),
  NumberOfEndcapDisks(conf.exists("NumPixelEndcap")?conf.getParameter<int>("NumPixelEndcap"):2),

  // ADC calibration 1adc count(135e.
  // Corresponds to 2adc/kev, 270[e/kev]/135[e/adc](2[adc/kev]
  // Be carefull, this parameter is also used in SiPixelDet.cc to
  // calculate the noise in adc counts from noise in electrons.
  // Both defaults should be the same.
  theElectronPerADC(conf.getParameter<double>("ElectronPerAdc")),

  // ADC saturation value, 255(8bit adc.
  //theAdcFullScale(conf.getUntrackedParameter<int>("AdcFullScale",255)),
  theAdcFullScale(conf.getParameter<int>("AdcFullScale")),
  theAdcFullScaleStack(conf.exists("AdcFullScaleStack")?conf.getParameter<int>("AdcFullScaleStack"):255),

  // Noise in electrons:
  // Pixel cell noise, relevant for generating noisy pixels
  theNoiseInElectrons(conf.getParameter<double>("NoiseInElectrons")),

  // Fill readout noise, including all readout chain, relevant for smearing
  //theReadoutNoise(conf.getUntrackedParameter<double>("ReadoutNoiseInElec",500.)),
  theReadoutNoise(conf.getParameter<double>("ReadoutNoiseInElec")),

  // Pixel threshold in units of noise:
  // thePixelThreshold(conf.getParameter<double>("ThresholdInNoiseUnits")),
  // Pixel threshold in electron units.
  theThresholdInE_FPix(conf.getParameter<double>("ThresholdInElectrons_FPix")),
  theThresholdInE_BPix(conf.getParameter<double>("ThresholdInElectrons_BPix")),
  theThresholdInE_BPix_L1(conf.exists("ThresholdInElectrons_BPix_L1")?conf.getParameter<double>("ThresholdInElectrons_BPix_L1"):theThresholdInE_BPix),
  theThresholdInE_BPix_L2(conf.exists("ThresholdInElectrons_BPix_L2")?conf.getParameter<double>("ThresholdInElectrons_BPix_L2"):theThresholdInE_BPix),

  // Add threshold gaussian smearing:
  theThresholdSmearing_FPix(conf.getParameter<double>("ThresholdSmearing_FPix")),
  theThresholdSmearing_BPix(conf.getParameter<double>("ThresholdSmearing_BPix")),
  theThresholdSmearing_BPix_L1(conf.exists("ThresholdSmearing_BPix_L1")?conf.getParameter<double>("ThresholdSmearing_BPix_L1"):theThresholdSmearing_BPix),
  theThresholdSmearing_BPix_L2(conf.exists("ThresholdSmearing_BPix_L2")?conf.getParameter<double>("ThresholdSmearing_BPix_L2"):theThresholdSmearing_BPix),

  // electrons to VCAL conversion needed in misscalibrate()
  electronsPerVCAL(conf.getParameter<double>("ElectronsPerVcal")),
  electronsPerVCAL_Offset(conf.getParameter<double>("ElectronsPerVcal_Offset")),
  electronsPerVCAL_L1(conf.exists("ElectronsPerVcal_L1")?conf.getParameter<double>("ElectronsPerVcal_L1"):electronsPerVCAL),
  electronsPerVCAL_L1_Offset(conf.exists("ElectronsPerVcal_L1_Offset")?conf.getParameter<double>("ElectronsPerVcal_L1_Offset"):electronsPerVCAL_Offset),

  //theTofCut 12.5, cut in particle TOD +/- 12.5ns
  //theTofCut(conf.getUntrackedParameter<double>("TofCut",12.5)),
  theTofLowerCut(conf.getParameter<double>("TofLowerCut")),
  theTofUpperCut(conf.getParameter<double>("TofUpperCut")),

  // Get the Lorentz angle from the cfg file:
  tanLorentzAnglePerTesla_FPix(use_LorentzAngle_DB_ ? 0.0 : conf.getParameter<double>("TanLorentzAnglePerTesla_FPix")),
  tanLorentzAnglePerTesla_BPix(use_LorentzAngle_DB_ ? 0.0 : conf.getParameter<double>("TanLorentzAnglePerTesla_BPix")),

  // signal response new parameterization: split Fpix and BPix
  FPix_p0(conf.getParameter<double>("FPix_SignalResponse_p0")),
  FPix_p1(conf.getParameter<double>("FPix_SignalResponse_p1")),
  FPix_p2(conf.getParameter<double>("FPix_SignalResponse_p2")),
  FPix_p3(conf.getParameter<double>("FPix_SignalResponse_p3")),

  BPix_p0(conf.getParameter<double>("BPix_SignalResponse_p0")),
  BPix_p1(conf.getParameter<double>("BPix_SignalResponse_p1")),
  BPix_p2(conf.getParameter<double>("BPix_SignalResponse_p2")),
  BPix_p3(conf.getParameter<double>("BPix_SignalResponse_p3")),

  // Add noise
  addNoise(conf.getParameter<bool>("AddNoise")),

  // Smear the pixel charge with a gaussian which RMS is a function of the
  // pixel charge (Danek's study)
  addChargeVCALSmearing(conf.getParameter<bool>("ChargeVCALSmearing")),

  // Add noisy pixels
  addNoisyPixels(conf.getParameter<bool>("AddNoisyPixels")),

  // Fluctuate charge in track subsegments
  fluctuateCharge(conf.getUntrackedParameter<bool>("FluctuateCharge",true)),

  // Control the pixel inefficiency
  AddPixelInefficiency(conf.getParameter<bool>("AddPixelInefficiency")),

  // Add threshold gaussian smearing:
  addThresholdSmearing(conf.getParameter<bool>("AddThresholdSmearing")),

  // Get the constants for the miss-calibration studies
  doMissCalibrate(conf.getParameter<bool>("MissCalibrate")), // Enable miss-calibration
  theGainSmearing(conf.getParameter<double>("GainSmearing")), // sigma of the gain smearing
  theOffsetSmearing(conf.getParameter<double>("OffsetSmearing")), //sigma of the offset smearing

  // Add pixel radiation damage for upgrade studies
  AddPixelAging(conf.getParameter<bool>("DoPixelAging")),
  UseReweighting(conf.getParameter<bool>("UseReweighting")),
  PrintClusters(conf.getParameter<bool>("PrintClusters")),
  PrintTemplates(conf.getParameter<bool>("PrintTemplates")),

  // delta cutoff in MeV, has to be same as in OSCAR(0.030/cmsim=1.0 MeV
  //tMax(0.030), // In MeV.
  //tMax(conf.getUntrackedParameter<double>("deltaProductionCut",0.030)),
  tMax(conf.getParameter<double>("deltaProductionCut")),

  fluctuate(fluctuateCharge ? new SiG4UniversalFluctuation() : nullptr),
  theNoiser(addNoise ? new GaussianTailNoiseGenerator() : nullptr),
  calmap(doMissCalibrate ? initCal() : std::map<int,CalParameters,std::less<int> >()),
  theSiPixelGainCalibrationService_(use_ineff_from_db_ ? new SiPixelGainCalibrationOfflineSimService(conf) : nullptr),
  pixelEfficiencies_(conf, AddPixelInefficiency,NumberOfBarrelLayers,NumberOfEndcapDisks),
  pixelAging_(conf,AddPixelAging,NumberOfBarrelLayers,NumberOfEndcapDisks)
{
  LogInfo ("PixelDigitizer ") <<"SiPixelDigitizerAlgorithm constructed"
                  <<"Configuration parameters:"
                  << "Threshold/Gain = "
                  << "threshold in electron FPix = "
                  << theThresholdInE_FPix
                  << "threshold in electron BPix = "
                  << theThresholdInE_BPix
                              << "threshold in electron BPix Layer1 = "
                              << theThresholdInE_BPix_L1
                              << "threshold in electron BPix Layer2 = "
                              << theThresholdInE_BPix_L2
                  <<" " << theElectronPerADC << " " << theAdcFullScale
                  << " The delta cut-off is set to " << tMax
                  << " pix-inefficiency "<<AddPixelInefficiency;

}

SiPixelDigitizerAlgorithm::~SiPixelDigitizerAlgorithm

(

)

Definition at line 394 of file SiPixelDigitizerAlgorithm.cc.

References LogDebug.

                                                      {
  LogDebug ("PixelDigitizer")<<"SiPixelDigitizerAlgorithm deleted";
}

Member Function Documentation

void SiPixelDigitizerAlgorithm::accumulateSimHits	(	const std::vector< PSimHit >::const_iterator	inputBegin,
		const std::vector< PSimHit >::const_iterator	inputEnd,
		const size_t	inputBeginGlobalIndex,
		const unsigned int	tofBin,
		const PixelGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 673 of file SiPixelDigitizerAlgorithm.cc.

References drift(), GeomDet::geographicalId(), induce_signal(), LogDebug, mag(), primary_ionization(), DetId::rawId(), GeomDet::surface(), theTofLowerCut, theTofUpperCut, and Surface::toGlobal().

                                                                                {
    // produce SignalPoint's for all SimHit's in detector
    // Loop over hits

    uint32_t detId = pixdet->geographicalId().rawId();
    size_t simHitGlobalIndex=inputBeginGlobalIndex; // This needs to stored to create the digi-sim link later
    for (std::vector<PSimHit>::const_iterator ssbegin = inputBegin; ssbegin != inputEnd; ++ssbegin, ++simHitGlobalIndex) {
      // skip hits not in this detector.
      if((*ssbegin).detUnitId() != detId) {
        continue;
      }

#ifdef TP_DEBUG
      LogDebug ("Pixel Digitizer")
    << (*ssbegin).particleType() << " " << (*ssbegin).pabs() << " "
    << (*ssbegin).energyLoss() << " " << (*ssbegin).tof() << " "
    << (*ssbegin).trackId() << " " << (*ssbegin).processType() << " "
    << (*ssbegin).detUnitId()
    << (*ssbegin).entryPoint() << " " << (*ssbegin).exitPoint() ;
#endif

      
      std::vector<EnergyDepositUnit> ionization_points;
      std::vector<SignalPoint> collection_points;

      // fill collection_points for this SimHit, indpendent of topology
      // Check the TOF cut
      if (  ((*ssbegin).tof() - pixdet->surface().toGlobal((*ssbegin).localPosition()).mag()/30.)>= theTofLowerCut &&
        ((*ssbegin).tof()- pixdet->surface().toGlobal((*ssbegin).localPosition()).mag()/30.) <= theTofUpperCut ) {
    primary_ionization(*ssbegin, ionization_points, engine); // fills _ionization_points
    drift(*ssbegin, pixdet, bfield, tTopo, ionization_points, collection_points);  // transforms _ionization_points to collection_points
    // compute induced signal on readout elements and add to _signal
    induce_signal(inputBegin, inputEnd, *ssbegin, simHitGlobalIndex, tofBin, pixdet, collection_points); // 1st 3 args needed only for SimHit<-->Digi link
      } //  end if
    } // end for

}

void SiPixelDigitizerAlgorithm::add_noise ( const PixelGeomDetUnit *  pixdet, float  thePixelThreshold, CLHEP::HepRandomEngine *  engine  )

private

Definition at line 1471 of file SiPixelDigitizerAlgorithm.cc.

References _signal, addChargeVCALSmearing, addNoisyPixels, officialStyle::chan, GeomDet::geographicalId(), mps_fire::i, createfilelist::int, LogDebug, PixelTopology::ncolumns(), PixelTopology::nrows(), PixelDigi::pixelToChannel(), DetId::rawId(), PixelGeomDetUnit::specificTopology(), theNoiseInElectrons, theNoiser, theReadoutNoise, theThresholdInE_BPix, and theThresholdInE_FPix.

Referenced by digitize().

                                                                        {

#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " enter add_noise " << theNoiseInElectrons;
#endif

  uint32_t detID= pixdet->geographicalId().rawId();
  signal_map_type& theSignal = _signal[detID];


  // First add noise to hit pixels
  float theSmearedChargeRMS = 0.0;

  for ( signal_map_iterator i = theSignal.begin(); i != theSignal.end(); i++) {

         if(addChargeVCALSmearing)
      {
    if((*i).second < 3000)
      {
        theSmearedChargeRMS = 543.6 - (*i).second * 0.093;
      } else if((*i).second < 6000){
        theSmearedChargeRMS = 307.6 - (*i).second * 0.01;
      } else{
        theSmearedChargeRMS = -432.4 +(*i).second * 0.123;
    }

    // Noise from Vcal smearing:
        float noise_ChargeVCALSmearing = theSmearedChargeRMS * CLHEP::RandGaussQ::shoot(engine, 0., 1.);
    // Noise from full readout:
        float noise  = CLHEP::RandGaussQ::shoot(engine, 0., theReadoutNoise);

        if(((*i).second + Amplitude(noise+noise_ChargeVCALSmearing, -1.)) < 0. ) {
          (*i).second.set(0);}
        else{
    (*i).second +=Amplitude(noise+noise_ChargeVCALSmearing, -1.);
        }

      } // End if addChargeVCalSmearing
     else
     {
    // Noise: ONLY full READOUT Noise.
    // Use here the FULL readout noise, including TBM,ALT,AOH,OPT-REC.
    float noise = CLHEP::RandGaussQ::shoot(engine, 0., theReadoutNoise);

        if(((*i).second + Amplitude(noise, -1.)) < 0. ) {
          (*i).second.set(0);}
        else{
    (*i).second +=Amplitude(noise, -1.);
        }
     } // end if only Noise from full readout

  }

  if(!addNoisyPixels)  // Option to skip noise in non-hit pixels
    return;

  const PixelTopology* topol=&pixdet->specificTopology();
  int numColumns = topol->ncolumns();  // det module number of cols&rows
  int numRows = topol->nrows();

  // Add noise on non-hit pixels
  // Use here the pixel noise
  int numberOfPixels = (numRows * numColumns);
  std::map<int,float, std::less<int> > otherPixels;
  std::map<int,float, std::less<int> >::iterator mapI;

  theNoiser->generate(numberOfPixels,
                      thePixelThreshold, //thr. in un. of nois
              theNoiseInElectrons, // noise in elec.
                      otherPixels,
                      engine );

#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer")
    <<  " Add noisy pixels " << numRows << " "
    << numColumns << " " << theNoiseInElectrons << " "
    << theThresholdInE_FPix << theThresholdInE_BPix <<" "<< numberOfPixels<<" "
    << otherPixels.size() ;
#endif

  // Add noisy pixels
  for (mapI = otherPixels.begin(); mapI!= otherPixels.end(); mapI++) {
    int iy = ((*mapI).first) / numRows;
    int ix = ((*mapI).first) - (iy*numRows);

    // Keep for a while for testing.
    if( iy < 0 || iy > (numColumns-1) )
      LogWarning ("Pixel Geometry") << " error in iy " << iy ;
    if( ix < 0 || ix > (numRows-1) )
      LogWarning ("Pixel Geometry")  << " error in ix " << ix ;

    int chan = PixelDigi::pixelToChannel(ix, iy);

#ifdef TP_DEBUG
    LogDebug ("Pixel Digitizer")
      <<" Storing noise = " << (*mapI).first << " " << (*mapI).second
      << " " << ix << " " << iy << " " << chan ;
#endif

    if(theSignal[chan] == 0){
      //      float noise = float( (*mapI).second );
      int noise=int( (*mapI).second );
      theSignal[chan] = Amplitude (noise, -1.);
    }
  }
}

double SiPixelDigitizerAlgorithm::calcQ ( float  x ) const

inlineprivate

Definition at line 486 of file SiPixelDigitizerAlgorithm.h.

References f, min(), mathSSE::sqrt(), and geometryCSVtoXML::xx.

Referenced by induce_signal().

                                {
      // need erf(x/sqrt2)
      //float x2=0.5*x*x;
      //float a=0.147;
      //double erf=sqrt(1.0f-exp( -1.0f*x2*( (4/M_PI)+a*x2)/(1.0+a*x2)));
      //if (x<0.) erf*=-1.0;
      //return 0.5*(1.0-erf);

      auto xx=std::min(0.5f*x*x,12.5f);
      return 0.5*(1.0-std::copysign(std::sqrt(1.f- unsafe_expf<4>(-xx*(1.f+0.2733f/(1.f+0.147f*xx)) )),x));
    }

void SiPixelDigitizerAlgorithm::calculateInstlumiFactor

(

PileupMixingContent *

puInfo

)

Definition at line 719 of file SiPixelDigitizerAlgorithm.cc.

References PileupMixingContent::getMix_bunchCrossing(), PileupMixingContent::getMix_TrueInteractions(), mps_fire::i, gen::n, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, muons2muons_cfi::pu, SiPixelDigitizerAlgorithm::PixelEfficiencies::pu_scale, SiPixelDigitizerAlgorithm::PixelEfficiencies::theInstLumiScaleFactor, and SiPixelDigitizerAlgorithm::PixelEfficiencies::thePUEfficiency.

Referenced by PreMixingSiPixelWorker::put().

                                                                                  {
  //Instlumi scalefactor calculating for dynamic inefficiency

  if (puInfo) {
    const std::vector<int>& bunchCrossing = puInfo->getMix_bunchCrossing();
    const std::vector<float>& TrueInteractionList = puInfo->getMix_TrueInteractions();      
    //const int bunchSpacing = puInfo->getMix_bunchSpacing();

    int pui = 0, p = 0;
    std::vector<int>::const_iterator pu;
    std::vector<int>::const_iterator pu0 = bunchCrossing.end();
    
    for (pu=bunchCrossing.begin(); pu!=bunchCrossing.end(); ++pu) {
      if (*pu==0) {
    pu0 = pu;
    p = pui;
      }
      pui++;
    }
    if (pu0!=bunchCrossing.end()) {
      for (size_t i=0, n = pixelEfficiencies_.thePUEfficiency.size(); i<n; i++) {
    double instlumi = TrueInteractionList.at(p)*pixelEfficiencies_.theInstLumiScaleFactor;
    double instlumi_pow=1.;
    pixelEfficiencies_.pu_scale[i] = 0;
    for  (size_t j=0; j<pixelEfficiencies_.thePUEfficiency[i].size(); j++){
      pixelEfficiencies_.pu_scale[i]+=instlumi_pow*pixelEfficiencies_.thePUEfficiency[i][j];
      instlumi_pow*=instlumi;
    }
      }
    }
  } 
  else {
    for (int i=0, n = pixelEfficiencies_.thePUEfficiency.size(); i<n; i++) {
      pixelEfficiencies_.pu_scale[i] = 1.;
    }
  }
}

void SiPixelDigitizerAlgorithm::calculateInstlumiFactor	(	const std::vector< PileupSummaryInfo > &	ps,
		int	bunchSpacing
	)

Definition at line 758 of file SiPixelDigitizerAlgorithm.cc.

References mps_fire::i, gen::n, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, SiPixelDigitizerAlgorithm::PixelEfficiencies::pu_scale, SiPixelDigitizerAlgorithm::PixelEfficiencies::theInstLumiScaleFactor, and SiPixelDigitizerAlgorithm::PixelEfficiencies::thePUEfficiency.

                                                                                                                {
  int p = -1;
  for(unsigned int i=0; i<ps.size(); i++)
    if (ps[i].getBunchCrossing() == 0)
      p=i;

  if(p >= 0) {
    for (size_t i=0, n = pixelEfficiencies_.thePUEfficiency.size(); i<n; i++) {
      double instlumi = ps[p].getTrueNumInteractions()*pixelEfficiencies_.theInstLumiScaleFactor;
      double instlumi_pow=1.;
      pixelEfficiencies_.pu_scale[i] = 0;
      for  (size_t j=0; j<pixelEfficiencies_.thePUEfficiency[i].size(); j++){
    pixelEfficiencies_.pu_scale[i]+=instlumi_pow*pixelEfficiencies_.thePUEfficiency[i][j];
    instlumi_pow*=instlumi;
      }
    }
  }
  else {
    for (int i=0, n = pixelEfficiencies_.thePUEfficiency.size(); i<n; i++) {
      pixelEfficiencies_.pu_scale[i] = 1.;
    }
  }
}

void SiPixelDigitizerAlgorithm::digitize	(	const PixelGeomDetUnit *	pixdet,
		std::vector< PixelDigi > &	digis,
		std::vector< PixelDigiSimLink > &	simlinks,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 793 of file SiPixelDigitizerAlgorithm.cc.

References _signal, add_noise(), addNoise, AddPixelInefficiency, addThresholdSmearing, Surface::bounds(), Exception, GeomDet::geographicalId(), GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), TrackerTopology::layer(), LogDebug, make_digis(), module_killing_conf(), module_killing_DB(), PixelTopology::ncolumns(), PixelTopology::nrows(), GeomDetEnumerators::P1PXB, pixel_inefficiency(), pixel_inefficiency_db(), GeomDetEnumerators::PixelBarrel, pixelEfficiencies_, DetId::rawId(), GeomDet::specificSurface(), PixelGeomDetUnit::specificTopology(), GeomDet::subDetector(), theNoiseInElectrons, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, theThresholdSmearing_BPix, theThresholdSmearing_BPix_L1, theThresholdSmearing_BPix_L2, theThresholdSmearing_FPix, Bounds::thickness(), PixelGeomDetUnit::type(), use_deadmodule_DB_, use_ineff_from_db_, and use_module_killing_.

Referenced by PreMixingSiPixelWorker::put().

                                                                       {
  
  // Pixel Efficiency moved from the constructor to this method because
  // the information of the det are not available in the constructor
  // Efficiency parameters. 0 - no inefficiency, 1-low lumi, 10-high lumi
  
  uint32_t detID = pixdet->geographicalId().rawId();
  const signal_map_type& theSignal = _signal[detID];
  
  // Noise already defined in electrons
  // thePixelThresholdInE = thePixelThreshold * theNoiseInElectrons ;
  // Find the threshold in noise units, needed for the noiser.
  

  float thePixelThresholdInE = 0.;
  
  if(theNoiseInElectrons>0.){
    if(pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()){ // Barrel modules
      int lay = tTopo->layer(detID);
      if(addThresholdSmearing) {
    if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelBarrel || pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXB) {
      if (lay==1) {
        thePixelThresholdInE = CLHEP::RandGaussQ::shoot(engine, theThresholdInE_BPix_L1, theThresholdSmearing_BPix_L1); // gaussian smearing
      } else if (lay==2) {
        thePixelThresholdInE = CLHEP::RandGaussQ::shoot(engine, theThresholdInE_BPix_L2, theThresholdSmearing_BPix_L2); // gaussian smearing
      } else {
        thePixelThresholdInE = CLHEP::RandGaussQ::shoot(engine, theThresholdInE_BPix , theThresholdSmearing_BPix); // gaussian smearing
      }
    }
      } else {
    if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelBarrel || pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXB) {
      if (lay==1) {
        thePixelThresholdInE = theThresholdInE_BPix_L1;
      } else if (lay==2) {
        thePixelThresholdInE = theThresholdInE_BPix_L2;
      } else {
        thePixelThresholdInE = theThresholdInE_BPix; // no smearing
      }
    }
      }
    } else if(pixdet->type().isTrackerPixel()) { // Forward disks modules
      if(addThresholdSmearing) {
    thePixelThresholdInE = CLHEP::RandGaussQ::shoot(engine, theThresholdInE_FPix, theThresholdSmearing_FPix); // gaussian smearing
      } else {
    thePixelThresholdInE = theThresholdInE_FPix; // no smearing
      }
    }
    else {throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;}
  }
  

#ifdef TP_DEBUG
  const PixelTopology* topol=&pixdet->specificTopology();  
  int numColumns = topol->ncolumns();  // det module number of cols&rows
  int numRows = topol->nrows();
  // full detector thickness
  float moduleThickness = pixdet->specificSurface().bounds().thickness();
  LogDebug ("PixelDigitizer")
    << " PixelDigitizer "
    << numColumns << " " << numRows << " " << moduleThickness;
#endif
  
  if(addNoise) add_noise(pixdet, thePixelThresholdInE/theNoiseInElectrons, engine);  // generate noise
  
  // Do only if needed
  
  if((AddPixelInefficiency) && (!theSignal.empty()))
    pixel_inefficiency(pixelEfficiencies_, pixdet, tTopo, engine); // Kill some pixels
  
  if(use_ineff_from_db_ && (!theSignal.empty()))
    pixel_inefficiency_db(detID);
  
  if(use_module_killing_) {
    if (use_deadmodule_DB_) {  // remove dead modules using DB
      module_killing_DB(detID);
    } else { // remove dead modules using the list in cfg file
      module_killing_conf(detID);
    }
  }
  
  make_digis(thePixelThresholdInE, detID, pixdet, digis, simlinks, tTopo);
  
#ifdef TP_DEBUG
  LogDebug ("PixelDigitizer") << "[SiPixelDigitizerAlgorithm] converted " << digis.size() << " PixelDigis in DetUnit" << detID;
#endif
}

void SiPixelDigitizerAlgorithm::drift ( const PSimHit &  hit, const PixelGeomDetUnit *  pixdet, const GlobalVector &  bfield, const TrackerTopology *  tTopo, const std::vector< EnergyDepositUnit > &  ionization_points, std::vector< SignalPoint > &  collection_points  ) const

private

Definition at line 1014 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelAging, alpha2Order, Surface::bounds(), PSimHit::detUnitId(), Dist300, DriftDirection(), JetChargeProducer_cfi::exp, mps_fire::i, LogDebug, pixel_aging(), pixelAging_, Sigma0, GeomDet::specificSurface(), mathSSE::sqrt(), Bounds::thickness(), PSimHit::tof(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by accumulateSimHits().

                                                                                       {
  
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " enter drift " ;
#endif
  
  collection_points.resize(ionization_points.size()); // set size
  
  LocalVector driftDir=DriftDirection(pixdet, bfield, hit.detUnitId());  // get the charge drift direction
  if(driftDir.z() ==0.) {
    LogWarning("Magnetic field") << " pxlx: drift in z is zero ";
    return;
  }
  
  // tangent of Lorentz angle
  //float TanLorenzAngleX = driftDir.x()/driftDir.z();
  //float TanLorenzAngleY = 0.; // force to 0, driftDir.y()/driftDir.z();
  
  float TanLorenzAngleX, TanLorenzAngleY,dir_z, CosLorenzAngleX,
    CosLorenzAngleY;
  if( alpha2Order) {
    TanLorenzAngleX = driftDir.x(); // tangen of Lorentz angle
    TanLorenzAngleY = driftDir.y();
    dir_z = driftDir.z(); // The z drift direction
    CosLorenzAngleX = 1./sqrt(1.+TanLorenzAngleX*TanLorenzAngleX); //cosine
    CosLorenzAngleY = 1./sqrt(1.+TanLorenzAngleY*TanLorenzAngleY); //cosine;
    
  } else{ 
    TanLorenzAngleX = driftDir.x();
    TanLorenzAngleY = 0.; // force to 0, driftDir.y()/driftDir.z();
    dir_z = driftDir.z(); // The z drift direction
    CosLorenzAngleX = 1./sqrt(1.+TanLorenzAngleX*TanLorenzAngleX); //cosine to estimate the path length
    CosLorenzAngleY = 1.;
  }
  
  float moduleThickness = pixdet->specificSurface().bounds().thickness();
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer")
    << " Lorentz Tan " << TanLorenzAngleX << " " << TanLorenzAngleY <<" "
    << CosLorenzAngleX << " " << CosLorenzAngleY << " "
    << moduleThickness*TanLorenzAngleX << " " << driftDir;
#endif
  
  float Sigma_x = 1.;  // Charge spread
  float Sigma_y = 1.;
  float DriftDistance; // Distance between charge generation and collection
  float DriftLength;   // Actual Drift Lentgh
  float Sigma;
  
  for (unsigned int i = 0; i != ionization_points.size(); i++) {
    
    float SegX, SegY, SegZ; // position
    SegX = ionization_points[i].x();
    SegY = ionization_points[i].y();
    SegZ = ionization_points[i].z();
    
    // Distance from the collection plane
    //DriftDistance = (moduleThickness/2. + SegZ); // Drift to -z
    // Include explixitely the E drift direction (for CMS dir_z=-1)
    DriftDistance = moduleThickness/2. - (dir_z * SegZ); // Drift to -z
    
    //if( DriftDistance <= 0.)
    //cout<<" <=0 "<<DriftDistance<<" "<<i<<" "<<SegZ<<" "<<dir_z<<" "
    //  <<SegX<<" "<<SegY<<" "<<(moduleThickness/2)<<" "
    //  <<ionization_points[i].energy()<<" "
    //  <<hit.particleType()<<" "<<hit.pabs()<<" "<<hit.energyLoss()<<" "
    //  <<hit.entryPoint()<<" "<<hit.exitPoint()
    //  <<std::endl;
    
    if( DriftDistance < 0.) {
      DriftDistance = 0.;
    } else if( DriftDistance > moduleThickness )
      DriftDistance = moduleThickness;
    
    // Assume full depletion now, partial depletion will come later.
    float XDriftDueToMagField = DriftDistance * TanLorenzAngleX;
    float YDriftDueToMagField = DriftDistance * TanLorenzAngleY;
    
    // Shift cloud center
    float CloudCenterX = SegX + XDriftDueToMagField;
    float CloudCenterY = SegY + YDriftDueToMagField;
    
    // Calculate how long is the charge drift path
    DriftLength = sqrt( DriftDistance*DriftDistance +
                        XDriftDueToMagField*XDriftDueToMagField +
                        YDriftDueToMagField*YDriftDueToMagField );
    
    // What is the charge diffusion after this path
    Sigma = sqrt(DriftLength/Dist300) * Sigma0;
    
    // Project the diffusion sigma on the collection plane
    Sigma_x = Sigma / CosLorenzAngleX ;
    Sigma_y = Sigma / CosLorenzAngleY ;
    
    // Insert a charge loss due to Rad Damage here
    float energyOnCollector = ionization_points[i].energy(); // The energy that reaches the collector
    
    // add pixel aging 
    if (AddPixelAging) {
      float kValue = pixel_aging(pixelAging_,pixdet,tTopo);
      energyOnCollector *= exp( -1*kValue*DriftDistance/moduleThickness );
    }
    
#ifdef TP_DEBUG
    LogDebug ("Pixel Digitizer")
      <<" Dift DistanceZ= "<<DriftDistance<<" module thickness= "<<moduleThickness
      <<" Start Energy= "<<ionization_points[i].energy()<<" Energy after loss= "<<energyOnCollector;
#endif
    SignalPoint sp( CloudCenterX, CloudCenterY,
            Sigma_x, Sigma_y, hit.tof(), energyOnCollector );
    
    // Load the Charge distribution parameters
    collection_points[i] = (sp);
    
  } // loop over ionization points, i.
  
} // end drift

LocalVector SiPixelDigitizerAlgorithm::DriftDirection ( const PixelGeomDetUnit *  pixdet, const GlobalVector &  bfield, const DetId &  detId  ) const

private

Definition at line 1910 of file SiPixelDigitizerAlgorithm.cc.

References alpha2Order, Exception, GeomDet::geographicalId(), SiPixelLorentzAngle::getLorentzAngle(), GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), LogDebug, GloballyPositioned< T >::position(), DetId::rawId(), GloballyPositioned< T >::rotation(), Scenarios_cff::scale, SiPixelLorentzAngle_, GeomDet::surface(), tanLorentzAnglePerTesla_BPix, tanLorentzAnglePerTesla_FPix, PixelGeomDetUnit::type(), and use_LorentzAngle_DB_.

Referenced by drift().

                                                                                {
  Frame detFrame(pixdet->surface().position(),pixdet->surface().rotation());
  LocalVector Bfield=detFrame.toLocal(bfield);
  
  float alpha2_FPix;
  float alpha2_BPix;
  float alpha2;
  
  //float dir_x = -tanLorentzAnglePerTesla * Bfield.y();
  //float dir_y = +tanLorentzAnglePerTesla * Bfield.x();
  //float dir_z = -1.; // E field always in z direction, so electrons go to -z
  // The dir_z has to be +/- 1. !
  // LocalVector theDriftDirection = LocalVector(dir_x,dir_y,dir_z);

  float dir_x = 0.0f;
  float dir_y = 0.0f;
  float dir_z = 0.0f;
  float scale = 0.0f;

  uint32_t detID= pixdet->geographicalId().rawId();


  // Read Lorentz angle from cfg file:**************************************************************

  if(!use_LorentzAngle_DB_){
    
    if( alpha2Order) {
      alpha2_FPix = tanLorentzAnglePerTesla_FPix*tanLorentzAnglePerTesla_FPix;
      alpha2_BPix = tanLorentzAnglePerTesla_BPix*tanLorentzAnglePerTesla_BPix;
    }else {
      alpha2_FPix = 0.0f;
      alpha2_BPix = 0.0f;
    }
    
    if(pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()){// barrel layers
      dir_x = -( tanLorentzAnglePerTesla_BPix * Bfield.y() + alpha2_BPix* Bfield.z()* Bfield.x() );
      dir_y = +( tanLorentzAnglePerTesla_BPix * Bfield.x() - alpha2_BPix* Bfield.z()* Bfield.y() );
      dir_z = -(1 + alpha2_BPix* Bfield.z()*Bfield.z() );
      scale = -dir_z;
    } else if (pixdet->type().isTrackerPixel()) {// forward disks
      dir_x = -( tanLorentzAnglePerTesla_FPix * Bfield.y() + alpha2_FPix* Bfield.z()* Bfield.x() );
      dir_y = +( tanLorentzAnglePerTesla_FPix * Bfield.x() - alpha2_FPix* Bfield.z()* Bfield.y() );
      dir_z = -(1 + alpha2_FPix* Bfield.z()*Bfield.z() );
      scale = -dir_z;
    } else {
      throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
    }
  } // end: Read LA from cfg file.
  
  //Read Lorentz angle from DB:********************************************************************
  if(use_LorentzAngle_DB_){
    float lorentzAngle = SiPixelLorentzAngle_->getLorentzAngle(detId);
    alpha2 = lorentzAngle * lorentzAngle;
    //std::cout << "detID is: "<< it->first <<"The LA per tesla is: "<< it->second << std::std::endl;
    dir_x = -( lorentzAngle * Bfield.y() + alpha2 * Bfield.z()* Bfield.x() );
    dir_y = +( lorentzAngle * Bfield.x() - alpha2 * Bfield.z()* Bfield.y() );
    dir_z = -(1 + alpha2 * Bfield.z()*Bfield.z() );
    scale = -dir_z;
  }// end: Read LA from DataBase.
  
  LocalVector theDriftDirection = LocalVector(dir_x/scale, dir_y/scale, dir_z/scale );
  
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " The drift direction in local coordinate is "
                   << theDriftDirection ;
#endif
  
  return theDriftDirection;
}

void SiPixelDigitizerAlgorithm::fluctuateEloss ( int  particleId, float  momentum, float  eloss, float  length, int  NumberOfSegments, float  elossVector[], CLHEP::HepRandomEngine *  engine  ) const

private

Definition at line 959 of file SiPixelDigitizerAlgorithm.cc.

References funct::abs(), fluctuate, mps_fire::i, cuy::ii, particleFlowDisplacedVertex_cfi::ratio, and tMax.

Referenced by primary_ionization().

                                                                                   {
  
  // Get dedx for this track
  //float dedx;
  //if( length > 0.) dedx = eloss/length;
  //else dedx = eloss;
  
  double particleMass = 139.6; // Mass in MeV, Assume pion
  pid = std::abs(pid);
  if(pid!=211) {       // Mass in MeV
    if(pid==11)        particleMass = 0.511;
    else if(pid==13)   particleMass = 105.7;
    else if(pid==321)  particleMass = 493.7;
    else if(pid==2212) particleMass = 938.3;
  }
  // What is the track segment length.
  float segmentLength = length/NumberOfSegs;
  
  // Generate charge fluctuations.
  float de=0.;
  float sum=0.;
  double segmentEloss = (1000.*eloss)/NumberOfSegs; //eloss in MeV
  for (int i=0;i<NumberOfSegs;i++) {
    //       material,*,   momentum,energy,*, *,  mass
    //myglandz_(14.,segmentLength,2.,2.,dedx,de,0.14);
    // The G4 routine needs momentum in MeV, mass in Mev, delta-cut in MeV,
    // track segment length in mm, segment eloss in MeV
    // Returns fluctuated eloss in MeV
    double deltaCutoff = tMax; // the cutoff is sometimes redefined inside, so fix it.
    de = fluctuate->SampleFluctuations(double(particleMomentum*1000.),
                       particleMass, deltaCutoff,
                       double(segmentLength*10.),
                                       segmentEloss, engine )/1000.; //convert to GeV 
    elossVector[i]=de;
    sum +=de;
  }
  
  if(sum>0.) {  // If fluctuations give eloss>0.
    // Rescale to the same total eloss
    float ratio = eloss/sum;
    
    for (int ii=0;ii<NumberOfSegs;ii++) elossVector[ii]= ratio*elossVector[ii];
  } else {  // If fluctuations gives 0 eloss
    float averageEloss = eloss/NumberOfSegs;
    for (int ii=0;ii<NumberOfSegs;ii++) elossVector[ii]= averageEloss;
  }
  return;
}

bool SiPixelDigitizerAlgorithm::hitSignalReweight ( const PSimHit &  hit, std::map< int, float, std::less< int > > &  hit_signal, const size_t  hitIndex, const unsigned int  tofBin, const PixelTopology *  topol, uint32_t  detID, signal_map_type &  theSignal, unsigned short int  processType  )

private

Definition at line 2121 of file SiPixelDigitizerAlgorithm.cc.

References officialStyle::chan, PixelDigi::channelToPixel(), ALCARECOTkAlJpsiMuMu_cff::charge, cuy::col, gather_cfg::cout, dbobject_den, dbobject_num, PSimHit::entryPoint(), PSimHit::exitPoint(), SiPixel2DTemplateDBObject::getTemplateID(), IDden, createfilelist::int, PixelTopology::isItBigPixelInX(), PixelTopology::isItBigPixelInY(), PSimHit::localPosition(), Topology::localPosition(), LogDebug, makeDigiSimLinks_, genParticles_cff::map, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PSimHit::particleType(), PixelTempRewgt2D(), PixelDigi::pixelToChannel(), printCluster(), PrintClusters, PSimHit::processType(), THX, THY, track, TXSIZE, TYSIZE, UseReweighting, PV2DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::x(), xdouble, PV2DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::y(), ydouble, and PV3DBase< T, PVType, FrameType >::z().

Referenced by induce_signal().

                                                         {

  int irow_min = topol->nrows();
  int irow_max = 0;
  int icol_min = topol->ncolumns();
  int icol_max = 0;
     
  float chargeBefore = 0;
  float chargeAfter = 0;
  signal_map_type hitSignal;
  LocalVector direction = hit.exitPoint() - hit.entryPoint();
  
  for ( std::map< int, float, std::less<int> >::const_iterator im = hit_signal.begin(); im != hit_signal.end(); ++im) {
    int chan =  (*im).first;
    std::pair<int,int> pixelWithCharge = PixelDigi::channelToPixel( chan);
    //std::cout << "PixelHit - x: " << pixelWithCharge.first << " y: " << pixelWithCharge.second << "  With Charge:  " << (*im).second <<  std::endl;
    
    hitSignal[chan] += (makeDigiSimLinks_ ? Amplitude( (*im).second, &hit, hitIndex, tofBin, (*im).second) : Amplitude( (*im).second, (*im).second) )  ;
    chargeBefore += (*im).second;
    
    if(pixelWithCharge.first < irow_min)
      irow_min = pixelWithCharge.first;
    if(pixelWithCharge.first > irow_max)
      irow_max = pixelWithCharge.first;
    if(pixelWithCharge.second < icol_min)
      icol_min = pixelWithCharge.second;
    if(pixelWithCharge.second > icol_max)
      icol_max = pixelWithCharge.second;
  }
  
  LocalPoint hitEntryPoint = hit.entryPoint();
  
  float trajectoryScaleToPosition = hitEntryPoint.z()/direction.z();
  
  if( (hitEntryPoint.z() > 0 && direction.z() < 0) || (hitEntryPoint.z() < 0 && direction.z() > 0) ){
    trajectoryScaleToPosition *= -1;
  }
  
  LocalPoint hitPosition = hitEntryPoint + trajectoryScaleToPosition * direction;  

  MeasurementPoint hitPositionPixel = topol->measurementPosition(hit.localPosition() );
  std::pair<int,int> hitPixel = std::pair<int,int>( int( floor(hitPositionPixel.x() ) ), int ( floor(hitPositionPixel.y() ) ));
  
  MeasurementPoint originPixel = MeasurementPoint(hitPixel.first - THX + 0.5, hitPixel.second - THY + 0.5);
  LocalPoint origin = topol->localPosition(originPixel);
  
  MeasurementPoint hitEntryPointPixel = topol->measurementPosition(hit.entryPoint() );
  MeasurementPoint hitExitPointPixel = topol->measurementPosition(hit.exitPoint() );
  std::pair<int,int> entryPixel = std::pair<int,int>( int( floor(hitEntryPointPixel.x() ) ), int ( floor(hitEntryPointPixel.y() ) ));
  std::pair<int,int> exitPixel = std::pair<int,int>( int( floor(hitExitPointPixel.x() ) ), int ( floor(hitExitPointPixel.y() ) ));

  int hitcol_min, hitcol_max, hitrow_min, hitrow_max;
  if(entryPixel.first>exitPixel.first){
    hitrow_min = exitPixel.first;
    hitrow_max = entryPixel.first;
  }else{
    hitrow_min = entryPixel.first;
    hitrow_max = exitPixel.first;
  }

  if(entryPixel.second>exitPixel.second){
    hitcol_min = exitPixel.second;
    hitcol_max = entryPixel.second;
  }else{
    hitcol_min = entryPixel.second;
    hitcol_max = exitPixel.second;
  }

  
#ifdef TP_DEBUG
  LocalPoint CMSSWhitPosition = hit.localPosition();

  LogDebug ("Pixel Digitizer")
  << "\n"
  << "Particle ID is: " << hit.particleType() << "\n"
  << "Process type: " << hit.processType() << "\n"
  << "HitPosition:" << "\n"
  << "Hit entry x/y/z: " << hit.entryPoint().x() << "  " << hit.entryPoint().y() << "  " << hit.entryPoint().z() << "  "
  << "Hit exit x/y/z: " << hit.exitPoint().x() << "  " << hit.exitPoint().y() << "  " << hit.exitPoint().z() << "  "

  << "Pixel Pos - X: " << hitPositionPixel.x() << " Y: " << hitPositionPixel.y() << "\n"
  << "Cart.Cor. - X: " << CMSSWhitPosition.x() << " Y: " << CMSSWhitPosition.y() << "\n"
  << "Z=0 Pos - X: " << hitPosition.x() << " Y: " << hitPosition.y() << "\n"
  
  << "Origin of the template:" << "\n"
  << "Pixel Pos - X: " << originPixel.x() << " Y: " << originPixel.y() << "\n"
  << "Cart.Cor. - X: " << origin.x() << " Y: " << origin.y() << "\n"
  << "\n"
  << "Entry/Exit:" << "\n"
  << "Entry - X: " << hit.entryPoint().x() << " Y: " << hit.entryPoint().y() << " Z: " << hit.entryPoint().z() << "\n"
  << "Exit - X: " << hit.exitPoint().x() << " Y: " << hit.exitPoint().y() << " Z: " << hit.exitPoint().z() << "\n"
  
  << "Entry - X Pixel: " << hitEntryPointPixel.x() << " Y Pixel: " << hitEntryPointPixel.y() << "\n"
  << "Exit - X Pixel: " << hitExitPointPixel.x() << " Y Pixel: " << hitExitPointPixel.y() << "\n"
  
  << "row min: " << irow_min << " col min: " << icol_min << "\n";
#endif

  if(!(irow_min<=hitrow_max && irow_max>=hitrow_min && icol_min<=hitcol_max && icol_max>=hitcol_min)){
    // The clusters do not have an overlap, hence the hit is NOT reweighted
    return false;
  }

  
  float cmToMicrons = 10000.f;
  
  track[0] = (hitPosition.x() - origin.x() )*cmToMicrons;
  track[1] = (hitPosition.y() - origin.y() )*cmToMicrons;
  track[2] = 0.0f; //Middle of sensor is origin for Z-axis
  track[3] = direction.x();
  track[4] = direction.y();
  track[5] = direction.z();
  
  array_2d pixrewgt(boost::extents[TXSIZE][TYSIZE]);

  for(int row = 0; row < TXSIZE; ++row) {
    for(int col = 0; col < TYSIZE; ++col) {
      pixrewgt[row][col] = 0;
    }
  }
  
  for(int row = 0; row < TXSIZE; ++row) {
    xdouble[row] = topol->isItBigPixelInX(hitPixel.first + row - THX);
  }
  
  for(int col = 0; col < TYSIZE; ++col) {
    ydouble[col] = topol->isItBigPixelInY(hitPixel.second + col - THY);
  }

  for(int row = 0; row < TXSIZE; ++row) {
    for(int col = 0; col < TYSIZE; ++col) {
      //Fill charges into 21x13 Pixel Array with hitPixel in centre
      pixrewgt[row][col] = hitSignal[PixelDigi::pixelToChannel(hitPixel.first + row - THX, hitPixel.second + col - THY)];
      //std::cout << "Signal in " << hitPixel.first + row - THX << "/" << hitPixel.second + col - THY << " is " << hitSignal[PixelDigi::pixelToChannel(hitPixel.first + row - THX, hitPixel.second + col - THY)] << std::endl;
    }
  }
    
  if(PrintClusters){
    std::cout << "Cluster before reweighting: " << std::endl;
    printCluster(pixrewgt);  
  }

  int ierr;
  // for unirradiated: 2nd argument is IDden
  // for irradiated: 2nd argument is IDnum
  if (UseReweighting == true){
    int ID1 = dbobject_num->getTemplateID(detID);
    int ID0 = dbobject_den->getTemplateID(detID);

    if(ID0==ID1){
      return false;
    }
    ierr = PixelTempRewgt2D(ID0, ID1, pixrewgt);
  }
  else{
    ierr = PixelTempRewgt2D(IDden, IDden, pixrewgt);
  }
  if (ierr!=0){
#ifdef TP_DEBUG 
    LogDebug ("PixelDigitizer ") << "Cluster Charge Reweighting did not work properly.";
#endif
    return false;
  }
  
  if(PrintClusters){
    std::cout << "Cluster after reweighting: " << std::endl;  
    printCluster(pixrewgt);
  }
  
  for(int row = 0; row < TXSIZE; ++row) { 
    for(int col = 0; col < TYSIZE; ++col) {
      float charge = 0;
      charge = pixrewgt[row][col];
      if( (hitPixel.first + row - THX) >= 0 && (hitPixel.first + row - THX) < topol->nrows() && (hitPixel.second + col - THY) >= 0 && (hitPixel.second + col - THY) < topol->ncolumns() && charge > 0){
    chargeAfter += charge;
    theSignal[PixelDigi::pixelToChannel(hitPixel.first + row - THX, hitPixel.second + col - THY)] += (makeDigiSimLinks_ ? Amplitude(charge , &hit, hitIndex, tofBin, charge) : Amplitude( charge, charge) )  ;
      }
    }
  }

  if(chargeBefore!=0. && chargeAfter==0.){
    return false;
  }
  
  if(PrintClusters){
    std::cout << std::endl;
    std::cout << "Charges (before->after): " << chargeBefore << " -> " << chargeAfter << std::endl;
    std::cout << "Charge loss: " << (1 - chargeAfter/chargeBefore)*100 << " %" << std::endl << std::endl;
  }

  return true;

}

void SiPixelDigitizerAlgorithm::induce_signal ( std::vector< PSimHit >::const_iterator  inputBegin, std::vector< PSimHit >::const_iterator  inputEnd, const PSimHit &  hit, const size_t  hitIndex, const unsigned int  tofBin, const PixelGeomDetUnit *  pixdet, const std::vector< SignalPoint > &  collection_points  )

private

Definition at line 1139 of file SiPixelDigitizerAlgorithm.cc.

References _signal, calcQ(), officialStyle::chan, Topology::channel(), PixelDigi::channelToPixel(), ClusterWidth, GeomDet::geographicalId(), hitSignalReweight(), mps_fire::i, createfilelist::int, Topology::localPosition(), LogDebug, makeDigiSimLinks_, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PixelTopology::pitch(), PixelDigi::pixelToChannel(), PSimHit::processType(), DetId::rawId(), gun_cff::SigmaX, gun_cff::SigmaY, PixelGeomDetUnit::specificTopology(), UseReweighting, x, PV2DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::x(), y, PV2DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by accumulateSimHits().

                                                                                               {

  // X  - Rows, Left-Right, 160, (1.6cm)   for barrel
  // Y  - Columns, Down-Up, 416, (6.4cm)

   const PixelTopology* topol=&pixdet->specificTopology();
   uint32_t detID= pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];

#ifdef TP_DEBUG
    LogDebug ("Pixel Digitizer")
      << " enter induce_signal, "
      << topol->pitch().first << " " << topol->pitch().second; //OK
#endif

   // local map to store pixels hit by 1 Hit.
   typedef std::map< int, float, std::less<int> > hit_map_type;
   hit_map_type hit_signal;

   // map to store pixel integrals in the x and in the y directions
   std::map<int, float, std::less<int> > x,y;

   // Assign signals to readout channels and store sorted by channel number

   // Iterate over collection points on the collection plane
   for ( std::vector<SignalPoint>::const_iterator i=collection_points.begin();
     i != collection_points.end(); ++i) {

     float CloudCenterX = i->position().x(); // Charge position in x
     float CloudCenterY = i->position().y(); //                 in y
     float SigmaX = i->sigma_x();            // Charge spread in x
     float SigmaY = i->sigma_y();            //               in y
     float Charge = i->amplitude();          // Charge amplitude


     //if(SigmaX==0 || SigmaY==0) {
     //cout<<SigmaX<<" "<<SigmaY
     //   << " cloud " << i->position().x() << " " << i->position().y() << " "
     //   << i->sigma_x() << " " << i->sigma_y() << " " << i->amplitude()<<std::endl;
     //}

#ifdef TP_DEBUG
       LogDebug ("Pixel Digitizer")
     << " cloud " << i->position().x() << " " << i->position().y() << " "
     << i->sigma_x() << " " << i->sigma_y() << " " << i->amplitude();
#endif

     // Find the maximum cloud spread in 2D plane , assume 3*sigma
     float CloudRight = CloudCenterX + ClusterWidth*SigmaX;
     float CloudLeft  = CloudCenterX - ClusterWidth*SigmaX;
     float CloudUp    = CloudCenterY + ClusterWidth*SigmaY;
     float CloudDown  = CloudCenterY - ClusterWidth*SigmaY;

     // Define 2D cloud limit points
     LocalPoint PointRightUp  = LocalPoint(CloudRight,CloudUp);
     LocalPoint PointLeftDown = LocalPoint(CloudLeft,CloudDown);

     // This points can be located outside the sensor area.
     // The conversion to measurement point does not check for that
     // so the returned pixel index might be wrong (outside range).
     // We rely on the limits check below to fix this.
     // But remember whatever we do here THE CHARGE OUTSIDE THE ACTIVE
     // PIXEL AREA IS LOST, it should not be collected.

     // Convert the 2D points to pixel indices
     MeasurementPoint mp = topol->measurementPosition(PointRightUp ); //OK

     int IPixRightUpX = int( floor( mp.x()));
     int IPixRightUpY = int( floor( mp.y()));

#ifdef TP_DEBUG
     LogDebug ("Pixel Digitizer") << " right-up " << PointRightUp << " "
                  << mp.x() << " " << mp.y() << " "
                  << IPixRightUpX << " " << IPixRightUpY ;
#endif

     mp = topol->measurementPosition(PointLeftDown ); //OK

     int IPixLeftDownX = int( floor( mp.x()));
     int IPixLeftDownY = int( floor( mp.y()));

#ifdef TP_DEBUG
     LogDebug ("Pixel Digitizer") << " left-down " << PointLeftDown << " "
                  << mp.x() << " " << mp.y() << " "
                  << IPixLeftDownX << " " << IPixLeftDownY ;
#endif

     // Check detector limits to correct for pixels outside range.
     int numColumns = topol->ncolumns();  // det module number of cols&rows
     int numRows = topol->nrows();

     IPixRightUpX = numRows>IPixRightUpX ? IPixRightUpX : numRows-1 ;
     IPixRightUpY = numColumns>IPixRightUpY ? IPixRightUpY : numColumns-1 ;
     IPixLeftDownX = 0<IPixLeftDownX ? IPixLeftDownX : 0 ;
     IPixLeftDownY = 0<IPixLeftDownY ? IPixLeftDownY : 0 ;

     x.clear(); // clear temporary integration array
     y.clear();

     // First integrate charge strips in x
     int ix; // TT for compatibility
     for (ix=IPixLeftDownX; ix<=IPixRightUpX; ix++) {  // loop over x index
       float xUB, xLB, UpperBound, LowerBound;

       // Why is set to 0 if ix=0, does it meen that we accept charge
       // outside the sensor? CHeck How it was done in ORCA?
       //if(ix == 0) LowerBound = 0.;
       if(ix == 0 || SigmaX==0. )  // skip for surface segemnts
     LowerBound = 0.;
       else {
     mp = MeasurementPoint( float(ix), 0.0);
     xLB = topol->localPosition(mp).x();
     LowerBound = 1-calcQ((xLB-CloudCenterX)/SigmaX);
       }

       if(ix == numRows-1 || SigmaX==0. )
     UpperBound = 1.;
       else {
     mp = MeasurementPoint( float(ix+1), 0.0);
     xUB = topol->localPosition(mp).x();
     UpperBound = 1. - calcQ((xUB-CloudCenterX)/SigmaX);
       }

       float   TotalIntegrationRange = UpperBound - LowerBound; // get strip
       x[ix] = TotalIntegrationRange; // save strip integral
       //if(SigmaX==0 || SigmaY==0)
       //cout<<TotalIntegrationRange<<" "<<ix<<std::endl;

     }

    // Now integrate strips in y
    int iy; // TT for compatibility
    for (iy=IPixLeftDownY; iy<=IPixRightUpY; iy++) { //loope over y ind
      float yUB, yLB, UpperBound, LowerBound;

      if(iy == 0 || SigmaY==0.)
    LowerBound = 0.;
      else {
        mp = MeasurementPoint( 0.0, float(iy) );
        yLB = topol->localPosition(mp).y();
    LowerBound = 1. - calcQ((yLB-CloudCenterY)/SigmaY);
      }

      if(iy == numColumns-1 || SigmaY==0. )
    UpperBound = 1.;
      else {
        mp = MeasurementPoint( 0.0, float(iy+1) );
        yUB = topol->localPosition(mp).y();
    UpperBound = 1. - calcQ((yUB-CloudCenterY)/SigmaY);
      }

      float   TotalIntegrationRange = UpperBound - LowerBound;
      y[iy] = TotalIntegrationRange; // save strip integral
      //if(SigmaX==0 || SigmaY==0)
      //cout<<TotalIntegrationRange<<" "<<iy<<std::endl;
    }

    // Get the 2D charge integrals by folding x and y strips
    int chan;
    for (ix=IPixLeftDownX; ix<=IPixRightUpX; ix++) {  // loop over x index
      for (iy=IPixLeftDownY; iy<=IPixRightUpY; iy++) { //loope over y ind

        float ChargeFraction = Charge*x[ix]*y[iy];

        if( ChargeFraction > 0. ) {
      chan = PixelDigi::pixelToChannel( ix, iy);  // Get index
          // Load the amplitude
          hit_signal[chan] += ChargeFraction;
    } // endif


    mp = MeasurementPoint( float(ix), float(iy) );
    LocalPoint lp = topol->localPosition(mp);
    chan = topol->channel(lp);

#ifdef TP_DEBUG
    LogDebug ("Pixel Digitizer")
      << " pixel " << ix << " " << iy << " - "<<" "
      << chan << " " << ChargeFraction<<" "
      << mp.x() << " " << mp.y() <<" "
      << lp.x() << " " << lp.y() << " "  // givex edge position
      << chan; // edge belongs to previous ?
#endif

      } // endfor iy
    } //endfor ix


  } // loop over charge distributions

  // Fill the global map with all hit pixels from this event

   bool reweighted = false;
   if (UseReweighting){
     if(hit.processType()==0){
       reweighted = hitSignalReweight (hit, hit_signal, hitIndex, tofBin, topol, detID, theSignal, hit.processType());
     }else{
       // If it's not the primary particle, use the first hit in the collection as SimHit, which should be the corresponding primary.
       reweighted = hitSignalReweight ((*inputBegin), hit_signal, hitIndex, tofBin, topol, detID, theSignal, hit.processType());
     }
   }
   if (!reweighted){
     for ( hit_map_type::const_iterator im = hit_signal.begin();
       im != hit_signal.end(); ++im) {
       int chan =  (*im).first;
       theSignal[chan] += (makeDigiSimLinks_ ? Amplitude( (*im).second, &hit, hitIndex, tofBin, (*im).second) : Amplitude( (*im).second, (*im).second) )  ;
       
#ifdef TP_DEBUG
       std::pair<int,int> ip = PixelDigi::channelToPixel(chan);
       LogDebug ("Pixel Digitizer")
     << " pixel " << ip.first << " " << ip.second << " "
     << theSignal[chan];
#endif
     }
   }

} // end induce_signal

void SiPixelDigitizerAlgorithm::init

(

const edm::EventSetup &

es

)

Definition at line 115 of file SiPixelDigitizerAlgorithm.cc.

References edm::EventSetup::get(), map_, SiPixel2DTemplateDBObject::numOfTempl(), edm::ESHandle< T >::product(), SiPixelTemplate2D::pushfile(), HiIsolationCommonParameters_cff::track, and HIPAlignmentAlgorithm_cfi::UseReweighting.

Referenced by PreMixingSiPixelWorker::initializeEvent().

                                                            {
  if(use_ineff_from_db_){// load gain calibration service fromdb...
    theSiPixelGainCalibrationService_->setESObjects( es );
  }
  if(use_deadmodule_DB_) {
    es.get<SiPixelQualityRcd>().get(SiPixelBadModule_);
  }
  if(use_LorentzAngle_DB_) {
    // Get Lorentz angle from DB record
    es.get<SiPixelLorentzAngleSimRcd>().get(SiPixelLorentzAngle_);
  }
  //gets the map and geometry from the DB (to kill ROCs)
  es.get<SiPixelFedCablingMapRcd>().get(map_);
  es.get<TrackerDigiGeometryRecord>().get(geom_);

  // Read template files for charge reweighting
  if (UseReweighting){
    edm::ESHandle<SiPixel2DTemplateDBObject> SiPixel2DTemp_den;
    es.get<SiPixel2DTemplateDBObjectRcd>().get("denominator",SiPixel2DTemp_den);
    dbobject_den = SiPixel2DTemp_den.product();
    
    edm::ESHandle<SiPixel2DTemplateDBObject> SiPixel2DTemp_num;
    es.get<SiPixel2DTemplateDBObjectRcd>().get("numerator",SiPixel2DTemp_num);
    dbobject_num = SiPixel2DTemp_num.product();
    
    int numOfTemplates = dbobject_den->numOfTempl()+dbobject_num->numOfTempl();
    templateStores_.reserve(numOfTemplates);
    SiPixelTemplate2D::pushfile(*dbobject_den, templateStores_);
    SiPixelTemplate2D::pushfile(*dbobject_num, templateStores_);
    
    track.reserve(6);
  }
}

void SiPixelDigitizerAlgorithm::init_DynIneffDB	(	const edm::EventSetup &	es,
		const unsigned int &	bunchspace
	)

Definition at line 523 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelInefficiency, SiPixelDigitizerAlgorithm::PixelEfficiencies::FromConfig, geom_, edm::EventSetup::get(), SiPixelDigitizerAlgorithm::PixelEfficiencies::init_from_db(), pixelEfficiencies_, and SiPixelDynamicInefficiency_.

Referenced by PreMixingSiPixelWorker::put().

                                                                                                      {
  if (AddPixelInefficiency&&!pixelEfficiencies_.FromConfig) {
    if (bunchspace == 50) es.get<SiPixelDynamicInefficiencyRcd>().get("50ns",SiPixelDynamicInefficiency_);
    else es.get<SiPixelDynamicInefficiencyRcd>().get(SiPixelDynamicInefficiency_);
    pixelEfficiencies_.init_from_db(geom_, SiPixelDynamicInefficiency_);
  }
}

std::map< int, SiPixelDigitizerAlgorithm::CalParameters, std::less< int > > SiPixelDigitizerAlgorithm::initCal ( ) const

private

Definition at line 302 of file SiPixelDigitizerAlgorithm.cc.

References calmap, MessageLogger_cfi::cerr, officialStyle::chan, PixelIndices::channelToPixelROC(), gather_cfg::cout, corrVsCorr::filename, mps_fire::i, recoMuon::in, create_public_lumi_plots::in_file, geometryCSVtoXML::line, LogDebug, dataset::name, AlCaHLTBitMon_ParallelJobs::p, SiPixelDigitizerAlgorithm::CalParameters::p0, SiPixelDigitizerAlgorithm::CalParameters::p1, SiPixelDigitizerAlgorithm::CalParameters::p2, SiPixelDigitizerAlgorithm::CalParameters::p3, RecoTauPiZeroBuilderPlugins_cfi::par0, RecoTauPiZeroBuilderPlugins_cfi::par1, PixelIndices::pixelToChannelROC(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                         {

  using std::cerr;
  using std::cout;
  using std::endl;

  std::map<int, SiPixelDigitizerAlgorithm::CalParameters, std::less<int> > calmap;
  // Prepare for the analog amplitude miss-calibration
  LogDebug ("PixelDigitizer ")
    << " miss-calibrate the pixel amplitude ";

  const bool ReadCalParameters = false;
  if(ReadCalParameters) {   // Read the calibration files from file
    // read the calibration constants from a file (testing only)
    std::ifstream in_file;  // data file pointer
    char filename[80] = "phCalibrationFit_C0.dat";

    in_file.open(filename, std::ios::in ); // in C++
    if(in_file.bad()) {
      cout << " File not found " << endl;
      return calmap; // signal error
    }
    cout << " file opened : " << filename << endl;

    char line[500];
    for (int i = 0; i < 3; i++) {
      in_file.getline(line, 500,'\n');
      cout<<line<<endl;
    }

    cout << " test map" << endl;

    float par0,par1,par2,par3;
    int colid,rowid;
    std::string name;
    // Read MC tracks
    for(int i=0;i<(52*80);i++)  { // loop over tracks
      in_file >> par0 >> par1 >> par2 >> par3 >> name >> colid >> rowid;
      if(in_file.bad()) { // check for errors
        cerr << "Cannot read data file" << endl;
        return calmap;
      }
      if( in_file.eof() != 0 ) {
        cerr << in_file.eof() << " " << in_file.gcount() << " "
             << in_file.fail() << " " << in_file.good() << " end of file "
             << endl;
        return calmap;
      }

      //cout << " line " << i << " " <<par0<<" "<<par1<<" "<<par2<<" "<<par3<<" "
      //   <<colid<<" "<<rowid<<endl;

      CalParameters onePix;
      onePix.p0=par0;
      onePix.p1=par1;
      onePix.p2=par2;
      onePix.p3=par3;

      // Convert ROC pixel index to channel
      int chan = PixelIndices::pixelToChannelROC(rowid,colid);
      calmap.insert(std::pair<int,CalParameters>(chan,onePix));

      // Testing the index conversion, can be skipped
      std::pair<int,int> p = PixelIndices::channelToPixelROC(chan);
      if(rowid!=p.first) cout<<" wrong channel row "<<rowid<<" "<<p.first<<endl;
      if(colid!=p.second) cout<<" wrong channel col "<<colid<<" "<<p.second<<endl;

    } // pixel loop in a ROC

    cout << " map size  " << calmap.size() <<" max "<<calmap.max_size() << " "
         <<calmap.empty()<< endl;

//     cout << " map size  " << calmap.size()  << endl;
//     map<int,CalParameters,std::less<int> >::iterator ix,it;
//     map<int,CalParameters,std::less<int> >::const_iterator ip;
//     for (ix = calmap.begin(); ix != calmap.end(); ++ix) {
//       int i = (*ix).first;
//       std::pair<int,int> p = channelToPixelROC(i);
//       it  = calmap.find(i);
//       CalParameters y  = (*it).second;
//       CalParameters z = (*ix).second;
//       cout << i <<" "<<p.first<<" "<<p.second<<" "<<y.p0<<" "<<z.p0<<" "<<calmap[i].p0<<endl;

//       //int dummy=0;
//       //cin>>dummy;
//     }

  } // end if readparameters
  return calmap;
} // end initCal()

void SiPixelDigitizerAlgorithm::initializeEvent ( )

inline

Definition at line 59 of file SiPixelDigitizerAlgorithm.h.

References genParticles_cff::map.

Referenced by PreMixingSiPixelWorker::initializeEvent().

                         {
    _signal.clear();
  }

void SiPixelDigitizerAlgorithm::make_digis ( float  thePixelThresholdInE, uint32_t  detID, const PixelGeomDetUnit *  pixdet, std::vector< PixelDigi > &  digis, std::vector< PixelDigiSimLink > &  simlinks, const TrackerTopology *  tTopo  ) const

private

Definition at line 1366 of file SiPixelDigitizerAlgorithm.cc.

References _signal, ecalMGPA::adc(), officialStyle::chan, PixelDigi::channelToPixel(), cuy::col, doMissCalibrate, f, runEdmFileComparison::found, dedxEstimators_cff::fraction, mps_fire::i, info(), createfilelist::int, LogDebug, makeDigiSimLinks_, min(), missCalibrate(), GeomDetEnumerators::P2OTB, mcMuonSeeds_cfi::SimTrack, GeomDet::subDetector(), theAdcFullScale, theAdcFullScaleStack, theElectronPerADC, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, and theThresholdInE_FPix.

Referenced by digitize().

                                                            {

#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " make digis "<<" "
                   << " pixel threshold FPix" << theThresholdInE_FPix << " "
                               << " pixel threshold BPix" << theThresholdInE_BPix << " "
                               << " pixel threshold BPix Layer1" << theThresholdInE_BPix_L1 << " "
                               << " pixel threshold BPix Layer2" << theThresholdInE_BPix_L2 << " "
                   << " List pixels passing threshold ";
#endif

  // Loop over hit pixels

  signalMaps::const_iterator it = _signal.find(detID);
  if (it == _signal.end()) {
    return;
  }

  const signal_map_type& theSignal = (*it).second;

  // unsigned long is enough to store SimTrack id and EncodedEventId
  using TrackEventId = std::pair<decltype(SimTrack().trackId()), decltype(EncodedEventId().rawId())>;
  std::map<TrackEventId, float> simi; // re-used

  for (signal_map_const_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {

    float signalInElectrons = (*i).second ;   // signal in electrons

    // Do the miss calibration for calibration studies only.
    //if(doMissCalibrate) signalInElectrons = missCalibrate(signalInElectrons)

    // Do only for pixels above threshold

    if( signalInElectrons >= thePixelThresholdInE && signalInElectrons > 0.) { // check threshold, always reject killed (0-charge) digis

      int chan =  (*i).first;  // channel number
      std::pair<int,int> ip = PixelDigi::channelToPixel(chan);
      int adc=0;  // ADC count as integer

      // Do the miss calibration for calibration studies only.
      if(doMissCalibrate) {
    int row = ip.first;  // X in row
    int col = ip.second; // Y is in col
    adc = int(missCalibrate(detID, tTopo, pixdet, col, row, signalInElectrons)); //full misscalib.
      } else { // Just do a simple electron->adc conversion
    adc = int( signalInElectrons / theElectronPerADC ); // calibrate gain
      }
      adc = std::min(adc, theAdcFullScale); // Check maximum value
// Calculate layerIndex
     if (theAdcFullScale!=theAdcFullScaleStack){
       if(pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTB) { // Phase 2 OT Barrel only
     // Set to 1 if over the threshold
     if (theAdcFullScaleStack==1) {adc=1;}
     // Make it a linear fit to the full scale of the normal adc count.   Start new adc from 1 not zero.
     if (theAdcFullScaleStack!=1&&theAdcFullScaleStack!=theAdcFullScale) {adc = int (1 + adc * (theAdcFullScaleStack-1)/float(theAdcFullScale) );}
       }
     } // Only enter this if the Adc changes for the outer layers
#ifdef TP_DEBUG
      LogDebug ("Pixel Digitizer")
    << (*i).first << " " << (*i).second << " " << signalInElectrons
    << " " << adc << ip.first << " " << ip.second ;
#endif

      // Load digis
      digis.emplace_back(ip.first, ip.second, adc);

      if (makeDigiSimLinks_ && !(*i).second.hitInfos().empty()) {
        //digilink
      unsigned int il=0;
          for(const auto& info: (*i).second.hitInfos()) {
            // note: according to C++ standard operator[] does
            // value-initializiation, which for float means initial value of 0
            simi[std::make_pair(info.trackId(), info.eventId().rawId())] += (*i).second.individualampl()[il];
            il++;
          }

      //sum the contribution of the same trackid
          for(const auto& info: (*i).second.hitInfos()) {
            // skip if track already processed
            auto found = simi.find(std::make_pair(info.trackId(), info.eventId().rawId()));
            if(found == simi.end())
              continue;

        float sum_samechannel = found->second;
        float fraction=sum_samechannel/(*i).second;
        if(fraction>1.f) fraction=1.f;

            // Approximation: pick hitIndex and tofBin only from the first SimHit
        simlinks.emplace_back((*i).first, info.trackId(), info.hitIndex(), info.tofBin(), info.eventId(), fraction);
            simi.erase(found);
      }
          simi.clear(); // although should be empty already
      }
    }
  }
}

float SiPixelDigitizerAlgorithm::missCalibrate ( uint32_t  detID, const TrackerTopology *  tTopo, const PixelGeomDetUnit *  pixdet, int  col, int  row, float  amp  ) const

private

Definition at line 1825 of file SiPixelDigitizerAlgorithm.cc.

References BPix_p0, BPix_p1, BPix_p2, BPix_p3, electronsPerVCAL, electronsPerVCAL_L1, electronsPerVCAL_L1_Offset, electronsPerVCAL_Offset, Exception, FPix_p0, FPix_p1, FPix_p2, FPix_p3, GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), p1, p2, p3, TrackerTopology::pxbLayer(), DetId::subdetId(), and PixelGeomDetUnit::type().

Referenced by make_digis().

                                                      {
  // Central values
  //const float p0=0.00352, p1=0.868, p2=112., p3=113.; // pix(0,0,0)
  //  const float p0=0.00382, p1=0.886, p2=112.7, p3=113.0; // average roc=0
  //const float p0=0.00492, p1=1.998, p2=90.6, p3=134.1; // average roc=6
  // Smeared (rms)
  //const float s0=0.00020, s1=0.051, s2=5.4, s3=4.4; // average roc=0
  //const float s0=0.00015, s1=0.043, s2=3.2, s3=3.1; // col average roc=0

  // Make 2 sets of parameters for Fpix and BPIx:

  float p0=0.0f;
  float p1=0.0f;
  float p2=0.0f;
  float p3=0.0f;

  if(pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()){// barrel layers
      p0 = BPix_p0;
      p1 = BPix_p1;
      p2 = BPix_p2;
      p3 = BPix_p3;
  } else if(pixdet->type().isTrackerPixel()) {// forward disks
      p0 = FPix_p0;
      p1 = FPix_p1;
      p2 = FPix_p2;
      p3 = FPix_p3;
  } else {
    throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
  }

  float newAmp = 0.f; //Modified signal

  // Convert electrons to VCAL units
  float signal = (signalInElectrons-electronsPerVCAL_Offset)/electronsPerVCAL;

  // New gains/offsets are needed for phase1 L1
  int layer = 0;
  if (DetId(detID).subdetId()==1) layer = tTopo->pxbLayer(detID);
  if (layer==1) signal = (signalInElectrons-electronsPerVCAL_L1_Offset)/electronsPerVCAL_L1;

  // Simulate the analog response with fixed parametrization
  newAmp = p3 + p2 * tanh(p0*signal - p1);


  // Use the pixel-by-pixel calibrations
  //transform to ROC index coordinates
  //int chipIndex=0, colROC=0, rowROC=0;
  //std::unique_ptr<PixelIndices> pIndexConverter(new PixelIndices(numColumns,numRows));
  //pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);

  // Use calibration from a file
  //int chanROC = PixelIndices::pixelToChannelROC(rowROC,colROC); // use ROC coordinates
  //float pp0=0, pp1=0,pp2=0,pp3=0;
  //map<int,CalParameters,std::less<int> >::const_iterator it=calmap.find(chanROC);
  //CalParameters y  = (*it).second;
  //pp0 = y.p0;
  //pp1 = y.p1;
  //pp2 = y.p2;
  //pp3 = y.p3;
  
  //
  // Use random smearing
  // Randomize the pixel response
  //float pp0  = RandGaussQ::shoot(p0,s0);
  //float pp1  = RandGaussQ::shoot(p1,s1);
  //float pp2  = RandGaussQ::shoot(p2,s2);
  //float pp3  = RandGaussQ::shoot(p3,s3);

  //newAmp = pp3 + pp2 * tanh(pp0*signal - pp1); // Final signal

  //cout<<" misscalibrate "<<col<<" "<<row<<" "<<chipIndex<<" "<<colROC<<" "
  //  <<rowROC<<" "<<signalInElectrons<<" "<<signal<<" "<<newAmp<<" "
  //  <<(signalInElectrons/theElectronPerADC)<<std::endl;

  return newAmp;
}

void SiPixelDigitizerAlgorithm::module_killing_conf ( uint32_t  detID )

private

Definition at line 2007 of file SiPixelDigitizerAlgorithm.cc.

References _signal, PixelDigi::channelToPixel(), DeadModules, mps_fire::i, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by digitize().

                                                                  {
  
  bool isbad=false;
  
  Parameters::const_iterator itDeadModules=DeadModules.begin();
  
  int detid = detID;
  for(; itDeadModules != DeadModules.end(); ++itDeadModules){
    int Dead_detID = itDeadModules->getParameter<int>("Dead_detID");
    if(detid == Dead_detID){
      isbad=true;
      break;
    }
  }
  
  if(!isbad)
    return;

  signal_map_type& theSignal = _signal[detID];
  
  std::string Module = itDeadModules->getParameter<std::string>("Module");
  
  if(Module=="whole"){
    for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
      i->second.set(0.); // reset amplitude
    }
  }
  
  for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
    std::pair<int,int> ip = PixelDigi::channelToPixel(i->first);//get pixel pos

    if(Module=="tbmA" && ip.first>=80 && ip.first<=159){
      i->second.set(0.);
    }

    if( Module=="tbmB" && ip.first<=79){
      i->second.set(0.);
    }
  }
}

void SiPixelDigitizerAlgorithm::module_killing_DB ( uint32_t  detID )

private

Definition at line 2048 of file SiPixelDigitizerAlgorithm.cc.

References _signal, funct::abs(), PixelDigi::channelToPixel(), SiPixelQuality::disabledModuleType::errorType, SiPixelFedCablingMap::findItem(), SiPixelQuality::getBadComponentList(), mps_fire::i, triggerObjects_cff::id, sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), DTRecHitClients_cfi::local, map_, callgraph::path, SiPixelFedCablingMap::pathToDetUnit(), edm::ESHandle< T >::product(), SiPixelBadModule_, and sipixelobjects::PixelROC::toGlobal().

Referenced by digitize().

                                                                {
// Not SLHC safe for now
  
  bool isbad=false;
  
  std::vector<SiPixelQuality::disabledModuleType>disabledModules = SiPixelBadModule_->getBadComponentList();
  
  SiPixelQuality::disabledModuleType badmodule;
  
  for (size_t id=0;id<disabledModules.size();id++)
    {
      if(detID==disabledModules[id].DetID){
    isbad=true;
        badmodule = disabledModules[id];
    break;
      }
    }
  
  if(!isbad)
    return;

  signal_map_type& theSignal = _signal[detID];
  
  //std::cout<<"Hit in: "<< detID <<" errorType "<< badmodule.errorType<<" BadRocs="<<std::hex<<SiPixelBadModule_->getBadRocs(detID)<<dec<<" "<<std::endl;
  if(badmodule.errorType == 0){ // this is a whole dead module.
    
    for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
      i->second.set(0.); // reset amplitude
    }
  }
  else { // all other module types: half-modules and single ROCs.
    // Get Bad ROC position:
    //follow the example of getBadRocPositions in CondFormats/SiPixelObjects/src/SiPixelQuality.cc
    std::vector<GlobalPixel> badrocpositions (0);
    for(unsigned int j = 0; j < 16; j++){
      if(SiPixelBadModule_->IsRocBad(detID, j) == true){
    
    std::vector<CablingPathToDetUnit> path = map_.product()->pathToDetUnit(detID);
    typedef  std::vector<CablingPathToDetUnit>::const_iterator IT;
    for  (IT it = path.begin(); it != path.end(); ++it) {
          const PixelROC* myroc = map_.product()->findItem(*it);
          if( myroc->idInDetUnit() == j) {
        LocalPixel::RocRowCol  local = { 39, 25};   //corresponding to center of ROC row, col
        GlobalPixel global = myroc->toGlobal( LocalPixel(local) );
        badrocpositions.push_back(global);
        break;
      }
    }
      }
    }// end of getBadRocPositions
    
    
    for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
      std::pair<int,int> ip = PixelDigi::channelToPixel(i->first);//get pixel pos
      
      for(std::vector<GlobalPixel>::const_iterator it = badrocpositions.begin(); it != badrocpositions.end(); ++it){
    if(it->row >= 80 && ip.first >= 80 ){
      if((std::abs(ip.second - it->col) < 26) ) {i->second.set(0.);}
          else if(it->row==120 && ip.second-it->col==26){i->second.set(0.);}
          else if(it->row==119 && it->col-ip.second==26){i->second.set(0.);}
    }
    else if(it->row < 80 && ip.first < 80 ){
      if((std::abs(ip.second - it->col) < 26) ){i->second.set(0.);}
          else if(it->row==40 && ip.second-it->col==26){i->second.set(0.);}
          else if(it->row==39 && it->col-ip.second==26){i->second.set(0.);}
       }
      }
    }
  }
}

float SiPixelDigitizerAlgorithm::pixel_aging ( const PixelAging &  aging, const PixelGeomDetUnit *  pixdet, const TrackerTopology *  tTopo  ) const

private

Definition at line 1772 of file SiPixelDigitizerAlgorithm.cc.

References SiPixelDigitizerAlgorithm::PixelAging::FPixIndex, GeomDet::geographicalId(), TrackerTopology::layer(), LogDebug, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2OTB, GeomDetEnumerators::P2OTEC, GeomDetEnumerators::P2PXEC, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, DetId::rawId(), GeomDet::subDetector(), and SiPixelDigitizerAlgorithm::PixelAging::thePixelPseudoRadDamage.

Referenced by drift().

                                                             {
  
  uint32_t detID= pixdet->geographicalId().rawId();
  
  
  // Predefined damage parameter (no aging)
  float pseudoRadDamage  = 0.0f;
  
  // setup the chip indices conversion
  if    (pixdet->subDetector() ==  GeomDetEnumerators::SubDetector::PixelBarrel ||
     pixdet->subDetector() ==  GeomDetEnumerators::SubDetector::P1PXB){// barrel layers
    int layerIndex=tTopo->layer(detID);
    
     pseudoRadDamage  = aging.thePixelPseudoRadDamage[layerIndex-1];
     
     //  std::cout << "pixel_aging: " << std::endl;
     // std::cout << "Subid " << Subid << " layerIndex " << layerIndex << " ladder " << tTopo->pxbLadder(detID)  << " module  " << tTopo->pxbModule(detID) << std::endl;
     
  } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelEndcap ||
         pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXEC ||
         pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2PXEC) {                // forward disks
    unsigned int diskIndex=tTopo->layer(detID)+aging.FPixIndex; // Use diskIndex-1 later to stay consistent with BPix
    
    pseudoRadDamage  = aging.thePixelPseudoRadDamage[diskIndex-1];
    
    //    std::cout << "pixel_aging: " << std::endl;
    //    std::cout << "Subid " << Subid << " diskIndex " << diskIndex << std::endl;
  } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTB || pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTEC) {
    // if phase 2 OT hardcoded value as it has always been
    pseudoRadDamage = 0.f;
  } // if barrel/forward
  
  //  std::cout << " pseudoRadDamage " << pseudoRadDamage << std::endl;
  //  std::cout << " end pixel_aging " << std::endl;
  
  return pseudoRadDamage;
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " enter pixel_aging " << pseudoRadDamage;
#endif
  
}

void SiPixelDigitizerAlgorithm::pixel_inefficiency ( const PixelEfficiencies &  eff, const PixelGeomDetUnit *  pixdet, const TrackerTopology *  tTopo, CLHEP::HepRandomEngine *  engine  )

private

Definition at line 1584 of file SiPixelDigitizerAlgorithm.cc.

References _signal, officialStyle::chan, PixelDigi::channelToPixel(), SiPixelDigitizerAlgorithm::PixelEfficiencies::ChipGeomFactors, cuy::col, SiPixelDigitizerAlgorithm::PixelEfficiencies::ColGeomFactors, mps_check::columns, SiPixelDigitizerAlgorithm::PixelEfficiencies::FPixIndex, SiPixelDigitizerAlgorithm::PixelEfficiencies::FromConfig, GeomDet::geographicalId(), mps_fire::i, SiPixelDigitizerAlgorithm::PixelEfficiencies::iPU, PixelTopology::isItBigPixelInX(), PixelTopology::isItBigPixelInY(), PVValHelper::ladder, TrackerTopology::layer(), LogDebug, PixelTopology::ncolumns(), PixelTopology::nrows(), NumberOfBarrelLayers, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2OTB, GeomDetEnumerators::P2OTEC, GeomDetEnumerators::P2PXEC, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelGeomFactors, SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelGeomFactorsROCBigPixels, SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelGeomFactorsROCStdPixels, SiPixelDigitizerAlgorithm::PixelEfficiencies::pu_scale, TrackerTopology::pxbLadder(), TrackerTopology::pxbModule(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), rand(), DetId::rawId(), PixelGeomDetUnit::specificTopology(), GeomDet::subDetector(), SiPixelDigitizerAlgorithm::PixelEfficiencies::theInnerEfficiency_FPix, SiPixelDigitizerAlgorithm::PixelEfficiencies::theLadderEfficiency_BPix, SiPixelDigitizerAlgorithm::PixelEfficiencies::theModuleEfficiency_BPix, SiPixelDigitizerAlgorithm::PixelEfficiencies::theOuterEfficiency_FPix, SiPixelDigitizerAlgorithm::PixelEfficiencies::thePixelChipEfficiency, SiPixelDigitizerAlgorithm::PixelEfficiencies::thePixelColEfficiency, and SiPixelDigitizerAlgorithm::PixelEfficiencies::thePixelEfficiency.

Referenced by digitize().

                                                                                 {
  
  uint32_t detID= pixdet->geographicalId().rawId();
  signal_map_type& theSignal = _signal[detID];
  const PixelTopology* topol=&pixdet->specificTopology();
  int numColumns = topol->ncolumns();  // det module number of cols&rows
  int numRows = topol->nrows();
  bool isPhase1 = pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXB 
    || pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXEC;
  // Predefined efficiencies
  double pixelEfficiency  = 1.0;
  double columnEfficiency = 1.0;
  double chipEfficiency   = 1.0;
  std::vector<double> pixelEfficiencyROCStdPixels(16,1);
  std::vector<double> pixelEfficiencyROCBigPixels(16,1);
  
  if (eff.FromConfig) {
    // setup the chip indices conversion
    if    (pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelBarrel ||
           pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXB){// barrel layers
      int layerIndex=tTopo->layer(detID);
      pixelEfficiency  = eff.thePixelEfficiency[layerIndex-1];
      columnEfficiency = eff.thePixelColEfficiency[layerIndex-1];
      chipEfficiency   = eff.thePixelChipEfficiency[layerIndex-1];
      //std::cout <<"Using BPix columnEfficiency = "<<columnEfficiency<< " for layer = "<<layerIndex <<"\n";
      // This should never happen, but only check if it is not an upgrade geometry
      if (NumberOfBarrelLayers==3){
        if(numColumns>416)  LogWarning ("Pixel Geometry") <<" wrong columns in barrel "<<numColumns;
        if(numRows>160)  LogWarning ("Pixel Geometry") <<" wrong rows in barrel "<<numRows;
        
        int ladder=tTopo->pxbLadder(detID);
        int module=tTopo->pxbModule(detID);
        if (module<=4) module=5-module;
        else module-=4;
        
        columnEfficiency *= eff.theLadderEfficiency_BPix[layerIndex-1][ladder-1]*eff.theModuleEfficiency_BPix[layerIndex-1][module-1]*eff.pu_scale[layerIndex-1];
      }
    } else if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelEndcap ||
              pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXEC ||
              pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2PXEC){                // forward disks
    
      unsigned int diskIndex=tTopo->layer(detID)+eff.FPixIndex; // Use diskIndex-1 later to stay consistent with BPix
      unsigned int panelIndex=tTopo->pxfPanel(detID);
      unsigned int moduleIndex=tTopo->pxfModule(detID);
      //if (eff.FPixIndex>diskIndex-1){throw cms::Exception("Configuration") <<"SiPixelDigitizer is using the wrong efficiency value. index = "
      //                                                                       <<diskIndex-1<<" , MinIndex = "<<eff.FPixIndex<<" ... "<<tTopo->pxfDisk(detID);}
      pixelEfficiency  = eff.thePixelEfficiency[diskIndex-1];
      columnEfficiency = eff.thePixelColEfficiency[diskIndex-1];
      chipEfficiency   = eff.thePixelChipEfficiency[diskIndex-1];
      //std::cout <<"Using FPix columnEfficiency = "<<columnEfficiency<<" for Disk = "<< tTopo->pxfDisk(detID)<<"\n";
      // Sometimes the forward pixels have wrong size,
      // this crashes the index conversion, so exit, but only check if it is not an upgrade geometry
      if (NumberOfBarrelLayers==3){  // whether it is the present or the phase 1 detector can be checked using GeomDetEnumerators::SubDetector
        if(numColumns>260 || numRows>160) {
          if(numColumns>260)  LogWarning ("Pixel Geometry") <<" wrong columns in endcaps "<<numColumns;
          if(numRows>160)  LogWarning ("Pixel Geometry") <<" wrong rows in endcaps "<<numRows;
          return;
        }
        if ((panelIndex==1 && (moduleIndex==1 || moduleIndex==2)) || (panelIndex==2 && moduleIndex==1)) { //inner modules
          columnEfficiency*=eff.theInnerEfficiency_FPix[diskIndex-1]*eff.pu_scale[3];
        } else { //outer modules
          columnEfficiency*=eff.theOuterEfficiency_FPix[diskIndex-1]*eff.pu_scale[4];
        }
      } // current detector, forward
    } else if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2OTB ||pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2OTEC) {
      // If phase 2 outer tracker, hardcoded values as they have been so far
      pixelEfficiency  = 0.999;
      columnEfficiency = 0.999;
      chipEfficiency   = 0.999;
    } // if barrel/forward
  } else { // Load precomputed factors from Database
    pixelEfficiency  = eff.PixelGeomFactors.at(detID);
    columnEfficiency = eff.ColGeomFactors.at(detID)*eff.pu_scale[eff.iPU.at(detID)];
    chipEfficiency   = eff.ChipGeomFactors.at(detID);
    if (isPhase1){
      for (unsigned int i_roc=0; i_roc<eff.PixelGeomFactorsROCStdPixels.at(detID).size();++i_roc){
    pixelEfficiencyROCStdPixels[i_roc] = eff.PixelGeomFactorsROCStdPixels.at(detID).at(i_roc);
    pixelEfficiencyROCBigPixels[i_roc] = eff.PixelGeomFactorsROCBigPixels.at(detID).at(i_roc);    
      }
    } // is Phase 1
  }
  
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer") << " enter pixel_inefficiency " << pixelEfficiency << " "
                   << columnEfficiency << " " << chipEfficiency;
#endif
  
  // Initilize the index converter
  //PixelIndices indexConverter(numColumns,numRows);
  std::unique_ptr<PixelIndices> pIndexConverter(new PixelIndices(numColumns,numRows));

  int chipIndex = 0;
  int rowROC = 0;
  int colROC = 0;
  std::map<int, int, std::less<int> >chips, columns, pixelStd, pixelBig;
  std::map<int, int, std::less<int> >::iterator iter;
  
  // Find out the number of columns and rocs hits
  // Loop over hit pixels, amplitude in electrons, channel = coded row,col
  for (signal_map_const_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
    
    int chan = i->first;
    std::pair<int,int> ip = PixelDigi::channelToPixel(chan);
    int row = ip.first;  // X in row
    int col = ip.second; // Y is in col
    //transform to ROC index coordinates
    pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);
    int dColInChip = pIndexConverter->DColumn(colROC); // get ROC dcol from ROC col
    //dcol in mod
    int dColInDet = pIndexConverter->DColumnInModule(dColInChip,chipIndex);
    
    chips[chipIndex]++;
    columns[dColInDet]++;
    if (isPhase1){
      if (topol->isItBigPixelInX(row) || topol->isItBigPixelInY(col))    
    pixelBig[chipIndex]++;
      else
    pixelStd[chipIndex]++;
    }
  }
  
  // Delete some ROC hits.
  for ( iter = chips.begin(); iter != chips.end() ; iter++ ) {
    //float rand  = RandFlat::shoot();
    float rand  = CLHEP::RandFlat::shoot(engine);
    if( rand > chipEfficiency ) chips[iter->first]=0;
  }
  
  // Delete some Dcol hits.
  for ( iter = columns.begin(); iter != columns.end() ; iter++ ) {
    //float rand  = RandFlat::shoot();
    float rand  = CLHEP::RandFlat::shoot(engine);
    if( rand > columnEfficiency ) columns[iter->first]=0;
  }
  
  // Delete some pixel hits based on DCDC issue damage.
  if (isPhase1){
    for ( iter = pixelStd.begin(); iter != pixelStd.end() ; iter++ ) {
      float rand  = CLHEP::RandFlat::shoot(engine);    
      if( rand > pixelEfficiencyROCStdPixels[iter->first]) pixelStd[iter->first] = 0;
    }
    
    for ( iter = pixelBig.begin(); iter != pixelBig.end() ; iter++ ) {
      float rand  = CLHEP::RandFlat::shoot(engine);    
      if( rand > pixelEfficiencyROCBigPixels[iter->first]) pixelBig[iter->first] = 0;
    }
  }
  
  // Now loop again over pixels to kill some of them.
  // Loop over hit pixels, amplitude in electrons, channel = coded row,col
  for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
    
    //    int chan = i->first;
    std::pair<int,int> ip = PixelDigi::channelToPixel(i->first);//get pixel pos
    int row = ip.first;  // X in row
    int col = ip.second; // Y is in col
    //transform to ROC index coordinates
    pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);
    int dColInChip = pIndexConverter->DColumn(colROC); //get ROC dcol from ROC col
    //dcol in mod
    int dColInDet = pIndexConverter->DColumnInModule(dColInChip,chipIndex);
    
    //float rand  = RandFlat::shoot();
    float rand  = CLHEP::RandFlat::shoot(engine);
    if( chips[chipIndex]==0 || columns[dColInDet]==0
    || rand>pixelEfficiency  
    || (pixelStd.count(chipIndex) && pixelStd[chipIndex] == 0)
    || (pixelBig.count(chipIndex) && pixelBig[chipIndex] == 0)) {
      // make pixel amplitude =0, pixel will be lost at clusterization
      i->second.set(0.); // reset amplitude,      
    } // end if
    if (isPhase1){
      if((pixelStd.count(chipIndex) && pixelStd[chipIndex] == 0)
     || (pixelBig.count(chipIndex) && pixelBig[chipIndex] == 0)) {
    // make pixel amplitude =0, pixel will be lost at clusterization
    i->second.set(0.); // reset amplitude,      
      } // end if
    } // is Phase 1
  } // end pixel loop
} // end pixel_indefficiency

void SiPixelDigitizerAlgorithm::pixel_inefficiency_db ( uint32_t  detID )

private

Definition at line 1984 of file SiPixelDigitizerAlgorithm.cc.

References _signal, PixelDigi::channelToPixel(), cuy::col, mps_fire::i, and theSiPixelGainCalibrationService_.

Referenced by digitize().

                                                                    {
 
  signal_map_type& theSignal = _signal[detID];

  // Loop over hit pixels, amplitude in electrons, channel = coded row,col
  for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {

    //    int chan = i->first;
    std::pair<int,int> ip = PixelDigi::channelToPixel(i->first);//get pixel pos
    int row = ip.first;  // X in row
    int col = ip.second; // Y is in col
    //transform to ROC index coordinates
    if(theSiPixelGainCalibrationService_->isDead(detID, col, row)){
      //      std::cout << "now in isdead check, row " << detID << " " << col << "," << row << std::std::endl;
      // make pixel amplitude =0, pixel will be lost at clusterization
      i->second.set(0.); // reset amplitude,
    } // end if
  } // end pixel loop
} // end pixel_indefficiency

int SiPixelDigitizerAlgorithm::PixelTempRewgt2D ( int  id_in, int  id_rewgt, array_2d &  cluster  )

private

Reweight CMSSW clusters to look like clusters corresponding to Pixelav Templates.

Parameters

id_in	- (input) identifier of the template corresponding to the input events
id_rewgt	- (input) identifier of the template corresponding to the output events
cluster	- (input/output) boost multi_array container of 7x21 array of pixel signals, origin of local coords (0,0) at center of pixel cluster[3][10]. returns 0 if everything is OK, 1 if angles are outside template coverage (cluster is probably still usable, > 1 if something is wrong (no reweight done).

Definition at line 2331 of file SiPixelDigitizerAlgorithm.cc.

References funct::abs(), BXM2, BYM2, gather_cfg::cout, f, mps_fire::i, createfilelist::int, gen::k, checklumidiff::l, LogDebug, printCluster(), PrintTemplates, SiPixelTemplate2D::s50(), summarizeEdmComparisonLogfiles::success, templ2D, track, TXSIZE, TYSIZE, xdouble, xsize, SiPixelTemplate2D::xsize(), SiPixelTemplate2D::xytemp(), ydouble, ysize, and SiPixelTemplate2D::ysize().

Referenced by hitSignalReweight().

{
  // Local variables 
  int i, j, k, l, kclose;
  int nclusx, nclusy, success;
  float xsize, ysize, q50i, q100i, q50r, q10r, q100r, xhit2D, yhit2D, qclust, dist2, dmin2;
  float xy_in[BXM2][BYM2], xy_rewgt[BXM2][BYM2], xy_clust[TXSIZE][TYSIZE];
  int denx_clust[TXSIZE][TYSIZE], deny_clust[TXSIZE][TYSIZE];
  int goodWeightsUsed, nearbyWeightsUsed, noWeightsUsed;
  float cotalpha, cotbeta; 
  // success = 0 is returned if everthing is OK
  success = 0;
    
  // Copy the array to remember original charges
  array_2d clust(cluster);

  // Take the pixel dimensions from the 2D template
  xsize = templ2D.xsize();
  ysize = templ2D.ysize();
  
  // Calculate the track angles

  if (std::abs(track[5]) > 0.f){
    cotalpha = track[3]/track[5]; //if track[5] (direction in z) is 0 the hit is not processed by re-weighting
    cotbeta = track[4]/track[5];
  } else {
    LogDebug ("Pixel Digitizer") << "Reweighting angle is not good!" << std::endl;
    return 9; //returned value here indicates that no reweighting was done in this case
  }

  // The 2-D templates are defined on a shifted coordinate system wrt the 1D templates
  if(ydouble[0]) {
    yhit2D = track[1] - cotbeta*track[2] + ysize;
  } else {
    yhit2D = track[1] - cotbeta*track[2] + 0.5f*ysize;
  }
  if(xdouble[0]) {
    xhit2D = track[0] - cotalpha*track[2] + xsize;
  } else {
    xhit2D = track[0] - cotalpha*track[2] + 0.5f*xsize;
  }
  
  // Zero the input and output templates
  for(i=0; i<BYM2; ++i) {
    for(j=0; j<BXM2; ++j) {
      xy_in[j][i] = 0.f;
      xy_rewgt[j][i] = 0.f;
    }
  }

  // Next, interpolate the CMSSW template needed to analyze this cluster     

  if(!templ2D.xytemp(id_in, cotalpha, cotbeta, xhit2D, yhit2D, ydouble, xdouble, xy_in)) {success = 1;}
  if(success != 0){
#ifdef TP_DEBUG 
    LogDebug("Pixel Digitizer") << "No matching template found" << std::endl;
#endif
    return 2;
  }

  if(PrintTemplates){
    std::cout << "Template unirrad: " << std::endl;
    printCluster(xy_in);
  }

  q50i = templ2D.s50();
  //q50i = 0;
  q100i = 2.f*q50i;

  // Check that the cluster container is a 13x21 matrix
  
  if(cluster.num_dimensions() != 2) {
    LogWarning ("Pixel Digitizer") << "Cluster is not 2-dimensional. Return." << std::endl;
    return 3;
  }
  nclusx = (int)cluster.shape()[0];
  nclusy = (int)cluster.shape()[1];
  if(nclusx != TXSIZE || xdouble.size() != TXSIZE) {
    LogWarning ("Pixel Digitizer") << "Sizes in x do not match: nclusx=" << nclusx << "  xdoubleSize=" << xdouble.size() << "  TXSIZE=" << TXSIZE << ". Return." << std::endl;
    return 4;
  }
  if(nclusy != TYSIZE || ydouble.size() != TYSIZE) {
    LogWarning ("Pixel Digitizer") << "Sizes in y do not match. Return." << std::endl;
    return 5;
  }
  
  // Sum initial charge in the cluster   
  
  qclust = 0.f;
  for(i=0; i<TYSIZE; ++i) {
    for(j=0; j<TXSIZE; ++j) {
      xy_clust[j][i] = 0.f;
      denx_clust[j][i] = 0;
      deny_clust[j][i] = 0;
      if(cluster[j][i] > q100i) {
    qclust += cluster[j][i];
      }
    }
  }
  
  // Next, interpolate the physical output template needed to reweight     

  if(!templ2D.xytemp(id_rewgt, cotalpha, cotbeta, xhit2D, yhit2D, ydouble, xdouble, xy_rewgt)) {success = 1;}

  if(PrintTemplates){
    std::cout << "Template irrad: " << std::endl;  
    printCluster(xy_rewgt);
  }
    
  q50r = templ2D.s50();
  q100r = 2.f*q50r;
  q10r = 0.2f*q50r;
  
  // Find all non-zero denominator pixels in the input template and generate "inside" weights
     
  int ntpix = 0;
  int ncpix = 0;
  std::vector<int> ytclust;
  std::vector<int> xtclust;
  std::vector<int> ycclust;
  std::vector<int> xcclust;
  qclust = 0.f;
  for(i=0; i<TYSIZE; ++i) {
    for(j=0; j<TXSIZE; ++j) {
      if(xy_in[j+1][i+1] > q100i) {
    ++ntpix;
    ytclust.push_back(i);
    xtclust.push_back(j);
    xy_clust[j][i] = xy_rewgt[j+1][i+1]/xy_in[j+1][i+1];
    denx_clust[j][i] = j;
    deny_clust[j][i] = i;
      }
    }
  }
  
  // Find all non-zero numerator pixels not matched to denominator in the output template and generate "inside" weights
    
  for(i=0; i<TYSIZE; ++i) {
    for(j=0; j<TXSIZE; ++j) {
      if(xy_rewgt[j+1][i+1] > q10r && xy_clust[j][i] == 0.f && ntpix>0) {
    // Search for nearest denominator pixel
    dmin2 = 10000.f; kclose = 0;
    for(k=0; k<ntpix; ++k) {
      dist2=(i-ytclust[k])*(i-ytclust[k])+0.44444f*(j-xtclust[k])*(j-xtclust[k]);
      if(dist2 < dmin2) {
        dmin2 = dist2;
        kclose = k;
      }
    }
    xy_clust[j][i] = xy_rewgt[j+1][i+1]/xy_in[xtclust[kclose]+1][ytclust[kclose]+1];
    denx_clust[j][i] = xtclust[kclose];
    deny_clust[j][i] = ytclust[kclose];
      }
    }
  }

  if(PrintTemplates){
    std::cout << "Weights:" << std::endl;
    printCluster(xy_clust);
  }
  
  
  
  // Do the reweighting
  goodWeightsUsed = 0;
  nearbyWeightsUsed = 0;
  noWeightsUsed = 0;

  for(i=0; i<TYSIZE; ++i) {
    for(j=0; j<TXSIZE; ++j) {
      if(xy_clust[j][i] > 0.f) {
    cluster[j][i] = xy_clust[j][i]*clust[denx_clust[j][i]][deny_clust[j][i]];
    if(cluster[j][i] > q100r) {
      qclust += cluster[j][i];
    }
    if(cluster[j][i] > 0) {
      goodWeightsUsed++;
    }
      } else {
    if(clust[j][i] > 0.f) {
      ++ncpix;
      ycclust.push_back(i);
      xcclust.push_back(j);
    }
      }
    }
  }
     
  // Now reweight pixels outside of template footprint using closest weights

  if(ncpix > 0) {
    for(l=0; l<ncpix; ++l) {
      i=ycclust[l]; j=xcclust[l];
      dmin2 = 10000.f; kclose = 0;
      for(k=0; k<ntpix; ++k) {
    dist2=(i-ytclust[k])*(i-ytclust[k])+0.44444f*(j-xtclust[k])*(j-xtclust[k]);
    if(dist2 < dmin2) {
      dmin2 = dist2;
      kclose = k;
    }
      }
      if(dmin2 < 5.f) {
    nearbyWeightsUsed++;
    cluster[j][i] *= xy_clust[xtclust[kclose]][ytclust[kclose]];
    if(cluster[j][i] > q100r) {
      qclust += cluster[j][i];
    }
      } else {
    noWeightsUsed++;
    cluster[j][i] = 0.f;
      }
    }
  }

  return success;
} // PixelTempRewgt2D 

void SiPixelDigitizerAlgorithm::primary_ionization ( const PSimHit &  hit, std::vector< EnergyDepositUnit > &  ionization_points, CLHEP::HepRandomEngine *  engine  ) const

private

Definition at line 887 of file SiPixelDigitizerAlgorithm.cc.

References PSimHit::energyLoss(), PSimHit::entryPoint(), PSimHit::exitPoint(), objects.autophobj::float, fluctuateCharge, fluctuateEloss(), GeVperElectron, mps_fire::i, createfilelist::int, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), PSimHit::pabs(), PSimHit::particleType(), sysUtil::pid, point, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by accumulateSimHits().

                                                                                                                                                          {
  
  // Straight line approximation for trajectory inside active media
  
  const float SegmentLength = 0.0010; //10microns in cm
  float energy;
  
  // Get the 3D segment direction vector
  LocalVector direction = hit.exitPoint() - hit.entryPoint();
  
  float eLoss = hit.energyLoss();  // Eloss in GeV
  float length = direction.mag();  // Track length in Silicon
  
  int NumberOfSegments = int ( length / SegmentLength); // Number of segments
  if(NumberOfSegments < 1) NumberOfSegments = 1;
  
#ifdef TP_DEBUG
  LogDebug ("Pixel Digitizer")
    << " enter primary_ionzation " << NumberOfSegments
    << " shift = "
    << (hit.exitPoint().x()-hit.entryPoint().x()) << " "
    << (hit.exitPoint().y()-hit.entryPoint().y()) << " "
    << (hit.exitPoint().z()-hit.entryPoint().z()) << " "
    << hit.particleType() <<" "<< hit.pabs() ;
#endif
  
  float* elossVector = new float[NumberOfSegments];  // Eloss vector
  
  if( fluctuateCharge ) {
    //MP DA RIMUOVERE ASSOLUTAMENTE
    int pid = hit.particleType();
    //int pid=211;  // assume it is a pion
    
    float momentum = hit.pabs();
    // Generate fluctuated charge points
    fluctuateEloss(pid, momentum, eLoss, length, NumberOfSegments,
           elossVector, engine);
  }
  
  ionization_points.resize( NumberOfSegments); // set size
  
  // loop over segments
  for ( int i = 0; i != NumberOfSegments; i++) {
    // Divide the segment into equal length subsegments
    Local3DPoint point = hit.entryPoint() +
      float((i+0.5)/NumberOfSegments) * direction;
    
    if( fluctuateCharge )
      energy = elossVector[i]/GeVperElectron; // Convert charge to elec.
    else
      energy = hit.energyLoss()/GeVperElectron/float(NumberOfSegments);
    
    EnergyDepositUnit edu( energy, point); //define position,energy point
    ionization_points[i] = edu; // save
    
#ifdef TP_DEBUG
    LogDebug ("Pixel Digitizer")
      << i << " " << ionization_points[i].x() << " "
      << ionization_points[i].y() << " "
      << ionization_points[i].z() << " "
      << ionization_points[i].energy();
#endif
    
  }  // end for loop
  
  delete[] elossVector;
  
}

void SiPixelDigitizerAlgorithm::printCluster ( array_2d &  cluster )

private

Definition at line 2548 of file SiPixelDigitizerAlgorithm.cc.

References cuy::col, gather_cfg::cout, alignBH_cfg::fixed, TXSIZE, and TYSIZE.

Referenced by hitSignalReweight(), and PixelTempRewgt2D().

{
  for(int col = 0; col < TYSIZE; ++col) {
    for(int row = 0; row < TXSIZE; ++row) {
      std::cout << std::setw(10) << std::setprecision(0) << std::fixed;
      std::cout << cluster[row][col];
    }
    std::cout << std::endl;
  }
  std::cout.copyfmt(std::ios(nullptr));
}

void SiPixelDigitizerAlgorithm::printCluster ( float  arr[13+2][21+2] )

private

Definition at line 2560 of file SiPixelDigitizerAlgorithm.cc.

References BXM2, BYM2, cuy::col, gather_cfg::cout, and alignBH_cfg::fixed.

{
  for(int col = 0; col < BYM2; ++col) {
    for(int row = 0; row < BXM2; ++row) {
      std::cout << std::setw(10) << std::setprecision(0) << std::fixed;
      std::cout << arr[row][col];
    }
    std::cout << std::endl;
  }
  std::cout.copyfmt(std::ios(nullptr));
}

void SiPixelDigitizerAlgorithm::printCluster ( float  arr[13][21] )

private

Definition at line 2572 of file SiPixelDigitizerAlgorithm.cc.

References cuy::col, gather_cfg::cout, alignBH_cfg::fixed, TXSIZE, and TYSIZE.

{
  for(int col = 0; col < TYSIZE; ++col) {
    for(int row = 0; row < TXSIZE; ++row) {
      std::cout << std::setw(10) << std::fixed;
      std::cout << arr[row][col];
    }
    std::cout << std::endl;
  }
  std::cout.copyfmt(std::ios(nullptr));
}

void SiPixelDigitizerAlgorithm::setSimAccumulator

(

const std::map< uint32_t, std::map< int, int > > &

signalMap

)

Definition at line 783 of file SiPixelDigitizerAlgorithm.cc.

References _signal, officialStyle::chan, and theElectronPerADC.

Referenced by PreMixingSiPixelWorker::put().

                                                                                                      {
  for(const auto& det: signalMap) {
    auto& theSignal = _signal[det.first];
    for(const auto& chan: det.second) {
      theSignal[chan.first].set(chan.second * theElectronPerADC); // will get divided again by theElectronPerAdc in digitize...
    }
  }
}

Member Data Documentation

signalMaps SiPixelDigitizerAlgorithm::_signal

private

Definition at line 297 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), induce_signal(), make_digis(), module_killing_conf(), module_killing_DB(), pixel_inefficiency(), pixel_inefficiency_db(), and setSimAccumulator().

const bool SiPixelDigitizerAlgorithm::addChargeVCALSmearing

private

Definition at line 381 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

const bool SiPixelDigitizerAlgorithm::addNoise

private

Definition at line 380 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const bool SiPixelDigitizerAlgorithm::addNoisyPixels

private

Definition at line 382 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

const bool SiPixelDigitizerAlgorithm::AddPixelAging

private

Definition at line 395 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

const bool SiPixelDigitizerAlgorithm::AddPixelInefficiency

private

Definition at line 385 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), init_DynIneffDB(), and SiPixelDigitizerAlgorithm().

const bool SiPixelDigitizerAlgorithm::addThresholdSmearing

private

Definition at line 387 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const bool SiPixelDigitizerAlgorithm::alpha2Order

private

Definition at line 331 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift(), and DriftDirection().

const float SiPixelDigitizerAlgorithm::BPix_p0

private

Definition at line 373 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::BPix_p1

private

Definition at line 374 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::BPix_p2

private

Definition at line 375 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::BPix_p3

private

Definition at line 376 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const std::map<int,CalParameters,std::less<int> > SiPixelDigitizerAlgorithm::calmap

private

Definition at line 413 of file SiPixelDigitizerAlgorithm.h.

Referenced by initCal().

const float SiPixelDigitizerAlgorithm::ClusterWidth

private

Definition at line 336 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal().

const SiPixel2DTemplateDBObject* SiPixelDigitizerAlgorithm::dbobject_den

private

Definition at line 317 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight().

const SiPixel2DTemplateDBObject* SiPixelDigitizerAlgorithm::dbobject_num

private

Definition at line 318 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight().

const Parameters SiPixelDigitizerAlgorithm::DeadModules

private

Definition at line 306 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_conf().

const float SiPixelDigitizerAlgorithm::Dist300

private

Definition at line 330 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

const bool SiPixelDigitizerAlgorithm::doMissCalibrate

private

Definition at line 390 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis().

const float SiPixelDigitizerAlgorithm::electronsPerVCAL

private

Definition at line 359 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_L1

private

Definition at line 361 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_L1_Offset

private

Definition at line 362 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_Offset

private

Definition at line 360 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const std::unique_ptr<SiG4UniversalFluctuation> SiPixelDigitizerAlgorithm::fluctuate

private

Definition at line 409 of file SiPixelDigitizerAlgorithm.h.

Referenced by fluctuateEloss().

const bool SiPixelDigitizerAlgorithm::fluctuateCharge

private

Definition at line 383 of file SiPixelDigitizerAlgorithm.h.

Referenced by primary_ionization().

const float SiPixelDigitizerAlgorithm::FPix_p0

private

Definition at line 369 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::FPix_p1

private

Definition at line 370 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::FPix_p2

private

Definition at line 371 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

const float SiPixelDigitizerAlgorithm::FPix_p3

private

Definition at line 372 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

edm::ESHandle<TrackerGeometry> SiPixelDigitizerAlgorithm::geom_

private

Definition at line 94 of file SiPixelDigitizerAlgorithm.h.

Referenced by init_DynIneffDB().

const float SiPixelDigitizerAlgorithm::GeVperElectron

private

Definition at line 326 of file SiPixelDigitizerAlgorithm.h.

Referenced by primary_ionization().

int SiPixelDigitizerAlgorithm::IDden

private

Definition at line 313 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight().

int SiPixelDigitizerAlgorithm::IDnum

private

Definition at line 313 of file SiPixelDigitizerAlgorithm.h.

const bool SiPixelDigitizerAlgorithm::makeDigiSimLinks_

private

Definition at line 299 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight(), induce_signal(), and make_digis().

edm::ESHandle<SiPixelFedCablingMap> SiPixelDigitizerAlgorithm::map_

private

Definition at line 93 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_DB().

const int SiPixelDigitizerAlgorithm::NumberOfBarrelLayers

private

Definition at line 338 of file SiPixelDigitizerAlgorithm.h.

Referenced by pixel_inefficiency(), SiPixelDigitizerAlgorithm::PixelAging::PixelAging(), and SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelEfficiencies().

const int SiPixelDigitizerAlgorithm::NumberOfEndcapDisks

private

Definition at line 339 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm::PixelAging::PixelAging(), and SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelEfficiencies().

const PixelAging SiPixelDigitizerAlgorithm::pixelAging_

private

Definition at line 484 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

PixelEfficiencies SiPixelDigitizerAlgorithm::pixelEfficiencies_

private

Definition at line 483 of file SiPixelDigitizerAlgorithm.h.

Referenced by calculateInstlumiFactor(), digitize(), and init_DynIneffDB().

const bool SiPixelDigitizerAlgorithm::PrintClusters

private

Definition at line 397 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight().

const bool SiPixelDigitizerAlgorithm::PrintTemplates

private

Definition at line 398 of file SiPixelDigitizerAlgorithm.h.

Referenced by PixelTempRewgt2D().

const float SiPixelDigitizerAlgorithm::Sigma0

private

Definition at line 329 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

edm::ESHandle<SiPixelQuality> SiPixelDigitizerAlgorithm::SiPixelBadModule_

private

Definition at line 90 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_DB().

edm::ESHandle<SiPixelDynamicInefficiency> SiPixelDigitizerAlgorithm::SiPixelDynamicInefficiency_

private

Definition at line 97 of file SiPixelDigitizerAlgorithm.h.

Referenced by init_DynIneffDB().

edm::ESHandle<SiPixelLorentzAngle> SiPixelDigitizerAlgorithm::SiPixelLorentzAngle_

private

Definition at line 87 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

const float SiPixelDigitizerAlgorithm::tanLorentzAnglePerTesla_BPix

private

Definition at line 367 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

const float SiPixelDigitizerAlgorithm::tanLorentzAnglePerTesla_FPix

private

Definition at line 366 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

SiPixelTemplate2D SiPixelDigitizerAlgorithm::templ2D

private

Definition at line 309 of file SiPixelDigitizerAlgorithm.h.

Referenced by PixelTempRewgt2D().

std::vector<SiPixelTemplateStore2D> SiPixelDigitizerAlgorithm::templateStores_

private

Definition at line 315 of file SiPixelDigitizerAlgorithm.h.

const int SiPixelDigitizerAlgorithm::theAdcFullScale

private

Definition at line 343 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis(), and SiPixelDigitizerAlgorithm().

const int SiPixelDigitizerAlgorithm::theAdcFullScaleStack

private

Definition at line 344 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis().

const float SiPixelDigitizerAlgorithm::theElectronPerADC

private

Definition at line 342 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis(), setSimAccumulator(), and SiPixelDigitizerAlgorithm().

const float SiPixelDigitizerAlgorithm::theGainSmearing

private

Definition at line 391 of file SiPixelDigitizerAlgorithm.h.

const float SiPixelDigitizerAlgorithm::theNoiseInElectrons

private

Definition at line 345 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), and digitize().

const std::unique_ptr<GaussianTailNoiseGenerator> SiPixelDigitizerAlgorithm::theNoiser

private

Definition at line 410 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

const float SiPixelDigitizerAlgorithm::theOffsetSmearing

private

Definition at line 392 of file SiPixelDigitizerAlgorithm.h.

const float SiPixelDigitizerAlgorithm::theReadoutNoise

private

Definition at line 346 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

const std::unique_ptr<SiPixelGainCalibrationOfflineSimService> SiPixelDigitizerAlgorithm::theSiPixelGainCalibrationService_

private

Definition at line 458 of file SiPixelDigitizerAlgorithm.h.

Referenced by pixel_inefficiency_db().

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix

private

Definition at line 350 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), make_digis(), and SiPixelDigitizerAlgorithm().

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix_L1

private

Definition at line 351 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), make_digis(), and SiPixelDigitizerAlgorithm().

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix_L2

private

Definition at line 352 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), make_digis(), and SiPixelDigitizerAlgorithm().

const float SiPixelDigitizerAlgorithm::theThresholdInE_FPix

private

Definition at line 349 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), make_digis(), and SiPixelDigitizerAlgorithm().

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix

private

Definition at line 355 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix_L1

private

Definition at line 356 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix_L2

private

Definition at line 357 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_FPix

private

Definition at line 354 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const float SiPixelDigitizerAlgorithm::theTofLowerCut

private

Definition at line 364 of file SiPixelDigitizerAlgorithm.h.

Referenced by accumulateSimHits().

const float SiPixelDigitizerAlgorithm::theTofUpperCut

private

Definition at line 365 of file SiPixelDigitizerAlgorithm.h.

Referenced by accumulateSimHits().

const double SiPixelDigitizerAlgorithm::tMax

private

Definition at line 405 of file SiPixelDigitizerAlgorithm.h.

Referenced by fluctuateEloss(), and SiPixelDigitizerAlgorithm().

std::vector<float> SiPixelDigitizerAlgorithm::track

private

Definition at line 312 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight(), and PixelTempRewgt2D().

const bool SiPixelDigitizerAlgorithm::use_deadmodule_DB_

private

Definition at line 303 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const bool SiPixelDigitizerAlgorithm::use_ineff_from_db_

private

Definition at line 301 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const bool SiPixelDigitizerAlgorithm::use_LorentzAngle_DB_

private

Definition at line 304 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

const bool SiPixelDigitizerAlgorithm::use_module_killing_

private

Definition at line 302 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

const bool SiPixelDigitizerAlgorithm::UseReweighting

private

Definition at line 396 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight(), and induce_signal().

std::vector<bool> SiPixelDigitizerAlgorithm::xdouble

private

Definition at line 310 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight(), and PixelTempRewgt2D().

std::vector<bool> SiPixelDigitizerAlgorithm::ydouble

private

Definition at line 311 of file SiPixelDigitizerAlgorithm.h.

Referenced by hitSignalReweight(), and PixelTempRewgt2D().