Class which reads a root file containing "commissioning histograms", analyzes the histograms to extract "monitorables", and creates summary histograms. More...

#include <SiStripCommissioningOfflineClient.h>

Inheritance diagram for SiStripCommissioningOfflineClient:

Public Types
typedef dqm::harvesting::DQMStore	DQMStore

typedef dqm::harvesting::MonitorElement	MonitorElement

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	endJob () override

	SiStripCommissioningOfflineClient (const edm::ParameterSet &)

	~SiStripCommissioningOfflineClient () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Types
typedef std::vector< TH1 * >	Histos

typedef std::map< uint32_t, Histos >	HistosMap

Protected Member Functions
virtual void	createHistos (const edm::ParameterSet &, const edm::EventSetup &)

virtual void	setInputFiles (std::vector< std::string > &, const std::string, const std::string, uint32_t, bool)

virtual void	uploadToConfigDb ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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)

Protected Attributes
bool	analyzeHistos_

DQMStore *	bei_

bool	clientHistos_

bool	collateHistos_

bool	createSummaryPlots_

CommissioningHistograms *	histos_

std::vector< std::string >	inputFiles_

HistosMap	map_

std::string	outputFileName_

edm::ParameterSet	parameters_

std::string	partitionName_

std::vector< SummaryPlot >	plots_

uint32_t	runNumber_

sistrip::RunType	runType_

bool	uploadToDb_

std::string	xmlFile_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Detailed Description

Class which reads a root file containing "commissioning histograms", analyzes the histograms to extract "monitorables", and creates summary histograms.

Author: M.Wingham, R.Bainbridge

Definition at line 29 of file SiStripCommissioningOfflineClient.h.

Member Typedef Documentation

typedef dqm::harvesting::DQMStore SiStripCommissioningOfflineClient::DQMStore

Definition at line 32 of file SiStripCommissioningOfflineClient.h.

typedef std::vector<TH1*> SiStripCommissioningOfflineClient::Histos

protected

Definition at line 87 of file SiStripCommissioningOfflineClient.h.

typedef std::map<uint32_t, Histos> SiStripCommissioningOfflineClient::HistosMap

protected

Definition at line 90 of file SiStripCommissioningOfflineClient.h.

typedef dqm::harvesting::MonitorElement SiStripCommissioningOfflineClient::MonitorElement

Definition at line 31 of file SiStripCommissioningOfflineClient.h.

Constructor & Destructor Documentation

SiStripCommissioningOfflineClient::SiStripCommissioningOfflineClient ( const edm::ParameterSet & pset )

Definition at line 36 of file SiStripCommissioningOfflineClient.cc.

References collateHistos_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputFiles_, LogTrace, sistrip::mlDqmClient_, setInputFiles(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : bei_(edm::Service<DQMStore>().operator->()),
       histos_(nullptr),
       //inputFiles_( pset.getUntrackedParameter< std::vector<std::string> >( "InputRootFiles", std::vector<std::string>() ) ),
       outputFileName_(pset.getUntrackedParameter<std::string>("OutputRootFile", "")),
       collateHistos_(!pset.getUntrackedParameter<bool>("UseClientFile", false)),
       analyzeHistos_(pset.getUntrackedParameter<bool>("AnalyzeHistos", true)),
       xmlFile_((pset.getUntrackedParameter<edm::FileInPath>("SummaryXmlFile", edm::FileInPath())).fullPath()),
       createSummaryPlots_(false),
       clientHistos_(false),
       uploadToDb_(false),
       runType_(sistrip::UNKNOWN_RUN_TYPE),
       runNumber_(0),
       partitionName_(pset.existsAs<std::string>("PartitionName") ? pset.getParameter<std::string>("PartitionName")
                                                                  : ""),
       map_(),
       plots_(),
       parameters_(pset) {
   LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                          << " Constructing object...";
   setInputFiles(inputFiles_,
                 pset.getUntrackedParameter<std::string>("FilePath"),
                 pset.existsAs<std::string>("PartitionName") ? pset.getParameter<std::string>("PartitionName") : "",
                 pset.getUntrackedParameter<uint32_t>("RunNumber"),
                 collateHistos_);
 }

SiStripCommissioningOfflineClient::~SiStripCommissioningOfflineClient ( )

override

Definition at line 65 of file SiStripCommissioningOfflineClient.cc.

References LogTrace, and sistrip::mlDqmClient_.

                                                                       {
   LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                          << " Destructing object...";
 }

Member Function Documentation

void SiStripCommissioningOfflineClient::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 341 of file SiStripCommissioningOfflineClient.cc.

References edm::EventID::event(), edm::EventBase::id(), LogTrace, and sistrip::mlDqmClient_.

                                                                                                  {
   if (!(event.id().event() % 10)) {
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Empty event loop! User can kill job...";
   }
 }

void SiStripCommissioningOfflineClient::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)

override

Definition at line 72 of file SiStripCommissioningOfflineClient.cc.

                                                                                               {
   LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                          << " Analyzing root file(s)...";
 
   // Check for null pointer
   if (!bei_) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " NULL pointer to DQMStore!"
                                 << " Aborting...";
     return;
   }
 
   // Check if .root file can be opened
   std::vector<std::string>::const_iterator ifile = inputFiles_.begin();
   for (; ifile != inputFiles_.end(); ifile++) {
     std::ifstream root_file;
     root_file.open(ifile->c_str());
     if (!root_file.is_open()) {
       edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                   << " The input root file \"" << *ifile << "\" could not be opened!"
                                   << " Please check the path and filename!";
     } else {
       root_file.close();
       std::string::size_type found = ifile->find(sistrip::dqmClientFileName_);
       if (found != std::string::npos && clientHistos_) {
         edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                     << " The input root files appear to be a mixture"
                                     << " of \"Source\" and \"Client\" files!"
                                     << " Aborting...";
         return;
       }
       if (found != std::string::npos && inputFiles_.size() != 1) {
         edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                     << " There appear to be multiple input \"Client\" root files!"
                                     << " Aborting...";
         return;
       }
       if (found != std::string::npos) {
         clientHistos_ = true;
       }
     }
   }
   if (clientHistos_ && inputFiles_.size() == 1) {
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Collated histograms found in input root file \"" << inputFiles_[0] << "\"";
   }
 
   // Check if .xml file can be opened
   if (!xmlFile_.empty()) {
     std::ifstream xml_file;
     xml_file.open(xmlFile_.c_str());
     if (!xml_file.is_open()) {
       edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                   << " The SummaryPlot XML file \"" << xmlFile_ << "\" could not be opened!"
                                   << " Please check the path and filename!"
                                   << " Aborting...";
       return;
     } else {
       createSummaryPlots_ = true;
       xml_file.close();
     }
   }
 
   // Open root file(s) and create ME's
   if (inputFiles_.empty()) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " No input root files specified!";
     return;
   }
 
   edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                  << " Opening root files. This may take some time!...";
   std::vector<std::string>::const_iterator jfile = inputFiles_.begin();
   for (; jfile != inputFiles_.end(); jfile++) {
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Opening root file \"" << *jfile << "\"... (This may take some time.)";
     if (clientHistos_) {
       bei_->open(*jfile, false, sistrip::collate_, "");
     } else {
       bei_->open(*jfile, false, "SiStrip", sistrip::collate_);
     }
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Opened root file \"" << *jfile << "\"!";
   }
   edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                  << " Opened " << inputFiles_.size() << " root files!";
 
   // Retrieve list of histograms
   std::vector<std::string> contents;
   bei_->getContents(contents);
 
   // If using client file, remove "source" histograms from list
   if (clientHistos_) {
     std::vector<std::string> temp;
     std::vector<std::string>::iterator istr = contents.begin();
     for (; istr != contents.end(); istr++) {
       if (istr->find(sistrip::collate_) != std::string::npos) {
         temp.push_back(*istr);
       }
     }
     contents.clear();
     contents = temp;
   }
 
   // Some debug
   LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                          << " Found " << contents.size() << " directories containing MonitorElements";
 
   // Some more debug
   if (false) {
     std::stringstream ss;
     ss << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
        << " Directories found: " << std::endl;
     std::vector<std::string>::iterator istr = contents.begin();
     for (; istr != contents.end(); istr++) {
       ss << " " << *istr << std::endl;
     }
     LogTrace(mlDqmClient_) << ss.str();
   }
 
   // Extract run type from contents
   runType_ = CommissioningHistograms::runType(bei_, contents);
 
   // Extract run number from contents
   runNumber_ = CommissioningHistograms::runNumber(bei_, contents);
 
   // Copy custom information to the collated structure
   CommissioningHistograms::copyCustomInformation(bei_, contents);
 
   // Check runType
   if (runType_ == sistrip::UNKNOWN_RUN_TYPE) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " Unknown commissioning runType: " << SiStripEnumsAndStrings::runType(runType_)
                                 << " and run number is " << runNumber_;
     return;
   } else {
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Run type is " << SiStripEnumsAndStrings::runType(runType_)
                                    << " and run number is " << runNumber_;
   }
 
   // Open and parse "summary plot" xml file
   if (createSummaryPlots_) {
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Parsing summary plot XML file...";
     SummaryPlotXmlParser xml_file;
     xml_file.parseXML(xmlFile_);
     plots_ = xml_file.summaryPlots(runType_);
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Parsed summary plot XML file and found " << plots_.size() << " plots defined!";
   } else {
     edm::LogWarning(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                   << " Null string for SummaryPlotXmlFile!"
                                   << " No summary plots will be created!";
   }
 
   // Some debug
   std::stringstream ss;
   ss << "[SiStripCommissioningOfflineClient::" << __func__ << "]" << std::endl << " Input root files      : ";
   if (inputFiles_.empty()) {
     ss << "(none)";
   } else {
     std::vector<std::string>::const_iterator ifile = inputFiles_.begin();
     for (; ifile != inputFiles_.end(); ifile++) {
       if (ifile != inputFiles_.begin()) {
         ss << std::setw(25) << std::setfill(' ') << ": ";
       }
       ss << "\"" << *ifile << "\"" << std::endl;
     }
   }
   ss << " Run type              : \"" << SiStripEnumsAndStrings::runType(runType_) << "\"" << std::endl
      << " Run number            :  " << runNumber_ << std::endl
      << " Summary plot XML file : ";
   if (xmlFile_.empty()) {
     ss << "(none)";
   } else {
     ss << "\"" << xmlFile_ << "\"";
   }
   edm::LogVerbatim(mlDqmClient_) << ss.str();
 
   // Virtual method that creates CommissioningHistogram object
   LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                          << " Creating CommissioningHistogram object...";
   createHistos(parameters_, setup);
   if (histos_) {
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Created CommissioningHistogram object!";
   } else {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " NULL pointer to CommissioningHistogram object!"
                                 << " Aborting...";
     return;
   }
 
   // Perform collation
   if (histos_) {
     histos_->extractHistograms(contents);
   }
 
   // Perform analysis
   if (analyzeHistos_) {
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Analyzing histograms...";
     if (histos_) {
       histos_->histoAnalysis(true);
     }
     LogTrace(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                            << " Analyzed histograms!";
   } else {
     edm::LogWarning(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                   << " No histogram analysis performed!";
   }
 
   // Create summary plots
   if (createSummaryPlots_) {
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Generating summary plots...";
     std::vector<SummaryPlot>::const_iterator iplot = plots_.begin();
     for (; iplot != plots_.end(); iplot++) {
       if (histos_) {
         histos_->createSummaryHisto(iplot->monitorable(), iplot->presentation(), iplot->level(), iplot->granularity());
       }
     }
     edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                    << " Generated summary plots!";
   } else {
     edm::LogWarning(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                   << " No summary plots generated!";
   }
 
   // Save client root file
   if (histos_) {
     bool save = parameters_.getUntrackedParameter<bool>("SaveClientFile", true);
     if (save) {
       if (runType_ != sistrip::CALIBRATION_SCAN and runType_ != sistrip::CALIBRATION_SCAN_DECO) {
         if (runType_ != sistrip::DAQ_SCOPE_MODE)
           histos_->save(outputFileName_, runNumber_);
         else
           histos_->save(outputFileName_, runNumber_, partitionName_);
       } else {
         CalibrationHistograms* histo = dynamic_cast<CalibrationHistograms*>(histos_);
         histo->save(outputFileName_, runNumber_);
       }
     } else {
       edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                      << " Client file not saved!";
     }
   }
 
   // Virtual method to trigger the database upload
   uploadToConfigDb();
 
   // Print analyses
   if (histos_) {
     histos_->printAnalyses();
     histos_->printSummary();
   }
 
   // Remove all ME/CME objects
   if (histos_) {
     histos_->remove();
   }
 
   edm::LogVerbatim(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                  << " Finished analyzing root file(s)...";
 }

void SiStripCommissioningOfflineClient::createHistos	(	const edm::ParameterSet &	pset,
		const edm::EventSetup &	setup
	)

protectedvirtual

Reimplemented in SiStripCommissioningOfflineDbClient.

Definition at line 354 of file SiStripCommissioningOfflineClient.cc.

References sistrip::APV_LATENCY, sistrip::APV_TIMING, bei_, sistrip::CALIBRATION, sistrip::CALIBRATION_DECO, sistrip::CALIBRATION_SCAN, sistrip::CALIBRATION_SCAN_DECO, CommissioningHistograms::configure(), sistrip::DAQ_SCOPE_MODE, sistrip::FAST_CABLING, sistrip::FED_CABLING, sistrip::FINE_DELAY, histos_, sistrip::mlDqmClient_, sistrip::NOISE, sistrip::OPTO_SCAN, sistrip::PEDESTALS, sistrip::PEDS_FULL_NOISE, sistrip::PEDS_ONLY, runType_, sistrip::UNDEFINED_RUN_TYPE, sistrip::UNKNOWN_RUN_TYPE, and sistrip::VPSP_SCAN.

Referenced by beginRun().

                                                                                                             {
   // Check pointer
   if (histos_) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " CommissioningHistogram object already exists!"
                                 << " Aborting...";
     return;
   }
 
   // Check pointer to BEI
   if (!bei_) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " NULL pointer to DQMStore!";
     return;
   }
 
   // Create "commissioning histograms" object
   if (runType_ == sistrip::FAST_CABLING) {
     histos_ = new FastFedCablingHistograms(pset, bei_);
   } else if (runType_ == sistrip::FED_CABLING) {
     histos_ = new FedCablingHistograms(pset, bei_);
   } else if (runType_ == sistrip::APV_TIMING) {
     histos_ = new ApvTimingHistograms(pset, bei_);
   } else if (runType_ == sistrip::OPTO_SCAN) {
     histos_ = new OptoScanHistograms(pset, bei_);
   } else if (runType_ == sistrip::VPSP_SCAN) {
     histos_ = new VpspScanHistograms(pset, bei_);
   } else if (runType_ == sistrip::PEDESTALS) {
     histos_ = new PedestalsHistograms(pset, bei_);
   } else if (runType_ == sistrip::PEDS_FULL_NOISE) {
     histos_ = new PedsFullNoiseHistograms(pset, bei_);
   } else if (runType_ == sistrip::PEDS_ONLY) {
     histos_ = new PedsOnlyHistograms(pset, bei_);
   } else if (runType_ == sistrip::NOISE) {
     histos_ = new NoiseHistograms(pset, bei_);
   } else if (runType_ == sistrip::APV_LATENCY || runType_ == sistrip::FINE_DELAY) {
     histos_ = new SamplingHistograms(pset, bei_, runType_);
   } else if (runType_ == sistrip::CALIBRATION || runType_ == sistrip::CALIBRATION_DECO ||
              runType_ == sistrip::CALIBRATION_SCAN || runType_ == sistrip::CALIBRATION_SCAN_DECO) {
     histos_ = new CalibrationHistograms(pset, bei_, runType_);
   } else if (runType_ == sistrip::DAQ_SCOPE_MODE) {
     histos_ = new DaqScopeModeHistograms(pset, bei_);
   } else if (runType_ == sistrip::UNDEFINED_RUN_TYPE) {
     histos_ = nullptr;
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " Undefined run type!";
     return;
   } else if (runType_ == sistrip::UNKNOWN_RUN_TYPE) {
     histos_ = nullptr;
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " Unknown run type!";
     return;
   }
   histos_->configure(pset, setup);
 }

void SiStripCommissioningOfflineClient::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 350 of file SiStripCommissioningOfflineClient.cc.

350 {}

void SiStripCommissioningOfflineClient::setInputFiles	(	std::vector< std::string > &	files,
		const std::string	path,
		const std::string	partitionName,
		uint32_t	run_number,
		bool	collate_histos
	)

protectedvirtual

Definition at line 412 of file SiStripCommissioningOfflineClient.cc.

References dqmPostProcessing_online::DIR, Calorimetry_cff::dp, mps_splice::entry, MillePedeFileConverter_cfg::fileName, compare_using_db::ifile, looper::jfile, LogTrace, sistrip::mlDqmClient_, castor_dqm_sourceclient_file_cfg::path, indexGen::rootFile, contentValuesCheck::run_number, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by SiStripCommissioningOfflineClient(), and uploadToConfigDb().

                                                                            {
   std::string runStr;
   std::stringstream ss;
   ss << std::setfill('0') << std::setw(8) << run_number;
   runStr = ss.str();
 
   std::string nameStr = "";
   if (!collate_histos) {
     nameStr = "SiStripCommissioningClient_";
   } else {
     nameStr = "SiStripCommissioningSource_";
   }
 
   LogTrace("TEST") << " runStr " << runStr;
 
   // Open directory
   DIR* dp;
   struct dirent* dirp;
   if ((dp = opendir(path.c_str())) == nullptr) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " Error locating directory \"" << path << "\". No such directory!";
     return;
   }
 
   // Find compatible files
   while ((dirp = readdir(dp)) != nullptr) {
     std::string fileName(dirp->d_name);
     bool goodName = (fileName.find(nameStr) != std::string::npos);
     bool goodRun = (fileName.find(runStr) != std::string::npos);
     bool rootFile = (fileName.find(".root") != std::string::npos);
     bool goodPartition = true;
     if (not partitionName.empty()) {
       goodPartition = (fileName.find(partitionName) != std::string::npos);
     }
 
     //bool rootFile = ( fileName.rfind(".root",5) == fileName.size()-5 );
     if (goodName && goodRun && rootFile && goodPartition) {
       std::string entry = path;
       entry += "/";
       entry += fileName;
       files.push_back(entry);
     }
   }
   closedir(dp);
 
   // Some debug
   if (!collate_histos && files.size() > 1) {
     std::stringstream ss;
     ss << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
        << " Found more than one client file!";
     std::vector<std::string>::const_iterator ifile = files.begin();
     std::vector<std::string>::const_iterator jfile = files.end();
     for (; ifile != jfile; ++ifile) {
       ss << std::endl << *ifile;
     }
     edm::LogError(mlDqmClient_) << ss.str();
   } else if (files.empty()) {
     edm::LogError(mlDqmClient_) << "[SiStripCommissioningOfflineClient::" << __func__ << "]"
                                 << " No input files found!";
   }
 }