dqi::HanConfigAssessor Class Reference

#include <HanConfigAssessor.h>

Inheritance diagram for dqi::HanConfigAssessor:

Collaboration diagram for dqi::HanConfigAssessor:

Classes
class	Visitor

Public Member Functions
	HanConfigAssessor ()
	HanConfigAssessor (const HanConfigAssessor &other)
HanConfigAssessor &	operator= (const HanConfigAssessor &other)
virtual	~HanConfigAssessor ()
virtual std::string	GetUniqueName () const
virtual void	SetName (std::string name_)
virtual const char *	GetName () const
virtual const char *	GetHistPath () const
virtual void	SetAlgName (std::string name_)
virtual const char *	GetAlgName () const
virtual void	SetAlgLibName (std::string name_)
virtual const char *	GetAlgLibName () const
virtual void	SetAlgRefName (std::string name_)
virtual std::string	GetAlgRefName () const
virtual const char *	GetAlgRefString () const
virtual void	AddAlgPar (const HanConfigAlgPar &algPar_)
virtual HanConfigAlgPar	GetAlgPar (std::string name_) const
virtual TIter	GetAllAlgPars () const
virtual void	AddAlgStrPar (const HanConfigParMap &algPar_)
virtual HanConfigParMap	GetAlgStrPar (std::string name_) const
virtual TIter	GetAllAlgStrPars () const
virtual void	AddAlgLimit (const HanConfigAlgLimit &algLim_)
virtual HanConfigAlgLimit	GetAlgLimit (std::string name_) const
virtual TIter	GetAllAlgLimits () const
virtual void	AddAnnotation (const HanConfigParMap &annotation_)
virtual const HanConfigParMap *	GetAnnotation (std::string name_) const
virtual TIter	GetAllAnnotations () const
virtual void	SetWeight (float weight_)
virtual float	GetWeight () const
virtual void	SetIsRegex (bool isRegex_)
virtual bool	GetIsRegex () const
virtual TSeqCollection *	GetList (TDirectory *basedir, std::map< std::string, TSeqCollection * > &mp)
virtual void	Accept (Visitor &visitor, boost::shared_ptr< dqm_core::Region > dqParent) const
virtual void	PrintIOStream (std::ostream &o) const

Protected Attributes
TObjString	m_name
TObjString	m_algName
TObjString	m_algLibName
TObjString	m_algRefName
TSeqCollection *	m_algPars
TSeqCollection *	m_algStrPars
TSeqCollection *	m_algLimits
TSeqCollection *	m_annotations
float	m_weight
bool	m_isRegex

Detailed Description

Definition at line 37 of file HanConfigAssessor.h.

Constructor & Destructor Documentation

HanConfigAssessor() [1/2]

dqi::HanConfigAssessor::HanConfigAssessor

(

)

Definition at line 34 of file HanConfigAssessor.cxx.

  : m_algPars( newTObjArray( "algPars" ) )
  , m_algStrPars( newTObjArray( "algStrPars" ) )
  , m_algLimits( newTObjArray( "algLimits" ) )
  , m_annotations( newTObjArray( "annotations" ) )
  , m_weight( 1 )
  , m_isRegex( false )
{ }

HanConfigAssessor() [2/2]

dqi::HanConfigAssessor::HanConfigAssessor

(

const HanConfigAssessor &

other

)

Definition at line 45 of file HanConfigAssessor.cxx.

  : TObject(other)
  , m_name(other.m_name)
  , m_algName(other.m_algName)
  , m_algLibName(other.m_algLibName)
  , m_algRefName(other.m_algRefName)
  , m_algPars( newTObjArray( "algPars", 0, other.m_algPars->GetEntries() ) )
  , m_algStrPars( newTObjArray( "algStrPars", 0, other.m_algStrPars->GetEntries() ) )
  , m_algLimits( newTObjArray( "algLimits", 0, other.m_algLimits->GetEntries() ) )
  , m_annotations( newTObjArray( "annotations", 0, other.m_annotations->GetEntries() ) )
  , m_weight(other.m_weight)
  , m_isRegex(other.m_isRegex)
{
  TIter nextPar( other.m_algPars );
  HanConfigAlgPar* otherPar;
  while( (otherPar = dynamic_cast<HanConfigAlgPar*>( nextPar() )) != 0 ) {
    HanConfigAlgPar* par = new HanConfigAlgPar( *otherPar );
    m_algPars->Add( par );
  }
 
  TIter nextStrPar( other.m_algStrPars );
  HanConfigParMap* otherStrPar;
  while( (otherStrPar = dynamic_cast<HanConfigParMap*>( nextStrPar() )) != 0 ) {
    HanConfigParMap* strPar = new HanConfigParMap( *otherStrPar );
    m_algStrPars->Add( strPar );
  }
  
  TIter nextLim( other.m_algLimits );
  HanConfigAlgLimit* otherLim;
  while( (otherLim = dynamic_cast<HanConfigAlgLimit*>( nextLim() )) != 0 ) {
    HanConfigAlgLimit* lim = new HanConfigAlgLimit( *otherLim );
    m_algLimits->Add( lim );
  }
  
  TIter nextParMap( other.m_annotations );
  HanConfigParMap* otherParMap;
  while( (otherParMap = dynamic_cast<HanConfigParMap*>( nextParMap() )) != 0 ) {
    HanConfigParMap* parMap = new HanConfigParMap( *otherParMap );
    m_annotations->Add( parMap );
  }
}

~HanConfigAssessor()

dqi::HanConfigAssessor::~HanConfigAssessor ( )

virtual

Definition at line 138 of file HanConfigAssessor.cxx.

{
  m_algPars->Delete();
  m_algStrPars->Delete();
  m_algLimits->Delete();
  m_annotations->Delete();
  delete m_algPars;
  delete m_algStrPars;
  delete m_algLimits;
  delete m_annotations;
}

Member Function Documentation

Accept()

void dqi::HanConfigAssessor::Accept ( Visitor &  visitor, boost::shared_ptr< dqm_core::Region >  dqParent  ) const

virtual

Reimplemented in dqi::HanConfigGroup.

Definition at line 522 of file HanConfigAssessor.cxx.

{
  visitor.Visit( this, std::move(dqParent) );
}

AddAlgLimit()

void dqi::HanConfigAssessor::AddAlgLimit ( const HanConfigAlgLimit &  algLim_ )

virtual

Definition at line 305 of file HanConfigAssessor.cxx.

{
  HanConfigAlgLimit* lim = new HanConfigAlgLimit( algLim_ );
  m_algLimits->Add( lim );
}

AddAlgPar()

void dqi::HanConfigAssessor::AddAlgPar ( const HanConfigAlgPar &  algPar_ )

virtual

Definition at line 245 of file HanConfigAssessor.cxx.

{
  HanConfigAlgPar* par = new HanConfigAlgPar( algPar_ );
  m_algPars->Add( par );
}

AddAlgStrPar()

void dqi::HanConfigAssessor::AddAlgStrPar ( const HanConfigParMap &  algPar_ )

virtual

Definition at line 275 of file HanConfigAssessor.cxx.

{
  HanConfigParMap* strPar = new HanConfigParMap( algStrPar_ );
  m_algStrPars->Add( strPar );
}

AddAnnotation()

void dqi::HanConfigAssessor::AddAnnotation ( const HanConfigParMap &  annotation_ )

virtual

Definition at line 334 of file HanConfigAssessor.cxx.

{
  HanConfigParMap* parMap = new HanConfigParMap( annotation_ );
  m_annotations->Add( parMap );
}

GetAlgLibName()

const char * dqi::HanConfigAssessor::GetAlgLibName ( ) const

virtual

Definition at line 212 of file HanConfigAssessor.cxx.

{
  return m_algLibName.GetName();
}

GetAlgLimit()

HanConfigAlgLimit dqi::HanConfigAssessor::GetAlgLimit ( std::string  name_ ) const

virtual

Definition at line 314 of file HanConfigAssessor.cxx.

{
  HanConfigAlgLimit* lim = dynamic_cast<HanConfigAlgLimit*>( m_algLimits->FindObject(name_.c_str()) );
  if( lim == 0 ) {
    return HanConfigAlgLimit();
  }
  
  return *lim;
}

GetAlgName()

const char * dqi::HanConfigAssessor::GetAlgName ( ) const

virtual

Definition at line 196 of file HanConfigAssessor.cxx.

{
  return m_algName.GetName();
}

GetAlgPar()

HanConfigAlgPar dqi::HanConfigAssessor::GetAlgPar ( std::string  name_ ) const

virtual

Definition at line 254 of file HanConfigAssessor.cxx.

{
  HanConfigAlgPar* par = dynamic_cast<HanConfigAlgPar*>( m_algPars->FindObject(name_.c_str()) );
  if( par == 0 ) {
    return HanConfigAlgPar();
  }
  
  return *par;
}

GetAlgRefName()

std::string dqi::HanConfigAssessor::GetAlgRefName ( ) const

virtual

Definition at line 228 of file HanConfigAssessor.cxx.

{
  dqi::ConditionsSingleton& condSingleton=dqi::ConditionsSingleton::getInstance();
  return condSingleton.conditionalSelect(std::string(m_algRefName.GetName()),std::string(condSingleton.getCondition()));
}

GetAlgRefString()

const char * dqi::HanConfigAssessor::GetAlgRefString ( ) const

virtual

Definition at line 237 of file HanConfigAssessor.cxx.

{
  return m_algRefName.GetName();
}

GetAlgStrPar()

HanConfigParMap dqi::HanConfigAssessor::GetAlgStrPar ( std::string  name_ ) const

virtual

Definition at line 284 of file HanConfigAssessor.cxx.

{
  HanConfigParMap* strPar = dynamic_cast<HanConfigParMap*>( m_algStrPars->FindObject(name_.c_str()) );
  if( strPar == 0 ) {
    return HanConfigParMap();
  }
  
  return *strPar;
}

GetAllAlgLimits()

TIter dqi::HanConfigAssessor::GetAllAlgLimits ( ) const

virtual

Definition at line 327 of file HanConfigAssessor.cxx.

{
  return TIter( m_algLimits );
}

GetAllAlgPars()

TIter dqi::HanConfigAssessor::GetAllAlgPars ( ) const

virtual

Definition at line 267 of file HanConfigAssessor.cxx.

{
  return TIter( m_algPars );
}

GetAllAlgStrPars()

TIter dqi::HanConfigAssessor::GetAllAlgStrPars ( ) const

virtual

Definition at line 297 of file HanConfigAssessor.cxx.

{
  return TIter( m_algStrPars );
}

GetAllAnnotations()

TIter dqi::HanConfigAssessor::GetAllAnnotations ( ) const

virtual

Definition at line 356 of file HanConfigAssessor.cxx.

{
  return TIter( m_annotations );
}

GetAnnotation()

const HanConfigParMap * dqi::HanConfigAssessor::GetAnnotation ( std::string  name_ ) const

virtual

Definition at line 343 of file HanConfigAssessor.cxx.

{
  HanConfigParMap* parMap = dynamic_cast<HanConfigParMap*>( m_annotations->FindObject(name_.c_str()) );
  if( parMap == 0 ) {
    //std::cerr << "WARNING: attempt to access non-existent annotation " << name_ << " on assessor " << GetName() << std::endl;
    return 0;
  }
  return parMap;
}

GetHistPath()

const char * dqi::HanConfigAssessor::GetHistPath ( ) const

virtual

Definition at line 176 of file HanConfigAssessor.cxx.

{
  const HanConfigParMap* parmap = GetAnnotation("inputname");
  if (!parmap) {
    return GetName();
  } else {
    return parmap->GetValue();
  }
}

GetIsRegex()

bool dqi::HanConfigAssessor::GetIsRegex ( ) const

virtual

Definition at line 384 of file HanConfigAssessor.cxx.

{
  return m_isRegex;
}

GetList()

TSeqCollection * dqi::HanConfigAssessor::GetList ( TDirectory *  basedir, std::map< std::string, TSeqCollection * > &  mp  )

virtual

Reimplemented in dqi::HanConfigGroup.

Definition at line 391 of file HanConfigAssessor.cxx.

{
  TSeqCollection *ret = newTList( (std::string(this->m_name.GetName())+std::string("_")).c_str());
  TSeqCollection *configList = newTList("Config");
  TSeqCollection *resultsList = newTList("Results");
  TSeqCollection *nameList = newTObjArray("name", new TObjString(m_algName), 1);
    
  std::string nameString = GetUniqueName();
  
  mp[nameString] = ret;
 
  // fill the configList
  configList->Add(nameList); 
  if (m_algPars == 0)
    std::cerr << "HanConfigAssessor::GetList(): Warning: m_algPars == 0\n";
  else {
    TIter nextAlgPar( m_algPars );
    HanConfigAlgPar *par;
    TSeqCollection *algParList = newTObjArray("algPars", 0, m_algPars->GetEntries());
    while( (par = dynamic_cast<HanConfigAlgPar*>( nextAlgPar() )) != 0 )
      algParList->Add(par->GetList());
    
    if (algParList->IsEmpty())
      delete algParList;
    else
      configList->Add(algParList);
  }
 
  if (m_algStrPars == 0)
    std::cerr << "HanConfigAssessor::GetList(): Warning: m_algStrPars == 0\n";
  else {
    TIter nextAlgStrPar( m_algStrPars );
    HanConfigParMap *strPar;
    TSeqCollection *algStrParList = newTObjArray("algStrPars", 0, m_algStrPars->GetEntries());
    while( (strPar = dynamic_cast<HanConfigParMap*>( nextAlgStrPar() )) != 0 )
      algStrParList->Add(strPar->GetList());
    
    if (algStrParList->IsEmpty())
      delete algStrParList;
    else
      configList->Add(algStrParList);
  }
 
  if (m_algLimits == 0)
    std::cerr << "HanConfigAssessor::GetList(): Warning: m_algLimits == 0\n";
  else {
    TIter nextAlgLim( m_algLimits );
    HanConfigAlgLimit *lim;
    TSeqCollection *algLimitList = newTObjArray("algLimits", 0, m_algLimits->GetEntries());
    while( (lim = dynamic_cast<HanConfigAlgLimit*>( nextAlgLim() )) != 0 )
      algLimitList->Add(lim->GetList());
    if(algLimitList->IsEmpty())
      delete algLimitList;
    else
      configList->Add(algLimitList);
  }
 
  TSeqCollection *parMapList(0);
  if (m_annotations == 0)
    std::cerr << "HanConfigAssessor::GetList(): Warning: annotations == 0\n";
  else {
    TIter nextParMap( m_annotations );
    HanConfigParMap *parMap;
    parMapList = newTObjArray("annotations", 0, m_annotations->GetEntries()+2);
    while( (parMap = dynamic_cast<HanConfigParMap*>( nextParMap() )) != 0 )
      parMapList->Add(parMap->GetList());
  }
  std::string usedAlgRef = GetAlgRefName();
  if ( parMapList && usedAlgRef.size() ) {
    TList* refSourceList = new TList();
    std::string refOrigin(ConditionsSingleton::getInstance().getRefSourceData(usedAlgRef));
    refSourceList->SetName("refSource");
    refSourceList->Add(new TObjString(refOrigin.c_str()));
    parMapList->Add(refSourceList);
    if (refOrigin != "Multiple references") {
      std::string refInfo(ConditionsSingleton::getInstance().getRefSourceData(refOrigin));
      if (refInfo != "") {
    refSourceList = new TList();
    refSourceList->SetName("refInfo");
    refSourceList->Add(new TObjString(refInfo.c_str()));
    parMapList->Add(refSourceList);
      }
    }
  }
  if(!parMapList || parMapList->IsEmpty())
    delete parMapList;
  else
    configList->Add(parMapList);
 
  // Get the histogram
  if (! GetIsRegex()) {
    TKey* key = getObjKey( basedir, GetHistPath() );
    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) {
    std::string::size_type rslash = nameString.rfind('/');
    if (rslash == std::string::npos) {
      rslash = 0;
    } else {
      rslash += 1;
    }
    HanHistogramLink* hhl = new HanHistogramLink(basedir, GetHistPath());
    hhl->SetName( nameString.substr(rslash, std::string::npos).c_str() );
    ret->Add(hhl);
    //   transobj->SetName( nameString.substr(rslash, std::string::npos).c_str() );
    // } else {
    //   std::cerr << "TNamed* cast failed for " << GetHistPath() 
    //      << std::endl;
    //   ret->Add(transobj);
    //  }
    
      }
    }
  }
 
  
  // fill the list that we return
  ret->Add(configList);
  ret->Add(resultsList);
  
  return ret;
}

GetName()

const char * dqi::HanConfigAssessor::GetName ( ) const

virtual

Definition at line 169 of file HanConfigAssessor.cxx.

{
  return m_name.GetName();
}

GetUniqueName()

std::string dqi::HanConfigAssessor::GetUniqueName ( ) const

virtual

Reimplemented in dqi::HanConfigGroup.

Definition at line 153 of file HanConfigAssessor.cxx.

{
  return std::string( GetName() );
}

GetWeight()

float dqi::HanConfigAssessor::GetWeight ( ) const

virtual

Definition at line 370 of file HanConfigAssessor.cxx.

{
  return m_weight;
}

operator=()

HanConfigAssessor & dqi::HanConfigAssessor::operator=

(

const HanConfigAssessor &

other

)

Definition at line 90 of file HanConfigAssessor.cxx.

{
  if (this == &other) return *this;
 
  m_name       = other.m_name;
  m_algName    = other.m_algName;
  m_algLibName = other.m_algLibName;
  m_algRefName = other.m_algRefName;
  m_weight     = other.m_weight;
  m_isRegex    = other.m_isRegex;
  
  m_algPars->Delete();
  TIter nextPar( other.m_algPars );
  HanConfigAlgPar* otherPar;
  while( (otherPar = dynamic_cast<HanConfigAlgPar*>( nextPar() )) != 0 ) {
    HanConfigAlgPar* par = new HanConfigAlgPar( *otherPar );
    m_algPars->Add( par );
  }
  
  m_algStrPars->Delete();
  TIter nextStrPar( other.m_algStrPars );
  HanConfigParMap* otherStrPar;
  while( (otherStrPar = dynamic_cast<HanConfigParMap*>( nextStrPar() )) != 0 ) {
    HanConfigParMap* strPar = new HanConfigParMap( *otherStrPar );
    m_algStrPars->Add( strPar );
  }
  
  m_algLimits->Delete();
  TIter nextLim( other.m_algLimits );
  HanConfigAlgLimit* otherLim;
  while( (otherLim = dynamic_cast<HanConfigAlgLimit*>( nextLim() )) != 0 ) {
    HanConfigAlgLimit* lim = new HanConfigAlgLimit( *otherLim );
    m_algLimits->Add( lim );
  }
  
  m_annotations->Delete();
  TIter nextParMap( other.m_annotations );
  HanConfigParMap* otherParMap;
  while( (otherParMap = dynamic_cast<HanConfigParMap*>( nextParMap() )) != 0 ) {
    HanConfigParMap* parMap = new HanConfigParMap( *otherParMap );
    m_annotations->Add( parMap );
  }
 
  return *this;
}

PrintIOStream()

void dqi::HanConfigAssessor::PrintIOStream ( std::ostream &  o ) const

virtual

Reimplemented in dqi::HanConfigGroup.

Definition at line 530 of file HanConfigAssessor.cxx.

{
  o << "\nHanConfigAssessor: " << GetName() << "\n"
    << "  Algorithm Name = \"" << GetAlgName() << "\"\n"
    << "  Algorithm Library = \"" << GetAlgLibName() << "\"\n"
    << "  Algorithm Reference = \"" << GetAlgRefString() << "\"\n"
    << "  Weight = " << GetWeight() << "\n";
 
  if (m_isRegex) {
    o << "  Is a regular expression" << std::endl;
  }
  
  if( !m_algPars->IsEmpty() ) {
    o << "  Algorithm Parameters = {\n";
    TIter nextPar( m_algPars );
    HanConfigAlgPar* par;
    while( (par = dynamic_cast<HanConfigAlgPar*>( nextPar() )) != 0 ) {
      o << "    " << par;
    }
    TIter nextStrPar( m_algStrPars );
    HanConfigParMap* strPar;
    while( (strPar = dynamic_cast<HanConfigParMap*>( nextStrPar() )) != 0 ) {
      o << "    " << strPar;
    }
    o << "  }\n";
  }
  
  if( !m_algLimits->IsEmpty() ) {
    o << "  Algorithm Limits = {\n";
    TIter nextLim( m_algLimits );
    HanConfigAlgLimit* lim;
    while( (lim = dynamic_cast<HanConfigAlgLimit*>( nextLim() )) != 0 ) {
      o << "    " << lim;
    }
    o << "  }\n";
  }
 
  if( !m_annotations->IsEmpty() ) {
    o << "  Annotations = {\n";
    TIter nextParMap( m_annotations );
    HanConfigParMap* parMap;
    while( (parMap = dynamic_cast<HanConfigParMap*>( nextParMap() )) != 0 ) {
      o << "    " << parMap;
    }
    o << "  }\n";
  }
 
 
}

SetAlgLibName()

void dqi::HanConfigAssessor::SetAlgLibName ( std::string  name_ )

virtual

Definition at line 204 of file HanConfigAssessor.cxx.

{
  m_algLibName.SetString( name_.c_str() );
}

SetAlgName()

void dqi::HanConfigAssessor::SetAlgName ( std::string  name_ )

virtual

Definition at line 188 of file HanConfigAssessor.cxx.

{
  m_algName.SetString( name_.c_str() );
}

SetAlgRefName()

void dqi::HanConfigAssessor::SetAlgRefName ( std::string  name_ )

virtual

Definition at line 220 of file HanConfigAssessor.cxx.

{
  m_algRefName.SetString( name_.c_str() );
}

SetIsRegex()

void dqi::HanConfigAssessor::SetIsRegex ( bool  isRegex_ )

virtual

Definition at line 377 of file HanConfigAssessor.cxx.

{
  m_isRegex = isRegex_;
}

SetName()

void dqi::HanConfigAssessor::SetName ( std::string  name_ )

virtual

Definition at line 161 of file HanConfigAssessor.cxx.

{
  m_name.SetString( name_.c_str() );
}

SetWeight()

void dqi::HanConfigAssessor::SetWeight ( float  weight_ )

virtual

Definition at line 363 of file HanConfigAssessor.cxx.

{
  m_weight = weight_;
}

Member Data Documentation

m_algLibName

TObjString dqi::HanConfigAssessor::m_algLibName

protected

Definition at line 109 of file HanConfigAssessor.h.

m_algLimits

TSeqCollection* dqi::HanConfigAssessor::m_algLimits

protected

Definition at line 114 of file HanConfigAssessor.h.

m_algName

TObjString dqi::HanConfigAssessor::m_algName

protected

Definition at line 108 of file HanConfigAssessor.h.

m_algPars

TSeqCollection* dqi::HanConfigAssessor::m_algPars

protected

Definition at line 112 of file HanConfigAssessor.h.

m_algRefName

TObjString dqi::HanConfigAssessor::m_algRefName

protected

Definition at line 110 of file HanConfigAssessor.h.

m_algStrPars

TSeqCollection* dqi::HanConfigAssessor::m_algStrPars

protected

Definition at line 113 of file HanConfigAssessor.h.

m_annotations

TSeqCollection* dqi::HanConfigAssessor::m_annotations

protected

Definition at line 115 of file HanConfigAssessor.h.

m_isRegex

bool dqi::HanConfigAssessor::m_isRegex

protected

Definition at line 118 of file HanConfigAssessor.h.

m_name

TObjString dqi::HanConfigAssessor::m_name

protected

Definition at line 106 of file HanConfigAssessor.h.

m_weight

float dqi::HanConfigAssessor::m_weight

protected

Definition at line 117 of file HanConfigAssessor.h.

---

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

• HanConfigAssessor.h
• HanConfigAssessor.cxx