Inheritance diagram for CTPPSCompositeESSource:

Classes
struct	BinData

struct	ProfileData

Public Member Functions
	CTPPSCompositeESSource (const edm::ParameterSet &)

std::unique_ptr < PPSDirectSimulationData >	produceDirectSimuData (const PPSDirectSimulationDataRcd &)

std::unique_ptr< LHCInfo >	produceLhcInfo (const LHCInfoRcd &)

std::shared_ptr < CTPPSRPAlignmentCorrectionsData >	produceMisalignedAlignments (const RPMisalignedAlignmentRecord &)

std::shared_ptr< CTPPSGeometry >	produceMisalignedTG (const VeryForwardMisalignedGeometryRecord &)

std::unique_ptr < LHCOpticalFunctionsSetCollection >	produceOptics (const CTPPSOpticsRcd &)

std::shared_ptr < CTPPSRPAlignmentCorrectionsData >	produceRealAlignments (const RPRealAlignmentRecord &)

std::shared_ptr< CTPPSGeometry >	produceRealTG (const VeryForwardRealGeometryRecord &)

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

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector < ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

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

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set < eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete

void	resetInterval (const eventsetup::EventSetupRecordKey &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

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

Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
void	buildAlignment (const edm::ParameterSet &profile, ProfileData &pData)

void	buildDirectSimuData (const edm::ParameterSet &profile, ProfileData &pData)

void	buildGeometry (const DDCompactView &cpv)

void	buildLHCInfo (const edm::ParameterSet &profile, ProfileData &pData)

void	buildOptics (const edm::ParameterSet &profile, ProfileData &pData)

void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override

Private Attributes
std::string	compactViewTag_

const ProfileData *	currentProfile_

unsigned int	generateEveryNEvents_

bool	geometryBuilt_

const bool	isRun2_

std::string	lhcInfoLabel_

std::unique_ptr < CLHEP::HepRandomEngine >	m_engine_

std::string	opticsLabel_

edm::EventID	previously_set_eventID_

std::vector< BinData < ProfileData > >	profile_bins_

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	tokenCompactViewMisaligned_

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	tokenCompactViewReal_

unsigned int	verbosity_

Additional Inherited Members
Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy >>>

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Detailed Description

Definition at line 50 of file CTPPSCompositeESSource.cc.

Constructor & Destructor Documentation

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

Definition at line 138 of file CTPPSCompositeESSource.cc.

References newFWLiteAna::bin, buildAlignment(), buildDirectSimuData(), buildLHCInfo(), buildOptics(), looper::cfg, compactViewTag_, edm::ParameterSet::getParameter(), lhcInfoLabel_, opticsLabel_, produceDirectSimuData(), produceLhcInfo(), produceMisalignedTG(), produceOptics(), produceRealTG(), profile_bins_, edm::ESProducer::setWhatProduced(), tokenCompactViewMisaligned_, and tokenCompactViewReal_.

     : compactViewTag_(conf.getParameter<std::string>("compactViewTag")),
       lhcInfoLabel_(conf.getParameter<std::string>("lhcInfoLabel")),
       opticsLabel_(conf.getParameter<std::string>("opticsLabel")),
       generateEveryNEvents_(conf.getUntrackedParameter<unsigned int>("generateEveryNEvents")),
       verbosity_(conf.getUntrackedParameter<unsigned int>("verbosity")),
       isRun2_(conf.getParameter<bool>("isRun2")),
       m_engine_(new CLHEP::HepJamesRandom(conf.getParameter<unsigned int>("seed"))),
       geometryBuilt_(false) {
   double l_int_sum = 0;
 
   for (const auto &cfg : conf.getParameter<std::vector<edm::ParameterSet>>("periods")) {
     double l_int = cfg.getParameter<double>("L_int");
 
     profile_bins_.emplace_back(BinData<ProfileData>{l_int_sum, l_int_sum + l_int, ProfileData()});
 
     l_int_sum += l_int;
 
     auto &pData = profile_bins_.back().data;
 
     buildLHCInfo(cfg, pData);
     buildOptics(cfg, pData);
     buildAlignment(cfg, pData);
     buildDirectSimuData(cfg, pData);
   }
 
   // normalise L_int sums to probabilities
   for (auto &bin : profile_bins_) {
     bin.min /= l_int_sum;
     bin.max /= l_int_sum;
   }
 
   // framework registrations
   setWhatProduced(this, &CTPPSCompositeESSource::produceLhcInfo, edm::es::Label(lhcInfoLabel_));
   setWhatProduced(this, &CTPPSCompositeESSource::produceOptics, edm::es::Label(opticsLabel_));
   setWhatProduced(this, &CTPPSCompositeESSource::produceDirectSimuData);
 
   tokenCompactViewReal_ = setWhatProduced(this, &CTPPSCompositeESSource::produceRealTG)
                               .consumesFrom<DDCompactView, IdealGeometryRecord>(edm::ESInputTag("", compactViewTag_));
   tokenCompactViewMisaligned_ =
       setWhatProduced(this, &CTPPSCompositeESSource::produceMisalignedTG)
           .consumesFrom<DDCompactView, IdealGeometryRecord>(edm::ESInputTag("", compactViewTag_));
 
   findingRecord<LHCInfoRcd>();
   findingRecord<CTPPSOpticsRcd>();
   findingRecord<PPSDirectSimulationDataRcd>();
   findingRecord<RPRealAlignmentRecord>();
   findingRecord<RPMisalignedAlignmentRecord>();
   findingRecord<VeryForwardRealGeometryRecord>();
   findingRecord<VeryForwardMisalignedGeometryRecord>();
 }

Member Function Documentation

void CTPPSCompositeESSource::buildAlignment	(	const edm::ParameterSet &	profile,
		ProfileData &	pData
	)

private

Definition at line 359 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::acMisaligned, CTPPSCompositeESSource::ProfileData::acReal, CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::acsMisaligned, CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::acsReal, edm::ParameterSet::addUntrackedParameter(), edm::ParameterSet::getParameter(), and verbosity_.

Referenced by CTPPSCompositeESSource().

                                                                                           {
   // load alignment data
   auto ctppsRPAlignmentCorrectionsDataXMLPSet =
       cfg.getParameter<edm::ParameterSet>("ctppsRPAlignmentCorrectionsDataXML");
   ctppsRPAlignmentCorrectionsDataXMLPSet.addUntrackedParameter("verbosity", verbosity_);
 
   CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon ctppsRPAlignmentCorrectionsDataESSourceXMLCommon(
       ctppsRPAlignmentCorrectionsDataXMLPSet);
 
   // store the first entry from the alignment sequence (more cannot be done)
   pData.acReal = std::make_shared<CTPPSRPAlignmentCorrectionsData>(
       ctppsRPAlignmentCorrectionsDataESSourceXMLCommon.acsReal.empty()
           ? CTPPSRPAlignmentCorrectionsData()
           : ctppsRPAlignmentCorrectionsDataESSourceXMLCommon.acsReal[0].second);
 
   pData.acMisaligned = std::make_shared<CTPPSRPAlignmentCorrectionsData>(
       ctppsRPAlignmentCorrectionsDataESSourceXMLCommon.acsMisaligned.empty()
           ? CTPPSRPAlignmentCorrectionsData()
           : ctppsRPAlignmentCorrectionsDataESSourceXMLCommon.acsMisaligned[0].second);
 }

void CTPPSCompositeESSource::buildDirectSimuData	(	const edm::ParameterSet &	profile,
		ProfileData &	pData
	)

private

Definition at line 268 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::directSimuData, mergeVDriftHistosByStation::file, PPSDirectSimulationData::getEfficienciesPerPlane(), PPSDirectSimulationData::getEfficienciesPerRP(), edm::ParameterSet::getParameter(), PPSDirectSimulationData::setEmpiricalAperture45(), PPSDirectSimulationData::setEmpiricalAperture56(), PPSDirectSimulationData::setTimeResolutionDiamonds45(), PPSDirectSimulationData::setTimeResolutionDiamonds56(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CTPPSCompositeESSource().

                                                                                                    {
   const auto &ctppsDirectSimuData = profile.getParameter<edm::ParameterSet>("ctppsDirectSimuData");
 
   pData.directSimuData.setEmpiricalAperture45(ctppsDirectSimuData.getParameter<std::string>("empiricalAperture45"));
   pData.directSimuData.setEmpiricalAperture56(ctppsDirectSimuData.getParameter<std::string>("empiricalAperture56"));
 
   pData.directSimuData.setTimeResolutionDiamonds45(
       ctppsDirectSimuData.getParameter<std::string>("timeResolutionDiamonds45"));
   pData.directSimuData.setTimeResolutionDiamonds56(
       ctppsDirectSimuData.getParameter<std::string>("timeResolutionDiamonds56"));
 
   for (const auto &ps : ctppsDirectSimuData.getParameterSetVector("efficienciesPerRP")) {
     const auto rpId = ps.getParameter<unsigned int>("rpId");
     const auto &file = ps.getParameter<std::string>("file");
     const auto &object = ps.getParameter<std::string>("object");
     pData.directSimuData.getEfficienciesPerRP()[rpId] = {file, object};
   }
 
   for (const auto &ps : ctppsDirectSimuData.getParameterSetVector("efficienciesPerPlane")) {
     const auto rpId = ps.getParameter<unsigned int>("rpId");
     const auto &file = ps.getParameter<std::string>("file");
     const auto &object = ps.getParameter<std::string>("object");
     pData.directSimuData.getEfficienciesPerPlane()[rpId] = {file, object};
   }
 }

void CTPPSCompositeESSource::buildGeometry ( const DDCompactView & cpv )

private

Definition at line 296 of file CTPPSCompositeESSource.cc.

References CTPPSGeometryESCommon::applyAlignments(), detgeomdescbuilder::buildDetGeomDescFromCompactView(), geometryBuilt_, isRun2_, AlCaHLTBitMon_ParallelJobs::p, profile_bins_, and verbosity_.

Referenced by produceMisalignedTG(), and produceRealTG().

                                                                    {
   std::unique_ptr<DetGeomDesc> idealGD = detgeomdescbuilder::buildDetGeomDescFromCompactView(cpv, isRun2_);
 
   for (auto &pb : profile_bins_) {
     auto &p = pb.data;
 
     p.misalignedGD = CTPPSGeometryESCommon::applyAlignments(*(idealGD), p.acMisaligned.get());
     p.misalignedTG = std::make_shared<CTPPSGeometry>(p.misalignedGD.get(), verbosity_);
 
     p.realGD = CTPPSGeometryESCommon::applyAlignments(*(idealGD), p.acReal.get());
     p.realTG = std::make_shared<CTPPSGeometry>(p.realGD.get(), verbosity_);
   }
 
   geometryBuilt_ = true;
 }

void CTPPSCompositeESSource::buildLHCInfo	(	const edm::ParameterSet &	profile,
		ProfileData &	pData
	)

private

Definition at line 382 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::beamEnergy, CTPPSCompositeESSource::ProfileData::betaStar, Exception, edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, w, x, CTPPSCompositeESSource::ProfileData::xangle, CTPPSCompositeESSource::ProfileData::xangleBetaStarBins, and y.

Referenced by CTPPSCompositeESSource().

                                                                                             {
   const auto &ctppsLHCInfo = profile.getParameter<edm::ParameterSet>("ctppsLHCInfo");
 
   pData.beamEnergy = ctppsLHCInfo.getParameter<double>("beamEnergy");
   pData.betaStar = ctppsLHCInfo.getParameter<double>("betaStar");
   pData.xangle = ctppsLHCInfo.getParameter<double>("xangle");
 
   // continue only if distributed xangle/beta* shall be used
   if (pData.xangle > 0)
     return;
 
   edm::FileInPath fip(ctppsLHCInfo.getParameter<std::string>("xangleBetaStarHistogramFile").c_str());
   std::unique_ptr<TFile> f_in(TFile::Open(fip.fullPath().c_str()));
   if (!f_in)
     throw cms::Exception("PPS") << "Cannot open input file '"
                                 << ctppsLHCInfo.getParameter<std::string>("xangleBetaStarHistogramFile") << "'.";
 
   TH2D *h_xangle_beta_star =
       (TH2D *)f_in->Get(ctppsLHCInfo.getParameter<std::string>("xangleBetaStarHistogramObject").c_str());
   if (!h_xangle_beta_star)
     throw cms::Exception("PPS") << "Cannot load input object '"
                                 << ctppsLHCInfo.getParameter<std::string>("xangleBetaStarHistogramObject") << "'.";
 
   // extract non-empty bins, calculate weights
   double sum = 0.;
   for (int bi = 1; bi <= h_xangle_beta_star->GetNcells(); ++bi)
     sum += h_xangle_beta_star->GetBinContent(bi);
 
   double cw = 0.;
   for (int x = 1; x <= h_xangle_beta_star->GetNbinsX(); ++x)
     for (int y = 1; y <= h_xangle_beta_star->GetNbinsY(); ++y) {
       const double w = h_xangle_beta_star->GetBinContent(h_xangle_beta_star->GetBin(x, y)) / sum;
       if (w > 0.) {
         pData.xangleBetaStarBins.push_back(
             {cw,
              cw + w,
              std::pair<double, double>(h_xangle_beta_star->GetXaxis()->GetBinCenter(x),
                                        h_xangle_beta_star->GetYaxis()->GetBinCenter(y))});
         cw += w;
       }
     }
 }

void CTPPSCompositeESSource::buildOptics	(	const edm::ParameterSet &	profile,
		ProfileData &	pData
	)

private

Definition at line 314 of file CTPPSCompositeESSource.cc.

References TrackerOfflineValidation_Dqm_cff::dirName, mps_splice::entry, fcn(), tkal_create_file_lists::FileInfo, MillePedeFileConverter_cfg::fileName, contentValuesFiles::fullPath, edm::ParameterSet::getParameter(), CTPPSCompositeESSource::ProfileData::lhcOptical, eostools::move(), TrackValidation_cff::pset, AlCaHLTBitMon_QueryRunRegistry::string, and z.

Referenced by CTPPSCompositeESSource().

                                                                                            {
   const auto &ctppsOpticalFunctions = profile.getParameter<edm::ParameterSet>("ctppsOpticalFunctions");
 
   struct FileInfo {
     double m_xangle;
     std::string m_fileName;
   };
 
   std::vector<FileInfo> fileInfo;
 
   for (const auto &pset : ctppsOpticalFunctions.getParameter<std::vector<edm::ParameterSet>>("opticalFunctions")) {
     const double &xangle = pset.getParameter<double>("xangle");
     const std::string &fileName = pset.getParameter<edm::FileInPath>("fileName").fullPath();
     fileInfo.push_back({xangle, fileName});
   }
 
   struct RPInfo {
     std::string m_dirName;
     double m_scoringPlaneZ;
   };
 
   std::unordered_map<unsigned int, RPInfo> rpInfo;
 
   for (const auto &pset : ctppsOpticalFunctions.getParameter<std::vector<edm::ParameterSet>>("scoringPlanes")) {
     const unsigned int rpId = pset.getParameter<unsigned int>("rpId");
     const std::string dirName = pset.getParameter<std::string>("dirName");
     const double z = pset.getParameter<double>("z");
     const RPInfo entry = {dirName, z};
     rpInfo.emplace(rpId, entry);
   }
 
   for (const auto &fi : fileInfo) {
     std::unordered_map<unsigned int, LHCOpticalFunctionsSet> xa_data;
 
     for (const auto &rpi : rpInfo) {
       LHCOpticalFunctionsSet fcn(fi.m_fileName, rpi.second.m_dirName, rpi.second.m_scoringPlaneZ);
       xa_data.emplace(rpi.first, std::move(fcn));
     }
 
     pData.lhcOptical.emplace(fi.m_xangle, xa_data);
   }
 }

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

static

Definition at line 192 of file CTPPSCompositeESSource.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addVPSet(), submitPVResolutionJobs::desc, haddnano::of, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("compactViewTag", "")->setComment("label of the geometry compact view");
   desc.add<std::string>("lhcInfoLabel", "")->setComment("label of the LHCInfo record");
   desc.add<std::string>("opticsLabel", "")->setComment("label of the optics record");
   desc.add<unsigned int>("seed", 1)->setComment("random seed");
   desc.add<bool>("isRun2", false)->setComment("use diamond's run 2 geometry definition?");
   desc.addUntracked<unsigned int>("generateEveryNEvents", 1)->setComment("how often to switch conditions");
   desc.addUntracked<unsigned int>("verbosity", 0);
 
   edm::ParameterSetDescription desc_profile;
   std::vector<edm::ParameterSet> vp;
   desc_profile.add<double>("L_int", 0.)->setComment("integrated luminosity");
 
   // lhcInfo
   edm::ParameterSetDescription desc_profile_ctppsLHCInfo;
   desc_profile_ctppsLHCInfo.add<double>("xangle", -1)
       ->setComment("constant xangle, if negative, the xangle/beta* distribution will be used");
   desc_profile_ctppsLHCInfo.add<double>("betaStar", 0.)->setComment("constant beta*");
   desc_profile_ctppsLHCInfo.add<double>("beamEnergy", 0.)->setComment("beam energy");
   desc_profile_ctppsLHCInfo.add<std::string>("xangleBetaStarHistogramFile", "")
       ->setComment("ROOT file with xangle/beta* distribution");
   desc_profile_ctppsLHCInfo.add<std::string>("xangleBetaStarHistogramObject", "")
       ->setComment("xangle distribution object in the ROOT file");
   desc_profile.add<edm::ParameterSetDescription>("ctppsLHCInfo", desc_profile_ctppsLHCInfo);
 
   // optics
   edm::ParameterSetDescription desc_profile_ctppsOpticalFunctions;
   edm::ParameterSetDescription of_desc;
   of_desc.add<double>("xangle")->setComment("half crossing angle value in urad");
   of_desc.add<edm::FileInPath>("fileName")->setComment("ROOT file with optical functions");
   std::vector<edm::ParameterSet> of;
   desc_profile_ctppsOpticalFunctions.addVPSet("opticalFunctions", of_desc, of)
       ->setComment("list of optical functions at different crossing angles");
 
   edm::ParameterSetDescription sp_desc;
   sp_desc.add<unsigned int>("rpId")->setComment("associated detector DetId");
   sp_desc.add<std::string>("dirName")->setComment("associated path to the optical functions file");
   sp_desc.add<double>("z")->setComment("longitudinal position at scoring plane/detector");
   std::vector<edm::ParameterSet> sp;
   desc_profile_ctppsOpticalFunctions.addVPSet("scoringPlanes", sp_desc, sp)
       ->setComment("list of sensitive planes/detectors stations");
   desc_profile.add<edm::ParameterSetDescription>("ctppsOpticalFunctions", desc_profile_ctppsOpticalFunctions);
 
   // alignment
   edm::ParameterSetDescription desc_profile_ctppsRPAlignmentCorrectionsDataXML;
   desc_profile_ctppsRPAlignmentCorrectionsDataXML.add<std::vector<std::string>>("MeasuredFiles");
   desc_profile_ctppsRPAlignmentCorrectionsDataXML.add<std::vector<std::string>>("RealFiles");
   desc_profile_ctppsRPAlignmentCorrectionsDataXML.add<std::vector<std::string>>("MisalignedFiles");
   desc_profile.add<edm::ParameterSetDescription>("ctppsRPAlignmentCorrectionsDataXML",
                                                  desc_profile_ctppsRPAlignmentCorrectionsDataXML);
 
   // direct simu config
   edm::ParameterSetDescription desc_profile_ctppsDirectSimuData;
   desc_profile_ctppsDirectSimuData.add<std::string>("empiricalAperture45");
   desc_profile_ctppsDirectSimuData.add<std::string>("empiricalAperture56");
 
   desc_profile_ctppsDirectSimuData.add<std::string>("timeResolutionDiamonds45");
   desc_profile_ctppsDirectSimuData.add<std::string>("timeResolutionDiamonds56");
 
   edm::ParameterSetDescription eps_desc;
   eps_desc.add<unsigned int>("rpId")->setComment("RP id");
   eps_desc.add<std::string>("file")->setComment("file name");
   eps_desc.add<std::string>("object")->setComment("path to the efficiency histogram");
   desc_profile_ctppsDirectSimuData.addVPSet("efficienciesPerRP", eps_desc, std::vector<edm::ParameterSet>());
   desc_profile_ctppsDirectSimuData.addVPSet("efficienciesPerPlane", eps_desc, std::vector<edm::ParameterSet>());
 
   desc_profile.add<edm::ParameterSetDescription>("ctppsDirectSimuData", desc_profile_ctppsDirectSimuData);
 
   desc.addVPSet("periods", desc_profile, vp)->setComment("profiles");
 
   descriptions.add("ctppsCompositeESSource", desc);
 }

std::unique_ptr< PPSDirectSimulationData > CTPPSCompositeESSource::produceDirectSimuData ( const PPSDirectSimulationDataRcd & )

Definition at line 488 of file CTPPSCompositeESSource.cc.

References currentProfile_, and CTPPSCompositeESSource::ProfileData::directSimuData.

Referenced by CTPPSCompositeESSource().

                                         {
   return std::make_unique<PPSDirectSimulationData>(currentProfile_->directSimuData);
 }

std::unique_ptr< LHCInfo > CTPPSCompositeESSource::produceLhcInfo ( const LHCInfoRcd & )

Definition at line 501 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::beamEnergy, CTPPSCompositeESSource::ProfileData::betaStar, currentProfile_, ztail::d, m_engine_, CTPPSCompositeESSource::ProfileData::xangle, and CTPPSCompositeESSource::ProfileData::xangleBetaStarBins.

Referenced by CTPPSCompositeESSource().

                                                                                 {
   double xangle = currentProfile_->xangle;
   double betaStar = currentProfile_->betaStar;
 
   if (currentProfile_->xangle < 0) {
     const double u = CLHEP::RandFlat::shoot(m_engine_.get(), 0., 1.);
     for (const auto &d : currentProfile_->xangleBetaStarBins) {
       if (d.min <= u && u <= d.max) {
         xangle = d.data.first;
         betaStar = d.data.second;
         break;
       }
     }
   }
 
   auto lhcInfo = std::make_unique<LHCInfo>();
   lhcInfo->setEnergy(currentProfile_->beamEnergy);
   lhcInfo->setCrossingAngle(xangle);
   lhcInfo->setBetaStar(betaStar);
 
   edm::LogInfo("PPS") << "new LHCInfo: xangle=" << xangle << ", betaStar=" << betaStar;
 
   return lhcInfo;
 }

std::shared_ptr< CTPPSRPAlignmentCorrectionsData > CTPPSCompositeESSource::produceMisalignedAlignments ( const RPMisalignedAlignmentRecord & )

Definition at line 462 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::acMisaligned, and currentProfile_.

                                          {
   return currentProfile_->acMisaligned;
 }

std::shared_ptr< CTPPSGeometry > CTPPSCompositeESSource::produceMisalignedTG ( const VeryForwardMisalignedGeometryRecord & iRecord )

Definition at line 478 of file CTPPSCompositeESSource.cc.

References buildGeometry(), currentProfile_, geometryBuilt_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), CTPPSCompositeESSource::ProfileData::misalignedTG, and tokenCompactViewMisaligned_.

Referenced by CTPPSCompositeESSource().

                                                         {
   if (!geometryBuilt_)
     buildGeometry(iRecord.getRecord<IdealGeometryRecord>().get(tokenCompactViewMisaligned_));
 
   return currentProfile_->misalignedTG;
 }

std::unique_ptr< LHCOpticalFunctionsSetCollection > CTPPSCompositeESSource::produceOptics ( const CTPPSOpticsRcd & )

Definition at line 495 of file CTPPSCompositeESSource.cc.

References currentProfile_, and CTPPSCompositeESSource::ProfileData::lhcOptical.

Referenced by CTPPSCompositeESSource().

                                                                                                             {
   return std::make_unique<LHCOpticalFunctionsSetCollection>(currentProfile_->lhcOptical);
 }

std::shared_ptr< CTPPSRPAlignmentCorrectionsData > CTPPSCompositeESSource::produceRealAlignments ( const RPRealAlignmentRecord & )

Definition at line 455 of file CTPPSCompositeESSource.cc.

References CTPPSCompositeESSource::ProfileData::acReal, and currentProfile_.

                                    {
   return currentProfile_->acReal;
 }

std::shared_ptr< CTPPSGeometry > CTPPSCompositeESSource::produceRealTG ( const VeryForwardRealGeometryRecord & iRecord )

Definition at line 469 of file CTPPSCompositeESSource.cc.

References buildGeometry(), currentProfile_, geometryBuilt_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), CTPPSCompositeESSource::ProfileData::realTG, and tokenCompactViewReal_.

Referenced by CTPPSCompositeESSource().

                                                                                                                {
   if (!geometryBuilt_)
     buildGeometry(iRecord.getRecord<IdealGeometryRecord>().get(tokenCompactViewReal_));
 
   return currentProfile_->realTG;
 }

void CTPPSCompositeESSource::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	key,
		const edm::IOVSyncValue &	iosv,
		edm::ValidityInterval &	oValidity
	)

overrideprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 427 of file CTPPSCompositeESSource.cc.

References newFWLiteAna::bin, currentProfile_, edm::EventID::event(), edm::IOVSyncValue::eventID(), generateEveryNEvents_, edm::EventID::luminosityBlock(), m_engine_, previously_set_eventID_, profile_bins_, and edm::EventID::run().

                                                                             {
   // determine new IOV
   edm::EventID beginEvent = iosv.eventID();
   edm::EventID endEvent(beginEvent.run(), beginEvent.luminosityBlock(), beginEvent.event() + generateEveryNEvents_);
   oValidity = edm::ValidityInterval(edm::IOVSyncValue(beginEvent), edm::IOVSyncValue(endEvent));
 
   // stop if new profile has already been generated
   if (beginEvent.run() == previously_set_eventID_.run() &&
       beginEvent.luminosityBlock() == previously_set_eventID_.luminosityBlock())
     return;
 
   previously_set_eventID_ = beginEvent;
 
   // randomly pick the next profile
   const double u = CLHEP::RandFlat::shoot(m_engine_.get(), 0., 1.);
 
   for (const auto &bin : profile_bins_) {
     if (bin.min <= u && u <= bin.max) {
       currentProfile_ = &bin.data;
       break;
     }
   }
 }