diff --git a/src/algorithms/digi/CMakeLists.txt b/src/algorithms/digi/CMakeLists.txt index bdf412c252..93cf682f14 100644 --- a/src/algorithms/digi/CMakeLists.txt +++ b/src/algorithms/digi/CMakeLists.txt @@ -1,5 +1,3 @@ -cmake_minimum_required(VERSION 3.16) - set(PLUGIN_NAME "algorithms_digi") # Function creates ${PLUGIN_NAME}_plugin and ${PLUGIN_NAME}_library targets @@ -12,7 +10,6 @@ plugin_add(${PLUGIN_NAME} WITH_SHARED_LIBRARY WITHOUT_PLUGIN) plugin_glob_all(${PLUGIN_NAME}) # Find dependencies -plugin_add_algorithms(${PLUGIN_NAME}) plugin_add_dd4hep(${PLUGIN_NAME}) plugin_add_cern_root(${PLUGIN_NAME}) plugin_add_event_model(${PLUGIN_NAME}) diff --git a/src/algorithms/digi/LGADChargeSharing.cc b/src/algorithms/digi/LGADChargeSharing.cc deleted file mode 100644 index 6a491c1b8a..0000000000 --- a/src/algorithms/digi/LGADChargeSharing.cc +++ /dev/null @@ -1,183 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Copyright (C) 2024 Chun Yuen Tsang, Prithwish Tribedy -// -// Spread energy deposition from one strip to neighboring strips within sensor boundaries - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "DD4hep/Detector.h" -#include "LGADChargeSharing.h" -#include "algorithms/digi/LGADChargeSharingConfig.h" -#include "services/evaluator/EvaluatorSvc.h" - -namespace eicrecon { - -void LGADChargeSharing::init() { - m_detector = algorithms::GeoSvc::instance().detector(); - m_converter = algorithms::GeoSvc::instance().cellIDPositionConverter(); - - auto seg = m_detector->readout(m_cfg.readout).segmentation(); - auto type = seg.type(); - // retrieve meaning of cellID bits - m_decoder = seg.decoder(); - m_idSpec = m_detector->readout(m_cfg.readout).idSpec(); - - // convert cellID to name value pairs for EvaluatorSvc to determine of different cells are neighbors - std::function hit_pair_to_map = [this](const dd4hep::rec::CellID& id1, - const dd4hep::rec::CellID& id2) { - std::unordered_map params; - for (const auto& p : m_idSpec.fields()) { - const std::string& name = p.first; - const dd4hep::IDDescriptor::Field* field = p.second; - params.emplace(name + "_1", field->value(id1)); - params.emplace(name + "_2", field->value(id2)); - trace("{}_1 = {}", name, field->value(id1)); - trace("{}_2 = {}", name, field->value(id2)); - } - return params; - }; - - auto& serviceSvc = algorithms::ServiceSvc::instance(); - _is_same_sensor = serviceSvc.service("EvaluatorSvc") - ->compile(m_cfg.same_sensor_condition, hit_pair_to_map); -} - -void LGADChargeSharing::process(const LGADChargeSharing::Input& input, - const LGADChargeSharing::Output& output) const { - const auto [simhits] = input; - auto [sharedHits] = output; - - for (const auto& hit : *simhits) { - auto cellID = hit.getCellID(); - const auto* context = m_converter->findContext(cellID); - - std::unordered_set dp; - std::vector neighbors; - this->_findAllNeighborsInSensor(cellID, neighbors, dp); - - double edep = hit.getEDep(); - double time = hit.getTime(); - auto momentum = hit.getMomentum(); - auto truePos = hit.getPosition(); - auto localPos_hit = this->_global2Local( - context, - dd4hep::Position(truePos.x * dd4hep::mm, truePos.y * dd4hep::mm, truePos.z * dd4hep::mm)); - - for (const auto neighbor : neighbors) { - // integrate over neighbor area to get total energy deposition - auto localPos_neighbor = this->_cell2LocalPosition(neighbor); - auto cellDimension = m_converter->cellDimensions(neighbor); - - double edep_cell = edep * - _integralGaus(localPos_hit.x(), m_cfg.sigma_sharingx, - localPos_neighbor.x() - 0.5 * cellDimension[0], - localPos_neighbor.x() + 0.5 * cellDimension[0]) * - _integralGaus(localPos_hit.y(), m_cfg.sigma_sharingy, - localPos_neighbor.y() - 0.5 * cellDimension[1], - localPos_neighbor.y() + 0.5 * cellDimension[1]); - - if (edep_cell > 0) { - auto globalPos = m_converter->position(neighbor); - auto hit = sharedHits->create(); - hit.setCellID(neighbor); - hit.setEDep(edep_cell); - hit.setTime(time); - hit.setPosition({globalPos.x(), globalPos.y(), globalPos.z()}); - hit.setMomentum({momentum.x, momentum.y, momentum.z}); - } - } - } -} // LGADChargeSharing:process - -void LGADChargeSharing::_findAllNeighborsInSensor( - dd4hep::rec::CellID hitCell, std::vector& answer, - std::unordered_set& dp) const { - // search all neighbors with DFS - answer.push_back(hitCell); - dp.insert(hitCell); - - for (const auto& field : m_cfg.neighbor_fields) { - // searchDir should either be +1 or -1 - for (int searchDir = -1; searchDir <= 1; searchDir += 2) { - auto fieldID = m_decoder->get(hitCell, field); - auto testCell = hitCell; - try { - m_decoder->set(testCell, field, fieldID + searchDir); - } catch (const std::runtime_error& err) { - // catch overflow error - // ignore if invalid position ID - continue; - } - - // check if new cellID really exists - try { - auto pos = m_converter->position(testCell); - if (testCell != m_converter->cellID(pos)) - continue; - } catch (const std::runtime_error& err) { - // Ignore CellID that is invalid - continue; - } - - // only look for cells that have not been searched - if (dp.find(testCell) == dp.end()) { - if (_is_same_sensor(hitCell, testCell)) { - // inside the same sensor - this->_findAllNeighborsInSensor(testCell, answer, dp); - } - } - } - } -} - -double LGADChargeSharing::_integralGaus(double mean, double sd, double low_lim, - double up_lim) const { - // return integral Gauss(mean, sd) dx from x = low_lim to x = up_lim - // default value is set when sd = 0 - double up = mean > up_lim ? -0.5 : 0.5; - double low = mean > low_lim ? -0.5 : 0.5; - if (sd > 0) { - up = -0.5 * std::erf(std::sqrt(2) * (mean - up_lim) / sd); - low = -0.5 * std::erf(std::sqrt(2) * (mean - low_lim) / sd); - } - return up - low; -} - -dd4hep::Position LGADChargeSharing::_cell2LocalPosition(const dd4hep::rec::CellID& cell) const { - auto context = m_converter->findContext(cell); // volume context - auto position = m_converter->position(cell); // global position - return this->_global2Local(context, position); -} - -dd4hep::Position LGADChargeSharing::_global2Local(const dd4hep::VolumeManagerContext* context, - const dd4hep::Position& pos) const { - auto nodeMatrix = context->element.nominal().worldTransformation(); - - double g[3], l[3]; - pos.GetCoordinates(g); - nodeMatrix.MasterToLocal(g, l); - dd4hep::Position position; - position.SetCoordinates(l); - return position; -} - -} // namespace eicrecon diff --git a/src/algorithms/digi/LGADChargeSharing.h b/src/algorithms/digi/LGADChargeSharing.h deleted file mode 100644 index d79762ad28..0000000000 --- a/src/algorithms/digi/LGADChargeSharing.h +++ /dev/null @@ -1,60 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Copyright (C) 2024 Chun Yuen Tsang, Prithwish Tribedy -// -// Spread energy deposition from one strip to neighboring strips within sensor boundaries - -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "DD4hep/Detector.h" -#include "algorithms/digi/LGADChargeSharingConfig.h" -#include "algorithms/interfaces/WithPodConfig.h" - -namespace eicrecon { - -using LGADChargeSharingAlgorithm = - algorithms::Algorithm, - algorithms::Output>; - -class LGADChargeSharing : public LGADChargeSharingAlgorithm, - public WithPodConfig { - -public: - LGADChargeSharing(std::string_view name) - : LGADChargeSharingAlgorithm{name, {"TOFBarrelHits"}, {"TOFBarrelSharedHits"}, ""} {}; - - void init() final; - void process(const Input&, const Output&) const final; - -private: - void _findAllNeighborsInSensor(dd4hep::rec::CellID hitCell, - std::vector& answer, - std::unordered_set& dp) const; - double _integralGaus(double mean, double sd, double low_lim, double up_lim) const; - dd4hep::Position _cell2LocalPosition(const dd4hep::rec::CellID& cell) const; - dd4hep::Position _global2Local(const dd4hep::VolumeManagerContext* context, - const dd4hep::Position& pos) const; - - const dd4hep::DDSegmentation::BitFieldCoder* m_decoder = nullptr; - const dd4hep::Detector* m_detector = nullptr; - const dd4hep::rec::CellIDPositionConverter* m_converter = nullptr; - dd4hep::IDDescriptor m_idSpec; - - // helper function to find neighbors - std::function - _is_same_sensor; -}; - -} // namespace eicrecon diff --git a/src/algorithms/digi/LGADChargeSharingConfig.h b/src/algorithms/digi/LGADChargeSharingConfig.h deleted file mode 100644 index 9374c5bce9..0000000000 --- a/src/algorithms/digi/LGADChargeSharingConfig.h +++ /dev/null @@ -1,20 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Copyright (C) 2024 Souvik Paul - -#pragma once - -#include - -namespace eicrecon { - -struct LGADChargeSharingConfig { - // Parameters of AC-LGAD signal generation - double sigma_sharingx; - double sigma_sharingy; - - std::string readout; - std::string same_sensor_condition; - std::vector neighbor_fields; -}; - -} // namespace eicrecon diff --git a/src/algorithms/digi/SiliconChargeSharing.cc b/src/algorithms/digi/SiliconChargeSharing.cc new file mode 100644 index 0000000000..4a4d18c6a6 --- /dev/null +++ b/src/algorithms/digi/SiliconChargeSharing.cc @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// Copyright (C) 2024-2025 Chun Yuen Tsang, Prithwish Tribedy, Simon Gardner +// +// Spread energy deposition from one strip to neighboring strips within sensor boundaries + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "DD4hep/Detector.h" +#include "SiliconChargeSharing.h" +#include "algorithms/digi/SiliconChargeSharingConfig.h" + +namespace eicrecon { + +void SiliconChargeSharing::init() { + m_converter = algorithms::GeoSvc::instance().cellIDPositionConverter(); + m_seg = algorithms::GeoSvc::instance().detector()->readout(m_cfg.readout).segmentation(); +} + +void SiliconChargeSharing::process(const SiliconChargeSharing::Input& input, + const SiliconChargeSharing::Output& output) const { + const auto [simhits] = input; + auto [sharedHits] = output; + + for (const auto& hit : *simhits) { + + auto cellID = hit.getCellID(); + + auto element = &m_converter->findContext(cellID)->element; // volume context + // ToDo: Move this to init() and set it once for every detelement associated with the readout + // Set transformation map if it hasn't already been set + m_transform_map.try_emplace(element, &element->nominal().worldTransformation()); + m_segmentation_map.try_emplace(element, getLocalSegmentation(cellID)); + + // Try and get a box of the detectorElement solid + try { + dd4hep::Box box = element->solid(); + + if (box) { + m_x_range_map.try_emplace(element, box->GetDX()); + m_y_range_map.try_emplace(element, box->GetDY()); + } + } catch (const std::bad_cast& e) { + error("Failed to cast solid to Box: {}", e.what()); + } + + auto edep = hit.getEDep(); + auto globalHitPos = hit.getPosition(); + auto hitPos = + global2Local(dd4hep::Position(globalHitPos.x * dd4hep::mm, globalHitPos.y * dd4hep::mm, + globalHitPos.z * dd4hep::mm), + m_transform_map[element]); + + std::unordered_set tested_cells; + std::vector> cell_charge; + findAllNeighborsInSensor(cellID, tested_cells, cell_charge, edep, hitPos, element); + + // Create a new simhit for each cell with deposited energy + for (const auto& [testCellID, edep_cell] : cell_charge) { + auto globalCellPos = m_converter->position(testCellID); + + edm4hep::MutableSimTrackerHit shared_hit = hit.clone(); + shared_hit.setCellID(testCellID); + shared_hit.setEDep(edep_cell); + shared_hit.setPosition({globalCellPos.x() / dd4hep::mm, globalCellPos.y() / dd4hep::mm, + globalCellPos.z() / dd4hep::mm}); + sharedHits->push_back(shared_hit); + } + + } // for simhits +} // SiliconChargeSharing:process + +// Recursively find neighbors where a charge is deposited +void SiliconChargeSharing::findAllNeighborsInSensor( + const dd4hep::rec::CellID testCellID, std::unordered_set& tested_cells, + std::vector>& cell_charge, const float edep, + const dd4hep::Position hitPos, const dd4hep::DetElement* element) const { + + // Tag cell as tested + tested_cells.insert(testCellID); + + auto localPos = cell2LocalPosition(testCellID); + + // Check if the cell is within the sensor boundaries + if (std::abs(localPos.x()) > m_x_range_map[element] || + std::abs(localPos.y()) > m_y_range_map[element]) { + return; + } + + auto segmentation = m_segmentation_map[element]; + + // cout the local position and hit position + auto xDimension = segmentation->gridSizeX(); + auto yDimension = segmentation->gridSizeY(); + // Calculate deposited energy in cell + float edepCell = energyAtCell(xDimension, yDimension, localPos, hitPos, edep); + if (edepCell < m_cfg.min_edep) { + return; + } + + // Store cellID and deposited energy + cell_charge.push_back(std::make_pair(testCellID, edepCell)); + + // As there is charge in the cell, test the neighbors too + std::set testCellNeighbours; + segmentation->neighbours(testCellID, testCellNeighbours); + + for (const auto& neighbourCell : testCellNeighbours) { + if (tested_cells.find(neighbourCell) == tested_cells.end()) { + findAllNeighborsInSensor(neighbourCell, tested_cells, cell_charge, edep, hitPos, element); + } + } +} + +// Calculate integral of Gaussian distribution +float SiliconChargeSharing::integralGaus(float mean, float sd, float low_lim, float up_lim) const { + // return integral Gauss(mean, sd) dx from x = low_lim to x = up_lim + // default value is set when sd = 0 + float up = mean > up_lim ? -0.5 : 0.5; + float low = mean > low_lim ? -0.5 : 0.5; + if (sd > 0) { + up = -0.5 * std::erf(std::sqrt(2) * (mean - up_lim) / sd); + low = -0.5 * std::erf(std::sqrt(2) * (mean - low_lim) / sd); + } + return up - low; +} + +// Convert cellID to local position +dd4hep::Position SiliconChargeSharing::cell2LocalPosition(const dd4hep::rec::CellID& cell) const { + auto position = m_seg->position(cell); // local position + return position; +} + +// Convert global position to local position +dd4hep::Position SiliconChargeSharing::global2Local(const dd4hep::Position& globalPosition, + const TGeoHMatrix* transform) const { + + double g[3]; + double l[3]; + + globalPosition.GetCoordinates(g); + transform->MasterToLocal(g, l); + dd4hep::Position localPosition; + localPosition.SetCoordinates(l); + return localPosition; +} + +// Calculate energy deposition in a cell relative to the hit position +float SiliconChargeSharing::energyAtCell(const double xDimension, const double yDimension, + const dd4hep::Position localPos, + const dd4hep::Position hitPos, const float edep) const { + float energy = edep * + integralGaus(hitPos.x(), m_cfg.sigma_sharingx, localPos.x() - 0.5 * xDimension, + localPos.x() + 0.5 * xDimension) * + integralGaus(hitPos.y(), m_cfg.sigma_sharingy, localPos.y() - 0.5 * yDimension, + localPos.y() + 0.5 * yDimension); + return energy; +} + +// Get the segmentation relevant to a cellID +const dd4hep::DDSegmentation::CartesianGridXY* +SiliconChargeSharing::getLocalSegmentation(const dd4hep::rec::CellID& cellID) const { + // Get the segmentation type + auto segmentation_type = m_seg.type(); + const dd4hep::DDSegmentation::Segmentation* segmentation = m_seg.segmentation(); + // Check if the segmentation is a multi-segmentation + while (segmentation_type == "MultiSegmentation") { + const auto* multi_segmentation = + dynamic_cast(segmentation); + segmentation = &multi_segmentation->subsegmentation(cellID); + segmentation_type = segmentation->type(); + } + + // Try to cast the segmentation to CartesianGridXY + const auto* cartesianGrid = + dynamic_cast(segmentation); + if (!cartesianGrid) { + throw std::runtime_error("Segmentation is not of type CartesianGridXY"); + } + + return cartesianGrid; +} + +} // namespace eicrecon diff --git a/src/algorithms/digi/SiliconChargeSharing.h b/src/algorithms/digi/SiliconChargeSharing.h new file mode 100644 index 0000000000..978e3a7338 --- /dev/null +++ b/src/algorithms/digi/SiliconChargeSharing.h @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// Copyright (C) 2024-2025 Chun Yuen Tsang, Prithwish Tribedy, Simon Gardner +// +// Spread energy deposition from one strip to neighboring strips within sensor boundaries + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "algorithms/digi/SiliconChargeSharingConfig.h" +#include "algorithms/interfaces/WithPodConfig.h" + +namespace eicrecon { + +using SiliconChargeSharingAlgorithm = + algorithms::Algorithm, + algorithms::Output>; + +class SiliconChargeSharing : public SiliconChargeSharingAlgorithm, + public WithPodConfig { + +public: + SiliconChargeSharing(std::string_view name) + : SiliconChargeSharingAlgorithm{name, {"inputHits"}, {"outputSharedHits"}, ""} {}; + + void init() final; + void process(const Input&, const Output&) const final; + +private: + void findAllNeighborsInSensor(const dd4hep::rec::CellID test_CellID, + std::unordered_set& tested_cells, + std::vector>& cell_charge, + const float edep, const dd4hep::Position hitPos, + const dd4hep::DetElement* element) const; + float energyAtCell(const double xDimension, const double yDimension, + const dd4hep::Position localPos, const dd4hep::Position hitPos, + const float edep) const; + float integralGaus(float mean, float sd, float low_lim, float up_lim) const; + dd4hep::Position cell2LocalPosition(const dd4hep::rec::CellID& cell) const; + dd4hep::Position global2Local(const dd4hep::Position& globalPosition, + const TGeoHMatrix* transform) const; + const dd4hep::DDSegmentation::CartesianGridXY* + getLocalSegmentation(const dd4hep::rec::CellID& cellID) const; + + mutable std::unordered_map m_transform_map; + mutable std::unordered_map + m_segmentation_map; + mutable std::unordered_map m_x_range_map; + mutable std::unordered_map m_y_range_map; + const dd4hep::rec::CellIDPositionConverter* m_converter = nullptr; + dd4hep::Segmentation m_seg; +}; + +} // namespace eicrecon diff --git a/src/algorithms/digi/SiliconChargeSharingConfig.h b/src/algorithms/digi/SiliconChargeSharingConfig.h new file mode 100644 index 0000000000..05c69fae14 --- /dev/null +++ b/src/algorithms/digi/SiliconChargeSharingConfig.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// Copyright (C) 2024 Souvik Paul + +#pragma once + +namespace eicrecon { + +struct SiliconChargeSharingConfig { + // Parameters of Silicon signal generation + float sigma_sharingx; + float sigma_sharingy; + float min_edep; + std::string readout; +}; + +} // namespace eicrecon diff --git a/src/detectors/BTOF/BTOF.cc b/src/detectors/BTOF/BTOF.cc index 4cc7f07b12..863ba7ae3b 100644 --- a/src/detectors/BTOF/BTOF.cc +++ b/src/detectors/BTOF/BTOF.cc @@ -19,11 +19,11 @@ #include "algorithms/pid_lut/PIDLookupConfig.h" #include "extensions/jana/JOmniFactoryGeneratorT.h" #include "factories/digi/EICROCDigitization_factory.h" -#include "factories/digi/LGADChargeSharing_factory.h" #include "factories/digi/SiliconPulseDiscretization_factory.h" #include "factories/digi/SiliconPulseGeneration_factory.h" #include "factories/digi/SiliconTrackerDigi_factory.h" #include "factories/tracking/TrackerHitReconstruction_factory.h" +#include "factories/digi/SiliconChargeSharing_factory.h" #include "factories/digi/PulseCombiner_factory.h" #include "global/pid_lut/PIDLookup_factory.h" #include "services/geometry/dd4hep/DD4hep_service.h" @@ -52,13 +52,14 @@ void InitPlugin(JApplication* app) { }, app)); // Hit reco default config for factories - app->Add(new JOmniFactoryGeneratorT( - "LGADChargeSharing", {"TOFBarrelHits"}, {"TOFBarrelSharedHits"}, - {.sigma_sharingx = 0.1 * dd4hep::cm, - .sigma_sharingy = 0.5 * dd4hep::cm, - .readout = "TOFBarrelHits", - .same_sensor_condition = "sensor_1 == sensor_2", - .neighbor_fields = {"x", "y"}}, + app->Add(new JOmniFactoryGeneratorT( + "TOFBarrelSharedHits", {"TOFBarrelHits"}, {"TOFBarrelSharedHits"}, + { + .sigma_sharingx = 0.1 * dd4hep::cm, + .sigma_sharingy = 0.5 * dd4hep::cm, + .min_edep = 0.0 * edm4eic::unit::GeV, + .readout = "TOFBarrelHits", + }, app)); // calculation of the extreme values for Landau distribution can be found on lin 514-520 of diff --git a/src/detectors/LOWQ2/LOWQ2.cc b/src/detectors/LOWQ2/LOWQ2.cc index 27ad43d151..edf984a375 100644 --- a/src/detectors/LOWQ2/LOWQ2.cc +++ b/src/detectors/LOWQ2/LOWQ2.cc @@ -3,6 +3,7 @@ // // +#include #include #include #include @@ -22,6 +23,7 @@ #include "extensions/jana/JOmniFactoryGeneratorT.h" #include "factories/digi/PulseCombiner_factory.h" #include "factories/digi/PulseNoise_factory.h" +#include "factories/digi/SiliconChargeSharing_factory.h" #include "factories/digi/SiliconPulseGeneration_factory.h" #include "factories/digi/SiliconTrackerDigi_factory.h" #include "factories/fardetectors/FarDetectorLinearProjection_factory.h" @@ -45,9 +47,20 @@ void InitPlugin(JApplication* app) { using namespace eicrecon; + std::string readout = "TaggerTrackerHits"; + + app->Add(new JOmniFactoryGeneratorT( + "TaggerTrackerChargeSharing", {"TaggerTrackerHits"}, {"TaggerTrackerSharedHits"}, + { + .sigma_sharingx = 15 * dd4hep::um, + .sigma_sharingy = 15 * dd4hep::um, + .min_edep = 0.1 * edm4eic::unit::keV, + .readout = readout, + }, + app)); // Generate signal pulse from hits app->Add(new JOmniFactoryGeneratorT( - "TaggerTrackerPulseGeneration", {"TaggerTrackerHits"}, {"TaggerTrackerHitPulses"}, + "TaggerTrackerPulseGeneration", {"TaggerTrackerSharedHits"}, {"TaggerTrackerHitPulses"}, { .pulse_shape_function = "LandauPulse", .pulse_shape_params = {1.0, 2 * edm4eic::unit::ns}, @@ -96,7 +109,6 @@ void InitPlugin(JApplication* app) { // Divide collection based on geometry segmentation labels // This should really be done before digitization as summing hits in the same cell couldn't even be mixed between layers. At the moment just prep for clustering. - std::string readout = "TaggerTrackerHits"; std::vector geometryLabels{"module", "layer"}; std::vector moduleIDs{1, 2}; std::vector layerIDs{0, 1, 2, 3}; diff --git a/src/factories/digi/PulseNoise_factory.h b/src/factories/digi/PulseNoise_factory.h index 5bdd8e724e..5a285775e5 100644 --- a/src/factories/digi/PulseNoise_factory.h +++ b/src/factories/digi/PulseNoise_factory.h @@ -3,9 +3,8 @@ #pragma once -#include - #include "algorithms/digi/PulseNoise.h" +#include "services/algorithms_init/AlgorithmsInit_service.h" #include "extensions/jana/JOmniFactory.h" namespace eicrecon { diff --git a/src/factories/digi/LGADChargeSharing_factory.h b/src/factories/digi/SiliconChargeSharing_factory.h similarity index 51% rename from src/factories/digi/LGADChargeSharing_factory.h rename to src/factories/digi/SiliconChargeSharing_factory.h index 4706c0bdf8..567e8c1b7d 100644 --- a/src/factories/digi/LGADChargeSharing_factory.h +++ b/src/factories/digi/SiliconChargeSharing_factory.h @@ -1,35 +1,35 @@ // SPDX-License-Identifier: LGPL-3.0-or-later -// Copyright (C) 2024 Chun Yuen Tsang +// Copyright (C) 2024-2025 Chun Yuen Tsang, Simon Gardner #pragma once +#include "algorithms/digi/SiliconChargeSharing.h" +#include "services/algorithms_init/AlgorithmsInit_service.h" #include "extensions/jana/JOmniFactory.h" -#include "algorithms/digi/LGADChargeSharing.h" -#include - namespace eicrecon { -class LGADChargeSharing_factory - : public JOmniFactory { +class SiliconChargeSharing_factory + : public JOmniFactory { public: - using AlgoT = eicrecon::LGADChargeSharing; + using AlgoT = eicrecon::SiliconChargeSharing; private: std::unique_ptr m_algo; PodioInput m_in_sim_track{this}; - PodioOutput m_out_reco_particles{this}; - ParameterRef m_sigma_sharingx{this, "sigmaSharingX", config().sigma_sharingx}; - ParameterRef m_sigma_sharingy{this, "sigmaSharingY", config().sigma_sharingy}; - Service m_algorithmsInit{this}; + ParameterRef m_sigma_sharingx{this, "sigmaSharingX", config().sigma_sharingx}; + ParameterRef m_sigma_sharingy{this, "sigmaSharingY", config().sigma_sharingy}; + ParameterRef m_min_edep{this, "minEDep", config().min_edep}; + ParameterRef m_readout{this, "readout", config().readout}; + public: void Configure() { - m_algo = std::make_unique(GetPrefix()); + m_algo = std::make_unique(GetPrefix()); m_algo->level(static_cast(logger()->level())); m_algo->applyConfig(config()); m_algo->init(); diff --git a/src/factories/digi/SiliconPulseDiscretization_factory.h b/src/factories/digi/SiliconPulseDiscretization_factory.h index ba2052f869..3133f36fc8 100644 --- a/src/factories/digi/SiliconPulseDiscretization_factory.h +++ b/src/factories/digi/SiliconPulseDiscretization_factory.h @@ -3,10 +3,9 @@ #pragma once -#include "extensions/jana/JOmniFactory.h" - +#include "services/algorithms_init/AlgorithmsInit_service.h" #include "algorithms/digi/SiliconPulseDiscretization.h" -#include +#include "extensions/jana/JOmniFactory.h" namespace eicrecon { @@ -33,7 +32,7 @@ class SiliconPulseDiscretization_factory public: void Configure() { - m_algo = std::make_unique(GetPrefix()); + m_algo = std::make_unique(GetPrefix()); m_algo->level(static_cast(logger()->level())); m_algo->applyConfig(config()); m_algo->init(); diff --git a/src/factories/digi/SiliconPulseGeneration_factory.h b/src/factories/digi/SiliconPulseGeneration_factory.h index b6fc153bd4..e1cf88ffe9 100644 --- a/src/factories/digi/SiliconPulseGeneration_factory.h +++ b/src/factories/digi/SiliconPulseGeneration_factory.h @@ -4,10 +4,9 @@ #pragma once -#include "extensions/jana/JOmniFactory.h" - #include "algorithms/digi/SiliconPulseGeneration.h" -#include +#include "services/algorithms_init/AlgorithmsInit_service.h" +#include "extensions/jana/JOmniFactory.h" namespace eicrecon { @@ -39,7 +38,7 @@ class SiliconPulseGeneration_factory public: void Configure() { - m_algo = std::make_unique(GetPrefix()); + m_algo = std::make_unique(GetPrefix()); m_algo->level(static_cast(logger()->level())); m_algo->applyConfig(config()); m_algo->init(); diff --git a/src/services/io/podio/JEventProcessorPODIO.cc b/src/services/io/podio/JEventProcessorPODIO.cc index 9a56b0fded..782bacb49c 100644 --- a/src/services/io/podio/JEventProcessorPODIO.cc +++ b/src/services/io/podio/JEventProcessorPODIO.cc @@ -132,6 +132,7 @@ JEventProcessorPODIO::JEventProcessorPODIO() { // LOWQ2 hits "TaggerTrackerHits", + "TaggerTrackerSharedHits", "TaggerTrackerHitPulses", "TaggerTrackerCombinedPulses", "TaggerTrackerCombinedPulsesWithNoise",