diff --git a/DDCore/include/DD4hep/Callback.h b/DDCore/include/DD4hep/Callback.h
index 3c48d9391dc586eff3025483d45cf799a7563784..d48026be7c2013a229774efa0e808b5e8811fd28 100644
--- a/DDCore/include/DD4hep/Callback.h
+++ b/DDCore/include/DD4hep/Callback.h
@@ -58,6 +58,11 @@ namespace dd4hep {
: par(p), call(0) {
func.first = func.second = 0;
}
+ /// Constructor with object initialization
+ Callback(const void* p)
+ : par((void*)p), call(0) {
+ func.first = func.second = 0;
+ }
/// Initializing constructor
Callback(void* p, void* mf, func_t c)
: par(p), call(c) {
diff --git a/DDDigi/include/DDDigi/DigiAction.h b/DDDigi/include/DDDigi/DigiAction.h
index 9db7b5e6b5a9f018af97b4e5209c129f0db13537..d6c8ec41d0016269dd32b174ceeb9fdc1283f073 100644
--- a/DDDigi/include/DDDigi/DigiAction.h
+++ b/DDDigi/include/DDDigi/DigiAction.h
@@ -83,19 +83,26 @@ namespace dd4hep {
* \ingroup DD4HEP_DIGITIZATION
*/
class DigiAction {
+
friend class DigiKernel;
+ public:
+ using context_t = DigiContext;
+ using kernel_t = DigiKernel;
+
protected:
/// Reference to the Digi context
#if defined(G__ROOT) || defined(__CLING__) || defined(__ROOTCLING__)
- const DigiKernel* m_kernel;
+ const kernel_t* m_kernel;
+
public:
- const DigiKernel* kernel() const {
+ const kernel_t* kernel() const {
return m_kernel;
}
+
protected:
#else
- const DigiKernel& m_kernel;
+ const kernel_t& m_kernel;
#endif
/// Action name
std::string m_name;
@@ -117,7 +124,7 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiAction(const DigiKernel& kernel, const std::string& nam);
+ DigiAction(const kernel_t& kernel, const std::string& nam);
/// Increase reference count
long addRef();
/// Decrease reference count. Implicit destruction
diff --git a/DDDigi/include/DDDigi/DigiActionSequence.h b/DDDigi/include/DDDigi/DigiActionSequence.h
index 548294422c86619d02fa64bffd26df94f8d0fcd5..2ec360f3ed5606f36c24d5008221a54963fba445 100644
--- a/DDDigi/include/DDDigi/DigiActionSequence.h
+++ b/DDDigi/include/DDDigi/DigiActionSequence.h
@@ -54,23 +54,23 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiActionSequence(const DigiKernel& kernel, const std::string& nam);
+ DigiActionSequence(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiActionSequence();
/// Adopt a new action as part of the sequence. Sequence takes ownership.
virtual void adopt(DigiEventAction* action) override;
/// Register external listener callbacks before starting the sequence
template <typename Q, typename T>
- void begin(Q* p, void (T::*f)(DigiContext* context)) {
+ void begin(Q* p, void (T::*f)(context_t* context)) {
m_begin.add(p, f);
}
/// Register external listener callbacks after finishing the sequence
template <typename Q, typename T>
- void end(Q* p, void (T::*f)(DigiContext* context)) {
+ void end(Q* p, void (T::*f)(context_t* context)) {
m_end.add(p, f);
}
/// Begin-of-event callback
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
/// Definitiaon of the sequential action sequence
@@ -83,7 +83,7 @@ namespace dd4hep {
class DigiSequentialActionSequence : public DigiActionSequence {
public:
/// Standard constructor
- DigiSequentialActionSequence(const DigiKernel& kernel, const std::string& nam);
+ DigiSequentialActionSequence(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiSequentialActionSequence();
};
@@ -98,7 +98,7 @@ namespace dd4hep {
class DigiParallelActionSequence : public DigiActionSequence {
public:
/// Standard constructor
- DigiParallelActionSequence(const DigiKernel& kernel, const std::string& nam);
+ DigiParallelActionSequence(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiParallelActionSequence();
};
diff --git a/DDDigi/include/DDDigi/DigiAttenuator.h b/DDDigi/include/DDDigi/DigiAttenuator.h
index b5ed824d6efd0a63b71896814cacbd68fcb8405e..a5d85b88689e16b1ef083d3201581d008a43abc4 100644
--- a/DDDigi/include/DDDigi/DigiAttenuator.h
+++ b/DDDigi/include/DDDigi/DigiAttenuator.h
@@ -63,9 +63,9 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiAttenuator(const DigiKernel& kernel, const std::string& nam);
+ DigiAttenuator(const kernel_t& kernel, const std::string& nam);
/// Main functional callback adapter
- virtual void execute(DigiContext& context, work_t& work, const predicate_t& predicate) const override;
+ virtual void execute(context_t& context, work_t& work, const predicate_t& predicate) const override;
};
/// Default base class for all Digitizer actions and derivates thereof.
@@ -96,11 +96,11 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiAttenuatorSequence(const DigiKernel& kernel, const std::string& nam);
+ DigiAttenuatorSequence(const kernel_t& kernel, const std::string& nam);
/// Initialization callback
virtual void initialize();
/// Main functional callback
- virtual void execute(DigiContext& context) const;
+ virtual void execute(context_t& context) const;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiContainerCombine.h b/DDDigi/include/DDDigi/DigiContainerCombine.h
index 043fbea97b49c73735f20cc16a74686068e75dd3..6343c0ff40bcda0cb700dbb107bd01e0c147fc8f 100644
--- a/DDDigi/include/DDDigi/DigiContainerCombine.h
+++ b/DDDigi/include/DDDigi/DigiContainerCombine.h
@@ -83,7 +83,7 @@ namespace dd4hep {
void have_workers(size_t len) const;
/// Combine selected containers to one single deposit container
- std::size_t combine_containers(DigiContext& context,
+ std::size_t combine_containers(context_t& context,
DigiEvent& event,
DataSegment& inputs,
DataSegment& outputs) const;
@@ -93,10 +93,10 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiContainerCombine(const DigiKernel& kernel, const std::string& name);
+ DigiContainerCombine(const kernel_t& kernel, const std::string& name);
/// Main functional callback
- virtual void execute(DigiContext& context) const;
+ virtual void execute(context_t& context) const;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiContainerDrop.h b/DDDigi/include/DDDigi/DigiContainerDrop.h
index 38e978ae8a8c6ca96ab431605a6931d8ab8e82a3..6083701174a12d89f95d1f4b1111cc684b53806a 100644
--- a/DDDigi/include/DDDigi/DigiContainerDrop.h
+++ b/DDDigi/include/DDDigi/DigiContainerDrop.h
@@ -41,15 +41,15 @@ namespace dd4hep {
protected:
/// Property: Container names to be loaded
- std::vector<std::string> m_containers { };
+ std::vector<std::string> m_containers { };
/// Property: Input data segment name
- std::string m_input_segment;
+ std::string m_input_segment;
/// Property: event masks to be handled
- std::vector<int> m_input_masks { };
+ std::vector<int> m_input_masks { };
/// Fully qualified keys of all containers to be manipulated
- std::set<Key::key_type> m_keys { };
+ std::set<Key::key_type> m_keys { };
/// Container keys of all containers to be manipulated
- std::set<Key::itemkey_type> m_cont_keys { };
+ std::set<Key::itemkey_type> m_cont_keys { };
/// Worker objects to be submitted to TBB each performing part of the job
Workers m_workers;
@@ -69,10 +69,10 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiContainerDrop(const DigiKernel& kernel, const std::string& name);
+ DigiContainerDrop(const kernel_t& kernel, const std::string& name);
/// Main functional callback
- virtual void execute(DigiContext& context) const;
+ virtual void execute(context_t& context) const;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiContainerProcessor.h b/DDDigi/include/DDDigi/DigiContainerProcessor.h
index 621370e94b3a6c96d0569010a499a01e9743b419..0dcfee5e137bc89b421df12f094b02bb3ef15bfe 100644
--- a/DDDigi/include/DDDigi/DigiContainerProcessor.h
+++ b/DDDigi/include/DDDigi/DigiContainerProcessor.h
@@ -29,9 +29,9 @@ namespace dd4hep {
namespace digi {
/// Forward declarations
+ class DigiSegmentContext;
class DigiContainerSequence;
class DigiContainerProcessor;
- class DigiSegmentProcessContext;
class DigiContainerSequenceAction;
class DigiMultiContainerProcessor;
@@ -44,11 +44,11 @@ namespace dd4hep {
*/
class DigiContainerProcessor : public DigiAction {
public:
- using segment_t = DataSegment;
- using context_t = DigiContext;
+ /// Structure imports
using action_t = DigiAction;
+ using segment_t = DataSegment;
using property_t = PropertyManager;
- using segmentation_t = DigiSegmentProcessContext;
+ using segmentation_t = DigiSegmentContext;
/// Input definition
struct input_t {
@@ -66,23 +66,30 @@ namespace dd4hep {
/// Hit processing predicate
struct predicate_t {
- Callback callback;
- const segmentation_t& segmentation;
- predicate_t(const segmentation_t& s) : segmentation(s) {}
- predicate_t(const Callback& cb, const segmentation_t& s) : callback(cb), segmentation(s) {}
+ Callback callback { };
+ uint32_t id { 0 };
+ const segmentation_t* segmentation { nullptr };
+ predicate_t() = default;
+ predicate_t(predicate_t&& copy) = default;
+ predicate_t(const predicate_t& copy) = default;
+ predicate_t(const Callback& c, uint32_t i, const segmentation_t* s)
+ : callback(c), id(i), segmentation(s) {}
+ predicate_t& operator = (predicate_t&& copy) = default;
+ predicate_t& operator = (const predicate_t& copy) = default;
/// Check if a deposit should be processed
bool operator()(const std::pair<const CellID, EnergyDeposit>& deposit) const;
};
+ /// Work definition
struct work_t {
/// Event processing context
- context_t& context;
+ context_t& context;
/// Input data
- input_t input;
+ input_t input;
/// Output data
- output_t& output;
+ output_t& output;
/// Optional properties
- const property_t& properties;
+ const property_t& properties;
/// Basic check if input data are present
bool has_input() const { return this->input.data.has_value(); }
@@ -107,13 +114,19 @@ namespace dd4hep {
static const predicate_t& accept_all();
/// Standard constructor
- DigiContainerProcessor(const DigiKernel& kernel, const std::string& name);
+ DigiContainerProcessor(const kernel_t& kernel, const std::string& name);
/// Default destructor
virtual ~DigiContainerProcessor();
/// Main functional callback adapter
- virtual void execute(DigiContext& context, work_t& work, const predicate_t& predicate) const;
+ virtual void execute(context_t& context, work_t& work, const predicate_t& predicate) const;
};
+ /// Check if a deposit should be processed
+ inline bool DigiContainerProcessor::predicate_t::operator()(const std::pair<const CellID, EnergyDeposit>& deposit) const {
+ const void* args[] = { &deposit };
+ return this->callback.execute(args);
+ }
+
/// Worker class act on containers in an event identified by input masks and container name
/**
* The sequencer calls all registered processors for the contaiers registered.
@@ -124,6 +137,7 @@ namespace dd4hep {
*/
class DigiContainerSequence : public DigiContainerProcessor {
protected:
+ /// Structure imports
using self_t = DigiContainerSequence;
using processor_t = DigiContainerProcessor;
using worker_t = DigiParallelWorker<processor_t,work_t>;
@@ -150,11 +164,11 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiContainerSequence(const DigiKernel& kernel, const std::string& name);
+ DigiContainerSequence(const kernel_t& kernel, const std::string& name);
/// Adopt new parallel worker
virtual void adopt_processor(DigiContainerProcessor* action);
/// Main functional callback adapter
- virtual void execute(DigiContext& context, work_t& work, const predicate_t& predicate) const;
+ virtual void execute(context_t& context, work_t& work, const predicate_t& predicate) const;
};
/// Worker base class to analyse containers from the input segment in parallel
@@ -169,23 +183,28 @@ namespace dd4hep {
class DigiContainerSequenceAction : public DigiEventAction {
protected:
- /// Argument structure for client calls
+ /// Structure imports
using action_t = DigiAction;
using self_t = DigiContainerSequenceAction;
using processor_t = DigiContainerProcessor;
using output_t = processor_t::output_t;
using property_t = processor_t::property_t;
+
+ /// Single worker work item definition
struct work_item_t {
Key key;
std::any* data;
};
+ /// Work definition structure
+ /// Argument structure for client calls
struct work_t {
- DigiContext& context;
+ context_t& context;
std::vector<work_item_t> input_items;
output_t& output;
const property_t& properties;
const self_t& parent;
};
+
using worker_t = DigiParallelWorker<processor_t, work_t>;
using workers_t = DigiParallelWorkers<worker_t>;
using reg_workers_t = std::map<Key, worker_t*>;
@@ -225,13 +244,13 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiContainerSequenceAction(const DigiKernel& kernel, const std::string& name);
+ DigiContainerSequenceAction(const kernel_t& kernel, const std::string& name);
/// Adopt new parallel worker acting on one single container
void adopt_processor(DigiContainerProcessor* action, const std::string& container);
/// Adopt new parallel worker acting on multiple containers
void adopt_processor(DigiContainerProcessor* action, const std::vector<std::string>& containers);
/// Main functional callback if specific work is known
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
/// Sequencer class to analyse containers from the input segment in parallel
@@ -252,7 +271,7 @@ namespace dd4hep {
/// Argument structure required to support multiple client calls
struct work_t {
- DigiContext& context;
+ context_t& context;
work_items_t& items;
output_t& output;
const property_t& properties;
@@ -298,7 +317,7 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiMultiContainerProcessor(const DigiKernel& kernel, const std::string& name);
+ DigiMultiContainerProcessor(const kernel_t& kernel, const std::string& name);
const std::vector<Key>& worker_keys(size_t worker_id) const {
return this->m_worker_keys.at(worker_id);
}
@@ -308,7 +327,7 @@ namespace dd4hep {
/// Adopt new parallel worker
void adopt_processor(DigiContainerProcessor* action, const std::vector<std::string>& containers);
/// Main functional callback
- virtual void execute(DigiContext& context) const;
+ virtual void execute(context_t& context) const;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiInputAction.h b/DDDigi/include/DDDigi/DigiInputAction.h
index 584775b0768599a7be62ea29cf0b7c7c57bbc6a3..bb605b417e17246ce707e322ef0df8ac0627615d 100644
--- a/DDDigi/include/DDDigi/DigiInputAction.h
+++ b/DDDigi/include/DDDigi/DigiInputAction.h
@@ -53,7 +53,7 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiInputAction(const DigiKernel& kernel, const std::string& nam);
+ DigiInputAction(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiInputAction();
@@ -70,7 +70,7 @@ namespace dd4hep {
return m_input_mask;
}
/// Callback to read event input
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiLockedAction.h b/DDDigi/include/DDDigi/DigiLockedAction.h
index 034575359199eec7a8a274329acba6ec71580252..992e70d4315de8885d24d2cff5a90d22e52deade 100644
--- a/DDDigi/include/DDDigi/DigiLockedAction.h
+++ b/DDDigi/include/DDDigi/DigiLockedAction.h
@@ -49,13 +49,13 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiLockedAction(const DigiKernel& kernel, const std::string& nam);
+ DigiLockedAction(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiLockedAction();
/// Underlying object to be used during the locked execution
void use(DigiEventAction* action);
/// Callback to read event locked
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
} // End namespace digi
diff --git a/DDDigi/include/DDDigi/DigiOutputAction.h b/DDDigi/include/DDDigi/DigiOutputAction.h
index 17314301fb723d082170999315fdfa5e5d058474..ae67ca80b934d5cb334bfe952710eba8c5c6ff1a 100644
--- a/DDDigi/include/DDDigi/DigiOutputAction.h
+++ b/DDDigi/include/DDDigi/DigiOutputAction.h
@@ -51,12 +51,12 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiOutputAction(const DigiKernel& kernel, const std::string& nam);
+ DigiOutputAction(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiOutputAction();
/// Callback to read event output
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
} // End namespace digi
diff --git a/DDDigi/include/DDDigi/DigiSegmentSplitter.h b/DDDigi/include/DDDigi/DigiSegmentSplitter.h
index 901854cc3dc54d50504b7b7c4c4495b6682dd183..85a046b55b99a79d8956ac044e95d05a4e238ab7 100644
--- a/DDDigi/include/DDDigi/DigiSegmentSplitter.h
+++ b/DDDigi/include/DDDigi/DigiSegmentSplitter.h
@@ -15,9 +15,9 @@
// Framework include files
#include <DDDigi/DigiEventAction.h>
-#include <DDDigi/DigiContainerProcessor.h>
-#include <DDDigi/DigiSegmentationTool.h>
#include <DDDigi/DigiParallelWorker.h>
+#include <DDDigi/DigiSegmentationTool.h>
+#include <DDDigi/DigiContainerProcessor.h>
/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
@@ -37,16 +37,15 @@ namespace dd4hep {
class DigiSegmentProcessContext : public DigiSegmentContext {
public:
using predicate_t = DigiContainerProcessor::predicate_t;
- predicate_t predicate { {}, *this };
- uint32_t id { 0 };
+ predicate_t predicate;
public:
/// Default constructor
DigiSegmentProcessContext() = default;
- /// Default move constructor
- DigiSegmentProcessContext(DigiSegmentProcessContext&& copy) = default;
/// Default copy constructor
DigiSegmentProcessContext(const DigiSegmentContext& copy);
+ /// Default move constructor
+ DigiSegmentProcessContext(DigiSegmentProcessContext&& copy) = default;
/// Default copy constructor
DigiSegmentProcessContext(const DigiSegmentProcessContext& copy) = default;
/// Default destructor
@@ -62,18 +61,35 @@ namespace dd4hep {
std::string identifier() const;
/// Check a given cell id if it matches this selection
bool matches(uint64_t cell) const {
- return this->split_id(cell) == this->id;
+ return this->split_id(cell) == this->predicate.id;
+ }
+ /// Check a given cell id if it matches this selection
+ bool matches(CellID cell) const {
+ return this->split_id(cell) == this->predicate.id;
}
+
+ /// Check if a deposit should be processed
+ bool use_depo(const std::pair<const CellID, EnergyDeposit>* deposit) const {
+ return this->matches(deposit->first);
+ }
+ void enable(uint32_t split_id);
};
+ /// Predicate function to accept a subset of segment entries
+ /**
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_DIGITIZATION
+ */
struct accept_segment_t : public DigiContainerProcessor::predicate_t {
- using segmentation_t = DigiSegmentProcessContext;
- accept_segment_t(const segmentation_t& s) : predicate_t( { this }, s) {
- auto fptr = &accept_segment_t::operator();
- callback.make(fptr);
+ accept_segment_t(const DigiSegmentContext* s, uint32_t i)
+ : predicate_t( {}, i, s) {
+ callback = Callback(this).make(&accept_segment_t::use_depo);
}
- inline bool operator()(const std::pair<const CellID, EnergyDeposit>& depo) const {
- return this->segmentation.matches(depo.first);
+ /// Check if a deposit should be processed
+ bool use_depo(const std::pair<const CellID, EnergyDeposit>* deposit) const {
+ return this->segmentation->split_id(deposit->first) == this->id;
}
};
@@ -88,41 +104,46 @@ namespace dd4hep {
*/
class DigiSegmentSplitter : public DigiContainerProcessor {
protected:
+
+ /** Local use definitions */
using self_t = DigiSegmentSplitter;
+ using tool_t = DigiSegmentationTool;
using split_t = std::pair<DetElement, VolumeID>;
using splits_t = std::map<VolumeID, split_t>;
using segment_t = DigiSegmentProcessContext;
using processor_t = DigiContainerProcessor;
+
using worker_t = DigiParallelWorker<processor_t,work_t, segment_t>;
using workers_t = DigiParallelWorkers<worker_t>;
friend class DigiParallelWorker<processor_t, work_t, segment_t>;
protected:
+
/** Object properties */
/// Property: Split element of the ID descriptor
std::string m_processor_type;
- /// Name of the subdetector to be handed
+ /// Property: Name of the subdetector to be handed
std::string m_detector_name;
- /// Splitter field in the segmentation description
+ /// Property: Splitter field in the segmentation description
std::string m_split_by;
+ /// Property to steer parallel processing
+ bool m_parallel { false };
/// Property: Flag if processors should be shared
bool m_share_processor { true };
/** Member variables */
- /// Segmentation too instance
- mutable DigiSegmentationTool m_split_tool;
- /// Segmentation split context
- DigiSegmentContext m_split_context;
/// Data keys from the readout collection names
- std::vector<Key> m_keys;
+ std::vector<Key> m_keys;
+ /// Segmentation split context
+ segment_t m_split_context;
/// Split elements used to parallelize the processing
- splits_t m_splits;
- /// Property to steer parallel processing
- bool m_parallel { false };
+ splits_t m_splits;
/// Array of sub-workers
- workers_t m_workers;
+ workers_t m_workers;
/// Lock for output merging
- mutable std::mutex m_output_lock;
+ mutable std::mutex m_output_lock;
+ /// Segmentation too instance
+ mutable tool_t m_split_tool;
protected:
/// Default destructor
@@ -139,11 +160,11 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiSegmentSplitter(const DigiKernel& kernel, const std::string& name);
+ DigiSegmentSplitter(const kernel_t& kernel, const std::string& name);
/// Access the readout collection keys
std::vector<std::string> collection_names() const;
/// Main functional callback
- virtual void execute(DigiContext& context, work_t& work, const predicate_t& predicate) const override;
+ virtual void execute(context_t& context, work_t& work, const predicate_t& predicate) const override;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiSegmentationTool.h b/DDDigi/include/DDDigi/DigiSegmentationTool.h
index 6ef34f1449240cac3b69052824598bb62bd0afde..713a4afa9568ccdbb6ecaa04d7fd4ff576105e03 100644
--- a/DDDigi/include/DDDigi/DigiSegmentationTool.h
+++ b/DDDigi/include/DDDigi/DigiSegmentationTool.h
@@ -30,8 +30,6 @@ namespace dd4hep {
/// Segmentation split context
/**
- *
- *
*
* \author M.Frank
* \version 1.0
@@ -39,15 +37,16 @@ namespace dd4hep {
*/
class DigiSegmentContext {
public:
- DetElement detector { };
- IDDescriptor idspec { };
- const BitFieldElement* field { nullptr };
- uint64_t cell_mask { ~0x0UL };
- uint64_t det_mask { 0UL };
- uint64_t split_mask { 0UL };
- int32_t offset { 0 };
- int32_t width { 0 };
- int32_t max_split { 0 };
+ using field_t = const BitFieldElement;
+ DetElement detector { };
+ IDDescriptor idspec { };
+ field_t* field { nullptr };
+ uint64_t cell_mask { ~0x0UL };
+ uint64_t det_mask { 0UL };
+ uint64_t split_mask { 0UL };
+ int32_t offset { 0 };
+ int32_t width { 0 };
+ int32_t max_split { 0 };
public:
/// Default constructor
@@ -67,18 +66,20 @@ namespace dd4hep {
const std::string& name() const;
/// Split field name
const char* cname() const;
+ /// Full identifier (field + id)
+ std::string identifier(uint32_t id) const;
/// Get the identifier of the cell to be split
uint32_t split_id(uint64_t cell) const {
- return int( (cell & this->split_mask) >> this->offset );
+ return uint32_t( (cell & this->split_mask) >> this->offset );
}
/// The CELL ID part of the identifier
uint64_t cell_id(uint64_t cell) const {
- return ( (cell & this->cell_mask) >> (this->offset + width) );
+ return uint64_t( uint64_t(cell & this->cell_mask) >> (this->offset + width) );
}
/// The identifier of the parent detector
uint64_t detector_id(uint64_t cell) const {
- return (cell & this->det_mask);
+ return uint64_t(cell & this->det_mask);
}
};
diff --git a/DDDigi/include/DDDigi/DigiStoreDump.h b/DDDigi/include/DDDigi/DigiStoreDump.h
index 6f9a6cc5f894b8ff9cb92b2e86927f6e613485fc..be581e83791f943047dd8b07b7cc30f133e809d9 100644
--- a/DDDigi/include/DDDigi/DigiStoreDump.h
+++ b/DDDigi/include/DDDigi/DigiStoreDump.h
@@ -48,6 +48,8 @@ namespace dd4hep {
std::vector<int> m_masks { };
std::vector<Key::itemkey_type> m_container_items { };
+ using records_t = std::vector<std::string>;
+
protected:
/// Define standard assignments and constructors
DDDIGI_DEFINE_ACTION_CONSTRUCTORS(DigiStoreDump);
@@ -56,23 +58,23 @@ namespace dd4hep {
virtual ~DigiStoreDump();
template <typename T> std::string data_header(Key key, const std::string& tag, const T& data) const;
- template <typename T> std::vector<std::string> dump_history(DigiContext& context, Key key, const T& container) const;
- template <typename T> std::vector<std::string> dump_history(DigiContext& context, Key key, const T& item, std::size_t seq_no) const;
+ template <typename T> records_t dump_history(context_t& context, Key key, const T& container) const;
+ template <typename T> records_t dump_history(context_t& context, Key key, const T& item, std::size_t seq_no) const;
- std::vector<std::string>
- dump_deposit_history(DigiContext& context, Key container_key, const DepositMapping& container) const;
+ records_t
+ dump_deposit_history(context_t& context, Key container_key, const DepositMapping& container) const;
- std::vector<std::string>
- dump_deposit_history(DigiContext& context, Key container_key, const DepositVector& container) const;
+ records_t
+ dump_deposit_history(context_t& context, Key container_key, const DepositVector& container) const;
- std::vector<std::string>
- dump_particle_history(DigiContext& context, Key container_key, const ParticleMapping& container) const;
+ records_t
+ dump_particle_history(context_t& context, Key container_key, const ParticleMapping& container) const;
/// Dump hit container
void dump_headers(const std::string& tag, const DigiEvent& event, const DataSegment& segment) const;
/// Dump hit container
- void dump_history(DigiContext& context, const std::string& tag, const DigiEvent& event, const DataSegment& cont) const;
+ void dump_history(context_t& context, const std::string& tag, const DigiEvent& event, const DataSegment& cont) const;
/// Initialize the action
virtual void initialize();
@@ -81,7 +83,7 @@ namespace dd4hep {
/// Standard constructor
DigiStoreDump(const DigiKernel& kernel, const std::string& nam);
/// Main functional callback
- virtual void execute(DigiContext& context) const;
+ virtual void execute(context_t& context) const;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/include/DDDigi/DigiSynchronize.h b/DDDigi/include/DDDigi/DigiSynchronize.h
index 3c4c565b8b3176a1f5f95dceb72322df464ccc5d..6a16e2b4547c748ba1c557705790bfd78c64cae2 100644
--- a/DDDigi/include/DDDigi/DigiSynchronize.h
+++ b/DDDigi/include/DDDigi/DigiSynchronize.h
@@ -34,8 +34,8 @@ namespace dd4hep {
*/
class DigiSynchronize : public DigiEventAction {
protected:
- using Worker = DigiParallelWorker<DigiEventAction,DigiContext,int>;
- using Workers = DigiParallelWorkers<Worker>;
+ using Worker = DigiParallelWorker<DigiEventAction,context_t,int>;
+ using Workers = DigiParallelWorkers<Worker>;
/// The list of action objects to be called
Workers m_actors;
@@ -45,13 +45,13 @@ namespace dd4hep {
public:
/// Standard constructor
- DigiSynchronize(const DigiKernel& kernel, const std::string& nam);
+ DigiSynchronize(const kernel_t& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiSynchronize();
/// Adopt a new action as part of the sequence. Sequence takes ownership.
virtual void adopt(DigiEventAction* action);
/// Begin-of-event callback
- virtual void execute(DigiContext& context) const override;
+ virtual void execute(context_t& context) const override;
};
} // End namespace digi
} // End namespace dd4hep
diff --git a/DDDigi/plugins/DigiSegmentDepositExtractor.cpp b/DDDigi/plugins/DigiSegmentDepositExtractor.cpp
index 48c81e463c7899cf84b0664e3211c493cb81f138..5039e39eb3a4e0137b3c9ed61bf68d7a99742685 100644
--- a/DDDigi/plugins/DigiSegmentDepositExtractor.cpp
+++ b/DDDigi/plugins/DigiSegmentDepositExtractor.cpp
@@ -17,6 +17,7 @@
/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
+
/// Namespace for the Digitization part of the AIDA detector description toolkit
namespace digi {
@@ -59,6 +60,6 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-
+// Factory definitiony
#include <DDDigi/DigiFactories.h>
DECLARE_DIGIACTION_NS(dd4hep::digi,DigiSegmentDepositExtractor)
diff --git a/DDDigi/plugins/DigiSegmentDepositPrint.cpp b/DDDigi/plugins/DigiSegmentDepositPrint.cpp
index db28f56d0dcc3bdccc8eccfa4f8d7d18820a68e1..5a17bf7da66f0fd98f4aa4b48835e07d10327ba1 100644
--- a/DDDigi/plugins/DigiSegmentDepositPrint.cpp
+++ b/DDDigi/plugins/DigiSegmentDepositPrint.cpp
@@ -40,7 +40,7 @@ namespace dd4hep {
print(const char* fmt, const T& cont, const predicate_t& predicate) const {
for( const auto& dep : cont ) {
if( predicate(dep) ) {
- info(fmt, predicate.segmentation.split_id(dep.first), dep.first,
+ info(fmt, predicate.segmentation->split_id(dep.first), dep.first,
dep.second.history.hits.size(),
dep.second.history.particles.size(),
dep.second.deposit);
@@ -55,8 +55,8 @@ namespace dd4hep {
"%s[%s] %s-id: %%d [processor:%d] Cell: %%016lX mask: %016lX "
"hist:%%4ld hits %%4ld parts. entries deposit: %%f",
context.event->id(),
- predicate.segmentation.idspec.name(), predicate.segmentation.cname(),
- predicate.segmentation.id, predicate.segmentation.split_mask);
+ predicate.segmentation->idspec.name(), predicate.segmentation->cname(),
+ predicate.id, predicate.segmentation->split_mask);
if ( const auto* m = work.get_input<DepositMapping>() )
print(format, *m, predicate);
else if ( const auto* v = work.get_input<DepositVector>() )
@@ -67,6 +67,6 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-
+// Factory definition
#include <DDDigi/DigiFactories.h>
DECLARE_DIGIACTION_NS(dd4hep::digi,DigiSegmentDepositPrint)
diff --git a/DDDigi/plugins/DigiSimpleADCResponse.cpp b/DDDigi/plugins/DigiSimpleADCResponse.cpp
index 5f5c52cec1106a36a4864f752cb658c51f227794..564756338dcc91ca2cc6b7814893f658513e48d1 100644
--- a/DDDigi/plugins/DigiSimpleADCResponse.cpp
+++ b/DDDigi/plugins/DigiSimpleADCResponse.cpp
@@ -21,6 +21,7 @@
/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
+
/// Namespace for the Digitization part of the AIDA detector description toolkit
namespace digi {
@@ -28,7 +29,6 @@ namespace dd4hep {
using segmentation_t = DigiSegmentProcessContext;
std::string m_response_postfix { ".adc" };
std::string m_history_postfix { ".hist" };
- double m_use_segmentation { false };
double m_signal_cutoff { std::numeric_limits<double>::epsilon() };
double m_signal_saturation { std::numeric_limits<double>::max() };
double m_adc_offset { 0e0 };
@@ -49,7 +49,7 @@ namespace dd4hep {
/// Create container with ADC counts and register it to the output segment
template <typename T, typename P>
void emulate_adc(const char* tag, const T& input, work_t& work, const P& predicate) const {
- std::string postfix = m_use_segmentation ? "."+predicate.segmentation.identifier() : std::string();
+ std::string postfix = predicate.segmentation ? "."+predicate.segmentation->identifier(predicate.id) : std::string();
std::string history_name = input.name + postfix + m_history_postfix;
std::string response_name = input.name + postfix + m_response_postfix;
DetectorHistory history (history_name, work.output.mask);
@@ -86,14 +86,12 @@ namespace dd4hep {
/// Main functional callback
virtual void execute(DigiContext& context, work_t& work, const predicate_t& predicate) const final {
- if ( !m_use_segmentation )
- emulate_adc(context, work, accept_all());
- else if ( predicate.segmentation.matches(work.input.key.value()) )
- emulate_adc(context, work, accept_segment_t(predicate.segmentation));
+ emulate_adc(context, work, predicate);
}
};
} // End namespace digi
} // End namespace dd4hep
-
+// Factory definition
#include <DDDigi/DigiFactories.h>
DECLARE_DIGIACTION_NS(dd4hep::digi,DigiSimpleADCResponse)
+
diff --git a/DDDigi/python/dddigi.py b/DDDigi/python/dddigi.py
index 8f7b02ebaac642bb212184b996463f7dcc2bde64..eb9028727dbd1731f14f3614a833effd9b8e428c 100644
--- a/DDDigi/python/dddigi.py
+++ b/DDDigi/python/dddigi.py
@@ -309,12 +309,12 @@ def _props(obj, **extensions):
cls = getattr(current, obj)
for extension in extensions.items():
call = extension[0]
- # print('TRY: Overloading: '+str(cls)+' '+call+' to __'+call+' '+str(hasattr(cls, call)))
+ # print('TRY: Overloading: ' + str(cls) + ' ' + call + ' to __' + call + ' ' + str(hasattr(cls, call)))
if hasattr(cls, call):
- # print('Overloading: '+str(cls)+' '+call+' to __'+call)
+ # print('Overloading: ' + str(cls) + ' ' + call + ' to __' + call)
setattr(cls, '__' + call, getattr(cls, call))
else:
- print('FAILED: Overloading: '+str(cls)+' '+call+' to __'+call+' '+str(hasattr(cls, call)))
+ print('FAILED: Overloading: ' + str(cls) + ' '+call + ' to __' + call + ' ' + str(hasattr(cls, call)))
setattr(cls, call, extension[1])
cls.__getattr__ = _get
cls.__setattr__ = _set
diff --git a/DDDigi/src/DigiContainerProcessor.cpp b/DDDigi/src/DigiContainerProcessor.cpp
index 040a7731b44e47a5d0a69706027ab8636bcd52d9..c93dba1926c6c88eb0b683bddc08ba73f4842fff 100644
--- a/DDDigi/src/DigiContainerProcessor.cpp
+++ b/DDDigi/src/DigiContainerProcessor.cpp
@@ -85,21 +85,13 @@ const DigiContainerProcessor::predicate_t& DigiContainerProcessor::accept_all()
bool use(const std::pair<const CellID, EnergyDeposit>&) const {
return true;
}
- };
- static true_t s_y { };
- static segmentation_t s_seg {};
- static predicate_t s_true { Callback(&s_y).make(&true_t::use), s_seg };
- return s_true;
-}
-
-/// Check if a deposit should be processed
-bool DigiContainerProcessor::predicate_t::operator()(const std::pair<const CellID, EnergyDeposit>& deposit) const {
- const void* args[] = { &deposit };
- return this->callback.execute(args);
+ } s_true;
+ static predicate_t s_pred { Callback(&s_true).make(&true_t::use), 0, nullptr };
+ return s_pred;
}
/// Standard constructor
-DigiContainerProcessor::DigiContainerProcessor(const DigiKernel& kernel, const std::string& name)
+DigiContainerProcessor::DigiContainerProcessor(const kernel_t& kernel, const std::string& name)
: DigiAction(kernel, name)
{
InstanceCount::increment(this);
@@ -111,13 +103,13 @@ DigiContainerProcessor::~DigiContainerProcessor() {
}
/// Main functional callback if specific work is known
-void DigiContainerProcessor::execute(DigiContext& /* context */,
+void DigiContainerProcessor::execute(context_t& /* context */,
work_t& /* work */,
const predicate_t& /* predicate */) const {
}
/// Standard constructor
-DigiContainerSequence::DigiContainerSequence(const DigiKernel& krnl, const std::string& nam)
+DigiContainerSequence::DigiContainerSequence(const kernel_t& krnl, const std::string& nam)
: DigiContainerProcessor(krnl, nam)
{
declareProperty("parallel", m_parallel = false);
@@ -139,7 +131,7 @@ void DigiContainerSequence::adopt_processor(DigiContainerProcessor* action) {
}
/// Main functional callback if specific work is known
-void DigiContainerSequence::execute(DigiContext& context, work_t& work, const predicate_t& /* predicate */) const {
+void DigiContainerSequence::execute(context_t& context, work_t& work, const predicate_t& /* predicate */) const {
auto group = m_workers.get_group();
m_kernel.submit(context, group, m_workers.size(), &work, m_parallel);
}
@@ -148,12 +140,12 @@ void DigiContainerSequence::execute(DigiContext& context, work_t& work, const pr
template <> void DigiParallelWorker<DigiContainerProcessor,
DigiContainerSequence::work_t,
std::size_t>::execute(void* data) const {
- calldata_t* args = reinterpret_cast<calldata_t*>(data);
- action->execute(args->context, *args, action->accept_all());
+ calldata_t* arg = reinterpret_cast<calldata_t*>(data);
+ action->execute(arg->context, *arg, action->accept_all());
}
/// Standard constructor
-DigiContainerSequenceAction::DigiContainerSequenceAction(const DigiKernel& krnl, const std::string& nam)
+DigiContainerSequenceAction::DigiContainerSequenceAction(const kernel_t& krnl, const std::string& nam)
: DigiEventAction(krnl, nam)
{
declareProperty("input_mask", m_input_mask);
@@ -227,27 +219,27 @@ DigiContainerSequenceAction::need_registered_worker(Key item_key, bool exc) co
}
/// Main functional callback if specific work is known
-void DigiContainerSequenceAction::execute(DigiContext& context) const {
- auto& event = *context.event;
- auto& inputs = event.get_segment(m_input_segment);
- auto& outputs = event.get_segment(m_output_segment);
+void DigiContainerSequenceAction::execute(context_t& context) const {
std::vector<ParallelWorker*> event_workers;
- output_t output { m_output_mask, outputs };
- work_t args { context, { }, output, m_properties, *this };
-
- args.input_items.resize(m_workers.size(), { { }, nullptr });
- event_workers.reserve(inputs.size());
- for( auto& i : inputs ) {
+ auto& event = *context.event;
+ auto& input = event.get_segment(m_input_segment);
+ auto& output = event.get_segment(m_output_segment);
+ output_t out { m_output_mask, output };
+ work_t arg { context, { }, out, m_properties, *this };
+
+ arg.input_items.resize(m_workers.size(), { { }, nullptr });
+ event_workers.reserve(input.size());
+ for( auto& i : input ) {
Key key(i.first);
if ( key.mask() == m_input_mask ) {
if ( worker_t* w = need_registered_worker(key, false) ) {
event_workers.emplace_back(w);
- args.input_items[w->options] = { key, &i.second };
+ arg.input_items[w->options] = { key, &i.second };
}
}
}
if ( !event_workers.empty() ) {
- m_kernel.submit(context, &event_workers.at(0), event_workers.size(), &args, m_parallel);
+ m_kernel.submit(context, &event_workers.at(0), event_workers.size(), &arg, m_parallel);
}
}
@@ -255,20 +247,20 @@ void DigiContainerSequenceAction::execute(DigiContext& context) const {
template <> void DigiParallelWorker<DigiContainerProcessor,
DigiContainerSequenceAction::work_t,
std::size_t>::execute(void* data) const {
- calldata_t* args = reinterpret_cast<calldata_t*>(data);
- auto& item = args->input_items[this->options];
- DigiContainerProcessor::work_t work {args->context, {item.key, *item.data}, args->output, args->properties};
+ calldata_t* args = reinterpret_cast<calldata_t*>(data);
+ auto& item = args->input_items[this->options];
+ DigiContainerProcessor::work_t work { args->context, { item.key, *item.data }, args->output, args->properties };
action->execute(args->context, work, action->accept_all());
}
/// Standard constructor
-DigiMultiContainerProcessor::DigiMultiContainerProcessor(const DigiKernel& krnl, const std::string& nam)
+DigiMultiContainerProcessor::DigiMultiContainerProcessor(const kernel_t& krnl, const std::string& nam)
: DigiEventAction(krnl, nam)
{
- this->declareProperty("input_masks", m_input_masks);
- this->declareProperty("input_segment", m_input_segment);
- this->declareProperty("output_mask", m_output_mask);
- this->declareProperty("output_segment", m_output_segment);
+ declareProperty("input_masks", m_input_masks);
+ declareProperty("input_segment", m_input_segment);
+ declareProperty("output_mask", m_output_mask);
+ declareProperty("output_segment", m_output_segment);
m_kernel.register_initialize(Callback(this).make(&DigiMultiContainerProcessor::initialize));
InstanceCount::increment(this);
}
@@ -347,17 +339,17 @@ void DigiMultiContainerProcessor::adopt_processor(DigiContainerProcessor* action
}
/// Main functional callback
-void DigiMultiContainerProcessor::execute(DigiContext& context) const {
+void DigiMultiContainerProcessor::execute(context_t& context) const {
work_items_t work_items;
- auto& msk = m_input_masks;
- auto& event = *context.event;
- auto& inputs = event.get_segment(m_input_segment);
+ auto& mask = m_input_masks;
+ auto& event = *context.event;
+ auto& input = event.get_segment(m_input_segment);
- work_items.reserve(inputs.size());
- for( auto& i : inputs ) {
- Key key(i.first);
+ work_items.reserve(input.size());
+ for( auto& i : input ) {
+ Key key(i.first);
key.set_mask(0);
- bool use = msk.empty() || std::find(msk.begin(), msk.end(), key.mask()) != msk.end();
+ bool use = mask.empty() || std::find(mask.begin(), mask.end(), key.mask()) != mask.end();
if ( use ) {
use = m_work_items.empty() || m_work_items.find(key) != m_work_items.end();
if ( use ) {
@@ -366,10 +358,10 @@ void DigiMultiContainerProcessor::execute(DigiContext& context) const {
}
}
if ( !work_items.empty() ) {
- auto& outputs = event.get_segment(m_output_segment);
- output_t output { m_output_mask, outputs };
- work_t args { context, work_items, output, properties(), *this };
- m_kernel.submit(context, m_workers.get_group(), m_workers.size(), &args, m_parallel);
+ auto& output = event.get_segment(m_output_segment);
+ output_t out { m_output_mask, output };
+ work_t arg { context, work_items, out, properties(), *this };
+ m_kernel.submit(context, m_workers.get_group(), m_workers.size(), &arg, m_parallel);
}
}
@@ -406,4 +398,3 @@ template <> void DigiParallelWorker<DigiContainerProcessor,
#endif
}
}
-
diff --git a/DDDigi/src/DigiSegmentSplitter.cpp b/DDDigi/src/DigiSegmentSplitter.cpp
index 4944c8c63368b65e43b34790c77c1a9463d7e93b..1f016a5aae7b83289b39c0beec2f80094913b698 100644
--- a/DDDigi/src/DigiSegmentSplitter.cpp
+++ b/DDDigi/src/DigiSegmentSplitter.cpp
@@ -29,11 +29,7 @@ DigiSegmentProcessContext::DigiSegmentProcessContext(const DigiSegmentContext& c
/// Full identifier (field + id)
std::string DigiSegmentProcessContext::identifier() const {
- std::stringstream str;
- if ( this->field ) {
- str << this->field->name() << "." << this->id;
- }
- return str.str();
+ return this->DigiSegmentContext::identifier(this->predicate.id);
}
/// Default move assignment
@@ -43,6 +39,12 @@ DigiSegmentProcessContext::operator=(const DigiSegmentContext& copy) {
return *this;
}
+void DigiSegmentProcessContext::enable(uint32_t split_id) {
+ this->predicate.id = split_id;
+ this->predicate.segmentation = this;
+ this->predicate.callback = Callback(this).make(&DigiSegmentProcessContext::use_depo);
+}
+
/// Worker adaptor for caller DigiContainerSequence
template <> void DigiParallelWorker<DigiContainerProcessor,
DigiContainerProcessor::work_t,
@@ -52,10 +54,11 @@ template <> void DigiParallelWorker<DigiContainerProcessor,
}
/// Standard constructor
-DigiSegmentSplitter::DigiSegmentSplitter(const DigiKernel& kernel, const std::string& nam)
+DigiSegmentSplitter::DigiSegmentSplitter(const kernel_t& kernel, const std::string& nam)
: DigiContainerProcessor(kernel, nam),
m_split_tool(kernel.detectorDescription())
{
+ declareProperty("parallel", m_parallel = false);
declareProperty("detector", m_detector_name);
declareProperty("split_by", m_split_by);
declareProperty("processor_type", m_processor_type);
@@ -98,13 +101,12 @@ void DigiSegmentSplitter::initialize() {
const auto& workers = group.actors();
/// Create the processors:
for( auto& p : m_splits ) {
- auto split_id = p.second.second;
bool ok = false;
+ auto split_id = p.second.second;
for( auto* w : workers ) {
- if ( w->options.id == split_id ) {
- auto& segment = w->options;
- segment = m_split_context;
- segment.id = p.second.second;
+ if ( w->options.predicate.id == split_id ) {
+ w->options = m_split_context;
+ w->options.enable(split_id);
ok = true;
break;
}
@@ -114,7 +116,7 @@ void DigiSegmentSplitter::initialize() {
bad = true;
}
}
- if ( bad ) {
+ if ( bad ) {
except("+++ If you add processors by hand, do it properly! "
"Otherwise use the property 'processor_type'. "
"This setup is invalid.");
@@ -124,18 +126,16 @@ void DigiSegmentSplitter::initialize() {
/// IF NOT:
/// 2) Create the processors using the 'processor_type' option
for( auto& p : m_splits ) {
- ::snprintf(text, sizeof(text), "_%05X",
- m_split_context.split_id(p.first));
+ uint32_t id = m_split_context.split_id(p.first);
+ ::snprintf(text, sizeof(text), "_%05X", id);
std::string nam = this->name() + text;
auto* proc = createAction<DigiContainerProcessor>(m_processor_type, m_kernel, nam);
if ( !proc ) {
- except("+++ Failed to create split worker: %s/%s",
- m_processor_type.c_str(), nam.c_str());
+ except("+++ Failed to create split worker: %s/%s", m_processor_type.c_str(), nam.c_str());
}
+ info("+++ Created worker: %s layer: %d %d", nam.c_str(), p.first, id);
auto* w = new worker_t(proc, m_split_context);
- auto& segment = w->options;
- segment.detector = p.second.first;
- segment.id = p.second.second;
+ w->options.enable(id);
m_workers.insert(w);
++count;
}
@@ -145,22 +145,21 @@ void DigiSegmentSplitter::initialize() {
/// Adopt new parallel worker handling a single split identifier
void DigiSegmentSplitter::adopt_segment_processor(DigiContainerProcessor* action, int split_id) {
if ( !action ) {
- except("+++ FAILED: attempt to add invalid processor!");
+ except("+++ adopt_segment_processor: FAILED attempt to add invalid processor!");
}
auto* w = new worker_t(action, m_split_context);
- w->options.id = split_id;
+ w->options.enable(split_id);
m_workers.insert(w);
}
/// Adopt new parallel worker handling multiple split-identifiers
void DigiSegmentSplitter::adopt_segment_processor(DigiContainerProcessor* action, const std::vector<int>& ids) {
- for( int split_id : ids ) {
+ for( int split_id : ids )
adopt_segment_processor(action, split_id);
- }
}
/// Main functional callback
-void DigiSegmentSplitter::execute(DigiContext& context, work_t& work, const predicate_t& /* predicate */) const {
+void DigiSegmentSplitter::execute(context_t& context, work_t& work, const predicate_t& /* predicate */) const {
Key key = work.input_key();
Key unmasked_key;
unmasked_key.set_item(key.item());
diff --git a/DDDigi/src/DigiSegmentationTool.cpp b/DDDigi/src/DigiSegmentationTool.cpp
index 2355590da8bb96b229736febd1252159a609f06e..c8f94fde03f0f7b56ff69344f06bcc2ef3db574c 100644
--- a/DDDigi/src/DigiSegmentationTool.cpp
+++ b/DDDigi/src/DigiSegmentationTool.cpp
@@ -57,6 +57,15 @@ const char* DigiSegmentContext::cname() const {
return this->field ? this->field->name().c_str() : "";
}
+/// Full identifier (field + id)
+std::string DigiSegmentContext::identifier(uint32_t id) const {
+ std::stringstream str;
+ if ( this->field ) {
+ str << this->field->name() << "." << id;
+ }
+ return str.str();
+}
+
/// Initializing constructor
DigiSegmentationTool::DigiSegmentationTool(Detector& desc)
: description(desc)
diff --git a/examples/DDDigi/scripts/DigiTest.py b/examples/DDDigi/scripts/DigiTest.py
index 798594a98e6e4094bbad3124be21af8a27bcfae5..9b0c5b298bb20ec70488375c434a204adb768244 100644
--- a/examples/DDDigi/scripts/DigiTest.py
+++ b/examples/DDDigi/scripts/DigiTest.py
@@ -10,7 +10,6 @@
# ==========================================================================
from __future__ import absolute_import
import os
-import dd4hep
import dddigi
import logging
from dd4hep import units
diff --git a/examples/DDDigi/scripts/TestSegmentationSplit.py b/examples/DDDigi/scripts/TestSegmentationSplit.py
index 6ff313bad24285e4c942e1a9699b7c806c48ef02..e64c83806f7d9fdcb838b76e4330bfb209e072c7 100644
--- a/examples/DDDigi/scripts/TestSegmentationSplit.py
+++ b/examples/DDDigi/scripts/TestSegmentationSplit.py
@@ -38,7 +38,7 @@ def run():
event.adopt_action('DigiStoreDump/StoreDump')
digi.info('Created event.dump')
# ========================================================================
- digi.run_checked(num_events=1, num_threads=10, parallel=3)
+ digi.run_checked(num_events=3, num_threads=10, parallel=3)
if __name__ == '__main__':
diff --git a/examples/DDDigi/scripts/TestSegmentationSplit2.py b/examples/DDDigi/scripts/TestSegmentationSplit2.py
index 88d1dc237074f45aa40d5fee28edea2fb7a78c05..f0611c0dc648dfcf13c94f6e4127936260649a39 100644
--- a/examples/DDDigi/scripts/TestSegmentationSplit2.py
+++ b/examples/DDDigi/scripts/TestSegmentationSplit2.py
@@ -43,7 +43,7 @@ def run():
event.adopt_action('DigiStoreDump/StoreDump')
digi.info('Created event.dump')
# ========================================================================
- digi.run_checked(num_events=1, num_threads=10, parallel=3)
+ digi.run_checked(num_events=5, num_threads=10, parallel=3)
if __name__ == '__main__':