doesn't have to be a producer. Can act as an analyzer, too. More...

#include <SubsystemNeutronWriter.h>

Inheritance diagram for SubsystemNeutronWriter:

Public Member Functions
virtual bool	accept (const edm::PSimHitContainer &cluster) const =0
	decides whether this cluster is good enough to be included More...

virtual int	chamberId (int globalDetId) const =0

virtual int	chamberType (int globalDetId) const =0

void	initialize (int chamberType)
	good practice to do once for each chamber type More...

virtual int	localDetId (int globalDetId) const =0

void	printStats ()

virtual void	produce (edm::Event &e, edm::EventSetup const &c)

	SubsystemNeutronWriter (edm::ParameterSet const &pset)

virtual	~SubsystemNeutronWriter ()
	destructor prints statistics on number of events written More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	adjust (PSimHit &h, float timeOffset, float smearing)
	helper to add time offsets and local det ID More...

void	updateCount (int chamberType)
	updates the counter More...

void	writeCluster (int chamberType, const edm::PSimHitContainer &cluster)

virtual void	writeHits (int chamberType, edm::PSimHitContainer &chamberHits, CLHEP::HepRandomEngine *)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Attributes
bool	initialized

std::map< int, int >	theCountPerChamberType

NeutronWriter *	theHitWriter

edm::InputTag	theInputTag

double	theNeutronTimeCut

int	theNEvents

double	theT0

double	theTimeWindow

bool	useLocalDetId_

bool	useRandFlat

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

doesn't have to be a producer. Can act as an analyzer, too.

Definition at line 28 of file SubsystemNeutronWriter.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 27 of file SubsystemNeutronWriter.cc.

References Exception, edm::ParameterSet::getParameter(), edm::Service< T >::isAvailable(), convertSQLitetoXML_cfg::output, theHitWriter, useLocalDetId_, and useRandFlat.

 : theHitWriter(0),
   useRandFlat(false),
   theInputTag(pset.getParameter<edm::InputTag>("input")),
   theNeutronTimeCut(pset.getParameter<double>("neutronTimeCut")),
   theTimeWindow(pset.getParameter<double>("timeWindow")),
   theT0(pset.getParameter<double>("t0")),
   theNEvents(0),
   initialized(false),
   useLocalDetId_(true)
 {
   string writer = pset.getParameter<string>("writer");
   string output = pset.getParameter<string>("output");
   if(writer == "ASCII")
   {
     theHitWriter = new AsciiNeutronWriter(output);
   }
   else if (writer == "ROOT")
   {
     theHitWriter = new RootNeutronWriter(output);
   }
   else if (writer == "EDM")
   {
     produces<edm::PSimHitContainer>();
     theHitWriter = new EDMNeutronWriter();
     // write out the real DetId, not the local one
     useLocalDetId_ = false;
     // smear the times
     edm::Service<edm::RandomNumberGenerator> rng;
     if ( ! rng.isAvailable()) {
      throw cms::Exception("Configuration")
        << "SubsystemNeutronWriter requires the RandomNumberGeneratorService\n"
           "which is not present in the configuration file.  You must add the service\n"
           "in the configuration file or remove the modules that require it.";
     }
     useRandFlat = true;
   }
   else 
   {
     throw cms::Exception("NeutronWriter") << "Bad writer: "
       << writer;
   } 
 }

SubsystemNeutronWriter::~SubsystemNeutronWriter ( )

virtual

destructor prints statistics on number of events written

Definition at line 72 of file SubsystemNeutronWriter.cc.

References printStats(), and theHitWriter.

 {
   printStats();
   delete theHitWriter;
 }

Member Function Documentation

virtual bool SubsystemNeutronWriter::accept ( const edm::PSimHitContainer & cluster ) const

pure virtual

decides whether this cluster is good enough to be included

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by Vispa.Gui.BoxContentDialog.BoxContentDialog::apply(), Vispa.Plugins.ConfigEditor.ToolDialog.ToolDialog::apply(), esMonitoring.FDJsonServer::handle_accept(), and writeCluster().

void SubsystemNeutronWriter::adjust	(	PSimHit &	h,
		float	timeOffset,
		float	smearing
	)

protected

helper to add time offsets and local det ID

Definition at line 182 of file SubsystemNeutronWriter.cc.

References PSimHit::detUnitId(), PSimHit::energyLoss(), PSimHit::entryPoint(), PSimHit::exitPoint(), localDetId(), PSimHit::momentumAtEntry(), PSimHit::pabs(), PSimHit::particleType(), PV3DBase< T, PVType, FrameType >::phi(), PV3DBase< T, PVType, FrameType >::theta(), PSimHit::timeOfFlight(), PSimHit::trackId(), and useLocalDetId_.

Referenced by writeHits().

                                                                                  {
   unsigned int detId = useLocalDetId_ ? localDetId(h.detUnitId()) : h.detUnitId();
   float htime = h.timeOfFlight() + timeOffset + smearing;
   // prevent float precision loss
   if (h.timeOfFlight() > 1.E+6) {
     htime = smearing;
   }
   h = PSimHit( h.entryPoint(), h.exitPoint(), h.pabs(), htime,
                h.energyLoss(), h.particleType(), 
                detId, h.trackId(),
                h.momentumAtEntry().theta(),
                h.momentumAtEntry().phi() );
 }

virtual int SubsystemNeutronWriter::chamberId ( int globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by produce().

virtual int SubsystemNeutronWriter::chamberType ( int globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by produce(), and writeHits().

void SubsystemNeutronWriter::initialize ( int chamberType )

good practice to do once for each chamber type

Definition at line 122 of file SubsystemNeutronWriter.cc.

References NeutronWriter::initialize(), and theHitWriter.

Referenced by CSCNeutronWriter::CSCNeutronWriter().

 {
   // should instantiate one of every chamber type, just so
   // ROOT knows what file to associate them with
   theHitWriter->initialize(chamberType);
 }

virtual int SubsystemNeutronWriter::localDetId ( int globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by adjust().

void SubsystemNeutronWriter::printStats ( )

Definition at line 80 of file SubsystemNeutronWriter.cc.

References theCountPerChamberType, and theNEvents.

Referenced by ~SubsystemNeutronWriter().

                                         {
   edm::LogInfo("SubsystemNeutronWriter") << "SubsystemNeutronWriter Statistics:\n";
   for(map<int,int>::iterator mapItr = theCountPerChamberType.begin();
       mapItr != theCountPerChamberType.end();  ++mapItr) {
      edm::LogInfo("SubsystemNeutronWriter") << "   theEventOccupancy[" << mapItr->first << "] = "
          << mapItr->second << " / " << theNEvents << " / NCT \n";
   }
 }

void SubsystemNeutronWriter::produce	(	edm::Event &	e,
		edm::EventSetup const &	c
	)

virtual

Implements edm::EDProducer.

Definition at line 90 of file SubsystemNeutronWriter.cc.

References NeutronWriter::beginEvent(), chamberId(), chamberType(), NeutronWriter::endEvent(), edm::Event::getByLabel(), edm::RandomNumberGenerator::getEngine(), edm::Event::streamID(), theHitWriter, theInputTag, theNEvents, useRandFlat, and writeHits().

 {
   CLHEP::HepRandomEngine* engine = nullptr;
   if(useRandFlat) {
     edm::Service<edm::RandomNumberGenerator> rng;
     engine = &rng->getEngine(e.streamID());
   }
   theHitWriter->beginEvent(e,c);
   ++theNEvents;
   edm::Handle<edm::PSimHitContainer> hits;
   e.getByLabel(theInputTag, hits);
 
   // sort hits by chamber
   map<int, edm::PSimHitContainer> hitsByChamber;
   for(edm::PSimHitContainer::const_iterator hitItr = hits->begin();
       hitItr != hits->end(); ++hitItr)
   {
     int chamberIndex = chamberId(hitItr->detUnitId());
     hitsByChamber[chamberIndex].push_back(*hitItr);
   }
 
   // now write out each chamber's contents
   for(map<int, edm::PSimHitContainer>::iterator hitsByChamberItr = hitsByChamber.begin();
       hitsByChamberItr != hitsByChamber.end(); ++hitsByChamberItr)
   {
     int chambertype = chamberType(hitsByChamberItr->first);
     writeHits(chambertype, hitsByChamberItr->second, engine);
   }
   theHitWriter->endEvent();
 }

void SubsystemNeutronWriter::updateCount ( int chamberType )

protected

updates the counter

Definition at line 197 of file SubsystemNeutronWriter.cc.

References theCountPerChamberType.

Referenced by writeCluster().

                                                         {
   map<int,int>::iterator entry = theCountPerChamberType.find(chamberType);
   if(entry == theCountPerChamberType.end()) {
     theCountPerChamberType.insert( pair<int,int>(chamberType, 1) );
   } else {
     ++(entry->second);
   }
 }

void SubsystemNeutronWriter::writeCluster	(	int	chamberType,
		const edm::PSimHitContainer &	cluster
	)

protected

Definition at line 172 of file SubsystemNeutronWriter.cc.

References accept(), theHitWriter, updateCount(), and NeutronWriter::writeCluster().

Referenced by writeHits().

 {
   if(accept(cluster))
   {
     theHitWriter->writeCluster(chamberType, cluster);
     updateCount(chamberType);
   }
 }

void SubsystemNeutronWriter::writeHits	(	int	chamberType,
		edm::PSimHitContainer &	chamberHits,
		CLHEP::HepRandomEngine *	engine
	)

protectedvirtual

Definition at line 130 of file SubsystemNeutronWriter.cc.

References adjust(), chamberType(), PSimHit::detUnitId(), i, LogDebug, PSimHit::pabs(), PSimHit::particleType(), python.multivaluedict::sort(), theNeutronTimeCut, theT0, theTimeWindow, PSimHit::tof(), useRandFlat, and writeCluster().

Referenced by produce().

 {
 
   sort(chamberHits.begin(), chamberHits.end(), SortByTime());
   edm::PSimHitContainer cluster;
   float startTime = -1000.;
   float smearing = 0.;
   for(size_t i = 0; i < chamberHits.size(); ++i) {
     PSimHit hit = chamberHits[i];
     float tof = hit.tof();
     LogDebug("SubsystemNeutronWriter") << "found hit from part type " << hit.particleType()
                    << " at tof " << tof << " p " << hit.pabs() 
                    << " on det " << hit.detUnitId() 
                    << " chamber type " << chamberType;
     if(tof > theNeutronTimeCut) {
       if(tof > (startTime + theTimeWindow) ) { // 1st in cluster
         startTime = tof;
         // set the time to be [t0, t0+25] at start of event
         smearing = theT0;
         if(useRandFlat) {
           smearing += CLHEP::RandFlat::shoot(engine, 25.);
         }
         if(!cluster.empty()) {
           LogDebug("SubsystemNeutronWriter") << "filling old cluster";
           writeCluster(chamberType, cluster);
           cluster.clear();
         }
         LogDebug("SubsystemNeutronWriter") << "starting neutron cluster at time " << startTime 
           << " on detType " << chamberType;
       }
       adjust(hit, -1.*startTime, smearing);
       cluster.push_back( hit );
     }
   }
   // get any leftover cluster
   if(!cluster.empty()) {
     writeCluster(chamberType, cluster);
   }
 }

Member Data Documentation

bool SubsystemNeutronWriter::initialized

private

Definition at line 74 of file SubsystemNeutronWriter.h.

std::map<int, int> SubsystemNeutronWriter::theCountPerChamberType

private

Definition at line 77 of file SubsystemNeutronWriter.h.

Referenced by printStats(), and updateCount().

NeutronWriter* SubsystemNeutronWriter::theHitWriter

private

Definition at line 67 of file SubsystemNeutronWriter.h.

Referenced by initialize(), produce(), SubsystemNeutronWriter(), writeCluster(), and ~SubsystemNeutronWriter().

edm::InputTag SubsystemNeutronWriter::theInputTag

private

Definition at line 69 of file SubsystemNeutronWriter.h.

Referenced by produce().

double SubsystemNeutronWriter::theNeutronTimeCut

private

Definition at line 70 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

int SubsystemNeutronWriter::theNEvents

private

Definition at line 73 of file SubsystemNeutronWriter.h.

Referenced by printStats(), and produce().

double SubsystemNeutronWriter::theT0

private

Definition at line 72 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

double SubsystemNeutronWriter::theTimeWindow

private

Definition at line 71 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

bool SubsystemNeutronWriter::useLocalDetId_

private

Definition at line 76 of file SubsystemNeutronWriter.h.

Referenced by adjust(), and SubsystemNeutronWriter().

bool SubsystemNeutronWriter::useRandFlat

private

Definition at line 68 of file SubsystemNeutronWriter.h.

Referenced by produce(), SubsystemNeutronWriter(), and writeHits().

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation