#include <CondTools/SiStrip/plugins/SiStripNoisesFromDBMiscalibrator.cc>

Inheritance diagram for SiStripNoisesFromDBMiscalibrator:

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

	~SiStripNoisesFromDBMiscalibrator () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

std::unique_ptr< SiStripNoises >	getNewObject (const std::map< std::pair< uint32_t, int >, float > &theMap)

std::unique_ptr< SiStripNoises >	getNewObject_withDefaults (const std::map< std::pair< uint32_t, int >, float > &theMap, const float theDefault)

Private Attributes
edm::FileInPath	fp_

const bool	m_fillDefaults

const std::vector< edm::ParameterSet >	m_parameters

const bool	m_saveMaps

std::unique_ptr< TrackerMap >	missing_map

std::unique_ptr< TrackerMap >	new_payload_map

std::unique_ptr< TrackerMap >	old_payload_map

std::unique_ptr< TrackerMap >	ratio_map

std::unique_ptr< TrackerMap >	scale_map

std::unique_ptr< TrackerMap >	smear_map

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Class to miscalibrate a SiStrip Noise payload from Database

Implementation: Read a SiStrip Noise payload from DB (either central DB or sqlite file) and apply a miscalibration (either an offset / gaussian smearing or both) returns a local sqlite file with the same since of the original payload

Definition at line 51 of file SiStripNoisesFromDBMiscalibrator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 82 of file SiStripNoisesFromDBMiscalibrator.cc.

References fp_, edm::ParameterSet::getUntrackedParameter(), m_fillDefaults, m_parameters, m_saveMaps, missing_map, new_payload_map, old_payload_map, ratio_map, scale_map, and smear_map.

                                                                                                 :
   m_fillDefaults{iConfig.getUntrackedParameter<bool>("fillDefaults",false)},
   m_saveMaps{iConfig.getUntrackedParameter<bool>("saveMaps",true)},
   m_parameters{iConfig.getParameter<std::vector<edm::ParameterSet> >("params")},
   fp_{iConfig.getUntrackedParameter<edm::FileInPath>("file",edm::FileInPath("CalibTracker/SiStripCommon/data/SiStripDetInfo.dat"))}
 {
    //now do what ever initialization is needed
 
   scale_map = std::unique_ptr<TrackerMap>(new TrackerMap("scale"));
   scale_map->setTitle("Tracker Map of Scale factor averaged by module");
   scale_map->setPalette(1);
 
   smear_map =std::unique_ptr<TrackerMap>(new TrackerMap("smear"));
   smear_map->setTitle("Tracker Map of Smear factor averaged by module");
   smear_map->setPalette(1);
 
   old_payload_map =std::unique_ptr<TrackerMap>(new TrackerMap("old_payload"));
   old_payload_map->setTitle("Tracker Map of Starting Noise Payload averaged by module");
   old_payload_map->setPalette(1);
 
   new_payload_map =std::unique_ptr<TrackerMap>(new TrackerMap("new_payload"));
   new_payload_map->setTitle("Tracker Map of Modified Noise Payload averaged by module");
   new_payload_map->setPalette(1);
 
   ratio_map = std::unique_ptr<TrackerMap>(new TrackerMap("ratio"));
   ratio_map->setTitle("Tracker Map of Average by module of the payload ratio (new/old)");
   ratio_map->setPalette(1);
 
   if(m_fillDefaults){
     missing_map = std::unique_ptr<TrackerMap>(new TrackerMap("uncabled"));
     missing_map->setTitle("Tracker Map of uncabled modules");
     missing_map->setPalette(1);
   }
 
 }

SiStripNoisesFromDBMiscalibrator::~SiStripNoisesFromDBMiscalibrator ( )

override

Definition at line 119 of file SiStripNoisesFromDBMiscalibrator.cc.

120 {

121 }

Member Function Documentation

void SiStripNoisesFromDBMiscalibrator::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 130 of file SiStripNoisesFromDBMiscalibrator.cc.

References SiStripMiscalibrate::Entry::add(), cond::service::PoolDBOutputService::currentTime(), edmIntegrityCheck::d, spr::find(), edm::EventSetup::get(), SiStripNoises::getDetIds(), getNewObject(), getNewObject_withDefaults(), SiStripNoises::getNoise(), SiStripNoises::getRange(), SiStripMiscalibrate::getRegionFromString(), SiStripMiscalibrate::getRegionsFromDetId(), edm::Service< T >::isAvailable(), m_fillDefaults, m_parameters, SiStripMiscalibrate::Entry::mean(), new_payload_map, old_payload_map, edm::ESHandle< T >::product(), ratio_map, SiStripMiscalibrate::Entry::reset(), scale_map, SiStripMiscalibrate::Smearings::setSmearing(), smear_map, AlCaHLTBitMon_QueryRunRegistry::string, and cond::service::PoolDBOutputService::writeOne().

 {
    using namespace edm;
 
    edm::ESHandle<TrackerTopology> tTopoHandle;
    iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
    const auto* const tTopo = tTopoHandle.product();
 
    std::vector<std::string> partitions;
 
    // fill the list of partitions 
    for(auto& thePSet : m_parameters){
      const std::string partition(thePSet.getParameter<std::string>("partition"));
      // only if it is not yet in the list
      if(std::find(partitions.begin(), partitions.end(), partition) == partitions.end()) {
        partitions.push_back(partition);
      }
    }
 
    std::map<sistripsummary::TrackerRegion,SiStripMiscalibrate::Smearings> mapOfSmearings;
 
    for(auto& thePSet : m_parameters){
      
      const std::string partition(thePSet.getParameter<std::string>("partition"));
      sistripsummary::TrackerRegion region = SiStripMiscalibrate::getRegionFromString(partition);
      
      bool    m_doScale(thePSet.getParameter<bool>("doScale"));
      bool    m_doSmear(thePSet.getParameter<bool>("doSmear"));
      double  m_scaleFactor(thePSet.getParameter<double>("scaleFactor"));
      double  m_smearFactor(thePSet.getParameter<double>("smearFactor"));
      
      SiStripMiscalibrate::Smearings params = SiStripMiscalibrate::Smearings();
      params.setSmearing(m_doScale,m_doSmear,m_scaleFactor,m_smearFactor);
      mapOfSmearings[region]=params;
    }
    
    edm::ESHandle<SiStripNoises> SiStripNoise_;
    iSetup.get<SiStripNoisesRcd>().get(SiStripNoise_);
 
    std::map<std::pair<uint32_t,int>,float> theMap, oldPayloadMap;
    
    std::vector<uint32_t> detid;
    SiStripNoise_->getDetIds(detid);
    for (const auto & d : detid) {
      SiStripNoises::Range range=SiStripNoise_->getRange(d);
 
      auto regions = SiStripMiscalibrate::getRegionsFromDetId(tTopo,d); 
 
      // sort by largest to smallest
      std::sort(regions.rbegin(), regions.rend());
      
      SiStripMiscalibrate::Smearings params = SiStripMiscalibrate::Smearings();
      
      for (unsigned int j=0; j<regions.size();j++){
        bool checkRegion = (mapOfSmearings.count(regions[j]) != 0);
 
        if(!checkRegion) {
      // if the subdetector is not in the list and there's no indication for the whole tracker, just use the default 
      // i.e. no change
      continue;
        } else {
      params = mapOfSmearings[regions[j]];
      break;
        }
      }
 
      scale_map->fill(d,params.m_scaleFactor);
      smear_map->fill(d,params.m_smearFactor);
 
      int nStrips=0;
      for( int it=0; it < (range.second-range.first)*8/9; ++it ){
        auto noise=SiStripNoise_->getNoise(it,range);
        std::pair<uint32_t,int> index = std::make_pair(d,nStrips);
 
        oldPayloadMap[index]=noise;
 
        if(params.m_doScale){
      noise*=params.m_scaleFactor;
        }
        
        if(params.m_doSmear){
      float smearedNoise = CLHEP::RandGauss::shoot(noise,params.m_smearFactor); 
      noise=smearedNoise;
        }
 
        theMap[index]=noise;
       
        nStrips+=1;
  
      } // loop over APVs
    } // loop over DetIds
 
    std::unique_ptr<SiStripNoises> theSiStripNoises;
    if(!m_fillDefaults){
      theSiStripNoises = this->getNewObject(theMap);
    } else {
      theSiStripNoises = this->getNewObject_withDefaults(theMap,-1.);
    }
 
    // make the payload ratio map
    uint32_t cachedId(0);
    SiStripMiscalibrate::Entry noise_ratio;
    SiStripMiscalibrate::Entry o_noise;
    SiStripMiscalibrate::Entry n_noise;
    for(const auto &element : theMap){
 
      uint32_t DetId  = element.first.first;
      int      nstrip = element.first.second;
      float new_noise = element.second;
      float old_noise = oldPayloadMap[std::make_pair(DetId,nstrip)];
      
      // flush the counters
      if(cachedId!=0 && DetId!=cachedId){
        ratio_map->fill(cachedId,noise_ratio.mean());
        old_payload_map->fill(cachedId,o_noise.mean());
        new_payload_map->fill(cachedId,n_noise.mean());
 
        //auto test = new_payload_map.get()->smoduleMap;
 
        noise_ratio.reset();
        o_noise.reset();
        n_noise.reset();
      } 
      
      cachedId=DetId;
      noise_ratio.add(new_noise/old_noise);
      o_noise.add(old_noise);
      n_noise.add(new_noise);
    }
 
    // write out the SiStripNoises record
    edm::Service<cond::service::PoolDBOutputService> poolDbService;
   
    if( poolDbService.isAvailable() )
      poolDbService->writeOne(theSiStripNoises.get(),poolDbService->currentTime(),"SiStripNoisesRcd");
    else
      throw std::runtime_error("PoolDBService required.");
  
 }

void SiStripNoisesFromDBMiscalibrator::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 272 of file SiStripNoisesFromDBMiscalibrator.cc.

273 {

274 }

void SiStripNoisesFromDBMiscalibrator::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 278 of file SiStripNoisesFromDBMiscalibrator.cc.

References SiStripMiscalibrate::getTruncatedRange(), m_fillDefaults, m_saveMaps, missing_map, new_payload_map, old_payload_map, ratio_map, scale_map, and smear_map.

 {
 
   if(m_saveMaps){
     scale_map->save(true,0,0,"noise_scale_map.pdf");
     scale_map->save(true,0,0,"noise_scale_map.png"); 
                          
     smear_map->save(true,0,0,"noise_smear_map.pdf");
     smear_map->save(true,0,0,"noise_smear_map.png"); 
                          
     ratio_map->save(true,0,0,"noise_ratio_map.pdf");
     ratio_map->save(true,0,0,"noise_ratio_map.png"); 
 
     auto range = SiStripMiscalibrate::getTruncatedRange(old_payload_map.get());
 
     old_payload_map->save(true,range.first,range.second,"starting_noise_payload_map.pdf");
     old_payload_map->save(true,range.first,range.second,"starting_noise_payload_map.png");
                                               
     range = SiStripMiscalibrate::getTruncatedRange(new_payload_map.get());
 
     new_payload_map->save(true,range.first,range.second,"new_noise_payload_map.pdf");
     new_payload_map->save(true,range.first,range.second,"new_noise_payload_map.png");
 
     if(m_fillDefaults){
       missing_map->save(true,0,0,"missing_map.pdf");
       missing_map->save(true,0,0,"missing_map.png");
     }
   }
 }

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

static

Definition at line 404 of file SiStripNoisesFromDBMiscalibrator.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, edm::ParameterSetDescription::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
   
   desc.setComment("Creates rescaled / smeared SiStrip Noise payload."
                   "PoolDBOutputService must be set up for 'SiSiStripNoisesRcd'.");
   
   edm::ParameterSetDescription descScaler;
   descScaler.setComment("ParameterSet specifying the Strip tracker partition to be scaled / smeared "
                         "by a given factor.");
 
   descScaler.add<std::string>("partition", "Tracker");
   descScaler.add<bool>("doScale",true);
   descScaler.add<bool>("doSmear",true);
   descScaler.add<double>("scaleFactor", 1.0);
   descScaler.add<double>("smearFactor", 1.0);
   desc.addVPSet("params", descScaler, std::vector<edm::ParameterSet>(1));
 
   desc.addUntracked<bool>("fillDefaults",false);
   desc.addUntracked<bool>("saveMaps",true);
 
   descriptions.add("scaleAndSmearSiStripNoises", desc);
 
 }

std::unique_ptr< SiStripNoises > SiStripNoisesFromDBMiscalibrator::getNewObject ( const std::map< std::pair< uint32_t, int >, float > & theMap )

private

Definition at line 374 of file SiStripNoisesFromDBMiscalibrator.cc.

References GetRecoTauVFromDQM_MC_cff::obj.

Referenced by analyze().

 {
   std::unique_ptr<SiStripNoises> obj = std::unique_ptr<SiStripNoises>(new SiStripNoises());
   
   uint32_t PreviousDetId = 0; 
   SiStripNoises::InputVector theSiStripVector;
   for(const auto &element : theMap){
 
     uint32_t DetId = element.first.first;
     float noise    = element.second;
 
     if(DetId != PreviousDetId){    
       if(!theSiStripVector.empty()){
 
     if ( ! obj->put(PreviousDetId,theSiStripVector) ) {
       edm::LogError("SiStripNoisesFromDBMiscalibrator")<<"[SiStripNoisesFromDBMiscalibrator::analyze] detid already exists"<<std::endl;
     }
       }
       
       theSiStripVector.clear();
       PreviousDetId = DetId;
     }
     obj->setData(noise,theSiStripVector);
   }
   return obj;
 }

std::unique_ptr< SiStripNoises > SiStripNoisesFromDBMiscalibrator::getNewObject_withDefaults	(	const std::map< std::pair< uint32_t, int >, float > &	theMap,
		const float	theDefault
	)

private

Definition at line 310 of file SiStripNoisesFromDBMiscalibrator.cc.

References fp_, edm::FileInPath::fullPath(), LogDebug, missing_map, dataset::name, GetRecoTauVFromDQM_MC_cff::obj, checklumidiff::ofile, matplotRender::reader, and estimatePileup_makeJSON::trunc.

Referenced by analyze().

 {
   std::unique_ptr<SiStripNoises> obj = std::unique_ptr<SiStripNoises>(new SiStripNoises());
   
   SiStripDetInfoFileReader reader(fp_.fullPath());
   const std::map<uint32_t, SiStripDetInfoFileReader::DetInfo >& DetInfos  = reader.getAllData();
 
   std::vector<uint32_t> missingDetIds;
 
   for(std::map<uint32_t, SiStripDetInfoFileReader::DetInfo >::const_iterator it = DetInfos.begin(); it != DetInfos.end(); it++){    
     //Generate Noise for det detid
     bool isMissing(false);
     SiStripNoises::InputVector theSiStripVector;
     for(int t_strip=0;t_strip<128*it->second.nApvs; ++t_strip){
     
       std::pair<uint32_t,int> index = std::make_pair(it->first, t_strip) ;
     
       if ( theMap.find(index) == theMap.end() ) {
 
     LogDebug("SiStripNoisesFromDBMiscalibrator") << "detid " << it->first << " \t"
                              << " strip " << t_strip << " \t"
                              << " not found" << std::endl;      
     
     isMissing = true;
     obj->setData(theDefault,theSiStripVector);
 
       } else {
 
     float noise = theMap.at(index);
     obj->setData(noise,theSiStripVector);
 
       }
     }    
      
     if(isMissing) missingDetIds.push_back(it->first);
  
     if ( ! obj->put(it->first,theSiStripVector) ) {
       edm::LogError("SiStripNoisesFromDBMiscalibrator")<<"[SiStripNoisesFromDBMiscalibrator::analyze] detid already exists"<<std::endl;
     }
   }
 
   if(!missingDetIds.empty()){
     // open output file
     std::stringstream name; 
     name << "missing_modules.txt";
     std::ofstream* ofile = new std::ofstream(name.str(), std::ofstream::trunc); 
     if ( !ofile->is_open() ) throw "cannot open output file!"; 
     for(const auto &missing : missingDetIds){
       edm::LogVerbatim("SiStripNoisesFromDBMiscalibrator") << missing << "  " << 1 << std::endl;
       (*ofile) << missing << " " << 1 << std::endl; 
       missing_map->fill(missing,1);
     }
 
     ofile->close();
     delete ofile;
 
   }
 
   return obj;
 }