Inheritance diagram for CTPPSModifiedOpticalFunctionsESSource:

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

std::shared_ptr< LHCInterpolatedOpticalFunctionsSetCollection >	produce (const CTPPSInterpolatedOpticsRcd &)

	~CTPPSModifiedOpticalFunctionsESSource () override

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)

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

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

Private Attributes
const double	factor_

const edm::ESGetToken< LHCInterpolatedOpticalFunctionsSetCollection, CTPPSInterpolatedOpticsRcd >	inputOpticsToken_

const unsigned int	rpDecId_45_F_

const unsigned int	rpDecId_45_N_

const unsigned int	rpDecId_56_F_

const unsigned int	rpDecId_56_N_

const std::string	scenario_

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 >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&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)

Detailed Description

Definition at line 16 of file CTPPSModifiedOpticalFunctionsESSource.cc.

Constructor & Destructor Documentation

◆ CTPPSModifiedOpticalFunctionsESSource()

CTPPSModifiedOpticalFunctionsESSource::CTPPSModifiedOpticalFunctionsESSource ( const edm::ParameterSet & iConfig )

Definition at line 38 of file CTPPSModifiedOpticalFunctionsESSource.cc.

     : inputOpticsToken_(setWhatProduced(this, iConfig.getParameter<std::string>("outputOpticsLabel"))
                             .consumes(edm::ESInputTag("", iConfig.getParameter<std::string>("inputOpticsLabel")))),
       scenario_(iConfig.getParameter<std::string>("scenario")),
       factor_(iConfig.getParameter<double>("factor")),
       rpDecId_45_N_(iConfig.getParameter<unsigned int>("rpId_45_N")),
       rpDecId_45_F_(iConfig.getParameter<unsigned int>("rpId_45_F")),
       rpDecId_56_N_(iConfig.getParameter<unsigned int>("rpId_56_N")),
       rpDecId_56_F_(iConfig.getParameter<unsigned int>("rpId_56_F")) {}

◆ ~CTPPSModifiedOpticalFunctionsESSource()

CTPPSModifiedOpticalFunctionsESSource::~CTPPSModifiedOpticalFunctionsESSource ( )

inlineoverride

Definition at line 19 of file CTPPSModifiedOpticalFunctionsESSource.cc.

19 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 50 of file CTPPSModifiedOpticalFunctionsESSource.cc.

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

                                                                                                        {
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("inputOpticsLabel", "")->setComment("label of the input optics records");
   desc.add<std::string>("outputOpticsLabel", "modified")->setComment("label of the output optics records");
 
   desc.add<std::string>("scenario", "none")->setComment("name of modification scenario");
 
   desc.add<double>("factor", 0.)->setComment("size of modification (number of sigmas)");
 
   desc.add<unsigned int>("rpId_45_N", 0)->setComment("decimal RP id for 45 near");
   desc.add<unsigned int>("rpId_45_F", 0)->setComment("decimal RP id for 45 far");
   desc.add<unsigned int>("rpId_56_N", 0)->setComment("decimal RP id for 56 near");
   desc.add<unsigned int>("rpId_56_F", 0)->setComment("decimal RP id for 56 far");
 
   descriptions.add("ctppsModifiedOpticalFunctionsESSource", desc);
 }

◆ produce()

std::shared_ptr< LHCInterpolatedOpticalFunctionsSetCollection > CTPPSModifiedOpticalFunctionsESSource::produce ( const CTPPSInterpolatedOpticsRcd & iRecord )

Definition at line 70 of file CTPPSModifiedOpticalFunctionsESSource.cc.

References a, protons_cff::arm, CTPPSDetId::arm(), b, ztail::d, LHCOpticalFunctionsSet::eLpx, LHCOpticalFunctionsSet::eLpy, LHCOpticalFunctionsSet::eLx, LHCOpticalFunctionsSet::eLy, LHCOpticalFunctionsSet::exd, factor_, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), mps_fire::i, input, inputOpticsToken_, convertSQLitetoXML_cfg::output, CTPPSDetId::rp(), rpDecId_45_F_, rpDecId_45_N_, rpDecId_56_F_, rpDecId_56_N_, scenario_, CTPPSDetId::station(), and protons_cff::xi.

                                                {
   // get input
   LHCInterpolatedOpticalFunctionsSetCollection const &input = iRecord.get(inputOpticsToken_);
 
   // prepare output
   std::shared_ptr<LHCInterpolatedOpticalFunctionsSetCollection> output =
       std::make_shared<LHCInterpolatedOpticalFunctionsSetCollection>(input);
 
   // premare arm/RP id map
   struct ArmInfo {
     unsigned int rpId_N = 0, rpId_F = 0;
   };
 
   std::map<unsigned int, ArmInfo> armInfo;
 
   for (const auto &fsp : *output) {
     CTPPSDetId rpId(fsp.first);
     unsigned int rpDecId = 100 * rpId.arm() + 10 * rpId.station() + rpId.rp();
 
     if (rpDecId == rpDecId_45_N_)
       armInfo[0].rpId_N = fsp.first;
     if (rpDecId == rpDecId_45_F_)
       armInfo[0].rpId_F = fsp.first;
     if (rpDecId == rpDecId_56_N_)
       armInfo[1].rpId_N = fsp.first;
     if (rpDecId == rpDecId_56_F_)
       armInfo[1].rpId_F = fsp.first;
   }
 
   // loop over arms
   bool applied = false;
 
   for (const auto &ap : armInfo) {
     const auto &arm = ap.first;
 
     //printf("* arm %u\n", arm);
 
     auto &of_N = output->find(ap.second.rpId_N)->second;
     auto &of_F = output->find(ap.second.rpId_F)->second;
 
     const double z_N = of_N.getScoringPlaneZ();
     const double z_F = of_F.getScoringPlaneZ();
     const double de_z = (arm == 0) ? z_N - z_F : z_F - z_N;
 
     //printf("  z_N = %.3f m, z_F = %.3f m\n", z_N*1E-2, z_F*1E-2);
 
     if (of_N.m_xi_values.size() != of_N.m_xi_values.size())
       throw cms::Exception("CTPPSModifiedOpticalFunctionsESSource")
           << "Different xi sampling of optical functions in near and far RP.";
 
     // loop over sampling points (in xi)
     for (unsigned int i = 0; i < of_N.m_xi_values.size(); ++i) {
       const double xi = of_N.m_xi_values[i];
 
       double x_d_N = of_N.m_fcn_values[LHCOpticalFunctionsSet::exd][i];
       double x_d_F = of_F.m_fcn_values[LHCOpticalFunctionsSet::exd][i];
 
       double L_x_N = of_N.m_fcn_values[LHCOpticalFunctionsSet::eLx][i];
       double L_x_F = of_F.m_fcn_values[LHCOpticalFunctionsSet::eLx][i];
       double Lp_x = of_N.m_fcn_values[LHCOpticalFunctionsSet::eLpx][i];
 
       double L_y_N = of_N.m_fcn_values[LHCOpticalFunctionsSet::eLy][i];
       double L_y_F = of_F.m_fcn_values[LHCOpticalFunctionsSet::eLy][i];
       double Lp_y = of_N.m_fcn_values[LHCOpticalFunctionsSet::eLpy][i];
 
       //printf("  xi = %.3f, Lp_x = %.3f, %.3f\n", xi, Lp_x, (L_x_F - L_x_N) / de_z);
 
       // apply modification scenario
       if (scenario_ == "none")
         applied = true;
 
       if (scenario_ == "Lx") {
         const double a = 3180., b = 40.;  // cm
         const double de_L_x = factor_ * (a * xi + b);
         L_x_N += de_L_x;
         L_x_F += de_L_x;
         applied = true;
       }
 
       if (scenario_ == "Lpx") {
         const double a = 0.42, b = 0.015;  // dimensionless
         const double de_Lp_x = factor_ * (a * xi + b) * Lp_x;
         Lp_x += de_Lp_x;
         L_x_N -= de_Lp_x * de_z / 2.;
         L_x_F += de_Lp_x * de_z / 2.;
         applied = true;
       }
 
       if (scenario_ == "xd") {
         const double d = 0.08;  // dimensionless
         x_d_N += x_d_N * d * factor_;
         x_d_F += x_d_F * d * factor_;
         applied = true;
       }
 
       // TODO: for test only
       if (scenario_ == "Lx-scale") {
         L_x_N *= factor_;
         L_x_F *= factor_;
         applied = true;
       }
 
       if (scenario_ == "Lpy") {
         const double a = 2.66, b = 0.015;  // dimensionless
         const double de_Lp_y = factor_ * (a * xi + b) * Lp_y;
         Lp_y += de_Lp_y;
         L_y_N -= de_Lp_y * de_z / 2.;
         L_y_F += de_Lp_y * de_z / 2.;
         applied = true;
       }
 
       // store updated values
       of_N.m_fcn_values[LHCOpticalFunctionsSet::exd][i] = x_d_N;
       of_F.m_fcn_values[LHCOpticalFunctionsSet::exd][i] = x_d_F;
 
       of_N.m_fcn_values[LHCOpticalFunctionsSet::eLx][i] = L_x_N;
       of_F.m_fcn_values[LHCOpticalFunctionsSet::eLx][i] = L_x_F;
 
       of_N.m_fcn_values[LHCOpticalFunctionsSet::eLpx][i] = Lp_x;
       of_F.m_fcn_values[LHCOpticalFunctionsSet::eLpx][i] = Lp_x;
 
       of_N.m_fcn_values[LHCOpticalFunctionsSet::eLy][i] = L_y_N;
       of_F.m_fcn_values[LHCOpticalFunctionsSet::eLy][i] = L_y_F;
 
       of_N.m_fcn_values[LHCOpticalFunctionsSet::eLpy][i] = Lp_y;
       of_F.m_fcn_values[LHCOpticalFunctionsSet::eLpy][i] = Lp_y;
     }
 
     // re-initialise splines
     of_N.initializeSplines();
     of_F.initializeSplines();
   }
 
   // modification applied?
   if (!applied)
     edm::LogError("CTPPSModifiedOpticalFunctionsESSource") << "Could not apply scenario `" + scenario_ + "'.";
 
   // save modified output
   return output;
 }