diff --git a/DDAlign/include/DDAlign/AlignmentsCalib.h b/DDAlign/include/DDAlign/AlignmentsCalib.h
index fac731056af47e58b7b8bb324de91e474f31d4fb..7e92591943b8a7687629aebd40efa23564cb3eb3 100644
--- a/DDAlign/include/DDAlign/AlignmentsCalib.h
+++ b/DDAlign/include/DDAlign/AlignmentsCalib.h
@@ -40,6 +40,14 @@ namespace dd4hep {
*/
class AlignmentsCalib {
public:
+ /// Helper class to store information about alignment calibration items
+ /** Implementation details: Alignment context entry
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 31/01/2017
+ * \ingroup DD4HEP_DDALIGN
+ */
class Entry;
/// Shortcut definitions
typedef std::map<Condition::key_type,Entry*> UsedConditions;
diff --git a/DDAlign/src/AlignmentsCalib.cpp b/DDAlign/src/AlignmentsCalib.cpp
index 0b5e69562411429180385bb96f1995a566449edf..5b809d470af6a02b8a260a9318bde1655c1d8488 100644
--- a/DDAlign/src/AlignmentsCalib.cpp
+++ b/DDAlign/src/AlignmentsCalib.cpp
@@ -24,6 +24,7 @@ using namespace dd4hep;
using namespace dd4hep::align;
typedef Condition::key_type key_type;
+/// Helper class to store information about alignment calibration items
/** Implementation details: Alignment context entry
*
* \author M.Frank
diff --git a/DDAlign/src/GlobalDetectorAlignment.cpp b/DDAlign/src/GlobalDetectorAlignment.cpp
index 793928cf566caf2b335319f98c020e95147f62af..5d5316ae341b554c1d2caafcd581d9edefc495ab 100644
--- a/DDAlign/src/GlobalDetectorAlignment.cpp
+++ b/DDAlign/src/GlobalDetectorAlignment.cpp
@@ -35,6 +35,12 @@ namespace dd4hep {
/// Namespace for the alignment part of the AIDA detector description toolkit
namespace align {
+ /// Global alignment data container
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_DDALIGN
+ */
class GlobalAlignmentData : public NamedObject {
public:
GlobalAlignment global;
diff --git a/DDCond/include/DDCond/ConditionsDataLoader.h b/DDCond/include/DDCond/ConditionsDataLoader.h
index 506a9aa4f3dfc702e86b6d345329544ce4079305..16f08716e377febfc4311ecbefa4eebefb1a6756 100644
--- a/DDCond/include/DDCond/ConditionsDataLoader.h
+++ b/DDCond/include/DDCond/ConditionsDataLoader.h
@@ -74,6 +74,7 @@ namespace dd4hep {
virtual ~ConditionsDataLoader();
/// Add data source definition to loader
void addSource(const std::string& source, const IOV& iov);
+#if 0
/// Load a condition set given the conditions key according to their validity
virtual size_t load_single(key_type key,
const IOV& req_validity,
@@ -82,6 +83,8 @@ namespace dd4hep {
virtual size_t load_range( key_type key,
const IOV& req_validity,
RangeConditions& conditions) = 0;
+#endif
+ /// Load a number of conditions items from the persistent medium according to the required IOV
virtual size_t load_many( const IOV& req_validity,
RequiredItems& work,
LoadedItems& loaded,
diff --git a/DDCond/include/DDCond/ConditionsManagerObject.h b/DDCond/include/DDCond/ConditionsManagerObject.h
index 33f3e7bd5a0af62fe786e4f017a5ca90e7b6d010..3f0655ea0f9bc283806110733b8d860dfde9bdd8 100644
--- a/DDCond/include/DDCond/ConditionsManagerObject.h
+++ b/DDCond/include/DDCond/ConditionsManagerObject.h
@@ -142,13 +142,13 @@ namespace dd4hep {
/// Access conditions multi IOV pool by iov type
virtual ConditionsIOVPool* iovPool(const IOVType& type) const = 0;
-
+#if 0
/// Retrieve a condition set given a Detector Element and the conditions name according to their validity
virtual Condition get(key_type key, const IOV& req_validity) = 0;
/// Retrieve a condition given a Detector Element and the conditions name
virtual RangeConditions getRange(key_type key, const IOV& req_validity) = 0;
-
+#endif
/// Push all pending updates to the conditions store.
/** Note:
* This does not yet make the new conditions availible to the clients
diff --git a/DDCond/include/DDCond/ConditionsRepository.h b/DDCond/include/DDCond/ConditionsRepository.h
index d6dc4972bcb64f92c82990ae9216b4caa2b22f8e..a4d803a00bf9e8b18531df92b3f4ec920ac50bbc 100644
--- a/DDCond/include/DDCond/ConditionsRepository.h
+++ b/DDCond/include/DDCond/ConditionsRepository.h
@@ -37,6 +37,7 @@ namespace dd4hep {
*/
class ConditionsRepository {
public:
+ /// Definition of a single Entry in the conditions repository
/**
* \author M.Frank
* \version 1.0
@@ -50,6 +51,8 @@ namespace dd4hep {
Entry(const Entry& e) = default;
Entry& operator=(const Entry& e) = default;
};
+
+ /// Definition of the entry collection
typedef std::vector<Entry> Data;
public:
diff --git a/DDCond/include/DDCond/ConditionsRootPersistency.h b/DDCond/include/DDCond/ConditionsRootPersistency.h
index ac0cee4ef7749b1fa2ea63daefc1aea7f1df968a..15a5df11d184df9dbffd23f486220811f0c95def 100644
--- a/DDCond/include/DDCond/ConditionsRootPersistency.h
+++ b/DDCond/include/DDCond/ConditionsRootPersistency.h
@@ -38,6 +38,13 @@ namespace dd4hep {
/// Helper to save conditions pools to ROOT
/**
+ * This is a rathr simplistic persistency mechanism for conditions.
+ * It is not suited to actually store and retrieve individual conditions
+ * by key. Though it is rather efficient to store and retrive
+ * entire conditions snapshots of the conditions store implemented by DDCond.
+ * It e.g. allows to fast load the conditions store for HLT applications,
+ * of which we know it takes ages to populate it from a database.
+ *
* \author M.Frank
* \version 1.0
*/
@@ -47,6 +54,7 @@ namespace dd4hep {
typedef std::pair<std::string, pool_type> named_pool_type;
typedef std::pair<std::string,std::pair<std::pair<std::string,int>,IOV::Key> > iov_key_type;
typedef std::list<std::pair<iov_key_type, pool_type> > persistent_type;
+
persistent_type conditionPools;
persistent_type userPools;
persistent_type iovPools;
diff --git a/DDCond/include/DDCond/ConditionsSelectors.h b/DDCond/include/DDCond/ConditionsSelectors.h
index e909de6fd0355a97fc847e5bfc69059df22e873a..b3a26f26cca82b8d4f890504bb92f6ca7f69bd73 100644
--- a/DDCond/include/DDCond/ConditionsSelectors.h
+++ b/DDCond/include/DDCond/ConditionsSelectors.h
@@ -25,6 +25,13 @@ namespace dd4hep {
/// Namespace for condition operators to avoid clashes
namespace Operators {
+
+ /// Definition of the selector object base class to cover type definitions
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
class Cond__Oper {
public:
typedef Condition cond_t;
@@ -33,6 +40,12 @@ namespace dd4hep {
typedef std::pair<const Condition::key_type,object_t*> ptr_mapentry_t;
};
+ /// Sequential container select operator for conditions mappings
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
template <typename T> struct SequenceSelect : public Cond__Oper {
T& mapping;
SequenceSelect(T& o) : mapping(o) { }
@@ -40,7 +53,13 @@ namespace dd4hep {
{ mapping.insert(mapping.end(), o); return true; }
};
- template <typename T> struct MapSelect : public Cond__Oper {
+ /// Mapped container selection operator for conditions mappings
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
+ template <typename T> struct MapSelect : public Cond__Oper {
T& mapping;
MapSelect(T& o) : mapping(o) { }
bool operator()(Condition::Object* o) const
@@ -51,6 +70,7 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename T> struct MapConditionsSelect : public ConditionsSelect {
T& mapping;
@@ -64,6 +84,7 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename T> struct PoolSelect : public Cond__Oper {
T& pool;
@@ -71,10 +92,11 @@ namespace dd4hep {
bool operator()(Condition::Object* o) const { return pool.insert(o); }
};
- /// Helper to remove objects from a conditions pool
+ /// Helper to remove objects from a conditions pool. The removed condition is deleted.
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename T> struct PoolRemove : public Cond__Oper {
T& pool;
@@ -82,6 +104,12 @@ namespace dd4hep {
bool operator()(object_t* o) const { pool.onRemove(o); delete(o); return true; }
};
+ /// Container select operator for conditions mappings with conditions flagged active
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
template <typename T> struct ActiveSelect : public Cond__Oper {
public:
T& collection;
@@ -99,6 +127,7 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template<typename collection_type> class KeyedSelect : public Cond__Oper {
cond_t::key_type key;
@@ -118,6 +147,7 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
class KeyFind : public Cond__Oper {
cond_t::key_type hash;
@@ -130,6 +160,7 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename OPER> class OperatorWrapper : public Cond__Oper {
public:
@@ -143,9 +174,13 @@ namespace dd4hep {
bool operator()(const mapentry_t& o) const { return oper(o.second.ptr()); }
bool operator()(const ptr_mapentry_t& o) const { return oper(o.second); }
};
- template <typename oper_type> OperatorWrapper<oper_type> operatorWrapper(oper_type& oper) {
- return OperatorWrapper<oper_type>(oper);
- }
+
+ /// Arbitrary wrapper for user defined conditions operators
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
template <typename OPER> class ConditionsOperation : public Cond__Oper {
public:
typedef OPER operator_t;
@@ -159,43 +194,48 @@ namespace dd4hep {
bool operator()(const ptr_mapentry_t& o) const { return oper(o.second); }
};
- /// Helper to insert objects into a conditions pool
+ /// Helper function to create a OperatorWrapper<T> object from the argument type
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
- //class ConditionsPoolSelect : public ConditionsOperation<ConditionsPoolSelect> {
- //public: ConditionsPoolSelect(ConditionsPool& p) : wrapper_t(operator_t(p)) {}
- //};
+ template <typename oper_type> OperatorWrapper<oper_type> operatorWrapper(oper_type& oper) {
+ return OperatorWrapper<oper_type>(oper);
+ }
- /// Helper to remove objects from a conditions pool
+ /// Helper to create functor to remove objects from a conditions pool
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename P> inline ConditionsOperation<PoolRemove<P> > poolRemove(P& pool)
{ return ConditionsOperation<PoolRemove<P> >(PoolRemove<P>(pool)); }
- /// Helper to insert objects into a conditions pool
+ /// Helper to create functor to insert objects into a conditions pool
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename P> inline ConditionsOperation<PoolSelect<P> > poolSelect(P& pool)
{ return ConditionsOperation<PoolSelect<P> >(PoolSelect<P>(pool)); }
- /// Helper to collect conditions using a ConditionsSelect base class
+ /// Helper to create functor to collect conditions using a ConditionsSelect base class
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename T> inline MapConditionsSelect<T> mapConditionsSelect(T& collection)
{ return MapConditionsSelect<T>(collection); }
- /// Helper to select objects from a conditions pool into a sequential container
+ /// Helper to create functor to select objects from a conditions pool into a sequential container
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename C> inline
ConditionsOperation<SequenceSelect<C> > sequenceSelect(C& coll) {
@@ -203,10 +243,11 @@ namespace dd4hep {
return ConditionsOperation<operator_t>(operator_t(coll));
}
- /// Helper to select objects from a conditions pool into a mapped container
+ /// Helper to create functor to select objects from a conditions pool into a mapped container
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename C> inline
ConditionsOperation<SequenceSelect<C> > mapSelect(C& coll) {
@@ -218,23 +259,26 @@ namespace dd4hep {
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename C> inline ConditionsOperation<ActiveSelect<C> > activeSelect(C& coll)
{ return ConditionsOperation<ActiveSelect<C> >(ActiveSelect<C>(coll)); }
- /// Helper to select keyed objects from a conditions pool
+ /// Helper to create functor to select keyed objects from a conditions pool
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
template <typename C> inline
ConditionsOperation<KeyedSelect<C> > keyedSelect(Condition::key_type key, C& coll)
{ return ConditionsOperation<KeyedSelect<C> >(KeyedSelect<C>(key, coll)); }
- /// Helper to find conditions objects by hash key
+ /// Helper to create functor to find conditions objects by hash key
/**
* \author M.Frank
* \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
*/
ConditionsOperation<KeyFind> inline keyFind(Condition::key_type key)
{ return ConditionsOperation<KeyFind>(KeyFind(key)); }
diff --git a/DDCond/include/DDCond/ConditionsTextRepository.h b/DDCond/include/DDCond/ConditionsTextRepository.h
index 3bb0ff53899f320565e8a19da19b6a2b13dfba6a..d73edba378c00992a754c389de839851cf088805 100644
--- a/DDCond/include/DDCond/ConditionsTextRepository.h
+++ b/DDCond/include/DDCond/ConditionsTextRepository.h
@@ -33,13 +33,18 @@ namespace dd4hep {
/// Base class to be implemented by objects to listen on condition callbacks
/**
- *
* \author M.Frank
* \version 1.0
* \ingroup DD4HEP_CONDITIONS
*/
class ConditionsTextRepository {
public:
+ /// Definition of a single Entry in the conditions repository
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
class Entry {
public:
std::string name, address;
@@ -49,6 +54,8 @@ namespace dd4hep {
~Entry() = default;
Entry& operator=(const Entry& copy) = default;
};
+
+ /// Definition of the entry collection
typedef std::vector<Entry> Data;
public:
diff --git a/DDCond/include/DDCond/ConditionsTreePersistency.h b/DDCond/include/DDCond/ConditionsTreePersistency.h
new file mode 100644
index 0000000000000000000000000000000000000000..039050c734cc7f371b13c9967017994f180ba569
--- /dev/null
+++ b/DDCond/include/DDCond/ConditionsTreePersistency.h
@@ -0,0 +1,142 @@
+//==========================================================================
+// AIDA Detector description implementation
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// Author : M.Frank
+//
+//==========================================================================
+#ifndef DD4HEP_CONDITIONS_CONDITIONSTREEPERSISTENCY_H
+#define DD4HEP_CONDITIONS_CONDITIONSTREEPERSISTENCY_H
+
+// Framework/ROOT include files
+#include "DDCond/ConditionsPool.h"
+
+#include "TNamed.h"
+class TFile;
+
+// C/C++ include files
+#include <map>
+#include <list>
+#include <vector>
+#include <memory>
+
+
+/// Namespace for the AIDA detector description toolkit
+namespace dd4hep {
+
+ /// Namespace for implementation details of the AIDA detector description toolkit
+ namespace cond {
+
+ /// Forward declarations
+ class ConditionsSlice;
+ class ConditionsIOVPool;
+
+ /// Helper to save conditions pools to ROOT
+ /**
+ * This is a rathr simplistic persistency mechanism for conditions.
+ * It is not suited to actually store and retrieve individual conditions
+ * by key. Though it is rather efficient to store and retrive
+ * entire conditions snapshots of the conditions store implemented by DDCond.
+ * It e.g. allows to fast load the conditions store for HLT applications,
+ * of which we know it takes ages to populate it from a database.
+ *
+ * \author M.Frank
+ * \version 1.0
+ */
+ class ConditionsTreePersistency : public TNamed {
+ public:
+ typedef std::vector<Condition> pool_type;
+ typedef std::pair<std::string, pool_type> named_pool_type;
+ typedef std::pair<std::string,std::pair<std::pair<std::string,int>,IOV::Key> > iov_key_type;
+ typedef std::list<std::pair<iov_key_type, pool_type> > persistent_type;
+
+ persistent_type conditionPools;
+ persistent_type userPools;
+ persistent_type iovPools;
+ float duration;
+ enum ImportStrategy {
+ IMPORT_ALL = 1<<0,
+ IMPORT_EXACT = 1<<1,
+ IMPORT_CONTAINED = 1<<2,
+ IMPORT_CONTAINED_LOWER = 1<<3,
+ IMPORT_CONTAINED_UPPER = 1<<4,
+ IMPORT_EDGE_LOWER = 1<<5,
+ IMPORT_EDGE_UPPER = 1<<6,
+ LAST
+ };
+ /// Load ConditionsIOVPool and populate conditions manager
+ size_t _import(ImportStrategy strategy,
+ persistent_type& pers,
+ const std::string& id,
+ const std::string& iov_type,
+ const IOV::Key& iov_key,
+ ConditionsManager mgr);
+
+ /// Clear object content and release allocated memory
+ void _clear(persistent_type& pool);
+
+ public:
+ /// No copy constructor
+ ConditionsTreePersistency(const ConditionsTreePersistency& copy) = delete;
+ /// Initializing constructor
+ ConditionsTreePersistency(const std::string& name, const std::string& title="DD4hep conditions container");
+ /// Default constructor
+ ConditionsTreePersistency();
+ /// Default destructor
+ virtual ~ConditionsTreePersistency();
+ /// No assignment
+ ConditionsTreePersistency& operator=(const ConditionsTreePersistency& copy) = delete;
+
+ /// Clear object content and release allocated memory
+ void clear();
+ /// Open ROOT file in read mode
+ static TFile* openFile(const std::string& fname);
+
+ /// Add conditions content to be saved. Note, that dependent conditions shall not be saved!
+ size_t add(const std::string& identifier, const IOV& iov, std::vector<Condition>& conditions);
+ /// Add conditions content to be saved. Note, that dependent conditions shall not be saved!
+ size_t add(const std::string& identifier, ConditionsPool& pool);
+ /// Add conditions content to be saved. Note, that dependent conditions shall not be saved!
+ size_t add(const std::string& identifier, const UserPool& pool);
+ /// Add conditions content to be saved. Note, that dependent conditions shall not be saved!
+ size_t add(const std::string& identifier, const ConditionsIOVPool& pool);
+
+ /// Load conditions content from file.
+ static std::unique_ptr<ConditionsTreePersistency> load(TFile* file,const std::string& object);
+
+ /// Load conditions content from file.
+ static std::unique_ptr<ConditionsTreePersistency> load(const std::string& file,const std::string& object) {
+ return load(openFile(file), object);
+ }
+
+ /// Load conditions IOV pool and populate conditions manager
+ size_t importIOVPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
+ /// Load conditions user pool and populate conditions manager
+ size_t importUserPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
+ /// Load conditions pool and populate conditions manager
+ size_t importConditionsPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
+
+ /// Load conditions pool and populate conditions manager. Allow tro be selective also for the key
+ size_t importConditionsPool(ImportStrategy strategy,
+ const std::string& id,
+ const std::string& iov_type,
+ const IOV::Key& key,
+ ConditionsManager mgr);
+
+ /// Save the data content to a root file
+ int save(TFile* file);
+ /// Save the data content to a root file
+ int save(const std::string& file_name);
+
+ /// ROOT object ClassDef
+ ClassDef(ConditionsTreePersistency,1);
+ };
+
+ } /* End namespace cond */
+} /* End namespace dd4hep */
+#endif /* DD4HEP_CONDITIONS_CONDITIONSTREEPERSISTENCY_H */
diff --git a/DDCond/include/DDCond/Type1/Manager_Type1.h b/DDCond/include/DDCond/Type1/Manager_Type1.h
index 695a7bb64709c69ef939352e57426a493d3a7984..d45bab2bca18233b5587afad2d2731bbd152eed9 100644
--- a/DDCond/include/DDCond/Type1/Manager_Type1.h
+++ b/DDCond/include/DDCond/Type1/Manager_Type1.h
@@ -150,13 +150,13 @@ namespace dd4hep {
* This does not yet make the new conditions availible to the clients
*/
virtual void pushUpdates() final;
-
+#if 0
/// Retrieve a condition set given a Detector Element and the conditions name according to their validity (deprecated)
virtual Condition get(key_type key, const IOV& req_validity) final;
/// Retrieve a condition given a Detector Element and the conditions name (deprecated)
virtual RangeConditions getRange(key_type key, const IOV& req_validity) final;
-
+#endif
/// Create empty user pool object
virtual std::unique_ptr<UserPool> createUserPool(const IOVType* iovT) const;
diff --git a/DDCond/src/ConditionsDictionary.h b/DDCond/src/ConditionsDictionary.h
index bbd000c2ea5fde725f5967febe8323576990271a..404f817cf992441edb4c1cf011db286c9d3578ab 100644
--- a/DDCond/src/ConditionsDictionary.h
+++ b/DDCond/src/ConditionsDictionary.h
@@ -21,6 +21,7 @@
#include "DDCond/ConditionsManager.h"
#include "DDCond/ConditionsManagerObject.h"
#include "DDCond/ConditionsRootPersistency.h"
+#include "DDCond/ConditionsTreePersistency.h"
// -------------------------------------------------------------------------
// Regular dd4hep dictionaries
@@ -63,6 +64,7 @@ using namespace dd4hep;
//#pragma link C++ class std::list<cond::ConditionsRootPersistency::IOVPool>+;
#pragma link C++ class cond::ConditionsRootPersistency+;
+#pragma link C++ class cond::ConditionsTreePersistency+;
#endif
diff --git a/DDCond/src/ConditionsRootPersistency.cpp b/DDCond/src/ConditionsRootPersistency.cpp
index 4ac7bd3831fed2628e6998eb8c29bfd2a1967643..f3b48587732884a0275666221ae6096333275fba 100644
--- a/DDCond/src/ConditionsRootPersistency.cpp
+++ b/DDCond/src/ConditionsRootPersistency.cpp
@@ -21,6 +21,7 @@
#include "TTimeStamp.h"
typedef dd4hep::cond::ConditionsRootPersistency __ConditionsRootPersistency;
+/// ROOT Class implementation directive
ClassImp(__ConditionsRootPersistency)
@@ -28,7 +29,9 @@ using namespace std;
using namespace dd4hep;
using namespace dd4hep::cond;
+// Local namespace for anonymous stuff
namespace {
+
/// Helper to select conditions
/*
* \author M.Frank
diff --git a/DDCond/src/ConditionsTreePersistency.cpp b/DDCond/src/ConditionsTreePersistency.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23868711afdf538fe26bc4beb0a200efc8e76e0b
--- /dev/null
+++ b/DDCond/src/ConditionsTreePersistency.cpp
@@ -0,0 +1,317 @@
+//==========================================================================
+// AIDA Detector description implementation
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// Author : M.Frank
+//
+//==========================================================================
+
+// Framework include files
+#include "DD4hep/Printout.h"
+#include "DDCond/ConditionsSlice.h"
+#include "DDCond/ConditionsIOVPool.h"
+#include "DDCond/ConditionsTreePersistency.h"
+
+#include "TFile.h"
+#include "TTimeStamp.h"
+
+typedef dd4hep::cond::ConditionsTreePersistency __ConditionsTreePersistency;
+/// ROOT Class implementation directive
+ClassImp(__ConditionsTreePersistency)
+
+
+using namespace std;
+using namespace dd4hep;
+using namespace dd4hep::cond;
+
+// Local namespace for anonymous stuff
+namespace {
+
+ /// Helper to select conditions
+ /*
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
+ struct Scanner : public Condition::Processor {
+ ConditionsTreePersistency::pool_type& pool;
+ /// Constructor
+ Scanner(ConditionsTreePersistency::pool_type& p) : pool(p) {}
+ /// Conditions callback for object processing
+ virtual int process(Condition c) const override {
+ pool.push_back(c.ptr());
+ return 1;
+ }
+ };
+ struct DurationStamp {
+ TTimeStamp start;
+ ConditionsTreePersistency* object = 0;
+ DurationStamp(ConditionsTreePersistency* obj) : object(obj) {
+ }
+ ~DurationStamp() {
+ TTimeStamp stop;
+ object->duration = stop.AsDouble()-start.AsDouble();
+ }
+ };
+}
+
+/// Default constructor
+ConditionsTreePersistency::ConditionsTreePersistency() : TNamed() {
+}
+
+/// Initializing constructor
+ConditionsTreePersistency::ConditionsTreePersistency(const string& name, const string& title)
+ : TNamed(name.c_str(), title.c_str())
+{
+}
+
+/// Default destructor
+ConditionsTreePersistency::~ConditionsTreePersistency() {
+ clear();
+}
+
+/// Add conditions content to be saved. Note, that dependent conditions shall not be saved!
+size_t ConditionsTreePersistency::add(const std::string& identifier,
+ const IOV& iov,
+ std::vector<Condition>& conditions) {
+ DurationStamp stamp(this);
+ conditionPools.push_back(pair<iov_key_type, pool_type>());
+ pool_type& ent = conditionPools.back().second;
+ iov_key_type& key = conditionPools.back().first;
+ key.first = identifier;
+ key.second.first = make_pair(iov.iovType->name,iov.type);
+ key.second.second = iov.key();
+ ent = conditions;
+ for(auto c : ent) c.ptr()->addRef();
+ return ent.size();
+}
+
+/// Add conditions content to the saved. Note, that dependent conditions shall not be saved!
+size_t ConditionsTreePersistency::add(const string& identifier, ConditionsPool& pool) {
+ DurationStamp stamp(this);
+ conditionPools.push_back(pair<iov_key_type, pool_type>());
+ pool_type& ent = conditionPools.back().second;
+ iov_key_type& key = conditionPools.back().first;
+ const IOV* iov = pool.iov;
+ key.first = identifier;
+ key.second.first = make_pair(iov->iovType->name,iov->type);
+ key.second.second = iov->key();
+ pool.select_all(ent);
+ for(auto c : ent) c.ptr()->addRef();
+ return ent.size();
+}
+
+/// Add conditions content to the saved. Note, that dependent conditions shall not be saved!
+size_t ConditionsTreePersistency::add(const string& identifier, const ConditionsIOVPool& pool) {
+ size_t count = 0;
+ DurationStamp stamp(this);
+ for( const auto& p : pool.elements ) {
+ iovPools.push_back(pair<iov_key_type, pool_type>());
+ pool_type& ent = iovPools.back().second;
+ iov_key_type& key = iovPools.back().first;
+ const IOV* iov = p.second->iov;
+ key.first = identifier;
+ key.second.first = make_pair(iov->iovType->name,iov->type);
+ key.second.second = p.first;
+ p.second->select_all(ent);
+ for(auto c : ent) c.ptr()->addRef();
+ count += ent.size();
+ }
+ return count;
+}
+
+/// Add conditions content to the saved. Note, that dependent conditions shall not be saved!
+size_t ConditionsTreePersistency::add(const string& identifier, const UserPool& pool) {
+ DurationStamp stamp(this);
+ userPools.push_back(pair<iov_key_type, pool_type>());
+ pool_type& ent = userPools.back().second;
+ iov_key_type& key = userPools.back().first;
+ const IOV& iov = pool.validity();
+ key.first = identifier;
+ key.second.first = make_pair(iov.iovType->name,iov.type);
+ key.second.second = iov.key();
+ pool.scan(Scanner(ent));
+ for(auto c : ent) c.ptr()->addRef();
+ return ent.size();
+}
+
+/// Open ROOT file in read mode
+TFile* ConditionsTreePersistency::openFile(const string& fname) {
+ TDirectory::TContext context;
+ TFile* file = TFile::Open(fname.c_str());
+ if ( file && !file->IsZombie()) return file;
+ except("ConditionsTreePersistency","+++ FAILED to open ROOT file %s in read-mode.",fname.c_str());
+ return 0;
+}
+
+/// Clear object content and release allocated memory
+void ConditionsTreePersistency::_clear(persistent_type& pool) {
+ /// Cleanup all the stuff not useful....
+ for (auto& p : pool ) {
+ for(Condition c : p.second )
+ c.ptr()->release();
+ p.second.clear();
+ }
+ pool.clear();
+}
+
+/// Clear object content and release allocated memory
+void ConditionsTreePersistency::clear() {
+ /// Cleanup all the stuff not useful....
+ _clear(conditionPools);
+ _clear(userPools);
+ _clear(iovPools);
+}
+
+/// Add conditions content to the saved. Note, that dependent conditions shall not be saved!
+std::unique_ptr<ConditionsTreePersistency>
+ConditionsTreePersistency::load(TFile* file,const string& obj) {
+ std::unique_ptr<ConditionsTreePersistency> p;
+ if ( file && !file->IsZombie()) {
+ TTimeStamp start;
+ p.reset((ConditionsTreePersistency*)file->Get(obj.c_str()));
+ TTimeStamp stop;
+ if ( p.get() ) {
+ p->duration = stop.AsDouble()-start.AsDouble();
+ return p;
+ }
+ except("ConditionsTreePersistency",
+ "+++ FAILED to load object %s from file %s",
+ obj.c_str(), file->GetName());
+ }
+ except("ConditionsTreePersistency",
+ "+++ FAILED to load object %s from file [Invalid file]",obj.c_str());
+ return p;
+}
+
+/// Load ConditionsPool(s) and populate conditions manager
+size_t ConditionsTreePersistency::_import(ImportStrategy strategy,
+ persistent_type& persistent_pools,
+ const std::string& id,
+ const std::string& iov_type,
+ const IOV::Key& iov_key,
+ ConditionsManager mgr) {
+ size_t count = 0;
+ std::pair<bool,const IOVType*> iovTyp(false,0);
+ for (auto& iovp : persistent_pools ) {
+ bool use = false;
+ const iov_key_type& key = iovp.first;
+ if ( !(id.empty() || id=="*" || key.first == id) )
+ continue;
+ if ( !(iov_type.empty() || iov_type == "*" || key.second.first.first == iov_type) )
+ continue;
+ switch(strategy) {
+ case IMPORT_ALL:
+ use = true;
+ break;
+ case IMPORT_EXACT:
+ use = key.second.second == iov_key;
+ break;
+ case IMPORT_CONTAINED:
+ use = IOV::key_is_contained(key.second.second,iov_key);
+ break;
+ case IMPORT_EDGE_LOWER:
+ use = IOV::key_overlaps_lower_end(key.second.second,iov_key);
+ break;
+ case IMPORT_EDGE_UPPER:
+ use = IOV::key_overlaps_higher_end(key.second.second,iov_key);
+ break;
+ case IMPORT_CONTAINED_LOWER:
+ use = IOV::key_is_contained(key.second.second,iov_key) ||
+ IOV::key_overlaps_lower_end(key.second.second,iov_key);
+ break;
+ case IMPORT_CONTAINED_UPPER:
+ use = IOV::key_is_contained(key.second.second,iov_key) ||
+ IOV::key_overlaps_higher_end(key.second.second,iov_key);
+ break;
+ default:
+ use = false;
+ break;
+ }
+ if ( !use )
+ continue;
+
+ iovTyp = mgr.registerIOVType(key.second.first.second,key.second.first.first);
+ if ( iovTyp.second ) {
+ ConditionsPool* pool = mgr.registerIOV(*iovTyp.second, key.second.second);
+ for (Condition c : iovp.second) {
+ Condition::Object* o = c.ptr();
+ o->iov = pool->iov;
+ if ( pool->insert(o->addRef()) ) {
+ //printout(WARNING,"ConditionsTreePersistency","%p: [%016llX] %s -> %s",
+ // o, o->hash,o->GetName(),o->data.str().c_str());
+ ++count;
+ }
+ else {
+ printout(WARNING,"ConditionsTreePersistency",
+ "+++ Ignore condition %s from %s iov:%s [Already present]",
+ c.name(),id.c_str(), iov_type.c_str());
+ }
+ }
+ }
+ }
+ return count;
+}
+
+/// Load ConditionsIOVPool and populate conditions manager
+size_t ConditionsTreePersistency::importIOVPool(const std::string& identifier,
+ const std::string& iov_type,
+ ConditionsManager mgr)
+{
+ DurationStamp stamp(this);
+ return _import(IMPORT_ALL,iovPools,identifier,iov_type,IOV::Key(),mgr);
+}
+
+/// Load ConditionsIOVPool and populate conditions manager
+size_t ConditionsTreePersistency::importUserPool(const std::string& identifier,
+ const std::string& iov_type,
+ ConditionsManager mgr)
+{
+ DurationStamp stamp(this);
+ return _import(IMPORT_ALL,userPools,identifier,iov_type,IOV::Key(),mgr);
+}
+
+/// Load ConditionsIOVPool and populate conditions manager
+size_t ConditionsTreePersistency::importConditionsPool(const std::string& identifier,
+ const std::string& iov_type,
+ ConditionsManager mgr)
+{
+ DurationStamp stamp(this);
+ return _import(IMPORT_ALL,conditionPools,identifier,iov_type,IOV::Key(),mgr);
+}
+
+/// Load conditions pool and populate conditions manager. Allow tro be selective also for the key
+size_t ConditionsTreePersistency::importConditionsPool(ImportStrategy strategy,
+ const std::string& identifier,
+ const std::string& iov_type,
+ const IOV::Key& iov_key,
+ ConditionsManager mgr) {
+ return _import(strategy,conditionPools,identifier,iov_type,iov_key,mgr);
+}
+
+/// Save the data content to a root file
+int ConditionsTreePersistency::save(TFile* file) {
+ DurationStamp stamp(this);
+ //TDirectory::TContext context;
+ int nBytes = file->WriteTObject(this,GetName());
+ return nBytes;
+}
+
+/// Save the data content to a root file
+int ConditionsTreePersistency::save(const string& fname) {
+ DurationStamp stamp(this);
+ //TDirectory::TContext context;
+ TFile* file = TFile::Open(fname.c_str(),"RECREATE");
+ if ( file && !file->IsZombie()) {
+ int nBytes = save(file);
+ file->Close();
+ delete file;
+ return nBytes;
+ }
+ return -1;
+}
diff --git a/DDCond/src/Type1/Manager_Type1.cpp b/DDCond/src/Type1/Manager_Type1.cpp
index ff252ec7fd16c1f1ed09ce58f5d5fea2cd388c8e..5a0a3d28778b86f2094ae204b51ae6aaebc2fcb7 100644
--- a/DDCond/src/Type1/Manager_Type1.cpp
+++ b/DDCond/src/Type1/Manager_Type1.cpp
@@ -375,7 +375,7 @@ bool Manager_Type1::select_range(Condition::key_type key,
}
return is_range_complete(req_validity,conditions);
}
-
+#if 0
/// Retrieve a condition given a Detector Element and the conditions name
Condition
Manager_Type1::get(Condition::key_type key, const IOV& iov)
@@ -437,6 +437,7 @@ Manager_Type1::getRange(Condition::key_type key, const IOV& iov)
}
return conditions;
}
+#endif
/// Prepare all updates for the given keys to the clients with the defined IOV
ConditionsManager::Result
diff --git a/DDCond/src/plugins/ConditionsMultiLoader.cpp b/DDCond/src/plugins/ConditionsMultiLoader.cpp
index 9df7320c595c59ed8ac8e31a34c81bab1e3e799d..d8a2bbd48f775f4fa7dbd77a17a690557866855d 100644
--- a/DDCond/src/plugins/ConditionsMultiLoader.cpp
+++ b/DDCond/src/plugins/ConditionsMultiLoader.cpp
@@ -47,6 +47,7 @@ namespace dd4hep {
ConditionsMultiLoader(Detector& description, ConditionsManager mgr, const std::string& nam);
/// Default destructor
virtual ~ConditionsMultiLoader();
+#if 0
/// Load a condition set given a Detector Element and the conditions name according to their validity
virtual size_t load_single(key_type key,
const IOV& req_validity,
@@ -55,6 +56,7 @@ namespace dd4hep {
virtual size_t load_range( key_type key,
const IOV& req_validity,
RangeConditions& conditions);
+#endif
/// Optimized update using conditions slice data
virtual size_t load_many( const IOV& /* req_validity */,
RequiredItems& /* work */,
@@ -146,7 +148,7 @@ ConditionsMultiLoader::load_source(const std::string& nam,
}
return (*iop).second;
}
-
+#if 0
/// Load a condition set given a Detector Element and the conditions name according to their validity
size_t ConditionsMultiLoader::load_range(key_type key,
const IOV& req_validity,
@@ -186,3 +188,4 @@ size_t ConditionsMultiLoader::load_single(key_type key,
}
return conditions.size() - len;
}
+#endif
diff --git a/DDCore/include/DD4hep/DD4hepRootPersistency.h b/DDCore/include/DD4hep/DD4hepRootPersistency.h
index 58c0b6cba96184b6e1c376757325ffcc591ef5b0..6f4b1a37a03b43dd51c61a6cff424a0464ead812 100644
--- a/DDCore/include/DD4hep/DD4hepRootPersistency.h
+++ b/DDCore/include/DD4hep/DD4hepRootPersistency.h
@@ -17,6 +17,11 @@
#include "DD4hep/DetectorData.h"
/// Helper class to support ROOT persistency of Detector objects
+/**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CORE
+ */
class DD4hepRootPersistency : public TNamed {
public:
typedef std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> > HandleMap;
@@ -81,6 +86,12 @@ public:
ClassDef(DD4hepRootPersistency,1);
};
+/// Helper class to check various ingredients of the Detector object after loaded from ROOT
+/**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CORE
+ */
class DD4hepRootCheck {
public:
/// Reference to the detector model object
@@ -125,5 +136,4 @@ public:
size_t checkAll() const;
};
-
#endif /* DD4HEP_DD4HEPROOTPERSISTENCY_H */
diff --git a/DDCore/include/DD4hep/Primitives.h b/DDCore/include/DD4hep/Primitives.h
index a368fc46e9890db6e4251eed3242485e1e2514ad..078d680bcb14103a9fe04ac67fa73a6904d3efbb 100644
--- a/DDCore/include/DD4hep/Primitives.h
+++ b/DDCore/include/DD4hep/Primitives.h
@@ -276,6 +276,12 @@ namespace dd4hep {
};
#endif
+ /// Operator to clear containers when out of scope
+ /**
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CORE
+ */
template<typename C> struct ClearOnReturn {
C& container;
ClearOnReturn(C& c) : container(c) { }
diff --git a/DDG4/include/DDG4/Geant4HitCollection.h b/DDG4/include/DDG4/Geant4HitCollection.h
index 31a00fd9d953296b98ff77675cce69d62892c4b5..ccbb19509ab29d43741d7f8360daee55ab4e1616 100644
--- a/DDG4/include/DDG4/Geant4HitCollection.h
+++ b/DDG4/include/DDG4/Geant4HitCollection.h
@@ -105,6 +105,7 @@ namespace dd4hep {
typedef HitManipulator::Wrapper Wrapper;
protected:
+ /// Wrapper data
mutable Wrapper m_data;
public:
@@ -224,8 +225,11 @@ namespace dd4hep {
virtual void* operator()(const Geant4HitWrapper& w) const = 0;
};
+ /// Union defining the hit collection flags for processing
union CollectionFlags {
+ /// Full value
unsigned long value;
+ /// Individual hit collection bits
struct BitItems {
unsigned repeatedLookup:1;
unsigned mappedLookup:1;
@@ -259,6 +263,7 @@ namespace dd4hep {
void getData(const ComponentCast& cast, std::vector<void*>* result);
public:
+ /// Enumeration for collection optimization types
enum OptimizationFlags {
OPTIMIZE_NONE = 0,
OPTIMIZE_REPEATEDLOOKUP = 1<<0,
diff --git a/DDG4/include/DDG4/Geant4Hits.h b/DDG4/include/DDG4/Geant4Hits.h
index ad1772d320f06712e7c2ec488ead9650a0393f4b..7e53ee0a041dbb722768398913a8078f2e1e6318 100644
--- a/DDG4/include/DDG4/Geant4Hits.h
+++ b/DDG4/include/DDG4/Geant4Hits.h
@@ -55,6 +55,7 @@ namespace dd4hep {
* @version 1.0
*/
template <class HIT> struct HitPositionCompare: public HitCompare<HIT> {
+ /// Reference to the hit position
const Position& pos;
/// Constructor
HitPositionCompare(const Position& p) : pos(p) {}
@@ -143,7 +144,7 @@ namespace dd4hep {
double length;
/// Monte Carlo / Geant4 information
Contribution truth;
-
+ /// Energy deposit of the hit
double energyDeposit;
public:
diff --git a/DDG4/plugins/Geant4EventReaderHepMC.cpp b/DDG4/plugins/Geant4EventReaderHepMC.cpp
index 7ee8d7701611aae57849db52c2d2192a8b9f2eb0..47dfbeb5ac598ec03392540aecd98049c6ed42c2 100644
--- a/DDG4/plugins/Geant4EventReaderHepMC.cpp
+++ b/DDG4/plugins/Geant4EventReaderHepMC.cpp
@@ -23,7 +23,12 @@ namespace dd4hep {
/// Namespace for the Geant4 based simulation part of the AIDA detector description toolkit
namespace sim {
- namespace HepMC { class EventStream; }
+ /// HepMC namespace declaration
+ namespace HepMC {
+ /// HepMC EventStream class used internally by the Geant4EventReaderHepMC plugin
+ class EventStream;
+ }
+
/// Class to populate Geant4 primaries from StdHep files.
/**
* Class to populate Geant4 primary particles and vertices from a
@@ -89,8 +94,16 @@ namespace dd4hep {
/// Namespace for the Geant4 based simulation part of the AIDA detector description toolkit
namespace sim {
+ /// HepMC namespace declaration
namespace HepMC {
+ /// HepMC EventHeader class used internally by the Geant4EventReaderHepMC plugin
+ /*
+ * \author P.Kostka (main author)
+ * \author M.Frank (code reshuffeling into new DDG4 scheme)
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
class EventHeader {
public:
int id;
@@ -103,6 +116,7 @@ namespace dd4hep {
float alpha_qed;
vector<float> weights;
vector<long> random;
+ /// Default constructor
EventHeader() : id(0), num_vertices(0), bp1(0), bp2(0),
signal_process_id(0), signal_process_vertex(0),
scale(0.0), alpha_qcd(0.0), alpha_qed(0.0), weights(), random() {}
@@ -111,6 +125,13 @@ namespace dd4hep {
/// The known_io enum is used to track which type of input is being read
enum known_io { gen=1, ascii, extascii, ascii_pdt, extascii_pdt };
+ /// HepMC EventStream class used internally by the Geant4EventReaderHepMC plugin
+ /*
+ * \author P.Kostka (main author)
+ * \author M.Frank (code reshuffeling into new DDG4 scheme)
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
class EventStream {
public:
typedef std::map<int,Geant4Vertex*> Vertices;
@@ -128,7 +149,7 @@ namespace dd4hep {
Vertices m_vertices;
Particles m_particles;
-
+ /// Default constructor
EventStream(istream& in) : instream(in), mom_unit(0.0), pos_unit(0.0),
io_type(0), xsection(0.0), xsection_err(0.0)
{ use_default_units(); }
diff --git a/DDG4/plugins/Geant4EventSeed.cpp b/DDG4/plugins/Geant4EventSeed.cpp
index 65960cbdda39f8dd9c62e8ce887d43bb35692ab6..3e253136d6f8df4c72efc3f9b264162afbaad074 100644
--- a/DDG4/plugins/Geant4EventSeed.cpp
+++ b/DDG4/plugins/Geant4EventSeed.cpp
@@ -11,8 +11,8 @@
//
//=========================================================================
-//Class include file
-#include "DDG4/Geant4EventSeed.h"
+// Class include file
+#include "Geant4EventSeed.h"
// Framework include files
#include "DD4hep/InstanceCount.h"
diff --git a/DDG4/include/DDG4/Geant4EventSeed.h b/DDG4/plugins/Geant4EventSeed.h
similarity index 98%
rename from DDG4/include/DDG4/Geant4EventSeed.h
rename to DDG4/plugins/Geant4EventSeed.h
index 6921989691ce33f146455a47015545788ccfc307..0114affedc9dbcd03913b2e8bb51cb3529fcafff 100644
--- a/DDG4/include/DDG4/Geant4EventSeed.h
+++ b/DDG4/plugins/Geant4EventSeed.h
@@ -22,6 +22,7 @@ namespace dd4hep {
/// Namespace for the Geant4 based simulation part of the AIDA detector description toolkit
namespace sim {
+ /// Plugin class to set the event seed for each event
/**
* \addtogroup Geant4RunActions
* @{
@@ -34,6 +35,7 @@ namespace dd4hep {
*
* \author A.Sailer
* \version 1.0
+ * \ingroup DD4HEP_SIMULATION
* @}
*/
class Geant4EventSeed: public Geant4RunAction {
diff --git a/DDG4/plugins/Geant4ExtraParticles.h b/DDG4/plugins/Geant4ExtraParticles.h
index ed40998e6e8125ef6f4ee88bd486e180b42adb4d..46575e820f93c79efdc02fc85ecbf617020e6373 100644
--- a/DDG4/plugins/Geant4ExtraParticles.h
+++ b/DDG4/plugins/Geant4ExtraParticles.h
@@ -21,6 +21,12 @@ namespace dd4hep {
/// Namespace for the Geant4 based simulation part of the AIDA detector description toolkit
namespace sim {
+ /// Plugin class to read non-standard particle definitions from text file
+ /**
+ * \author A.Sailer
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
class Geant4ExtraParticles : public Geant4PhysicsConstructor {
public:
/// Standard constructor with initailization parameters
diff --git a/DDG4/src/Geant4Exec.cpp b/DDG4/src/Geant4Exec.cpp
index ec8c721e05b106020518d591dad68d94a78e3e3e..27f9cd15439ac4f445d5e5cd84a36a5ecb011a9f 100644
--- a/DDG4/src/Geant4Exec.cpp
+++ b/DDG4/src/Geant4Exec.cpp
@@ -57,6 +57,11 @@ namespace dd4hep {
namespace sim {
/// Sequence handler implementing common actions to all sequences.
+ /** @class SequenceHdl
+ *
+ * @author M.Frank
+ * @version 1.0
+ */
template <typename T> class SequenceHdl {
public:
typedef SequenceHdl<T> Base;
@@ -66,42 +71,52 @@ namespace dd4hep {
SequenceHdl()
: m_sequence(0), m_activeContext(0) {
}
+ /// Initializing constructor
SequenceHdl(Geant4Context* ctxt, T* seq) : m_sequence(0), m_activeContext(ctxt) {
_aquire(seq);
}
+ /// Default destructor
virtual ~SequenceHdl() {
_release();
}
+ /// Aquire object reference
void _aquire(T* s) {
InstanceCount::increment(this);
m_sequence = s;
if ( m_sequence ) m_sequence->addRef();
}
+ /// Release object
+ void _release() {
+ detail::releasePtr(m_sequence);
+ InstanceCount::decrement(this);
+ }
+ /// Update Geant4Context for current call
void updateContext(Geant4Context* ctxt) {
m_activeContext = ctxt;
if ( m_sequence ) {
m_sequence->updateContext(ctxt);
}
}
- void _release() {
- detail::releasePtr(m_sequence);
- InstanceCount::decrement(this);
- }
+ /// Access reference to the current active Geant4Context structure
Geant4Context* context() const {
return m_activeContext;
}
+ /// Access reference to the current active Geant4Kernel structure
Geant4Kernel& kernel() const {
return context()->kernel();
}
+ /// G4 callback in multi threaded mode to configure thread fiber
void configureFiber(Geant4Context* ctxt) {
if ( m_sequence ) {
m_sequence->configureFiber(ctxt);
}
}
+ /// Create Geant4 run context
void createClientContext(const G4Run* run) {
Geant4Run* r = new Geant4Run(run);
m_activeContext->setRun(r);
}
+ /// Destroy Geant4 run context
void destroyClientContext(const G4Run*) {
Geant4Run* r = m_activeContext->runPtr();
if ( r ) {
@@ -109,10 +124,12 @@ namespace dd4hep {
detail::deletePtr(r);
}
}
+ /// Create Geant4 event context
void createClientContext(const G4Event* evt) {
Geant4Event* e = new Geant4Event(evt,Geant4Random::instance());
m_activeContext->setEvent(e);
}
+ /// Destroy Geant4 event context
void destroyClientContext(const G4Event*) {
Geant4Event* e = m_activeContext->eventPtr();
if ( e ) {
@@ -122,6 +139,7 @@ namespace dd4hep {
}
};
+ /// Forward declarations
class Geant4UserRunAction;
class Geant4UserEventAction;
@@ -480,11 +498,24 @@ using namespace dd4hep::sim;
#include "G4RunManager.hh"
#include "G4PhysListFactory.hh"
+
+/// Compatibility actions for running Geant4 in single threaded mode
+/** @class Geant4Compatibility
+ *
+ * @author M.Frank
+ * @version 1.0
+ */
class Geant4Compatibility {
public:
- Geant4Compatibility() {}
+ /// Default constructor
+ Geant4Compatibility() = default;
+ /// Default destructor
+ virtual ~Geant4Compatibility() = default;
+ /// Detector construction invocation in compatibility mode
Geant4DetectorConstructionSequence* buildDefaultDetectorConstruction(Geant4Kernel& kernel);
};
+
+/// Detector construction invocation in compatibility mode
Geant4DetectorConstructionSequence* Geant4Compatibility::buildDefaultDetectorConstruction(Geant4Kernel& kernel) {
Geant4Action* cr;
Geant4DetectorConstruction* det_cr;
diff --git a/doc/LaTex/DDCond-ConditionsAccess.png b/doc/LaTex/DDCond-ConditionsAccess.png
index 36e4170d9a470233e1b7848349f336a7fa116998..b49966249b514c3a6f23ba1b0647a280c543153a 100644
Binary files a/doc/LaTex/DDCond-ConditionsAccess.png and b/doc/LaTex/DDCond-ConditionsAccess.png differ
diff --git a/doc/LaTex/DDConditionsManual.tex b/doc/LaTex/DDConditionsManual.tex
index c5d8d6ddc847c3055d55d9d5c636b28e5112543f..97129c57480bce7952e0b3e37d964f186c2635fa 100644
--- a/doc/LaTex/DDConditionsManual.tex
+++ b/doc/LaTex/DDConditionsManual.tex
@@ -97,7 +97,7 @@ time-dependent and typically called $conditons$. The ability of an
experiment to produce correct and timely results depends on the complete
and efficient availability of needed conditions for each stage of data
handling. This manual should introduce to the \DDC toolkit, which provides
-access to conditions data within the \DDH data structures.
+access to conditions data within the \DDH data structures~\cite{bib:dd4hep-manual}.
\noindent
The \DDC extensions to the \DDH toolkit formalize both the access and
@@ -113,8 +113,12 @@ For this reason \DDC does not attempt to solve the persistency problem,
but rather defines an interface used to load missing data items from the
persistent medium. Any persistent data representation, which can fulfill
the requirements of this interface may be adopted by the \DDC
-conditions caching and access mechanism. For details please see
-section~\ref{sec:ddcond-user-interface}.
+conditions caching and access mechanism.
+
+\noindent
+At the end of this manual a walk-through of an example is discussed to
+illustrate, which steps have to be performed to use the \DDH conditions
+store within a client application.
%=============================================================================
\subsection{Definition of Conditions Data}
@@ -122,7 +126,7 @@ section~\ref{sec:ddcond-user-interface}.
%=============================================================================
\noindent
Conditions data are firstly
-\begin{itemize}
+\begin{itemize}\itemcompact
\item raw data values. Raw data values are recorded from measurement
devices such as
thermometers, pressure devices or
@@ -198,7 +202,7 @@ conditions slices as described in section~\ref{subsec:ddcond-conditions-slices}.
\noindent
A conditions objects serves two purposes:
-\begin{itemize}
+\begin{itemize}\itemcompact
\item Firstly, it supports the basic functionality which is generic to any
condition -- independent of the actual user payload. This information
includes access to the interval of validity and the key to uniquely identify
@@ -208,11 +212,11 @@ A conditions objects serves two purposes:
conditions data. These data are freely user defined. An automatic
parsing mechanism from a string representation is supported if the
payload-class can properly described using a boost::spirit
- parsing structure. Default types are defined for
- \begin{itemize}
+ parsing structure. Default type implementations are defined for
+ \begin{itemize}\itemcompact
\item all primitive data types,
\item ROOT::Math::XYZVector, ROOT::Math::XYZPoint, ROOT::Math::PxPyPzEVector.
- \item a number of STL containers thereof:\\
+ \item a number of STL containers of the above basic data types:\\
std::vector\textless TYPE\textgreater,
std::list\textless TYPE\textgreater,
std::set\textless TYPE\textgreater,\\
@@ -220,15 +224,18 @@ A conditions objects serves two purposes:
std::map\textless string,TYPE\textgreater,\\
std::pair\textless int,TYPE\textgreater,
std::pair\textless string,TYPE\textgreater.
- \end{itemize}
-
+ \end{itemize}
+ Additional types can easily be implemented using boost::spirit if the basic
+ representation is in the form of a string. Dummy boost::spirit parsers
+ may be implemented if the conversion to and from strings is not required.
\item Thirdly, it supports the basic functionality required by a
conditions management framework, which implements the $ConditionsMap$
interface.
\end{itemize}
For completeness we include here the basic data access methods of the conditions
-class:
-\vspace{-0.2cm}
+class\\
+(see \detdesc{classdd4hep_1_1_condition.html}{DD4hep/Conditions.h}):
+\vspace{-0.4cm}
\begin{unnumberedcode}
class Condition: public Handle<detail::ConditionObject> {
/** Interval of validity */
@@ -311,7 +318,7 @@ allow tools or clients to interact with conditions of a given slice.
This interface defines the interaction of clients with a conditions slice.
These interactions cover both the data access and the data management
within a slice. The interface allows to
-\begin{itemize}
+\begin{itemize}\itemcompact
\item access individual conditions by the detector element
and a given item key. The interface allows
\item to scan conditions according to the detector element or
@@ -357,7 +364,7 @@ has the following entry points:
\end{unnumberedcode}
Such $ConditionsMap$ implementations can easily be constructed using standard
STL maps. The lookup key is constructed out of two elements:
-\begin{itemize}
+\begin{itemize}\itemcompact
\item The detector element this condition belongs to and
\item an identifier of condition within this detector element.
\end{itemize}
@@ -377,6 +384,11 @@ this user interface is the $ConditionsSlice$ implemented in the
\label{subsec:ddcond-conditions-store}
%=============================================================================
+\noindent
+The $ConditionsMap$ interface allows tools to work with various conditions
+data stores. \DDC provides an efficient implementation of such a store,
+which is described in the following chapters.
+
%=============================================================================
\subsection{Data Organization}
\label{subsec:ddcond-internal-data-organization}
@@ -396,6 +408,15 @@ and not necessarily resemble to values in seconds or fractions thereof.
Time stamps could as well be formulated as an interval of luminosity sections,
run numbers, fill numbers or entire years.
+%=============================================================================
+\begin{figure}[t]
+ \begin{center}\includegraphics[height=11cm] {DDCond-ConditionsStore.png}
+ \caption{The graphical representation of the organisation of the
+ conditions data in \DDH. }
+ \label{fig:ddcond-data-organization}
+ \end{center}
+\end{figure}
+
\noindent
Groups of parameters associated to certain intervals of validity can
be very effectively managed if pooled together according to the
@@ -415,17 +436,6 @@ Users can organize data according to certain types, These types are
independently managed and subdivided into pools. Each of these pools
manages a set of conditions items sharing the same interval ov validity.
-%=============================================================================
-\begin{figure}[h]
- \begin{center}\includegraphics[height=10cm] {DDCond-ConditionsStore.png}
- \caption{The graphical representation of the organisation of the
- conditions data in \DDH. }
- \label{fig:ddcond-data-organization}
- \end{center}
-\end{figure}
-\vspace{-0.5cm}
-
-
\noindent
The internal organization of the conditions data in \DDC is entirely
transparent to the user. The description here is contained for
@@ -441,31 +451,79 @@ these fairly straight forward using a suited approach.
\noindent
As defined in section~\ref{subsec:ddcond-conditions-slices}, the conditions slice
-id the main entity to project conditions suitable to process a given particle
-collision. As shown also in Figure~\ref{fig:ddcond-slice-usage}, there are
+is the main entity to project conditions suitable to process a given particle
+collision (see \detdesc{classdd4hep_1_1cond_1_1_conditions_content.html}{DDCond/ConditionsContent.h} for details).
+As shown also in Figure~\ref{fig:ddcond-slice-usage}, there are
several steps to be performed before a conditions slice is ready to be used:
-\begin{enumerate}
+\begin{enumerate}\itemcompact
\item Create the conditions data slice.
-\item Setting up the data content of the slice.
+\item Setting up the data content of the slice by attaching an object of type
+ $ConditionsContent$.
\item Preparing the conditions data slice.
\item Using the conditions data slice.
\end{enumerate}
-NEED TO MENTION ConditionsContent
+\noindent
+The $ConditionsContent$ (see \detdesc{classdd4hep_1_1cond_1_1_conditions_slice.html}{DDCond/ConditionsSlice.h} for details)
+is a simple object, which contains load addresses
+to identify persistent conditions within the database/persistent schema
+used and a set of dependency rules to compute the corresponding derived conditions.
%=============================================================================
\begin{figure}[h]
\begin{center}\includegraphics[width=15cm] {DDCond-ConditionsAccess.png}
- \caption{The interaction of a particular user with the conditions
- data store using the $ConditionsManager$ interface.}
+ \caption{The interaction of a user with the conditions
+ data store using the $ConditionsSlice$ and the
+ $ConditionsManager$ interface to define the conditions content,
+ prepare the data and then access the loaded data from the slice
+ projected according to the required interval of validity.}
\label{fig:ddcond-slice-usage}
\end{center}
\end{figure}
\vspace{-0.5cm}
+\noindent
+The $ConditionsSlice$ holds a consistent set of conditions valid for a given
+interval of validity, which is the intersection of the intervals of
+validity of all contained conditions. The has the following consequences
+for the client when using a prepared $ConditionsSlice$:
+\begin{itemize}
+\item $ConditionsSlice$ objects are prepared by the client framework.
+ Specific algorithms and other code fragments developed by physicist users
+ should not deal with such activities. In multi-threaded applications
+ the preparation of a $ConditionsSlice$ may be done in a separate thread.
+\item Once prepared, the slice nor the contained conditions may be altered.
+ All contained conditions must be considered read-only.
+\item Since the slice is considered read-only, it can be used by multiple
+ clients simultaneously. In particular, multiple threads may share
+ the same slice.
+\item A $ConditionsSlice$ may only be re-used and prepared according to
+ a different interval of validity once no other clients use it.
+\item At any point of time any number of $ConditionsSlice$ objects
+ may be present in the client framework. There is no interference
+ as long as the above mentioned requirements are fulfilled.
+\end{itemize}
+
+\noindent
+The fact that multiple instances of the conditions slices may be present
+as well as the fact that the preparation of slices and their use is strictly
+separated makes then ideal for the usage within multi-threaded event
+processing frameworks. As shown in
+figure~\ref{fig:ddcond-multi-threaded-processing},
+the following use cases can easily be met:
+\begin{itemize}
+\item Mulitple threads may share the same slice while processing event data
+ (thread 1-3) as long as the time stamp of the event data processed
+ by each thread is contained in the interval of validity of the
+ slice.
+\item At the same time another thread may process event data with a different
+ time stamp. The conditions for this event were prepared using another slice
+ (thread 4-N).
+\end{itemize}
+
%=============================================================================
-\begin{figure}[h]
+\begin{figure}[t]
\begin{center}\includegraphics[width=15cm] {DDCond-ConditionsMT.png}
\caption{MT.}
\label{fig:ddcond-multi-threaded-processing}
@@ -473,33 +531,104 @@ NEED TO MENTION ConditionsContent
\end{figure}
\vspace{-0.5cm}
-\newpage
+
%=============================================================================
-\section{The User Interface}
-\label{sec:ddcond-user-interface}
+\subsection{Loading Conditions Data}
+\label{subsec:ddcond-data-loading}
%=============================================================================
+\noindent
+The loading of conditions data is highly experiment specific. Different
+access patterns and load implementations (single threaded, multi-threaded, locking etc.)
+make it close to impossible to implement any solution fitting all needs.
+For this reason the loading of conditions is deferred to an abstract implementation,
+which is invoked during the preparation phase of a conditions slice if the required
+data are not found in the conditions cache. This data loader interface
+(see \detdesc{classdd4hep_1_1cond_1_1_conditions_data_loader.html}{ConditionsDataLoader.h}
+for details), receives all relevant callbacks from the framework to resolve
+missing conditions and pass the loaded objects to the framework for the management.
+The callback to be implemented by the framework developers are:
+\begin{unnumberedcode}
+/// Interface for a generic conditions loader
+/**
+ * Common function for all loader.
+ */
+class ConditionsDataLoader : public NamedObject, public PropertyConfigurable {
+ typedef Condition::key_type key_type;
+ typedef std::map<key_type,Condition> LoadedItems;
+ typedef std::vector<std::pair<key_type,ConditionsLoadInfo*> > RequiredItems;
+public:
+ ....
+ /// Load a number of conditions items from the persistent medium according to the required IOV
+ virtual size_t load_many( const IOV& req_validity,
+ RequiredItems& work,
+ LoadedItems& loaded,
+ IOV& combined_validity) = 0;
+};
+\end{unnumberedcode}
+The arguments to the callback contain the necessary information to retrieve
+the requested items.
+
+\newpage
%=============================================================================
-\subsection{Conditions Data Classes}
-\label{subsec:ddcond-data-classes}
+\section{Example Walkthrough}
+\label{sec:ddcond-example}
%=============================================================================
%=============================================================================
-\subsection{ConditionsSlice}
-\label{subsec:ddcond-data-classes}
+\subsection{Example to Load and Prepare Conditions(Slices)}
+\label{subsec:ddcond-example-loading}
%=============================================================================
\noindent
-The ConditionsSlice a Concrete inmplementation of the ConditonsMap Interface.
-bla bla
+To illustrate the usage of the \DDC package an example is discussed here in detail.
+The full example is part of the conditions unit tests and can be found in the
+\DDH examples.\\
+(See examples/Conditions/src/ConditionExample\_manual.cpp).
+
+\noindent
+The examples uses conditions names and detector element names explicitly and
+hence requires a fixed detector description being loaded in memory.
+For simplicity we use here the Minitel example from the example/ClientTests.
+
+\begin{code}
+ description.fromXML("examples/ClientTests/compact/MiniTel.xml");
+ description.apply("DD4hep_ConditionsManagerInstaller",0,(char**)0);
+
+ ConditionsManager manager = ConditionsManager::from(description);
+ manager["PoolType"] = "DD4hep_ConditionsLinearPool";
+ manager["UserPoolType"] = "DD4hep_ConditionsMapUserPool";
+ manager["UpdatePoolType"] = "DD4hep_ConditionsLinearUpdatePool";
+ manager["LoaderType"] = "root";
+ manager.initialize();
+
+ shared_ptr<ConditionsContent> content(new ConditionsContent());
+ shared_ptr<ConditionsSlice> slice(new ConditionsSlice(manager,content));
+
+ \end{code}
+
+\noindent
+{\bf{Explanation:}} \\
+\begin{tabular} {l||p{0cm}}
+\docline{Line}{}
+\docline{1}{Load the MiniTel detector description using the compact notation.}
+\docline{2}{Install the conditions manager implementation using the plugin mechanism.}
+\docline{4}{Access conditions manager instance from the Detector interface.}
+\docline{5-8}{Configure the properties of the conditions manager.}
+\docline{9}{Initialize the conditions manager instance.}
+\docline{11-12}{Create empty $ConditionsSlice$ and $ConditionsContent$ instances.}
+\docline{14}{}
+
+\end{tabular}
+
+
+TO BE COMPLETED!
+
\newpage
%=============================================================================
\begin{thebibliography}{9}
-\bibitem{bib:LHCb-geometry} S. Ponce et al.,
- "Detector Description Framework in LHCb",
- International Conference on Computing in High Energy and Nuclear Physics (CHEP 2003),
- La Jolla, CA, 2003, proceedings.
+\bibitem{bib:dd4hep-manual} M.Frank, \DDH manual.
\bibitem{bib:ddalign-manual} M.Frank, \DDA manual.
\end{thebibliography}
%=============================================================================
diff --git a/doc/doxygen/Geant4Classes.h b/doc/doxygen/Geant4Classes.h
index 00c8cdfa95f3886f688903ed2fc829cad79fc411..db812ad0e4ee1eb09318166251230f8df2d2fc53 100644
--- a/doc/doxygen/Geant4Classes.h
+++ b/doc/doxygen/Geant4Classes.h
@@ -39,6 +39,10 @@ class G4VHit {};
/** Class of the Geant4 toolkit. \see http://www-geant4.kek.jp/Reference */
class G4VHitsCollection {};
+/// Class of the Geant4 toolkit. See http://www-geant4.kek.jp/Reference
+/** Class of the Geant4 toolkit. \see http://www-geant4.kek.jp/Reference */
+class G4VPhysicsConstructor {};
+
/// Class of the Geant4 toolkit. See http://www-geant4.kek.jp/Reference
/** Class of the Geant4 toolkit. \see http://www-geant4.kek.jp/Reference */
class G4VSDFilter {};
diff --git a/doc/doxygen/TiXMLClasses.h b/doc/doxygen/TiXMLClasses.h
index 3dfd50401eadb514be5eb387c742f667b7ecaebf..17e1f721293b428637ffe6d44afea06df800b72b 100644
--- a/doc/doxygen/TiXMLClasses.h
+++ b/doc/doxygen/TiXMLClasses.h
@@ -2,9 +2,11 @@
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlAttribute {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlAttributeSet {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlBase {
@@ -12,36 +14,51 @@ class TiXmlBase {
/** See \see http://www.grinninglizard.com/tinyxml */
class Entity {};
};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlComment {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlCursor {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlDeclaration {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlDocument {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlElement {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlHandle {};
+
+/// TinyXML class. See http://www.grinninglizard.com/tinyxml
+/** See \see http://www.grinninglizard.com/tinyxml */
+class TiXmlHandle_t {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlNode {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlOutStream {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlParsingData {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlPrinter {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlString {
@@ -49,12 +66,15 @@ class TiXmlString {
/** See \see http://www.grinninglizard.com/tinyxml */
class Rep {};
};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlText {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlUnknown {};
+
/// TinyXML class. See http://www.grinninglizard.com/tinyxml
/** See \see http://www.grinninglizard.com/tinyxml */
class TiXmlVisitor {};
diff --git a/examples/Conditions/src/ConditionExample_manual.cpp b/examples/Conditions/src/ConditionExample_manual.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a22e52562e9bd7428ad0880042ccb5f0c002a5ad
--- /dev/null
+++ b/examples/Conditions/src/ConditionExample_manual.cpp
@@ -0,0 +1,146 @@
+//==========================================================================
+// AIDA Detector description implementation
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// Author : M.Frank
+//
+//==========================================================================
+/*
+
+ Plugin invocation:
+ ==================
+ This plugin behaves like a main program.
+ Invoke the plugin with something like this:
+
+ geoPluginRun -volmgr -destroy -plugin DD4hep_ConditionExample_load \
+ -input file:${DD4hep_DIR}/examples/AlignDet/compact/Telescope.xml \
+ -conditions Conditions.root
+
+ Save the conditions store by hand for a set of IOVs.
+ Then compute the corresponding alignment entries....
+
+*/
+// Framework include files
+#include "ConditionExampleObjects.h"
+#include "DDCond/ConditionsIOVPool.h"
+#include "DDCond/ConditionsManager.h"
+#include "DDCond/ConditionsRootPersistency.h"
+#include "DD4hep/Factories.h"
+
+using namespace std;
+using namespace dd4hep;
+using namespace dd4hep::ConditionExamples;
+
+static void help(int argc, char** argv) {
+ /// Help printout describing the basic command line interface
+ cout <<
+ "Usage: -plugin <name> -arg [-arg] \n"
+ " name: factory name DD4hep_ConditionExample_load \n"
+ " -input <string> Geometry file \n"
+ " -conditions <string> Conditions input file \n"
+ " -iovs <number> Number of parallel IOV slots for processing. \n"
+ " -restore <string> Restore strategy: iovpool, userpool or condpool.\n"
+ "\tArguments given: " << arguments(argc,argv) << endl << flush;
+ ::exit(EINVAL);
+}
+
+/// Plugin function: Condition program example
+/**
+ * Factory: DD4hep_ConditionExample_load
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/12/2016
+ */
+static int condition_example (Detector& description, int argc, char** argv) {
+ string input, conditions, restore="iovpool";
+ int num_iov = 10;
+ bool arg_error = false;
+ for(int i=0; i<argc && argv[i]; ++i) {
+ if ( 0 == ::strncmp("-input",argv[i],4) )
+ input = argv[++i];
+ else if ( 0 == ::strncmp("-conditions",argv[i],4) )
+ conditions = argv[++i];
+ else if ( 0 == ::strncmp("-restore",argv[i],4) )
+ restore = argv[++i];
+ else if ( 0 == ::strncmp("-iovs",argv[i],4) )
+ num_iov = ::atol(argv[++i]);
+ else
+ arg_error = true;
+ }
+ if ( arg_error || input.empty() || conditions.empty() ) help(argc,argv);
+
+ // First we load the geometry
+ description.fromXML(input);
+
+ /******************** Initialize the conditions manager *****************/
+ // Now we instantiate the conditions manager
+ description.apply("DD4hep_ConditionsManagerInstaller",0,(char**)0);
+
+ ConditionsManager manager = ConditionsManager::from(description);
+ manager["PoolType"] = "DD4hep_ConditionsLinearPool";
+ manager["UserPoolType"] = "DD4hep_ConditionsMapUserPool";
+ manager["UpdatePoolType"] = "DD4hep_ConditionsLinearUpdatePool";
+ manager["LoaderType"] = "root";
+ manager.initialize();
+
+ shared_ptr<ConditionsContent> content(new ConditionsContent());
+ shared_ptr<ConditionsSlice> slice(new ConditionsSlice(manager,content));
+
+ Scanner(ConditionsKeys(*content,INFO),description.world());
+ Scanner(ConditionsDependencyCreator(*content,DEBUG),description.world());
+
+ /******************** Load the conditions from file *********************/
+ {
+ auto pers = cond::ConditionsRootPersistency::load(conditions.c_str(),"DD4hep Conditions");
+ printout(ALWAYS,"Statistics","+=========================================================================");
+ printout(ALWAYS,"Statistics","+ Loaded conditions object from file %s. Took %8.3f seconds.",
+ conditions.c_str(),pers->duration);
+ size_t num_cond = 0;
+ if ( restore == "iovpool" )
+ num_cond = pers->importIOVPool("ConditionsIOVPool No 1","run",manager);
+ else if ( restore == "userpool" )
+ num_cond = pers->importUserPool("*","run",manager);
+ else if ( restore == "condpool" )
+ num_cond = pers->importConditionsPool("*","run",manager);
+ else
+ help(argc,argv);
+
+ printout(ALWAYS,"Statistics","+ Imported %ld conditions from %s to IOV pool. Took %8.3f seconds.",
+ num_cond, restore.c_str(), pers->duration);
+ printout(ALWAYS,"Statistics","+=========================================================================");
+ }
+ // ++++++++++++++++++++++++ Now compute the conditions for each of these IOVs
+ const IOVType* iov_typ = manager.iovType("run");
+ cond::ConditionsIOVPool* pool = manager.iovPool(*iov_typ);
+ for( const auto& p : pool->elements )
+ p.second->print("*");
+
+ ConditionsManager::Result total;
+ for(int i=0; i<num_iov; ++i) {
+ IOV req_iov(iov_typ,i*10+5);
+ // Select the proper set of conditions and attach them to the user pool
+ ConditionsManager::Result r = manager.prepare(req_iov,*slice);
+ total += r;
+ if ( 0 == i ) { // First one we print...
+ Scanner(ConditionsPrinter(slice.get(),"Example"),description.world());
+ }
+ // Now compute the tranformation matrices
+ printout(ALWAYS,"Prepare","Total %ld conditions (S:%ld,L:%ld,C:%ld,M:%ld) of IOV %s",
+ r.total(), r.selected, r.loaded, r.computed, r.missing, req_iov.str().c_str());
+ }
+ printout(ALWAYS,"Statistics","+=========================================================================");
+ printout(ALWAYS,"Statistics","+ Accessed a total of %ld conditions (S:%6ld,L:%6ld,C:%6ld,M:%ld)",
+ total.total(), total.selected, total.loaded, total.computed, total.missing);
+ printout(ALWAYS,"Statistics","+=========================================================================");
+ // All done.
+ return 1;
+}
+
+// first argument is the type from the xml file
+DECLARE_APPLY(DD4hep_ConditionExample_load,condition_example)