dqm_algorithms::RepeatAlgorithm Class Reference

#include <RepeatAlgorithm.h>

Inheritance diagram for dqm_algorithms::RepeatAlgorithm:

Collaboration diagram for dqm_algorithms::RepeatAlgorithm:

Public Member Functions
	RepeatAlgorithm (const RepeatAlgorithm &other)
	RepeatAlgorithm ()
RepeatAlgorithm &	operator= (const RepeatAlgorithm &other)
virtual	~RepeatAlgorithm ()
virtual dqm_core::Algorithm *	clone ()
virtual dqm_core::Result *	execute (const std::string &name, const TObject &data, const dqm_core::AlgorithmConfig &config)
dqm_core::AlgorithmConfig *	ConfigureSubAlg (const dqm_core::AlgorithmConfig &config, TObject *reference)
virtual void	printDescription (std::ostream &out)

Protected Attributes
std::shared_ptr< dqm_core::Algorithm >	m_subalg

Detailed Description

Definition at line 17 of file RepeatAlgorithm.h.

Constructor & Destructor Documentation

RepeatAlgorithm() [1/2]

dqm_algorithms::RepeatAlgorithm::RepeatAlgorithm

(

const RepeatAlgorithm &

other

)

Definition at line 30 of file RepeatAlgorithm.cxx.

                                          :
  m_subalg() {
}  

RepeatAlgorithm() [2/2]

dqm_algorithms::RepeatAlgorithm::RepeatAlgorithm

(

)

Definition at line 44 of file RepeatAlgorithm.cxx.

{
  dqm_core::AlgorithmManager::instance().registerAlgorithm("RepeatAlgorithm", this);
}

~RepeatAlgorithm()

dqm_algorithms::RepeatAlgorithm::~RepeatAlgorithm ( )

virtual

Definition at line 50 of file RepeatAlgorithm.cxx.

{
}

Member Function Documentation

clone()

dqm_core::Algorithm * dqm_algorithms::RepeatAlgorithm::clone ( )

virtual

Definition at line 56 of file RepeatAlgorithm.cxx.

{
  return new RepeatAlgorithm(*this);
}

ConfigureSubAlg()

dqm_core::AlgorithmConfig * dqm_algorithms::RepeatAlgorithm::ConfigureSubAlg	(	const dqm_core::AlgorithmConfig &	config,
		TObject *	reference )

Definition at line 148 of file RepeatAlgorithm.cxx.

{
// caller owns the returned object
 
// what we do: copy reference, params, limits to newly created config
// copy all params except AuxAlgName--blah and RepeatAlgorithm--blah
  
  auto rv(new dqm_core::test::DummyAlgorithmConfig(reference));
 
  for (const auto& parVal : config.getParameters()) {
    if (parVal.first.find("AuxAlgName--") == std::string::npos
    && parVal.first.find("RepeatAlgorithm--") == std::string::npos) {
      rv->addParameter(parVal.first, parVal.second);
    }
  }
  for (const auto& grthr : config.getGreenThresholds()) {
    rv->addGreenThreshold(grthr.first, grthr.second);
  }
  for (const auto& rdthr : config.getRedThresholds()) {
    rv->addRedThreshold(rdthr.first, rdthr.second);
  }
  return rv;
}

execute()

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

virtual

Definition at line 78 of file RepeatAlgorithm.cxx.

{
  dqm_core::Result::Status status(dqm_core::Result::Undefined);
  std::map<std::string,double> tags;
  std::unique_ptr<TObjArray> returnObjs(new TObjArray);
 
  if (!m_subalg.get()) {
    // rely on requested subalg not changing over time
    std::string subalgname(dqm_algorithms::tools::ExtractAlgorithmName(config));
    try {
      m_subalg.reset(dqm_core::AlgorithmManager::instance().getAlgorithm(subalgname));
    }
    catch (dqm_core::Exception& ex) {
      throw dqm_core::BadConfig( ERS_HERE, "RepeatAlgorithm", ex.what(), ex );
    }
  }
  TObject* ref(0);
  try {
    ref = config.getReference();
  } catch (dqm_core::BadConfig &) {
    throw dqm_core::BadConfig( ERS_HERE, "RepeatAlgorithm", "No references defined for RepeatAlgorithm - this makes no sense" );
  }
  const TCollection* listptr(dynamic_cast<const TCollection*>(ref));
  if (!listptr) {
    throw dqm_core::BadConfig( ERS_HERE, "RepeatAlgorithm", "Reference needs to be a TCollection" );
  }
  TIter itr(listptr);
  while ( TObject* ireference = itr.Next() ) {
    std::unique_ptr<dqm_core::AlgorithmConfig> subConfig(ConfigureSubAlg(config, ireference));
    dqm_core::Result* subResult = m_subalg->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 ) {
      tags[ireference->GetName() + std::string("|") + tagsIter->first] = tagsIter->second;
    }
    tags[ireference->GetName() + std::string("|Status")] = subResult->status_; 
    if ( dqm_algorithms::tools::GetFirstFromMap("RepeatAlgorithm--ResultsNEntries", config.getParameters(), 0) > 0 ) {
 
       if( ireference->IsA()->InheritsFrom( "TH1" )){
          TH1* hireference = dynamic_cast<TH1*>(ireference);
          if (hireference) {
            tags[ireference->GetName() + std::string("|NEntries")] = hireference->GetEntries();
          } 
       }
    }
 
    if (subResult->getObject()) {
      // do nothing here; ROOT handling is terrible
      //      returnObjs->Add(subResult->getObject()->Clone());
    }
    //delete subConfig;
    delete subResult;
  }
  
  dqm_core::Result* result = new dqm_core::Result( status );
  result->tags_ = std::move(tags);
  if (!returnObjs->IsEmpty()) {
    result->object_.reset(returnObjs.release());
  }
  
  return result;
}

operator=()

RepeatAlgorithm & dqm_algorithms::RepeatAlgorithm::operator=

(

const RepeatAlgorithm &

other

)

Definition at line 36 of file RepeatAlgorithm.cxx.

                                        {
  if (this != &other) {
    m_subalg = other.m_subalg;
  }
  return *this;
}

printDescription()

void dqm_algorithms::RepeatAlgorithm::printDescription ( std::ostream & out )

virtual

Definition at line 63 of file RepeatAlgorithm.cxx.

{
  std::string message;
  message += "\n";
  message += "Algorithm: RepeatAlgorithm\n";
  message += "Description: Repeats the specified algorithm for each input reference.\n";
  message += "Parameters: AuxAlgName--xxx: run algorithm xxx\n";
  message += "            RepeatAlgorithm--ResultsNEntries: return # of entries of reference histogram as a result\n";
  
  out << message;
}

Member Data Documentation

m_subalg

std::shared_ptr<dqm_core::Algorithm> dqm_algorithms::RepeatAlgorithm::m_subalg

protected

Definition at line 35 of file RepeatAlgorithm.h.

---

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

• RepeatAlgorithm.h
• RepeatAlgorithm.cxx