diff --git a/DDDigi/include/DDDigi/DigiData.h b/DDDigi/include/DDDigi/DigiData.h
index 02c6b4804078a2ac899de672ff84dd400c4e7675..72d63000f3d21538b5bae5393a2de3c22ec509e4 100644
--- a/DDDigi/include/DDDigi/DigiData.h
+++ b/DDDigi/include/DDDigi/DigiData.h
@@ -55,6 +55,9 @@ namespace dd4hep {
key_type key;
/// Second union entry to use for discrimination
struct {
+ // Ordering is important here:
+ // We want to group the containers by item ie. by container name
+ // and not by mask
itemkey_type item;
mask_type mask;
mask_type spare;
@@ -85,6 +88,14 @@ namespace dd4hep {
key_type toLong() const {
return key;
}
+ /// Project the mask part of the key
+ itemkey_type item() {
+ return this->values.item;
+ }
+ /// Project the item part of the key
+ mask_type mask() {
+ return this->values.mask;
+ }
/// Generate key using hash algorithm
void set(const std::string& name, int mask);
@@ -96,6 +107,14 @@ namespace dd4hep {
static mask_type mask(key_type k) {
return Key(k).values.mask;
}
+ /// Project the mask part of the key
+ static itemkey_type item(Key k) {
+ return k.values.item;
+ }
+ /// Project the item part of the key
+ static mask_type mask(Key k) {
+ return k.values.mask;
+ }
/// Access key name (if registered properly)
static std::string key_name(const Key& key);
};
@@ -265,6 +284,43 @@ namespace dd4hep {
{
}
+ /// Energy deposit vector definition for digitization
+ /** Energy deposit vector definition for digitization
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_DIGITIZATION
+ */
+ class DepositVector : public std::vector<std::pair<CellID, EnergyDeposit> > {
+ public:
+ std::string name { };
+ Key key { 0x0 };
+
+ public:
+ /// Initializing constructor
+ DepositVector(const std::string& name, Key::mask_type mask);
+ /// Default constructor
+ DepositVector() = default;
+ /// Disable move constructor
+ DepositVector(DepositVector&& copy) = default;
+ /// Disable copy constructor
+ DepositVector(const DepositVector& copy) = default;
+ /// Default destructor
+ virtual ~DepositVector() = default;
+ /// Disable move assignment
+ DepositVector& operator=(DepositVector&& copy) = default;
+ /// Disable copy assignment
+ DepositVector& operator=(const DepositVector& copy) = default;
+ /// Merge new deposit map onto existing map (not thread safe!)
+ std::size_t merge(DepositVector&& updates);
+ };
+
+ /// Initializing constructor
+ inline DepositVector::DepositVector(const std::string& n, Key::mask_type mask)
+ : name(n), key(mask, n)
+ {
+ }
+
/// Energy deposit mapping definition for digitization
/** Energy deposit mapping definition for digitization
*
@@ -292,7 +348,6 @@ namespace dd4hep {
DepositMapping& operator=(DepositMapping&& copy) = default;
/// Disable copy assignment
DepositMapping& operator=(const DepositMapping& copy) = default;
-
/// Merge new deposit map onto existing map (not thread safe!)
std::size_t merge(DepositMapping&& updates);
};
diff --git a/DDDigi/include/DDDigi/DigiInputAction.h b/DDDigi/include/DDDigi/DigiInputAction.h
index ab41c5e2bd2911be65e63078dee31dad701c5112..ca3690b12550fbd401242e3c569ed1203f9c0fd4 100644
--- a/DDDigi/include/DDDigi/DigiInputAction.h
+++ b/DDDigi/include/DDDigi/DigiInputAction.h
@@ -56,6 +56,7 @@ namespace dd4hep {
DigiInputAction(const DigiKernel& kernel, const std::string& nam);
/// Default destructor
virtual ~DigiInputAction();
+
/// Callback to read event input
virtual void execute(DigiContext& context) const override;
};
diff --git a/DDDigi/include/DDDigi/DigiKernel.h b/DDDigi/include/DDDigi/DigiKernel.h
index 29fb36891d37228a091dd7a898ddfdd6d3ef9870..0bd549d99aa01412e0e9afcaf5fe522d22dd5344 100644
--- a/DDDigi/include/DDDigi/DigiKernel.h
+++ b/DDDigi/include/DDDigi/DigiKernel.h
@@ -42,6 +42,20 @@ namespace dd4hep {
typedef std::map<std::string,int> ClientOutputLevels;
typedef std::pair<void*, const std::type_info*> UserFramework;
+ class CallWrapper {
+ public:
+ CallWrapper* worker { nullptr };
+ public:
+ CallWrapper(CallWrapper* worker);
+ CallWrapper() = default;
+ CallWrapper(CallWrapper&& copy) = default;
+ CallWrapper(const CallWrapper& copy) = default;
+ CallWrapper& operator=(CallWrapper&& copy) = delete;
+ CallWrapper& operator=(const CallWrapper& copy) = delete;
+ virtual ~CallWrapper() = default;
+ virtual void operator()() const;
+ };
+
private:
class Internals;
class Processor;
@@ -148,20 +162,40 @@ namespace dd4hep {
DigiActionSequence& eventAction() const;
/// Access to the main output action sequence from the kernel object
DigiActionSequence& outputAction() const;
+
+ /// Submit a bunch of actions to be executed in parallel
+ virtual void submit (const std::vector<CallWrapper*>& algorithms) const;
+ /// Submit a bunch of actions to be executed serially
+ virtual void execute(const std::vector<CallWrapper*>& algorithms) const;
+
/// Submit a bunch of actions to be executed in parallel
virtual void submit (const DigiAction::Actors<DigiEventAction>& algorithms, DigiContext& context) const;
/// Submit a bunch of actions to be executed serially
virtual void execute(const DigiAction::Actors<DigiEventAction>& algorithms, DigiContext& context) const;
+ /// If running multithreaded: wait until the thread-group finished execution
virtual void wait(DigiContext& context) const;
+
};
+
+ inline DigiKernel::CallWrapper::CallWrapper(CallWrapper* w)
+ : worker(w)
+ {
+ }
+
+ inline void DigiKernel::CallWrapper::operator()() const {
+ if ( this->worker ) {
+ (*this->worker)();
+ }
+ }
+
/// Declare property
- template <typename T> DigiKernel& DigiKernel::declareProperty(const std::string& nam, T& val) {
+ template <typename T> inline DigiKernel& DigiKernel::declareProperty(const std::string& nam, T& val) {
properties().add(nam, val);
return *this;
}
/// Declare property
- template <typename T> DigiKernel& DigiKernel::declareProperty(const char* nam, T& val) {
+ template <typename T> inline DigiKernel& DigiKernel::declareProperty(const char* nam, T& val) {
properties().add(nam, val);
return *this;
}
diff --git a/DDDigi/include/DDDigi/DigiMultiContainerProcessor.h b/DDDigi/include/DDDigi/DigiMultiContainerProcessor.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b0c7c0ed9d21f33801591472f510902fac7aa3a
--- /dev/null
+++ b/DDDigi/include/DDDigi/DigiMultiContainerProcessor.h
@@ -0,0 +1,140 @@
+//==========================================================================
+// 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 DDDIGI_DIGIMULTICONTAINERPROCESSOR_H
+#define DDDIGI_DIGIMULTICONTAINERPROCESSOR_H
+
+// Framework include files
+#include <DDDigi/DigiData.h>
+#include <DDDigi/DigiKernel.h>
+#include <DDDigi/DigiActionSequence.h>
+
+/// C/C++ include files
+#include <set>
+
+/// Namespace for the AIDA detector description toolkit
+namespace dd4hep {
+
+ /// Namespace for the Digitization part of the AIDA detector description toolkit
+ namespace digi {
+
+ /// Wrapper class to submit bulk actions
+ /**
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
+ template <typename ACTION_TYPE, typename OPTIONS>
+ class DigiParallelWorker : public DigiKernel::CallWrapper {
+ ACTION_TYPE* processor { nullptr };
+ public:
+ OPTIONS options;
+
+ public:
+ DigiParallelWorker(ACTION_TYPE* p, const OPTIONS& opts);
+ DigiParallelWorker() = default;
+ DigiParallelWorker(DigiParallelWorker&& copy) = default;
+ DigiParallelWorker(const DigiParallelWorker& copy) = delete;
+ DigiParallelWorker& operator=(DigiParallelWorker&& copy) = delete;
+ DigiParallelWorker& operator=(const DigiParallelWorker& copy) = delete;
+ virtual ~DigiParallelWorker();
+ const char* name() const { return processor->name().c_str(); }
+ virtual void operator()() const override final;
+ };
+
+ template <typename ACTION_TYPE, typename OPTIONS>
+ DigiParallelWorker<ACTION_TYPE, OPTIONS>::DigiParallelWorker(ACTION_TYPE* p, const OPTIONS& opts)
+ : processor(p), options(opts)
+ {
+ processor->addRef();
+ }
+
+ template <typename ACTION_TYPE, typename OPTIONS>
+ DigiParallelWorker<ACTION_TYPE, OPTIONS>::~DigiParallelWorker() {
+ if ( processor ) {
+ processor->release();
+ processor = nullptr;
+ }
+ }
+
+
+ /// Worker base class to analyse containers from the input segment in parallel
+ class DigiContainerProcessor : public DigiAction {
+
+ public:
+ using WorkItems = std::vector<std::pair<Key, std::any*> >;
+
+ public:
+ /// Property: Input data segment name
+ std::string m_input_segment { "inputs" };
+ /// Property: event masks to be handled
+ std::vector<int> m_input_masks { };
+ /// Item keys required by this worker
+ std::vector<Key> m_work_keys;
+
+ public:
+ /// Standard constructor
+ DigiContainerProcessor(const DigiKernel& kernel, const std::string& name);
+ /// Main functional callback if specific work is known
+ virtual void execute(DigiContext& context, WorkItems& work) const;
+ };
+
+
+ /// Sequencer class to analyse containers from the input segment in parallel
+ /**
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
+ class DigiMultiContainerProcessor : public DigiEventAction {
+ public:
+ using WorkItems = DigiContainerProcessor::WorkItems;
+ struct ProcessorOptions {
+ DigiContext* context { nullptr };
+ WorkItems* work { nullptr };
+ std::vector<Key> keys { };
+ };
+ using Worker = DigiParallelWorker<DigiContainerProcessor,ProcessorOptions>;
+ using Workers = std::vector<std::unique_ptr<Worker> >;
+ using Callers = std::vector<DigiKernel::CallWrapper*>;
+
+ protected:
+ /// Property: Input data segment name
+ std::string m_input_segment { "inputs" };
+ /// Property: event masks to be handled
+ std::vector<int> m_input_masks { };
+ /// Property: Allow for multiple workers accessing same container
+ bool m_allow_duplicates { true };
+
+ std::set<Key> m_work_items;
+ Workers m_workers;
+ Callers m_callers;
+
+ protected:
+ /// Define standard assignments and constructors
+ DDDIGI_DEFINE_ACTION_CONSTRUCTORS(DigiMultiContainerProcessor);
+ /// Default destructor
+ virtual ~DigiMultiContainerProcessor();
+
+ public:
+ /// Standard constructor
+ DigiMultiContainerProcessor(const DigiKernel& kernel, const std::string& name);
+ /// Adopt new parallel worker
+ void adopt_processor(DigiContainerProcessor* action, const std::vector<std::string>& containers);
+ /// Main functional callback
+ virtual void execute(DigiContext& context) const;
+ };
+ } // End namespace digi
+} // End namespace dd4hep
+#endif // DDDIGI_DIGIMULTICONTAINERPROCESSOR_H
diff --git a/DDDigi/include/DDDigi/DigiSegmentAction.h b/DDDigi/include/DDDigi/DigiSegmentAction.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab265c7849152670c44fc6e7df9042a92c91704d
--- /dev/null
+++ b/DDDigi/include/DDDigi/DigiSegmentAction.h
@@ -0,0 +1,70 @@
+//==========================================================================
+// 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 DDDIGI_DIGISEGMENTACTION_H
+#define DDDIGI_DIGISEGMENTACTION_H
+
+// Framework include files
+#include <DDDigi/DigiData.h>
+#include <DDDigi/DigiEventAction.h>
+
+/// Namespace for the AIDA detector description toolkit
+namespace dd4hep {
+
+ /// Namespace for the Digitization part of the AIDA detector description toolkit
+ namespace digi {
+
+ /// Forward declarations
+ class DigiSegmentAction;
+ class DigiSegmentContext;
+ class DigiSegmentationSplitter;
+
+ /// Default base class for all Digitizer actions and derivates thereof.
+ /**
+ * This is a utility class supporting properties, output and access to
+ * event and run objects through the context.
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
+ class DigiSegmentAction : public DigiEventAction {
+ private:
+ friend class DigiSegmentationSplitter;
+
+ /// Implementation declaration
+#if defined(G__ROOT) || defined(__CLING__) || defined(__ROOTCLING__)
+ typedef long internals_t;
+#else
+ class internals_t;
+#endif
+ /// Reference to the implementation
+ std::unique_ptr<internals_t> internals;
+
+ /// Define standard assignments and constructors
+ DDDIGI_DEFINE_ACTION_CONSTRUCTORS(DigiSegmentAction);
+
+ public:
+ /// Standard constructor
+ DigiSegmentAction(const DigiKernel& kernel, const std::string& name);
+ /// Default destructor
+ virtual ~DigiSegmentAction();
+ /// Main functional callback
+ virtual void execute(DigiContext& context) const final;
+ /// Main functional callback. Default implementnation is noop.
+ virtual DepositVector handleSegment(DigiContext& context,
+ const DigiSegmentContext& segment,
+ const DepositMapping& deposits) const;
+ };
+ } // End namespace digi
+} // End namespace dd4hep
+#endif // DDDIGI_DIGISEGMENTACTION_H
diff --git a/DDDigi/include/DDDigi/DigiSegmentationSplitter.h b/DDDigi/include/DDDigi/DigiSegmentationSplitter.h
index 3c9e72a24d99e145f3bc0e5a530bd6748669eb53..f380de57e43ee8241055169d344ecbbad9be9aa5 100644
--- a/DDDigi/include/DDDigi/DigiSegmentationSplitter.h
+++ b/DDDigi/include/DDDigi/DigiSegmentationSplitter.h
@@ -14,8 +14,7 @@
#define DDDIGI_DIGISEGMENTATIONSPLITTER_H
// Framework include files
-#include <DDDigi/DigiData.h>
-#include <DDDigi/DigiEventAction.h>
+#include <DDDigi/DigiSegmentAction.h>
#include <DDDigi/DigiActionSequence.h>
#include <DDDigi/DigiSegmentationTool.h>
@@ -25,47 +24,6 @@ namespace dd4hep {
/// Namespace for the Digitization part of the AIDA detector description toolkit
namespace digi {
- /// Forward declarations
- class DigiSegmentAction;
- class DigiSegmentContext;
- class DigiSegmentationSplitter;
-
- /// Default base class for all Digitizer actions and derivates thereof.
- /**
- * This is a utility class supporting properties, output and access to
- * event and run objects through the context.
- *
- * \author M.Frank
- * \version 1.0
- * \ingroup DD4HEP_SIMULATION
- */
- class DigiSegmentAction : public DigiEventAction {
- private:
- friend class DigiSegmentationSplitter;
-
- /// Implementation declaration
- class internals_t;
- /// Reference to the implementation
- std::unique_ptr<internals_t> internals;
-
- /// Define standard assignments and constructors
- DDDIGI_DEFINE_ACTION_CONSTRUCTORS(DigiSegmentAction);
-
- public:
- /// Standard constructor
- DigiSegmentAction(const DigiKernel& kernel, const std::string& name);
- /// Default destructor
- virtual ~DigiSegmentAction();
-
- /// Main functional callback
- virtual void execute(DigiContext& context) const final;
- /// Main functional callback
- std::vector<std::pair<Key::key_type, std::any> >
- handleSegment(DigiContext& context,
- const DigiSegmentContext& segment,
- const DepositMapping& deposits) const;
- };
-
/// Default base class for all Digitizer actions and derivates thereof.
/**
* This is a utility class supporting properties, output and access to
@@ -107,8 +65,6 @@ namespace dd4hep {
std::vector<Key> m_data_keys;
protected:
- /// Define standard assignments and constructors
- DDDIGI_DEFINE_ACTION_CONSTRUCTORS(DigiSegmentationSplitter);
/// Default destructor
virtual ~DigiSegmentationSplitter();
diff --git a/DDDigi/include/DDDigi/DigiSegmentationTool.h b/DDDigi/include/DDDigi/DigiSegmentationTool.h
index 8d1b1ffa74c0c5f1f8dfc7c4f2e4112fa95fea0e..0e4858ab1b19b32e54b21ae48324815ea6154c68 100644
--- a/DDDigi/include/DDDigi/DigiSegmentationTool.h
+++ b/DDDigi/include/DDDigi/DigiSegmentationTool.h
@@ -14,6 +14,7 @@
#define DDDIGI_DIGISEGMENTATIONTOOL_H
// Framework include files
+#include <DDDigi/DigiData.h>
#include <DD4hep/Detector.h>
#include <DD4hep/DetElement.h>
@@ -55,16 +56,20 @@ namespace dd4hep {
/// Split field name
const char* cname() const;
/// Get the identifier of the cell to be split
- uint32_t split_id(uint64_t cell_id) const {
- return int( (cell_id & this->split_mask) >> this->offset );
+ uint32_t split_id(uint64_t cell) const {
+ return int( (cell & this->split_mask) >> this->offset );
}
/// The CELL ID part of the identifier
- uint64_t cell_id(uint64_t cell_id) const {
- return ( (cell_id & this->cell_mask) >> (this->offset + width) );
+ uint64_t cell_id(uint64_t cell) const {
+ return ( (cell & this->cell_mask) >> (this->offset + width) );
}
/// The identifier of the parent detector
- uint64_t detector_id(uint64_t cell_id) const {
- return (cell_id & this->det_mask);
+ uint64_t detector_id(uint64_t cell) const {
+ return (cell & this->det_mask);
+ }
+ /// Check a given cell id if it matches this selection
+ bool matches(uint64_t cell) const {
+ return this->split_id(cell) == this->id;
}
};
diff --git a/DDDigi/include/DDDigi/noise/DigiExponentialNoise.h b/DDDigi/include/DDDigi/noise/DigiExponentialNoise.h
index 1a489961c1c3d351065f467316bd08d3b8c27a37..29be3beefb23f6d6a7fc1ec56de7235e9d236fed 100644
--- a/DDDigi/include/DDDigi/noise/DigiExponentialNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiExponentialNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGIEXPONENTIALNOISE_H
-#define DDDIGI_DIGIEXPONENTIALNOISE_H
+#ifndef DDDIGI_NOISE_DIGIEXPONENTIALNOISE_H
+#define DDDIGI_NOISE_DIGIEXPONENTIALNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -47,4 +47,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGIEXPONENTIALNOISE_H
+#endif // DDDIGI_NOISE_DIGIEXPONENTIALNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiGaussianNoise.h b/DDDigi/include/DDDigi/noise/DigiGaussianNoise.h
index 177d2397afc1807a11d48311a31412e205901295..ad8f7b23d83f84d968ee22706739af6139111676 100644
--- a/DDDigi/include/DDDigi/noise/DigiGaussianNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiGaussianNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGIGAUSSIANNOISE_H
-#define DDDIGI_DIGIGAUSSIANNOISE_H
+#ifndef DDDIGI_NOISE_DIGIGAUSSIANNOISE_H
+#define DDDIGI_NOISE_DIGIGAUSSIANNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -54,4 +54,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGIGAUSSIANNOISE_H
+#endif // DDDIGI_NOISE_DIGIGAUSSIANNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiLandauNoise.h b/DDDigi/include/DDDigi/noise/DigiLandauNoise.h
index 42eaf0dc89a134db74413b658249136217cb5033..f69ff79719611c7e518c2d92aaf23f73d9d900d2 100644
--- a/DDDigi/include/DDDigi/noise/DigiLandauNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiLandauNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGILANDAUNOISE_H
-#define DDDIGI_DIGILANDAUNOISE_H
+#ifndef DDDIGI_NOISE_DIGILANDAUNOISE_H
+#define DDDIGI_NOISE_DIGILANDAUNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -54,4 +54,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGILANDAUNOISE_H
+#endif // DDDIGI_NOISE_DIGILANDAUNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiPoissonNoise.h b/DDDigi/include/DDDigi/noise/DigiPoissonNoise.h
index bb7d848b910a5e7e3e023de2dc602c1278d3962f..bd61aceb062bb3284b03b12b3287f77381827095 100644
--- a/DDDigi/include/DDDigi/noise/DigiPoissonNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiPoissonNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGIPOISSONNOISE_H
-#define DDDIGI_DIGIPOISSONNOISE_H
+#ifndef DDDIGI_NOISE_DIGIPOISSONNOISE_H
+#define DDDIGI_NOISE_DIGIPOISSONNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -52,4 +52,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGIPOISSONNOISE_H
+#endif // DDDIGI_NOISE_DIGIPOISSONNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiRandomNoise.h b/DDDigi/include/DDDigi/noise/DigiRandomNoise.h
index 75e637e024f74953c77ef84207a16b137b1413ef..3e20a878f93c0713f8b26594dedbba3815d468d2 100644
--- a/DDDigi/include/DDDigi/noise/DigiRandomNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiRandomNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGIRANDOMNOISE_H
-#define DDDIGI_DIGIRANDOMNOISE_H
+#ifndef DDDIGI_NOISE_DIGIRANDOMNOISE_H
+#define DDDIGI_NOISE_DIGIRANDOMNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -68,4 +68,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGIRANDOMNOISE_H
+#endif // DDDIGI_NOISE_DIGIRANDOMNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiSignalProcessorSequence.h b/DDDigi/include/DDDigi/noise/DigiSignalProcessorSequence.h
index 947ac6c0bc9f878a9fd498921c4ab4010c5404e3..3a137477ee8b1725968f8d010647ee6575f6c289 100644
--- a/DDDigi/include/DDDigi/noise/DigiSignalProcessorSequence.h
+++ b/DDDigi/include/DDDigi/noise/DigiSignalProcessorSequence.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGISIGNALPROCESSORSEQUENCE_H
-#define DDDIGI_DIGISIGNALPROCESSORSEQUENCE_H
+#ifndef DDDIGI_NOISE_DIGISIGNALPROCESSORSEQUENCE_H
+#define DDDIGI_NOISE_DIGISIGNALPROCESSORSEQUENCE_H
// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -62,4 +62,4 @@ namespace dd4hep {
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGISIGNALPROCESSORSEQUENCE_H
+#endif // DDDIGI_NOISE_DIGISIGNALPROCESSORSEQUENCE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiSubdetectorSequence.h b/DDDigi/include/DDDigi/noise/DigiSubdetectorSequence.h
index dc58cd62b986637c205e48af4b6132ad2d862f68..c2a68bdafeb14b60fe90fba24f2364aa104049ec 100644
--- a/DDDigi/include/DDDigi/noise/DigiSubdetectorSequence.h
+++ b/DDDigi/include/DDDigi/noise/DigiSubdetectorSequence.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGISUBDETECTORSEQUENCE_H
-#define DDDIGI_DIGISUBDETECTORSEQUENCE_H
+#ifndef DDDIGI_NOISE_DIGISUBDETECTORSEQUENCE_H
+#define DDDIGI_NOISE_DIGISUBDETECTORSEQUENCE_H
// Framework include files
#include <DDDigi/DigiActionSequence.h>
@@ -110,4 +110,4 @@ namespace dd4hep {
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGISUBDETECTORSEQUENCE_H
+#endif // DDDIGI_NOISE_DIGISUBDETECTORSEQUENCE_H
diff --git a/DDDigi/include/DDDigi/noise/DigiUniformNoise.h b/DDDigi/include/DDDigi/noise/DigiUniformNoise.h
index 2b8dcceb1bd039f79a1e7f1a215c7a48c53ce2e5..70aa8ecc93e21dc00a31dc3bc2a5aa0c013672a1 100644
--- a/DDDigi/include/DDDigi/noise/DigiUniformNoise.h
+++ b/DDDigi/include/DDDigi/noise/DigiUniformNoise.h
@@ -10,8 +10,8 @@
// Author : M.Frank
//
//==========================================================================
-#ifndef DDDIGI_DIGIUNIFORMNOISE_H
-#define DDDIGI_DIGIUNIFORMNOISE_H
+#ifndef DDDIGI_NOISE_DIGIUNIFORMNOISE_H
+#define DDDIGI_NOISE_DIGIUNIFORMNOISE_H
/// Framework include files
#include <DDDigi/DigiSignalProcessor.h>
@@ -49,4 +49,4 @@ namespace dd4hep {
};
} // End namespace digi
} // End namespace dd4hep
-#endif // DDDIGI_DIGIUNIFORMNOISE_H
+#endif // DDDIGI_NOISE_DIGIUNIFORMNOISE_H
diff --git a/DDDigi/include/DDDigi/noise/FalphaNoise.h b/DDDigi/include/DDDigi/noise/FalphaNoise.h
index a52688f127caac708d2dc49d842af158fb76b545..a97032482351260339319a6b13110b999005f62a 100644
--- a/DDDigi/include/DDDigi/noise/FalphaNoise.h
+++ b/DDDigi/include/DDDigi/noise/FalphaNoise.h
@@ -47,8 +47,8 @@
//
//==========================================================================
-#ifndef DDDIGI_FALPHANOISE_H
-#define DDDIGI_FALPHANOISE_H
+#ifndef DDDIGI_NOISE_FALPHANOISE_H
+#define DDDIGI_NOISE_FALPHANOISE_H
/// C/C++ include files
#include <vector>
@@ -171,4 +171,4 @@ namespace dd4hep {
}
} // End namespace detail
} // End namespace dd4hep
-#endif // DDDIGI_FALPHANOISE_H
+#endif // DDDIGI_NOISE_FALPHANOISE_H
diff --git a/DDDigi/plugins/Components.cpp b/DDDigi/plugins/Components.cpp
index c277b79c0c7bd3df6038ca5dd872c110df3d99ed..9d998f509ebfa1f78c9f26369029aa05dbce5f83 100644
--- a/DDDigi/plugins/Components.cpp
+++ b/DDDigi/plugins/Components.cpp
@@ -57,6 +57,10 @@ DECLARE_DIGIEVENTACTION_NS(dd4hep::digi,DigiContainerCombine)
DECLARE_DIGISEGMENTACTION_NS(dd4hep::digi,DigiSegmentAction)
DECLARE_DIGIEVENTACTION_NS(dd4hep::digi,DigiSegmentationSplitter)
+#include <DDDigi/DigiMultiContainerProcessor.h>
+DECLARE_DIGIEVENTACTION_NS(dd4hep::digi,DigiMultiContainerProcessor)
+DECLARE_DIGIACTION_NS(dd4hep::digi,DigiContainerProcessor)
+
/// Basic entry point
static long dummy(dd4hep::Detector&, int, char**) {
return 0;
diff --git a/DDDigi/plugins/DigiSegmentDepositPrint.cpp b/DDDigi/plugins/DigiSegmentDepositPrint.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c247267e0a2780b549d76ed4e80eaf547e0b1b1b
--- /dev/null
+++ b/DDDigi/plugins/DigiSegmentDepositPrint.cpp
@@ -0,0 +1,59 @@
+//==========================================================================
+// 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 <DDDigi/DigiContext.h>
+#include <DDDigi/DigiSegmentationSplitter.h>
+
+/// Namespace for the AIDA detector description toolkit
+namespace dd4hep {
+
+ /// Namespace for the Digitization part of the AIDA detector description toolkit
+ namespace digi {
+
+ /// Helper class to print energy deposits pre-selected by the segment splitter
+ /** Helper class to print energy deposits pre-selected by the segment splitter
+ *
+ * \author M.Frank
+ * \version 1.0
+ * \ingroup DD4HEP_SIMULATION
+ */
+ class DigiSegmentDepositPrint : public DigiSegmentAction {
+ public:
+ /// Constructors used of base class
+ using DigiSegmentAction::DigiSegmentAction;
+
+ /// Main functional callback
+ virtual DepositVector
+ handleSegment(DigiContext& context,
+ const DigiSegmentContext& segment,
+ const DepositMapping& deposits) const override final {
+ char format[256];
+ ::snprintf(format, sizeof(format),
+ "%s[%s] %s-id: %%d [processor:%d] Cell: %%016lX mask: %016lX hist:%%4ld entries deposit: %%f",
+ context.event->id(), segment.idspec.name(), segment.cname(), segment.id, segment.split_mask);
+ for( const auto& d : deposits ) {
+ if ( segment.matches(d.first) ) {
+ auto cell = d.first;
+ auto& depo = d.second;
+ info(format, segment.split_id(cell), cell, depo.history.size(), depo.deposit);
+ }
+ }
+ return {};
+ }
+ };
+ } // End namespace digi
+} // End namespace dd4hep
+
+#include <DDDigi/DigiFactories.h>
+DECLARE_DIGISEGMENTACTION_NS(dd4hep::digi,DigiSegmentDepositPrint)
diff --git a/DDDigi/python/DDDigiDict.C b/DDDigi/python/DDDigiDict.C
index 10f6d167f837dd6748889eecaf631fa88b482835..4eb4e9a4c2b79aec77d5f138c1a809584f7458e2 100644
--- a/DDDigi/python/DDDigiDict.C
+++ b/DDDigi/python/DDDigiDict.C
@@ -39,7 +39,9 @@
#include <DDDigi/DigiSynchronize.h>
#include <DDDigi/DigiEventAction.h>
#include <DDDigi/DigiInputAction.h>
+#include <DDDigi/DigiSegmentAction.h>
#include <DDDigi/DigiActionSequence.h>
+#include <DDDigi/DigiMultiContainerProcessor.h>
#include <DDDigi/DigiSignalProcessor.h>
struct DDDigiDict {};
@@ -70,6 +72,8 @@ namespace dd4hep {
ACTIONHANDLE(Action);
ACTIONHANDLE(EventAction);
ACTIONHANDLE(InputAction);
+ ACTIONHANDLE(SegmentAction);
+ ACTIONHANDLE(ContainerProcessor);
ACTIONHANDLE(ActionSequence);
ACTIONHANDLE(Synchronize);
@@ -102,6 +106,9 @@ namespace dd4hep {
static InputActionHandle createInputAction(KernelHandle& kernel, const std::string& name_type)
{ return cr<InputActionHandle,DigiHandle<DigiInputAction> >(kernel,name_type); }
+ static SegmentActionHandle createSegmentAction(KernelHandle& kernel, const std::string& name_type)
+ { return cr<SegmentActionHandle,DigiHandle<DigiSegmentAction> >(kernel,name_type); }
+
static ActionSequenceHandle createSequence(KernelHandle& kernel, const std::string& name_type)
{ return cr<ActionSequenceHandle,DigiHandle<DigiActionSequence> >(kernel,name_type); }
@@ -109,15 +116,19 @@ namespace dd4hep {
{ return cr<SynchronizeHandle,DigiHandle<DigiSynchronize> >(kernel,name_type); }
static DigiAction* toAction(DigiAction* f) { return f; }
+#if 0
static DigiAction* toAction(DigiEventAction* f) { return f; }
static DigiAction* toAction(DigiInputAction* f) { return f; }
+ static DigiAction* toAction(DigiSegmentAction* f) { return f; }
+ static DigiAction* toAction(DigiContainerProcessor* f) { return f; }
static DigiAction* toAction(DigiActionSequence* f) { return f; }
static DigiAction* toAction(DigiSynchronize* f) { return f; }
static DigiAction* toAction(DigiSignalProcessor* f) { return f; }
-
+#endif
static DigiAction* toAction(ActionHandle f) { return f.action; }
static DigiAction* toAction(EventActionHandle f) { return f.action; }
static DigiAction* toAction(InputActionHandle f) { return f.action; }
+ static DigiAction* toAction(SegmentActionHandle f) { return f.action; }
static DigiAction* toAction(ActionSequenceHandle f) { return f.action; }
static DigiAction* toAction(SynchronizeHandle f) { return f.action; }
static DigiAction* toAction(SignalProcessorHandle f) { return f.action; }
@@ -179,6 +190,9 @@ using namespace std;
#pragma link C++ class dd4hep::digi::DigiInputAction;
#pragma link C++ class dd4hep::digi::InputActionHandle;
+#pragma link C++ class dd4hep::digi::DigiSegmentAction;
+#pragma link C++ class dd4hep::digi::SegmentActionHandle;
+
#pragma link C++ class dd4hep::digi::DigiActionSequence;
#pragma link C++ class dd4hep::digi::ActionSequenceHandle;
@@ -188,6 +202,9 @@ using namespace std;
#pragma link C++ class dd4hep::digi::DigiSignalProcessor;
#pragma link C++ class dd4hep::digi::SignalProcessorHandle;
+#pragma link C++ class dd4hep::digi::DigiContainerProcessor;
+#pragma link C++ class dd4hep::digi::DigiMultiContainerProcessor;
+
/// Digi data item wrappers
#pragma link C++ class dd4hep::digi::DigiEvent;
#pragma link C++ class dd4hep::digi::EnergyDeposit+;
diff --git a/DDDigi/python/dddigi.py b/DDDigi/python/dddigi.py
index 94bb896d4f2803b8e28a0f6bc77094b066b0e218..dfd1b041c38eceb07292edd6204426ea544e8e6b 100644
--- a/DDDigi/python/dddigi.py
+++ b/DDDigi/python/dddigi.py
@@ -172,13 +172,20 @@ ActionHandle = digi.ActionHandle
# ---------------------------------------------------------------------------
-def Action(kernel, nam, parallel=False):
- obj = Interface.createAction(kernel, str(nam))
- obj.parallel = parallel
+def TestAction(kernel, nam, sleep=0):
+ obj = Interface.createEventAction(kernel, str('DigiTestAction/' + nam))
+ if sleep != 0:
+ obj.sleep = sleep
return obj
+# ---------------------------------------------------------------------------
+def Action(kernel, nam):
+ obj = Interface.createAction(kernel, str(nam))
+ return obj
# ---------------------------------------------------------------------------
+
+
def EventAction(kernel, nam, parallel=False):
obj = Interface.createEventAction(kernel, str(nam))
obj.parallel = parallel
@@ -186,10 +193,9 @@ def EventAction(kernel, nam, parallel=False):
# ---------------------------------------------------------------------------
-def TestAction(kernel, nam, sleep=0):
- obj = Interface.createEventAction(kernel, str('DigiTestAction/' + nam))
- if sleep != 0:
- obj.sleep = sleep
+def SegmentAction(kernel, nam, parallel=False):
+ obj = Interface.createSegmentAction(kernel, str(nam))
+ obj.parallel = parallel
return obj
# ---------------------------------------------------------------------------
@@ -208,14 +214,14 @@ def Synchronize(kernel, nam, parallel=False):
# ---------------------------------------------------------------------------
-def _setup(obj):
- def _adopt(self, action):
- getattr(self,'__adopt')(action.get())
+def _default_adopt(self, action):
+ getattr(self, '__adopt')(action.get())
+
+def _setup(obj, call='adopt', py_call=_default_adopt):
_import_class('digi', obj)
cls = getattr(current, obj)
- setattr(cls, '__adopt', getattr(cls, 'adopt'))
- setattr(cls, 'adopt', _adopt)
- # setattr(cls,'add',_adopt)
+ setattr(cls, '__'+call, getattr(cls, call))
+ setattr(cls, call, py_call)
return cls
@@ -279,12 +285,19 @@ def adopt_sequence_action(self, name, **options):
return action
+def _adopt_processor(self, action, containers):
+ getattr(self, '__adopt_processor')(action.get(), containers)
+
+
_props('DigiSynchronize')
_props('DigiActionSequence', adopt_action=adopt_sequence_action)
_props('DigiParallelActionSequence', adopt_action=adopt_sequence_action)
_props('DigiSequentialActionSequence', adopt_action=adopt_sequence_action)
+_setup('DigiMultiContainerProcessor', call='adopt_processor', py_call=_adopt_processor)
+
+
# Need to import digitize late, since it cross includes dddigi
Digitize = None
try:
diff --git a/DDDigi/python/digitize.py b/DDDigi/python/digitize.py
index e7170f94df23494714a54fedcb88e6af9c27f2f5..b77dfe6cd5a33b4d562836a3c391af930e2e3720 100644
--- a/DDDigi/python/digitize.py
+++ b/DDDigi/python/digitize.py
@@ -54,6 +54,12 @@ class Digitize(dd4hep.Logger):
self._main_processor.parallel = self._parallel
return self._main_processor
+ def create_action(self, name, **options):
+ action = dddigi.Action(self._kernel, name)
+ for option in options.items():
+ setattr(action, option[0], option[1])
+ return action
+
def new_action(self, name, **options):
action = dddigi.EventAction(self._kernel, name)
for option in options.items():
@@ -75,7 +81,7 @@ class Digitize(dd4hep.Logger):
self._input_processor.adopt(act)
return act
- def event_action(self, name=None, **options):
+ def event_action(self, name=None, register=True, **options):
"""
Append a new action to the kernel's main event action sequence
"""
@@ -87,7 +93,8 @@ class Digitize(dd4hep.Logger):
return self._event_processor
action = self.new_action(name, **options)
- self._event_processor.adopt(action)
+ if register:
+ self._event_processor.adopt(action)
return action
def output_action(self, name=None, **options):
diff --git a/DDDigi/src/DigiContainerCombine.cpp b/DDDigi/src/DigiContainerCombine.cpp
index e36d49f3b0bb7dddaad9c8753b887738cff92cb6..0bfdd89e8e6073fd8261282d0ce62b4e7bf75efd 100644
--- a/DDDigi/src/DigiContainerCombine.cpp
+++ b/DDDigi/src/DigiContainerCombine.cpp
@@ -28,7 +28,7 @@ public:
/// Property: Container names to be loaded
std::vector<std::string> containers { };
/// Property: event masks to be handled
- std::vector<int> masks { };
+ std::vector<int> input_masks { };
/// Property: Output container dressing
std::string output_name_flag;
/// Property: Input data segment name
@@ -59,18 +59,18 @@ public:
for ( const auto& c : this->containers ) {
Key key(0x0, c);
this->cont_keys.emplace(key.key);
- if ( this->masks.empty() ) {
+ if ( this->input_masks.empty() ) {
this->keys.emplace(key.key);
continue;
}
- for ( int m : this->masks ) {
+ for ( int m : this->input_masks ) {
key.values.mask = m;
this->keys.emplace(key.key);
}
}
this->container_selector = [this](Key::key_type k) {
- const auto& m = this->masks;
+ const auto& m = this->input_masks;
bool use = m.empty() || this->keys.empty();
if ( !use ) {
if ( !this->cont_keys.empty() )
@@ -90,7 +90,7 @@ dd4hep::digi::DigiContainerCombine::DigiContainerCombine(const DigiKernel& krnl,
{
this->internals = std::make_unique<internals_t>();
this->declareProperty("containers", this->internals->containers);
- this->declareProperty("masks", this->internals->masks);
+ this->declareProperty("input_masks", this->internals->input_masks);
this->declareProperty("input_segment", this->internals->input = "inputs");
this->declareProperty("output_segment", this->internals->output = "deposits");
this->declareProperty("deposit_mask", this->internals->deposit_mask);
@@ -104,6 +104,29 @@ dd4hep::digi::DigiContainerCombine::~DigiContainerCombine() {
InstanceCount::decrement(this);
}
+struct work_definition {
+ using Key = dd4hep::digi::Key;
+ using DigiEvent = dd4hep::digi::DigiEvent;
+ using DataSegment = dd4hep::digi::DataSegment;
+ std::size_t cnt_depos = 0;
+ std::size_t cnt_parts = 0;
+ std::size_t cnt_conts = 0;
+ std::vector<Key> keys;
+ std::vector<std::any*> work;
+ std::set<Key::itemkey_type> items;
+ Key depo_key;
+ char format[128];
+ DigiEvent& event;
+ DataSegment& inputs;
+ DataSegment& outputs;
+ work_definition(DigiEvent& e, DataSegment& i, DataSegment& o)
+ : event(e), inputs(i), outputs(o) {}
+};
+struct DigiCombineAction : public dd4hep::digi::DigiEventAction {
+public:
+ work_definition work;
+};
+
/// Combine selected containers to one single deposit container
template <typename PREDICATE> std::size_t
dd4hep::digi::DigiContainerCombine::combine_containers(DigiEvent& event,
@@ -111,89 +134,83 @@ dd4hep::digi::DigiContainerCombine::combine_containers(DigiEvent& event,
DataSegment& outputs,
const PREDICATE& predicate) const
{
- std::size_t cnt_depos = 0;
- std::size_t cnt_parts = 0;
- std::size_t cnt_conts = 0;
- std::vector<Key> keys;
- std::vector<std::any*> work;
std::set<Key::itemkey_type> items;
-
- keys.reserve(inputs.size());
- work.reserve(inputs.size());
- for( auto& i : inputs ) {
+ work_definition def(event, inputs, outputs);
+ def.depo_key.values.mask = internals->deposit_mask;
+ def.keys.reserve(inputs.size());
+ def.work.reserve(inputs.size());
+ for( auto& i : def.inputs ) {
if ( predicate(i.first) ) {
- keys.emplace_back(i.first);
- work.emplace_back(&i.second);
+ def.keys.emplace_back(i.first);
+ def.work.emplace_back(&i.second);
items.insert(Key(i.first).values.item);
}
}
- Key depo_key;
- depo_key.values.mask = internals->deposit_mask;
+
+ ::snprintf(def.format, sizeof(def.format),
+ "%s+++ %%-32s Mask: $%04X Input: $%%04X Merged %%6ld %%s",
+ event.id(), def.depo_key.values.mask);
+
for(auto itm : items) {
- for( std::size_t i=0; i < keys.size(); ++i ) {
- if ( keys[i].values.item != itm )
+ for( std::size_t i=0; i < def.keys.size(); ++i ) {
+ if ( def.keys[i].values.item != itm )
continue;
- auto* output = work[i];
- depo_key.values.item = itm;
+ auto* output = def.work[i];
+ def.depo_key.values.item = itm;
/// Merge deposit mapping
if ( DepositMapping* depos = std::any_cast<DepositMapping>(output) ) {
if ( !internals->output_name_flag.empty() )
depos->name = depos->name+"/"+internals->output_name_flag;
- cnt_depos += depos->size();
- cnt_conts++;
- this->info("%s+++ %-32s Mask: $%04X Input: $%04X Merged %6ld deposits",
- event.id(), depos->name.c_str(), depo_key.values.mask,
- keys[i].values.mask, depos->size());
- for( std::size_t j=i+1; j < keys.size(); ++j ) {
- if ( keys[j].values.item == itm ) {
- DepositMapping* next = std::any_cast<DepositMapping>(work[j]);
- cnt_depos += next->size();
- cnt_conts++;
+ def.cnt_depos += depos->size();
+ def.cnt_conts++;
+ this->info(def.format, depos->name.c_str(),
+ def.keys[i].values.mask, depos->size(), "deposits");
+ for( std::size_t j=i+1; j < def.keys.size(); ++j ) {
+ if ( def.keys[j].values.item == itm ) {
+ DepositMapping* next = std::any_cast<DepositMapping>(def.work[j]);
std::size_t cnt = depos->merge(std::move(*next));
- this->info("%s+++ %-32s Mask: $%04X Input: $%04X Merged %6ld deposits",
- event.id(), depos->name.c_str(), depo_key.values.mask,
- keys[j].values.mask, cnt);
- cnt_depos += cnt;
- cnt_conts++;
- work[j]->reset();
+ this->info(def.format, next->name.c_str(),
+ def.keys[j].values.mask, cnt, "deposits");
+ def.cnt_depos += cnt;
+ def.cnt_conts++;
+ def.work[j]->reset();
}
}
- outputs.emplace(depo_key, std::move(*output));
+ def.outputs.emplace(def.depo_key, std::move(*output));
break;
}
+ /// Merge particle container
else if ( ParticleMapping* parts = std::any_cast<ParticleMapping>(output) ) {
if ( !internals->output_name_flag.empty() )
parts->name = parts->name+"/"+internals->output_name_flag;
- cnt_parts += parts->size();
- cnt_conts++;
-
- this->info("%s+++ %-32s Mask: $%04X Input: $%04X Merged %6ld particles",
- event.id(), parts->name.c_str(), depo_key.values.mask,
- keys[i].values.mask, parts->size());
- for( std::size_t j=i+1; j < keys.size(); ++j ) {
- if ( keys[j].values.item == itm ) {
- ParticleMapping* next = std::any_cast<ParticleMapping>(work[j]);
+ def.cnt_parts += parts->size();
+ def.cnt_conts++;
+
+ this->info(def.format, parts->name.c_str(),
+ def.keys[i].values.mask, parts->size(), "particles");
+ for( std::size_t j=i+1; j < def.keys.size(); ++j ) {
+ if ( def.keys[j].values.item == itm ) {
+ ParticleMapping* next = std::any_cast<ParticleMapping>(def.work[j]);
std::size_t cnt = parts->merge(std::move(*next));
- this->info("%s+++ %-32s Mask: $%04X Input: $%04X Merged %6ld particles",
- event.id(), parts->name.c_str(), depo_key.values.mask,
- keys[j].values.mask, cnt);
- cnt_parts += cnt;
- cnt_conts++;
- work[j]->reset();
+ this->info(def.format, next->name.c_str(),
+ def.keys[j].values.mask, cnt, "particles");
+ def.cnt_parts += cnt;
+ def.cnt_conts++;
+ def.work[j]->reset();
}
}
- outputs.emplace(depo_key, std::move(*output));
+ def.outputs.emplace(def.depo_key, std::move(*output));
break;
}
}
}
if ( this->internals->erase_combined ) {
- inputs.erase(keys);
+ inputs.erase(def.keys);
}
this->info("%s+++ Merged %ld particles and %ld deposits from %ld containers",
- event.id(), cnt_parts, cnt_depos, cnt_conts);
- return cnt_depos;
+ event.id(), def.cnt_parts, def.cnt_depos, def.cnt_conts);
+ return def.cnt_depos;
}
/// Main functional callback
diff --git a/DDDigi/src/DigiData.cpp b/DDDigi/src/DigiData.cpp
index 371e219d6009d21f527caf1bff481341a997480a..cf7bff4f63f3c30b341666f058280dc97d7477be 100644
--- a/DDDigi/src/DigiData.cpp
+++ b/DDDigi/src/DigiData.cpp
@@ -41,7 +41,7 @@ void Key::set(const std::string& name, int mask) {
except("DDDigi::Key", "+++ No key name was specified -- this is illegal!");
}
this->key = 0;
- this->values.mask = (unsigned char)(0xFF&mask);
+ this->values.mask = (Key::mask_type)(0xFFFF&mask);
this->values.item = detail::hash32(name);
std::lock_guard<std::mutex> lock(_k.lock);
_k.map[this->key] = name;
@@ -62,6 +62,15 @@ std::string Key::key_name(const Key& k) {
return "UNKNOWN";
}
+/// Merge new deposit map onto existing map
+std::size_t DepositVector::merge(DepositVector&& updates) {
+ std::size_t update_size = updates.size();
+ for( auto& c : updates ) {
+ this->emplace_back(c);
+ }
+ return update_size;
+}
+
/// Merge new deposit map onto existing map
std::size_t DepositMapping::merge(DepositMapping&& updates) {
std::size_t update_size = updates.size();
@@ -85,7 +94,9 @@ std::size_t ParticleMapping::merge(ParticleMapping&& updates) {
std::size_t update_size = updates.size();
for( ParticleMapping::value_type& c : updates ) {
Particle part(std::move(c.second));
+#if defined(__GNUC__) && (__GNUC__ >= 10)
this->push(c.first, std::move(part));
+#endif
}
return update_size;
}
@@ -167,12 +178,12 @@ void DataSegment::print_keys() const {
/// Call on failed any-casts during data requests
std::string DataSegment::invalid_cast(Key key, const std::type_info& type) const {
return dd4hep::format(0, "Invalid segment data cast. Key:%ld type:%s",
- key, typeName(type).c_str());
+ key.key, typeName(type).c_str());
}
/// Call on failed data requests during data requests
std::string DataSegment::invalid_request(Key key) const {
- return dd4hep::format(0, "Invalid segment data requested. Key:%ld",key);
+ return dd4hep::format(0, "Invalid segment data requested. Key:%ld",key.key);
}
/// Access data item by key
diff --git a/DDDigi/src/DigiHandle.cpp b/DDDigi/src/DigiHandle.cpp
index 1099d011d975f2741a0e9e615d60c79b26370ec5..45f7e8e1d814127adde45317923a8e36bc007f21 100644
--- a/DDDigi/src/DigiHandle.cpp
+++ b/DDDigi/src/DigiHandle.cpp
@@ -21,6 +21,7 @@
#include <DDDigi/DigiInputAction.h>
#include <DDDigi/DigiEventAction.h>
#include <DDDigi/DigiSignalProcessor.h>
+#include <DDDigi/DigiSegmentationSplitter.h>
// C/C++ include files
#include <stdexcept>
@@ -68,6 +69,10 @@ namespace dd4hep {
return PluginService::Create<DigiAction*>(t, &kernel, n);
}
+ template <> DigiSegmentAction* _raw_create<DigiSegmentAction>(const std::string& t, const DigiKernel& kernel, const std::string& n) {
+ return PluginService::Create<DigiSegmentAction*>(t, &kernel, n);
+ }
+
template <> DigiSignalProcessor* _raw_create<DigiSignalProcessor>(const std::string& t, const DigiKernel& kernel, const std::string& n) {
return PluginService::Create<DigiSignalProcessor*>(t, &kernel, n);
}
@@ -197,6 +202,7 @@ namespace dd4hep {
template class DigiHandle<DigiAction>;
template class DigiHandle<DigiInputAction>;
template class DigiHandle<DigiEventAction>;
+ template class DigiHandle<DigiSegmentAction>;
template class DigiHandle<DigiSynchronize>;
template class DigiHandle<DigiActionSequence>;
template class DigiHandle<DigiSignalProcessor>;
diff --git a/DDDigi/src/DigiKernel.cpp b/DDDigi/src/DigiKernel.cpp
index e20a471839102fb2cecaec8d1d45c15a9cf48398..1c41cba4f35c62f706f0f7ce56a9dd1fa07e4f1e 100644
--- a/DDDigi/src/DigiKernel.cpp
+++ b/DDDigi/src/DigiKernel.cpp
@@ -100,7 +100,7 @@ public:
* \version 1.0
* \ingroup DD4HEP_DIGITIZATION
*/
-class DigiKernel::Wrapper {
+class DigiKernel::Wrapper : public CallWrapper {
public:
DigiContext& context;
DigiEventAction* action = 0;
@@ -317,6 +317,28 @@ DigiActionSequence& DigiKernel::outputAction() const {
return *internals->outputAction;
}
+/// Submit a bunch of actions to be executed in parallel
+void DigiKernel::submit (const std::vector<CallWrapper*>& actions) const {
+ bool parallel = 0 != internals->tbbInit && internals->numThreads>0;
+#ifdef DD4HEP_USE_TBB
+ if ( parallel ) {
+ tbb::task_group que;
+ for ( auto* algo : actions )
+ que.run( *algo );
+ que.wait();
+ return;
+ }
+#endif
+ for ( auto* algo : actions )
+ (*algo)();
+}
+
+/// Submit a bunch of actions to be executed serially
+void DigiKernel::execute(const std::vector<CallWrapper*>& actions) const {
+ for ( auto* algo : actions )
+ (*algo)();
+}
+
void DigiKernel::submit(const DigiAction::Actors<DigiEventAction>& actions, DigiContext& context) const {
std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
bool parallel = 0 != internals->tbbInit && internals->numThreads>0;
@@ -324,7 +346,7 @@ void DigiKernel::submit(const DigiAction::Actors<DigiEventAction>& actions, Digi
if ( parallel ) {
tbb::task_group que;
for ( auto* i : actions )
- que.run(Wrapper(context, i));
+ que.run( Wrapper(context, i) );
que.wait();
goto print_stamp;
}
diff --git a/DDDigi/src/DigiMultiContainerProcessor.cpp b/DDDigi/src/DigiMultiContainerProcessor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e1f648cc03afbc2129826872f90b4b4f51bed33
--- /dev/null
+++ b/DDDigi/src/DigiMultiContainerProcessor.cpp
@@ -0,0 +1,116 @@
+//==========================================================================
+// 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/InstanceCount.h>
+
+#include <DDDigi/DigiData.h>
+#include <DDDigi/DigiContext.h>
+#include <DDDigi/DigiMultiContainerProcessor.h>
+
+/// C/C++ include files
+#include <set>
+#include <sstream>
+
+using namespace dd4hep::digi;
+
+template <> void DigiParallelWorker<DigiContainerProcessor, DigiMultiContainerProcessor::ProcessorOptions>::operator()() const {
+ processor->execute(*options.context, *options.work);
+}
+
+/// Standard constructor
+DigiMultiContainerProcessor::DigiMultiContainerProcessor(const DigiKernel& krnl, const std::string& nam)
+ : DigiEventAction(krnl, nam)
+{
+ this->declareProperty("input_masks", m_input_masks);
+ this->declareProperty("input_segment", m_input_segment);
+ this->declareProperty("allow_duplicates", m_allow_duplicates);
+ InstanceCount::increment(this);
+}
+
+/// Default destructor
+DigiMultiContainerProcessor::~DigiMultiContainerProcessor() {
+ InstanceCount::decrement(this);
+}
+
+void DigiMultiContainerProcessor::adopt_processor(DigiContainerProcessor* action, const std::vector<std::string>& containers) {
+ if ( !action ) {
+ except("+++ Attempt to use invalid processor. Request FAILED.");
+ }
+ else if ( containers.empty() ) {
+ except("+++ Processor %s is defined, but no workload was assigned. Request FAILED.");
+ }
+ const char* aname = action->name().c_str();
+ std::stringstream str;
+ std::vector<Key> keys;
+ for(const auto& c : containers) {
+ Key key(0x0, c);
+ if ( !m_allow_duplicates ) {
+ for(const auto& w : m_workers) {
+ if ( std::find(m_work_items.begin(), m_work_items.end(), key.item()) != m_work_items.end() ) {
+ error("+++ Container %s has already a worker action attached: %s",
+ c.c_str(), w->name());
+ except("+++ Need to set property allow_duplicates=True to allow such behavior.");
+ }
+ }
+ }
+ keys.push_back(key);
+ m_work_items.insert(key.item());
+ str << c << " ";
+ }
+ action->m_work_keys = keys;
+ Worker* w = new Worker(action, {nullptr, nullptr, keys});
+ m_callers.emplace_back(new DigiKernel::CallWrapper(w));
+ m_workers.emplace_back(std::unique_ptr<Worker>(w));
+ info("+++ Use processor: %-32s for processing: %s", aname, str.str().c_str());
+}
+
+/// Main functional callback
+void DigiMultiContainerProcessor::execute(DigiContext& context) const {
+ WorkItems work_items;
+ auto& msk = m_input_masks;
+ auto& event = *context.event;
+ auto& inputs = event.get_segment(m_input_segment);
+
+ work_items.reserve(inputs.size());
+ for( auto& i : inputs ) {
+ Key in_key(i.first);
+ bool use = msk.empty() || std::find(msk.begin(), msk.end(), in_key.mask()) != msk.end();
+ if ( use ) {
+ use = m_work_items.find(in_key.item()) != m_work_items.end();
+ if ( use ) {
+ work_items.emplace_back(std::make_pair(i.first, &i.second));
+ }
+ }
+ }
+ if ( !work_items.empty() ) {
+ for(std::size_t i=0; i < m_workers.size(); ++i) {
+ m_workers[i]->options.context = &context;
+ m_workers[i]->options.work = &work_items;
+ }
+ m_kernel.submit(m_callers);
+ }
+}
+
+/// Standard constructor
+DigiContainerProcessor::DigiContainerProcessor(const DigiKernel& kernel, const std::string& name)
+ : DigiAction(kernel, name)
+{
+ this->declareProperty("input_masks", m_input_masks);
+ this->declareProperty("input_segment", m_input_segment);
+}
+
+/// Main functional callback if specific work is known
+void DigiContainerProcessor::execute(DigiContext& context, WorkItems& data) const {
+ info("Hello there %p", (void*)&data);
+}
diff --git a/DDDigi/src/DigiSegmentationSplitter.cpp b/DDDigi/src/DigiSegmentationSplitter.cpp
index f4d1bfb0adbcede22e77e832b574b8e20fe876ee..28d860af728d4473973995677089cb745aab105c 100644
--- a/DDDigi/src/DigiSegmentationSplitter.cpp
+++ b/DDDigi/src/DigiSegmentationSplitter.cpp
@@ -23,9 +23,9 @@ using namespace dd4hep::digi;
class DigiSegmentAction::internals_t {
public:
- DigiSegmentContext split { };
- std::vector<std::pair<Key::key_type, std::any> > output;
- const DepositMapping* input { nullptr };
+ DigiSegmentContext split { };
+ DepositVector output { };
+ const DepositMapping* input { nullptr };
};
class DigiSegmentationSplitter::internals_t {
@@ -49,8 +49,9 @@ public:
};
/// Standard constructor
-DigiSegmentationSplitter::DigiSegmentationSplitter(const DigiKernel& krnl, const std::string& nam)
- : DigiActionSequence(krnl, nam), m_split_tool(krnl.detectorDescription())
+DigiSegmentationSplitter::DigiSegmentationSplitter(const DigiKernel& kernel, const std::string& nam)
+ : DigiActionSequence(kernel, nam),
+ m_split_tool(kernel.detectorDescription())
{
this->internals = std::make_unique<internals_t>(this);
declareProperty("detector", this->m_detector_name);
@@ -72,7 +73,6 @@ DigiSegmentationSplitter::~DigiSegmentationSplitter() {
void DigiSegmentationSplitter::initialize() {
char text[256];
std::size_t count = 0;
- DigiSegmentAction* proc;
this->m_split_tool.set_detector(this->m_detector_name);
this->m_split_context = this->m_split_tool.split_context(this->m_split_by);
@@ -83,7 +83,15 @@ void DigiSegmentationSplitter::initialize() {
for( auto& p : this->m_splits ) {
::snprintf(text, sizeof(text), "_%05X", m_split_context.split_id(p.first));
std::string nam = this->name() + text;
- proc = PluginService::Create<DigiSegmentAction*>(m_processor_type, &m_kernel, nam);
+ auto* eproc = PluginService::Create<DigiEventAction*>(m_processor_type, &m_kernel, nam);
+ if ( !eproc ) {
+ except("+++ Failed to create split worker: %s/%s", m_processor_type.c_str(), nam.c_str());
+ }
+ auto* proc = dynamic_cast<DigiSegmentAction*>(eproc);
+ if ( !proc ) {
+ except("+++ Split worker: %s/%s is not of type DigiSegmentAction!",
+ m_processor_type.c_str(), nam.c_str());
+ }
proc->internals = std::make_unique<DigiSegmentAction::internals_t>();
proc->internals->split = this->m_split_context;
proc->internals->split.detector = p.second.first;
@@ -102,6 +110,8 @@ void DigiSegmentationSplitter::execute(DigiContext& context) const {
auto* hits = input.pointer<DepositMapping>(k);
if ( hits ) {
/// prepare processors for execution
+ info("+++ Got hit collection %04X %08X. Prepare processors.",
+ Key::mask(k), Key::item(k));
for ( auto* a : this->m_actors ) {
auto* proc = (DigiSegmentAction*)a;
proc->internals->input = hits;
@@ -127,23 +137,13 @@ DigiSegmentAction::~DigiSegmentAction() {
void DigiSegmentAction::execute(DigiContext& context) const {
auto& imp = *this->internals;
- auto ret = this->handleSegment(context, imp.split, *imp.input);
- imp.output = std::move(ret);
+ imp.output = this->handleSegment(context, imp.split, *imp.input);
}
/// Main functional callback
-std::vector<std::pair<Key::key_type, std::any> >
-DigiSegmentAction::handleSegment(DigiContext& context,
- const DigiSegmentContext& segment,
- const DepositMapping& deposits) const {
- for( const auto& depo : deposits ) {
- if ( segment.split_id(depo.first) == segment.id ) {
- auto cell = depo.first;
- const auto& d = depo.second;
- info("%s[%s] %s-id: %d [processor:%d] Cell: %016lX mask: %016lX hist:%4ld entries deposit: %f",
- context.event->id(), segment.idspec.name(), segment.cname(),
- segment.split_id(cell), segment.id, cell, segment.split_mask, d.history.size(), d.deposit);
- }
- }
+DepositVector
+DigiSegmentAction::handleSegment(DigiContext& /* context */,
+ const DigiSegmentContext& /* segment */,
+ const DepositMapping& /* depos */) const {
return {};
}
diff --git a/DDDigi/src/DigiStoreDump.cpp b/DDDigi/src/DigiStoreDump.cpp
index 50c8d29787ef058476fbb8eadf68efaebe053e98..b93ed8a26f2464a26c9f3909002d7ee834d9c934 100644
--- a/DDDigi/src/DigiStoreDump.cpp
+++ b/DDDigi/src/DigiStoreDump.cpp
@@ -55,10 +55,15 @@ void dd4hep::digi::DigiStoreDump::dump(const std::string& tag,
std::size_t idx = typ.find(", std::less<long long>, std::allocator<std::pair");
if ( idx != std::string::npos ) typ = str_replace(typ, typ.substr(idx), ">");
typ = str_replace(str_replace(typ,"std::",""),"dd4hep::digi::","");
- if ( const auto* hits = std::any_cast<DepositMapping>(&data) ) {
+ if ( const auto* mapping = std::any_cast<DepositMapping>(&data) ) {
str = this->format("%s|---- %4X %08X %-32s: %6ld hits [%s]",
event.id(), key.values.mask, key.values.item,
- nam.c_str(), hits->size(), typ.c_str());
+ nam.c_str(), mapping->size(), typ.c_str());
+ }
+ else if ( const auto* vector = std::any_cast<DepositVector>(&data) ) {
+ str = this->format("%s|---- %4X %08X %-32s: %6ld hits [%s]",
+ event.id(), key.values.mask, key.values.item,
+ nam.c_str(), vector->size(), typ.c_str());
}
else if ( const auto* parts = std::any_cast<ParticleMapping>(&data) ) {
str = this->format("%s|---- %4X %08X %-32s: %6ld particles [%s]",
diff --git a/DDDigi/src/noise/DigiExponentialNoise.cpp b/DDDigi/src/noise/DigiExponentialNoise.cpp
index ff456171f1cf680dba55985a6ef1dfb4f90aafb8..83bc2ad4c6b703cdc1b998de7cb1ca22663f1a39 100644
--- a/DDDigi/src/noise/DigiExponentialNoise.cpp
+++ b/DDDigi/src/noise/DigiExponentialNoise.cpp
@@ -15,7 +15,7 @@
#include <DD4hep/InstanceCount.h>
#include <DDDigi/DigiSegmentation.h>
#include <DDDigi/DigiRandomGenerator.h>
-#include <DDDigi/DigiExponentialNoise.h>
+#include <DDDigi/noise/DigiExponentialNoise.h>
using namespace dd4hep::digi;
diff --git a/DDDigi/src/noise/DigiGaussianNoise.cpp b/DDDigi/src/noise/DigiGaussianNoise.cpp
index dc10c3aa9ad1dbd21bedfe686ec2a64127a890cb..362104ccd2a6c6c2eed17c57b0b484d1e74377c6 100644
--- a/DDDigi/src/noise/DigiGaussianNoise.cpp
+++ b/DDDigi/src/noise/DigiGaussianNoise.cpp
@@ -15,7 +15,7 @@
#include <DD4hep/InstanceCount.h>
#include <DDDigi/DigiSegmentation.h>
#include <DDDigi/DigiRandomGenerator.h>
-#include <DDDigi/DigiGaussianNoise.h>
+#include <DDDigi/noise/DigiGaussianNoise.h>
using namespace dd4hep::digi;
diff --git a/DDDigi/src/noise/DigiLandauNoise.cpp b/DDDigi/src/noise/DigiLandauNoise.cpp
index 11188203bec55ef5ced5411e160c7ea96dba4246..8de50b2bc4bc91d43b388c3dfefb956d315d2cfc 100644
--- a/DDDigi/src/noise/DigiLandauNoise.cpp
+++ b/DDDigi/src/noise/DigiLandauNoise.cpp
@@ -13,7 +13,7 @@
// Framework include files
#include <DD4hep/InstanceCount.h>
-#include <DDDigi/DigiLandauNoise.h>
+#include <DDDigi/noise/DigiLandauNoise.h>
#include <DDDigi/DigiSegmentation.h>
#include <DDDigi/DigiRandomGenerator.h>
diff --git a/DDDigi/src/noise/DigiPoissonNoise.cpp b/DDDigi/src/noise/DigiPoissonNoise.cpp
index 85f4ff81cb7b6f3f5199690e1b4d40258c22a168..3143ea3c6525a776fa02d8fc5d7ddcc1e1445830 100644
--- a/DDDigi/src/noise/DigiPoissonNoise.cpp
+++ b/DDDigi/src/noise/DigiPoissonNoise.cpp
@@ -13,7 +13,7 @@
// Framework include files
#include <DD4hep/InstanceCount.h>
-#include <DDDigi/DigiPoissonNoise.h>
+#include <DDDigi/noise/DigiPoissonNoise.h>
#include <DDDigi/DigiSegmentation.h>
#include <DDDigi/DigiRandomGenerator.h>
diff --git a/DDDigi/src/noise/DigiRandomNoise.cpp b/DDDigi/src/noise/DigiRandomNoise.cpp
index 458c0d7a8b316ef0dcec67a7b0cba6a7253129fa..2869a3b649078908af6029dba7351b1d913d1217 100644
--- a/DDDigi/src/noise/DigiRandomNoise.cpp
+++ b/DDDigi/src/noise/DigiRandomNoise.cpp
@@ -13,7 +13,7 @@
// Framework include files
#include <DD4hep/InstanceCount.h>
-#include <DDDigi/DigiRandomNoise.h>
+#include <DDDigi/noise/DigiRandomNoise.h>
using namespace dd4hep::digi;
diff --git a/DDDigi/src/noise/DigiSignalProcessorSequence.cpp b/DDDigi/src/noise/DigiSignalProcessorSequence.cpp
index b7001f8ad2e41658c29bf7d7eba5b8484d943c9d..25aec3071d13c336034e933295c933119c7f833e 100644
--- a/DDDigi/src/noise/DigiSignalProcessorSequence.cpp
+++ b/DDDigi/src/noise/DigiSignalProcessorSequence.cpp
@@ -14,7 +14,7 @@
// Framework include files
#include <DD4hep/InstanceCount.h>
#include <DDDigi/DigiSegmentation.h>
-#include <DDDigi/DigiSignalProcessorSequence.h>
+#include <DDDigi/noise/DigiSignalProcessorSequence.h>
// C/C++ include files
#include <stdexcept>
diff --git a/DDDigi/src/noise/DigiSubdetectorSequence.cpp b/DDDigi/src/noise/DigiSubdetectorSequence.cpp
index a46bd2a73096fbbc7165042fa19cc6086817b419..9d9fc3ab59e373d16e67fee990204bd819d19ab6 100644
--- a/DDDigi/src/noise/DigiSubdetectorSequence.cpp
+++ b/DDDigi/src/noise/DigiSubdetectorSequence.cpp
@@ -12,7 +12,7 @@
//==========================================================================
// Framework include files
-#include <DDDigi/DigiSubdetectorSequence.h>
+#include <DDDigi/noise/DigiSubdetectorSequence.h>
#include <DDDigi/DigiSegmentation.h>
#include <DDDigi/DigiKernel.h>
#include <DDDigi/DigiContext.h>
diff --git a/DDDigi/src/noise/DigiUniformNoise.cpp b/DDDigi/src/noise/DigiUniformNoise.cpp
index d4dd6d190e681b1b122b423bc82160de6013b21c..78fc7a3da6677c2b91dbe78f76e40db80f049ffa 100644
--- a/DDDigi/src/noise/DigiUniformNoise.cpp
+++ b/DDDigi/src/noise/DigiUniformNoise.cpp
@@ -14,7 +14,7 @@
// Framework include files
#include <DD4hep/InstanceCount.h>
#include <DDDigi/DigiRandomGenerator.h>
-#include <DDDigi/DigiUniformNoise.h>
+#include <DDDigi/noise/DigiUniformNoise.h>
using namespace dd4hep::digi;
diff --git a/DDDigi/src/noise/FalphaNoise.cpp b/DDDigi/src/noise/FalphaNoise.cpp
index 70946b8168bb545d58ef10d3f94315a359c92e16..6155579999859011e751216ebdc46049c688504a 100644
--- a/DDDigi/src/noise/FalphaNoise.cpp
+++ b/DDDigi/src/noise/FalphaNoise.cpp
@@ -12,7 +12,7 @@
//==========================================================================
/// Framework include files
-#include <DDDigi/FalphaNoise.h>
+#include <DDDigi/noise/FalphaNoise.h>
/// C/C++ include files
#include <cmath>
diff --git a/examples/DDDigi/scripts/DigiTest.py b/examples/DDDigi/scripts/DigiTest.py
index b47182e09478e548eca02b99bf09ffdfb0221a9a..84cf2d952feca4ab101c1642999d50bb09eef57f 100644
--- a/examples/DDDigi/scripts/DigiTest.py
+++ b/examples/DDDigi/scripts/DigiTest.py
@@ -70,12 +70,22 @@ class Test(dddigi.Digitize):
'CLICSiD_2022-10-05_14-40.root']
self.used_inputs = []
+ def segment_action(self, nam, **options):
+ obj = dddigi.Interface.createSegmentAction(self.kernel(), str(nam))
+ return obj
+
def load_geo(self):
- install_dir = os.environ['DD4hepINSTALL']
- fname = "file:" + install_dir + "/DDDetectors/compact/SiD.xml"
+ fname = "file:" + os.environ['DD4hepINSTALL'] + "/DDDetectors/compact/SiD.xml"
self.kernel().loadGeometry(str(fname))
self.printDetectors()
+ def data_containers(self):
+ return list(self.attenuation.keys())
+
+ def containers(self, first, last):
+ keys = list(self.attenuation.keys())
+ return keys[first:last]
+
def check_creation(self, objs):
for o in objs:
if o is None:
diff --git a/examples/DDDigi/scripts/TestInput.py b/examples/DDDigi/scripts/TestInput.py
index 6615e5d473e82335319d9974aff8373b10f0c49b..a35b18f93453a19c97ebb0d2a84eb632b3df02f4 100644
--- a/examples/DDDigi/scripts/TestInput.py
+++ b/examples/DDDigi/scripts/TestInput.py
@@ -14,7 +14,7 @@ from __future__ import absolute_import
def run():
import DigiTest
digi = DigiTest.Test(geometry=None)
- read = digi.input_action('DigiROOTInput/SignalReader', mask=0x1, input=['CLICSiD_2022-10-05_13-21.root'])
+ read = digi.input_action('DigiROOTInput/SignalReader', mask=0x0, input=['CLICSiD_2022-10-05_13-21.root'])
dump = digi.event_action('DigiStoreDump/StoreDump')
digi.check_creation([read, dump])
digi.run_checked(num_events=5, num_threads=5, parallel=3)
diff --git a/examples/DDDigi/scripts/TestMultiContainerParallel.py b/examples/DDDigi/scripts/TestMultiContainerParallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..150143cd31d4bb9ef2c6c4957fef92190fb53abb
--- /dev/null
+++ b/examples/DDDigi/scripts/TestMultiContainerParallel.py
@@ -0,0 +1,43 @@
+# ==========================================================================
+# 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.
+#
+# ==========================================================================
+from __future__ import absolute_import
+import dddigi
+
+def run():
+ import DigiTest
+ digi = DigiTest.Test(geometry=None)
+ #digi.load_geo()
+ input = digi.input_action('DigiParallelActionSequence/READER')
+ # ========================================================================
+ digi.info('Created SIGNAL input')
+ signal = input.adopt_action('DigiROOTInput/SignalReader', mask=0x0, input=[digi.next_input()])
+ digi.check_creation([signal])
+ # ========================================================================
+ event = digi.event_action('DigiSequentialActionSequence/EventAction')
+ proc = event.adopt_action('DigiMultiContainerProcessor/ContainerProc',
+ input_masks=[0x0, 0x1, 0x2, 0x3])
+ cont = digi.data_containers()
+ num = int((len(cont)+2)/3)
+ for i in range(num):
+ #merge = digi.event_action('DigiSegmentDepositPrint/SegmentPrint_%03d'%(i,), register=None)
+ merge = dddigi.Action(digi.kernel(), 'DigiContainerProcessor/SegmentPrint_%03d'%(i,));
+ conts = digi.containers(i*3,(i+1)*3)
+ proc.adopt_processor(merge, conts)
+
+ #dump = event.adopt_action('DigiStoreDump/StoreDump')
+ #digi.check_creation([combine, dump, splitter])
+ #digi.info('Created event.dump')
+ # ========================================================================
+ digi.run_checked(num_events=1, num_threads=5, parallel=3)
+
+
+if __name__ == '__main__':
+ run()
diff --git a/examples/DDDigi/scripts/TestMultiInteractions.py b/examples/DDDigi/scripts/TestMultiInteractions.py
index 0637e1c9706e17b16e10625b29130e674a79629e..223e18e673d85fba4f6ff69240d317e5cf9216ba 100644
--- a/examples/DDDigi/scripts/TestMultiInteractions.py
+++ b/examples/DDDigi/scripts/TestMultiInteractions.py
@@ -42,7 +42,7 @@ def run():
digi.info('Created input.overlay75')
# ========================================================================================================
event = digi.event_action('DigiSequentialActionSequence/EventAction')
- combine = event.adopt_action('DigiContainerCombine/Combine', masks=[0x0, 0x1, 0x2, 0x3], deposit_mask=0xFEED)
+ combine = event.adopt_action('DigiContainerCombine/Combine', input_masks=[0x0, 0x1, 0x2, 0x3], deposit_mask=0xFEED)
combine.erase_combined = True # Not thread-safe! only do in SequentialActionSequence
dump = event.adopt_action('DigiStoreDump/StoreDump')
digi.check_creation([combine, dump])
diff --git a/examples/DDDigi/scripts/TestSegmentationSplit.py b/examples/DDDigi/scripts/TestSegmentationSplit.py
index e5acd8ab868153b5537e7b61daeb3909a17a0115..2707b1769d71e4f742c8b01fcb0dc5f8f2f7f280 100644
--- a/examples/DDDigi/scripts/TestSegmentationSplit.py
+++ b/examples/DDDigi/scripts/TestSegmentationSplit.py
@@ -22,14 +22,14 @@ def run():
digi.check_creation([signal])
# ========================================================================
event = digi.event_action('DigiSequentialActionSequence/EventAction')
- combine = event.adopt_action('DigiContainerCombine/Combine', masks=[0x0, 0x1, 0x2, 0x3], deposit_mask=0xFEED)
+ combine = event.adopt_action('DigiContainerCombine/Combine', input_masks=[0x0, 0x1, 0x2, 0x3], deposit_mask=0xFEED)
combine.erase_combined = True # Not thread-safe! only do in SequentialActionSequence
splitter = event.adopt_action('DigiSegmentationSplitter/Splitter',
input='deposits',
mask=0xFEED,
detector='SiTrackerBarrel',
split_by='layer',
- processor_type='DigiSegmentAction')
+ processor_type='DigiSegmentDepositPrint')
splitter.parallel = True
dump = event.adopt_action('DigiStoreDump/StoreDump')
digi.check_creation([combine, dump, splitter])
diff --git a/examples/DDDigi/scripts/TestSpillover.py b/examples/DDDigi/scripts/TestSpillover.py
index 7e1fe1530a30736a26aa94471c3b6773a5251ab9..59471682d41ee49e06197db70d77eff9b07153db 100644
--- a/examples/DDDigi/scripts/TestSpillover.py
+++ b/examples/DDDigi/scripts/TestSpillover.py
@@ -76,7 +76,9 @@ def run():
digi.info('Created input.spillover75')
# ========================================================================================================
event = digi.event_action('DigiSequentialActionSequence/EventAction')
- combine = event.adopt_action('DigiContainerCombine/Combine', masks=[0x0, 0x1, 0x2, 0x3], deposit_mask=0xFEED)
+ combine = event.adopt_action('DigiContainerCombine/Combine',
+ input_masks=[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6],
+ deposit_mask=0xFEED)
combine.erase_combined = True # Not thread-safe! only do in SequentialActionSequence
evtdump = event.adopt_action('DigiStoreDump/StoreDump')
digi.check_creation([combine, evtdump])