dqi::CompositeAlgorithm Class Reference

#include <CompositeAlgorithm.h>

Inheritance diagram for dqi::CompositeAlgorithm:

Collaboration diagram for dqi::CompositeAlgorithm:

Public Member Functions
	CompositeAlgorithm (const CompositeAlgorithm &other)
	CompositeAlgorithm (HanConfigCompAlg &compAlg)
virtual	~CompositeAlgorithm ()
virtual dqm_core::Algorithm *	clone ()
virtual dqm_core::Result *	execute (const std::string &name, const TObject &data, const dqm_core::AlgorithmConfig &config)
virtual void	printDescription ()

Protected Types
typedef std::vector< std::pair< dqm_core::Algorithm *, std::string > >	AlgVec_t

Protected Member Functions
HanAlgorithmConfig *	ConfigureSubAlg (const dqm_core::AlgorithmConfig &config, const std::string &subalg)

Protected Attributes
std::string	m_name
AlgVec_t	m_subAlgs

Detailed Description

Definition at line 18 of file CompositeAlgorithm.h.

Member Typedef Documentation

AlgVec_t

typedef std::vector<std::pair<dqm_core::Algorithm*, std::string> > dqi::CompositeAlgorithm::AlgVec_t

protected

Definition at line 33 of file CompositeAlgorithm.h.

Constructor & Destructor Documentation

CompositeAlgorithm() [1/2]

dqi::CompositeAlgorithm::CompositeAlgorithm

(

const CompositeAlgorithm &

other

)

Definition at line 25 of file CompositeAlgorithm.cxx.

  : Algorithm(other)
  , m_name(other.m_name)
{
  AlgVec_t::const_iterator subAlgsEnd = other.m_subAlgs.end();
  AlgVec_t::const_iterator subAlgsIter = other.m_subAlgs.begin();
  for( ; subAlgsIter != subAlgsEnd; ++subAlgsIter ) {
    dqm_core::Algorithm* otherSubAlg = subAlgsIter->first;    
    dqm_core::Algorithm* alg = otherSubAlg->clone();
    m_subAlgs.push_back( AlgVec_t::value_type(alg, subAlgsIter->second) );
  }
}

CompositeAlgorithm() [2/2]

dqi::CompositeAlgorithm::CompositeAlgorithm

(

HanConfigCompAlg &

compAlg

)

Definition at line 40 of file CompositeAlgorithm.cxx.

  : m_name (compAlgConfig.GetName())
{
  TObjString* libStr;
  TIter libIter( compAlgConfig.GetAllLib() );
  while( (libStr = dynamic_cast<TObjString*>( libIter() )) != 0 ){
    try {
      dqm_core::LibraryManager::instance().loadLibrary( libStr->GetString().Data() );
    } 
    catch ( dqm_core::Exception& ex ) {
      std::cout << "Can't load library " << libStr->GetString()
        << " for composite algorithm " << m_name 
        << ". Continuing regardless ..." << std::endl;
    }
  }
  
  TObjString* algStr;
  TIter algIter( compAlgConfig.GetAllAlg() );
  while( (algStr = dynamic_cast<TObjString*>( algIter() )) != 0 ){
    dqm_core::Algorithm* alg(0);
    std::string algName(algStr->GetString().Data());
    try {
        alg = dqm_core::AlgorithmManager::instance().getAlgorithm( algName );
    }
    catch( dqm_core::Exception& ex ) {
        throw dqm_core::BadConfig( ERS_HERE, m_name, ex.what(), ex );
    }
    m_subAlgs.push_back( AlgVec_t::value_type(alg, algName) );
  }
  dqm_core::AlgorithmManager::instance().registerAlgorithm( m_name, this );
}

~CompositeAlgorithm()

dqi::CompositeAlgorithm::~CompositeAlgorithm ( )

virtual

Definition at line 74 of file CompositeAlgorithm.cxx.

{
  AlgVec_t::const_iterator subAlgsEnd = m_subAlgs.end();
  AlgVec_t::const_iterator subAlgsIter = m_subAlgs.begin();
  for( ; subAlgsIter != subAlgsEnd; ++subAlgsIter ) {
    dqm_core::Algorithm* alg = subAlgsIter->first;
    delete alg;
  }
  m_subAlgs.clear();
}

Member Function Documentation

clone()

dqm_core::Algorithm * dqi::CompositeAlgorithm::clone ( )

virtual

Definition at line 88 of file CompositeAlgorithm.cxx.

{
  dqi::CompositeAlgorithm* result = new CompositeAlgorithm(*this);
  return result;
}

ConfigureSubAlg()

HanAlgorithmConfig * dqi::CompositeAlgorithm::ConfigureSubAlg ( const dqm_core::AlgorithmConfig & config, const std::string & subalg )

protected

Definition at line 145 of file CompositeAlgorithm.cxx.

{
// caller owns the returned object
 
// what we do: copy reference, params, limits to newly created config
// copy all those WITHOUT a / (backwards compatibility) and those of the form
// subalg/xxx.
 
  TObject* ref(0);
  try {
    ref = config.getReference();
  } catch (dqm_core::BadConfig &) { /* ignore */ }
  std::map< std::string,double >  pars;
  std::map<std::string,std::string> strPars;
  std::map<std::string,double> grthr;
  std::map<std::string,double> rdthr;
 
  std::map< std::string, double > oldpars(config.getParameters());
  std::map<std::string,double> oldgrthr(config.getGreenThresholds());
  std::map<std::string,double> oldrdthr(config.getRedThresholds());
 
  for (std::map< std::string, double >::const_iterator parVal = oldpars.begin();
    parVal != oldpars.end(); ++parVal) {
      std::string parname(parVal->first);
      std::string::size_type pos = parname.find('|');
      if (pos == std::string::npos) {
    pars.insert(*parVal);
      } else if (parname.substr(0, pos) == subalg) {
    pars.insert(std::map< std::string, double >::value_type(parname.substr(pos+1), parVal->second));
      }
  }
  for ( auto& strPar : config.getGenericParameters() ) {
    std::string parname = strPar.first;
    auto pipeIndex = parname.find( '|' );
    if ( pipeIndex == std::string::npos ) {
      strPars.insert( strPar );
    } else if ( parname.substr( 0, pipeIndex ) == subalg ) {
      strPars.emplace( parname.substr( pipeIndex + 1 ), strPar.second );
    }
  }
  for (std::map< std::string, double >::const_iterator thrVal = oldgrthr.begin();
       thrVal != oldgrthr.end(); ++thrVal) {
    std::string thrname(thrVal->first);
    std::string::size_type pos = thrname.find('|');
    if (pos == std::string::npos) {
      grthr.insert(*thrVal);
    } else if (thrname.substr(0, pos) == subalg) {
      grthr.insert(std::map< std::string, double >::value_type(thrname.substr(pos+1), thrVal->second));
    }
  }
  for (std::map< std::string, double >::const_iterator thrVal = oldrdthr.begin();
       thrVal != oldrdthr.end(); ++thrVal) {
    std::string thrname(thrVal->first);
    std::string::size_type pos = thrname.find('|');
    if (pos == std::string::npos) {
      rdthr.insert(*thrVal);
    } else if (thrname.substr(0, pos) == subalg) {
    rdthr.insert(std::map< std::string, double >::value_type(thrname.substr(pos+1), thrVal->second));
      }
  }
  return new HanAlgorithmConfig(ref, pars, strPars, grthr, rdthr, 0);
}

execute()

dqm_core::Result * dqi::CompositeAlgorithm::execute ( const std::string & name, const TObject & data, const dqm_core::AlgorithmConfig & config )

virtual

Definition at line 111 of file CompositeAlgorithm.cxx.

{
  dqm_core::Result::Status status(dqm_core::Result::Undefined);
  std::map<std::string,double> tags;
  
  AlgVec_t::const_iterator subAlgsEnd = m_subAlgs.end();
  AlgVec_t::const_iterator subAlgsIter = m_subAlgs.begin();
  for( ; subAlgsIter != subAlgsEnd; ++subAlgsIter ) {
    std::unique_ptr<HanAlgorithmConfig> subConfig(ConfigureSubAlg(config, subAlgsIter->second));
 
    dqm_core::Algorithm* alg = subAlgsIter->first;
    dqm_core::Result* subResult = alg->execute( name, data, *subConfig );
    if( subResult->status_ != dqm_core::Result::Undefined ) {
      status = ( status == dqm_core::Result::Undefined ) ? dqm_core::Result::Green : status;
      status = ( subResult->status_ < status ) ? subResult->status_ : status;
    }
    
    std::map<std::string,double>::const_iterator tagsEnd  = subResult->tags_.end();
    std::map<std::string,double>::const_iterator tagsIter = subResult->tags_.begin();
    for( ; tagsIter != tagsEnd; ++tagsIter ) {
      std::map<std::string,double>::value_type tagVal( subAlgsIter->second + std::string("|") + tagsIter->first, tagsIter->second );
      tags.insert( std::move(tagVal) );
    }
    delete subResult;
  }
  
  dqm_core::Result* result = new dqm_core::Result( status );
  result->tags_ = std::move(tags);
  
  return result;
}

printDescription()

void dqi::CompositeAlgorithm::printDescription ( )

virtual

Definition at line 97 of file CompositeAlgorithm.cxx.

{
  std::string message;
  message += "\n";
  message += "Algorithm: \"" + m_name + "\"\n";
  message += "Description: Builds a container for subalgorithms.\n";
  message += "Parameters: none\n";
  
  std::cout << message;
}

Member Data Documentation

m_name

std::string dqi::CompositeAlgorithm::m_name

protected

Definition at line 35 of file CompositeAlgorithm.h.

m_subAlgs

AlgVec_t dqi::CompositeAlgorithm::m_subAlgs

protected

Definition at line 36 of file CompositeAlgorithm.h.

---

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

• CompositeAlgorithm.h
• CompositeAlgorithm.cxx