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
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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
const edm::EDGetTokenT< edm::PSimHitContainer >	hitToken_
bool	initialized
std::map< int, int >	theCountPerChamberType
NeutronWriter *	theHitWriter
const edm::InputTag	theInputTag
const double	theNeutronTimeCut
int	theNEvents
const double	theT0
const double	theTimeWindow
bool	useLocalDetId_
bool	useRandFlat

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::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.

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

    : 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")),
      hitToken_(consumes<edm::PSimHitContainer>(theInputTag)),
      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::~SubsystemNeutronWriter ( )

override

destructor prints statistics on number of events written

Definition at line 60 of file SubsystemNeutronWriter.cc.

References printStats(), and theHitWriter.

                                                {
  printStats();
  delete 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.

References h, localDetId(), simBeamSpotPI::timeOffset, 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());
}

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.

References chamberType(), 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);
}

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

produce()

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

override

Definition at line 74 of file SubsystemNeutronWriter.cc.

References NeutronWriter::beginEvent(), HltBtagPostValidation_cff::c, chamberId(), chamberType(), MillePedeFileConverter_cfg::e, NeutronWriter::endEvent(), edm::RandomNumberGenerator::getEngine(), hfClusterShapes_cfi::hits, hitToken_, theHitWriter, 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;
  const edm::Handle<edm::PSimHitContainer>& hits = e.getHandle(hitToken_);

  // sort hits by chamber
  std::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 (std::map<int, edm::PSimHitContainer>::iterator hitsByChamberItr = hitsByChamber.begin();
       hitsByChamberItr != hitsByChamber.end();
       ++hitsByChamberItr) {
    int chambertype = chamberType(hitsByChamberItr->first);
    writeHits(chambertype, hitsByChamberItr->second, engine);
  }
  theHitWriter->endEvent();
}

updateCount()

void SubsystemNeutronWriter::updateCount ( int  chamberType )

protected

updates the counter

Definition at line 172 of file SubsystemNeutronWriter.cc.

References chamberType(), mps_splice::entry, and 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);
  }
}

writeCluster()

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

protected

Definition at line 146 of file SubsystemNeutronWriter.cc.

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

Referenced by writeHits().

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

writeHits()

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

protectedvirtual

Definition at line 107 of file SubsystemNeutronWriter.cc.

References adjust(), chamberType(), mps_fire::i, LogDebug, jetUpdater_cfi::sort, beamSpotPI::startTime, theNeutronTimeCut, theT0, theTimeWindow, 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

hitToken_

const edm::EDGetTokenT<edm::PSimHitContainer> SubsystemNeutronWriter::hitToken_

private

Definition at line 69 of file SubsystemNeutronWriter.h.

Referenced by produce().

initialized

bool SubsystemNeutronWriter::initialized

private

Definition at line 71 of file SubsystemNeutronWriter.h.

theCountPerChamberType

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

private

Definition at line 74 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

const edm::InputTag SubsystemNeutronWriter::theInputTag

private

Definition at line 65 of file SubsystemNeutronWriter.h.

theNeutronTimeCut

const double SubsystemNeutronWriter::theNeutronTimeCut

private

Definition at line 66 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

theNEvents

int SubsystemNeutronWriter::theNEvents

private

Definition at line 70 of file SubsystemNeutronWriter.h.

Referenced by printStats(), and produce().

theT0

const double SubsystemNeutronWriter::theT0

private

Definition at line 68 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

theTimeWindow

const double SubsystemNeutronWriter::theTimeWindow

private

Definition at line 67 of file SubsystemNeutronWriter.h.

Referenced by writeHits().

useLocalDetId_

bool SubsystemNeutronWriter::useLocalDetId_

private

Definition at line 73 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().