plugins/fake/SiStripLorentzAngleFakeESSource.cc

0001 // -*- C++ -*-
0002 //
0003 // Package:    CalibTracker/SiStripESProducers
0004 // Class:      SiStripLorentzAngleFakeESSource
0005 //
0006 /**\class SiStripLorentzAngleFakeESSource SiStripLorentzAngleFakeESSource.h CalibTracker/SiStripESProducers/plugins/SiStripLorentzAngleFakeESSource.cc
0007
0008  Description: Generator of the ideal/fake conditions for the LorentzAngle.
0009
0010  It receives input values with layer granularity and it is able to perform gaussian smearing or
0011  use a uniform distribution at the module level.
0012  Depending on the parameters passed via cfg, it is able to generate the values per DetId
0013  with a gaussian distribution and a uniform distribution. When setting the sigma of the gaussian to 0
0014  and passing a single value the generated values are fixed.
0015  For TID and TEC the decision to generate with a uniform distribution comes from the setting
0016  for the first layers of TIB and TOB.
0017
0018  Implementation:
0019      Port of SiStripLorentzAngleGenerator and templated fake ESSource to an edm::ESProducer
0020 */
0021
0022 // system include files
0023 #include <memory>
0024 #include <numeric>
0025
0026 // user include files
0027 #include "FWCore/Framework/interface/ESProducer.h"
0028 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0029
0030 #include "CondFormats/SiStripObjects/interface/SiStripLorentzAngle.h"
0031 #include "CondFormats/DataRecord/interface/SiStripCondDataRecords.h"
0032 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0033 #include "DataFormats/SiStripDetId/interface/SiStripDetId.h"
0034 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
0035 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0036 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
0037
0038 class SiStripLorentzAngleFakeESSource : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
0039 public:
0040   SiStripLorentzAngleFakeESSource(const edm::ParameterSet&);
0041   ~SiStripLorentzAngleFakeESSource() override;
0042
0043   void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
0044                       const edm::IOVSyncValue& iov,
0045                       edm::ValidityInterval& iValidity) override;
0046
0047   typedef std::unique_ptr<SiStripLorentzAngle> ReturnType;
0048   ReturnType produce(const SiStripLorentzAngleRcd&);
0049
0050 private:
0051   std::vector<double> m_TIB_EstimatedValuesMin;
0052   std::vector<double> m_TIB_EstimatedValuesMax;
0053   std::vector<double> m_TOB_EstimatedValuesMin;
0054   std::vector<double> m_TOB_EstimatedValuesMax;
0055   std::vector<double> m_TIB_PerCent_Errs;
0056   std::vector<double> m_TOB_PerCent_Errs;
0057   std::vector<double> m_StdDevs_TIB;
0058   std::vector<double> m_StdDevs_TOB;
0059   std::vector<bool> m_uniformTIB;
0060   std::vector<bool> m_uniformTOB;
0061   double m_TIBmeanValueMin;
0062   double m_TIBmeanValueMax;
0063   double m_TOBmeanValueMin;
0064   double m_TOBmeanValueMax;
0065   double m_TIBmeanPerCentError;
0066   double m_TOBmeanPerCentError;
0067   double m_TIBmeanStdDev;
0068   double m_TOBmeanStdDev;
0069   edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> m_tTopoToken;
0070   edm::ESGetToken<GeometricDet, IdealGeometryRecord> m_geomDetToken;
0071 };
0072
0073 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0074 #include "Geometry/TrackerNumberingBuilder/interface/utils.h"
0075
0076 #include "CLHEP/Random/RandFlat.h"
0077 #include "CLHEP/Random/RandGauss.h"
0078
0079 namespace {  // helper methods
0080   /// Method used to determine whether to generate with a uniform distribution for each layer
0081   void setUniform(const std::vector<double>& estimatedValuesMin,
0082                   const std::vector<double>& estimatedValuesMax,
0083                   std::vector<bool>& uniform) {
0084     if (!estimatedValuesMax.empty()) {
0085       std::vector<double>::const_iterator min = estimatedValuesMin.begin();
0086       std::vector<double>::const_iterator max = estimatedValuesMax.begin();
0087       std::vector<bool>::iterator uniformIt = uniform.begin();
0088       for (; min != estimatedValuesMin.end(); ++min, ++max, ++uniformIt) {
0089         if (*min != *max)
0090           *uniformIt = true;
0091       }
0092     }
0093   }
0094
0095   double computeSigma(const double& value, const double& perCentError) { return (perCentError / 100) * value; }
0096
0097   /**
0098    * Generate a hallMobility value according to the parameters passed in the cfg.
0099    * - If a min and max value were passed it takes the value from a uniform distribution.
0100    * - If only a single value was passed and the error is set != 0 it takes the value from a gaussian distribution.
0101    * - If the error is 0 and only one value is passed it takes the fixed min value.
0102    */
0103   float hallMobility(const double& meanMin, const double& meanMax, const double& sigma, const bool uniform) {
0104     if (uniform) {
0105       return CLHEP::RandFlat::shoot(meanMin, meanMax);
0106     } else if (sigma > 0) {
0107       return CLHEP::RandGauss::shoot(meanMin, sigma);
0108     } else {
0109       return meanMin;
0110     }
0111   }
0112 }  // namespace
0113
0114 SiStripLorentzAngleFakeESSource::SiStripLorentzAngleFakeESSource(const edm::ParameterSet& iConfig) {
0115   auto cc = setWhatProduced(this);
0116   m_tTopoToken = cc.consumes();
0117   m_geomDetToken = cc.consumes();
0118   findingRecord<SiStripLorentzAngleRcd>();
0119
0120   m_TIB_EstimatedValuesMin = iConfig.getParameter<std::vector<double>>("TIB_EstimatedValuesMin");
0121   m_TIB_EstimatedValuesMax = iConfig.getParameter<std::vector<double>>("TIB_EstimatedValuesMax");
0122   m_TOB_EstimatedValuesMin = iConfig.getParameter<std::vector<double>>("TOB_EstimatedValuesMin");
0123   m_TOB_EstimatedValuesMax = iConfig.getParameter<std::vector<double>>("TOB_EstimatedValuesMax");
0124   m_TIB_PerCent_Errs = iConfig.getParameter<std::vector<double>>("TIB_PerCent_Errs");
0125   m_TOB_PerCent_Errs = iConfig.getParameter<std::vector<double>>("TOB_PerCent_Errs");
0126
0127   // If max values are passed they must be equal in number to the min values.
0128   if (((!m_TIB_EstimatedValuesMax.empty()) && (m_TIB_EstimatedValuesMin.size() != m_TIB_EstimatedValuesMax.size())) ||
0129       ((!m_TOB_EstimatedValuesMax.empty()) && (m_TOB_EstimatedValuesMin.size() != m_TOB_EstimatedValuesMax.size()))) {
0130     std::cout << "ERROR: size of min and max values is different" << std::endl;
0131     std::cout << "TIB_EstimatedValuesMin.size() = " << m_TIB_EstimatedValuesMin.size()
0132               << ", TIB_EstimatedValuesMax.size() " << m_TIB_EstimatedValuesMax.size() << std::endl;
0133     std::cout << "TOB_EstimatedValuesMin.size() = " << m_TOB_EstimatedValuesMin.size()
0134               << ", TOB_EstimatedValuesMax.size() " << m_TOB_EstimatedValuesMax.size() << std::endl;
0135   }
0136
0137   m_uniformTIB = std::vector<bool>(m_TIB_EstimatedValuesMin.size(), false);
0138   m_uniformTOB = std::vector<bool>(m_TOB_EstimatedValuesMin.size(), false);
0139   setUniform(m_TIB_EstimatedValuesMin, m_TIB_EstimatedValuesMax, m_uniformTIB);
0140   setUniform(m_TOB_EstimatedValuesMin, m_TOB_EstimatedValuesMax, m_uniformTOB);
0141
0142   // Compute standard deviations
0143   m_StdDevs_TIB = std::vector<double>(m_TIB_EstimatedValuesMin.size(), 0);
0144   m_StdDevs_TOB = std::vector<double>(m_TOB_EstimatedValuesMin.size(), 0);
0145   transform(m_TIB_EstimatedValuesMin.begin(),
0146             m_TIB_EstimatedValuesMin.end(),
0147             m_TIB_PerCent_Errs.begin(),
0148             m_StdDevs_TIB.begin(),
0149             computeSigma);
0150   transform(m_TOB_EstimatedValuesMin.begin(),
0151             m_TOB_EstimatedValuesMin.end(),
0152             m_TOB_PerCent_Errs.begin(),
0153             m_StdDevs_TOB.begin(),
0154             computeSigma);
0155
0156   // Compute mean values to be used with TID and TEC
0157   m_TIBmeanValueMin = std::accumulate(m_TIB_EstimatedValuesMin.begin(), m_TIB_EstimatedValuesMin.end(), 0.) /
0158                       double(m_TIB_EstimatedValuesMin.size());
0159   m_TIBmeanValueMax = std::accumulate(m_TIB_EstimatedValuesMax.begin(), m_TIB_EstimatedValuesMax.end(), 0.) /
0160                       double(m_TIB_EstimatedValuesMax.size());
0161   m_TOBmeanValueMin = std::accumulate(m_TOB_EstimatedValuesMin.begin(), m_TOB_EstimatedValuesMin.end(), 0.) /
0162                       double(m_TOB_EstimatedValuesMin.size());
0163   m_TOBmeanValueMax = std::accumulate(m_TOB_EstimatedValuesMax.begin(), m_TOB_EstimatedValuesMax.end(), 0.) /
0164                       double(m_TOB_EstimatedValuesMax.size());
0165   m_TIBmeanPerCentError =
0166       std::accumulate(m_TIB_PerCent_Errs.begin(), m_TIB_PerCent_Errs.end(), 0.) / double(m_TIB_PerCent_Errs.size());
0167   m_TOBmeanPerCentError =
0168       std::accumulate(m_TOB_PerCent_Errs.begin(), m_TOB_PerCent_Errs.end(), 0.) / double(m_TOB_PerCent_Errs.size());
0169   m_TIBmeanStdDev = (m_TIBmeanPerCentError / 100) * m_TIBmeanValueMin;
0170   m_TOBmeanStdDev = (m_TOBmeanPerCentError / 100) * m_TOBmeanValueMin;
0171 }
0172
0173 SiStripLorentzAngleFakeESSource::~SiStripLorentzAngleFakeESSource() {}
0174
0175 void SiStripLorentzAngleFakeESSource::setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
0176                                                      const edm::IOVSyncValue& iov,
0177                                                      edm::ValidityInterval& iValidity) {
0178   iValidity = edm::ValidityInterval{iov.beginOfTime(), iov.endOfTime()};
0179 }
0180
0181 // ------------ method called to produce the data  ------------
0182 SiStripLorentzAngleFakeESSource::ReturnType SiStripLorentzAngleFakeESSource::produce(
0183     const SiStripLorentzAngleRcd& iRecord) {
0184   using namespace edm::es;
0185
0186   const auto& geomDet = iRecord.getRecord<TrackerTopologyRcd>().get(m_geomDetToken);
0187   const auto& tTopo = iRecord.get(m_tTopoToken);
0188
0189   auto lorentzAngle = std::make_unique<SiStripLorentzAngle>();
0190
0191   for (const auto detId : TrackerGeometryUtils::getSiStripDetIds(geomDet)) {
0192     const DetId detectorId = DetId(detId);
0193     const int subDet = detectorId.subdetId();
0194
0195     float mobi{0.};
0196
0197     if (subDet == int(StripSubdetector::TIB)) {
0198       const int layerId = tTopo.tibLayer(detectorId) - 1;
0199       mobi = hallMobility(m_TIB_EstimatedValuesMin[layerId],
0200                           m_TIB_EstimatedValuesMax[layerId],
0201                           m_StdDevs_TIB[layerId],
0202                           m_uniformTIB[layerId]);
0203     } else if (subDet == int(StripSubdetector::TOB)) {
0204       const int layerId = tTopo.tobLayer(detectorId) - 1;
0205       mobi = hallMobility(m_TOB_EstimatedValuesMin[layerId],
0206                           m_TOB_EstimatedValuesMax[layerId],
0207                           m_StdDevs_TOB[layerId],
0208                           m_uniformTOB[layerId]);
0209     } else if (subDet == int(StripSubdetector::TID)) {
0210       // ATTENTION: as of now the uniform generation for TID is decided by the setting for layer 0 of TIB
0211       mobi = hallMobility(m_TIBmeanValueMin, m_TIBmeanValueMax, m_TIBmeanStdDev, m_uniformTIB[0]);
0212     }
0213     if (subDet == int(StripSubdetector::TEC)) {
0214       if (tTopo.tecRing(detectorId) < 5) {
0215         // ATTENTION: as of now the uniform generation for TEC is decided by the setting for layer 0 of TIB
0216         mobi = hallMobility(m_TIBmeanValueMin, m_TIBmeanValueMax, m_TIBmeanStdDev, m_uniformTIB[0]);
0217       } else {
0218         // ATTENTION: as of now the uniform generation for TEC is decided by the setting for layer 0 of TOB
0219         mobi = hallMobility(m_TOBmeanValueMin, m_TOBmeanValueMax, m_TOBmeanStdDev, m_uniformTOB[0]);
0220       }
0221     }
0222
0223     if (!lorentzAngle->putLorentzAngle(detId, mobi)) {
0224       edm::LogError("SiStripLorentzAngleFakeESSource::produce ") << " detid already exists";
0225     }
0226   }
0227
0228   return lorentzAngle;
0229 }
0230
0231 //define this as a plug-in
0232 #include "FWCore/Framework/interface/SourceFactory.h"
0233 DEFINE_FWK_EVENTSETUP_SOURCE(SiStripLorentzAngleFakeESSource);