SubsystemNeutronWriter Class Reference

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 ()
void	produce (edm::Event &e, edm::EventSetup const &c) override
	SubsystemNeutronWriter (edm::ParameterSet const &pset)
	~SubsystemNeutronWriter () override
	destructor prints statistics on number of events written More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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 *)

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::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

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::SubsystemNeutronWriter ( edm::ParameterSet const &  pset )

explicit

Definition at line 24 of file SubsystemNeutronWriter.cc.

    : theHitWriter(nullptr),
      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;
  }
}

References Exception, edm::Service< T >::isAvailable(), convertSQLitetoXML_cfg::output, muonDTDigis_cfi::pset, theHitWriter, useLocalDetId_, useRandFlat, and cscNeutronWriter_cfi::writer.

~SubsystemNeutronWriter()

SubsystemNeutronWriter::~SubsystemNeutronWriter ( )

override

destructor prints statistics on number of events written

Definition at line 59 of file SubsystemNeutronWriter.cc.

                                                {
  printStats();
  delete theHitWriter;
}

References printStats(), and theHitWriter.

Member Function Documentation

accept()

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 esMonitoring.FDJsonServer::handle_accept(), and writeCluster().

adjust()

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

protected

helper to add time offsets and local det ID

Definition at line 153 of file SubsystemNeutronWriter.cc.

                                                                                {
  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());
}

References localDetId(), CalibratedDigis_cfi::timeOffset, and useLocalDetId_.

Referenced by writeHits().

chamberId()

virtual int SubsystemNeutronWriter::chamberId ( int  globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by produce().

chamberType()

virtual int SubsystemNeutronWriter::chamberType ( int  globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by initialize(), produce(), updateCount(), writeCluster(), and writeHits().

initialize()

void SubsystemNeutronWriter::initialize

(

int

chamberType

)

good practice to do once for each chamber type

Definition at line 101 of file SubsystemNeutronWriter.cc.

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

References chamberType(), NeutronWriter::initialize(), and theHitWriter.

Referenced by CSCNeutronWriter::CSCNeutronWriter().

localDetId()

virtual int SubsystemNeutronWriter::localDetId ( int  globalDetId ) const

pure virtual

Implemented in CSCNeutronWriter, RPCNeutronWriter, and DTNeutronWriter.

Referenced by adjust().

printStats()

void SubsystemNeutronWriter::printStats

(

)

Definition at line 64 of file SubsystemNeutronWriter.cc.

                                        {
  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";
  }
}

References theCountPerChamberType, and theNEvents.

Referenced by ~SubsystemNeutronWriter().

produce()

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

override

Definition at line 73 of file SubsystemNeutronWriter.cc.

                                                                        {
  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();
}

References NeutronWriter::beginEvent(), HltBtagPostValidation_cff::c, chamberId(), chamberType(), MillePedeFileConverter_cfg::e, NeutronWriter::endEvent(), edm::RandomNumberGenerator::getEngine(), hfClusterShapes_cfi::hits, theHitWriter, theInputTag, theNEvents, useRandFlat, and writeHits().

updateCount()

void SubsystemNeutronWriter::updateCount ( int  chamberType )

protected

updates the counter

Definition at line 172 of file SubsystemNeutronWriter.cc.

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

References chamberType(), mps_splice::entry, and theCountPerChamberType.

Referenced by writeCluster().

writeCluster()

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

protected

Definition at line 146 of file SubsystemNeutronWriter.cc.

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

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

Referenced by writeHits().

writeHits()

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

protectedvirtual

Definition at line 107 of file SubsystemNeutronWriter.cc.

                                                                     {
  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);
  }
}

References adjust(), chamberType(), mps_fire::i, LogDebug, theNeutronTimeCut, theT0, theTimeWindow, useRandFlat, and writeCluster().

Referenced by produce().

Member Data Documentation

initialized

bool SubsystemNeutronWriter::initialized

private

Definition at line 70 of file SubsystemNeutronWriter.h.

theCountPerChamberType

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

private

Definition at line 73 of file SubsystemNeutronWriter.h.

Referenced by printStats(), and updateCount().

theHitWriter

NeutronWriter* SubsystemNeutronWriter::theHitWriter

private

Definition at line 63 of file SubsystemNeutronWriter.h.

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

theInputTag

edm::InputTag SubsystemNeutronWriter::theInputTag

private

Definition at line 65 of file SubsystemNeutronWriter.h.

Referenced by produce().

theNeutronTimeCut

double SubsystemNeutronWriter::theNeutronTimeCut

private

Definition at line 66 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

theNEvents

int SubsystemNeutronWriter::theNEvents

private

Definition at line 69 of file SubsystemNeutronWriter.h.

Referenced by printStats(), and produce().

theT0

double SubsystemNeutronWriter::theT0

private

Definition at line 68 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

theTimeWindow

double SubsystemNeutronWriter::theTimeWindow

private

Definition at line 67 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

useLocalDetId_

bool SubsystemNeutronWriter::useLocalDetId_

private

Definition at line 72 of file SubsystemNeutronWriter.h.

Referenced by adjust(), and SubsystemNeutronWriter().

useRandFlat

bool SubsystemNeutronWriter::useRandFlat

private

Definition at line 64 of file SubsystemNeutronWriter.h.

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