diff --git a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py
index 9ae29387ee5dfa707ebcd12ae06c85f1fa6bd1dc..576539c552e8d95af18d0ade1f1fb2774639f6e4 100644
--- a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py
+++ b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py
@@ -158,5 +158,5 @@ def ITkPixelOfflineCalibCondAlgCfg(flags, name="ITkPixelOfflineCalibCondAlg", **
kwargs.setdefault("ReadKey", "/PIXEL/ITkClusterError")
kwargs.setdefault("WriteKey", "ITkPixelOfflineCalibData")
kwargs.setdefault("InputSource", 2)
- acc.addCondAlgo(CompFactory.ITkPixelOfflineCalibCondAlg(name, **kwargs))
+ acc.addCondAlgo(CompFactory.ITk.PixelOfflineCalibCondAlg(name, **kwargs))
return acc
diff --git a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.cxx b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.cxx
index 9343027bd528e6dca30ce7ae787ba81a42eb18b4..ca4b89cb48081109027a5e115cb4c4c1aa08ea6a 100644
--- a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.cxx
+++ b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.cxx
@@ -10,13 +10,16 @@
#include <memory>
#include <sstream>
-ITkPixelOfflineCalibCondAlg::ITkPixelOfflineCalibCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+namespace ITk
+{
+
+PixelOfflineCalibCondAlg::PixelOfflineCalibCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
::AthReentrantAlgorithm(name, pSvcLocator)
{
}
-StatusCode ITkPixelOfflineCalibCondAlg::initialize() {
+StatusCode PixelOfflineCalibCondAlg::initialize() {
ATH_MSG_DEBUG("ITkPixelOfflineCalibCondAlg::initialize()");
ATH_CHECK(m_condSvc.retrieve());
@@ -41,17 +44,17 @@ StatusCode ITkPixelOfflineCalibCondAlg::initialize() {
-StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
+StatusCode PixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
ATH_MSG_DEBUG("ITkPixelOfflineCalibCondAlg::execute()");
- SG::WriteCondHandle<ITkPixelCalib::ITkPixelOfflineCalibData> writeHandle(m_writeKey, ctx);
+ SG::WriteCondHandle<PixelOfflineCalibData> writeHandle(m_writeKey, ctx);
if (writeHandle.isValid()) {
ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid.. In theory this should not be called, but may happen if multiple concurrent events are being processed out of order.");
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
}
// Construct the output Cond Object and fill it in
- std::unique_ptr<ITkPixelCalib::ITkPixelOfflineCalibData> writeCdo(std::make_unique<ITkPixelCalib::ITkPixelOfflineCalibData>());
+ std::unique_ptr<PixelOfflineCalibData> writeCdo(std::make_unique<PixelOfflineCalibData>());
if (m_inputSource==0) {
ATH_MSG_WARNING("So far do nothing!! return StatusCode::FAILURE");
@@ -60,9 +63,8 @@ StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
else if (m_inputSource==1) {
ATH_MSG_WARNING("Pixel ITk constants read from text file. Only supported for local developments and debugging!");
- ITkPixelCalib::ITkPixelOfflineCalibData* calibData = new ITkPixelCalib::ITkPixelOfflineCalibData;
-
- ITkPixelCalib::ITkPixelClusterErrorData* pced = calibData->getITkPixelClusterErrorData();
+ auto calibData = std::make_unique<PixelOfflineCalibData>();
+ PixelClusterErrorData* pced = calibData->getClusterErrorData();
// Find and open the text file
ATH_MSG_INFO("Load ITkPixelErrorData constants from text file");
@@ -73,7 +75,7 @@ StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
ATH_MSG_DEBUG("Get error constants");
std::vector<float> constants = calibData->getConstants();
if (!constants.empty()) { ATH_MSG_VERBOSE("constants are defined"); }
- else { ATH_MSG_ERROR("constants size is NULL!!!"); }
+ else { ATH_MSG_ERROR("constants size is NULL!!!"); }
const EventIDBase start{EventIDBase::UNDEFNUM, EventIDBase::UNDEFEVT, 0, 0, EventIDBase::UNDEFNUM, EventIDBase::UNDEFNUM};
@@ -81,7 +83,7 @@ StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
const EventIDRange rangeW{start, stop};
ATH_MSG_DEBUG("Range of input is " << rangeW);
-
+
if (!constants.empty()) {
ATH_MSG_DEBUG("Found constants with new-style Identifier key");
writeCdo->setConstants(constants);
@@ -97,8 +99,6 @@ StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
ATH_MSG_DEBUG("Dump the constants to file");
calibData->dump();
}
- delete calibData;
-
}
else if (m_inputSource==2) {
@@ -208,3 +208,5 @@ StatusCode ITkPixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
return StatusCode::SUCCESS;
}
+
+} // namespace ITk
diff --git a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.h b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.h
index 9eba9ae26ed9272a65e1ac82c2c2c850d571850a..7c40c5ad140680e860359494bafcaf44e23b0d48 100644
--- a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.h
+++ b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/ITkPixelOfflineCalibCondAlg.h
@@ -1,6 +1,6 @@
/*
Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
+*/
#ifndef ITKPIXELOFFLINECALIBCONDALG
#define ITKPIXELOFFLINECALIBCONDALG
@@ -19,10 +19,14 @@
#include "StoreGate/StoreGateSvc.h"
#include "InDetIdentifier/PixelID.h"
-class ITkPixelOfflineCalibCondAlg : public AthReentrantAlgorithm {
+namespace ITk
+{
+
+class PixelOfflineCalibCondAlg : public AthReentrantAlgorithm
+{
public:
- ITkPixelOfflineCalibCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
- virtual ~ITkPixelOfflineCalibCondAlg() = default;
+ PixelOfflineCalibCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~PixelOfflineCalibCondAlg() = default;
virtual StatusCode initialize() override;
virtual StatusCode execute(const EventContext& ctx) const override;
@@ -30,9 +34,9 @@ class ITkPixelOfflineCalibCondAlg : public AthReentrantAlgorithm {
private:
Gaudi::Property<int> m_inputSource
{this, "InputSource",2,"Source of data: 0 (none), 1 (text file), 2 (database)"};
-
+
Gaudi::Property<std::string> m_textFileName
- {this, "ITkPixelClusterErrorDataFile", "ITkPixelClusterErrorData.txt","Read constants from this file"};
+ {this, "DataFile", "ITkPixelClusterErrorData.txt","Read constants from this file"};
Gaudi::Property<int> m_dump
{this, "DumpConstants", 0, "Dump constants to text file"};
@@ -40,7 +44,7 @@ class ITkPixelOfflineCalibCondAlg : public AthReentrantAlgorithm {
SG::ReadCondHandleKey<CondAttrListCollection> m_readKey
{this, "ReadKey", "/PIXEL/ITkClusterError", "Input key of pixreco conditions folder"};
- SG::WriteCondHandleKey<ITkPixelCalib::ITkPixelOfflineCalibData> m_writeKey
+ SG::WriteCondHandleKey<ITk::PixelOfflineCalibData> m_writeKey
{this, "WriteKey", "ITkPixelOfflineCalibData", "Output key of pixel module data"};
ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
@@ -50,5 +54,6 @@ class ITkPixelOfflineCalibCondAlg : public AthReentrantAlgorithm {
};
+} // namespace ITk
#endif
diff --git a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/components/PixelConditionsAlgorithms_entries.cxx b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/components/PixelConditionsAlgorithms_entries.cxx
index 6d31a38c53709df973e0c3cd1875d0efd1d62289..a9eb168f9d78dc33ad68b52542afd0259a78d1fe 100644
--- a/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/components/PixelConditionsAlgorithms_entries.cxx
+++ b/InnerDetector/InDetConditions/PixelConditionsAlgorithms/src/components/PixelConditionsAlgorithms_entries.cxx
@@ -38,4 +38,4 @@ DECLARE_COMPONENT( PixelAlignCondAlg )
DECLARE_COMPONENT( PixelDetectorElementCondAlg )
DECLARE_COMPONENT( PixeldEdxAlg )
DECLARE_COMPONENT( PixelRadSimFluenceMapAlg )
-DECLARE_COMPONENT( ITkPixelOfflineCalibCondAlg )
+DECLARE_COMPONENT( ITk::PixelOfflineCalibCondAlg )
diff --git a/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelClusterErrorData.h b/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelClusterErrorData.h
index abe1cf4682edd7bc990cf439ba613ce313671262..47ea98b38f36957957036940017f1779e5a5fb1a 100644
--- a/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelClusterErrorData.h
+++ b/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelClusterErrorData.h
@@ -14,15 +14,17 @@
#include <string>
#include <vector>
-namespace ITkPixelCalib {
+namespace ITk
+{
-class ITkPixelClusterErrorData {
+class PixelClusterErrorData
+{
- public:
- ITkPixelClusterErrorData(){ Initialize(); }
- ~ITkPixelClusterErrorData(){};
+ public:
+ PixelClusterErrorData() { Initialize(); }
+ ~PixelClusterErrorData() {};
- /** Methods to access the calibration data */
+ /** Methods to access the calibration data */
std::pair<double,double> getDelta(const Identifier* pixelId,
int sizePhi, double angle,
@@ -34,12 +36,12 @@ class ITkPixelClusterErrorData {
double period_phi, double period_sinheta,
double delta_x_slope, double delta_x_offset, double error_x,
double delta_y_slope, double delta_y_offset, double error_y );
-
+
void print(const std::string& file) const;
void load(const std::string& file);
- private:
+ private:
void Initialize();
// map to store all ITk Analogue Clustering constants and errors
@@ -48,9 +50,9 @@ class ITkPixelClusterErrorData {
StoreGateSvc* m_detStore{nullptr};
const PixelID* m_pixelID{nullptr};
-};
+};
-}
+} // namespace ITk
#endif
diff --git a/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelOfflineCalibData.h b/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelOfflineCalibData.h
index 292a094973cc9484c5f46ac6f3f39844a9d04f8f..bbb85703a8da2ab6bcc261680f42558d11b19f59 100644
--- a/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelOfflineCalibData.h
+++ b/InnerDetector/InDetConditions/PixelConditionsData/PixelConditionsData/ITkPixelOfflineCalibData.h
@@ -10,90 +10,76 @@
#define ITKPIXELOFFLINECALIBDATA_H
#include "AthenaKernel/CLASS_DEF.h"
-
-#include "PixelConditionsData/ITkPixelClusterErrorData.h"
-
#include "AthenaKernel/CondCont.h"
+#include "PixelConditionsData/ITkPixelClusterErrorData.h"
+#include <memory>
-/** @class ITkPixelOfflineCalibData
+/** @class ITk::PixelOfflineCalibData
- The ITkPixelOfflineCalibData is a class that designed to hold the
+ The ITk::PixelOfflineCalibData is a class that designed to hold the
data used by ITk pixel offline algorithms.
-*/
-
-namespace ITkPixelCalib {
+*/
-class ITkPixelOfflineCalibData{
+namespace ITk
+{
- public:
+class PixelOfflineCalibData
+{
+public:
/** Constructor:*/
- ITkPixelOfflineCalibData();
- ITkPixelOfflineCalibData(const ITkPixelOfflineCalibData& rhs);
- ITkPixelOfflineCalibData& operator=(const ITkPixelOfflineCalibData& rhs);
+ PixelOfflineCalibData()
+ : m_clusterErrorData(std::make_unique<PixelClusterErrorData>()) {}
+ PixelOfflineCalibData(const PixelOfflineCalibData& rhs);
+ PixelOfflineCalibData& operator=(const PixelOfflineCalibData& rhs);
/** default destructor */
- ~ITkPixelOfflineCalibData ();
+ ~PixelOfflineCalibData () = default;
- bool update(const ITkPixelClusterErrorData& idat);
+ bool update(const PixelClusterErrorData& idat);
// get the pointer to pixel cluster error data
- ITkPixelClusterErrorData* getITkPixelClusterErrorData();
- const ITkPixelClusterErrorData* getITkPixelClusterErrorData() const;
+ PixelClusterErrorData *getClusterErrorData();
+ const PixelClusterErrorData *getClusterErrorData() const;
std::vector<float> getConstants() const;
void setConstants(const std::vector<float> &constants);
void dump();
- private:
- ITkPixelClusterErrorData* m_clustererrordata;
-
-
+private:
+ std::unique_ptr<PixelClusterErrorData> m_clusterErrorData{};
};
-inline ITkPixelOfflineCalibData::ITkPixelOfflineCalibData() {
- m_clustererrordata = new ITkPixelClusterErrorData();
-}
-
-inline ITkPixelOfflineCalibData::ITkPixelOfflineCalibData(const ITkPixelOfflineCalibData& rhs){
- m_clustererrordata = rhs.m_clustererrordata;
+inline PixelOfflineCalibData::PixelOfflineCalibData(const PixelOfflineCalibData& rhs) {
+ m_clusterErrorData.reset(new PixelClusterErrorData(*rhs.m_clusterErrorData));
}
-inline ITkPixelOfflineCalibData& ITkPixelOfflineCalibData::operator=(const ITkPixelOfflineCalibData& rhs){
- if(this != &rhs){
- m_clustererrordata = rhs.m_clustererrordata;
+inline PixelOfflineCalibData& PixelOfflineCalibData::operator=(const PixelOfflineCalibData& rhs) {
+ if (this != &rhs) {
+ m_clusterErrorData.reset(new PixelClusterErrorData(*rhs.m_clusterErrorData));
}
return (*this);
}
-
-inline bool ITkPixelOfflineCalibData::update(const ITkPixelClusterErrorData& idat){
- *m_clustererrordata = idat;
- return true;
-}
-
-inline ITkPixelClusterErrorData* ITkPixelOfflineCalibData::getITkPixelClusterErrorData() {
- return m_clustererrordata;
-}
-inline const ITkPixelClusterErrorData* ITkPixelOfflineCalibData::getITkPixelClusterErrorData() const {
- return m_clustererrordata;
+inline bool PixelOfflineCalibData::update(const PixelClusterErrorData& idat) {
+ *m_clusterErrorData = idat;
+ return true;
}
-
-
-inline ITkPixelOfflineCalibData::~ITkPixelOfflineCalibData(){
- m_clustererrordata = nullptr; //Needed to avoid segfault when destructor is called
- delete m_clustererrordata;
+inline PixelClusterErrorData* PixelOfflineCalibData::getClusterErrorData() {
+ return m_clusterErrorData.get();
}
+inline const PixelClusterErrorData* PixelOfflineCalibData::getClusterErrorData() const {
+ return m_clusterErrorData.get();
}
+} // namespace ITk
-CLASS_DEF( ITkPixelCalib::ITkPixelOfflineCalibData , 222566141 , 1 )
-CLASS_DEF( CondCont<ITkPixelCalib::ITkPixelOfflineCalibData> , 115484743 , 1 )
-
-#endif
+CLASS_DEF( ITk::PixelOfflineCalibData , 114268426 , 1 )
+CLASS_DEF( CondCont<ITk::PixelOfflineCalibData> , 183220670 , 1 )
+#endif
diff --git a/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelClusterErrorData.cxx b/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelClusterErrorData.cxx
index ce65e6c698fc0f155211270cd8fe81cf1d8f4e6d..9a6de409d4297a0bae9bc45a8ba0298ac97ca238 100644
--- a/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelClusterErrorData.cxx
+++ b/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelClusterErrorData.cxx
@@ -13,9 +13,11 @@
#include <stdexcept>
-namespace ITkPixelCalib{
+namespace ITk
+{
-void ITkPixelClusterErrorData::Initialize(){
+void PixelClusterErrorData::Initialize()
+{
ISvcLocator* svcLoc = Gaudi::svcLocator();
StatusCode sc = svcLoc->service("DetectorStore", m_detStore);
@@ -30,9 +32,10 @@ void ITkPixelClusterErrorData::Initialize(){
}
-std::pair<double,double> ITkPixelClusterErrorData::getDelta(const Identifier* pixelId,
- int sizePhi, double angle,
- int sizeZ, double eta) const{
+std::pair<double,double> PixelClusterErrorData::getDelta(const Identifier* pixelId,
+ int sizePhi, double angle,
+ int sizeZ, double eta) const
+{
std::vector<double> value = m_constmap.at(*pixelId);
double period_phi = value[0];
@@ -50,7 +53,8 @@ std::pair<double,double> ITkPixelClusterErrorData::getDelta(const Identifier* pi
}
-std::pair<double,double> ITkPixelClusterErrorData::getDeltaError(const Identifier* pixelId) const{
+std::pair<double,double> PixelClusterErrorData::getDeltaError(const Identifier* pixelId) const
+{
std::vector<double> value = m_constmap.at(*pixelId);
@@ -64,10 +68,11 @@ std::pair<double,double> ITkPixelClusterErrorData::getDeltaError(const Identifie
// SET METHODS
-void ITkPixelClusterErrorData::setDeltaError(const Identifier* pixelId,
+void PixelClusterErrorData::setDeltaError(const Identifier* pixelId,
double period_phi, double period_sinheta,
double delta_x_slope, double delta_x_offset, double error_x,
- double delta_y_slope, double delta_y_offset, double error_y){
+ double delta_y_slope, double delta_y_offset, double error_y)
+{
std::vector<double> linevalues = {period_phi, period_sinheta,
delta_x_slope, delta_x_offset, error_x,
@@ -80,30 +85,30 @@ void ITkPixelClusterErrorData::setDeltaError(const Identifier* pixelId,
// save all constants to file
-void ITkPixelClusterErrorData::print(const std::string& file) const {
+void PixelClusterErrorData::print(const std::string& file) const
+{
- std::ofstream* outfile = new std::ofstream(file.c_str());
+ std::ofstream outfile(file.c_str());
for(const auto & x : m_constmap){
std::vector<double> value = x.second;
- *outfile << m_pixelID->wafer_hash(x.first) << " " << value[0] << " " << value[1] << " " << value[2] << " " << value[3] << " " << value[4] << " " << value[5] << " " << value[6] << " " << value[7] << std::endl;
+ outfile << m_pixelID->wafer_hash(x.first) << " " << value[0] << " " << value[1] << " " << value[2] << " " << value[3] << " " << value[4] << " " << value[5] << " " << value[6] << " " << value[7] << std::endl;
}
- outfile->close();
- delete outfile;
+ outfile.close();
}
// Load ITk constants from file
-void ITkPixelClusterErrorData::load(const std::string& file){
+void PixelClusterErrorData::load(const std::string& file){
std::ifstream infile( file.c_str() );
-
+
if(infile.is_open()){
-
+
//
// Data in the file is stored in the following columns:
// waferID_hash : period_phi : period_sinheta : delta_x_slope : delta_x_offset : delta_error_x : delta_y_slope : delta_y_offset : delta_error_y
@@ -117,12 +122,12 @@ void ITkPixelClusterErrorData::load(const std::string& file){
double delta_error_x;
double delta_y_slope;
double delta_y_offset;
- double delta_error_y;
+ double delta_error_y;
while(!infile.eof()){
infile >> waferID_hash_int >> period_phi >> period_sinheta >> delta_x_slope >> delta_x_offset >> delta_error_x >> delta_y_slope >> delta_y_offset >> delta_error_y;
-
+
IdentifierHash waferID_hash(waferID_hash_int);
Identifier pixelId = m_pixelID->wafer_id(waferID_hash);
setDeltaError(&pixelId,
@@ -131,17 +136,13 @@ void ITkPixelClusterErrorData::load(const std::string& file){
delta_y_slope, delta_y_offset, delta_error_y);
}
-
+
infile.close();
-
- }else{
+
+ } else {
throw std::runtime_error("ITkAnalogueClusteringConstantsFile \"" + file + "\" can not be read. Unable to proceed.");
}
-
-}
-
}
-
-
+} // namespace ITk
diff --git a/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelOfflineCalibData.cxx b/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelOfflineCalibData.cxx
index 5f88ee6e62c603d48f1e9065bc3090bcfd0e0580..32b23c05dbd2d0ca7360ba198420e73c67508955 100644
--- a/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelOfflineCalibData.cxx
+++ b/InnerDetector/InDetConditions/PixelConditionsData/src/ITkPixelOfflineCalibData.cxx
@@ -11,12 +11,12 @@
#include <sstream>
+namespace ITk
+{
-namespace ITkPixelCalib{
+ std::vector<float> PixelOfflineCalibData::getConstants() const {
- std::vector<float> ITkPixelOfflineCalibData::getConstants() const {
-
- std::map< const Identifier, std::vector<double> > constMap = m_clustererrordata->getConstMap();
+ std::map< const Identifier, std::vector<double> > constMap = m_clusterErrorData->getConstMap();
int entry_size = 9; // pixel Id + period_phi + period_sinheta + delta_x_slope + delta_x_offset + delta_err_x + delta_y_slope + delta_y_offset + delta_err_y
int data_size = entry_size*constMap.size();
@@ -38,12 +38,12 @@ namespace ITkPixelCalib{
}
- void ITkPixelOfflineCalibData::dump(){
- m_clustererrordata->print("ITkPixelClusterDump.txt");
+ void PixelOfflineCalibData::dump() {
+ m_clusterErrorData->print("ITkPixelClusterDump.txt");
}
- void ITkPixelOfflineCalibData::setConstants(const std::vector<float> &constants){
+ void PixelOfflineCalibData::setConstants(const std::vector<float> &constants) {
int entry_size = 9;
int map_size = constants.size()/entry_size;
@@ -65,17 +65,12 @@ namespace ITkPixelCalib{
double delta_y_slope = constants[i*entry_size + 6];
double delta_y_offset = constants[i*entry_size + 7];
double delta_err_y = constants[i*entry_size + 8];
-
- m_clustererrordata->setDeltaError(&pixelId, period_phi, period_sinheta,
+
+ m_clusterErrorData->setDeltaError(&pixelId, period_phi, period_sinheta,
delta_x_slope, delta_x_offset, delta_err_x,
delta_y_slope, delta_y_offset, delta_err_y);
}
+ }
- return;
-
- }
-
-
-
-} // end of namespace
+} // end of namespace ITk
diff --git a/InnerDetector/InDetConfig/python/ITkTrackingCommonConfig.py b/InnerDetector/InDetConfig/python/ITkTrackingCommonConfig.py
index d2429734859c40bc65906dd346af253e8bfbb9f2..8ae9b955f65462b53b864c6ab860eb171e108428 100644
--- a/InnerDetector/InDetConfig/python/ITkTrackingCommonConfig.py
+++ b/InnerDetector/InDetConfig/python/ITkTrackingCommonConfig.py
@@ -79,7 +79,7 @@ def ITkPixelClusterOnTrackToolBaseCfg(flags, name="ITkPixelClusterOnTrackTool",
kwargs.setdefault("PixelErrorScalingKey", "")
- acc.setPrivateTools(CompFactory.InDet.ITkPixelClusterOnTrackTool(the_name, **kwargs))
+ acc.setPrivateTools(CompFactory.ITk.PixelClusterOnTrackTool(the_name, **kwargs))
return acc
def ITkPixelClusterOnTrackToolDigitalCfg(flags, name='ITkPixelClusterOnTrackToolDigital', **kwargs):
diff --git a/InnerDetector/InDetConfig/python/ITkTrackingSiPatternConfig.py b/InnerDetector/InDetConfig/python/ITkTrackingSiPatternConfig.py
index 3b216c3578955b02bb0222c22cb716e409bf634a..cbd27c7715acb49ea432baad981d73c85738e95a 100644
--- a/InnerDetector/InDetConfig/python/ITkTrackingSiPatternConfig.py
+++ b/InnerDetector/InDetConfig/python/ITkTrackingSiPatternConfig.py
@@ -24,7 +24,7 @@ def ITkSiSpacePointsSeedMakerCfg(flags, name="ITkSpSeedsMaker", InputCollections
#
# --- Space points seeds maker, use different ones for cosmics and collisions
#
- SiSpacePointsSeedMaker = CompFactory.InDet.SiSpacePointsSeedMaker_ITK
+ SiSpacePointsSeedMaker = CompFactory.ITk.SiSpacePointsSeedMaker
kwargs.setdefault("pTmin", flags.ITk.Tracking.minPTSeed )
kwargs.setdefault("maxdImpact", flags.ITk.Tracking.maxPrimaryImpactSeed )
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h
similarity index 78%
rename from InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h
rename to InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h
index 28d3ec7907d4a0e2f26ba7961516b28b18be237c..0079d7003b8b3e49591765e22fc9f348b153e879 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h
@@ -5,17 +5,17 @@
*/
/////////////////////////////////////////////////////////////////////////////////
-// Header file for class SiSpacePointForSeedITK
+// Header file for class ITk::SiSpacePointForSeed
/////////////////////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
/////////////////////////////////////////////////////////////////////////////////
-// Class space points for seed maker
+// Class space points for seed maker
/////////////////////////////////////////////////////////////////////////////////
// Version 1.0 18/11/2004 I.Gavrilenko
/////////////////////////////////////////////////////////////////////////////////
-#ifndef SiSpacePointForSeedITK_h
-#define SiSpacePointForSeedITK_h
+#ifndef ITkSiSpacePointForSeed_h
+#define ITkSiSpacePointForSeed_h
#include <cmath>
@@ -26,21 +26,24 @@ namespace Trk {
namespace InDet {
class SiCluster;
+}
+
+namespace ITk
+{
+ class SiSpacePointForSeed {
- class SiSpacePointForSeedITK {
-
/////////////////////////////////////////////////////////////////////////////////
// Public methods:
/////////////////////////////////////////////////////////////////////////////////
-
+
public:
-
- SiSpacePointForSeedITK();
- SiSpacePointForSeedITK(const Trk::SpacePoint*const&,const float*);
- SiSpacePointForSeedITK(const Trk::SpacePoint*const&,const float*,const float*);
- SiSpacePointForSeedITK(const SiSpacePointForSeedITK&);
- virtual ~SiSpacePointForSeedITK() ;
- SiSpacePointForSeedITK& operator = (const SiSpacePointForSeedITK&);
+
+ SiSpacePointForSeed();
+ SiSpacePointForSeed(const Trk::SpacePoint*const&,const float*);
+ SiSpacePointForSeed(const Trk::SpacePoint*const&,const float*,const float*);
+ SiSpacePointForSeed(const SiSpacePointForSeed&);
+ virtual ~SiSpacePointForSeed() ;
+ SiSpacePointForSeed& operator = (const SiSpacePointForSeed&);
void set(const Trk::SpacePoint*const&,const float*) ;
void set(const Trk::SpacePoint*const&,const float*,const float*);
@@ -52,7 +55,7 @@ namespace InDet {
void setScorePenalty(const float&);
void setPt(const float&);
- const Trk::SpacePoint* spacepoint{} ;
+ const Trk::SpacePoint* spacepoint{} ;
const float& x() const {return m_x;}
const float& y() const {return m_y;}
const float& z() const {return m_z;}
@@ -73,8 +76,8 @@ namespace InDet {
bool coordinates(const float*,float*);
private:
-
- float m_x{} ; // x-coordinate in beam system coordinates
+
+ float m_x{} ; // x-coordinate in beam system coordinates
float m_y{} ; // y-coordinate in beam system coordinates
float m_z{} ; // z-coordinate in beam system coordinetes
float m_r{} ; // radius in beam system coordinates
@@ -97,8 +100,7 @@ namespace InDet {
const Trk::Surface* m_su{};
const Trk::Surface* m_sn{};
};
-
-} // end of name space
+} // end of name space ITk
-#endif // SiSpacePointForSeedITK_h
+#endif // ITkSiSpacePointForSeed_h
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsProSeedITK.h b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h
similarity index 54%
rename from InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsProSeedITK.h
rename to InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h
index d07b37fc916671abefbc37a78c17a238c8a07c0d..0bd79034862efc5ef860437860a813079dad29e3 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsProSeedITK.h
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h
@@ -5,7 +5,7 @@
*/
/////////////////////////////////////////////////////////////////////////////////
-// Header file for class SiSpacesProSeed
+// Header file for class ITk::SiSpacesProSeed
/////////////////////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
/////////////////////////////////////////////////////////////////////////////////
@@ -14,14 +14,18 @@
// Version 1.0 27/02/2013 I.Gavrilenko
/////////////////////////////////////////////////////////////////////////////////
-#ifndef SiSpacePointsProSeedITK_h
-#define SiSpacePointsProSeedITK_h
+#ifndef ITkSiSpacePointsProSeed_h
+#define ITkSiSpacePointsProSeed_h
namespace InDet {
- class SiSpacePointForSeedITK;
class SiSpacePointsSeed;
+}
- class SiSpacePointsProSeedITK {
+namespace ITk
+{
+ class SiSpacePointForSeed;
+
+ class SiSpacePointsProSeed {
/////////////////////////////////////////////////////////////////////////////////
// Public methods:
@@ -29,32 +33,32 @@ namespace InDet {
public:
- SiSpacePointsProSeedITK();
+ SiSpacePointsProSeed();
- SiSpacePointsProSeedITK(SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,float);
- SiSpacePointsProSeedITK(const SiSpacePointsProSeedITK&);
- virtual ~SiSpacePointsProSeedITK();
- SiSpacePointsProSeedITK& operator = (const SiSpacePointsProSeedITK&);
+ SiSpacePointsProSeed(SiSpacePointForSeed*&,SiSpacePointForSeed*&,SiSpacePointForSeed*&,float);
+ SiSpacePointsProSeed(const SiSpacePointsProSeed&);
+ virtual ~SiSpacePointsProSeed();
+ SiSpacePointsProSeed& operator = (const SiSpacePointsProSeed&);
- SiSpacePointForSeedITK* spacepoint0() {return m_s0;}
- SiSpacePointForSeedITK* spacepoint1() {return m_s1;}
- SiSpacePointForSeedITK* spacepoint2() {return m_s2;}
+ SiSpacePointForSeed* spacepoint0() {return m_s0;}
+ SiSpacePointForSeed* spacepoint1() {return m_s1;}
+ SiSpacePointForSeed* spacepoint2() {return m_s2;}
const float& z() const {return m_z ;}
const float& quality() const {return m_q ;}
- void set(SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,float);
+ void set(SiSpacePointForSeed*&,SiSpacePointForSeed*&,SiSpacePointForSeed*&,float);
bool setQuality(float);
bool set3(InDet::SiSpacePointsSeed&);
void set2(InDet::SiSpacePointsSeed&);
private:
- SiSpacePointForSeedITK* m_s0{};
- SiSpacePointForSeedITK* m_s1{};
- SiSpacePointForSeedITK* m_s2{};
- float m_z{} ;
- float m_q{} ;
+ SiSpacePointForSeed* m_s0{};
+ SiSpacePointForSeed* m_s1{};
+ SiSpacePointForSeed* m_s2{};
+ float m_z{} ;
+ float m_q{} ;
};
} // end of name space
-#endif // SiSpacePointsProSeedITK_h
+#endif // ITkSiSpacePointsProSeed_h
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h
index 80531162ea40255bd1e00df46e9734b21e6ee0c9..b0cfe4ad75da4e4b83a73717ee2610ee93debea3 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h
@@ -13,9 +13,9 @@
#include "SiSpacePointsSeed/SiSpacePointsSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointForSeed.h"
-#include "SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointsProSeed.h"
-#include "SiSPSeededTrackFinderData/SiSpacePointsProSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h"
#include <list>
#include <map>
@@ -42,12 +42,12 @@ namespace InDet {
class SiSpacePointsSeedMakerEventData {
public:
/// enums to specify which SiSpacePointsSeedMaker owns the object.
- enum ToolType {
+ enum class ToolType {
ATLxk, ///< SiSpacePointsSeedMaker_ATLxk
BeamGas, ///< SiSpacePointsSeedMaker_BeamGas
Cosmic, ///< SiSpacePointsSeedMaker_Cosmic
HeavyIon, ///< SiSpacePointsSeedMaker_HeavyIon
- ITK, ///< SiSpacePointsSeedMaker_ITK
+ ITk, ///< ITk::SiSpacePointsSeedMaker
LowMomentum, ///< SiSpacePointsSeedMaker_LowMomentum
Trigger ////< SiSpacePointsSeedMaker_Trigger
};
@@ -133,7 +133,7 @@ namespace InDet {
*/
//@{
std::vector<InDet::SiSpacePointForSeed*> SP; ///< space points to consider for the current seed candidate
- std::vector<InDet::SiSpacePointForSeedITK*> SP_ITK;
+ std::vector<ITk::SiSpacePointForSeed*> ITkSP;
/// The following are parameters characterising individual space points within a seed (relative to the central point)
std::vector<float> Zo; ///< z0 estimate from 2 points
@@ -151,25 +151,25 @@ namespace InDet {
std::vector<InDet::SiSpacePointsSeed> OneSeeds;
std::vector<InDet::SiSpacePointsProSeed> OneSeeds_Pro;
- std::vector<InDet::SiSpacePointsProSeedITK> OneSeeds_ITK;
+ std::vector<ITk::SiSpacePointsProSeed> ITkOneSeeds;
std::vector<std::pair<float,InDet::SiSpacePointForSeed*>> CmSp;
- std::vector<std::pair<float,InDet::SiSpacePointForSeedITK*>> CmSp_ITK;
+ std::vector<std::pair<float,ITk::SiSpacePointForSeed*>> ITkCmSp;
std::vector<std::vector<InDet::SiSpacePointForSeed*>> r_Sorted; ///< vector of space points in each bin of the 1D radial binning
std::vector<std::vector<InDet::SiSpacePointForSeed*>> rf_Sorted;
std::vector<std::vector<InDet::SiSpacePointForSeed*>> rfz_Sorted; ///< vector of space points in each bin of the 2D phi-z binning
std::vector<std::vector<InDet::SiSpacePointForSeed*>> rfzv_Sorted;
- std::vector<std::list<InDet::SiSpacePointForSeedITK*>> r_Sorted_ITK;
- std::vector<std::list<InDet::SiSpacePointForSeedITK*>> rfz_Sorted_ITK;
- std::vector<std::list<InDet::SiSpacePointForSeedITK*>> rfzv_Sorted_ITK;
+ std::vector<std::list<ITk::SiSpacePointForSeed*>> r_ITkSorted;
+ std::vector<std::list<ITk::SiSpacePointForSeed*>> rfz_ITkSorted;
+ std::vector<std::list<ITk::SiSpacePointForSeed*>> rfzv_ITkSorted;
std::vector<InDet::SiSpacePointsSeed> seeds;
std::list<InDet::SiSpacePointForSeed> l_spforseed; //<! list of all space points considered for seed building. This has ownership over the pointers stored in the binned vectors ("histograms") above
std::list<InDet::SiSpacePointForSeed>::iterator i_spforseed; //<! keep track of an iterator over the seed list. Frequently used to keep track of where to add the next SP
- std::list<InDet::SiSpacePointForSeedITK> l_spforseed_ITK;
- std::list<InDet::SiSpacePointForSeedITK>::iterator i_spforseed_ITK;
+ std::list<ITk::SiSpacePointForSeed> l_ITkSpacePointForSeed;
+ std::list<ITk::SiSpacePointForSeed>::iterator i_ITkSpacePointForSeed;
std::list<InDet::SiSpacePointsSeed> l_seeds;
std::list<InDet::SiSpacePointsSeed>::iterator i_seed;
@@ -177,12 +177,12 @@ namespace InDet {
std::list<InDet::SiSpacePointsProSeed> l_seeds_Pro; //<! lists of output seeds
std::list<InDet::SiSpacePointsProSeed>::iterator i_seed_Pro; //<! iterators over the said list
std::list<InDet::SiSpacePointsProSeed>::iterator i_seede_Pro;
- std::list<InDet::SiSpacePointsProSeedITK> l_seeds_ITK;
- std::list<InDet::SiSpacePointsProSeedITK>::iterator i_seed_ITK;
- std::list<InDet::SiSpacePointsProSeedITK>::iterator i_seede_ITK;
+ std::list<ITk::SiSpacePointsProSeed> i_ITkSeeds;
+ std::list<ITk::SiSpacePointsProSeed>::iterator i_ITkSeed;
+ std::list<ITk::SiSpacePointsProSeed>::iterator i_ITkSeedEnd;
std::vector<InDet::SiSpacePointForSeed*>::iterator rMin;
- std::list<InDet::SiSpacePointForSeedITK*>::iterator rMin_ITK;
+ std::list<ITk::SiSpacePointForSeed*>::iterator ITk_rMin;
std::multimap<float,InDet::SiSpacePointsSeed*> mapOneSeeds;
std::multimap<float,InDet::SiSpacePointsSeed*> mapSeeds;
@@ -194,9 +194,9 @@ namespace InDet {
std::multimap<float,InDet::SiSpacePointsProSeed*> mapOneSeeds_Pro;
std::multimap<float,InDet::SiSpacePointsProSeed*> seeds_Pro;
std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator seed_Pro;
- std::multimap<float,InDet::SiSpacePointsProSeedITK*> mapOneSeeds_ITK;
- std::multimap<float,InDet::SiSpacePointsProSeedITK*> seeds_ITK;
- std::multimap<float,InDet::SiSpacePointsProSeedITK*>::iterator seed_ITK;
+ std::multimap<float,ITk::SiSpacePointsProSeed*> ITkMapOneSeeds;
+ std::multimap<float,ITk::SiSpacePointsProSeed*> ITkSeeds;
+ std::multimap<float,ITk::SiSpacePointsProSeed*>::iterator ITkSeedIterator;
/// allow to resize the space-point container on-the-fly in case
@@ -206,8 +206,8 @@ namespace InDet {
void resizeSPCont(size_t increment=50, ToolType type = ToolType::ATLxk){
size_t currSize = SP.size();
size_t newSize = currSize + increment;
- if (type == ITK) {
- SP_ITK.resize(newSize, nullptr);
+ if (type == ToolType::ITk) {
+ ITkSP.resize(newSize, nullptr);
X.resize(newSize, 0.);
Y.resize(newSize, 0.);
Tn.resize(newSize);
@@ -219,7 +219,7 @@ namespace InDet {
Er.resize(newSize, 0.);
U.resize(newSize, 0.);
V.resize(newSize, 0.);
- if (type != Cosmic) {
+ if (type != ToolType::Cosmic) {
Zo.resize(newSize, 0.);
}
}
@@ -235,31 +235,31 @@ namespace InDet {
int sizeRFZ,
int sizeRFZV,
bool checkEta) {
- if (type==ATLxk) {
+ if (type==ToolType::ATLxk) {
CmSp.reserve(500);
- } else if (type==ITK) {
- CmSp_ITK.reserve(500);
+ } else if (type==ToolType::ITk) {
+ ITkCmSp.reserve(500);
}
resizeSPCont(maxsizeSP,type);
seedPerSpCapacity = maxOneSize;
- if (type==ATLxk) {
+ if (type==ToolType::ATLxk) {
OneSeeds_Pro.resize(maxOneSize);
- } else if (type==BeamGas or type==HeavyIon or type==LowMomentum or type==Trigger) {
+ } else if (type==ToolType::BeamGas or type==ToolType::HeavyIon or type==ToolType::LowMomentum or type==ToolType::Trigger) {
OneSeeds.resize(maxOneSize);
- } else if (type==ITK) {
- OneSeeds_ITK.resize(maxOneSize);
+ } else if (type==ToolType::ITk) {
+ ITkOneSeeds.resize(maxOneSize);
}
// Build radius sorted containers
r_index.resize(sizeR, 0);
r_map.resize(sizeR, 0);
- if (type==ITK) {
- r_Sorted_ITK.resize(sizeR);
+ if (type==ToolType::ITk) {
+ r_ITkSorted.resize(sizeR);
} else {
r_Sorted.resize(sizeR);
}
- if (type==BeamGas or type==Cosmic) {
+ if (type==ToolType::BeamGas or type==ToolType::Cosmic) {
// Build radius-azimuthal sorted containers
rf_index.resize(sizeRF, 0);
rf_map.resize(sizeRF, 0);
@@ -269,44 +269,44 @@ namespace InDet {
// Build radius-azimuthal-Z sorted containers
rfz_index.resize(sizeRFZ, 0);
rfz_map.resize(sizeRFZ, 0);
- if (type==ITK) {
- rfz_Sorted_ITK.resize(sizeRFZ, {});
+ if (type==ToolType::ITk) {
+ rfz_ITkSorted.resize(sizeRFZ, {});
} else {
rfz_Sorted.resize(sizeRFZ, {});
}
- if (type==ATLxk or type==HeavyIon or type==ITK or type==Trigger) {
+ if (type==ToolType::ATLxk or type==ToolType::HeavyIon or type==ToolType::ITk or type==ToolType::Trigger) {
// Build radius-azimuthal-Z sorted containers for Z-vertices
rfzv_index.resize(sizeRFZV, 0);
rfzv_map.resize(sizeRFZV, 0);
- if (type==ITK) {
- rfzv_Sorted_ITK.resize(sizeRFZV, {});
+ if (type==ToolType::ITk) {
+ rfzv_ITkSorted.resize(sizeRFZV, {});
} else {
rfzv_Sorted.resize(sizeRFZV, {});
}
}
- if (type==Cosmic) {
+ if (type==ToolType::Cosmic) {
seeds.resize(maxsize+5);
}
- if (type==ATLxk) {
+ if (type==ToolType::ATLxk) {
i_seed_Pro = l_seeds_Pro.begin();
i_seede_Pro = l_seeds_Pro.end();
- } else if (type==BeamGas or type==HeavyIon or type==LowMomentum or type==Trigger) {
+ } else if (type==ToolType::BeamGas or type==ToolType::HeavyIon or type==ToolType::LowMomentum or type==ToolType::Trigger) {
i_seed = l_seeds.begin();
i_seede = l_seeds.end();
- } else if (type==ITK) {
- i_seed_ITK = l_seeds_ITK.begin();
- i_seede_ITK = l_seeds_ITK.end();
+ } else if (type==ToolType::ITk) {
+ i_ITkSeed = i_ITkSeeds.begin();
+ i_ITkSeedEnd = i_ITkSeeds.end();
}
- if (type==Trigger) {
+ if (type==ToolType::Trigger) {
seed = mapSeeds.begin();
seede = mapSeeds.end();
}
- if (type==ATLxk or type==ITK) {
+ if (type==ToolType::ATLxk or type==ToolType::ITk) {
checketa = checkEta;
}
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointForSeedITK.cxx b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointForSeed.cxx
similarity index 85%
rename from InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointForSeedITK.cxx
rename to InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointForSeed.cxx
index f3501a90bada0861b1655553de74664a4bfaddd0..87240d12cd5edc28891754cd698eb2fb17a96f26 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointForSeedITK.cxx
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointForSeed.cxx
@@ -1,21 +1,22 @@
/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
#include <cmath>
-#include "SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
#include "InDetPrepRawData/SiCluster.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "TrkSpacePoint/SpacePoint.h"
#include "TrkSurfaces/Surface.h"
-namespace InDet {
+namespace ITk
+{
- SiSpacePointForSeedITK::SiSpacePointForSeedITK ()
+ SiSpacePointForSeed::SiSpacePointForSeed ()
{
spacepoint = nullptr;
m_x = 0.;
@@ -36,8 +37,8 @@ namespace InDet {
for(int i=0; i!=3; ++i) {m_b0[i]=0.; m_b1[i]=0.; m_dr[i]=0.; m_r0[i]=0.;}
}
- SiSpacePointForSeedITK& SiSpacePointForSeedITK::operator =
- (const SiSpacePointForSeedITK& sp)
+ SiSpacePointForSeed& SiSpacePointForSeed::operator =
+ (const SiSpacePointForSeed& sp)
{
if(&sp!=this) {
spacepoint = sp.spacepoint ;
@@ -63,13 +64,13 @@ namespace InDet {
return(*this);
}
- SiSpacePointForSeedITK::SiSpacePointForSeedITK
+ SiSpacePointForSeed::SiSpacePointForSeed
(const Trk::SpacePoint*const& sp,const float* r)
{
set(sp,r); m_param = 0.;
}
- SiSpacePointForSeedITK::SiSpacePointForSeedITK
+ SiSpacePointForSeed::SiSpacePointForSeed
(const Trk::SpacePoint*const& sp,const float* r,const float* sc)
{
set(sp,r,sc); m_param = 0.;
@@ -79,7 +80,7 @@ namespace InDet {
// Copy constructor
/////////////////////////////////////////////////////////////////////////////////
- SiSpacePointForSeedITK::SiSpacePointForSeedITK (const SiSpacePointForSeedITK& sp)
+ SiSpacePointForSeed::SiSpacePointForSeed (const SiSpacePointForSeed& sp)
{
*this = sp;
}
@@ -88,7 +89,7 @@ namespace InDet {
// Destructor
/////////////////////////////////////////////////////////////////////////////////
- SiSpacePointForSeedITK::~SiSpacePointForSeedITK()
+ SiSpacePointForSeed::~SiSpacePointForSeed()
{
}
@@ -96,7 +97,7 @@ namespace InDet {
// Set
/////////////////////////////////////////////////////////////////////////////////
- void SiSpacePointForSeedITK::set
+ void SiSpacePointForSeed::set
(const Trk::SpacePoint*const& sp,const float* r)
{
spacepoint = sp ;
@@ -134,27 +135,27 @@ namespace InDet {
}
- void SiSpacePointForSeedITK::setDR(const float& dr)
+ void SiSpacePointForSeed::setDR(const float& dr)
{
m_dR = dr;
}
- void SiSpacePointForSeedITK::setEta(const float& eta)
+ void SiSpacePointForSeed::setEta(const float& eta)
{
m_eta = eta;
}
- void SiSpacePointForSeedITK::setDZDR(const float& dzdr)
+ void SiSpacePointForSeed::setDZDR(const float& dzdr)
{
m_dzdr = dzdr;
}
- void SiSpacePointForSeedITK::setPt(const float& pt)
+ void SiSpacePointForSeed::setPt(const float& pt)
{
m_pt = pt;
}
- void SiSpacePointForSeedITK::setScorePenalty(const float& score)
+ void SiSpacePointForSeed::setScorePenalty(const float& score)
{
m_scorePenalty = score;
}
@@ -168,7 +169,7 @@ namespace InDet {
// sc[3] - endcap sct
/////////////////////////////////////////////////////////////////////////////////
- void SiSpacePointForSeedITK::set
+ void SiSpacePointForSeed::set
(const Trk::SpacePoint*const& sp,const float* r,const float* sc)
{
spacepoint = sp ;
@@ -204,11 +205,11 @@ namespace InDet {
m_su = &sp->clusterList().first->detectorElement()->surface();
}
- void SiSpacePointForSeedITK::setParam(const float& p)
+ void SiSpacePointForSeed::setParam(const float& p)
{
m_param = p;
}
- void SiSpacePointForSeedITK::setQuality(float q)
+ void SiSpacePointForSeed::setQuality(float q)
{
if(q <= m_q) m_q = q;
}
@@ -220,7 +221,7 @@ namespace InDet {
// true if cross point is inside detector elements
/////////////////////////////////////////////////////////////////////////////////
- bool SiSpacePointForSeedITK::coordinates(const float* d,float* r)
+ bool SiSpacePointForSeed::coordinates(const float* d,float* r)
{
float d0[3] = {m_b1[1]*d[2]-m_b1[2]*d[1],m_b1[2]*d[0]-m_b1[0]*d[2],m_b1[0]*d[1]-m_b1[1]*d[0]};
float bd0 = m_b0[0]*d0[0]+m_b0[1]*d0[1]+m_b0[2]*d0[2]; if( bd0==0. ) return false;
@@ -236,4 +237,4 @@ namespace InDet {
return true;
}
-} // end of name space
+} // end of name space ITk
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointsProSeedITK.cxx b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointsProSeed.cxx
similarity index 73%
rename from InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointsProSeedITK.cxx
rename to InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointsProSeed.cxx
index 94cf8c220cce18ea023023d1d7f0d7246502b768..44bf3de6cbba23982161edf333bca368da5ae000 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiSpacePointsProSeedITK.cxx
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/ITkSiSpacePointsProSeed.cxx
@@ -2,13 +2,15 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SiSPSeededTrackFinderData/SiSpacePointsProSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointsProSeed.h"
#include "SiSpacePointsSeed/SiSpacePointsSeed.h"
-#include "SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
-namespace InDet {
- SiSpacePointsProSeedITK::SiSpacePointsProSeedITK ()
+namespace ITk
+{
+
+ SiSpacePointsProSeed::SiSpacePointsProSeed ()
{
m_s0 = nullptr ;
m_s1 = nullptr ;
@@ -17,8 +19,8 @@ namespace InDet {
m_q = 0.;
}
- SiSpacePointsProSeedITK& SiSpacePointsProSeedITK::operator =
- (const SiSpacePointsProSeedITK& sp)
+ SiSpacePointsProSeed& SiSpacePointsProSeed::operator =
+ (const SiSpacePointsProSeed& sp)
{
if(&sp!=this) {
@@ -31,8 +33,8 @@ namespace InDet {
return(*this);
}
- SiSpacePointsProSeedITK::SiSpacePointsProSeedITK
- (SiSpacePointForSeedITK*& s0,SiSpacePointForSeedITK*& s1,SiSpacePointForSeedITK*& s2,float z)
+ SiSpacePointsProSeed::SiSpacePointsProSeed
+ (SiSpacePointForSeed*& s0,SiSpacePointForSeed*& s1,SiSpacePointForSeed*& s2,float z)
{
set(s0,s1,s2,z); m_q = 0.;
}
@@ -41,7 +43,7 @@ namespace InDet {
// Copy constructor
/////////////////////////////////////////////////////////////////////////////////
- SiSpacePointsProSeedITK::SiSpacePointsProSeedITK (const SiSpacePointsProSeedITK& sp): m_s0(sp.m_s0),m_s1(sp.m_s1),m_s2(sp.m_s2)
+ SiSpacePointsProSeed::SiSpacePointsProSeed (const SiSpacePointsProSeed& sp): m_s0(sp.m_s0),m_s1(sp.m_s1),m_s2(sp.m_s2)
{
*this = sp;
}
@@ -50,7 +52,7 @@ namespace InDet {
// Destructor
/////////////////////////////////////////////////////////////////////////////////
- SiSpacePointsProSeedITK::~SiSpacePointsProSeedITK()
+ SiSpacePointsProSeed::~SiSpacePointsProSeed()
{
}
@@ -58,8 +60,8 @@ namespace InDet {
// Set
/////////////////////////////////////////////////////////////////////////////////
- void SiSpacePointsProSeedITK::set
- (SiSpacePointForSeedITK*& s0,SiSpacePointForSeedITK*& s1,SiSpacePointForSeedITK*& s2,float z)
+ void SiSpacePointsProSeed::set
+ (SiSpacePointForSeed*& s0,SiSpacePointForSeed*& s1,SiSpacePointForSeed*& s2,float z)
{
m_z = z ;
m_s0 = s0;
@@ -71,7 +73,7 @@ namespace InDet {
// Set two space points seed
/////////////////////////////////////////////////////////////////////////////////
- void SiSpacePointsProSeedITK::set2(InDet::SiSpacePointsSeed& s)
+ void SiSpacePointsProSeed::set2(InDet::SiSpacePointsSeed& s)
{
s.erase();
s.add(m_s0->spacepoint);
@@ -83,7 +85,7 @@ namespace InDet {
// Set three space points seed
/////////////////////////////////////////////////////////////////////////////////
- bool SiSpacePointsProSeedITK::set3(InDet::SiSpacePointsSeed& s)
+ bool SiSpacePointsProSeed::set3(InDet::SiSpacePointsSeed& s)
{
bool pixb = !m_s0->spacepoint->clusterList().second;
@@ -109,7 +111,7 @@ namespace InDet {
// Set quality in pro seed
/////////////////////////////////////////////////////////////////////////////////
- bool SiSpacePointsProSeedITK::setQuality(float q)
+ bool SiSpacePointsProSeed::setQuality(float q)
{
m_q = q;
bool pixb = !m_s0->spacepoint->clusterList().second;
@@ -123,4 +125,4 @@ namespace InDet {
return q < m_s0->quality() || q < m_s1->quality() || q < m_s2->quality();
}
-} // end of name space
+} // end of name space ITk
diff --git a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/SiClusterOnTrackTool/ITkPixelClusterOnTrackTool.h b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/SiClusterOnTrackTool/ITkPixelClusterOnTrackTool.h
index 27b41ed3bee308e896e66b97b2fd9a992006203d..d2bb00073e73728af4f9bdad42a8ca1fb825c0b1 100755
--- a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/SiClusterOnTrackTool/ITkPixelClusterOnTrackTool.h
+++ b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/SiClusterOnTrackTool/ITkPixelClusterOnTrackTool.h
@@ -11,6 +11,7 @@
#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
#include "InDetRIO_OnTrack/PixelClusterOnTrack.h"
#include "InDetRIO_OnTrack/PixelRIO_OnTrackErrorScaling.h"
+#include "SiClusterizationTool/NnClusterizationFactory.h"
#include "InDetPrepRawData/PixelGangedClusterAmbiguities.h"
#include "TrkParameters/TrackParameters.h"
@@ -31,7 +32,8 @@
#include <atomic>
#include <mutex>
-namespace InDet {
+namespace ITk
+{
/** @brief creates PixelClusterOnTrack objects allowing to
calibrate cluster position and error using a given track hypothesis.
@@ -47,16 +49,14 @@ namespace InDet {
*/
- class NnClusterizationFactory;
-
- enum ITkPixelClusterStrategy {
- ITKPIXELCLUSTER_DEFAULT=0,
- ITKPIXELCLUSTER_OUTLIER=1,
- ITKPIXELCLUSTER_SHARED =2,
- ITKPIXELCLUSTER_SPLIT =3
+ enum class PixelClusterStrategy {
+ DEFAULT=0,
+ OUTLIER=1,
+ SHARED =2,
+ SPLIT =3
};
- class ITkPixelClusterOnTrackTool:
+ class PixelClusterOnTrackTool:
public AthAlgTool, virtual public Trk::IRIO_OnTrackCreator
{
///////////////////////////////////////////////////////////////////
@@ -66,13 +66,11 @@ namespace InDet {
public:
//! AlgTool constructor
- ITkPixelClusterOnTrackTool(const std::string&,const std::string&,
+ PixelClusterOnTrackTool(const std::string&,const std::string&,
const IInterface*);
- virtual ~ITkPixelClusterOnTrackTool ();
+ virtual ~PixelClusterOnTrackTool () = default;
//! AlgTool initialisation
virtual StatusCode initialize() override;
- //! AlgTool termination
- virtual StatusCode finalize () override;
/** @brief produces a PixelClusterOnTrack (object factory!).
@@ -102,7 +100,7 @@ protected:
const InDet::PixelClusterOnTrack* correct
(const Trk::PrepRawData&, const Trk::TrackParameters&,
- const InDet::ITkPixelClusterStrategy) const;
+ const ITk::PixelClusterStrategy) const;
const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &getClusterSplittingProbability(const InDet::PixelCluster*pix) const {
if (!pix || m_clusterSplitProbContainer.key().empty()) return Trk::ClusterSplitProbabilityContainer::getNoSplitProbability();
@@ -122,7 +120,7 @@ private:
ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retreive Lorentz angle"};
- SG::ReadCondHandleKey<ITkPixelCalib::ITkPixelOfflineCalibData> m_clusterITkErrorKey{this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"};
+ SG::ReadCondHandleKey<ITk::PixelOfflineCalibData> m_clusterITkErrorKey{this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"};
SG::ReadCondHandleKey<RIO_OnTrackErrorScaling> m_pixelErrorScalingKey
{this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."};
@@ -154,7 +152,7 @@ private:
BooleanProperty m_applyNNcorrectionProperty{this, "applyNNcorrection", false};
/** NN clusterizationi factory for NN based positions and errors **/
- ToolHandle<NnClusterizationFactory> m_NnClusterizationFactory;
+ ToolHandle<InDet::NnClusterizationFactory> m_NnClusterizationFactory;
bool m_doNotRecalibrateNN;
bool m_noNNandBroadErrors;
@@ -166,6 +164,6 @@ private:
};
-} // end of namespace InDet
+} // end of namespace ITk
#endif // ITkPixelClusterOnTrackTool_H
diff --git a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/ITkPixelClusterOnTrackTool.cxx b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/ITkPixelClusterOnTrackTool.cxx
index 368ebbabddb456299c86cea4fbc0d219a4af8e63..690ecb3945f223975ad25b513997d096acf14309 100755
--- a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/ITkPixelClusterOnTrackTool.cxx
+++ b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/ITkPixelClusterOnTrackTool.cxx
@@ -3,7 +3,7 @@
*/
/////////////////////////////////////////////////////////////////
-// Implementation file for class ITkPixelClusterOnTrackTool
+// Implementation file for class ITk::PixelClusterOnTrackTool
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
@@ -16,7 +16,6 @@
#include "PixelReadoutGeometry/PixelModuleDesign.h"
#include "InDetIdentifier/PixelID.h"
#include "TrkSurfaces/PlaneSurface.h"
-#include "SiClusterizationTool/NnClusterizationFactory.h"
#include "EventPrimitives/EventPrimitives.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
@@ -54,7 +53,10 @@ namespace
}
}
-InDet::ITkPixelClusterOnTrackTool::ITkPixelClusterOnTrackTool
+namespace ITk
+{
+
+PixelClusterOnTrackTool::PixelClusterOnTrackTool
(const std::string &t, const std::string &n, const IInterface *p) :
::AthAlgTool(t, n, p),
m_pixelid(nullptr),
@@ -74,19 +76,13 @@ InDet::ITkPixelClusterOnTrackTool::ITkPixelClusterOnTrackTool
declareProperty("RunningTIDE_Ambi", m_usingTIDE_Ambi);
}
-///////////////////////////////////////////////////////////////////
-// Destructor
-///////////////////////////////////////////////////////////////////
-
-InDet::ITkPixelClusterOnTrackTool::~ITkPixelClusterOnTrackTool() {
-}
///////////////////////////////////////////////////////////////////
// Initialisation
///////////////////////////////////////////////////////////////////
StatusCode
-InDet::ITkPixelClusterOnTrackTool::initialize() {
+PixelClusterOnTrackTool::initialize() {
ATH_MSG_DEBUG(name() << " initialize()");
@@ -114,23 +110,13 @@ InDet::ITkPixelClusterOnTrackTool::initialize() {
}
-
-///////////////////////////////////////////////////////////////////
-// Finalize
-///////////////////////////////////////////////////////////////////
-
-StatusCode
-InDet::ITkPixelClusterOnTrackTool::finalize() {
-return StatusCode::SUCCESS;
-}
-
///////////////////////////////////////////////////////////////////
// Trk::SiClusterOnTrack production
///////////////////////////////////////////////////////////////////
const InDet::PixelClusterOnTrack *
-InDet::ITkPixelClusterOnTrackTool::correct
+PixelClusterOnTrackTool::correct
(const Trk::PrepRawData &rio, const Trk::TrackParameters &trackPar) const {
if (not m_applyNNcorrection){
@@ -164,7 +150,7 @@ InDet::ITkPixelClusterOnTrackTool::correct
* measured PixelCluster and the track prediction.
*/
const InDet::PixelClusterOnTrack *
-InDet::ITkPixelClusterOnTrackTool::correctDefault
+PixelClusterOnTrackTool::correctDefault
(const Trk::PrepRawData &rio, const Trk::TrackParameters &trackPar) const {
using CLHEP::micrometer;
@@ -286,13 +272,13 @@ InDet::ITkPixelClusterOnTrackTool::correctDefault
int ncol = colmax - colmin + 1;
// TOT interpolation for collision data
- SG::ReadCondHandle<ITkPixelCalib::ITkPixelOfflineCalibData> offlineITkCalibDataHandle(m_clusterITkErrorKey);
+ SG::ReadCondHandle<ITk::PixelOfflineCalibData> offlineITkCalibDataHandle(m_clusterITkErrorKey);
if (m_positionStrategy > 0 && omegaphi > -0.5 && omegaeta > -0.5) {
localphi = centroid.xPhi() + shift;
localeta = centroid.xEta();
- std::pair<double,double> delta = offlineITkCalibDataHandle->getITkPixelClusterErrorData()->getDelta(&element_id,nrows,angle,ncol,etaloc);
+ std::pair<double,double> delta = offlineITkCalibDataHandle->getClusterErrorData()->getDelta(&element_id,nrows,angle,ncol,etaloc);
double delta_phi = nrows != 1 ? delta.first : 0.;
double delta_eta = ncol != 1 ? delta.second : 0.;
localphi += delta_phi*(omegaphi-0.5);
@@ -327,7 +313,7 @@ InDet::ITkPixelClusterOnTrackTool::correctDefault
errphi = (width.phiR() / nrows) * TOPHAT_SIGMA;
erreta = (width.z() / ncol) * TOPHAT_SIGMA;
}else if (m_errorStrategy == 2) {
- std::pair<double,double> delta_err = offlineITkCalibDataHandle->getITkPixelClusterErrorData()->getDeltaError(&element_id);
+ std::pair<double,double> delta_err = offlineITkCalibDataHandle->getClusterErrorData()->getDeltaError(&element_id);
errphi = nrows != 1 ? delta_err.first : (width.phiR()/nrows)*TOPHAT_SIGMA;
erreta = ncol != 1 ? delta_err.second : (width.z()/ncol)*TOPHAT_SIGMA;
}
@@ -363,15 +349,15 @@ InDet::ITkPixelClusterOnTrackTool::correctDefault
const InDet::PixelClusterOnTrack *
-InDet::ITkPixelClusterOnTrackTool::correct
+PixelClusterOnTrackTool::correct
(const Trk::PrepRawData &rio, const Trk::TrackParameters &trackPar,
- const InDet::ITkPixelClusterStrategy strategy) const {
+ const ITk::PixelClusterStrategy strategy) const {
int initial_errorStrategy;
const InDet::PixelClusterOnTrack *newROT;
switch (strategy) {
- case InDet::ITKPIXELCLUSTER_OUTLIER: // if cluster is outlier, increase errors
- case InDet::ITKPIXELCLUSTER_SHARED:
+ case PixelClusterStrategy::OUTLIER: // if cluster is outlier, increase errors
+ case PixelClusterStrategy::SHARED:
initial_errorStrategy = m_errorStrategy;
m_errorStrategy = 0; // error as size of cluster /sqrt(12)
newROT = correct(rio, trackPar);
@@ -385,7 +371,7 @@ InDet::ITkPixelClusterOnTrackTool::correct
// GP: NEW correct() method in case of NN based calibration */
const InDet::PixelClusterOnTrack *
-InDet::ITkPixelClusterOnTrackTool::correctNN
+PixelClusterOnTrackTool::correctNN
(const Trk::PrepRawData &rio,
const Trk::TrackParameters &trackPar) const {
const InDet::PixelCluster *pixelPrepCluster = dynamic_cast<const InDet::PixelCluster *>(&rio);
@@ -460,10 +446,10 @@ InDet::ITkPixelClusterOnTrackTool::correctNN
}
bool
-InDet::ITkPixelClusterOnTrackTool::getErrorsDefaultAmbi(const InDet::PixelCluster *pixelPrepCluster,
- const Trk::TrackParameters &trackPar,
- Amg::Vector2D &finalposition,
- Amg::MatrixX &finalerrormatrix) const {
+PixelClusterOnTrackTool::getErrorsDefaultAmbi(const InDet::PixelCluster *pixelPrepCluster,
+ const Trk::TrackParameters &trackPar,
+ Amg::Vector2D &finalposition,
+ Amg::MatrixX &finalerrormatrix) const {
std::vector<Amg::Vector2D> vectorOfPositions;
int numberOfSubclusters = 1;
vectorOfPositions.push_back(pixelPrepCluster->localPosition());
@@ -473,12 +459,12 @@ InDet::ITkPixelClusterOnTrackTool::getErrorsDefaultAmbi(const InDet::PixelCluste
InDet::PixelGangedClusterAmbiguities::const_iterator mapBegin = splitClusterMap->begin();
InDet::PixelGangedClusterAmbiguities::const_iterator mapEnd = splitClusterMap->end();
for (InDet::PixelGangedClusterAmbiguities::const_iterator mapIter = mapBegin; mapIter != mapEnd; ++mapIter) {
- const SiCluster *first = (*mapIter).first;
- const SiCluster *second = (*mapIter).second;
+ const InDet::SiCluster *first = (*mapIter).first;
+ const InDet::SiCluster *second = (*mapIter).second;
if (first == pixelPrepCluster && second != pixelPrepCluster) {
ATH_MSG_DEBUG("Found additional split cluster in ambiguity map (+=1).");
numberOfSubclusters += 1;
- const SiCluster *otherOne = second;
+ const InDet::SiCluster *otherOne = second;
const InDet::PixelCluster *pixelAddCluster = dynamic_cast<const InDet::PixelCluster *>(otherOne);
if (pixelAddCluster == nullptr) {
ATH_MSG_WARNING("Pixel ambiguity map has empty pixel cluster. Please DEBUG!");
@@ -605,10 +591,10 @@ InDet::ITkPixelClusterOnTrackTool::getErrorsDefaultAmbi(const InDet::PixelCluste
}
bool
-InDet::ITkPixelClusterOnTrackTool::getErrorsTIDE_Ambi(const InDet::PixelCluster *pixelPrepCluster,
- const Trk::TrackParameters &trackPar,
- Amg::Vector2D &finalposition,
- Amg::MatrixX &finalerrormatrix) const {
+PixelClusterOnTrackTool::getErrorsTIDE_Ambi(const InDet::PixelCluster *pixelPrepCluster,
+ const Trk::TrackParameters &trackPar,
+ Amg::Vector2D &finalposition,
+ Amg::MatrixX &finalerrormatrix) const {
const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = getClusterSplittingProbability(pixelPrepCluster);
std::vector<Amg::Vector2D> vectorOfPositions;
int numberOfSubclusters = 1;
@@ -690,3 +676,5 @@ InDet::ITkPixelClusterOnTrackTool::getErrorsTIDE_Ambi(const InDet::PixelCluster
finalerrormatrix = allErrorMatrix[index];
return true;
}
+
+} // namespace ITk
diff --git a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/components/SiClusterOnTrackTool_entries.cxx b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/components/SiClusterOnTrackTool_entries.cxx
index a0fd5f09720adb4fa7e6f5facc02116e648780e2..bc1b4198314b629bc9a567a05760391ac2ba3ab8 100644
--- a/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/components/SiClusterOnTrackTool_entries.cxx
+++ b/InnerDetector/InDetRecTools/SiClusterOnTrackTool/src/components/SiClusterOnTrackTool_entries.cxx
@@ -4,4 +4,4 @@
DECLARE_COMPONENT( InDet::PixelClusterOnTrackTool )
DECLARE_COMPONENT( InDet::SCT_ClusterOnTrackTool )
-DECLARE_COMPONENT( InDet::ITkPixelClusterOnTrackTool )
+DECLARE_COMPONENT( ITk::PixelClusterOnTrackTool )
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_ITK.h b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/ITkSiSpacePointsSeedMaker.h
similarity index 83%
rename from InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_ITK.h
rename to InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/ITkSiSpacePointsSeedMaker.h
index ae0265a2f1e8b09be5a46a0e2396b821be8dfd28..2218aa1add6b6888b91e241c00acf613bb849aab 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_ITK.h
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/SiSpacePointsSeedTool_xk/ITkSiSpacePointsSeedMaker.h
@@ -5,19 +5,19 @@
*/
/////////////////////////////////////////////////////////////////////////////////
-// Header file for class SiSpacePointsSeedMaker_ITK
+// Header file for class ITk::SiSpacePointsSeedMaker
/////////////////////////////////////////////////////////////////////////////////
// Version 1.0 3/10/2004 I.Gavrilenko
/////////////////////////////////////////////////////////////////////////////////
-#ifndef SiSpacePointsSeedMaker_ITK_H
-#define SiSpacePointsSeedMaker_ITK_H
+#ifndef ITkSiSpacePointsSeedMaker_H
+#define ITkSiSpacePointsSeedMaker_H
#include "InDetRecToolInterfaces/ISiSpacePointsSeedMaker.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
-#include "SiSPSeededTrackFinderData/SiSpacePointForSeedITK.h"
+#include "SiSPSeededTrackFinderData/ITkSiSpacePointForSeed.h"
#include "SiSPSeededTrackFinderData/SiSpacePointsSeedMakerEventData.h"
#include "TrkSpacePoint/SpacePointContainer.h"
#include "TrkSpacePoint/SpacePointOverlapCollection.h"
@@ -44,36 +44,37 @@
class MsgStream;
-namespace InDet {
+namespace ITk
+{
///////////////////////////////////////////////////////////////////
// Object function for ordering space point in R coordinate order
///////////////////////////////////////////////////////////////////
- class SiSpacePointsITKComparison_R {
+ class SiSpacePointsComparison_R {
public:
- bool operator () (InDet::SiSpacePointForSeedITK* s1,InDet::SiSpacePointForSeedITK* s2) {
+ bool operator () (SiSpacePointForSeed* s1, SiSpacePointForSeed* s2) {
return((*s1).radius() < (*s2).radius());
}
};
- using EventData = SiSpacePointsSeedMakerEventData;
+ using EventData = InDet::SiSpacePointsSeedMakerEventData;
/**
- * @class SiSpacePointsSeedMaker_ATLxk
+ * @class ITk::SiSpacePointsSeedMaker
* Class for track candidates generation using space points information
* for standard Atlas geometry
*
- * In AthenaMT, event dependent cache inside SiSpacePointsSeedMaker_ITK
+ * In AthenaMT, event dependent cache inside ITk::SiSpacePointsSeedMaker
* is not preferred. SiSpacePointsSeedMakerEventData = EventData class
- * holds event dependent data for SiSpacePointsSeedMaker_ITK.
+ * holds event dependent data for ITk::SiSpacePointsSeedMaker.
* Its object is instantiated in SiSPSeededTrackFinder::execute.
*/
- class SiSpacePointsSeedMaker_ITK :
- public extends<AthAlgTool, ISiSpacePointsSeedMaker>
+ class SiSpacePointsSeedMaker :
+ public extends<AthAlgTool, InDet::ISiSpacePointsSeedMaker>
{
///////////////////////////////////////////////////////////////////
// Public methods:
@@ -85,9 +86,9 @@ namespace InDet {
/// @name Standard tool methods
///////////////////////////////////////////////////////////////////
//@{
- SiSpacePointsSeedMaker_ITK
+ SiSpacePointsSeedMaker
(const std::string&,const std::string&,const IInterface*);
- virtual ~SiSpacePointsSeedMaker_ITK() = default;
+ virtual ~SiSpacePointsSeedMaker() = default;
virtual StatusCode initialize() override;
virtual StatusCode finalize() override;
//@}
@@ -129,10 +130,10 @@ namespace InDet {
/// produced accordingly methods find
///////////////////////////////////////////////////////////////////
//@{
- virtual const SiSpacePointsSeed* next(const EventContext& ctx, EventData& data) const override;
+ virtual const InDet::SiSpacePointsSeed* next(const EventContext& ctx, EventData& data) const override;
//@}
- virtual void writeNtuple(const SiSpacePointsSeed* seed, const Trk::Track* track, int seedType, long eventNumber) const override;
+ virtual void writeNtuple(const InDet::SiSpacePointsSeed* seed, const Trk::Track* track, int seedType, long eventNumber) const override;
virtual bool getWriteNtupleBoolProperty() const override;
///////////////////////////////////////////////////////////////////
@@ -236,7 +237,7 @@ namespace InDet {
BooleanProperty m_checketa{this, "checkEta", false};
//@}
- /// @name Properties, which are not used in this implementation of SiSpacePointsSeedMaker_ITK class
+ /// @name Properties, which are not used in this implementation of ITk::SiSpacePointsSeedMaker class
//@{
BooleanProperty m_dbm{this, "useDBM", false};
UnsignedIntegerProperty m_maxNumberVertices{this, "maxNumberVertices", 99};
@@ -347,9 +348,9 @@ namespace InDet {
///////////////////////////////////////////////////////////////////
/// @name Disallow default instantiation, copy, assignment
//@{
- SiSpacePointsSeedMaker_ITK() = delete;
- SiSpacePointsSeedMaker_ITK(const SiSpacePointsSeedMaker_ITK&) = delete;
- SiSpacePointsSeedMaker_ITK &operator=(const SiSpacePointsSeedMaker_ITK&) = delete;
+ SiSpacePointsSeedMaker() = delete;
+ SiSpacePointsSeedMaker(const SiSpacePointsSeedMaker&) = delete;
+ SiSpacePointsSeedMaker &operator=(const SiSpacePointsSeedMaker&) = delete;
//@}
MsgStream& dumpConditions(EventData& data, MsgStream& out) const;
@@ -391,21 +392,21 @@ namespace InDet {
* @param[in,out] data: Provides beam spot location, receives updates to the l_spforseed and i_spforseed members
* @param[in] sp: Input space point.
**/
- SiSpacePointForSeedITK* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp) const;
- SiSpacePointForSeedITK* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp, float* r, bool usePixStripInform=false) const;
+ SiSpacePointForSeed* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp) const;
+ SiSpacePointForSeed* newSpacePoint(EventData& data, const Trk::SpacePoint*const& sp, float* r, bool usePixStripInform=false) const;
static void newSeed
(EventData& data,
- SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,float) ;
+ SiSpacePointForSeed*&,SiSpacePointForSeed*&,float) ;
void newOneSeed
(EventData& data,
- SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,
- SiSpacePointForSeedITK*&,float,float) const;
+ SiSpacePointForSeed*&,SiSpacePointForSeed*&,
+ SiSpacePointForSeed*&,float,float) const;
void newOneSeedWithCurvaturesComparison
(EventData& data,
- SiSpacePointForSeedITK*&,SiSpacePointForSeedITK*&,float) const;
+ SiSpacePointForSeed*&,SiSpacePointForSeed*&,float) const;
static void fillSeeds(EventData& data) ;
void fillLists(EventData& data) const;
@@ -443,27 +444,27 @@ namespace InDet {
**/
void production3SpSSS
(EventData& data,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_topCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_topCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
const int numberBottomCells, const int numberTopCells, int& nseed) const;
void production3SpPPP
(EventData& data,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_topCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_bottomCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endBottomCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_topCands,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & iter_endTopCands,
const int numberBottomCells, const int numberTopCells, int& nseed) const;
/// as above, but for the trigger
void production3SpTrigger
(EventData& /*data*/,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & /*rb*/,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & /*rbe*/,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & /*rt*/,
- std::array<std::list<InDet::SiSpacePointForSeedITK*>::iterator, arraySizeNeighbourBins> & /*rte*/,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rb*/,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rbe*/,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rt*/,
+ std::array<std::list<SiSpacePointForSeed*>::iterator, arraySizeNeighbourBins> & /*rte*/,
const int /*numberBottomCells*/, const int /*numberTopCells*/, int& /*nseed*/) const;
/** This creates all possible seeds with the passed central and bottom SP, using all top SP
@@ -475,11 +476,11 @@ namespace InDet {
* @param[in] Zob z0 estimate
**/
void newOneSeedWithCurvaturesComparisonSSS
- (EventData& data, SiSpacePointForSeedITK*& SPb, SiSpacePointForSeedITK*& SP0, float Zob) const;
+ (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
void newOneSeedWithCurvaturesComparisonPPP
- (EventData& data, SiSpacePointForSeedITK*& SPb, SiSpacePointForSeedITK*& SP0, float Zob) const;
+ (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
void newOneSeedWithCurvaturesComparisonSeedConfirmation
- (EventData& data, SiSpacePointForSeedITK*& SPb, SiSpacePointForSeedITK*& SP0, float Zob) const;
+ (EventData& data, SiSpacePointForSeed*& SPb, SiSpacePointForSeed*& SP0, float Zob) const;
/** Helper method to determine if a seed
@@ -494,10 +495,10 @@ namespace InDet {
* @param[in] quality: seed quality
* @return true if the seed is confirmed, false otherwise
**/
- bool isConfirmedSeed(const InDet::SiSpacePointForSeedITK* bottomSP, const InDet::SiSpacePointForSeedITK* topSP, float quality) const;
+ bool isConfirmedSeed(const SiSpacePointForSeed* bottomSP, const SiSpacePointForSeed* topSP, float quality) const;
- void sort(std::vector<FloatInt>& s, int start, int size) const;
+ void sort(std::vector<InDet::FloatInt>& s, int start, int size) const;
bool newVertices(EventData& data, const std::list<Trk::Vertex>&) const;
void findNext(EventData& data) const;
bool isZCompatible(EventData& data, float&,float&,float&) const;
@@ -507,30 +508,27 @@ namespace InDet {
void initializeEventData(EventData& data) const;
};
-} // end of name space
-
-///////////////////////////////////////////////////////////////////
-// Object-function for curvature seeds comparison
-///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
+ // Object-function for curvature seeds comparison
+ ///////////////////////////////////////////////////////////////////
-class comCurvatureITK {
-public:
- bool operator ()
- (const std::pair<float,InDet::SiSpacePointForSeedITK*>& i1,
- const std::pair<float,InDet::SiSpacePointForSeedITK*>& i2)
- {
- return i1.first < i2.first;
- }
-};
+ class comCurvature {
+ public:
+ bool operator ()
+ (const std::pair<float,SiSpacePointForSeed*>& i1,
+ const std::pair<float,SiSpacePointForSeed*>& i2)
+ {
+ return i1.first < i2.first;
+ }
+ };
-///////////////////////////////////////////////////////////////////
-// Test is space point used
-///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
+ // Test is space point used
+ ///////////////////////////////////////////////////////////////////
-namespace InDet {
inline
- bool SiSpacePointsSeedMaker_ITK::isUsed(const Trk::SpacePoint* sp, const Trk::PRDtoTrackMap &prd_to_track_map) const
+ bool SiSpacePointsSeedMaker::isUsed(const Trk::SpacePoint* sp, const Trk::PRDtoTrackMap &prd_to_track_map) const
{
const Trk::PrepRawData* d = sp->clusterList().first;
if (!d || !prd_to_track_map.isUsed(*d)) return false;
@@ -541,19 +539,19 @@ namespace InDet {
return false;
}
-///////////////////////////////////////////////////////////////////
+ ///////////////////////////////////////////////////////////////////
// The procedure sorts the elements into ascending order.
///////////////////////////////////////////////////////////////////
inline
- void SiSpacePointsSeedMaker_ITK::sort(std::vector<FloatInt>& s, int start, int size) const
+ void SiSpacePointsSeedMaker::sort(std::vector<InDet::FloatInt>& s, int start, int size) const
{
//QuickSort for fast tracking currently buggy
//TBC if really faster than std::sort
//Using std::sort in all cases for now
- std::sort(s.begin()+start,s.begin()+start+size,[](const FloatInt a,const FloatInt b)->bool {return a.Fl < b.Fl;});
+ std::sort(s.begin()+start,s.begin()+start+size,[](const InDet::FloatInt a, const InDet::FloatInt b)->bool {return a.Fl < b.Fl;});
}
-}
+} // namespace ITk
-#endif // SiSpacePointsSeedMaker_ITK_H
+#endif // ITkSiSpacePointsSeedMaker_H
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ITK.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/ITkSiSpacePointsSeedMaker.cxx
similarity index 86%
rename from InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ITK.cxx
rename to InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/ITkSiSpacePointsSeedMaker.cxx
index 1adb68b8dcd0ffd2123045cf3c1fabff2f8e1753..1f8f2b2cbf22d8fad14c05abf418e1eaed266f1d 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ITK.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/ITkSiSpacePointsSeedMaker.cxx
@@ -3,7 +3,7 @@
*/
///////////////////////////////////////////////////////////////////
-// Implementation file for class SiSpacePointsSeedMaker_ITK
+// Implementation file for class ITk::SiSpacePointsSeedMaker
///////////////////////////////////////////////////////////////////
// (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
@@ -12,7 +12,7 @@
// Version 1.0 21/04/2004 I.Gavrilenko
///////////////////////////////////////////////////////////////////
-#include "SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_ITK.h"
+#include "SiSpacePointsSeedTool_xk/ITkSiSpacePointsSeedMaker.h"
#include "InDetPrepRawData/SiCluster.h"
@@ -26,12 +26,14 @@
#include <iomanip>
#include <ostream>
+namespace ITk
+{
///////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////
-InDet::SiSpacePointsSeedMaker_ITK::SiSpacePointsSeedMaker_ITK(const std::string &t, const std::string &n, const IInterface *p)
+SiSpacePointsSeedMaker::SiSpacePointsSeedMaker(const std::string &t, const std::string &n, const IInterface *p)
: base_class(t, n, p),
m_thistSvc(nullptr),
m_outputTree(nullptr),
@@ -49,7 +51,7 @@ InDet::SiSpacePointsSeedMaker_ITK::SiSpacePointsSeedMaker_ITK(const std::string
// Initialisation
///////////////////////////////////////////////////////////////////
-StatusCode InDet::SiSpacePointsSeedMaker_ITK::initialize()
+StatusCode SiSpacePointsSeedMaker::initialize()
{
StatusCode sc = AlgTool::initialize();
@@ -131,7 +133,7 @@ StatusCode InDet::SiSpacePointsSeedMaker_ITK::initialize()
// Finalize
///////////////////////////////////////////////////////////////////
-StatusCode InDet::SiSpacePointsSeedMaker_ITK::finalize()
+StatusCode SiSpacePointsSeedMaker::finalize()
{
return AlgTool::finalize();
}
@@ -140,7 +142,7 @@ StatusCode InDet::SiSpacePointsSeedMaker_ITK::finalize()
// Initialize tool for new event
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventData &data, int iteration) const
+void SiSpacePointsSeedMaker::newEvent(const EventContext &ctx, EventData &data, int iteration) const
{
/// if not done so, book the arrays etc inside the event data object
@@ -178,7 +180,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
const AtlasFieldCacheCondObj *fieldCondObj{*readHandle};
if (fieldCondObj == nullptr)
{
- ATH_MSG_ERROR("SiSpacePointsSeedMaker_ITK: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
+ ATH_MSG_ERROR("ITk::SiSpacePointsSeedMaker: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
return;
}
fieldCondObj->getInitializedCache(fieldCache);
@@ -213,7 +215,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
data.COFK = m_COF * (data.K * data.K);
/// set the spacepoint iterator to the beginning of the space-point list
- data.i_spforseed_ITK = data.l_spforseed_ITK.begin();
+ data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
// Set the seed multiplicity strategy of the event data to the one configured
// by the user for strip seeds
data.maxSeedsPerSP = m_maxOneSizeSSS;
@@ -255,7 +257,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
{
int n = data.r_index[i];
data.r_map[n] = 0;
- data.r_Sorted_ITK[n].clear();
+ data.r_ITkSorted[n].clear();
}
data.ns = data.nr = 0;
@@ -306,7 +308,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
* This will also add the point to the l_spforseed list and update
* the i_spforseed iterator
**/
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp);
/// this can occur if we fail the eta cut
if (!sps)
continue;
@@ -319,7 +321,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
radiusBin = maxBinR;
/// now add the SP to the r-binned vector
- data.r_Sorted_ITK[radiusBin].push_back(sps);
+ data.r_ITkSorted[radiusBin].push_back(sps);
/// increment the counter for this bin
++data.r_map[radiusBin];
/// if this is the first time we see this bin in use, we update the index map for this bin
@@ -354,7 +356,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || sp->r() > m_r_rmax || sp->r() < m_r_rmin)
continue;
/// create a space point and write it into the data object's list of points
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp);
if (!sps)
continue;
@@ -364,7 +366,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
if (radiusBin > maxBinR)
radiusBin = maxBinR;
/// again store the SP in the r-binned vectors
- data.r_Sorted_ITK[radiusBin].push_back(sps);
+ data.r_ITkSorted[radiusBin].push_back(sps);
/// update the count of SP in the given bin
++data.r_map[radiusBin];
/// update the r_index map and data.nr if needed
@@ -390,7 +392,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
continue;
/// SP creation, entry into list of the data object
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp);
if (!sps)
continue;
@@ -399,7 +401,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
if (radiusBin > maxBinR)
radiusBin = maxBinR;
/// insert into the "histogram" vector
- data.r_Sorted_ITK[radiusBin].push_back(sps);
+ data.r_ITkSorted[radiusBin].push_back(sps);
/// update the counter for each bin content
++data.r_map[radiusBin];
/// update the bin index list and occupied bin counter
@@ -425,8 +427,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::newEvent(const EventContext &ctx, EventD
// Initialize tool for new region
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, EventData &data,
- const std::vector<IdentifierHash> &vPixel, const std::vector<IdentifierHash> &vStrip) const
+void SiSpacePointsSeedMaker::newRegion(const EventContext &ctx, EventData &data,
+ const std::vector<IdentifierHash> &vPixel, const std::vector<IdentifierHash> &vStrip) const
{
if (not data.initialized)
initializeEventData(data);
@@ -453,7 +455,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
const AtlasFieldCacheCondObj *fieldCondObj{*readHandle};
if (fieldCondObj == nullptr)
{
- ATH_MSG_ERROR("SiSpacePointsSeedMaker_ITK: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
+ ATH_MSG_ERROR("ITk::SiSpacePointsSeedMaker: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
return;
}
fieldCondObj->getInitializedCache(fieldCache);
@@ -473,7 +475,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
data.ipt2C = m_ipt2 * m_COF;
data.COFK = m_COF * (data.K * data.K);
- data.i_spforseed_ITK = data.l_spforseed_ITK.begin();
+ data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
float oneOverBinSizeR = 1. / m_binSizeR; //was float irstep = 1.f/m_binSizeR;
int maxBinR = m_nBinsR - 1; //was int irmax = m_nBinsR-1;
@@ -485,7 +487,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
{
int n = data.r_index[i];
data.r_map[n] = 0;
- data.r_Sorted_ITK[n].clear();
+ data.r_ITkSorted[n].clear();
}
data.ns = data.nr = 0;
@@ -524,11 +526,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
float r = sp->r();
if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || r > m_r_rmax || r < m_r_rmin)
continue;
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp);
int ir = static_cast<int>(sps->radius() * oneOverBinSizeR);
if (ir > maxBinR)
ir = maxBinR;
- data.r_Sorted_ITK[ir].push_back(sps);
+ data.r_ITkSorted[ir].push_back(sps);
++data.r_map[ir];
if (data.r_map[ir] == 1)
data.r_index[data.nr++] = ir;
@@ -562,11 +564,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
float r = sp->r();
if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || r > m_r_rmax || r < m_r_rmin)
continue;
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp);
int ir = static_cast<int>(sps->radius() * oneOverBinSizeR);
if (ir > maxBinR)
ir = maxBinR;
- data.r_Sorted_ITK[ir].push_back(sps);
+ data.r_ITkSorted[ir].push_back(sps);
++data.r_map[ir];
if (data.r_map[ir] == 1)
data.r_index[data.nr++] = ir;
@@ -582,8 +584,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
// Initialize tool for new region
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, EventData &data,
- const std::vector<IdentifierHash> &vPixel, const std::vector<IdentifierHash> &vStrip, const IRoiDescriptor &IRD) const
+void SiSpacePointsSeedMaker::newRegion(const EventContext &ctx, EventData &data,
+ const std::vector<IdentifierHash> &vPixel, const std::vector<IdentifierHash> &vStrip, const IRoiDescriptor &IRD) const
{
constexpr float twoPi = 2. * M_PI;
@@ -614,7 +616,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newRegion(const EventContext &ctx, Event
// with two space points with or without vertex constraint
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::find2Sp(EventData &data, const std::list<Trk::Vertex> &lv) const
+void SiSpacePointsSeedMaker::find2Sp(EventData &data, const std::list<Trk::Vertex> &lv) const
{
if (not data.initialized)
initializeEventData(data);
@@ -630,7 +632,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find2Sp(EventData &data, const std::list
if (newv || !data.state || data.nspoint != 2 || data.mode != mode || data.nlist)
{
- data.i_seede_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
data.state = 1;
data.nspoint = 2;
data.nlist = 0;
@@ -641,7 +643,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find2Sp(EventData &data, const std::list
data.zMin = 0;
production2Sp(data);
}
- data.i_seed_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeed = data.i_ITkSeeds.begin();
if (m_outputlevel <= 0)
{
@@ -655,7 +657,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find2Sp(EventData &data, const std::list
// with three space points with or without vertex constraint
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv) const
+void SiSpacePointsSeedMaker::find3Sp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv) const
{
if (not data.initialized)
initializeEventData(data);
@@ -675,7 +677,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
/// update the data object's config
if (newv || !data.state || data.nspoint != 3 || data.mode != mode || data.nlist)
{
- data.i_seede_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
data.state = 1;
data.nspoint = 3;
data.nlist = 0;
@@ -687,9 +689,9 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
production3Sp(data); ///< This performs the actual seed finding
}
- /// reset the i_seed_ITK iterator - this is used to return the seeds to the
+ /// reset the i_ITkSeed iterator - this is used to return the seeds to the
/// consumer when they call next()
- data.i_seed_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeed = data.i_ITkSeeds.begin();
if (msgLvl(MSG::DEBUG))
{
@@ -703,7 +705,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
// with three space points with or without vertex constraint
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv, const double *ZVertex) const
+void SiSpacePointsSeedMaker::find3Sp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv, const double *ZVertex) const
{
if (not data.initialized)
@@ -730,7 +732,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
/// update the data object's config
if (newv || !data.state || data.nspoint != 3 || data.mode != mode || data.nlist)
{
- data.i_seede_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
data.state = 1;
data.nspoint = 3;
data.nlist = 0;
@@ -741,9 +743,9 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
data.zMin = 0;
production3Sp(data); ///< This performs the actual seed finding
}
- /// reset the i_seed_ITK iterator - this is used to return the seeds to the
+ /// reset the i_ITkSeed iterator - this is used to return the seeds to the
/// consumer when they call next()
- data.i_seed_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeed = data.i_ITkSeeds.begin();
if (msgLvl(MSG::DEBUG))
{
@@ -758,7 +760,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::find3Sp(const EventContext &, EventData
// Variable means (2,3,4,....) any number space points
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::findVSp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv) const
+void SiSpacePointsSeedMaker::findVSp(const EventContext &, EventData &data, const std::list<Trk::Vertex> &lv) const
{
if (not data.initialized)
@@ -774,7 +776,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::findVSp(const EventContext &, EventData
if (newv || !data.state || data.nspoint != 4 || data.mode != mode || data.nlist)
{
- data.i_seede_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
data.state = 1;
data.nspoint = 4;
data.nlist = 0;
@@ -785,7 +787,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::findVSp(const EventContext &, EventData
data.zMin = 0;
production3Sp(data);
}
- data.i_seed_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeed = data.i_ITkSeeds.begin();
if (msgLvl(MSG::DEBUG))
{
@@ -798,7 +800,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::findVSp(const EventContext &, EventData
// Dumps relevant information into the MsgStream
///////////////////////////////////////////////////////////////////
-MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dump(EventData &data, MsgStream &out) const
+MsgStream &SiSpacePointsSeedMaker::dump(EventData &data, MsgStream &out) const
{
if (not data.initialized)
initializeEventData(data);
@@ -812,7 +814,7 @@ MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dump(EventData &data, MsgStream &o
// Dumps conditions information into the MsgStream
///////////////////////////////////////////////////////////////////
-MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dumpConditions(EventData &data, MsgStream &out) const
+MsgStream &SiSpacePointsSeedMaker::dumpConditions(EventData &data, MsgStream &out) const
{
int n = 42-m_spacepointsPixel.key().size();
std::string s2;
@@ -929,7 +931,7 @@ MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dumpConditions(EventData &data, Ms
// Dumps event information into the MsgStream
///////////////////////////////////////////////////////////////////
-MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dumpEvent(EventData &data, MsgStream &out)
+MsgStream &SiSpacePointsSeedMaker::dumpEvent(EventData &data, MsgStream &out)
{
out<<"|---------------------------------------------------------------------|"
<<endmsg;
@@ -943,7 +945,7 @@ MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dumpEvent(EventData &data, MsgStre
<<std::setw(12)<<data.nsazv
<<" |"<<endmsg;
out<<"| seeds | "
- <<std::setw(12)<<data.l_seeds_ITK.size()
+ <<std::setw(12)<<data.i_ITkSeeds.size()
<<" |"<<endmsg;
out<<"|---------------------------------------------------------------------|"
<<endmsg;
@@ -955,17 +957,17 @@ MsgStream &InDet::SiSpacePointsSeedMaker_ITK::dumpEvent(EventData &data, MsgStre
// Find next set space points
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::findNext(EventData &data) const
+void SiSpacePointsSeedMaker::findNext(EventData &data) const
{
if (data.endlist)
return;
- data.i_seede_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
if (data.mode == 2 || data.mode == 3 || data.mode == 5 || data.mode == 6)
production3Sp(data);
- data.i_seed_ITK = data.l_seeds_ITK.begin();
+ data.i_ITkSeed = data.i_ITkSeeds.begin();
++data.nlist;
}
@@ -973,7 +975,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::findNext(EventData &data) const
// New and old list vertices comparison
///////////////////////////////////////////////////////////////////
-bool InDet::SiSpacePointsSeedMaker_ITK::newVertices(EventData &data, const std::list<Trk::Vertex> &lV) const
+bool SiSpacePointsSeedMaker::newVertices(EventData &data, const std::list<Trk::Vertex> &lV) const
{
unsigned int s1 = data.l_vertex.size();
@@ -1015,7 +1017,7 @@ bool InDet::SiSpacePointsSeedMaker_ITK::newVertices(EventData &data, const std::
// Initiate frame work for seed generator
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::buildFrameWork()
+void SiSpacePointsSeedMaker::buildFrameWork()
{
m_ptmin = std::abs(m_ptmin);
@@ -1121,11 +1123,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::buildFrameWork()
m_maxPhiBinSSS, true);
}
-void InDet::SiSpacePointsSeedMaker_ITK::buildConnectionMaps(std::array<int, arraySizePhiZ> &nNeighbourCellsBottom,
- std::array<int, arraySizePhiZ> &nNeighbourCellsTop,
- std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> &neighbourCellsBottom,
- std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> &neighbourCellsTop,
- int maxPhiBin, bool isSSS)
+void SiSpacePointsSeedMaker::buildConnectionMaps(std::array<int, arraySizePhiZ> &nNeighbourCellsBottom,
+ std::array<int, arraySizePhiZ> &nNeighbourCellsTop,
+ std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> &neighbourCellsBottom,
+ std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> &neighbourCellsTop,
+ int maxPhiBin, bool isSSS)
{
/// Build maps for radius-azimuthal-Z sorted collections.
@@ -1261,7 +1263,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::buildConnectionMaps(std::array<int, arra
}
}
-float InDet::SiSpacePointsSeedMaker_ITK::azimuthalStep(const float pTmin, const float maxd0, const float Rmin, const float Rmax)
+float SiSpacePointsSeedMaker::azimuthalStep(const float pTmin, const float maxd0, const float Rmin, const float Rmax)
{
/// here we approximate the largest curvature
/// that can be expected for the seeds we build
@@ -1288,7 +1290,7 @@ float InDet::SiSpacePointsSeedMaker_ITK::azimuthalStep(const float pTmin, const
// Initiate beam frame work for seed generator
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::buildBeamFrameWork(EventData &data) const
+void SiSpacePointsSeedMaker::buildBeamFrameWork(EventData &data) const
{
SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey};
@@ -1322,7 +1324,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::buildBeamFrameWork(EventData &data) cons
///////////////////////////////////////////////////////////////////
// Initiate beam frame work for seed generator
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::convertToBeamFrameWork(EventData &data, const Trk::SpacePoint *const &sp, float *r)
+void SiSpacePointsSeedMaker::convertToBeamFrameWork(EventData &data, const Trk::SpacePoint *const &sp, float *r)
{
r[0] = static_cast<float>(sp->globalPosition().x()) - data.xbeam[0];
r[1] = static_cast<float>(sp->globalPosition().y()) - data.ybeam[0];
@@ -1334,8 +1336,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::convertToBeamFrameWork(EventData &data,
// Only for SCT space points
//
- const InDet::SiCluster* c0 = static_cast<const InDet::SiCluster*>(sp->clusterList().first );
- const InDet::SiCluster* c1 = static_cast<const InDet::SiCluster*>(sp->clusterList().second);
+ const SiCluster* c0 = static_cast<const SiCluster*>(sp->clusterList().first );
+ const SiCluster* c1 = static_cast<const SiCluster*>(sp->clusterList().second);
Amg::Vector2D lc0 = c0->localPosition();
Amg::Vector2D lc1 = c1->localPosition();
@@ -1375,7 +1377,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::convertToBeamFrameWork(EventData &data,
// Initiate space points seed maker
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::fillLists(EventData &data) const
+void SiSpacePointsSeedMaker::fillLists(EventData &data) const
{
constexpr float twoPi = 2. * M_PI;
@@ -1421,7 +1423,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillLists(EventData &data) const
continue;
// Stop when we reach strip SP in PPP iteration #1
- std::list<InDet::SiSpacePointForSeedITK *>::iterator SP_first = data.r_Sorted_ITK[radialBin].begin();
+ std::list<SiSpacePointForSeed *>::iterator SP_first = data.r_ITkSorted[radialBin].begin();
if (data.iteration && (*SP_first)->spacepoint->clusterList().second)
break;
@@ -1431,7 +1433,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillLists(EventData &data) const
lastRadialBin = radialBin;
// loop over the space points in the r-bin and sort them into the 2d phi-z binning
- for (InDet::SiSpacePointForSeedITK *SP : data.r_Sorted_ITK[radialBin])
+ for (SiSpacePointForSeed *SP : data.r_ITkSorted[radialBin])
{
/// Azimuthal angle sort
@@ -1473,7 +1475,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillLists(EventData &data) const
/// This is not reset between iterations.
++data.nsaz;
// push our space point into the 2D binned array
- data.rfz_Sorted_ITK[twoDbin].push_back(SP);
+ data.rfz_ITkSorted[twoDbin].push_back(SP);
/// the conditional seems to always be true. The rfz_index vector stores
/// the 2D bin for each SP in the radius-sorted map. This way,
/// we obtain effectively a *3D binning* in r(via the r-sorted vector), phi and z (via the 2D index)
@@ -1503,7 +1505,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillLists(EventData &data) const
/// Initiate space points seed maker for fast tracking
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::fillListsFast(const EventContext &ctx, EventData &data) const
+void SiSpacePointsSeedMaker::fillListsFast(const EventContext &ctx, EventData &data) const
{
constexpr float twoPi = 2. * M_PI;
@@ -1583,11 +1585,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillListsFast(const EventContext &ctx, E
if (prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr))
continue;
- /** create a SiSpacePointForSeedITK from the space point.
+ /** create a SiSpacePointForSeed from the space point.
* This will also add the point to the l_spforseed list and update
* the i_spforseed iterator
**/
- InDet::SiSpacePointForSeedITK *sps = newSpacePoint(data, sp, r);
+ SiSpacePointForSeed *sps = newSpacePoint(data, sp, r);
if (!sps)
continue;
@@ -1629,7 +1631,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillListsFast(const EventContext &ctx, E
/// This is not reset between iterations.
++data.nsaz;
// push our space point into the 2D binned array
- data.rfz_Sorted_ITK[twoDbin].push_back(sps);
+ data.rfz_ITkSorted[twoDbin].push_back(sps);
/// the conditional seems to always be true. The rfz_index vector stores
/// the 2D bin for each SP in the radius-sorted map. This way,
/// we obtain effectively a *3D binning* in r(via the r-sorted vector), phi and z (via the 2D index)
@@ -1643,9 +1645,9 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillListsFast(const EventContext &ctx, E
//
for (int twoDbin(0); twoDbin != arraySizePhiZ; ++twoDbin)
{
- if (data.rfz_Sorted_ITK[twoDbin].size() > 1)
+ if (data.rfz_ITkSorted[twoDbin].size() > 1)
{
- data.rfz_Sorted_ITK[twoDbin].sort(InDet::SiSpacePointsITKComparison_R());
+ data.rfz_ITkSorted[twoDbin].sort(SiSpacePointsComparison_R());
}
}
@@ -1663,7 +1665,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillListsFast(const EventContext &ctx, E
// Pixels information
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::pixInform(const Trk::SpacePoint *sp, float *r)
+void SiSpacePointsSeedMaker::pixInform(const Trk::SpacePoint *sp, float *r)
{
const InDet::SiCluster *cl = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
const InDetDD::SiDetectorElement *de = cl->detectorElement();
@@ -1677,7 +1679,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::pixInform(const Trk::SpacePoint *sp, flo
// Strip information
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::stripInform(EventData &data, const Trk::SpacePoint *sp, float *r)
+void SiSpacePointsSeedMaker::stripInform(EventData &data, const Trk::SpacePoint *sp, float *r)
{
const InDet::SiCluster *c0 = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
const InDet::SiCluster *c1 = static_cast<const InDet::SiCluster *>(sp->clusterList().second);
@@ -1724,20 +1726,20 @@ void InDet::SiSpacePointsSeedMaker_ITK::stripInform(EventData &data, const Trk::
// Erase space point information
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::erase(EventData &data)
+void SiSpacePointsSeedMaker::erase(EventData &data)
{
for (int i = 0; i < data.nrfz; ++i)
{
int n = data.rfz_index[i];
data.rfz_map[n] = 0;
- data.rfz_Sorted_ITK[n].clear();
+ data.rfz_ITkSorted[n].clear();
}
for (int i = 0; i < data.nrfzv; ++i)
{
int n = data.rfzv_index[i];
data.rfzv_map[n] = 0;
- data.rfzv_Sorted_ITK[n].clear();
+ data.rfzv_ITkSorted[n].clear();
}
data.state = 0;
data.nsaz = 0;
@@ -1750,12 +1752,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::erase(EventData &data)
// 2 space points seeds production
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::production2Sp(EventData &data) const
+void SiSpacePointsSeedMaker::production2Sp(EventData &data) const
{
if (data.nsazv < 2)
return;
- std::list<InDet::SiSpacePointForSeedITK *>::iterator r0, r0e, r, re;
+ std::list<SiSpacePointForSeed *>::iterator r0, r0e, r, re;
int nseed = 0;
// Loop thorugh all azimuthal regions
@@ -1774,12 +1776,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::production2Sp(EventData &data) const
int a = f * arraySizeZV + z;
if (!data.rfzv_map[a])
continue;
- r0 = data.rfzv_Sorted_ITK[a].begin();
- r0e = data.rfzv_Sorted_ITK[a].end();
+ r0 = data.rfzv_ITkSorted[a].begin();
+ r0e = data.rfzv_ITkSorted[a].end();
if (!data.endlist)
{
- r0 = data.rMin_ITK;
+ r0 = data.ITk_rMin;
data.endlist = true;
}
@@ -1807,8 +1809,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production2Sp(EventData &data) const
if (!data.rfzv_map[an])
continue;
- r = data.rfzv_Sorted_ITK[an].begin();
- re = data.rfzv_Sorted_ITK[an].end();
+ r = data.rfzv_ITkSorted[an].begin();
+ re = data.rfzv_ITkSorted[an].end();
for (; r != re; ++r)
{
@@ -1859,7 +1861,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production2Sp(EventData &data) const
if (nseed < m_maxsize)
continue;
data.endlist = false;
- data.rMin_ITK = (++r0);
+ data.ITk_rMin = (++r0);
data.fvNmin = f;
data.zMin = z;
return;
@@ -1873,7 +1875,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production2Sp(EventData &data) const
// Production 3 space points seeds
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::production3Sp(EventData &data) const
+void SiSpacePointsSeedMaker::production3Sp(EventData &data) const
{
/// we need at least 3 SP in our phi-z binning, otherwise can't build 3-SP seeds
if (data.nsaz < 3)
@@ -1910,10 +1912,10 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3Sp(EventData &data) const
/// prepare arrays to store the iterators over the SP containers for all
/// neighbouring cells we wish to consider in the seed formation
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> iter_topCands;
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> iter_endTopCands;
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> iter_bottomCands;
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> iter_endBottomCands;
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_topCands;
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_endTopCands;
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_bottomCands;
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_endBottomCands;
int nPhiBins;
std::array<int, arraySizePhiZ> nNeighbourCellsBottom{};
@@ -1987,8 +1989,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3Sp(EventData &data) const
if (!data.rfz_map[theNeighbourCell])
continue;
/// plug the begin and end iterators to the SP in the cell into our array
- iter_bottomCands[numberBottomCells] = data.rfz_Sorted_ITK[theNeighbourCell].begin();
- iter_endBottomCands[numberBottomCells++] = data.rfz_Sorted_ITK[theNeighbourCell].end();
+ iter_bottomCands[numberBottomCells] = data.rfz_ITkSorted[theNeighbourCell].begin();
+ iter_endBottomCands[numberBottomCells++] = data.rfz_ITkSorted[theNeighbourCell].end();
}
/// walk through the cells in phi-z we wish to consider for the top SP search.
@@ -2003,8 +2005,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3Sp(EventData &data) const
if (!data.rfz_map[theNeighbourCell])
continue;
/// plug the begin and end iterators to the SP in the cell into our array
- iter_topCands[numberTopCells] = data.rfz_Sorted_ITK[theNeighbourCell].begin();
- iter_endTopCands[numberTopCells++] = data.rfz_Sorted_ITK[theNeighbourCell].end();
+ iter_topCands[numberTopCells] = data.rfz_ITkSorted[theNeighbourCell].begin();
+ iter_endTopCands[numberTopCells++] = data.rfz_ITkSorted[theNeighbourCell].end();
}
/// now run the seed search for the current phi-z bin.
@@ -2040,12 +2042,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3Sp(EventData &data) const
// Production 3 pixel space points seeds for full scan
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_bottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_endBottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_topCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_endTopCands,
- const int numberBottomCells, const int numberTopCells, int &nseed) const
+void SiSpacePointsSeedMaker::production3SpPPP(EventData &data,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_bottomCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_endBottomCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_topCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_endTopCands,
+ const int numberBottomCells, const int numberTopCells, int &nseed) const
{
/**
* This method implements the seed search for a single phi-Z region of the detector.
@@ -2054,8 +2056,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
**/
/// iterator across the candidates for the central space point.
- std::list<InDet::SiSpacePointForSeedITK *>::iterator iter_centralSP = iter_bottomCands[0];
- std::list<InDet::SiSpacePointForSeedITK *>::iterator iter_otherSP; ///< will be used for iterating over top/bottom SP
+ std::list<SiSpacePointForSeed *>::iterator iter_centralSP = iter_bottomCands[0];
+ std::list<SiSpacePointForSeed *>::iterator iter_otherSP; ///< will be used for iterating over top/bottom SP
/**
* Next, we work out where we are within the ATLAS geometry.
@@ -2081,11 +2083,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
const float &maxd0cut = m_maxdImpact;
const float &zmax = data.zmaxU;
const float &dzdrmax = data.dzdrmax;
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
/// keep track of the SP storace capacity.
/// Extend it needed (should rarely be the case)
- size_t SPcapacity = data.SP_ITK.size();
+ size_t SPcapacity = data.ITkSP.size();
/// Loop through all central space point candidates
for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
@@ -2179,13 +2181,13 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
continue;
/// add SP to the list
- data.SP_ITK[Nt] = (*iter_otherSP);
+ data.ITkSP[Nt] = (*iter_otherSP);
data.R[Nt] = dr; ///< inverse distance to central SP
data.U[Nt] = u; ///< transformed U coordinate
data.V[Nt] = v; ///< transformed V coordinate
data.Er[Nt] = ((covz0 + (*iter_otherSP)->covz()) + (tz * tz) * (covr0 + (*iter_otherSP)->covr())) * r2; ///<squared Error on 1/tan theta coming from the space-point position errors
- data.SP_ITK[Nt]->setDR(std::sqrt(dxy + dz * dz));
- data.SP_ITK[Nt]->setDZDR(dZdR);
+ data.ITkSP[Nt]->setDR(std::sqrt(dxy + dz * dz));
+ data.ITkSP[Nt]->setDZDR(dZdR);
data.Tn[Nt].Fl = tz;
data.Tn[Nt].In = Nt;
@@ -2195,7 +2197,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
if (++Nt == SPcapacity)
{
data.resizeSPCont();
- SPcapacity = data.SP_ITK.size();
+ SPcapacity = data.ITkSP.size();
}
} ///< end of loop over SP within top candidate cell
} ///< end of loop over top candidate cells
@@ -2267,13 +2269,13 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
continue;
/// add SP to the list
- data.SP_ITK[Nb] = (*iter_otherSP);
+ data.ITkSP[Nb] = (*iter_otherSP);
data.R[Nb] = dr; ///< inverse distance to central SP
data.U[Nb] = u; ///< transformed U coordinate
data.V[Nb] = v; ///< transformed V coordinate
data.Er[Nb] = ((covz0 + (*iter_otherSP)->covz()) + (tz * tz) * (covr0 + (*iter_otherSP)->covr())) * r2; ///<squared Error on 1/tan theta coming from the space-point position errors
- data.SP_ITK[Nb]->setDR(std::sqrt(dxy + dz * dz));
- data.SP_ITK[Nb]->setDZDR(dZdR);
+ data.ITkSP[Nb]->setDR(std::sqrt(dxy + dz * dz));
+ data.ITkSP[Nb]->setDZDR(dZdR);
data.Tn[Nb].Fl = tz;
data.Tn[Nb].In = Nb;
@@ -2283,7 +2285,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
if (++Nb == SPcapacity)
{
data.resizeSPCont();
- SPcapacity = data.SP_ITK.size();
+ SPcapacity = data.ITkSP.size();
}
} ///< end of loop over SP in bottom candidate cell
@@ -2297,7 +2299,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
sort(data.Tn,Nt,Nb-Nt);
data.nOneSeeds = 0;
- data.mapOneSeeds_ITK.clear();
+ data.ITkMapOneSeeds.clear();
/// Three space points comparison
/// first, loop over the bottom point candidates
@@ -2327,7 +2329,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
float d0max = maxd0cut;
size_t Nc = 1;
- if (data.SP_ITK[b]->radius() > m_rmaxPPP)
+ if (data.ITkSP[b]->radius() > m_rmaxPPP)
Nc = 0;
if (data.nOneSeeds)
++Nc;
@@ -2445,8 +2447,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
/// obtain a quality score - start from the d0 estimate, and add
/// a penalty term corresponding to how far the seed segments
/// deviate from a straight line in r-z
- data.SP_ITK[t]->setScorePenalty(std::abs((Tzb - Tzt) / (dr * sTzb2)));
- data.SP_ITK[t]->setParam(d0);
+ data.ITkSP[t]->setScorePenalty(std::abs((Tzb - Tzt) / (dr * sTzb2)));
+ data.ITkSP[t]->setParam(d0);
float meanOneOverTanTheta = std::sqrt(meanOneOverTanThetaSquare);
if (meanOneOverTanTheta < 1e-8)
@@ -2454,23 +2456,23 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
if (BSquare < 1e-8)
BSquare = 1e-8;
float theta = std::atan(1. / std::sqrt(meanOneOverTanThetaSquare));
- data.SP_ITK[t]->setEta(-std::log(std::tan(0.5 * theta)));
- data.SP_ITK[t]->setPt(std::sqrt(onePlusAsquare / BSquare) / (1000 * data.K));
+ data.ITkSP[t]->setEta(-std::log(std::tan(0.5 * theta)));
+ data.ITkSP[t]->setPt(std::sqrt(onePlusAsquare / BSquare) / (1000 * data.K));
/// record one possible seed candidate, sort by the curvature
- data.CmSp_ITK.emplace_back(std::make_pair(B / std::sqrt(onePlusAsquare), data.SP_ITK[t]));
+ data.ITkCmSp.emplace_back(std::make_pair(B / std::sqrt(onePlusAsquare), data.ITkSP[t]));
/// store the transverse IP, will later be used as a quality estimator
- if (data.CmSp_ITK.size() == 500)
+ if (data.ITkCmSp.size() == 500)
break;
}
} ///< end loop over top space point candidates
/// now apply further cleaning on the seed candidates for this central+bottom pair.
- if (data.CmSp_ITK.size() > Nc)
+ if (data.ITkCmSp.size() > Nc)
{
- newOneSeedWithCurvaturesComparisonPPP(data, data.SP_ITK[b], (*iter_centralSP), Z - R * Tzb);
+ newOneSeedWithCurvaturesComparisonPPP(data, data.ITkSP[b], (*iter_centralSP), Z - R * Tzb);
}
- data.CmSp_ITK.clear(); /// cleared in newOneSeedWithCurvaturesComparisonPPP but need to also be cleared in case previous conditional statement isn't fulfilled
+ data.ITkCmSp.clear(); /// cleared in newOneSeedWithCurvaturesComparisonPPP but need to also be cleared in case previous conditional statement isn't fulfilled
} ///< end loop over bottom space points
///record seeds found in this run
fillSeeds(data);
@@ -2483,12 +2485,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpPPP(EventData &data,
/// Production 3 space points seeds for full scan
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_bottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_endBottomCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_topCands,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &iter_endTopCands,
- const int numberBottomCells, const int numberTopCells, int &nseed) const
+void SiSpacePointsSeedMaker::production3SpSSS(EventData &data,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_bottomCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_endBottomCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_topCands,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &iter_endTopCands,
+ const int numberBottomCells, const int numberTopCells, int &nseed) const
{
/**
@@ -2498,8 +2500,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
**/
/// iterator across the candidates for the central space point.
- std::list<InDet::SiSpacePointForSeedITK *>::iterator iter_centralSP = iter_bottomCands[0];
- std::list<InDet::SiSpacePointForSeedITK *>::iterator iter_otherSP; ///< will be used for iterating over top/bottom SP
+ std::list<SiSpacePointForSeed *>::iterator iter_centralSP = iter_bottomCands[0];
+ std::list<SiSpacePointForSeed *>::iterator iter_otherSP; ///< will be used for iterating over top/bottom SP
/**
* Next, we work out where we are within the ATLAS geometry.
@@ -2524,11 +2526,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
const float &COFK = data.COFK;
const float &maxd0cut = m_maxdImpactSSS;
const float &zmax = data.zmaxU;
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
/// keep track of the SP storace capacity.
/// Extend it needed (should rarely be the case)
- size_t SPcapacity = data.SP_ITK.size();
+ size_t SPcapacity = data.ITkSP.size();
/// Loop through all central space point candidates
for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
@@ -2593,15 +2595,15 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
continue;
/// add SP to the list
- data.SP_ITK[Nt] = (*iter_otherSP);
- data.SP_ITK[Nt]->setDZDR(dZdR);
+ data.ITkSP[Nt] = (*iter_otherSP);
+ data.ITkSP[Nt]->setDZDR(dZdR);
/// if we are exceeding the SP capacity of our data object,
/// make it resize its vectors. Will add 50 slots by default,
/// so rarely should happen more than once per event.
if (++Nt == SPcapacity)
{
data.resizeSPCont();
- SPcapacity = data.SP_ITK.size();
+ SPcapacity = data.ITkSP.size();
}
} ///< end of loop over SP within top candidate cell
} ///< end of loop over top candidate cells
@@ -2647,15 +2649,15 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
if (std::abs(dz) > m_dzmaxSSS || std::abs(z0) > zmax)
continue;
/// found a bottom SP candidate, write it into the data object
- data.SP_ITK[Nb] = (*iter_otherSP);
- data.SP_ITK[Nb]->setDZDR(dZdR);
+ data.ITkSP[Nb] = (*iter_otherSP);
+ data.ITkSP[Nb]->setDZDR(dZdR);
/// if we are exceeding the SP capacity of our data object,
/// make it resize its vectors. Will add 50 slots by default,
/// so rarely should happen more than once per event.
if (++Nb == SPcapacity)
{
data.resizeSPCont();
- SPcapacity = data.SP_ITK.size();
+ SPcapacity = data.ITkSP.size();
}
} ///< end of loop over SP in bottom candidate cell
} ///< end of loop over bottom candidate cells
@@ -2677,7 +2679,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
for (size_t i = 0; i < Nb; ++i)
{
- InDet::SiSpacePointForSeedITK *sp = data.SP_ITK[i];
+ SiSpacePointForSeed *sp = data.ITkSP[i];
/// transform the space point coordinates into a frame centered around the middle SP,
/// where the x axis points away from the detector frame origin
@@ -2712,7 +2714,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
}
data.nOneSeeds = 0;
- data.mapOneSeeds_ITK.clear();
+ data.ITkMapOneSeeds.clear();
/// Three space points comparison
/// first, loop over the bottom point candidates
@@ -2787,7 +2789,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
float Sb = A0 + B0 * data.X[b];
float db[3] = {Sx * Cb - Sy * Sb, Sx * Sb + Sy * Cb, Cn};
float rb[3];
- if (!data.SP_ITK[b]->coordinates(db, rb))
+ if (!data.ITkSP[b]->coordinates(db, rb))
continue;
// Top point
@@ -2796,7 +2798,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
float St = A0 + B0 * data.X[t];
float dt[3] = {Sx * Ct - Sy * St, Sx * St + Sy * Ct, Cn};
float rt[3];
- if (!data.SP_ITK[t]->coordinates(dt, rt))
+ if (!data.ITkSP[t]->coordinates(dt, rt))
continue;
float xb = rb[0] - rn[0];
@@ -2893,31 +2895,31 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
/// obtain a quality score - start from the d0 estimate, and add
/// a penalty term corresponding to how far the seed segments
/// deviate from a straight line in r-z
- data.SP_ITK[t]->setScorePenalty(std::abs((tb - tz) / (dr * sTzb2)));
- data.SP_ITK[t]->setParam(d0);
+ data.ITkSP[t]->setScorePenalty(std::abs((tb - tz) / (dr * sTzb2)));
+ data.ITkSP[t]->setParam(d0);
float DR = xt * xt + yt * yt + zt * zt; // distance between top and central SP
- data.SP_ITK[t]->setDR(DR);
+ data.ITkSP[t]->setDR(DR);
if (meanOneOverTanTheta < 1e-8)
meanOneOverTanTheta = 1e-8;
if (BSquare < 1e-8)
BSquare = 1e-8;
float theta = std::atan(1. / meanOneOverTanTheta);
- data.SP_ITK[t]->setEta(-std::log(std::tan(0.5 * theta)));
- data.SP_ITK[t]->setPt(std::sqrt(onePlusAsquare / BSquare) / (1000 * data.K));
+ data.ITkSP[t]->setEta(-std::log(std::tan(0.5 * theta)));
+ data.ITkSP[t]->setPt(std::sqrt(onePlusAsquare / BSquare) / (1000 * data.K));
/// record one possible seed candidate, sort by the curvature
- data.CmSp_ITK.emplace_back(std::make_pair(B / std::sqrt(onePlusAsquare), data.SP_ITK[t]));
+ data.ITkCmSp.emplace_back(std::make_pair(B / std::sqrt(onePlusAsquare), data.ITkSP[t]));
/// store the transverse IP, will later be used as a quality estimator
- if (data.CmSp_ITK.size() == 500)
+ if (data.ITkCmSp.size() == 500)
break;
}
} ///< end loop over top space point candidates
/// now apply further cleaning on the seed candidates for this central+bottom pair.
- if (!data.CmSp_ITK.empty())
+ if (!data.ITkCmSp.empty())
{
- newOneSeedWithCurvaturesComparisonSSS(data, data.SP_ITK[b], (*iter_centralSP), Zob);
+ newOneSeedWithCurvaturesComparisonSSS(data, data.ITkSP[b], (*iter_centralSP), Zob);
}
} ///< end loop over bottom space points
///record seeds found in this run
@@ -2931,17 +2933,17 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpSSS(EventData &data,
// Production 3 space points seeds in ROI
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &rb,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &rbe,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &rt,
- std::array<std::list<InDet::SiSpacePointForSeedITK *>::iterator, arraySizeNeighbourBins> &rte,
- const int numberBottomCells, const int numberTopCells, int &nseed) const
+void SiSpacePointsSeedMaker::production3SpTrigger(EventData &data,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &rb,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &rbe,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &rt,
+ std::array<std::list<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> &rte,
+ const int numberBottomCells, const int numberTopCells, int &nseed) const
{
- std::list<InDet::SiSpacePointForSeedITK *>::iterator r0 = rb[0], r;
+ std::list<SiSpacePointForSeed *>::iterator r0 = rb[0], r;
if (!data.endlist)
{
- r0 = data.rMin_ITK;
+ r0 = data.ITk_rMin;
data.endlist = true;
}
@@ -2953,14 +2955,14 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
float imaxp = m_maxdImpact;
float imaxs = m_maxdImpactSSS;
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
// Loop through all trigger space points
//
for (; r0 != rbe[0]; ++r0)
{
data.nOneSeeds = 0;
- data.mapOneSeeds_ITK.clear();
+ data.ITkMapOneSeeds.clear();
float R = (*r0)->radius();
@@ -2993,7 +2995,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
float Zu = Z + (550.f - R) * Tz;
if (Zu < data.zminU || Zu > data.zmaxU)
continue;
- data.SP_ITK[Nb] = (*r);
+ data.ITkSP[Nb] = (*r);
if (++Nb == m_maxsizeSP)
goto breakb;
}
@@ -3032,7 +3034,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
float Zu = Z + (550.f - R) * Tz;
if (Zu < data.zminU || Zu > data.zmaxU)
continue;
- data.SP_ITK[Nt] = (*r);
+ data.ITkSP[Nt] = (*r);
if (++Nt == m_maxsizeSP)
goto breakt;
}
@@ -3049,7 +3051,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
for (int i = 0; i < Nt; ++i)
{
- InDet::SiSpacePointForSeedITK *sp = data.SP_ITK[i];
+ SiSpacePointForSeed *sp = data.ITkSP[i];
float dx = sp->x() - X;
float dy = sp->y() - Y;
@@ -3089,7 +3091,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
float CSA = Tzb2 * COFK;
float ICSA = Tzb2 * ipt2C;
float imax = imaxp;
- if (data.SP_ITK[b]->spacepoint->clusterList().second)
+ if (data.ITkSP[b]->spacepoint->clusterList().second)
imax = imaxs;
for (int t = Nb; t != Nt; ++t)
@@ -3120,12 +3122,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
df = pi2 - df;
if (df > data.ftrigW)
continue;
- data.CmSp_ITK.emplace_back(std::make_pair(B / std::sqrt(S2), data.SP_ITK[t]));
- data.SP_ITK[t]->setParam(Im);
+ data.ITkCmSp.emplace_back(std::make_pair(B / std::sqrt(S2), data.ITkSP[t]));
+ data.ITkSP[t]->setParam(Im);
}
- if (!data.CmSp_ITK.empty())
+ if (!data.ITkCmSp.empty())
{
- newOneSeedWithCurvaturesComparison(data, data.SP_ITK[b], (*r0), Zob);
+ newOneSeedWithCurvaturesComparison(data, data.ITkSP[b], (*r0), Zob);
}
}
fillSeeds(data);
@@ -3134,7 +3136,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
{
data.endlist = false;
++r0;
- data.rMin_ITK = r0;
+ data.ITk_rMin = r0;
return;
}
}
@@ -3144,16 +3146,16 @@ void InDet::SiSpacePointsSeedMaker_ITK::production3SpTrigger(EventData &data,
// New 3 space points pro seeds
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newOneSeed(EventData &data,
- InDet::SiSpacePointForSeedITK *&p1, InDet::SiSpacePointForSeedITK *&p2,
- InDet::SiSpacePointForSeedITK *&p3, float z, float seedCandidateQuality) const
+void SiSpacePointsSeedMaker::newOneSeed(EventData &data,
+ SiSpacePointForSeed *&p1, SiSpacePointForSeed *&p2,
+ SiSpacePointForSeed *&p3, float z, float seedCandidateQuality) const
{
/// get the worst seed so far
float worstQualityInMap = std::numeric_limits<float>::min();
- InDet::SiSpacePointsProSeedITK *worstSeedSoFar = nullptr;
- if (!data.mapOneSeeds_ITK.empty())
+ SiSpacePointsProSeed *worstSeedSoFar = nullptr;
+ if (!data.ITkMapOneSeeds.empty())
{
- std::multimap<float, InDet::SiSpacePointsProSeedITK *>::reverse_iterator l = data.mapOneSeeds_ITK.rbegin();
+ std::multimap<float, SiSpacePointsProSeed *>::reverse_iterator l = data.ITkMapOneSeeds.rbegin();
worstQualityInMap = (*l).first;
worstSeedSoFar = (*l).second;
}
@@ -3167,8 +3169,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeed(EventData &data,
///and the new seed of higher quality than the worst one so far, with the latter however being confirmed
|| (m_useSeedConfirmation && data.keepAllConfirmedSeeds && worstQualityInMap > seedCandidateQuality && isConfirmedSeed(worstSeedSoFar->spacepoint0(), worstSeedSoFar->spacepoint2(), worstQualityInMap) && data.nOneSeeds < data.seedPerSpCapacity))
{
- data.OneSeeds_ITK[data.nOneSeeds].set(p1, p2, p3, z);
- data.mapOneSeeds_ITK.insert(std::make_pair(seedCandidateQuality, &data.OneSeeds_ITK[data.nOneSeeds]));
+ data.ITkOneSeeds[data.nOneSeeds].set(p1, p2, p3, z);
+ data.ITkMapOneSeeds.insert(std::make_pair(seedCandidateQuality, &data.ITkOneSeeds[data.nOneSeeds]));
++data.nOneSeeds;
}
@@ -3178,14 +3180,14 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeed(EventData &data,
/// Overwrite the parameters of the worst seed with the new one
worstSeedSoFar->set(p1, p2, p3, z);
/// re-insert it with its proper quality to make sure it ends up in the right place
- std::multimap<float, InDet::SiSpacePointsProSeedITK *>::iterator
- i = data.mapOneSeeds_ITK.insert(std::make_pair(seedCandidateQuality, worstSeedSoFar));
+ std::multimap<float, SiSpacePointsProSeed *>::iterator
+ i = data.ITkMapOneSeeds.insert(std::make_pair(seedCandidateQuality, worstSeedSoFar));
/// and remove the entry with the old quality to avoid duplicates
- for (++i; i != data.mapOneSeeds_ITK.end(); ++i)
+ for (++i; i != data.ITkMapOneSeeds.end(); ++i)
{
if ((*i).second == worstSeedSoFar)
{
- data.mapOneSeeds_ITK.erase(i);
+ data.ITkMapOneSeeds.erase(i);
return;
}
}
@@ -3196,14 +3198,14 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeed(EventData &data,
// New 3 space points pro seeds production
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparison(EventData &data, SiSpacePointForSeedITK *&SPb, SiSpacePointForSeedITK *&SP0, float Zob) const
+void SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparison(EventData &data, SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
{
const float dC = .00003;
bool pixb = !SPb->spacepoint->clusterList().second;
- std::sort(data.CmSp_ITK.begin(), data.CmSp_ITK.end(), comCurvatureITK());
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator j, jn, i = data.CmSp_ITK.begin(), ie = data.CmSp_ITK.end();
+ std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator j, jn, i = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
jn = i;
for (; i != ie; ++i)
@@ -3271,25 +3273,25 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparison(Event
newOneSeed(data, SPb, SP0, (*i).second, Zob, u);
}
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
}
///////////////////////////////////////////////////////////////////
// Fill seeds
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::fillSeeds(EventData &data)
+void SiSpacePointsSeedMaker::fillSeeds(EventData &data)
{
data.fillOneSeeds = 0;
- std::multimap<float, InDet::SiSpacePointsProSeedITK *>::iterator it_seedCandidate = data.mapOneSeeds_ITK.begin();
- std::multimap<float, InDet::SiSpacePointsProSeedITK *>::iterator it_endSeedCandidates = data.mapOneSeeds_ITK.end();
+ std::multimap<float, SiSpacePointsProSeed *>::iterator it_seedCandidate = data.ITkMapOneSeeds.begin();
+ std::multimap<float, SiSpacePointsProSeed *>::iterator it_endSeedCandidates = data.ITkMapOneSeeds.end();
/// no seeds - nothing to do.
if (it_seedCandidate == it_endSeedCandidates)
return;
- SiSpacePointsProSeedITK *theSeed{nullptr};
+ SiSpacePointsProSeed *theSeed{nullptr};
/// loop over the seed candidates we have stored in the event data
for (; it_seedCandidate != it_endSeedCandidates; ++it_seedCandidate)
@@ -3304,24 +3306,24 @@ void InDet::SiSpacePointsSeedMaker_ITK::fillSeeds(EventData &data)
continue;
/// if we have space, write the seed directly into an existing slot
- if (data.i_seede_ITK != data.l_seeds_ITK.end())
+ if (data.i_ITkSeedEnd != data.i_ITkSeeds.end())
{
- theSeed = &(*data.i_seede_ITK++);
+ theSeed = &(*data.i_ITkSeedEnd++);
*theSeed = *(*it_seedCandidate).second;
}
else
{
/// otherwise, extend the seed list and update the iterators
- data.l_seeds_ITK.emplace_back(SiSpacePointsProSeedITK(*(*it_seedCandidate).second));
- theSeed = &(data.l_seeds_ITK.back());
- data.i_seede_ITK = data.l_seeds_ITK.end();
+ data.i_ITkSeeds.emplace_back(SiSpacePointsProSeed(*(*it_seedCandidate).second));
+ theSeed = &(data.i_ITkSeeds.back());
+ data.i_ITkSeedEnd = data.i_ITkSeeds.end();
}
++data.fillOneSeeds;
} ///< end loop over seed candidates
}
-const InDet::SiSpacePointsSeed *InDet::SiSpacePointsSeedMaker_ITK::next(const EventContext &, EventData &data) const
+const InDet::SiSpacePointsSeed *SiSpacePointsSeedMaker::next(const EventContext &, EventData &data) const
{
/// This only holds if we call next() without manually calling newEvent/find3Sp
if (not data.initialized)
@@ -3332,7 +3334,7 @@ const InDet::SiSpacePointsSeed *InDet::SiSpacePointsSeedMaker_ITK::next(const Ev
do
{
/// If we are out of seeds, call findNext to see if we can find more.
- if (data.i_seed_ITK == data.i_seede_ITK)
+ if (data.i_ITkSeed == data.i_ITkSeedEnd)
{
/// findNext will call production3Sp again IF data.endlist is false,
/// which is only the case if the last run of production3Sp did not run to the end
@@ -3340,30 +3342,30 @@ const InDet::SiSpacePointsSeed *InDet::SiSpacePointsSeedMaker_ITK::next(const Ev
/// For run-3 offline, this will not do anything.
findNext(data);
/// if no new seeds were found, exit
- if (data.i_seed_ITK == data.i_seede_ITK)
+ if (data.i_ITkSeed == data.i_ITkSeedEnd)
return nullptr;
}
/// iterate until we find a valid seed satisfying certain quality cuts in set3
- } while (!(*data.i_seed_ITK++).set3(data.seedOutput));
+ } while (!(*data.i_ITkSeed++).set3(data.seedOutput));
/// then return this next seed candidate
return &data.seedOutput;
}
else
{
/// same as above for 2SP
- if (data.i_seed_ITK == data.i_seede_ITK)
+ if (data.i_ITkSeed == data.i_ITkSeedEnd)
{
findNext(data);
- if (data.i_seed_ITK == data.i_seede_ITK)
+ if (data.i_ITkSeed == data.i_ITkSeedEnd)
return nullptr;
}
- (*data.i_seed_ITK++).set2(data.seedOutput);
+ (*data.i_ITkSeed++).set2(data.seedOutput);
return &data.seedOutput;
}
return nullptr;
}
-bool InDet::SiSpacePointsSeedMaker_ITK::isZCompatible(EventData &data, float &Zv, float &R, float &T) const
+bool SiSpacePointsSeedMaker::isZCompatible(EventData &data, float &Zv, float &R, float &T) const
{
if (Zv < data.zminU || Zv > data.zmaxU)
return false;
@@ -3385,16 +3387,16 @@ bool InDet::SiSpacePointsSeedMaker_ITK::isZCompatible(EventData &data, float &Zv
// New space point for seeds
///////////////////////////////////////////////////////////////////
-InDet::SiSpacePointForSeedITK *InDet::SiSpacePointsSeedMaker_ITK::newSpacePoint(EventData &data, const Trk::SpacePoint *const &sp) const
+SiSpacePointForSeed *SiSpacePointsSeedMaker::newSpacePoint(EventData &data, const Trk::SpacePoint *const &sp) const
{
float r[15];
return newSpacePoint(data, sp, r, true);
}
-InDet::SiSpacePointForSeedITK *InDet::SiSpacePointsSeedMaker_ITK::newSpacePoint(EventData &data, const Trk::SpacePoint *const &sp, float *r, bool usePixStripInform) const
+SiSpacePointForSeed *SiSpacePointsSeedMaker::newSpacePoint(EventData &data, const Trk::SpacePoint *const &sp, float *r, bool usePixStripInform) const
{
- InDet::SiSpacePointForSeedITK *sps = nullptr;
+ SiSpacePointForSeed *sps = nullptr;
/// r will store the coordinates of the space point relative
/// to the beam spot
@@ -3430,10 +3432,10 @@ InDet::SiSpacePointForSeedITK *InDet::SiSpacePointsSeedMaker_ITK::newSpacePoint(
/// If we have previously populated the list and just reset
/// the iterator when re-initialising the data object,
/// then we re-use existing entries
- if (data.i_spforseed_ITK != data.l_spforseed_ITK.end())
+ if (data.i_ITkSpacePointForSeed != data.l_ITkSpacePointForSeed.end())
{
/// re-use existing entry at the current location
- sps = &(*data.i_spforseed_ITK++);
+ sps = &(*data.i_ITkSpacePointForSeed++);
/// and then update the existing entry with the new SP and location.
/// Unfortunately, set still relies on C-arrays...
sps->set(sp, r);
@@ -3441,11 +3443,11 @@ InDet::SiSpacePointForSeedITK *InDet::SiSpacePointsSeedMaker_ITK::newSpacePoint(
else
{
/// otherwise, the list needs to grow
- data.l_spforseed_ITK.emplace_back(InDet::SiSpacePointForSeedITK(sp, &(r[0])));
+ data.l_ITkSpacePointForSeed.emplace_back(SiSpacePointForSeed(sp, &(r[0])));
/// set our return pointer
- sps = &(data.l_spforseed_ITK.back());
+ sps = &(data.l_ITkSpacePointForSeed.back());
/// and make sure to update the iterator
- data.i_spforseed_ITK = data.l_spforseed_ITK.end();
+ data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.end();
}
return sps;
@@ -3455,29 +3457,29 @@ InDet::SiSpacePointForSeedITK *InDet::SiSpacePointsSeedMaker_ITK::newSpacePoint(
// New 2 space points seeds
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newSeed(EventData &data,
- InDet::SiSpacePointForSeedITK *&p1, InDet::SiSpacePointForSeedITK *&p2, float z)
+void SiSpacePointsSeedMaker::newSeed(EventData &data,
+ SiSpacePointForSeed *&p1, SiSpacePointForSeed *&p2, float z)
{
- InDet::SiSpacePointForSeedITK *p3 = nullptr;
+ SiSpacePointForSeed *p3 = nullptr;
- if (data.i_seede_ITK != data.l_seeds_ITK.end())
+ if (data.i_ITkSeedEnd != data.i_ITkSeeds.end())
{
- InDet::SiSpacePointsProSeedITK *s = &(*data.i_seede_ITK++);
+ SiSpacePointsProSeed *s = &(*data.i_ITkSeedEnd++);
s->set(p1, p2, p3, z);
}
else
{
- data.l_seeds_ITK.emplace_back(InDet::SiSpacePointsProSeedITK(p1, p2, p3, z));
- data.i_seede_ITK = data.l_seeds_ITK.end();
+ data.i_ITkSeeds.emplace_back(SiSpacePointsProSeed(p1, p2, p3, z));
+ data.i_ITkSeedEnd = data.i_ITkSeeds.end();
}
}
-void InDet::SiSpacePointsSeedMaker_ITK::initializeEventData(EventData &data) const
+void SiSpacePointsSeedMaker::initializeEventData(EventData &data) const
{
int seedArrayPerSPSize = (m_maxOneSizePPP > m_maxOneSizeSSS ? m_maxOneSizePPP : m_maxOneSizeSSS);
if (m_alwaysKeepConfirmedStripSeeds || m_alwaysKeepConfirmedPixelSeeds)
seedArrayPerSPSize = 50;
- data.initialize(EventData::ITK,
+ data.initialize(EventData::ToolType::ITk,
m_maxsizeSP,
seedArrayPerSPSize,
0, /// maxsize not used
@@ -3492,8 +3494,8 @@ void InDet::SiSpacePointsSeedMaker_ITK::initializeEventData(EventData &data) con
// New 3 space points pro seeds production
///////////////////////////////////////////////////////////////////
-void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSSS(EventData &data,
- SiSpacePointForSeedITK *&SPb, SiSpacePointForSeedITK *&SP0, float Zob) const
+void SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonSSS(EventData &data,
+ SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
{
if (m_useSeedConfirmation)
@@ -3507,12 +3509,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSSS(Ev
static const float curvatureInterval = .00003;
/// sort common SP by curvature
- if (data.CmSp_ITK.size() > 2)
- std::sort(data.CmSp_ITK.begin(), data.CmSp_ITK.end(), comCurvatureITK());
+ if (data.ITkCmSp.size() > 2)
+ std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_otherSP;
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_commonTopSP = data.CmSp_ITK.begin(), ie = data.CmSp_ITK.end();
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_startInnerLoop = it_commonTopSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;
float Lt[4];
@@ -3520,7 +3522,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSSS(Ev
for (; it_commonTopSP != ie; ++it_commonTopSP)
{
- SiSpacePointForSeedITK *SPt = (*it_commonTopSP).second;
+ SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
int NT = 1;
Lt[0] = SPt->dR();
float seedIP = SPt->param();
@@ -3568,19 +3570,19 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSSS(Ev
}
}
- // ITK seed quality used so far
+ // ITk seed quality used so far
float Q = seedIP - float(NT) * 100.;
if (NT > 2)
Q -= 100000.;
/// this is a good seed, save it (unless we have too many seeds per SP)
newOneSeed(data, SPb, SP0, SPt, Zob, Q);
} ///< end of loop over top SP candidates
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
}
}
-void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonPPP(EventData &data,
- SiSpacePointForSeedITK *&SPb, SiSpacePointForSeedITK *&SP0, float Zob) const
+void SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonPPP(EventData &data,
+ SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
{
if (m_useSeedConfirmation)
@@ -3594,12 +3596,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonPPP(Ev
static const float curvatureInterval = .00003;
/// sort common SP by curvature
- if (data.CmSp_ITK.size() > 2)
- std::sort(data.CmSp_ITK.begin(), data.CmSp_ITK.end(), comCurvatureITK());
+ if (data.ITkCmSp.size() > 2)
+ std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_otherSP;
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_commonTopSP = data.CmSp_ITK.begin(), ie = data.CmSp_ITK.end();
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_startInnerLoop = it_commonTopSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;
float Lt[4];
@@ -3608,14 +3610,14 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonPPP(Ev
int NTc(2);
if (Rb > 280.)
NTc = 1;
- SiSpacePointForSeedITK *SPmin = nullptr;
+ SiSpacePointForSeed *SPmin = nullptr;
bool Qm = Rb < 120. || std::abs(Zob) > 150.;
/// check all possible common top SP
for (; it_commonTopSP != ie; ++it_commonTopSP)
{
- SiSpacePointForSeedITK *SPt = (*it_commonTopSP).second;
+ SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
int NT = 1;
Lt[0] = SPt->dR();
float seedIP = SPt->param();
@@ -3669,7 +3671,7 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonPPP(Ev
if (Qm && !dN && seedIP > 1.)
continue;
- // ITK seed quality used so far
+ // ITk seed quality used so far
float Q = 100. * seedIP + (std::abs(Zob) - float(NT) * 100.);
if (Q > SPb->quality() && Q > SP0->quality() && Q > SPt->quality())
continue;
@@ -3684,12 +3686,12 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonPPP(Ev
} ///< end of loop over top SP candidates
if (SPmin && !data.nOneSeeds)
newOneSeed(data, SPb, SP0, SPmin, Zob, Qmin);
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
}
}
-void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSeedConfirmation(EventData &data,
- SiSpacePointForSeedITK *&SPb, SiSpacePointForSeedITK *&SP0, float Zob) const
+void SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonSeedConfirmation(EventData &data,
+ SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
{
static const float curvatureInterval = .00003;
bool bottomSPisPixel = !SPb->spacepoint->clusterList().second;
@@ -3697,21 +3699,21 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSeedCo
float centralSPQuality = SP0->quality();
/// sort common SP by curvature
- if (data.CmSp_ITK.size() > 2)
- std::sort(data.CmSp_ITK.begin(), data.CmSp_ITK.end(), comCurvatureITK());
+ if (data.ITkCmSp.size() > 2)
+ std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
float bottomR = SPb->radius();
float bottomZ = SPb->z();
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_otherSP;
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_commonTopSP = data.CmSp_ITK.begin(), ie = data.CmSp_ITK.end();
- std::vector<std::pair<float, InDet::SiSpacePointForSeedITK *>>::iterator it_startInnerLoop = it_commonTopSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
+ std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;
/// check all possible common top SP
for (; it_commonTopSP != ie; ++it_commonTopSP)
{
- SiSpacePointForSeedITK *SPt = (*it_commonTopSP).second;
+ SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
/// the seed quality is set to d0 initially
float seedIP = SPt->param();
float seedQuality = seedIP + SPt->scorePenalty();
@@ -3823,11 +3825,11 @@ void InDet::SiSpacePointsSeedMaker_ITK::newOneSeedWithCurvaturesComparisonSeedCo
/// this is a good seed, save it (unless we have too many seeds per SP)
newOneSeed(data, SPb, SP0, SPt, Zob, seedQuality);
} ///< end of loop over top SP candidates
- data.CmSp_ITK.clear();
+ data.ITkCmSp.clear();
}
-bool InDet::SiSpacePointsSeedMaker_ITK::isConfirmedSeed(const InDet::SiSpacePointForSeedITK *bottomSP,
- const InDet::SiSpacePointForSeedITK *topSP, float quality) const
+bool SiSpacePointsSeedMaker::isConfirmedSeed(const SiSpacePointForSeed *bottomSP,
+ const SiSpacePointForSeed *topSP, float quality) const
{
/// SSS seeds
@@ -3845,7 +3847,7 @@ bool InDet::SiSpacePointsSeedMaker_ITK::isConfirmedSeed(const InDet::SiSpacePoin
return (quality < 0.);
}
-void InDet::SiSpacePointsSeedMaker_ITK::writeNtuple(const SiSpacePointsSeed* seed, const Trk::Track* track, int seedType, long eventNumber) const
+void SiSpacePointsSeedMaker::writeNtuple(const InDet::SiSpacePointsSeed* seed, const Trk::Track* track, int seedType, long eventNumber) const
{
if(m_writeNtuple) {
std::lock_guard<std::mutex> lock(m_mutex);
@@ -3886,7 +3888,9 @@ void InDet::SiSpacePointsSeedMaker_ITK::writeNtuple(const SiSpacePointsSeed* see
}
-bool InDet::SiSpacePointsSeedMaker_ITK::getWriteNtupleBoolProperty() const
+bool SiSpacePointsSeedMaker::getWriteNtupleBoolProperty() const
{
return m_writeNtuple;
}
+
+} // namespace ITk
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ATLxk.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ATLxk.cxx
index e6e97bc9731039bf489e0f97dc1220b2ef30455a..d1b4ccd4092c22135b74280bfd04f1d21c76d78e 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ATLxk.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_ATLxk.cxx
@@ -2649,7 +2649,7 @@ void InDet::SiSpacePointsSeedMaker_ATLxk::newSeed
void InDet::SiSpacePointsSeedMaker_ATLxk::initializeEventData(EventData& data) const {
int seedArrayPerSPSize = (m_maxOneSizePPP>m_maxOneSizeSSS ? m_maxOneSizePPP : m_maxOneSizeSSS);
if (m_alwaysKeepConfirmedStripSeeds || m_alwaysKeepConfirmedPixelSeeds) seedArrayPerSPSize = 50;
- data.initialize(EventData::ATLxk,
+ data.initialize(EventData::ToolType::ATLxk,
m_maxsizeSP,
seedArrayPerSPSize,
0, /// maxsize not used
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_BeamGas.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_BeamGas.cxx
index 485ef3474767f674682ecadf503b67d861554279..e1cacaf0114d80d3e0ec9ddbab747d901b01ee5c 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_BeamGas.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_BeamGas.cxx
@@ -1208,7 +1208,7 @@ void InDet::SiSpacePointsSeedMaker_BeamGas::fillSeeds(EventData& data)
}
void InDet::SiSpacePointsSeedMaker_BeamGas::initializeEventData(EventData& data) const {
- data.initialize(EventData::BeamGas,
+ data.initialize(EventData::ToolType::BeamGas,
m_maxsizeSP,
m_maxOneSize,
0, // maxsize not used
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Cosmic.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Cosmic.cxx
index 7f11db239b256bfa85b19b37b16f3b2f10bc3f41..6dce87861e377ff99793086d405b035b3ff2db73 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Cosmic.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Cosmic.cxx
@@ -1152,7 +1152,7 @@ void InDet::SiSpacePointsSeedMaker_Cosmic::newSeed
}
void InDet::SiSpacePointsSeedMaker_Cosmic::initializeEventData(EventData& data) const {
- data.initialize(EventData::Cosmic,
+ data.initialize(EventData::ToolType::Cosmic,
m_maxsizeSP,
0, // maxOneSize not used
m_maxsize,
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_HeavyIon.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_HeavyIon.cxx
index adb5c365aa9b03b1bf834e406dd793accc97f6a5..c01db444143a411cbdf948e962a3e75537f7b9b9 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_HeavyIon.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_HeavyIon.cxx
@@ -1735,7 +1735,7 @@ void InDet::SiSpacePointsSeedMaker_HeavyIon::fillSeeds(EventData& data)
}
void InDet::SiSpacePointsSeedMaker_HeavyIon::initializeEventData(EventData& data) const {
- data.initialize(EventData::HeavyIon,
+ data.initialize(EventData::ToolType::HeavyIon,
m_maxsizeSP,
m_maxOneSize,
0, // maxsize not used
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_LowMomentum.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_LowMomentum.cxx
index 7b22d5b1782c8ff3860657995987af9dc9c50133..1cda3fd8fee3095c64d4d8a5b487c057bd5e8752 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_LowMomentum.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_LowMomentum.cxx
@@ -1176,7 +1176,7 @@ void InDet::SiSpacePointsSeedMaker_LowMomentum::fillSeeds(EventData& data)
}
void InDet::SiSpacePointsSeedMaker_LowMomentum::initializeEventData(EventData& data) const {
- data.initialize(EventData::LowMomentum,
+ data.initialize(EventData::ToolType::LowMomentum,
m_maxsizeSP,
m_maxOneSize,
0, // maxsize not used
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Trigger.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Trigger.cxx
index 58ad68106c0d98c612d0462483aa00925aaafc22..eeed91aa6f9986258fa789254e81a9bbddd5a123 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Trigger.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/SiSpacePointsSeedMaker_Trigger.cxx
@@ -1656,7 +1656,7 @@ void InDet::SiSpacePointsSeedMaker_Trigger::fillSeeds(EventData& data)
}
void InDet::SiSpacePointsSeedMaker_Trigger::initializeEventData(EventData& data) const {
- data.initialize(EventData::Trigger,
+ data.initialize(EventData::ToolType::Trigger,
m_maxsizeSP,
m_maxOneSize,
0, // maxsize not used
diff --git a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/components/SiSpacePointsSeedTool_xk_entries.cxx b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/components/SiSpacePointsSeedTool_xk_entries.cxx
index 899ae675335f1d47f6ff32cbecb25bd300938e11..65674fcf77626e3a25ea9b1c5a1b7ffc18ccd7a7 100644
--- a/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/components/SiSpacePointsSeedTool_xk_entries.cxx
+++ b/InnerDetector/InDetRecTools/SiSpacePointsSeedTool_xk/src/components/SiSpacePointsSeedTool_xk_entries.cxx
@@ -4,7 +4,7 @@
#include "SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_Cosmic.h"
#include "SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_HeavyIon.h"
#include "SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_Trigger.h"
-#include "SiSpacePointsSeedTool_xk/SiSpacePointsSeedMaker_ITK.h"
+#include "SiSpacePointsSeedTool_xk/ITkSiSpacePointsSeedMaker.h"
using namespace InDet;
@@ -14,5 +14,5 @@ DECLARE_COMPONENT( SiSpacePointsSeedMaker_BeamGas )
DECLARE_COMPONENT( SiSpacePointsSeedMaker_Cosmic )
DECLARE_COMPONENT( SiSpacePointsSeedMaker_HeavyIon )
DECLARE_COMPONENT( SiSpacePointsSeedMaker_Trigger )
-DECLARE_COMPONENT( SiSpacePointsSeedMaker_ITK )
+DECLARE_COMPONENT( ITk::SiSpacePointsSeedMaker )