RPDigiProducer Class Reference

Inheritance diagram for RPDigiProducer:

Public Member Functions
	RPDigiProducer (const edm::ParameterSet &)
	~RPDigiProducer () override=default
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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef std::map< unsigned int, std::vector< PSimHit > >	simhit_map
typedef simhit_map::iterator	simhit_map_iterator

Private Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override
edm::DetSet< TotemRPDigi >	convertRPStripDetSet (const edm::DetSet< TotemRPDigi > &)
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::ESGetToken< CTPPSRPAlignmentCorrectionsData, VeryForwardMisalignedGeometryRecord >	alignmentToken
edm::ParameterSet	conf_
DeadChannelsManager	deadChannelsManager
edm::ESGetToken< CTPPSGeometry, VeryForwardRealGeometryRecord >	geomToken
CLHEP::HepRandomEngine *	rndEngine_ = nullptr
std::vector< std::string >	RP_hit_containers_
bool	simulateDeadChannels
std::map< RPDetId, std::unique_ptr< RPDetDigitizer > >	theAlgoMap
edm::ESGetToken< TotemAnalysisMask, TotemReadoutRcd >	tokenAnalysisMask
edm::EDGetTokenT< CrossingFrame< PSimHit > >	tokenCrossingFrameTotemRP
int	verbosity_

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

Definition at line 55 of file RPDigiProducer.cc.

Member Typedef Documentation

simhit_map

typedef std::map<unsigned int, std::vector<PSimHit> > RPDigiProducer::simhit_map

private

Definition at line 70 of file RPDigiProducer.cc.

simhit_map_iterator

typedef simhit_map::iterator RPDigiProducer::simhit_map_iterator

private

Definition at line 71 of file RPDigiProducer.cc.

Constructor & Destructor Documentation

RPDigiProducer()

RPDigiProducer::RPDigiProducer ( const edm::ParameterSet &  conf )

explicit

Definition at line 95 of file RPDigiProducer.cc.

References alignmentToken, deDxTools::esConsumes(), edm::ParameterSet::exists(), geomToken, edm::ParameterSet::getParameter(), HLT_2022v15_cff::InputTag, RP_hit_containers_, simulateDeadChannels, tokenAnalysisMask, tokenCrossingFrameTotemRP, and verbosity_.

                                                          : conf_(conf) {
  //now do what ever other initialization is needed
  produces<edm::DetSetVector<TotemRPDigi>>();

  // register data to consume
  tokenCrossingFrameTotemRP = consumes<CrossingFrame<PSimHit>>(edm::InputTag("mix", "g4SimHitsTotemHitsRP", ""));

  RP_hit_containers_ = conf.getParameter<std::vector<std::string>>("ROUList");
  verbosity_ = conf.getParameter<int>("RPVerbosity");

  simulateDeadChannels = false;
  if (conf.exists(
          "simulateDeadChannels")) {  //check if "simulateDeadChannels" variable is defined in configuration file
    simulateDeadChannels = conf.getParameter<bool>("simulateDeadChannels");
  }
  if (simulateDeadChannels) {
    tokenAnalysisMask = esConsumes();
  }
  alignmentToken = esConsumes();
  geomToken = esConsumes();
}

~RPDigiProducer()

RPDigiProducer::~RPDigiProducer ( )

overridedefault

Member Function Documentation

beginRun()

void RPDigiProducer::beginRun ( const edm::Run &  beginrun, const edm::EventSetup &  es  )

overrideprivate

Definition at line 213 of file RPDigiProducer.cc.

References deadChannelsManager, edm::EventSetup::getData(), simulateDeadChannels, and tokenAnalysisMask.

                                                                             {
  // get analysis mask to mask channels
  if (simulateDeadChannels) {
    //set analysisMask in deadChannelsManager
    deadChannelsManager = DeadChannelsManager(&es.getData(tokenAnalysisMask));
  }
}

convertRPStripDetSet()

edm::DetSet< TotemRPDigi > RPDigiProducer::convertRPStripDetSet ( const edm::DetSet< TotemRPDigi > &  rpstrip_detset )

private

Definition at line 221 of file RPDigiProducer.cc.

References edm::DetSet< T >::data, edm::DetSet< T >::detId(), edm::DetSet< T >::reserve(), and edm::DetSet< T >::size().

Referenced by produce().

                                                                                                        {
  edm::DetSet<TotemRPDigi> rpdigi_detset(rpstrip_detset.detId());
  rpdigi_detset.reserve(rpstrip_detset.size());

  for (std::vector<TotemRPDigi>::const_iterator stripIterator = rpstrip_detset.data.begin();
       stripIterator < rpstrip_detset.data.end();
       ++stripIterator) {
    rpdigi_detset.push_back(TotemRPDigi(stripIterator->stripNumber()));
  }

  return rpdigi_detset;
}

fillDescriptions()

void RPDigiProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 234 of file RPDigiProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
  //RPSiDetDigitizer
  //all distances in [mm]
  edm::ParameterSetDescription desc;
  desc.add<bool>("RPLandauFluctuations", true);
  desc.add<bool>("RPDisplacementOn", false);
  desc.add<int>("RPVerbosity", 0);
  desc.add<double>("RPVFATThreshold", 9000.0);
  desc.add<double>("RPTopEdgePosition", 1.5);
  desc.add<double>("RPActiveEdgeSmearing", 0.013);
  desc.add<double>("RPEquivalentNoiseCharge300um", 1000.0);
  desc.add<int>("RPVFATTriggerMode", 2);
  desc.add<std::vector<double>>("RPInterStripSmearing",
                                {
                                    0.011,
                                });
  desc.add<double>("RPSharingSigmas", 5.0);  //how many sigmas taken into account for the edges and inter strips
  desc.add<double>("RPGeVPerElectron", 3.61e-09);
  desc.add<double>("RPActiveEdgePosition", 0.034);  //from the physical edge
  desc.add<bool>("RPDeadStripSimulationOn", false);
  desc.add<std::vector<std::string>>("ROUList",
                                     {
                                         "TotemHitsRP",
                                     });
  desc.add<bool>("RPNoNoise", false);
  desc.add<bool>("RPDigiSimHitRelationsPresistence", false);  //save links betweend digi, clusters and OSCAR/Geant4 hits
  desc.add<std::string>("mixLabel", "mix");
  desc.add<int>("RPChargeDivisionsPerThickness", 5);
  desc.add<double>("RPDeltaProductionCut", 0.120425);  //[MeV]
  desc.add<double>("RPBottomEdgePosition", 1.5);
  desc.add<double>("RPBottomEdgeSmearing", 0.011);
  desc.add<double>("RPTopEdgeSmearing", 0.011);
  desc.add<std::string>("InputCollection", "g4SimHitsTotemHitsRP");
  desc.add<double>("RPInterStripCoupling",
                   1.0);  //fraction of charge going to the strip, the missing part is taken by its neighbours
  desc.add<double>("RPDeadStripProbability", 0.001);
  desc.add<int>("RPChargeDivisionsPerStrip", 15);
  descriptions.add("RPSiDetDigitizer", desc);
}

produce()

void RPDigiProducer::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

Definition at line 122 of file RPDigiProducer.cc.

References alignmentToken, MixCollection< T >::MixItr::bunch(), cuy::col, conf_, convertRPStripDetSet(), submitPVResolutionJobs::count, edm::DetSet< T >::data, Exception, relativeConstraints::geom, geomToken, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), MixCollection< T >::MixItr::getTrigger(), iEvent, edm::Service< T >::isAvailable(), eostools::move(), edm::Handle< T >::product(), rndEngine_, writedatasetfile::run, theAlgoMap, edm::EventSetup::tryToGet(), and verbosity_.

                                                                          {
  using namespace edm;

  // initialize random engine
  if (!rndEngine_) {
    Service<RandomNumberGenerator> rng;
    if (!rng.isAvailable()) {
      throw cms::Exception("Configuration")
          << "This class 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.";
    }
    rndEngine_ = &(rng->getEngine(iEvent.streamID()));
  }

  // Step A: Get Inputs
  edm::Handle<CrossingFrame<PSimHit>> cf;
  iEvent.getByLabel("mix", "g4SimHitsTotemHitsRP", cf);

  if (verbosity_) {
    edm::LogInfo("RPDigiProducer") << "\n\n=================== Starting SimHit access"
                                   << "  ==================="
                                   << "\n";

    MixCollection<PSimHit> col{cf.product(), std::pair(-0, 0)};
    MixCollection<PSimHit>::iterator cfi;
    int count = 0;
    for (cfi = col.begin(); cfi != col.end(); cfi++) {
      edm::LogInfo("RPDigiProducer") << " Hit " << count << " has tof " << cfi->timeOfFlight() << " trackid "
                                     << cfi->trackId() << " bunchcr " << cfi.bunch() << " trigger " << cfi.getTrigger()
                                     << ", from EncodedEventId: " << cfi->eventId().bunchCrossing() << " "
                                     << cfi->eventId().event() << " bcr from MixCol " << cfi.bunch() << "\n";
      edm::LogInfo("RPDigiProducer") << " Hit: " << (*cfi) << "\n";
      count++;
    }
  }

  MixCollection<PSimHit> allRPHits{cf.product(), std::pair(0, 0)};

  if (verbosity_)
    edm::LogInfo("RPDigiProducer") << "Input MixCollection size = " << allRPHits.size() << "\n";

  //Loop on PSimHit
  simhit_map simHitMap_;
  simHitMap_.clear();

  MixCollection<PSimHit>::iterator isim;
  for (isim = allRPHits.begin(); isim != allRPHits.end(); ++isim) {
    simHitMap_[(*isim).detUnitId()].push_back((*isim));
  }

  // Step B: LOOP on hits in event
  std::vector<edm::DetSet<TotemRPDigi>> DigiVector;
  DigiVector.reserve(400);
  DigiVector.clear();

  CTPPSRPAlignmentCorrectionsData const* alignments = nullptr;
  if (auto rec = iSetup.tryToGet<VeryForwardMisalignedGeometryRecord>()) {
    alignments = &iSetup.getData(alignmentToken);
  }
  auto const& geom = iSetup.getData(geomToken);

  for (simhit_map_iterator it = simHitMap_.begin(); it != simHitMap_.end(); ++it) {
    edm::DetSet<TotemRPDigi> digi_collector(it->first);

    if (theAlgoMap.find(it->first) == theAlgoMap.end()) {
      theAlgoMap[it->first] = std::make_unique<RPDetDigitizer>(conf_, *rndEngine_, it->first, alignments, geom);
    }

    std::vector<int> input_links;
    simromanpot::DigiPrimaryMapType output_digi_links;

    (theAlgoMap.find(it->first)->second)
        ->run(simHitMap_[it->first], input_links, digi_collector.data, output_digi_links);

    if (!digi_collector.data.empty()) {
      DigiVector.push_back(convertRPStripDetSet(digi_collector));
    }
  }

  // Step C: create empty output collection
  std::unique_ptr<edm::DetSetVector<TotemRPDigi>> digi_output(new edm::DetSetVector<TotemRPDigi>(DigiVector));

  if (verbosity_) {
    edm::LogInfo("RPDigiProducer") << "digi_output->size()=" << digi_output->size() << "\n";
  }
  // Step D: write output to file
  iEvent.put(std::move(digi_output));
}

Member Data Documentation

alignmentToken

edm::ESGetToken<CTPPSRPAlignmentCorrectionsData, VeryForwardMisalignedGeometryRecord> RPDigiProducer::alignmentToken

private

Definition at line 91 of file RPDigiProducer.cc.

Referenced by produce(), and RPDigiProducer().

conf_

edm::ParameterSet RPDigiProducer::conf_

private

Definition at line 73 of file RPDigiProducer.cc.

Referenced by produce().

deadChannelsManager

DeadChannelsManager RPDigiProducer::deadChannelsManager

private

this variable answers the question whether given channel is dead or not

Definition at line 82 of file RPDigiProducer.cc.

Referenced by beginRun().

geomToken

edm::ESGetToken<CTPPSGeometry, VeryForwardRealGeometryRecord> RPDigiProducer::geomToken

private

Definition at line 92 of file RPDigiProducer.cc.

Referenced by produce(), and RPDigiProducer().

rndEngine_

CLHEP::HepRandomEngine* RPDigiProducer::rndEngine_ = nullptr

private

Definition at line 76 of file RPDigiProducer.cc.

Referenced by produce().

RP_hit_containers_

std::vector<std::string> RPDigiProducer::RP_hit_containers_

private

Definition at line 69 of file RPDigiProducer.cc.

Referenced by RPDigiProducer().

simulateDeadChannels

bool RPDigiProducer::simulateDeadChannels

private

this variable indicates whether we take into account dead channels or simulate as if all channels work ok (by default we do not simulate dead channels)

Definition at line 87 of file RPDigiProducer.cc.

Referenced by beginRun(), and RPDigiProducer().

theAlgoMap

std::map<RPDetId, std::unique_ptr<RPDetDigitizer> > RPDigiProducer::theAlgoMap

private

Definition at line 74 of file RPDigiProducer.cc.

Referenced by produce().

tokenAnalysisMask

edm::ESGetToken<TotemAnalysisMask, TotemReadoutRcd> RPDigiProducer::tokenAnalysisMask

private

Definition at line 90 of file RPDigiProducer.cc.

Referenced by beginRun(), and RPDigiProducer().

tokenCrossingFrameTotemRP

edm::EDGetTokenT<CrossingFrame<PSimHit> > RPDigiProducer::tokenCrossingFrameTotemRP

private

Definition at line 89 of file RPDigiProducer.cc.

Referenced by RPDigiProducer().

verbosity_

int RPDigiProducer::verbosity_

private

Definition at line 77 of file RPDigiProducer.cc.

Referenced by produce(), and RPDigiProducer().