DQMFileLoader.cc

Go to the documentation of this file.

#include "Validation/RecoTau/plugins/DQMFileLoader.h"

#include "Validation/RecoTau/plugins/dqmAuxFunctions.h"

// framework & common header files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

//DQM services
#include "DQMServices/Core/interface/DQMStore.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "DQMServices/Core/interface/MonitorElement.h"

#include <TFile.h>
#include <TList.h>
#include <TKey.h>
#include <TH1.h>

#include <iostream>

const std::string dqmRootDirectory_inTFile = "DQMData";

const double defaultScaleFactor = 1.;

const int verbosity = 0;

void mapSubDirectoryStructure(TDirectory* directory, std::string directoryName, std::set<std::string>& subDirectories)
{
  //std::cout << "<mapSubDirectoryStructure>:" << std::endl;
  //std::cout << " directoryName = " << directoryName << std::endl;

  TList* subDirectoryNames = directory->GetListOfKeys();
  if ( !subDirectoryNames ) return;

  TIter next(subDirectoryNames);
  while ( TKey* key = dynamic_cast<TKey*>(next()) ) {
    //std::cout << " key->GetName = " << key->GetName() << std::endl;
    TObject* obj = directory->Get(key->GetName());
    //std::cout << " obj = " << obj << std::endl;
    if ( TDirectory* subDirectory = dynamic_cast<TDirectory*>(obj) ) {
      std::string subDirectoryName = dqmDirectoryName(directoryName).append(key->GetName());
      //std::cout << " subDirectoryName = " << subDirectoryName << std::endl;
    
      subDirectories.insert(subDirectoryName);
    
      mapSubDirectoryStructure(subDirectory, subDirectoryName, subDirectories); 
    }
  }
} 

//
//-----------------------------------------------------------------------------------------------------------------------
//

TauDQMFileLoader::cfgEntryFileSet::cfgEntryFileSet(const std::string& name, const edm::ParameterSet& cfg)
{
  //std::cout << "<TauDQMFileLoader::cfgEntryFileSet>" << std::endl;

  name_ = name;

  vstring inputFileList = cfg.getParameter<vstring>("inputFileNames");
  for ( vstring::const_iterator inputFile = inputFileList.begin();
    inputFile != inputFileList.end(); ++inputFile ) {
    if ( inputFile->find(rangeKeyword) != std::string::npos ) {
      size_t posRangeStart = inputFile->find(rangeKeyword) + rangeKeyword.length();
      size_t posRangeEnd = inputFile->find('#', posRangeStart); 
      
      size_t posRangeSeparator = inputFile->find('-', posRangeStart);

      if ( (posRangeEnd == std::string::npos) || 
       (posRangeSeparator >= posRangeEnd) ) { 
    edm::LogError ("TauDQMFileLoader::cfgEntryFileSet") << " Invalid range specification in inputFile = " << (*inputFile) << " !!";
    continue;
      }

      std::string firstFile = std::string(*inputFile, posRangeStart, posRangeSeparator - posRangeStart);
      //std::cout << "firstFile = " << firstFile << std::endl;
      std::string lastFile = std::string(*inputFile, posRangeSeparator + 1, posRangeEnd - (posRangeSeparator + 1));
      //std::cout << "lastFile = " << lastFile << std::endl;

      if ( firstFile.length() != lastFile.length() ) {
    edm::LogError ("TauDQMFileLoader::cfgEntryFileSet") << " Invalid range specification in inputFile = " << (*inputFile) << " !!";
    continue;
      }

      int numFirstFile = atoi(firstFile.data());
      int numLastFile = atoi(lastFile.data());
      for ( int iFile = numFirstFile; iFile <= numLastFile; ++iFile ) {
    std::ostringstream fileName;
    fileName << std::string(*inputFile, 0, inputFile->find(rangeKeyword));
    fileName << std::setfill('0') << std::setw(firstFile.length()) << iFile;
    fileName << std::string(*inputFile, posRangeEnd + 1);
    //std::cout << "iFile = " << iFile << ", fileName = " << fileName.str() << std::endl;
    inputFileNames_.push_back(fileName.str());
      }
    } else {
      inputFileNames_.push_back(*inputFile);
    }
  }

  scaleFactor_ = ( cfg.exists("scaleFactor") ) ? cfg.getParameter<double>("scaleFactor") : defaultScaleFactor;

  //dqmDirectory_store_ = ( cfg.exists("dqmDirectory_store") ) ? cfg.getParameter<std::string>("dqmDirectory_store") : name_;
  dqmDirectory_store_ = ( cfg.exists("dqmDirectory_store") ) ? cfg.getParameter<std::string>("dqmDirectory_store") : "";

  if ( verbosity ) print();
}

void TauDQMFileLoader::cfgEntryFileSet::print() const
{
  std::cout << "<cfgEntryFileSet::print>:" << std::endl;
  std::cout << " name = " << name_ << std::endl;
  std::cout << " inputFileNames = " << format_vstring(inputFileNames_) << std::endl;
  std::cout << " scaleFactor = " << scaleFactor_ << std::endl;
  std::cout << " dqmDirectory_store = " << dqmDirectory_store_ << std::endl;
}

//
//-----------------------------------------------------------------------------------------------------------------------
//

TauDQMFileLoader::TauDQMFileLoader(const edm::ParameterSet& cfg)
{
  std::cout << "<TauDQMFileLoader::TauDQMFileLoader>:" << std::endl;

  cfgError_ = 0;

//--- configure fileSets  
  //std::cout << "--> configuring fileSets..." << std::endl;
  readCfgParameter<cfgEntryFileSet>(cfg, fileSets_);
  
//--- check that dqmDirectory_store configuration parameters are specified for all fileSets,
//    unless there is only one fileSet to be loaded
//    (otherwise histograms of different fileSets get overwritten,
//     once histograms of the next fileSet are loaded)
  for ( std::map<std::string, cfgEntryFileSet>::const_iterator fileSet = fileSets_.begin();
    fileSet != fileSets_.end(); ++fileSet ) {
    if ( fileSet->second.dqmDirectory_store_ == "" && fileSets_.size() > 1 ) {
      edm::LogError ("TauDQMFileLoader") << " dqmDirectory_store undefined for fileSet = " << fileSet->second.name_ << " !!";
      cfgError_ = 1;
      break;
    }
  }

  std::cout << "done." << std::endl;
}

TauDQMFileLoader::~TauDQMFileLoader() 
{
// nothing to be done yet...
}

void TauDQMFileLoader::analyze(const edm::Event&, const edm::EventSetup&)
{
// nothing to be done yet...
}

void TauDQMFileLoader::endRun(const edm::Run& r, const edm::EventSetup& c)
{
  std::cout << "<TauDQMFileLoader::endJob>:" << std::endl;

//--- check that configuration parameters contain no errors
  if ( cfgError_ ) {
    edm::LogError ("endJob") << " Error in Configuration ParameterSet" 
                 << " --> histograms will NOT be loaded !!";
    return;
  }

//--- check that DQMStore service is available
  if ( !edm::Service<DQMStore>().isAvailable() ) {
    edm::LogError ("endJob") << " Failed to access dqmStore" 
                 << " --> histograms will NOT be loaded !!";
    return;
  }

//--- stop ROOT from keeping references to all histograms
  //TH1::AddDirectory(false);

//--- check that inputFiles exist;
//    store list of directories existing in inputFile,
//    in order to separate histogram directories existing in the inputFile from directories existing in DQMStore
//    when calling recursive function dqmCopyRecursively
  for ( std::map<std::string, cfgEntryFileSet>::const_iterator fileSet = fileSets_.begin();
    fileSet != fileSets_.end(); ++fileSet ) {
    for ( vstring::const_iterator inputFileName = fileSet->second.inputFileNames_.begin();
      inputFileName != fileSet->second.inputFileNames_.end(); ++inputFileName ) {
      //std::cout << " checking inputFile = " << (*inputFileName) << std::endl;
      TFile inputFile(inputFileName->data());
      if ( inputFile.IsZombie() ) {
    edm::LogError ("endJob") << " Failed to open inputFile = " << (*inputFileName) 
                 << "--> histograms will NOT be loaded !!";
    return;
      }
 
      TObject* obj = inputFile.Get(dqmRootDirectory_inTFile.data());
      //std::cout << " obj = " << obj << std::endl;
      if ( TDirectory* directory = dynamic_cast<TDirectory*>(obj) ) {
    mapSubDirectoryStructure(directory, dqmRootDirectory, subDirectoryMap_[*inputFileName]);
      } else {
    edm::LogError ("endJob") << " Failed to access " << dqmRootDirectory_inTFile << " in inputFile = " << (*inputFileName) 
                 << "--> histograms will NOT be loaded !!";
    return;
      }

      inputFile.Close();
    }
  }
  
  //for ( std::map<std::string, sstring>::const_iterator inputFile = subDirectoryMap_.begin();
  //      inputFile != subDirectoryMap_.end(); ++inputFile ) {
  //  std::cout << "inputFile = " << inputFile->first << ":" << std::endl;
  //  for ( sstring::const_iterator directory = inputFile->second.begin();
  //        directory != inputFile->second.end(); ++directory ) {
  //    std::cout << " " << (*directory) << std::endl;
  //  }
  //}

//--- load histograms from file
  //std::cout << "--> loading histograms from file..." << std::endl;
  DQMStore& dqmStore = (*edm::Service<DQMStore>());
  for ( std::map<std::string, cfgEntryFileSet>::const_iterator fileSet = fileSets_.begin();
    fileSet != fileSets_.end(); ++fileSet ) {
    for ( vstring::const_iterator inputFileName = fileSet->second.inputFileNames_.begin();
      inputFileName != fileSet->second.inputFileNames_.end(); ++inputFileName ) {
      if ( verbosity ) std::cout << " opening inputFile = " << (*inputFileName) << std::endl;
      dqmStore.open(*inputFileName, true);

      //if ( verbosity ) dqmStore.showDirStructure();
      
//--- if dqmDirectory_store specified in configuration parameters,
//    move histograms from dqmRootDirectory to dqmDirectory_store
//    (if the histograms are not moved, the histograms get overwritten,
//     the next time DQMStore::open is called)
      if ( fileSet->second.dqmDirectory_store_ != "" ) {
    std::string inputDirectory = dqmRootDirectory;
    //std::cout << "inputDirectory = " << inputDirectory << std::endl;
    std::string outputDirectory = dqmDirectoryName(std::string(inputDirectory)).append(fileSet->second.dqmDirectory_store_);
    //std::cout << "outputDirectory = " << outputDirectory << std::endl;

    dqmStore.setCurrentFolder(inputDirectory);
    std::vector<std::string> dirNames = dqmStore.getSubdirs();
    for ( std::vector<std::string>::const_iterator dirName = dirNames.begin();
          dirName != dirNames.end(); ++dirName ) {
      std::string subDirName = dqmSubDirectoryName_merged(inputDirectory, *dirName);
      //std::cout << " subDirName = " << subDirName << std::endl;
      
      const sstring& subDirectories = subDirectoryMap_[*inputFileName];
      if ( subDirectories.find(subDirName) != subDirectories.end() ) {
        std::string inputDirName_full = dqmDirectoryName(inputDirectory).append(subDirName);
        //std::cout << " inputDirName_full = " << inputDirName_full << std::endl;
        
        std::string outputDirName_full = dqmDirectoryName(outputDirectory).append(subDirName);
        //std::cout << " outputDirName_full = " << outputDirName_full << std::endl;

//--- load histograms contained in inputFile into inputDirectory;
//    when processing first inputFile, check that histograms in outputDirectory do not yet exist;
//    add histograms in inputFile to those in outputDirectory afterwards;
//    clear inputDirectory once finished processing all inputFiles.
        int mode = ( inputFileName == fileSet->second.inputFileNames_.begin() ) ? 1 : 3;
        dqmCopyRecursively(dqmStore, inputDirName_full, outputDirName_full, fileSet->second.scaleFactor_, mode, true);
      }
    }
      }
    }
  }

  std::cout << "done." << std::endl; 
  if ( verbosity ) dqmStore.showDirStructure();
}

#include "FWCore/Framework/interface/MakerMacros.h"

DEFINE_FWK_MODULE(TauDQMFileLoader);