#include <SubsystemNeutronReader.h>

Inheritance diagram for SubsystemNeutronReader:

Public Member Functions
void	clear ()

void	generateChamberNoise (int chamberType, int chamberIndex, edm::PSimHitContainer &result, CLHEP::HepRandomEngine *)

	SubsystemNeutronReader (const edm::ParameterSet &pset)

virtual	~SubsystemNeutronReader ()

Protected Member Functions
virtual int	detId (int chamberIndex, int localDetId)=0

Private Attributes
std::vector< int >	theChambersDone
	just makes sure chambers aren't done twice More...

float	theEndTime

std::vector< double >	theEventOccupancy

float	theEventsInWindow
	how many collsions happened between theStartTime and theEndTime More...

NeutronReader *	theHitReader

float	theLuminosity
	in units of 10**34, set by Muon:NeutronLuminosity More...

float	theStartTime

Detailed Description

Definition at line 20 of file SubsystemNeutronReader.h.

Constructor & Destructor Documentation

SubsystemNeutronReader::SubsystemNeutronReader ( const edm::ParameterSet & pset )

the hits will be distributed flat in time between startTime and endTime eventOccupancy is the expected chamber occupancy from a single min bias event for each chamber type

Definition at line 13 of file SubsystemNeutronReader.cc.

References edm::ParameterSet::getParameter(), input, createfilelist::int, matplotRender::reader, theEndTime, theEventsInWindow, theHitReader, theLuminosity, and theStartTime.

 : theHitReader(nullptr),
   theLuminosity(pset.getParameter<double>("luminosity")), // in units of 10^34
   theStartTime(pset.getParameter<double>("startTime")), 
   theEndTime(pset.getParameter<double>("endTime")),
   theEventOccupancy(pset.getParameter<vector<double> >("eventOccupancy")) // TODO make map
 {
   // 17.3 collisions per live bx, 79.5% of bx live
   float collisionsPerCrossing = 13.75 * theLuminosity;
   int windowSize = (int)((theEndTime-theStartTime)/25.);
   theEventsInWindow = collisionsPerCrossing * windowSize;
   string reader = pset.getParameter<string>("reader");
   edm::FileInPath input = pset.getParameter<edm::FileInPath>("input");
   if(reader == "ASCII")
   {
     theHitReader = new AsciiNeutronReader(input.fullPath());
   }
   else if (reader == "ROOT")
   {
     theHitReader = new RootNeutronReader(input.fullPath());
   }
 }

SubsystemNeutronReader::~SubsystemNeutronReader ( )

virtual

Definition at line 37 of file SubsystemNeutronReader.cc.

References theHitReader.

                                                 {
   delete theHitReader;
 }

Member Function Documentation

void SubsystemNeutronReader::clear ( void )

inline

Definition at line 34 of file SubsystemNeutronReader.h.

34 {theChambersDone.clear();}

SubsystemNeutronReader::theChambersDone

std::vector< int > theChambersDone

just makes sure chambers aren't done twice

Definition: SubsystemNeutronReader.h:47

virtual int SubsystemNeutronReader::detId	(	int	chamberIndex,
		int	localDetId
	)

protectedpure virtual

detector-specific way to get the global detector ID, given the local one.

Implemented in CSCNeutronReader.

Referenced by generateChamberNoise().

void SubsystemNeutronReader::generateChamberNoise	(	int	chamberType,
		int	chamberIndex,
		edm::PSimHitContainer &	result,
		CLHEP::HepRandomEngine *	engine
	)

this class makes sure the same chamberIndex isn't called twice for an event

Definition at line 43 of file SubsystemNeutronReader.cc.

References detId(), PSimHit::detUnitId(), PSimHit::energyLoss(), PSimHit::entryPoint(), PSimHit::exitPoint(), spr::find(), mps_fire::i, PSimHit::pabs(), PSimHit::particleType(), PSimHit::phiAtEntry(), PSimHit::processType(), NeutronReader::readNextEvent(), theChambersDone, theEndTime, theEventOccupancy, theEventsInWindow, theHitReader, theStartTime, PSimHit::thetaAtEntry(), hgcalLayerClusters_cff::timeOffset, PSimHit::tof(), and PSimHit::trackId().

Referenced by CSCNeutronReader::addHits().

 {
   // make sure this chamber hasn't been done before
   if(find(theChambersDone.begin(), theChambersDone.end(), chamberIndex) 
      == theChambersDone.end()) 
   {
     float meanNumberOfEvents = theEventOccupancy[chamberType-1] 
                              * theEventsInWindow;
     CLHEP::RandPoissonQ randPoissonQ(*engine, meanNumberOfEvents);
     int nEventsToAdd = randPoissonQ.fire();
 //    LogDebug("NeutronReader") << "Number of neutron events to add: " 
 //std::cout << "Number of neutron events to add for chamber type " << chamberType << " : " 
 // << nEventsToAdd <<  " mean " << meanNumberOfEvents << std::endl;
 //                   << nEventsToAdd <<  " mean " << meanNumberOfEvents;
 
     for(int i = 0; i < nEventsToAdd; ++i) {
       // find the time for this event
       float timeOffset = CLHEP::RandFlat::shoot(engine, theStartTime, theEndTime);
       vector<PSimHit> neutronHits;
       theHitReader->readNextEvent(chamberType, neutronHits);
 
       for( vector<PSimHit>::const_iterator neutronHitItr = neutronHits.begin();
            neutronHitItr != neutronHits.end(); ++neutronHitItr)
       {
          const PSimHit & rawHit = *neutronHitItr;
          // do the time offset and local det id
          int det = detId(chamberIndex, rawHit.detUnitId());
          PSimHit hit(rawHit.entryPoint(), rawHit.exitPoint(), rawHit.pabs(),
                      rawHit.tof()+timeOffset,
                      rawHit.energyLoss(), rawHit.particleType(),
                      det, rawHit.trackId(),
                      rawHit.thetaAtEntry(),  rawHit.phiAtEntry(), rawHit.processType());
 //std::cout << "NEWHIT " << hit << std::endl;
          result.push_back(hit);
       }
 
     }
     theChambersDone.push_back(chamberIndex);
   }
 }