CSCBaseElectronicsSim.h

Go to the documentation of this file.

#ifndef MU_END_BASE_ELECTRONICS_SIM_H
#define MU_END_BASE_ELECTRONICS_SIM_H
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "SimMuon/CSCDigitizer/src/CSCAnalogSignal.h"
#include <map>
#include <vector>
 
#include "DataFormats/Common/interface/DetSet.h"
#include "SimDataFormats/TrackerDigiSimLink/interface/StripDigiSimLink.h"
 
// declarations
class CSCLayer;
class CSCChamberSpecs;
class CSCDetectorHit;
class CSCLayerGeometry;
#include "DataFormats/MuonDetId/interface/CSCDetId.h"
class DetId;
class PSimHit;
 
namespace CLHEP {
  class HepRandomEngine;
}
 
class CSCBaseElectronicsSim {
public:
  typedef std::map<int, CSCAnalogSignal, std::less<int>> CSCSignalMap;
  typedef edm::DetSet<StripDigiSimLink> DigiSimLinks;
 
  // takes the input detector hits, turns them into DIGIs, and
  // stores them in the layer
  void simulate(const CSCLayer *layer, const std::vector<CSCDetectorHit> &inputHits, CLHEP::HepRandomEngine *);
 
  const DigiSimLinks &digiSimLinks() const { return theDigiSimLinks; }
 
  virtual ~CSCBaseElectronicsSim();
 
  void setLayerId(const CSCDetId &id) { theLayerId = id; }
 
protected:
  // constructor protected, so this class must be a base class
  CSCBaseElectronicsSim(const edm::ParameterSet &p);
 
  void setLayer(const CSCLayer *layer);
  // initialize things that change from layer to layer
  virtual void initParameters() = 0;
 
  void fillAmpResponse();
  virtual float calculateAmpResponse(float t) const = 0;
 
  // this one turns CSCDetectorHits into CSCAnalogSignals
  CSCAnalogSignal amplifySignal(const CSCDetectorHit &);
 
  // returns readout element.  So wire 20 might be part of wire group 2.
  virtual int readoutElement(int element) const = 0;
 
  //  fills the member map of signals on strips, superimposing any duplicates
  void combineAnalogSignals(const std::vector<CSCAnalogSignal> &);
 
  void setNoise(float rmsNoise, float noiseSigmaThreshold);
 
  void setSignalTimeRange(double startTime, double stopTime) {
    theSignalStartTime = startTime;
    theSignalStopTime = stopTime;
  }
 
  void addNoise(CLHEP::HepRandomEngine *);
 
  CSCAnalogSignal &find(int element, CLHEP::HepRandomEngine *);
  // the returned signal will be the one stored in the
  // signal, not the original.  If another signal
  // is found on this element, they will be superimposed.
  CSCAnalogSignal &add(const CSCAnalogSignal &, CLHEP::HepRandomEngine *);
  virtual CSCAnalogSignal makeNoiseSignal(int element, CLHEP::HepRandomEngine *);
 
  virtual float signalDelay(int element, float pos) const;
 
  virtual void addLinks(int channelIndex);
 
  virtual int channelIndex(int channel) const { return channel; }
 
  CSCDetId layerId() const { return theLayerId; }
 
  double averageTimeOfFlight(const DetId &detId) const;
 
  // member data
  enum { NONE, CONSERVATIVE, RADICAL };
 
  const CSCChamberSpecs *theSpecs;
  const CSCLayerGeometry *theLayerGeometry;
  const CSCLayer *theLayer;  // the one currently being digitized
  CSCDetId theLayerId;
 
  CSCSignalMap theSignalMap;
  CSCAnalogSignal theAmpResponse;
 
  // Useful parameters
  float theBunchSpacing;
 
  // lets routines know whether new signals should
  //  have noise added, or just be empty.  If the
  //  noise hasn't been added yet, just make empty.
  bool theNoiseWasAdded;
 
  // the numbers of wire groups or strips in this layer
  int nElements;
 
  // amplifier parameters
  int theShapingTime;
  float thePeakTimeSigma;
  // used to correct the bunch timing so that the signal event
  // comes at BX zero.
  std::vector<double> theBunchTimingOffsets;
 
  // when the signal is to be simulated
  float theSignalStartTime;
  float theSignalStopTime;
 
  // size of time bins for signal shape, in ns
  float theSamplingTime;
 
  // time bins for pulse shape
  int theNumberOfSamples;
 
  // Which bit in the 16-bit time word corresponds to the zeroth beam crossing?
  int theOffsetOfBxZero;  // bit corresponding to bx 0 (counting from 0-15)
  std::vector<double> theSignalPropagationSpeed;
  std::vector<double> theTimingCalibrationError;
  bool doNoise_;
 
  // keeps track of which hits contribute to which channels
  typedef std::multimap<int, CSCDetectorHit, std::less<int>> DetectorHitMap;
  DetectorHitMap theDetectorHitMap;
  DigiSimLinks theDigiSimLinks;
};
 
#endif