Inheritance diagram for PPSAlignmentConfigurationESSource:

Public Member Functions
	PPSAlignmentConfigurationESSource (const edm::ParameterSet &iConfig)

std::unique_ptr< PPSAlignmentConfiguration >	produce (const PPSAlignmentConfigurationRcd &)

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 &descriptions)

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

Private Member Functions
std::vector< PPSAlignmentConfiguration::PointErrors >	buildVectorFromDirectory (TDirectory *dir, const PPSAlignmentConfiguration::RPConfig &rpd)

TDirectory *	findDirectoryWithName (TDirectory *dir, std::string searchName)

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

Private Attributes
std::map< unsigned int, PPSAlignmentConfiguration::SelectionRange >	alignment_x_meth_o_ranges

std::map< unsigned int, PPSAlignmentConfiguration::SelectionRange >	alignment_x_relative_ranges

std::map< unsigned int, PPSAlignmentConfiguration::SelectionRange >	alignment_y_ranges

PPSAlignmentConfiguration::Binning	binning

double	chiSqThreshold

bool	debug

std::vector< double >	extraParams

unsigned int	fitProfileMinBinEntries

unsigned int	fitProfileMinNReasonable

std::string	label

std::map< unsigned int, std::vector< PPSAlignmentConfiguration::PointErrors > >	matchingReferencePoints

std::map< unsigned int, PPSAlignmentConfiguration::SelectionRange >	matchingShiftRanges

unsigned int	maxRPTracksSize

unsigned int	methOGraphMinN

double	methOUncFitRange

unsigned int	minRPTracksSize

unsigned int	modeGraphMinN

unsigned int	multSelProjYMinEntries

double	n_si

unsigned int	nearFarMinEntries

PPSAlignmentConfiguration::SectorConfig	sectorConfig45

PPSAlignmentConfiguration::SectorConfig	sectorConfig56

double	x_ali_sh_step

double	y_mode_max_valid

double	y_mode_sys_unc

double	y_mode_unc_max_valid

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 37 of file PPSAlignmentConfigurationESSource.cc.

Constructor & Destructor Documentation

◆ PPSAlignmentConfigurationESSource()

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

Definition at line 93 of file PPSAlignmentConfigurationESSource.cc.

                                                                                                    {
   label = iConfig.getParameter<std::string>("label");
 
   debug = iConfig.getParameter<bool>("debug");
   std::unique_ptr<TFile> debugFile;
   if (debug) {
     debugFile =
         std::make_unique<TFile>(("debug_producer_" + (label.empty() ? "test" : label) + ".root").c_str(), "recreate");
   }
 
   sectorConfig45.name_ = "sector 45";
 
   sectorConfig45.rp_N_.position_ = "N";
   sectorConfig45.rp_F_.position_ = "F";
 
   sectorConfig56.name_ = "sector 56";
 
   sectorConfig56.rp_N_.position_ = "N";
   sectorConfig56.rp_F_.position_ = "F";
 
   for (std::string sectorName : {"sector_45", "sector_56"}) {
     const auto& sps = iConfig.getParameter<edm::ParameterSet>(sectorName);
     PPSAlignmentConfiguration::SectorConfig* sc;
     if (sectorName == "sector_45")
       sc = &sectorConfig45;
     else
       sc = &sectorConfig56;
 
     for (std::string rpName : {"rp_N", "rp_F"}) {
       const auto& rpps = sps.getParameter<edm::ParameterSet>(rpName);
       PPSAlignmentConfiguration::RPConfig* rc;
       if (rpName == "rp_N")
         rc = &sc->rp_N_;
       else
         rc = &sc->rp_F_;
 
       rc->name_ = rpps.getParameter<std::string>("name");
       rc->id_ = rpps.getParameter<int>("id");
 
       rc->slope_ = rpps.getParameter<double>("slope");
       rc->sh_x_ = rpps.getParameter<double>("sh_x");
 
       rc->x_min_fit_mode_ = rpps.getParameter<double>("x_min_fit_mode");
       rc->x_max_fit_mode_ = rpps.getParameter<double>("x_max_fit_mode");
       rc->y_max_fit_mode_ = rpps.getParameter<double>("y_max_fit_mode");
       rc->y_cen_add_ = rpps.getParameter<double>("y_cen_add");
       rc->y_width_mult_ = rpps.getParameter<double>("y_width_mult");
 
       rc->x_slice_min_ = rpps.getParameter<double>("x_slice_min");
       rc->x_slice_w_ = rpps.getParameter<double>("x_slice_w");
       rc->x_slice_n_ = std::ceil((rpps.getParameter<double>("x_slice_max") - rc->x_slice_min_) / rc->x_slice_w_);
     }
 
     sc->slope_ = sps.getParameter<double>("slope");
 
     sc->cut_h_apply_ = sps.getParameter<bool>("cut_h_apply");
     sc->cut_h_a_ = sps.getParameter<double>("cut_h_a");
     sc->cut_h_c_ = sps.getParameter<double>("cut_h_c");
     sc->cut_h_si_ = sps.getParameter<double>("cut_h_si");
 
     sc->cut_v_apply_ = sps.getParameter<bool>("cut_v_apply");
     sc->cut_v_a_ = sps.getParameter<double>("cut_v_a");
     sc->cut_v_c_ = sps.getParameter<double>("cut_v_c");
     sc->cut_v_si_ = sps.getParameter<double>("cut_v_si");
   }
 
   std::map<unsigned int, std::string> rpTags = {{sectorConfig45.rp_F_.id_, "rp_L_F"},
                                                 {sectorConfig45.rp_N_.id_, "rp_L_N"},
                                                 {sectorConfig56.rp_N_.id_, "rp_R_N"},
                                                 {sectorConfig56.rp_F_.id_, "rp_R_F"}};
 
   std::map<unsigned int, std::string> sectorNames = {{sectorConfig45.rp_F_.id_, sectorConfig45.name_},
                                                      {sectorConfig45.rp_N_.id_, sectorConfig45.name_},
                                                      {sectorConfig56.rp_N_.id_, sectorConfig56.name_},
                                                      {sectorConfig56.rp_F_.id_, sectorConfig56.name_}};
 
   std::map<unsigned int, const PPSAlignmentConfiguration::RPConfig*> rpConfigs = {
       {sectorConfig45.rp_F_.id_, &sectorConfig45.rp_F_},
       {sectorConfig45.rp_N_.id_, &sectorConfig45.rp_N_},
       {sectorConfig56.rp_N_.id_, &sectorConfig56.rp_N_},
       {sectorConfig56.rp_F_.id_, &sectorConfig56.rp_F_}};
 
   x_ali_sh_step = iConfig.getParameter<double>("x_ali_sh_step");
 
   y_mode_sys_unc = iConfig.getParameter<double>("y_mode_sys_unc");
   chiSqThreshold = iConfig.getParameter<double>("chiSqThreshold");
   y_mode_unc_max_valid = iConfig.getParameter<double>("y_mode_unc_max_valid");
   y_mode_max_valid = iConfig.getParameter<double>("y_mode_max_valid");
 
   minRPTracksSize = iConfig.getParameter<unsigned int>("min_RP_tracks_size");
   maxRPTracksSize = iConfig.getParameter<unsigned int>("max_RP_tracks_size");
   n_si = iConfig.getParameter<double>("n_si");
 
   const auto& c_axo = iConfig.getParameter<edm::ParameterSet>("x_alignment_meth_o");
   for (const auto& p : rpTags) {
     const auto& ps = c_axo.getParameter<edm::ParameterSet>(p.second);
     alignment_x_meth_o_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
   }
   fitProfileMinBinEntries = c_axo.getParameter<unsigned int>("fit_profile_min_bin_entries");
   fitProfileMinNReasonable = c_axo.getParameter<unsigned int>("fit_profile_min_N_reasonable");
   methOGraphMinN = c_axo.getParameter<unsigned int>("meth_o_graph_min_N");
   methOUncFitRange = c_axo.getParameter<double>("meth_o_unc_fit_range");
 
   const auto& c_m = iConfig.getParameter<edm::ParameterSet>("matching");
   const auto& referenceDataset = c_m.getParameter<std::string>("reference_dataset");
 
   // constructing vectors with reference data
   if (!referenceDataset.empty()) {
     auto f_ref = std::make_unique<TFile>(referenceDataset.c_str(), "READ");
     if (!f_ref->IsOpen()) {
       edm::LogWarning("PPS") << "[ESSource] could not find reference dataset file: " << referenceDataset;
     } else {
       TDirectory* ad_ref = findDirectoryWithName((TDirectory*)f_ref.get(), sectorConfig45.name_);
       if (ad_ref == nullptr) {
         edm::LogWarning("PPS") << "[ESSource] could not find reference dataset in " << referenceDataset;
       } else {
         edm::LogInfo("PPS") << "[ESSource] loading reference dataset from " << ad_ref->GetPath();
 
         for (const auto& p : rpTags) {
           if (debug)
             gDirectory = debugFile->mkdir(rpConfigs[p.first]->name_.c_str())->mkdir("fits_ref");
 
           auto* d_ref = (TDirectory*)ad_ref->Get(
               (sectorNames[p.first] + "/near_far/x slices, " + rpConfigs[p.first]->position_).c_str());
           if (d_ref == nullptr) {
             edm::LogWarning("PPS") << "[ESSource] could not load d_ref";
           } else {
             matchingReferencePoints[p.first] = buildVectorFromDirectory(d_ref, *rpConfigs[p.first]);
           }
         }
       }
     }
   }
 
   for (const auto& p : rpTags) {
     const auto& ps = c_m.getParameter<edm::ParameterSet>(p.second);
     matchingShiftRanges[p.first] = {ps.getParameter<double>("sh_min"), ps.getParameter<double>("sh_max")};
   }
 
   const auto& c_axr = iConfig.getParameter<edm::ParameterSet>("x_alignment_relative");
   for (const auto& p : rpTags) {
     if (p.second.back() == 'N') {  // only near RPs
       const auto& ps = c_axr.getParameter<edm::ParameterSet>(p.second);
       alignment_x_relative_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
     }
   }
   nearFarMinEntries = c_axr.getParameter<unsigned int>("near_far_min_entries");
 
   const auto& c_ay = iConfig.getParameter<edm::ParameterSet>("y_alignment");
   for (const auto& p : rpTags) {
     const auto& ps = c_ay.getParameter<edm::ParameterSet>(p.second);
     alignment_y_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
   }
   modeGraphMinN = c_ay.getParameter<unsigned int>("mode_graph_min_N");
   multSelProjYMinEntries = c_ay.getParameter<unsigned int>("mult_sel_proj_y_min_entries");
 
   const auto& bps = iConfig.getParameter<edm::ParameterSet>("binning");
   binning.bin_size_x_ = bps.getParameter<double>("bin_size_x");
   binning.n_bins_x_ = bps.getParameter<unsigned int>("n_bins_x");
   binning.pixel_x_offset_ = bps.getParameter<double>("pixel_x_offset");
   binning.n_bins_y_ = bps.getParameter<unsigned int>("n_bins_y");
   binning.y_min_ = bps.getParameter<double>("y_min");
   binning.y_max_ = bps.getParameter<double>("y_max");
 
   binning.diffFN_n_bins_x_ = bps.getParameter<unsigned int>("diffFN_n_bins_x");
   binning.diffFN_x_min_ = bps.getParameter<double>("diffFN_x_min");
   binning.diffFN_x_max_ = bps.getParameter<double>("diffFN_x_max");
 
   binning.slice_n_bins_x_ = bps.getParameter<unsigned int>("slice_n_bins_x");
   binning.slice_x_min_ = bps.getParameter<double>("slice_x_min");
   binning.slice_x_max_ = bps.getParameter<double>("slice_x_max");
   binning.slice_n_bins_y_ = bps.getParameter<unsigned int>("slice_n_bins_y");
   binning.slice_y_min_ = bps.getParameter<double>("slice_y_min");
   binning.slice_y_max_ = bps.getParameter<double>("slice_y_max");
 
   extraParams = iConfig.getParameter<std::vector<double>>("extra_params");
 
   setWhatProduced(this, label);
   findingRecord<PPSAlignmentConfigurationRcd>();
 }

Member Function Documentation

◆ buildVectorFromDirectory()

std::vector< PPSAlignmentConfiguration::PointErrors > PPSAlignmentConfigurationESSource::buildVectorFromDirectory	(	TDirectory *	dir,
		const PPSAlignmentConfiguration::RPConfig &	rpd
	)

private

Definition at line 619 of file PPSAlignmentConfigurationESSource.cc.

References ztail::d, debug, DeadROC_duringRun::dir, alig_utils::fitProfile(), fitProfileMinBinEntries, fitProfileMinNReasonable, dqmdumpme::k, Skims_PA_cff::name, GetRecoTauVFromDQM_MC_cff::next, EcalTangentSkim_cfg::o, MetAnalyzer::pv(), AlCaHLTBitMon_QueryRunRegistry::string, PPSAlignmentConfiguration::RPConfig::y_cen_add_, and PPSAlignmentConfiguration::RPConfig::y_width_mult_.

Referenced by PPSAlignmentConfigurationESSource().

                                                                    {
   std::vector<PPSAlignmentConfiguration::PointErrors> pv;
 
   TIter next(dir->GetListOfKeys());
   TObject* o;
   while ((o = next())) {
     TKey* k = (TKey*)o;
 
     std::string name = k->GetName();
     size_t d = name.find('-');
     const double x_min = std::stod(name.substr(0, d));
     const double x_max = std::stod(name.substr(d + 1));
 
     TDirectory* d_slice = (TDirectory*)k->ReadObj();
 
     TH1D* h_y = (TH1D*)d_slice->Get("h_y");
     TProfile* p_y_diffFN_vs_y = (TProfile*)d_slice->Get("p_y_diffFN_vs_y");
 
     double y_cen = h_y->GetMean();
     double y_width = h_y->GetRMS();
 
     y_cen += rpd.y_cen_add_;
     y_width *= rpd.y_width_mult_;
 
     double sl = 0., sl_unc = 0.;
     int fr = alig_utils::fitProfile(
         p_y_diffFN_vs_y, y_cen, y_width, fitProfileMinBinEntries, fitProfileMinNReasonable, sl, sl_unc);
     if (fr != 0)
       continue;
 
     if (debug)
       p_y_diffFN_vs_y->Write(name.c_str());
 
     pv.push_back({(x_max + x_min) / 2., sl, (x_max - x_min) / 2., sl_unc});
   }
 
   return pv;
 }

◆ fillDescriptions()

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

static

Definition at line 324 of file PPSAlignmentConfigurationESSource.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), binning, submitPVResolutionJobs::desc, TtSemiLepJetCombMVATrainer_cfi::matching, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                    {
   edm::ParameterSetDescription desc;
 
   desc.add<bool>("debug", false);
 
   desc.add<std::string>("label", "");
 
   // sector_45
   {
     edm::ParameterSetDescription sector45;
 
     edm::ParameterSetDescription rp_N;
     rp_N.add<std::string>("name", "L_1_F");
     rp_N.add<int>("id", 3);
 
     rp_N.add<double>("slope", 0.19);
     rp_N.add<double>("sh_x", -3.6);
 
     rp_N.add<double>("x_min_fit_mode", 2.);
     rp_N.add<double>("x_max_fit_mode", 7.0);
     rp_N.add<double>("y_max_fit_mode", 7.0);
     rp_N.add<double>("y_cen_add", -0.3);
     rp_N.add<double>("y_width_mult", 1.1);
 
     rp_N.add<double>("x_slice_min", 7.);
     rp_N.add<double>("x_slice_max", 19.);
     rp_N.add<double>("x_slice_w", 0.2);
     sector45.add<edm::ParameterSetDescription>("rp_N", rp_N);
 
     edm::ParameterSetDescription rp_F;
     rp_F.add<std::string>("name", "L_2_F");
     rp_F.add<int>("id", 23);
 
     rp_F.add<double>("slope", 0.19);
     rp_F.add<double>("sh_x", -42.);
 
     rp_F.add<double>("x_min_fit_mode", 2.);
     rp_F.add<double>("x_max_fit_mode", 7.5);
     rp_F.add<double>("y_max_fit_mode", 7.5);
     rp_F.add<double>("y_cen_add", -0.3);
     rp_F.add<double>("y_width_mult", 1.1);
 
     rp_F.add<double>("x_slice_min", 46.);
     rp_F.add<double>("x_slice_max", 58.);
     rp_F.add<double>("x_slice_w", 0.2);
     sector45.add<edm::ParameterSetDescription>("rp_F", rp_F);
 
     sector45.add<double>("slope", 0.006);
     sector45.add<bool>("cut_h_apply", true);
     sector45.add<double>("cut_h_a", -1.);
     sector45.add<double>("cut_h_c", -38.55);
     sector45.add<double>("cut_h_si", 0.2);
     sector45.add<bool>("cut_v_apply", true);
     sector45.add<double>("cut_v_a", -1.07);
     sector45.add<double>("cut_v_c", 1.63);
     sector45.add<double>("cut_v_si", 0.15);
 
     desc.add<edm::ParameterSetDescription>("sector_45", sector45);
   }
 
   // sector_56
   {
     edm::ParameterSetDescription sector56;
 
     edm::ParameterSetDescription rp_N;
     rp_N.add<std::string>("name", "R_1_F");
     rp_N.add<int>("id", 103);
 
     rp_N.add<double>("slope", 0.40);
     rp_N.add<double>("sh_x", -2.8);
 
     rp_N.add<double>("x_min_fit_mode", 2.);
     rp_N.add<double>("x_max_fit_mode", 7.4);
     rp_N.add<double>("y_max_fit_mode", 7.4);
     rp_N.add<double>("y_cen_add", -0.8);
     rp_N.add<double>("y_width_mult", 1.0);
 
     rp_N.add<double>("x_slice_min", 6.);
     rp_N.add<double>("x_slice_max", 17.);
     rp_N.add<double>("x_slice_w", 0.2);
     sector56.add<edm::ParameterSetDescription>("rp_N", rp_N);
 
     edm::ParameterSetDescription rp_F;
     rp_F.add<std::string>("name", "R_2_F");
     rp_F.add<int>("id", 123);
 
     rp_F.add<double>("slope", 0.39);
     rp_F.add<double>("sh_x", -41.9);
 
     rp_F.add<double>("x_min_fit_mode", 2.);
     rp_F.add<double>("x_max_fit_mode", 8.0);
     rp_F.add<double>("y_max_fit_mode", 8.0);
     rp_F.add<double>("y_cen_add", -0.8);
     rp_F.add<double>("y_width_mult", 1.0);
 
     rp_F.add<double>("x_slice_min", 45.);
     rp_F.add<double>("x_slice_max", 57.);
     rp_F.add<double>("x_slice_w", 0.2);
     sector56.add<edm::ParameterSetDescription>("rp_F", rp_F);
 
     sector56.add<double>("slope", -0.015);
     sector56.add<bool>("cut_h_apply", true);
     sector56.add<double>("cut_h_a", -1.);
     sector56.add<double>("cut_h_c", -39.26);
     sector56.add<double>("cut_h_si", 0.2);
     sector56.add<bool>("cut_v_apply", true);
     sector56.add<double>("cut_v_a", -1.07);
     sector56.add<double>("cut_v_c", 1.49);
     sector56.add<double>("cut_v_si", 0.15);
 
     desc.add<edm::ParameterSetDescription>("sector_56", sector56);
   }
 
   desc.add<double>("x_ali_sh_step", 0.01);
 
   desc.add<double>("y_mode_sys_unc", 0.03);
   desc.add<double>("chiSqThreshold", 50.);
   desc.add<double>("y_mode_unc_max_valid", 5.);
   desc.add<double>("y_mode_max_valid", 20.);
 
   desc.add<unsigned int>("min_RP_tracks_size", 1);
   desc.add<unsigned int>("max_RP_tracks_size", 1);
   desc.add<double>("n_si", 4.);
 
   // matching
   {
     edm::ParameterSetDescription matching;
     matching.add<std::string>("reference_dataset", "");
 
     edm::ParameterSetDescription rpLF;
     rpLF.add<double>("sh_min", -43.);
     rpLF.add<double>("sh_max", -41.);
     matching.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
 
     edm::ParameterSetDescription rpLN;
     rpLN.add<double>("sh_min", -4.2);
     rpLN.add<double>("sh_max", -2.4);
     matching.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
 
     edm::ParameterSetDescription rpRN;
     rpRN.add<double>("sh_min", -3.6);
     rpRN.add<double>("sh_max", -1.8);
     matching.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
 
     edm::ParameterSetDescription rpRF;
     rpRF.add<double>("sh_min", -43.2);
     rpRF.add<double>("sh_max", -41.2);
     matching.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
 
     desc.add<edm::ParameterSetDescription>("matching", matching);
   }
 
   // x alignment meth o
   {
     edm::ParameterSetDescription x_alignment_meth_o;
 
     edm::ParameterSetDescription rpLF;
     rpLF.add<double>("x_min", 47.);
     rpLF.add<double>("x_max", 56.5);
     x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
 
     edm::ParameterSetDescription rpLN;
     rpLN.add<double>("x_min", 9.);
     rpLN.add<double>("x_max", 18.5);
     x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
 
     edm::ParameterSetDescription rpRN;
     rpRN.add<double>("x_min", 7.);
     rpRN.add<double>("x_max", 15.);
     x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
 
     edm::ParameterSetDescription rpRF;
     rpRF.add<double>("x_min", 46.);
     rpRF.add<double>("x_max", 54.);
     x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
 
     x_alignment_meth_o.add<unsigned int>("fit_profile_min_bin_entries", 5);
     x_alignment_meth_o.add<unsigned int>("fit_profile_min_N_reasonable", 10);
     x_alignment_meth_o.add<unsigned int>("meth_o_graph_min_N", 5);
     x_alignment_meth_o.add<double>("meth_o_unc_fit_range", 0.5);
 
     desc.add<edm::ParameterSetDescription>("x_alignment_meth_o", x_alignment_meth_o);
   }
 
   // x alignment relative
   {
     edm::ParameterSetDescription x_alignment_relative;
 
     edm::ParameterSetDescription rpLN;
     rpLN.add<double>("x_min", 7.5);
     rpLN.add<double>("x_max", 12.);
     x_alignment_relative.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
 
     edm::ParameterSetDescription rpRN;
     rpRN.add<double>("x_min", 6.);
     rpRN.add<double>("x_max", 10.);
     x_alignment_relative.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
 
     x_alignment_relative.add<unsigned int>("near_far_min_entries", 100);
 
     desc.add<edm::ParameterSetDescription>("x_alignment_relative", x_alignment_relative);
   }
 
   // y alignment
   {
     edm::ParameterSetDescription y_alignment;
 
     edm::ParameterSetDescription rpLF;
     rpLF.add<double>("x_min", 44.5);
     rpLF.add<double>("x_max", 49.);
     y_alignment.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
 
     edm::ParameterSetDescription rpLN;
     rpLN.add<double>("x_min", 6.7);
     rpLN.add<double>("x_max", 11.);
     y_alignment.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
 
     edm::ParameterSetDescription rpRN;
     rpRN.add<double>("x_min", 5.9);
     rpRN.add<double>("x_max", 10.);
     y_alignment.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
 
     edm::ParameterSetDescription rpRF;
     rpRF.add<double>("x_min", 44.5);
     rpRF.add<double>("x_max", 49.);
     y_alignment.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
 
     y_alignment.add<unsigned int>("mode_graph_min_N", 5);
     y_alignment.add<unsigned int>("mult_sel_proj_y_min_entries", 300);
 
     desc.add<edm::ParameterSetDescription>("y_alignment", y_alignment);
   }
 
   // binning
   {
     edm::ParameterSetDescription binning;
 
     binning.add<double>("bin_size_x", 142.3314E-3);
     binning.add<unsigned int>("n_bins_x", 210);
     binning.add<double>("pixel_x_offset", 40.);
     binning.add<unsigned int>("n_bins_y", 400);
     binning.add<double>("y_min", -20.);
     binning.add<double>("y_max", 20.);
 
     binning.add<unsigned int>("diffFN_n_bins_x", 100);
     binning.add<double>("diffFN_x_min", 0.);
     binning.add<double>("diffFN_x_max", 20.);
 
     binning.add<unsigned int>("slice_n_bins_x", 100);
     binning.add<double>("slice_x_min", -10.);
     binning.add<double>("slice_x_max", 10.);
     binning.add<unsigned int>("slice_n_bins_y", 100);
     binning.add<double>("slice_y_min", -2.);
     binning.add<double>("slice_y_max", 2.);
 
     desc.add<edm::ParameterSetDescription>("binning", binning);
   }
 
   desc.add<std::vector<double>>("extra_params", {});
 
   descriptions.add("ppsAlignmentConfigurationESSource", desc);
 }

◆ findDirectoryWithName()

TDirectory * PPSAlignmentConfigurationESSource::findDirectoryWithName	(	TDirectory *	dir,
		std::string	searchName
	)

private

Definition at line 591 of file PPSAlignmentConfigurationESSource.cc.

References DeadROC_duringRun::dir, dqmdumpme::k, Skims_PA_cff::name, GetRecoTauVFromDQM_MC_cff::next, EcalTangentSkim_cfg::o, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PPSAlignmentConfigurationESSource().

                                                                                                           {
   TIter next(dir->GetListOfKeys());
   std::queue<TDirectory*> dirQueue;
   TObject* o;
   while ((o = next())) {
     TKey* k = (TKey*)o;
 
     std::string name = k->GetName();
     if (name == searchName)
       return dir;
 
     if (((TSystemFile*)k)->IsDirectory())
       dirQueue.push((TDirectory*)k->ReadObj());
   }
 
   while (!dirQueue.empty()) {
     TDirectory* resultDir = findDirectoryWithName(dirQueue.front(), searchName);
     dirQueue.pop();
     if (resultDir != nullptr)
       return resultDir;
   }
 
   return nullptr;
 }

◆ produce()

std::unique_ptr< PPSAlignmentConfiguration > PPSAlignmentConfigurationESSource::produce ( const PPSAlignmentConfigurationRcd & )

Definition at line 276 of file PPSAlignmentConfigurationESSource.cc.

References alignment_x_meth_o_ranges, alignment_x_relative_ranges, alignment_y_ranges, binning, chiSqThreshold, extraParams, fitProfileMinBinEntries, fitProfileMinNReasonable, label, matchingReferencePoints, matchingShiftRanges, maxRPTracksSize, methOGraphMinN, methOUncFitRange, minRPTracksSize, modeGraphMinN, multSelProjYMinEntries, n_si, nearFarMinEntries, AlCaHLTBitMon_ParallelJobs::p, sectorConfig45, sectorConfig56, x_ali_sh_step, y_mode_max_valid, y_mode_sys_unc, and y_mode_unc_max_valid.

                                          {
   auto p = std::make_unique<PPSAlignmentConfiguration>();
 
   p->setSectorConfig45(sectorConfig45);
   p->setSectorConfig56(sectorConfig56);
 
   p->setX_ali_sh_step(x_ali_sh_step);
 
   p->setY_mode_sys_unc(y_mode_sys_unc);
   p->setChiSqThreshold(chiSqThreshold);
   p->setY_mode_unc_max_valid(y_mode_unc_max_valid);
   p->setY_mode_max_valid(y_mode_max_valid);
 
   p->setMinRPTracksSize(minRPTracksSize);
   p->setMaxRPTracksSize(maxRPTracksSize);
   p->setN_si(n_si);
 
   p->setMatchingReferencePoints(matchingReferencePoints);
   p->setMatchingShiftRanges(matchingShiftRanges);
 
   p->setAlignment_x_meth_o_ranges(alignment_x_meth_o_ranges);
   p->setFitProfileMinBinEntries(fitProfileMinBinEntries);
   p->setFitProfileMinNReasonable(fitProfileMinNReasonable);
   p->setMethOGraphMinN(methOGraphMinN);
   p->setMethOUncFitRange(methOUncFitRange);
 
   p->setAlignment_x_relative_ranges(alignment_x_relative_ranges);
   p->setNearFarMinEntries(nearFarMinEntries);
 
   p->setAlignment_y_ranges(alignment_y_ranges);
   p->setModeGraphMinN(modeGraphMinN);
   p->setMultSelProjYMinEntries(multSelProjYMinEntries);
 
   p->setBinning(binning);
 
   p->setExtraParams(extraParams);
 
   edm::LogInfo("PPS") << "\n"
                       << "[ESSource] " << (label.empty() ? "empty label" : "label = " + label) << ":\n\n"
                       << (*p);
 
   return p;
 }

◆ setIntervalFor()

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

overrideprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 661 of file PPSAlignmentConfigurationESSource.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), edm::EventID::event(), edm::IOVSyncValue::eventID(), infinity, crabWrapper::key, and edm::EventID::run().

                                                                                        {
   edm::LogInfo("PPS") << ">> PPSAlignmentConfigurationESSource::setIntervalFor(" << key.name() << ")\n"
                       << "    run=" << iosv.eventID().run() << ", event=" << iosv.eventID().event();
 
   edm::ValidityInterval infinity(iosv.beginOfTime(), iosv.endOfTime());
   oValidity = infinity;
 }