diff --git a/DDCore/include/DD4hep/ConditionAny.h b/DDCore/include/DD4hep/ConditionAny.h
index 093fd185bf238c399bfe873fce53b1e35edf57bc..c95b49469450e03cf38fd37a382927b47ca06448 100644
--- a/DDCore/include/DD4hep/ConditionAny.h
+++ b/DDCore/include/DD4hep/ConditionAny.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DD4HEP_CONDITIONSANY_H
-#define DD4HEP_CONDITIONSANY_H
+#ifndef DD4HEP_CONDITIONANY_H
+#define DD4HEP_CONDITIONANY_H
// Framework include files
#include "DD4hep/Conditions.h"
@@ -42,11 +42,13 @@ namespace dd4hep {
class ConditionAny : public Handle<detail::ConditionObject> {
public:
/// Forward definition of the key type
- using key_type = Condition::key_type;
+ using key_type = Condition::key_type;
/// High part of the key identifies the detector element
- using detkey_type = Condition::detkey_type;
+ using detkey_type = Condition::detkey_type;
/// Low part of the key identifies the item identifier
using itemkey_type = Condition::itemkey_type;
+ /// Forward definition of the object properties
+ using mask_type = Condition::mask_type;
private:
/// Verify that underlying data are either invalid of contain an instance of std::any.
@@ -104,15 +106,26 @@ namespace dd4hep {
/// Item part of the identifier
itemkey_type item_key() const;
+ /// Flag operations: Get condition flags
+ mask_type flags() const;
+ /// Flag operations: Set a conditons flag
+ void setFlag(mask_type option);
+ /// Flag operations: UN-Set a conditons flag
+ void unFlag(mask_type option);
+ /// Flag operations: Test for a given a conditons flag
+ bool testFlag(mask_type option) const;
+
/// Generic getter. Specify the exact type, not a polymorph type
std::any& get();
/// Generic getter (const version). Specify the exact type, not a polymorph type
const std::any& get() const;
- /// Access to the type information
- const std::type_info& any_type() const;
/// Checks whether the object contains a value
bool has_value() const;
+ /// Access to the type information
+ const std::type_info& any_type() const;
+ /// Access to the type information as string
+ const std::string any_type_name() const;
/// Access the contained object inside std::any
template <typename T> T& as();
/// Access the contained object inside std::any
diff --git a/DDCore/include/DD4hep/Conditions.h b/DDCore/include/DD4hep/Conditions.h
index 624cce177473472f24d970c798e9bf0957de7c8c..bc9d77f0a5f8ebabcea66cace5a9de72fd4e43b4 100644
--- a/DDCore/include/DD4hep/Conditions.h
+++ b/DDCore/include/DD4hep/Conditions.h
@@ -178,10 +178,9 @@ namespace dd4hep {
itemkey_type item_key() const;
/** Direct data items in string form */
+#if defined(DD4HEP_CONDITIONS_DEBUG) || !defined(DD4HEP_MINIMAL_CONDITIONS)
/// Access the type field of the condition
const std::string& type() const;
-
-#if defined(DD4HEP_CONDITIONS_DEBUG) || !defined(DD4HEP_MINIMAL_CONDITIONS)
/// Access the value field of the condition as a string
const std::string& value() const;
/// Access the comment field of the condition
diff --git a/DDCore/include/DD4hep/detail/DetectorInterna.h b/DDCore/include/DD4hep/detail/DetectorInterna.h
index 56d4ca242be471afc095ed592b1f594e3ec41c94..2086c885a5e5bc275d6e27a7e0f740fe369bb75b 100644
--- a/DDCore/include/DD4hep/detail/DetectorInterna.h
+++ b/DDCore/include/DD4hep/detail/DetectorInterna.h
@@ -142,14 +142,6 @@ namespace dd4hep {
Ref_t global_alignment;
//@}
-#if 0
- // To be removed!
- /// Alignment entries for lower level volumes, which are NOT attached to daughter DetElements
- std::vector<Alignment> volume_alignments;
- /// Alignment entries for lower level volumes, which are NOT attached to daughter DetElements
- std::vector<Alignment> volume_surveys;
-#endif
-
private:
friend class VolumeManager_Populator;
diff --git a/DDCore/src/ConditionAny.cpp b/DDCore/src/ConditionAny.cpp
index 30487f0968141f7a105a5d3430990214eb02dfa2..14ae22a9c00544b9b992f80c4dbcbc3152f10fdd 100644
--- a/DDCore/src/ConditionAny.cpp
+++ b/DDCore/src/ConditionAny.cpp
@@ -56,13 +56,14 @@ ConditionAny::ConditionAny(const string& nam, const string& typ) : Handle<Object
void ConditionAny::use_data(detail::ConditionObject* obj) {
if ( obj ) {
if ( !obj->data.grammar ) {
- except("ConditionAny","+++ Cannot assign unbound conditions data to handle. [Invalid operation]");
+ except("ConditionAny",
+ "+++ Cannot assign unbound conditions data to handle. [Invalid operation]");
}
if ( obj->data.grammar != any_grammar() ) {
except("ConditionAny",
"+++ Cannot assign data of type " +
obj->data.grammar->type_name() +
- " to std::any. [Invalid operation]");
+ " to handle holding std::any. [Invalid operation]");
}
}
this->m_element = obj;
@@ -93,14 +94,42 @@ ConditionAny::itemkey_type ConditionAny::item_key() const {
return ConditionKey::KeyMaker(access()->hash).values.item_key;
}
+/// Flag operations: Get flags
+ConditionAny::mask_type ConditionAny::flags() const {
+ return access()->flags;
+}
+
+/// Flag operations: Set a conditons flag
+void ConditionAny::setFlag(mask_type option) {
+ access()->setFlag(option);
+}
+
+/// Flag operations: UN-Set a conditons flag
+void ConditionAny::unFlag(mask_type option) {
+ access()->unFlag(option);
+}
+
+/// Flag operations: Test for a given a conditons flag
+bool ConditionAny::testFlag(mask_type option) const {
+ return access()->testFlag(option);
+}
+
/// Generic getter. Specify the exact type, not a polymorph type
std::any& ConditionAny::get() {
- return this->access()->data.get<std::any>();
+ auto& o = this->access()->data;
+ if ( o.grammar && (o.grammar == any_grammar()) ) {
+ return *(std::any*)o.ptr();
+ }
+ throw std::bad_cast();
}
/// Generic getter (const version). Specify the exact type, not a polymorph type
const std::any& ConditionAny::get() const {
- return this->access()->data.get<std::any>();
+ const auto& o = this->access()->data;
+ if ( o.grammar && (o.grammar == any_grammar()) ) {
+ return *(std::any*)o.ptr();
+ }
+ throw std::bad_cast();
}
/// Checks whether the object contains a value
@@ -110,19 +139,20 @@ bool ConditionAny::has_value() const {
/// Access to the type information
const type_info& ConditionAny::any_type() const {
- return this->get().type();
-}
-
-#if 0
-/// Access to the grammar type
-const dd4hep::BasicGrammar& ConditionAny::descriptor() const {
- const BasicGrammar* grammar = access()->data.grammar;
- if ( !grammar ) {
- invalidHandleError<ConditionAny>();
- // This code is never reached, since function above throws exception!
- // Needed to satisfay CppCheck
- throw runtime_error("Null pointer in Grammar object");
+ const auto* o = this->ptr();
+ if ( o && o->data.grammar && (o->data.grammar == any_grammar()) ) {
+ const std::any* a = (const std::any*)o->data.ptr();
+ return a->type();
+ }
+ return typeid(void);
+}
+
+/// Access to the type information as string
+const std::string ConditionAny::any_type_name() const {
+ const auto* o = this->ptr();
+ if ( o && o->data.grammar && (o->data.grammar == any_grammar()) ) {
+ const std::any* a = (const std::any*)o->data.ptr();
+ return typeName(a->type());
}
- return *grammar;
+ return typeName(typeid(void));
}
-#endif
diff --git a/doc/usermanuals/DD4hep/chapters/basics.tex b/doc/usermanuals/DD4hep/chapters/basics.tex
index 981bd2c5db00e1742be4412450b0b5abd072ceba..1066f3a099c7a7c02f80e33d9bf4daacb10fcbb2 100644
--- a/doc/usermanuals/DD4hep/chapters/basics.tex
+++ b/doc/usermanuals/DD4hep/chapters/basics.tex
@@ -129,7 +129,40 @@ NEEDS ADDITIONAL CLARIFICATION
\section{DD4hep Handles}
\label{sec:dd4hep-user-manual-handles}
-Handles are the means of clients accessing DD4hep detector description data. The data itself is not held by the handle itself, the handle only allows the access to the data typically held by a pointer. The template handle class (see for details the \href{https://dd4hep.web.cern.ch/dd4hep/reference/classdd4hep_1_1Handle.html}{\texttt{Handle.h}} header file) allows type safe assignment of other unrelated handles and supports standard data conversions to the underlying object in form of the raw pointer, a reference etc. The template handle class:
+Handles are the means of clients accessing DD4hep detector description data. Handles are an intrinsic ingredient to DD4hep meant to also support various views onto relatively simple structures. The data itself is not held by the handle itself, the handle only allows the access to the data typically held by a pointer.
+
+DD4hep internally prefers to expose data structures which are as simple as possible while at the same time being as complicated as necessary. These objects are then manipulated by Handles, smart pointer objects with sometimes specialized functionality depending on the contained data type. It is seen as a clear advantage that these smart pointer objects to not impose any restrictions on the underlying object except the accessibility of the contained data.
+
+The freedom to attach handle based facades to virtually any data item allows for optimized data views depending on the application type, such as special views for reconstruction, simulation, tracking, etc.
+
+For the importance of the functionality of this issue we repeat here the functionality described in~\ref{subsect:extesions-and-views} which is achieved by specializing the basic templated handle implementation:
+\begin{description}
+\item [Convenience Views] provide higher level abstractions and internally group complex calculations. Such views simplify the life of the end-users.
+\item [Optimization Views] allows end-users extend the data of the common detector detector element and store precomputed results, which would be expensive to obtain repeatedly.
+\item [Compatibility Views] help to ensure smooth periods of software redesign. During the life-time of the experiment often various software constructs are for functional reasons re-designed and re-engineered. Compatibility Views either adapt new data designs to existing application code or expose new behavior based on existing data.
+\end{description}
+
+Since the lifetime of DD4hep objects is mostly defined by the lifetime of the {\texttt{dd4hep::Detector}} object (in turn defining the lifetime of ROOT's {\texttt{TGeoManager}}) or for the conditions is managed by the ConditionsManager object under the steering of the embeding framework there is also no memory model imposed which would only lead to performance penalties. Hence, handles can be applied to data structures independent of their origin:
+\begin{itemize}
+\item allocated from the stack
+\item allocated from the heap
+\item allocated as single objects of in bulk by array constructors.
+\end{itemize}
+
+There is no restriction to allow toolkit users to extend any of the internally used DD4hep classes such as e.g. the {\texttt{dd4hep::DetElement}} data object {\texttt{dd4hep::detail::DetElementObject}} with their own implementation supporting further enhanced functionality both in terms of additional data and additional member functions provided the user specialized class inherits from the DD4hep provided base. Obviously such enhancements do not hold for the geometry classes provided by ROOT because here the ROOT framework internally calls its object constructors. Hence, though DD4hep internally uses templated handles to manipulate data objects, DD4hep allows for all freedom to extend any of the internally used objects and a priori no restrictions are imposed by the DD4hep framework besides the mentioned inheritance.
+
+The design approach of DD4hep to internally use handles to manipulate objects which is also offered to clients clearly has difficulties to support the Liskov substitution principle. This was a conscious decision when designing DD4hep.
+
+Frameworks which see the substitution principle for the implementation of the simple data structures mandatory for its functionality clearly limit the benefits of the handles unless
+
+\begin{itemize}
+\item the depending frameworks provides handles which are a fully implemented facade or
+\item the depending framework use consistently the operator->() provided by all handles to directly access the underlying object or
+\item the depending framework uses DD4hep and it is provided only internally and provide top level user code only with pointers/references to the data structures in their full object oriented glory.
+\end{itemize}
+
+The template handle class (see for details the \href{https://dd4hep.web.cern.ch/dd4hep/reference/classdd4hep_1_1Handle.html}{\texttt{Handle.h}} header file) allows type safe assignment of other unrelated handles and supports standard data conversions to the underlying object in form of the raw pointer, a reference etc.
+The template handle class:
\begin{minted}[frame=single,framesep=3pt,breaklines=true,tabsize=2,linenos,fontsize=\small]{c++}
template <typename T> class Handle {
diff --git a/doc/usermanuals/DD4hep/references.bib b/doc/usermanuals/DD4hep/references.bib
index bc1b7c4a3fdc7f0e169fa60a603b496cdb3b776c..35803155881e11baf05081979a75f2b2a02c5e33 100755
--- a/doc/usermanuals/DD4hep/references.bib
+++ b/doc/usermanuals/DD4hep/references.bib
@@ -119,6 +119,15 @@
day = {16}
}
+@article{Frank_et_al:2014_DDCore,
+ author = "M. Frank et al.",
+ title = "{DD4hep: A Detector Description Toolkit for High Energy Physics Experiments}",
+ journal = "Journal of Physics: Conference Series",
+ volume = "513",
+ year = "2014",
+ pages = "022010"
+}
+
@article{Chytracek:2006be,
author = "Chytracek, R. and McCormick, J. and Pokorski, W. and
Santin, G.",
diff --git a/examples/Conditions/CMakeLists.txt b/examples/Conditions/CMakeLists.txt
index d5137b46ddf8090abff01480ca4e504e7be98b88..85396422a2b26c914e725ca1eafe57d3e69a878f 100644
--- a/examples/Conditions/CMakeLists.txt
+++ b/examples/Conditions/CMakeLists.txt
@@ -222,3 +222,20 @@ dd4hep_add_test_reg( Conditions_CLICSiD_root_load_cond_LONGTEST
REGEX_PASS "\\+ Accessed a total of 1053210 conditions \\(S:947889,L: 0,C:105321,M:0\\)"
REGEX_FAIL " ERROR ;EXCEPTION;Exception"
)
+#
+#---Testing: Basic test using std::any as conditions payload
+dd4hep_add_test_reg( Conditions_any_basic
+ COMMAND "${CMAKE_INSTALL_PREFIX}/bin/run_test_Conditions.sh"
+ EXEC_ARGS geoPluginRun -print INFO -destroy -plugin DD4hep_Conditions_any_basic
+ REGEX_PASS "Test PASSED"
+ REGEX_FAIL "Test FAILED"
+ )
+#
+#---Testing: Simple stress: Load Telescope geometry and have multiple runs on IOVs
+dd4hep_add_test_reg( Conditions_any_Telescope_populate
+ COMMAND "${CMAKE_INSTALL_PREFIX}/bin/run_test_Conditions.sh"
+ EXEC_ARGS geoPluginRun -destroy -plugin DD4hep_ConditionAnyExample_populate
+ -input file:${CMAKE_INSTALL_PREFIX}/examples/AlignDet/compact/Telescope.xml -iovs 2
+ REGEX_PASS "\\+ Analyzed 1020 any object/elements"
+ REGEX_FAIL " ERROR ;EXCEPTION;Exception"
+ )
diff --git a/examples/Conditions/src/ConditionAnyExampleObjects.cpp b/examples/Conditions/src/ConditionAnyExampleObjects.cpp
index 09dcbeaa976f6969c455e36ec97754a5f676fa21..3d5525eb9c2acc240d3d11eb06ab1be944590c26 100644
--- a/examples/Conditions/src/ConditionAnyExampleObjects.cpp
+++ b/examples/Conditions/src/ConditionAnyExampleObjects.cpp
@@ -24,8 +24,12 @@ using cond::DependencyBuilder;
using cond::ConditionsLoadInfo;
namespace {
+ static int num_any_ingredients = 0;
template <typename T> inline void __prt(ostream& os, const vector<T>& obj) {
- for(const auto& o : obj) os << o << " ";
+ for(const auto& o : obj) {
+ os << o << " ";
+ ++num_any_ingredients;
+ }
}
}
@@ -75,12 +79,72 @@ void ConditionAnyUpdate2::resolve(Condition target, ConditionUpdateContext& cont
vector<int>& c1 = cond1.as<vector<int> >();
data.insert(data.end(), c1.begin(), c1.end());
}
+
+
+/// Interface to client Callback in order to update the condition
+Condition ConditionAnyUpdate3::operator()(const ConditionKey& key, ConditionUpdateContext&) {
+#ifdef DD4HEP_CONDITIONS_DEBUG
+ printout(printLevel,"ConditionUpdate3","++ Building dependent condition: %016llX [%s]",key.hash, key.name.c_str());
+ return ConditionAny(key.name,"derived");
+#else
+ printout(printLevel,"ConditionUpdate3","++ Building dependent condition: %016llX",key.hash);
+ return ConditionAny(key.hash);
+#endif
+}
+
+/// Interface to client Callback in order to update the condition
+void ConditionAnyUpdate3::resolve(Condition target, ConditionUpdateContext& context) {
+ vector<int> data;
+ ConditionAny cond0 = context.condition(context.key(0));
+ ConditionAny cond1 = context.condition(context.key(1));
+ ConditionAny cond2 = context.condition(context.key(2));
+
+ data.push_back(cond0.as<int>());
+ data.push_back(cond0.as<int>()*2);
+ vector<int>& c1 = cond1.as<vector<int> >();
+ data.insert(data.end(), c1.begin(), c1.end());
+
+ vector<int>& c2 = cond2.as<vector<int> >();
+ data.insert(data.end(), c2.begin(), c2.end());
+ target.get<std::any>() = std::move(data);
+}
+
+/// Interface to client Callback in order to update the condition
+Condition ConditionAnyUpdate4::operator()(const ConditionKey& key, ConditionUpdateContext& context) {
+#ifdef DD4HEP_CONDITIONS_DEBUG
+ printout(printLevel,"ConditionUpdate4","++ Building dependent condition: %016llX [%s]",key.hash, key.name.c_str());
+ ConditionAny target(key.name,"derived", vector<int>());
+#else
+ printout(printLevel,"ConditionUpdate4","++ Building dependent condition: %016llX",key.hash);
+ ConditionAny target(key.hash, vector<int>());
+#endif
+ vector<int>& data = target.as<std::vector<int> >();
+ ConditionAny cond3 = context.condition(context.key(0));
+ ConditionAny cond2 = context.condition(context.key(1));
+ ConditionAny cond0 = context.condition(context.key(2));
+ ConditionAny cond1 = context.condition(context.key(3));
+
+ data.push_back(cond0.as<int>());
+ data.push_back(cond0.as<int>()*2);
+ vector<int>& c1 = cond1.as<vector<int> >();
+ data.insert(data.end(), c1.begin(), c1.end());
+
+ vector<int>& c2 = cond2.as<vector<int> >();
+ data.insert(data.end(), c2.begin(), c2.end());
+
+ vector<int>& c3 = cond3.as<vector<int> >();
+ data.insert(data.end(), c3.begin(), c3.end());
+ return target;
+}
+
/// Initializing constructor
ConditionsAnyDependencyCreator::ConditionsAnyDependencyCreator(ConditionsContent& c, PrintLevel p, bool persist, int ex)
: OutputLevel(p), content(c), persist_conditions(persist), extended(ex)
{
call1 = std::shared_ptr<ConditionUpdateCall>(new ConditionAnyUpdate1(printLevel));
call2 = std::shared_ptr<ConditionUpdateCall>(new ConditionAnyUpdate2(printLevel));
+ call3 = std::shared_ptr<ConditionUpdateCall>(new ConditionAnyUpdate3(printLevel));
+ call4 = std::shared_ptr<ConditionUpdateCall>(new ConditionAnyUpdate4(printLevel));
}
/// Callback to process a single detector element
@@ -88,8 +152,11 @@ int ConditionsAnyDependencyCreator::operator()(DetElement de, int) const {
ConditionKey key (de,"derived_data");
ConditionKey target1(de,"derived_data/derived_1");
ConditionKey target2(de,"derived_data/derived_2");
+ ConditionKey target3(de,"derived_data/derived_3");
+ ConditionKey target4(de,"derived_data/derived_4");
DependencyBuilder build_1(de, target1.item_key(), call1);
DependencyBuilder build_2(de, target2.item_key(), call2);
+ DependencyBuilder build_3(de, target3.item_key(), call3);
// Compute the derived stuff
build_1.add(key);
@@ -97,12 +164,33 @@ int ConditionsAnyDependencyCreator::operator()(DetElement de, int) const {
build_2.add(key);
build_2.add(target1);
+
+ build_3.add(key);
+ build_3.add(target1);
+ build_3.add(target2);
+
+ if ( extended >= 1 ) {
+ DependencyBuilder build_4(de, target4.item_key(), call4);
+ build_4.add(target3);
+ build_4.add(target2);
+ build_4.add(key);
+ build_4.add(target1);
+ content.addDependency(build_4.release());
+ }
content.addDependency(build_1.release());
content.addDependency(build_2.release());
+ content.addDependency(build_3.release());
printout(printLevel,"Example","++ Added derived conditions dependencies for %s",de.path().c_str());
return 1;
}
+/// Standard destructor
+ConditionsAnyDataAccess::~ConditionsAnyDataAccess() {
+ printout(printLevel,"Example","+=========================================================================");
+ printout(printLevel,"Example","+ Analyzed %d any object/elements", num_any_ingredients);
+ printout(printLevel,"Example","+=========================================================================");
+}
+
/// Callback to process a single detector element
int ConditionsAnyDataAccess::operator()(DetElement de, int level) const {
vector<Condition> conditions;
@@ -119,6 +207,8 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
ConditionKey key_derived_data(de,"derived_data");
ConditionKey key_derived1 (de,"derived_data/derived_1");
ConditionKey key_derived2 (de,"derived_data/derived_2");
+ ConditionKey key_derived3 (de,"derived_data/derived_3");
+ ConditionKey key_derived4 (de,"derived_data/derived_4");
ConditionKey key_path (de,"de_path");
int result = 0, count = 0;
@@ -138,6 +228,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %s", cond.value<string>().c_str());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_temperature.item_key() ) {
result += int(cond.as<double>());
@@ -146,6 +237,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %f", cond.as<double>());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_pressure.item_key() ) {
result += int(cond.as<double>());
@@ -154,6 +246,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %f", cond.as<double>());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_double_table.item_key() ) {
result += int(cond.as<vector<double> >().size());
@@ -163,6 +256,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_int_table.item_key() ) {
result += int(cond.as<vector<int> >().size());
@@ -172,6 +266,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_derived_data.item_key() ) {
result += int(cond.as<int>());
@@ -180,6 +275,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %d", cond.as<int>());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_derived1.item_key() ) {
result += int(cond.as<vector<int> >().size());
@@ -189,6 +285,7 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
}
else if ( cond.item_key() == key_derived2.item_key() ) {
result += int(cond.as<vector<int> >().size());
@@ -198,6 +295,27 @@ int ConditionsAnyDataAccess::accessConditions(DetElement de, const std::vector<C
typeName(typeid(cond.get())).c_str(),
typeName(cond.any_type()).c_str());
printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
+ }
+ else if ( cond.item_key() == key_derived3.item_key() ) {
+ result += int(cond.as<vector<int> >().size());
+ __prt(str,cond.as<vector<int> >());
+ printout(INFO,"accessConditions","Condition: %s type: %s [%s]",
+ key_derived3.toString().c_str(),
+ typeName(typeid(cond.get())).c_str(),
+ typeName(cond.any_type()).c_str());
+ printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
+ }
+ else if ( cond.item_key() == key_derived4.item_key() ) {
+ result += int(cond.as<vector<int> >().size());
+ __prt(str,cond.as<vector<int> >());
+ printout(INFO,"accessConditions","Condition: %s type: %s [%s]",
+ key_derived4.toString().c_str(),
+ typeName(typeid(cond.get())).c_str(),
+ typeName(cond.any_type()).c_str());
+ printout(INFO,"accessConditions"," value: %s", str.str().c_str());
+ ++num_any_ingredients;
}
if ( !IOV::key_is_contained(iov.key(),cond.iov().key()) ) {
printout(INFO,"CondAccess","++ IOV mismatch:%s <> %s",
diff --git a/examples/Conditions/src/ConditionAnyExampleObjects.h b/examples/Conditions/src/ConditionAnyExampleObjects.h
index 654bf77a1d4b6ef4fd44dd58e2477d1d59b838eb..31f6d19052f94aa54dc381274c34d139743604d1 100644
--- a/examples/Conditions/src/ConditionAnyExampleObjects.h
+++ b/examples/Conditions/src/ConditionAnyExampleObjects.h
@@ -62,6 +62,44 @@ namespace dd4hep {
virtual void resolve(Condition condition, ConditionUpdateContext& context) override final;
};
+ /// Specialized conditions update callback
+ /**
+ * Used by clients to update a condition.
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
+ class ConditionAnyUpdate3 : public ConditionUpdateCall, public OutputLevel {
+ public:
+ /// Initializing constructor
+ ConditionAnyUpdate3(PrintLevel p) : OutputLevel(p) { }
+ /// Default destructor
+ virtual ~ConditionAnyUpdate3() = default;
+ /// Interface to client Callback in order to update the condition
+ virtual Condition operator()(const ConditionKey& key, ConditionUpdateContext& context) override final;
+ /// Interface to client Callback in order to update the condition
+ virtual void resolve(Condition condition, ConditionUpdateContext& context) override final;
+ };
+
+ /// Specialized conditions update callback
+ /**
+ * Used by clients to update a condition.
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_CONDITIONS
+ */
+ class ConditionAnyUpdate4 : public ConditionUpdateCall, public OutputLevel {
+ public:
+ /// Initializing constructor
+ ConditionAnyUpdate4(PrintLevel p) : OutputLevel(p) { }
+ /// Default destructor
+ virtual ~ConditionAnyUpdate4() = default;
+ /// Interface to client Callback in order to update the condition
+ virtual Condition operator()(const ConditionKey& key, ConditionUpdateContext& context) override final;
+ };
+
/// This is important, otherwise the register and forward calls won't find them!
/**
* \author M.Frank
@@ -91,7 +129,7 @@ namespace dd4hep {
/// Content object to be filled
ConditionsContent& content;
/// Three different update call types
- std::shared_ptr<ConditionUpdateCall> scall1, call1, call2, call3, call4, call5, call6, callUnresolved;
+ std::shared_ptr<ConditionUpdateCall> call1, call2, call3, call4;
/// Flag for special setup for ROOT persistency
bool persist_conditions;
/// Flag to indicate increased complexity
@@ -155,7 +193,7 @@ namespace dd4hep {
ConditionsAnyDataAccess(const IOV& i, ConditionsMap& m, PrintLevel l=DEBUG)
: OutputLevel(l), iov(i), map(m) {}
/// Destructor
- virtual ~ConditionsAnyDataAccess() = default;
+ virtual ~ConditionsAnyDataAccess();
/// Callback to process a single detector element
virtual int operator()(DetElement de, int level) const;
/// Common call to access selected conditions
diff --git a/examples/Conditions/src/ConditionExampleObjects.cpp b/examples/Conditions/src/ConditionExampleObjects.cpp
index 5c319192b30543c7b20bdc08c2dde5ee38f8e74a..6572c7d2d674159363bfb731e3a08c6be5961cbd 100644
--- a/examples/Conditions/src/ConditionExampleObjects.cpp
+++ b/examples/Conditions/src/ConditionExampleObjects.cpp
@@ -121,7 +121,6 @@ void ConditionUpdate2::resolve(Condition target, ConditionUpdateContext& context
data.insert(data.end(), c1.begin(), c1.end());
}
-
/// Interface to client Callback in order to update the condition
Condition ConditionUpdate3::operator()(const ConditionKey& key, ConditionUpdateContext&) {
#ifdef DD4HEP_CONDITIONS_DEBUG
diff --git a/examples/Conditions/src/Conditions_any_basic.cpp b/examples/Conditions/src/Conditions_any_basic.cpp
index dfa09a4d0f986b25cbd72127efdc4a6b04f59138..7055450f4c9deb1c764670dc07f3823724939b49 100644
--- a/examples/Conditions/src/Conditions_any_basic.cpp
+++ b/examples/Conditions/src/Conditions_any_basic.cpp
@@ -95,6 +95,7 @@ static int condition_any_basic (Detector& /* description */, int /* argc */, cha
try {
c1 = c2;
cout << "Assigned: ConditionAny = Condition(vector) . " << endl;
+ cout << "Test FAILED" << endl;
}
catch(const std::exception& e) {
cout << "Expected exception: ConditionAny = Condition(vector) : " << e.what() << endl;
@@ -118,6 +119,7 @@ static int condition_any_basic (Detector& /* description */, int /* argc */, cha
ConditionAny c5(c2);
cout << "Construct c5: ConditionAny( Condition(vector) ) Pointer: "
<< (void*)c5.ptr() << " type:" << c5.any_type().name() << endl;
+ cout << "Test FAILED" << endl;
}
catch(const std::exception& e) {
cout << "Expected exception: Construct c5: ConditionAny( Condition(vector) ) : " << e.what() << endl;