dqi::HanOutput Class Reference

#include <HanOutput.h>

Inheritance diagram for dqi::HanOutput:

Collaboration diagram for dqi::HanOutput:

Classes
class	RegionNameComp
class	Result

Public Types
enum	Version { V1 = 1, V2 = 2 }
typedef std::map< std::string, TSeqCollection * >	DQOutputMap_t

Public Member Functions
	HanOutput (const std::string &rootFileName, DQOutputMap_t *outputMap, TSeqCollection *outputList)
virtual	~HanOutput ()
virtual void	addListener (const std::string &name, dqm_core::OutputListener *listener)
virtual void	addListener (const dqm_core::Parameter &parameter, dqm_core::OutputListener *listener)
virtual void	publishResult (const std::string &name, const dqm_core::Result &result)
virtual void	flushResults ()
virtual void	activate ()
virtual void	deactivate ()
virtual void	setConfig (HanConfig *config)
virtual void	publishMissingDQPars ()
virtual void	setInput (TDirectory *input)

Public Attributes
Version	HanOutput_FileVersion = V2

Protected Types
typedef std::map< std::string, dqm_core::Region * >	DQParMap_t
typedef std::multimap< dqm_core::Region *, std::string, RegionNameComp >	DQRegMap_t
typedef std::map< dqm_core::Region *, int, RegionNameComp >	DQRegCount_t
typedef std::map< std::string, dqm_core::Result * >	DQResultMap_t
typedef std::set< std::string >	DQParSet_t

Protected Attributes
std::string	m_fileName
std::unique_ptr< TFile >	m_file
bool	m_retainUnpubData
DQParSet_t	m_unpublishedDQPars
DQParMap_t	m_dqPars
DQRegMap_t	m_dqRegs
DQRegCount_t	m_dqRegCounts
DQResultMap_t	m_dqResults
DQOutputMap_t *	m_outputMap
TSeqCollection *	m_outputList
HanConfig *	m_config
DQParSet_t	m_regexlist
TDirectory *	m_input

Private Member Functions
	HanOutput ()

Detailed Description

Definition at line 38 of file HanOutput.h.

Member Typedef Documentation

DQOutputMap_t

typedef std::map<std::string, TSeqCollection*> dqi::HanOutput::DQOutputMap_t

Definition at line 45 of file HanOutput.h.

DQParMap_t

typedef std::map<std::string, dqm_core::Region*> dqi::HanOutput::DQParMap_t

protected

Definition at line 93 of file HanOutput.h.

DQParSet_t

typedef std::set<std::string> dqi::HanOutput::DQParSet_t

protected

Definition at line 97 of file HanOutput.h.

DQRegCount_t

typedef std::map<dqm_core::Region*, int, RegionNameComp> dqi::HanOutput::DQRegCount_t

protected

Definition at line 95 of file HanOutput.h.

DQRegMap_t

typedef std::multimap<dqm_core::Region*, std::string, RegionNameComp> dqi::HanOutput::DQRegMap_t

protected

Definition at line 94 of file HanOutput.h.

DQResultMap_t

typedef std::map<std::string, dqm_core::Result*> dqi::HanOutput::DQResultMap_t

protected

Definition at line 96 of file HanOutput.h.

Member Enumeration Documentation

Version

enum dqi::HanOutput::Version

Enumerator
V1
V2

Definition at line 41 of file HanOutput.h.

{ V1 = 1, V2 = 2 };

Constructor & Destructor Documentation

HanOutput() [1/2]

dqi::HanOutput::HanOutput	(	const std::string &	rootFileName,
		DQOutputMap_t *	outputMap,
		TSeqCollection *	outputList
	)

Definition at line 95 of file HanOutput.cxx.

    : m_fileName(rootFileName),
      m_file(TFile::Open(rootFileName.c_str(), "RECREATE")),
      m_retainUnpubData(false),
      m_config(0),
      m_input(0)
  {
    m_outputMap = outMap;
    m_outputList = outList;
    if (m_file.get() == 0)
    {
      std::cerr << "File not writable: " << rootFileName << "\n";
    }
  }

~HanOutput()

dqi::HanOutput::~HanOutput ( )

virtual

Definition at line 110 of file HanOutput.cxx.

  {
    DQResultMap_t::const_iterator rend = m_dqResults.end();
    for (DQResultMap_t::const_iterator i = m_dqResults.begin(); i != rend; ++i)
    {
      dqm_core::Result* result = i->second;
      delete result;
    }
    m_file->Close();
  }

HanOutput() [2/2]

dqi::HanOutput::HanOutput ( )

private

Definition at line 678 of file HanOutput.cxx.

: m_retainUnpubData(false), m_outputMap(0), m_outputList(0), m_config(0), m_input(0) {}

Member Function Documentation

activate()

void dqi::HanOutput::activate ( )

virtual

Definition at line 385 of file HanOutput.cxx.

{ gROOT->cd(); }

addListener() [1/2]

void dqi::HanOutput::addListener ( const dqm_core::Parameter &  parameter, dqm_core::OutputListener *  listener  )

virtual

Definition at line 148 of file HanOutput.cxx.

  {
    addListener(parameter.getName(), listener);
  }

addListener() [2/2]

void dqi::HanOutput::addListener ( const std::string &  name, dqm_core::OutputListener *  listener  )

virtual

Definition at line 121 of file HanOutput.cxx.

  {
    dqm_core::Region* region = dynamic_cast<dqm_core::Region*>(listener);
    if (region == 0) return;
 
    DQParMap_t::const_iterator i = m_dqPars.find(name);
    if (i != m_dqPars.end())
    {
      if (i->second != region)
      {
        std::cerr << "Attempt to add " << name << " twice; ignoring" << std::endl;
      }
      else
      {
        return;
      }
    }
 
    DQParMap_t::value_type dqParVal(name, region);
    m_dqPars.insert(dqParVal);
 
    DQRegMap_t::value_type dqRegVal(region, name);
    m_dqRegs.insert(dqRegVal);
 
    m_unpublishedDQPars.insert(name);
  }

deactivate()

void dqi::HanOutput::deactivate ( )

virtual

Definition at line 573 of file HanOutput.cxx.

  {
    flushResults();
    m_file->SetBit(TFile::kDevNull);
 
    WriteListToDirectory(
      m_file.get(), dynamic_cast<TSeqCollection*>(m_outputList->First()), m_file.get(), 4, HanOutput_FileVersion);
 
    if (HanOutput_FileVersion == 2)
    {
      m_file->cd("HanMetadata_");
      TDirectory* version_dir = gDirectory->mkdir("File");
      version_dir->cd();
      TDirectory* version_subdir = gDirectory->mkdir("Version_name");
      version_subdir->cd();
      TObjString file_version;
      file_version.Write("V.2.3");
    }
    m_file->Write();
    m_file->Flush();
  }

flushResults()

void dqi::HanOutput::flushResults ( )

virtual

Definition at line 177 of file HanOutput.cxx.

  {
    // store regex lists
    DQOutputMap_t tmpRegex;
    DQParSet_t::const_iterator regexEnd = m_regexlist.end();
    for (DQParSet_t::const_iterator regex = m_regexlist.begin(); regex != regexEnd; ++regex)
    {
      TSeqCollection* resultList = (*m_outputMap)[*regex];
      if (resultList == 0)
      {
        std::cerr << "Can't find original list for regex???" << std::endl;
      }
      else
      {
        tmpRegex.insert(DQOutputMap_t::value_type(*regex, resultList));
        (*m_outputMap).erase(*regex);
        DQParMap_t::const_iterator i = m_dqPars.find(*regex);
        if (i != m_dqPars.end())
        {
          dqm_core::Region* parent = i->second;
 
          std::string parentName = parent->getName();
          // just remove, don't delete
          dynamic_cast<TSeqCollection*>((*m_outputMap)[parentName])->Remove(resultList);
        }
      }
    }
 
    // replay results
    DQResultMap_t::const_iterator rEnd = m_dqResults.end();
    for (DQResultMap_t::const_iterator r = m_dqResults.begin(); r != rEnd; ++r)
    {
      const std::string name(r->first);
      const dqm_core::Result& result(*(r->second));
 
      std::string parentName("top_level");
      DQParMap_t::const_iterator i = m_dqPars.find(name);
 
      if (i != m_dqPars.end())
      {
        dqm_core::Region* parent = i->second;
        parentName = parent->getName();
      }
      // copy-paste ENDS here
 
      TSeqCollection* resultList = (*m_outputMap)[name];
      std::string parname(name);
      std::string storename(name);
 
      if (resultList == NULL)
      {
        // is regex?
        bool isRegex = false;
        std::string extra;
        for (DQParSet_t::const_iterator regex = m_regexlist.begin(); regex != regexEnd; ++regex)
        {
          std::string::size_type regexlen = regex->length();
          if (*regex + "_" == name.substr(0, regexlen + 1))
          {
            isRegex = true;
            parname = *regex;
            std::string::size_type atsign = regex->rfind('@');
            if (atsign != std::string::npos)
            {
              extra = regex->substr(atsign, std::string::npos);
            }
            storename = name.substr(regexlen + 1, std::string::npos);
            break;
          }
        }
        if (isRegex)
        {
          if (m_input == NULL)
          {
            std::cerr << "WARNING: setInput() has not been set; cannot publish regex results" << std::endl;
            continue;
          }
          resultList = dynamic_cast<TSeqCollection*>(tmpRegex[parname]->Clone());
          (*m_outputMap)[storename + extra] = resultList;
          DQParMap_t::const_iterator i = m_dqPars.find(parname);
          parentName = i->second->getName();
          bool use_full_name = false;
          if (m_config)
          {
            std::unique_ptr<const HanConfigAssessor> a(m_config->GetAssessor(parentName, parname));
            if (a.get())
            {
              std::string store_using_path;
              const HanConfigParMap* hcpm = a->GetAnnotation("store_using_path");
              if (hcpm)
              {
                store_using_path.assign(hcpm->GetValue());
              }
              boost::algorithm::to_lower(store_using_path);
              if (store_using_path == "1" || store_using_path == "yes" || store_using_path == "true")
              {
                use_full_name = true;
              }
            }
          }
          if (use_full_name)
          {
            resultList->SetName((boost::algorithm::replace_all_copy(storename, "/", "_") + extra + "_").c_str());
          }
          else
          {
            resultList->SetName((storename + extra + "_").c_str());
          }
          dynamic_cast<TSeqCollection*>((*m_outputMap)[parentName])->Add(resultList);
          TKey* key = getObjKey(m_input, storename);
          if (key != 0)
          {
            const char* className = key->GetClassName();
            if ((strncmp(className, "TH", 2) == 0) || (strncmp(className, "TGraph", 6) == 0) ||
                (strncmp(className, "TProfile", 8) == 0) || (strncmp(className, "TEfficiency", 11) == 0))
            {
              TNamed* transobj = dynamic_cast<TNamed*>(key->ReadObj());
              if (transobj != NULL)
              {
                HanHistogramLink* hhl = new HanHistogramLink(m_input, storename);
                if (use_full_name)
                {
                  hhl->SetName((boost::algorithm::replace_all_copy(storename, "/", "_") + extra).c_str());
                }
                else
                {
                  hhl->SetName((std::string(transobj->GetName()) + extra).c_str());
                }
                // transobj->SetName((std::string(transobj->GetName()) + extra).c_str());
                // resultList->Add(transobj);
                resultList->Add(hhl);
              }
              else
              {
                std::cerr << "TNamed* cast failed for " << storename << std::endl;
              }
            }
          }
          else
          {
            std::cout << "key is NULL" << std::endl;
          }
        }
        else
        {
          std::cerr << "WARNING: Unable to find mapping for " << name << std::endl;
          continue;
        }
      }
 
      
      if (resultList)//ensure resultList is not null before dereference
      {
        resultList = dynamic_cast<TSeqCollection*>(resultList->FindObject("Results"));
      }
      //check dynamic cast
      if (resultList == nullptr)
      {
        std::cerr << "Warning: no result list found associated with '" << name << "'\n";
        continue;
      }
 
      
      resultList->Add(newTObjArray("Status", new TObjString(StatusToStr(result.status_).c_str()), 1));
 
      // iterate through the tags
      std::map<std::string, double>::const_iterator iter = result.tags_.begin();
      for (; iter != result.tags_.end(); ++iter)
      {
        std::ostringstream tagval;
        tagval << std::setprecision(4) << iter->second;
        resultList->Add(newTObjArray(iter->first.c_str(), new TObjString(tagval.str().c_str()), 1));
      }
 
      // if there's an output object from the algorithm, include a clone
      TObject* resultobj = result.getObject();
      if (resultobj != 0)
      {
        TObject* resultobjclone = resultobj->Clone();
        if (setNameGeneral(resultobj, "ResultObject"))
        {
          resultList->Add(resultobjclone);
        }
        else
        {
          std::cerr << "Discarding result object " << result.getObject()->GetName() << std::endl;
          delete resultobjclone;
        }
      }
 
      if (m_config != 0)
      {
        TObject* ref = m_config->GetReference(parentName, parname);
        if (ref)
        {
          if (setNameGeneral(ref, "Reference"))
          {
            resultList->Add(ref);
          }
          else
          {
            std::cerr << "Discarding reference object " << ref->GetName() << std::endl;
          }
        }
      }
    }
  }

publishMissingDQPars()

void dqi::HanOutput::publishMissingDQPars ( )

virtual

Definition at line 601 of file HanOutput.cxx.

  {
    m_retainUnpubData = true;
 
    DQRegMap_t::const_iterator dqRegIter = m_dqRegs.begin();
    DQRegMap_t::const_iterator dqRegEnd = m_dqRegs.end();
    for (; dqRegIter != dqRegEnd; ++dqRegIter)
    {
      std::string regname = dqRegIter->first->getName();
      m_unpublishedDQPars.erase(regname);
    }
 
    DQParSet_t::const_iterator regexItr = m_regexlist.begin();
    DQParSet_t::const_iterator regexEnd = m_regexlist.end();
    for (; regexItr != regexEnd; ++regexItr)
    {
      m_unpublishedDQPars.erase(*regexItr);
    }
 
    dqm_core::Result::Status status(dqm_core::Result::Undefined);
    dqm_core::Result result(status);
 
    DQParSet_t::const_iterator unpubIter = m_unpublishedDQPars.begin();
    DQParSet_t::const_iterator unpubEnd = m_unpublishedDQPars.end();
    for (; unpubIter != unpubEnd; ++unpubIter)
    {
      const std::string& name = *unpubIter;
      // reduce verbosity
      // std::cout << "--> Publishing missing object: \"" << name << "\"\n";
      publishResult(name, result);
    }
 
    m_retainUnpubData = false;
  }

publishResult()

void dqi::HanOutput::publishResult ( const std::string &  name, const dqm_core::Result &  result  )

virtual

Definition at line 153 of file HanOutput.cxx.

  {
    //  std::cout << "Publish " << name << std::endl;
    delete m_dqResults[name];
    m_dqResults[name] = result.clone();
 
    DQParSet_t::iterator dqpari = m_unpublishedDQPars.find(name);
    if (dqpari != m_unpublishedDQPars.end() && !m_retainUnpubData)
    {
      m_unpublishedDQPars.erase(dqpari);
    }
 
    if (m_retainUnpubData)
    {
      DQParMap_t::const_iterator i = m_dqPars.find(name);
      if (i != m_dqPars.end())
      {
        dqm_core::Region* parent = i->second;
        dqm_core::OutputListener* plistener = parent;
        plistener->handleResult(name, result);
      }
    }
  }

setConfig()

void dqi::HanOutput::setConfig ( HanConfig *  config )

virtual

Definition at line 595 of file HanOutput.cxx.

  {
    m_config = config;
    config->GetRegexList(m_regexlist);
  }

setInput()

void dqi::HanOutput::setInput ( TDirectory *  input )

virtual

Definition at line 387 of file HanOutput.cxx.

{ m_input = input; }

Member Data Documentation

HanOutput_FileVersion

Version dqi::HanOutput::HanOutput_FileVersion = V2

Definition at line 43 of file HanOutput.h.

m_config

HanConfig* dqi::HanOutput::m_config

protected

Definition at line 111 of file HanOutput.h.

m_dqPars

DQParMap_t dqi::HanOutput::m_dqPars

protected

Definition at line 104 of file HanOutput.h.

m_dqRegCounts

DQRegCount_t dqi::HanOutput::m_dqRegCounts

protected

Definition at line 106 of file HanOutput.h.

m_dqRegs

DQRegMap_t dqi::HanOutput::m_dqRegs

protected

Definition at line 105 of file HanOutput.h.

m_dqResults

DQResultMap_t dqi::HanOutput::m_dqResults

protected

Definition at line 107 of file HanOutput.h.

m_file

std::unique_ptr<TFile> dqi::HanOutput::m_file

protected

Definition at line 100 of file HanOutput.h.

m_fileName

std::string dqi::HanOutput::m_fileName

protected

Definition at line 99 of file HanOutput.h.

m_input

TDirectory* dqi::HanOutput::m_input

protected

Definition at line 113 of file HanOutput.h.

m_outputList

TSeqCollection* dqi::HanOutput::m_outputList

protected

Definition at line 110 of file HanOutput.h.

m_outputMap

DQOutputMap_t* dqi::HanOutput::m_outputMap

protected

Definition at line 108 of file HanOutput.h.

m_regexlist

DQParSet_t dqi::HanOutput::m_regexlist

protected

Definition at line 112 of file HanOutput.h.

m_retainUnpubData

bool dqi::HanOutput::m_retainUnpubData

protected

Definition at line 101 of file HanOutput.h.

m_unpublishedDQPars

DQParSet_t dqi::HanOutput::m_unpublishedDQPars

protected

Definition at line 103 of file HanOutput.h.

---

The documentation for this class was generated from the following files:

• HanOutput.h
• HanOutput.cxx