ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Private Member Functions | List of all members
dqi::HanConfig Class Reference

#include <HanConfig.h>

Inheritance diagram for dqi::HanConfig:
Collaboration diagram for dqi::HanConfig:

Classes

class  RefVisitor
class  RefWriter
class  AssessmentVisitorBase
class  RegionVisitor
class  AssessmentVisitor
class  RegexVisitor
class  ConfigVisitor
class  CompAlgVisitor
class  MetadataVisitor

Public Member Functions

 HanConfig ()
virtual ~HanConfig ()
virtual void AssembleAndSave (const std::string &infileName, const std::string &outfileName, const std::string &connectionString="sqlite://;schema=/afs/cern.ch/user/a/atlasdqm/dqmdisk1/cherrypy-devel/RefDB.db;dbname=REFDB", long runNumber=2147483646, bool bulk=false)
virtual void BuildMonitors (std::string configName, HanInputRootFile &input, HanOutput &output)
virtual boost::shared_ptr< dqm_core::Region > BuildMonitorsNewRoot (std::string configName, HanInputRootFile &input, dqm_core::Output &output)
virtual void BuildConfigOutput (std::string configName, TFile *inputFile, const std::string &path, std::map< std::string, TSeqCollection * > *outputMap, TSeqCollection *outputList)
virtual TObject * GetReference (std::string &groupName, std::string &name)
virtual const HanConfigAssessor * GetAssessor (std::string &groupName, std::string &name) const
virtual void GetRegexList (std::set< std::string > &regexlist)

Protected Types

typedef std::map< std::string, TDirectory * > DirMap_t

Protected Member Functions

bool Initialize (const std::string &configName)

Protected Attributes

TFile * m_config {}
boost::shared_ptr< dqm_core::Region > m_dqRoot
HanConfigGroup * m_top_level {}
TSeqCollection * m_metadata {}

Static Private Member Functions

static TKey * GetObjKey (TDirectory *dir, std::string path)
static TDirectory * ChangeInputDir (TDirectory *dir, const std::string &path)
static TDirectory * ChangeOutputDir (TFile *file, const std::string &path, DirMap_t &directories)

Detailed Description

Definition at line 48 of file HanConfig.h.

Member Typedef Documentation

◆ DirMap_t

typedef std::map<std::string,TDirectory*> dqi::HanConfig::DirMap_t
protected

Definition at line 73 of file HanConfig.h.

Constructor & Destructor Documentation

◆ HanConfig()

dqi::HanConfig::HanConfig ( )

Definition at line 69 of file HanConfig.cxx.

71 : m_config(0)
72 , m_dqRoot()
73 , m_top_level(0)
74 , m_metadata(0)
75{
76}
dqi::HanConfig::m_dqRoot
boost::shared_ptr< dqm_core::Region > m_dqRoot
Definition HanConfig.h:190
dqi::HanConfig::m_top_level
HanConfigGroup * m_top_level
Definition HanConfig.h:192
dqi::HanConfig::m_config
TFile * m_config
Definition HanConfig.h:188
dqi::HanConfig::m_metadata
TSeqCollection * m_metadata
Definition HanConfig.h:193

◆ ~HanConfig()

dqi::HanConfig::~HanConfig ( )
virtual

Definition at line 79 of file HanConfig.cxx.

81{
82 delete m_config;
83 /* delete m_dqRoot; */
84 delete m_top_level;
85 if (m_metadata) m_metadata->Delete();
86 delete m_metadata;
87}

Member Function Documentation

◆ AssembleAndSave()

void dqi::HanConfig::AssembleAndSave ( const std::string & infileName,
const std::string & outfileName,
const std::string & connectionString = "sqlite://;schema=/afs/cern.ch/user/a/atlasdqm/dqmdisk1/cherrypy-devel/RefDB.db;dbname=REFDB",
long runNumber = 2147483646,
bool bulk = false )
virtual

Definition at line 101 of file HanConfig.cxx.

103{
104 std::unique_ptr< TFile > outfile( TFile::Open( outfileName.c_str(),
105 "RECREATE" ) );
106 DirMap_t directories;
107
108 // Collect reference histograms and copy to config file
109 MiniConfig refconfig;
110 refconfig.AddKeyword("reference");
111 refconfig.ReadFile(infileName);
112 TMap refsourcedata;
113 refsourcedata.SetOwnerKeyValue();
114 RefVisitor refvisitor( outfile.get(), directories, &refsourcedata );
115 refconfig.SendVisitor( refvisitor );
116
117 DatabaseConfig databaseConfig(connectionString, runNumber);
118 RefWriter refwriter(databaseConfig, bulk);
119 refconfig.SendWriter( refwriter );
120 databaseConfig.Disconnect();
121
122 // Collect threshold definitions
123 MiniConfig thrconfig;
124 thrconfig.AddKeyword("thresholds");
125 thrconfig.AddAttributeKeyword("limits");
126 thrconfig.ReadFile(infileName);
127
128 // Collect algorithm definitions
129 MiniConfig algconfig;
130 algconfig.AddKeyword("algorithm");
131 algconfig.ReadFile(infileName);
132
133 // Collect region definitions
134 MiniConfig regconfig;
135 regconfig.AddKeyword("output");
136 regconfig.ReadFile(infileName);
137
138 // Collect histogram definitions
139 MiniConfig histconfig;
140 histconfig.AddKeyword("dir");
141 histconfig.AddAttributeKeyword("hist");
142 histconfig.SetAttribKeywordPropagateDown(false);
143 histconfig.ReadFile(infileName);
144
145 // Collect and write composite-algorithm definitions
146 MiniConfig compalgconfig;
147 compalgconfig.AddKeyword("compositealgorithm");
148 compalgconfig.ReadFile(infileName);
149 CompAlgVisitor compalgvisitor(outfile.get(), compalgconfig);
150 compalgconfig.SendVisitor(compalgvisitor);
151
152 MiniConfig metadataconfig;
153 metadataconfig.AddKeyword("metadata");
154 metadataconfig.ReadFile(infileName);
155 MetadataVisitor metadatavisitor(outfile.get(), metadataconfig);
156 metadataconfig.SendVisitor(metadatavisitor);
157
158 // Assemble into a hierarchical configuration
159 outfile->cd();
160 std::unique_ptr< HanConfigGroup > root( new HanConfigGroup() );
161
162 RegionVisitor regvisitor( root.get(), algconfig, thrconfig, refconfig, directories );
163 regconfig.SendVisitor( regvisitor );
164
165 AssessmentVisitor histvisitor( root.get(), algconfig, thrconfig, refconfig, outfile.get(),
166 directories, &refsourcedata );
167 histconfig.SendVisitor( histvisitor );
168
169 outfile->WriteTObject(&refsourcedata, "refsourcedata");
170 outfile->cd();
171 root->Write();
172 outfile->Write();
173 outfile->Close();
174}
dqi::HanConfig::DirMap_t
std::map< std::string, TDirectory * > DirMap_t
Definition HanConfig.h:73
directories
std::vector< std::string > directories
Definition listroot.cxx:185
sendEI_SPB.root
root
Definition sendEI_SPB.py:34

◆ BuildConfigOutput()

void dqi::HanConfig::BuildConfigOutput ( std::string configName,
TFile * inputFile,
const std::string & path,
std::map< std::string, TSeqCollection * > * outputMap,
TSeqCollection * outputList )
virtual

Definition at line 240 of file HanConfig.cxx.

243{
244 bool isInitialized = Initialize( configName );
245 if( !isInitialized ) {
246 return;
247 }
248
249 if( inputFile == 0 ) {
250 return;
251 }
252
253 TDirectory* basedir(0);
254 if( path != "" ) {
255 std::string pathForSearch = path + "/dummyName";
256 basedir = ChangeInputDir( inputFile, std::move(pathForSearch) );
257 }
258
259 if( basedir == 0 )
260 basedir = inputFile;
261
262 TIter mdIter(m_metadata);
263 TSeqCollection* mdList = newTList("HanMetadata_");
264 HanConfigMetadata* md(0);
265 while ((md = dynamic_cast<HanConfigMetadata*>(mdIter()))) {
266 mdList->Add( md->GetList(basedir,*outputMap) );
267 }
268 TSeqCollection* top_level_list = m_top_level->GetList(basedir,*outputMap);
269 top_level_list->Add( mdList );
270 outputList->Add( top_level_list );
271}
dqi::HanConfig::Initialize
bool Initialize(const std::string &configName)
Definition HanConfig.cxx:1301
dqi::HanConfig::ChangeInputDir
static TDirectory * ChangeInputDir(TDirectory *dir, const std::string &path)
Definition HanConfig.cxx:1380
CaloCondBlobAlgs_fillNoiseFromASCII.inputFile
str inputFile
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:16
athena.path
path
python interpreter configuration --------------------------------------—
Definition athena.py:130
dqi::newTList
TSeqCollection * newTList(const char *name, TObject *obj=0)
Definition HanUtils.cxx:18

◆ BuildMonitors()

void dqi::HanConfig::BuildMonitors ( std::string configName,
HanInputRootFile & input,
HanOutput & output )
virtual

Definition at line 177 of file HanConfig.cxx.

179{
180 bool isInitialized = Initialize( configName );
181 if( !isInitialized ) {
182 return;
183 }
184
185 m_dqRoot = BuildMonitorsNewRoot( std::move(configName), input, output );
186
187 output.setConfig( this );
188}
dqi::HanConfig::BuildMonitorsNewRoot
virtual boost::shared_ptr< dqm_core::Region > BuildMonitorsNewRoot(std::string configName, HanInputRootFile &input, dqm_core::Output &output)
Definition HanConfig.cxx:192
merge.output
output
Definition merge.py:16

◆ BuildMonitorsNewRoot()

boost::shared_ptr< dqm_core::Region > dqi::HanConfig::BuildMonitorsNewRoot ( std::string configName,
HanInputRootFile & input,
dqm_core::Output & output )
virtual

Definition at line 191 of file HanConfig.cxx.

193{
194 bool isInitialized = Initialize( configName );
195 if( !isInitialized ) {
196 return boost::shared_ptr<dqm_core::Region>();
197 }
198
199 TDirectory* topdir = const_cast<TDirectory*>(input.getBasedir());
200 TPython::Bind(m_config, "config");
201 TPython::Bind(m_top_level, "top_level");
202 TPython::Bind(topdir, "path");
203 TPython::Exec("from DataQualityInterfaces.han import FixRegion, logLevel");
204 const char* debugflag = std::getenv("HANDEBUG");
205 if (!debugflag) {
206 TPython::Exec("logLevel('INFO')");
207 } else {
208 TPython::Exec("logLevel('DEBUG')");
209 }
210
211#if ROOT_VERSION_CODE >= ROOT_VERSION(6,33,01)
212 std::any result;
213 TPython::Exec ("_anyresult = ROOT.std.make_any['dqi::HanConfigGroup'](FixRegion(config, top_level, path))", &result);
214 auto new_top_level = new dqi::HanConfigGroup (std::any_cast<HanConfigGroup>(result));
215#else
216 HanConfigGroup* new_top_level = TPython::Eval("FixRegion(config, top_level, path)");
217#endif
218 delete m_top_level;
219 m_top_level = new_top_level;
220
221 std::string algName( m_top_level->GetAlgName() );
222 std::string algLibName( m_top_level->GetAlgLibName() );
223 if( algLibName != "" ) {
224 try {
225 dqm_core::LibraryManager::instance().loadLibrary( algLibName );
226 }
227 catch ( dqm_core::Exception& ex ) {
228 //std::cout << "Can't load library " << algLibName << ". Continuing regardless ..." << std::endl;
229 }
230 }
231 dqm_core::RegionConfig regc( algName, 1.0 );
232 boost::shared_ptr<dqm_core::Region> retval(dqm_core::Region::createRootRegion( "top_level", input, output, regc ));
233
234 ConfigVisitor confvisitor( m_config, &output );
235 m_top_level->Accept( confvisitor, retval );
236 return retval;
237}
LArCellBinning_test.retval
retval
Definition LArCellBinning_test.py:112
get_generator_info.result
result
Definition get_generator_info.py:21
xAOD::JetAlgorithmType::algName
const std::string & algName(ID id)
Converts a JetAlgorithmType::ID into a string.
Definition JetContainerInfo.cxx:67

◆ ChangeInputDir()

TDirectory * dqi::HanConfig::ChangeInputDir ( TDirectory * dir,
const std::string & path )
staticprivate

Definition at line 1379 of file HanConfig.cxx.

1381{
1382 if( dir == 0 )
1383 return 0;
1384
1385 TKey* key(0);
1386
1387 std::string::size_type i = path.find_first_of('/');
1388 if( i != std::string::npos ) {
1389 std::string dName( path, 0, i );
1390 std::string pName( path, i+1, std::string::npos );
1391 if( dName != "" ) {
1392 TDirectory* subDir(0);
1393 key = dir->FindKey( dName.c_str() );
1394 if( key != 0 ) {
1395 subDir = dynamic_cast<TDirectory*>( key->ReadObj() );
1396 }
1397 else {
1398 return 0;
1399 }
1400 TDirectory* retval = ChangeInputDir( subDir, pName );
1401 return retval;
1402 }
1403 return ChangeInputDir( dir, pName );
1404 }
1405
1406 return dir;
1407}

◆ ChangeOutputDir()

TDirectory * dqi::HanConfig::ChangeOutputDir ( TFile * file,
const std::string & path,
DirMap_t & directories )
staticprivate

Definition at line 1411 of file HanConfig.cxx.

1413{
1414 if( file == 0 )
1415 return 0;
1416
1417 std::string::size_type i = path.find_last_of('/');
1418 if( i != std::string::npos ) {
1419 std::string subPath( path, 0, i );
1420 DirMap_t::const_iterator j = directories.find( subPath );
1421 if( j != directories.end() ) {
1422 TDirectory* dir = j->second;
1423 return dir;
1424 }
1425 else {
1426 TDirectory* parDir = ChangeOutputDir( file, subPath, directories );
1427 std::string dirName;
1428 std::string::size_type k = subPath.find_last_of('/');
1429 dirName = (k != std::string::npos) ? std::string( subPath, k+1, std::string::npos ) : subPath;
1430 TDirectory* dir = nullptr;
1431 if (!parDir->FindKey(dirName.c_str())) {
1432 dir = parDir->mkdir( dirName.c_str() );
1433 }
1434 else{
1435 std::cout << "Failed to make directory " << dirName << std::endl;
1436 }
1437 DirMap_t::value_type dirVal( subPath, dir );
1438 directories.insert( std::move(dirVal) );
1439 return dir;
1440 }
1441 }
1442
1443 return file;
1444}
dqi::HanConfig::ChangeOutputDir
static TDirectory * ChangeOutputDir(TFile *file, const std::string &path, DirMap_t &directories)
Definition HanConfig.cxx:1412
TauHitVars::j
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
Definition ConstituentLoaderTauHit.cxx:102
file
TFile * file
Definition tile_monitor.h:29

◆ GetAssessor()

const HanConfigAssessor * dqi::HanConfig::GetAssessor ( std::string & groupName,
std::string & name ) const
virtual

Definition at line 337 of file HanConfig.cxx.

339{
340 if( m_top_level == 0 ) {
341 return 0;
342 }
343
344 HanConfigGroup* parent = m_top_level->GetNode(groupName);
345 if( parent == 0 ) {
346 parent = m_top_level;
347 }
348
349 const HanConfigAssessor& a = parent->GetAssessor(name);
350
351 return new HanConfigAssessor(a);
352}
a
static Double_t a
Definition LArPhysWaveHECTool.cxx:38
test_pyathena.parent
parent
Definition test_pyathena.py:15

◆ GetObjKey()

TKey * dqi::HanConfig::GetObjKey ( TDirectory * dir,
std::string path )
staticprivate

◆ GetReference()

TObject * dqi::HanConfig::GetReference ( std::string & groupName,
std::string & name )
virtual

Definition at line 275 of file HanConfig.cxx.

277{
278 /* if( m_top_level == 0 ) {
279 return 0;
280 }
281
282 HanConfigGroup* parent = m_top_level->GetNode(groupName);
283 if( parent == 0 ) {
284 parent = m_top_level;
285 } */
286
287 std::unique_ptr<const HanConfigAssessor> a(GetAssessor( groupName, name ));
288 if (!a.get()) return 0;
289 std::string refName( a->GetAlgRefName() );
290 if( refName != "" ) {
291 TKey* key = getObjKey( m_config, refName );
292 if( key != 0 ) {
293 //TObject* ref = m_config->Get(refName.c_str());
294 TObject* ref = key->ReadObj();
295 if (ref)
296 return ref;
297 }
298 }
299
300 return 0;
301}
ref
const boost::regex ref(r_ef)
dqi::HanConfig::GetAssessor
virtual const HanConfigAssessor * GetAssessor(std::string &groupName, std::string &name) const
Definition HanConfig.cxx:338
dqi::getObjKey
TKey * getObjKey(TDirectory *dir, const std::string &path)
Definition HanUtils.cxx:36

◆ GetRegexList()

void dqi::HanConfig::GetRegexList ( std::set< std::string > & regexlist)
virtual

Definition at line 355 of file HanConfig.cxx.

357{
358 RegexVisitor rv(regexlist);
359 m_top_level->Accept(rv, boost::shared_ptr<dqm_core::Region>());
360}
dq_make_web_display.rv
rv
Definition dq_make_web_display.py:218

◆ Initialize()

bool dqi::HanConfig::Initialize ( const std::string & configName)
protected

Definition at line 1300 of file HanConfig.cxx.

1302{
1303 if( m_config == 0 || m_top_level == 0 ) {
1304
1305 delete m_config;
1306 delete m_top_level;
1307 if (m_metadata) {
1308 m_metadata->Delete();
1309 }
1310 delete m_metadata; m_metadata=newTList("HanMetadata");
1311
1312 m_config = TFile::Open( configName.c_str(), "READ" );
1313 if( m_config == 0 ) {
1314 std::cerr << "HanConfig::Initialize() cannot open file \"" << configName << "\"\n";
1315 return false;
1316 }
1317
1318 TMap* refsourcedata = dynamic_cast<TMap*>(m_config->Get("refsourcedata"));
1319 if (refsourcedata) {
1320 ConditionsSingleton::getInstance().setRefSourceMapping(refsourcedata);
1321 } else {
1322 std::cerr << "Can't retrieve reference source info" << std::endl;
1323 }
1324
1325 TIter nextKey( m_config->GetListOfKeys() );
1326 TKey* compAlgKey(0);
1327 while( (compAlgKey = dynamic_cast<TKey*>( nextKey() )) != 0 ) {
1328 TObject* obj = compAlgKey->ReadObj();
1329 HanConfigCompAlg* compAlg = dynamic_cast<HanConfigCompAlg*>( obj );
1330 if( compAlg != 0 ) {
1331 //std::cout << "Instantiating composite algorithm \"" << compAlg->GetName() << "\"...\n";
1332 new CompositeAlgorithm( *compAlg );
1333 }
1334 delete obj;
1335 }
1336
1337 TKey* key(0);
1338
1339 m_metadata = newTList("HanMetadata");
1340 key = m_config->FindKey("HanMetadata");
1341 if ( key ) {
1342 TDirectory* mdDir = dynamic_cast<TDirectory*>(key->ReadObj());
1343 if (mdDir) {
1344 TIter mdIter(mdDir->GetListOfKeys());
1345 TKey* mdKey(0);
1346 while ((mdKey = dynamic_cast<TKey*>(mdIter()))) {
1347 HanConfigMetadata* md = dynamic_cast<HanConfigMetadata*>(mdKey->ReadObj());
1348 if (md) {
1349 m_metadata->Add(md);
1350 }
1351 }
1352 }
1353 delete mdDir;
1354 }
1355
1356 key = m_config->FindKey("top_level");
1357 if( key == 0 ) {
1358 std::cerr << "HanConfig::Initialize() cannot find configuration in file \"" << configName << "\"\n";
1359 return false;
1360 }
1361
1362 m_top_level = dynamic_cast<HanConfigGroup*>( key->ReadObj() );
1363 if( m_top_level == 0 ) {
1364 std::cerr << "HanConfig::Initialize() cannot find configuration in file \"" << configName << "\"\n";
1365 return false;
1366 }
1367 }
1368
1369 return true;
1370}
dqi::ConditionsSingleton::getInstance
static ConditionsSingleton & getInstance()
Definition ConditionsSingleton.cxx:23
dqi::ConditionsSingleton::setRefSourceMapping
void setRefSourceMapping(const TMap *refsourcedata)
Definition ConditionsSingleton.cxx:39

Member Data Documentation

◆ m_config

TFile* dqi::HanConfig::m_config {}
protected

Definition at line 188 of file HanConfig.h.

188{};

◆ m_dqRoot

boost::shared_ptr<dqm_core::Region> dqi::HanConfig::m_dqRoot
protected

Definition at line 190 of file HanConfig.h.

◆ m_metadata

TSeqCollection* dqi::HanConfig::m_metadata {}
protected

Definition at line 193 of file HanConfig.h.

193{};

◆ m_top_level

HanConfigGroup* dqi::HanConfig::m_top_level {}
protected

Definition at line 192 of file HanConfig.h.

192{};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1