GEMSimpleModel Class Reference

#include <GEMSimpleModel.h>

Inheritance diagram for GEMSimpleModel:

Public Member Functions
	GEMSimpleModel (const edm::ParameterSet &)
int	getSimHitBx (const PSimHit *, CLHEP::HepRandomEngine *)
void	setup ()
std::vector< std::pair< int, int > >	simulateClustering (const GEMEtaPartition *, const PSimHit *, const int, CLHEP::HepRandomEngine *) override
void	simulateNoise (const GEMEtaPartition *, CLHEP::HepRandomEngine *) override
void	simulateSignal (const GEMEtaPartition *, const edm::PSimHitContainer &, CLHEP::HepRandomEngine *) override
	~GEMSimpleModel ()
Public Member Functions inherited from GEMDigiModel
void	fillDigis (int rollDetId, GEMDigiCollection &)
const GEMGeometry *	getGeometry ()
void	setGeometry (const GEMGeometry *geom)
const StripDigiSimLinks &	stripDigiSimLinks () const
virtual	~GEMDigiModel ()

Private Attributes
double	averageEfficiency_
double	averageNoiseRate_
double	averageShapingTime_
int	bxwidth_
std::vector< double >	clsParametrization_
double	constNeuGE11_
bool	cosmics_
bool	digitizeOnlyMuons_
bool	doBkgNoise_
bool	doNoiseCLS_
bool	fixedRollRadius_
std::vector< double >	GE11ElecBkgParams_
std::vector< double >	GE21ElecBkgParams_
std::vector< double >	GE21NeuBkgParams_
int	maxBunch_
int	minBunch_
double	minPabsNoiseCLS_
double	scaleLumi_
double	signalPropagationSpeed_
bool	simulateElectronBkg_
bool	simulateIntrinsicNoise_
double	slopeNeuGE11_
double	timeJitter_
double	timeResolution_

Additional Inherited Members
Public Types inherited from GEMDigiModel
typedef edm::DetSet < StripDigiSimLink >	StripDigiSimLinks
Protected Types inherited from GEMDigiModel
typedef std::multimap < std::pair< unsigned int, int > , const PSimHit *, std::less < std::pair< unsigned int, int > > >	DetectorHitMap
Protected Member Functions inherited from GEMDigiModel
void	addLinks (unsigned int strip, int bx)
	creates links from Digi to SimTrack More...
	GEMDigiModel (const edm::ParameterSet &)
Protected Attributes inherited from GEMDigiModel
DetectorHitMap	detectorHitMap_
const GEMGeometry *	geometry_
StripDigiSimLinks	stripDigiSimLinks_
std::set< std::pair< int, int > >	strips_

Detailed Description

Class for the GEM strip response simulation based on a very simple model

Author

Sven Dildick by Roumyana Hadjiiska

Definition at line 22 of file GEMSimpleModel.h.

Constructor & Destructor Documentation

GEMSimpleModel::GEMSimpleModel

(

const edm::ParameterSet &

config

)

Definition at line 26 of file GEMSimpleModel.cc.

                                                            :
GEMDigiModel(config)
, averageEfficiency_(config.getParameter<double> ("averageEfficiency"))
, averageShapingTime_(config.getParameter<double> ("averageShapingTime"))
, timeResolution_(config.getParameter<double> ("timeResolution"))
, timeJitter_(config.getParameter<double> ("timeJitter"))
, averageNoiseRate_(config.getParameter<double> ("averageNoiseRate"))
//, averageClusterSize_(config.getParameter<double> ("averageClusterSize"))
, clsParametrization_(config.getParameter<std::vector<double>>("clsParametrization"))
, signalPropagationSpeed_(config.getParameter<double> ("signalPropagationSpeed"))
, cosmics_(config.getParameter<bool> ("cosmics"))
, bxwidth_(config.getParameter<int> ("bxwidth"))
, minBunch_(config.getParameter<int> ("minBunch"))
, maxBunch_(config.getParameter<int> ("maxBunch"))
, digitizeOnlyMuons_(config.getParameter<bool> ("digitizeOnlyMuons"))
, doBkgNoise_(config.getParameter<bool> ("doBkgNoise"))
, doNoiseCLS_(config.getParameter<bool> ("doNoiseCLS"))
, fixedRollRadius_(config.getParameter<bool> ("fixedRollRadius"))
, scaleLumi_(config.getParameter<double> ("scaleLumi"))
, simulateElectronBkg_(config.getParameter<bool> ("simulateElectronBkg"))
, constNeuGE11_(config.getParameter<double> ("constNeuGE11"))
, slopeNeuGE11_(config.getParameter<double> ("slopeNeuGE11"))
, GE21NeuBkgParams_(config.getParameter<std::vector<double>>("GE21NeuBkgParams"))
, GE11ElecBkgParams_(config.getParameter<std::vector<double>>("GE11ElecBkgParams"))
, GE21ElecBkgParams_(config.getParameter<std::vector<double>>("GE21ElecBkgParams"))

{

}

GEMSimpleModel::~GEMSimpleModel

(

)

Definition at line 56 of file GEMSimpleModel.cc.

{
}

Member Function Documentation

int GEMSimpleModel::getSimHitBx	(	const PSimHit *	simhit,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 88 of file GEMSimpleModel.cc.

References averageShapingTime_, bxwidth_, cosmics_, gather_cfg::cout, debug, PSimHit::detUnitId(), alignCSCRings::e, GEMGeometry::etaPartition(), edm::hlt::Exception, GEMDigiModel::geometry_, PSimHit::localPosition(), signalPropagationSpeed_, mathSSE::sqrt(), timeJitter_, PSimHit::timeOfFlight(), timeResolution_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by simulateSignal().

{
  int bx = -999;
  const LocalPoint simHitPos(simhit->localPosition());
  const float tof(simhit->timeOfFlight());
  // random Gaussian time correction due to electronics jitter
  float randomJitterTime = CLHEP::RandGaussQ::shoot(engine, 0., timeJitter_);

  const GEMDetId id(simhit->detUnitId());
  const GEMEtaPartition* roll(geometry_->etaPartition(id));

  if (!roll)
  {
    throw cms::Exception("Geometry")<< "GEMSimpleModel::getSimHitBx() - GEM simhit id does not match any GEM roll id: " << id << "\n";
    return 999;
  }

  if (roll->id().region() == 0)
  {
    throw cms::Exception("Geometry") << "GEMSimpleModel::getSimHitBx() - this GEM id is from barrel, which cannot happen: " << roll->id() << "\n";
  }

  // signal propagation speed in vacuum in [m/s]
  const double cspeed = 299792458; 
  const int nstrips = roll->nstrips();
  float middleStrip = nstrips/2.;
  LocalPoint middleOfRoll = roll->centreOfStrip(middleStrip);
  GlobalPoint globMiddleRol = roll->toGlobal(middleOfRoll);
  double muRadius = sqrt(globMiddleRol.x()*globMiddleRol.x() + globMiddleRol.y()*globMiddleRol.y() +globMiddleRol.z()*globMiddleRol.z());
  double timeCalibrationOffset_ = (muRadius *1e+9)/(cspeed*1e+2); //[ns]

  const TrapezoidalStripTopology* top(dynamic_cast<const TrapezoidalStripTopology*> (&(roll->topology())));
  const float halfStripLength(0.5 * top->stripLength());
  const float distanceFromEdge(halfStripLength - simHitPos.y());

  // signal propagation speed in material in [cm/ns]
  double signalPropagationSpeedTrue = signalPropagationSpeed_ * cspeed * 1e+2 * 1e-9;

  // average time for the signal to propagate from the SimHit to the top of a strip
  const float averagePropagationTime(distanceFromEdge / signalPropagationSpeedTrue);
  // random Gaussian time correction due to the finite timing resolution of the detector
  float randomResolutionTime = CLHEP::RandGaussQ::shoot(engine, 0., timeResolution_);

  const float simhitTime(tof + averageShapingTime_ + randomResolutionTime + averagePropagationTime + randomJitterTime);

  float referenceTime = 0.;
  referenceTime = timeCalibrationOffset_ + halfStripLength / signalPropagationSpeedTrue + averageShapingTime_;
  const float timeDifference(cosmics_ ? (simhitTime - referenceTime) / COSMIC_PAR : simhitTime - referenceTime);

  // assign the bunch crossing
  bx = static_cast<int> (std::round((timeDifference) / bxwidth_));

  // check time
  const bool debug(false);
  if (debug)
  {
    std::cout << "checktime " << "bx = " << bx << "\tdeltaT = " << timeDifference << "\tsimT =  " << simhitTime
        << "\trefT =  " << referenceTime << "\ttof = " << tof << "\tavePropT =  " << averagePropagationTime
        << "\taveRefPropT = " << halfStripLength / signalPropagationSpeedTrue << std::endl;
  }
  return bx;
}

void GEMSimpleModel::setup ( void  )

virtual

Implements GEMDigiModel.

Definition at line 60 of file GEMSimpleModel.cc.

{
  return;
}

std::vector< std::pair< int, int > > GEMSimpleModel::simulateClustering ( const GEMEtaPartition *  roll, const PSimHit *  simHit, const int  bx, CLHEP::HepRandomEngine *  engine  )

overridevirtual

Implements GEMDigiModel.

Definition at line 332 of file GEMSimpleModel.cc.

References funct::abs(), averageEfficiency_, GEMEtaPartition::centreOfStrip(), Topology::channel(), clsParametrization_, i, PSimHit::localPosition(), minPabsNoiseCLS_, GEMEtaPartition::nstrips(), PSimHit::pabs(), PSimHit::particleType(), PV3DBase< T, PVType, FrameType >::phi(), GEMEtaPartition::specificTopology(), GeomDet::toGlobal(), and ecaldqm::topology().

Referenced by simulateSignal().

{
  //  const Topology& topology(roll->specs()->topology());
  const StripTopology& topology = roll->specificTopology();
  //  const LocalPoint& entry(simHit->entryPoint());
  const LocalPoint& hit_position(simHit->localPosition());
  const int nstrips(roll->nstrips());

  int centralStrip = 0;
  if (!(topology.channel(hit_position) + 1 > nstrips))
    centralStrip = topology.channel(hit_position) + 1;
  else
    centralStrip = topology.channel(hit_position);

  GlobalPoint pointSimHit = roll->toGlobal(hit_position);
  GlobalPoint pointDigiHit = roll->toGlobal(roll->centreOfStrip(centralStrip));
  double deltaphi = pointSimHit.phi() - pointDigiHit.phi();

  // Add central digi to cluster vector
  std::vector<std::pair<int, int> > cluster_;
  cluster_.clear();
  cluster_.push_back(std::pair<int, int>(centralStrip, bx));

  // get the cluster size
      int clusterSize = 0;
      double randForCls = CLHEP::RandFlat::shoot(engine);

      if(randForCls <= clsParametrization_[0] && randForCls >= 0.)
        clusterSize = 1;
      else if(randForCls <= clsParametrization_[1] && randForCls > clsParametrization_[0])
        clusterSize = 2;
      else if(randForCls <= clsParametrization_[2] && randForCls > clsParametrization_[1])
        clusterSize = 3;
      else if(randForCls <= clsParametrization_[3] && randForCls > clsParametrization_[2])
        clusterSize = 4;
      else if(randForCls <= clsParametrization_[4] && randForCls > clsParametrization_[3])
        clusterSize = 5;
      else if(randForCls <= clsParametrization_[5] && randForCls > clsParametrization_[4])
        clusterSize = 6;
      else if(randForCls <= clsParametrization_[6] && randForCls > clsParametrization_[5])
        clusterSize = 7;
      else if(randForCls <= clsParametrization_[7] && randForCls > clsParametrization_[6])
        clusterSize = 8;
      else if(randForCls <= clsParametrization_[8] && randForCls > clsParametrization_[7])
        clusterSize = 9;

  if (abs(simHit->particleType()) != 13 && fabs(simHit->pabs()) < minPabsNoiseCLS_)
    return cluster_;

  //odd cls
  if (clusterSize % 2 != 0)
  {
    int clsR = (clusterSize - 1) / 2;
    for (int i = 1; i <= clsR; ++i)
    {
      if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - i > 0))
        cluster_.push_back(std::pair<int, int>(centralStrip - i, bx));
      if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + i <= nstrips))
        cluster_.push_back(std::pair<int, int>(centralStrip + i, bx));
    }
  }
  //even cls
  if (clusterSize % 2 == 0)
  {
    int clsR = (clusterSize - 2) / 2;
    if (deltaphi <= 0)
    {
      if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - 1 > 0))
        cluster_.push_back(std::pair<int, int>(centralStrip - 1, bx));
      for (int i = 1; i <= clsR; ++i)
      {
        if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - 1 - i > 0))
          cluster_.push_back(std::pair<int, int>(centralStrip - 1 - i, bx));
        if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + i <= nstrips))
          cluster_.push_back(std::pair<int, int>(centralStrip + i, bx));
      }
    }
    else
    {
      if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + 1 <= nstrips))
        cluster_.push_back(std::pair<int, int>(centralStrip + 1, bx));
      for (int i = 1; i <= clsR; ++i)
      {
        if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + 1 + i <= nstrips))
          cluster_.push_back(std::pair<int, int>(centralStrip + 1 + i, bx));
        if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - i < 0))
          cluster_.push_back(std::pair<int, int>(centralStrip - i, bx));
      }
    }
  }
  return cluster_;

}

void GEMSimpleModel::simulateNoise ( const GEMEtaPartition *  roll, CLHEP::HepRandomEngine *  engine  )

overridevirtual

Implements GEMDigiModel.

Definition at line 151 of file GEMSimpleModel.cc.

References averageEfficiency_, averageNoiseRate_, bxwidth_, clsParametrization_, constNeuGE11_, doBkgNoise_, doNoiseCLS_, alignCSCRings::e, edm::hlt::Exception, fixedRollRadius_, GE11ElecBkgParams_, GE21ElecBkgParams_, GE21NeuBkgParams_, i, GEMEtaPartition::id(), j, roll_playback::k, maxBunch_, minBunch_, GEMEtaPartition::nstrips(), GEMEtaPartition::pitch(), scaleLumi_, simulateElectronBkg_, simulateIntrinsicNoise_, slopeNeuGE11_, GEMDigiModel::strips_, and GEMEtaPartition::topology().

{
  if (!doBkgNoise_)
  return;

  const GEMDetId gemId(roll->id());
  const int nstrips(roll->nstrips());
  double trArea(0.0);
  double trStripArea(0.0);

  if (gemId.region() == 0)
  {
    throw cms::Exception("Geometry")
        << "GEMSynchronizer::simulateNoise() - this GEM id is from barrel, which cannot happen.";
  }
  const TrapezoidalStripTopology* top_(dynamic_cast<const TrapezoidalStripTopology*> (&(roll->topology())));
  const float striplength(top_->stripLength());
  trStripArea = (roll->pitch()) * striplength;
  trArea = trStripArea * nstrips;
  const int nBxing(maxBunch_ - minBunch_ + 1);

  const float rollRadius(fixedRollRadius_ ? top_->radius() : 
             top_->radius() + CLHEP::RandFlat::shoot(engine, -1.*top_->stripLength()/2., top_->stripLength()/2.));

  //calculate noise from model
  double averageNeutralNoiseRatePerRoll = 0.;
  double averageNoiseElectronRatePerRoll = 0.;
  double averageNoiseRatePerRoll = 0.;

  if(gemId.station() == 1)
  {
//simulate neutral background for GE1/1
    averageNeutralNoiseRatePerRoll = constNeuGE11_ * TMath::Exp(slopeNeuGE11_*rollRadius);

//simulate eletron background for GE1/1
//the product is faster than Power or pow:
    if(simulateElectronBkg_)
    averageNoiseElectronRatePerRoll = GE11ElecBkgParams_[0]
                                    + GE11ElecBkgParams_[1]*rollRadius
                                    + GE11ElecBkgParams_[2]*rollRadius*rollRadius
                                    + GE11ElecBkgParams_[3]*rollRadius*rollRadius*rollRadius;

    averageNoiseRatePerRoll = averageNeutralNoiseRatePerRoll + averageNoiseElectronRatePerRoll;
  }

  if(gemId.station() == 2 || gemId.station() == 3)
  {
//simulate neutral background for GE2/1
    averageNeutralNoiseRatePerRoll = GE21NeuBkgParams_[0]
                                   + GE21NeuBkgParams_[1]*rollRadius
                                   + GE21NeuBkgParams_[2]*rollRadius*rollRadius
                                   + GE21NeuBkgParams_[3]*rollRadius*rollRadius*rollRadius
                                   + GE21NeuBkgParams_[4]*rollRadius*rollRadius*rollRadius*rollRadius
                                   + GE21NeuBkgParams_[5]*rollRadius*rollRadius*rollRadius*rollRadius*rollRadius;


//simulate eletron background for GE2/1
    if(simulateElectronBkg_)
    averageNoiseElectronRatePerRoll = GE21ElecBkgParams_[0]
                                    + GE21ElecBkgParams_[1]*rollRadius
                                    + GE21ElecBkgParams_[2]*rollRadius*rollRadius
                                    + GE21ElecBkgParams_[3]*rollRadius*rollRadius*rollRadius
                                    + GE21ElecBkgParams_[4]*rollRadius*rollRadius*rollRadius*rollRadius
                                    + GE21ElecBkgParams_[5]*rollRadius*rollRadius*rollRadius*rollRadius*rollRadius
                                    + GE21ElecBkgParams_[6]*rollRadius*rollRadius*rollRadius*rollRadius*rollRadius*rollRadius;

    averageNoiseRatePerRoll = averageNeutralNoiseRatePerRoll + averageNoiseElectronRatePerRoll;
  }

  //simulate intrinsic noise
  if(simulateIntrinsicNoise_)
  {
    const double aveIntrinsicNoisePerStrip(averageNoiseRate_ * nBxing * bxwidth_ * trStripArea * 1.0e-9);
    for(int j = 0; j < nstrips; ++j)
    {
      CLHEP::RandPoissonQ randPoissonQ(*engine, aveIntrinsicNoisePerStrip);
      const int n_intrHits(randPoissonQ.fire());
    
      for (int k = 0; k < n_intrHits; k++ )
      {
        const int time_hit(static_cast<int>(CLHEP::RandFlat::shoot(engine, nBxing)) + minBunch_);
        std::pair<int, int> digi(k+1,time_hit);
        strips_.insert(digi);
      }
    }
  }//end simulate intrinsic noise

  //simulate bkg contribution
  const double averageNoise(averageNoiseRatePerRoll * nBxing * bxwidth_ * trArea * 1.0e-9 * scaleLumi_);
  CLHEP::RandPoissonQ randPoissonQ(*engine, averageNoise);
  const int n_hits(randPoissonQ.fire());

  for (int i = 0; i < n_hits; ++i)
  {
    const int centralStrip(static_cast<int> (CLHEP::RandFlat::shoot(engine, 1, nstrips)));
    const int time_hit(static_cast<int>(CLHEP::RandFlat::shoot(engine, nBxing)) + minBunch_);

    if (doNoiseCLS_)
    {
      std::vector<std::pair<int, int> > cluster_;
      cluster_.clear();
      cluster_.push_back(std::pair<int, int>(centralStrip, time_hit));

      int clusterSize = 0;
      double randForCls = CLHEP::RandFlat::shoot(engine);

      if(randForCls <= clsParametrization_[0] && randForCls >= 0.)
        clusterSize = 1;
      else if(randForCls <= clsParametrization_[1] && randForCls > clsParametrization_[0])
        clusterSize = 2;
      else if(randForCls <= clsParametrization_[2] && randForCls > clsParametrization_[1])
        clusterSize = 3;
      else if(randForCls <= clsParametrization_[3] && randForCls > clsParametrization_[2])
        clusterSize = 4;
      else if(randForCls <= clsParametrization_[4] && randForCls > clsParametrization_[3])
        clusterSize = 5;
      else if(randForCls <= clsParametrization_[5] && randForCls > clsParametrization_[4])
        clusterSize = 6;
      else if(randForCls <= clsParametrization_[6] && randForCls > clsParametrization_[5])
        clusterSize = 7;
      else if(randForCls <= clsParametrization_[7] && randForCls > clsParametrization_[6])
        clusterSize = 8;
      else if(randForCls <= clsParametrization_[8] && randForCls > clsParametrization_[7])
        clusterSize = 9;

      //odd cls
      if (clusterSize % 2 != 0)
      {
        int clsR = (clusterSize - 1) / 2;
        for (int i = 1; i <= clsR; ++i)
        {
          if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - i > 0))
            cluster_.push_back(std::pair<int, int>(centralStrip - i, time_hit));
          if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + i <= nstrips))
            cluster_.push_back(std::pair<int, int>(centralStrip + i, time_hit));
        }
      }
      //even cls
      if (clusterSize % 2 == 0)
      {
        int clsR = (clusterSize - 2) / 2;
        if(CLHEP::RandFlat::shoot(engine) < 0.5)
        {
          if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - 1 > 0))
            cluster_.push_back(std::pair<int, int>(centralStrip - 1, time_hit));
          for (int i = 1; i <= clsR; ++i)
          {
            if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - 1 - i > 0))
              cluster_.push_back(std::pair<int, int>(centralStrip - 1 - i, time_hit));
            if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + i <= nstrips))
              cluster_.push_back(std::pair<int, int>(centralStrip + i, time_hit));
          }
        }

        else
        {
      if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + 1 <= nstrips))
        cluster_.push_back(std::pair<int, int>(centralStrip + 1, time_hit));
          for (int i = 1; i <= clsR; ++i)
          {
            if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip + 1 + i <= nstrips))
            cluster_.push_back(std::pair<int, int>(centralStrip + 1 + i, time_hit));
            if (CLHEP::RandFlat::shoot(engine) < averageEfficiency_ && (centralStrip - i < 0))
            cluster_.push_back(std::pair<int, int>(centralStrip - i, time_hit));
          }
        }
      }
      for(auto & digi : cluster_)
      {
        strips_.insert(digi);
      }
    }//end doNoiseCLS_
    else
    {
      std::pair<int, int> digi(centralStrip, time_hit);
      strips_.insert(digi);
    }
  }
  return;
}

void GEMSimpleModel::simulateSignal ( const GEMEtaPartition *  roll, const edm::PSimHitContainer &  simHits, CLHEP::HepRandomEngine *  engine  )

overridevirtual

Implements GEMDigiModel.

Definition at line 65 of file GEMSimpleModel.cc.

References funct::abs(), averageEfficiency_, edm::DetSet< T >::clear(), GEMDigiModel::detectorHitMap_, digitizeOnlyMuons_, getSimHitBx(), GEMEtaPartition::id(), DetId::rawId(), simulateClustering(), GEMDigiModel::stripDigiSimLinks_, and GEMDigiModel::strips_.

{
  stripDigiSimLinks_.clear();
  detectorHitMap_.clear();
  stripDigiSimLinks_ = StripDigiSimLinks(roll->id().rawId());

  for (edm::PSimHitContainer::const_iterator hit = simHits.begin(); hit != simHits.end(); ++hit)
  {
   if (std::abs(hit->particleType()) != 13 && digitizeOnlyMuons_)
      continue;

    // Check GEM efficiency
    if (CLHEP::RandFlat::shoot(engine) > averageEfficiency_) continue;
    const int bx(getSimHitBx(&(*hit), engine));
    const std::vector<std::pair<int, int> > cluster(simulateClustering(roll, &(*hit), bx, engine));
    for  (auto & digi : cluster)
    {
      detectorHitMap_.insert(DetectorHitMap::value_type(digi,&*(hit)));
      strips_.insert(digi);
    }
  }
}

Member Data Documentation

double GEMSimpleModel::averageEfficiency_

private

Definition at line 43 of file GEMSimpleModel.h.

Referenced by simulateClustering(), simulateNoise(), and simulateSignal().

double GEMSimpleModel::averageNoiseRate_

private

Definition at line 47 of file GEMSimpleModel.h.

Referenced by simulateNoise().

double GEMSimpleModel::averageShapingTime_

private

Definition at line 44 of file GEMSimpleModel.h.

Referenced by getSimHitBx().

int GEMSimpleModel::bxwidth_

private

Definition at line 52 of file GEMSimpleModel.h.

Referenced by getSimHitBx(), and simulateNoise().

std::vector<double> GEMSimpleModel::clsParametrization_

private

Definition at line 49 of file GEMSimpleModel.h.

Referenced by simulateClustering(), and simulateNoise().

double GEMSimpleModel::constNeuGE11_

private

Definition at line 63 of file GEMSimpleModel.h.

Referenced by simulateNoise().

bool GEMSimpleModel::cosmics_

private

Definition at line 51 of file GEMSimpleModel.h.

Referenced by getSimHitBx().

bool GEMSimpleModel::digitizeOnlyMuons_

private

Definition at line 55 of file GEMSimpleModel.h.

Referenced by simulateSignal().

bool GEMSimpleModel::doBkgNoise_

private

Definition at line 56 of file GEMSimpleModel.h.

Referenced by simulateNoise().

bool GEMSimpleModel::doNoiseCLS_

private

Definition at line 57 of file GEMSimpleModel.h.

Referenced by simulateNoise().

bool GEMSimpleModel::fixedRollRadius_

private

Definition at line 58 of file GEMSimpleModel.h.

Referenced by simulateNoise().

std::vector<double> GEMSimpleModel::GE11ElecBkgParams_

private

Definition at line 66 of file GEMSimpleModel.h.

Referenced by simulateNoise().

std::vector<double> GEMSimpleModel::GE21ElecBkgParams_

private

Definition at line 67 of file GEMSimpleModel.h.

Referenced by simulateNoise().

std::vector<double> GEMSimpleModel::GE21NeuBkgParams_

private

Definition at line 65 of file GEMSimpleModel.h.

Referenced by simulateNoise().

int GEMSimpleModel::maxBunch_

private

Definition at line 54 of file GEMSimpleModel.h.

Referenced by simulateNoise().

int GEMSimpleModel::minBunch_

private

Definition at line 53 of file GEMSimpleModel.h.

Referenced by simulateNoise().

double GEMSimpleModel::minPabsNoiseCLS_

private

Definition at line 59 of file GEMSimpleModel.h.

Referenced by simulateClustering().

double GEMSimpleModel::scaleLumi_

private

Definition at line 61 of file GEMSimpleModel.h.

Referenced by simulateNoise().

double GEMSimpleModel::signalPropagationSpeed_

private

Definition at line 50 of file GEMSimpleModel.h.

Referenced by getSimHitBx().

bool GEMSimpleModel::simulateElectronBkg_

private

Definition at line 62 of file GEMSimpleModel.h.

Referenced by simulateNoise().

bool GEMSimpleModel::simulateIntrinsicNoise_

private

Definition at line 60 of file GEMSimpleModel.h.

Referenced by simulateNoise().

double GEMSimpleModel::slopeNeuGE11_

private

Definition at line 64 of file GEMSimpleModel.h.

Referenced by simulateNoise().

double GEMSimpleModel::timeJitter_

private

Definition at line 46 of file GEMSimpleModel.h.

Referenced by getSimHitBx().

double GEMSimpleModel::timeResolution_

private

Definition at line 45 of file GEMSimpleModel.h.

Referenced by getSimHitBx().