diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 2af30ad112b69c7b1fd5a31a6845500a46cda489..6370f91f5351306512031f993b5715b1b5986c33 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -25,9 +25,9 @@ build_image:
- mkdir build
- cd build
- set +e && source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh; set -e
- - set +e && asetup master,latest,Athena; set -e
- - cmake ../../calypso
- - make
+ - set +e && asetup --input=../../calypso/asetup.faser master,latest,Athena; set -e
+ - cmake ../../calypso
+ - make -j
artifacts:
paths:
- build/
@@ -41,8 +41,8 @@ test_unittest:
- yum -y install man
- cd build
- set +e && source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh; set -e
- - set +e && asetup master,latest,Athena; set -e
+ - set +e && asetup --input=../../calypso/asetup.faser master,latest,Athena; set -e
- set +e && source `find . -name 'setup.sh'`; set -e
- - ctest -j12
+ - ctest -j12
dependencies:
- build_image
\ No newline at end of file
diff --git a/Control/CalypsoExample/GeoModelTest/CMakeLists.txt b/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
index 1bed9607b2b71570ad27ed631738c6997ecd7307..b7e6768546809e803338740202f5e167fdbf8df5 100644
--- a/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
+++ b/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
@@ -8,11 +8,15 @@ atlas_subdir( GeoModelTest )
# Declare the package's dependencies:
atlas_depends_on_subdirs( PRIVATE
Control/AthenaBaseComps
+ DetectorDescription/GeoModel/GeoModelSvc
DetectorDescription/GeoModel/GeoModelInterfaces
DetectorDescription/GeoModel/GeoModelUtilities
Scintillator/ScintDetDescr/ScintReadoutGeometry
Tracker/TrackerDetDescr/TrackerReadoutGeometry
MagneticField/MagFieldInterfaces
+ MagneticField/MagFieldConditions
+ MagneticField/MagFieldElements
+ MagneticField/MagFieldServices
Tracker/TrackerAlignTools/TrackerAlignGenTools
)
@@ -24,10 +28,10 @@ atlas_add_component( GeoModelTest
src/GeoModelTestAlg.cxx
src/components/GeoModelTest_entries.cxx
INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
- LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaBaseComps GeoModelUtilities ScintReadoutGeometry TrackerReadoutGeometry MagFieldInterfaces )
+ LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaBaseComps GeoModelUtilities ScintReadoutGeometry TrackerReadoutGeometry MagFieldInterfaces MagFieldElements MagFieldConditions )
atlas_add_test( GeoModelCheck
- SCRIPT python/GeoModelTestConfig.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/python/GeoModelTestConfig.py
PROPERTIES WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
PROPERTIES TIMEOUT 300 )
@@ -35,4 +39,4 @@ atlas_add_test( GeoModelCheck
#atlas_install_headers( GeoModelTest )
#atlas_install_joboptions( share/*.py )
atlas_install_python_modules( python/*.py )
-atlas_install_scripts( scripts/*.sh )
+#atlas_install_scripts( scripts/*.sh )
diff --git a/Control/CalypsoExample/GeoModelTest/README.md b/Control/CalypsoExample/GeoModelTest/README.md
index aebd77fab8ff8e1630370d84ff1beb098337901f..edbed6d9d087abf1565bedacecdee8747cde9964 100644
--- a/Control/CalypsoExample/GeoModelTest/README.md
+++ b/Control/CalypsoExample/GeoModelTest/README.md
@@ -5,8 +5,6 @@ This example package serves several purposes:
* It checks that the expected number of detector elements are created.
-* It generates a set of neutral alignment constants for the Tracker, which can be folded into the conditions database.
-
* It dumps a standalone GeoModel sqlite geometry database which could be used by external programs to display FASER without requiring any FASER software (only GeoModel)
To run the algorithm, in a run directory where Calypso has been installed (displayed below as the command-line prompt `run >`), do
@@ -18,10 +16,3 @@ run > python python/GeoModelTest/GeoModelTestConfig.py
The file `GeoModelTestConfig.py` can be edited to change some run options.
-After running the algorithm, to add the alignment data into your local conditions DB, do:
-
-```
-run > CopyAlignFolder.sh
-```
-
-
diff --git a/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py b/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
index f65f88e3cfbbbea2d058539e2d7c5c7c261cd09f..dac052eb977a427a38bae24daece5ea6a727e497 100644
--- a/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
+++ b/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
@@ -1,6 +1,9 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
#!/usr/bin/env python
import sys
-from AthenaCommon.Constants import VERBOSE, INFO
+# from AthenaCommon.Constants import VERBOSE
+from AthenaConfiguration.ComponentFactory import CompFactory
def GeoModelTestCfg(flags, name="GeoModelTestAlg", **kwargs):
@@ -11,30 +14,31 @@ def GeoModelTestCfg(flags, name="GeoModelTestAlg", **kwargs):
# Initialize field service
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
a.merge(MagneticFieldSvcCfg(flags))
- fieldSvc = a.getService("FaserFieldSvc")
+ # fieldSvc = a.getService("FaserFieldSvc")
# This section is to allow alignment to be written to a conditions DB file
- from IOVDbSvc.IOVDbSvcConfig import IOVDbSvcCfg
- result = IOVDbSvcCfg(flags)
- iovDbSvc = result.getPrimary()
- iovDbSvc.dbConnection="sqlite://;schema=ALLP200.db;dbname=OFLP200"
- a.merge(result)
+ # from IOVDbSvc.IOVDbSvcConfig import IOVDbSvcCfg
+ # result = IOVDbSvcCfg(flags)
+ # iovDbSvc = result.getPrimary()
+ # iovDbSvc.dbConnection="sqlite://;schema=ALLP200.db;dbname=OFLP200"
+ # a.merge(result)
- AthenaPoolCnvSvc=CompFactory.AthenaPoolCnvSvc
- apcs=AthenaPoolCnvSvc()
- a.addService(apcs)
- EvtPersistencySvc=CompFactory.EvtPersistencySvc
- a.addService(EvtPersistencySvc("EventPersistencySvc",CnvServices=[apcs.getFullJobOptName(),]))
+ # AthenaPoolCnvSvc=CompFactory.AthenaPoolCnvSvc
+ # apcs=AthenaPoolCnvSvc()
+ # a.addService(apcs)
+ # EvtPersistencySvc=CompFactory.EvtPersistencySvc
+ # a.addService(EvtPersistencySvc("EventPersistencySvc",CnvServices=[apcs.getFullJobOptName(),]))
- a.addService(CompFactory.IOVRegistrationSvc(PayloadTable=False,OutputLevel=VERBOSE))
+ # a.addService(CompFactory.IOVRegistrationSvc(PayloadTable=False,OutputLevel=VERBOSE))
# Configure the algorithm itself
- from GeoModelTest.GeoModelTestConf import GeoModelTestAlg
- outputTool = CompFactory.AthenaOutputStreamTool("DbStreamTool", OutputFile = "FaserSCT_AlignDb.pool.root")
- alignDbTool = CompFactory.TrackerAlignDBTool("AlignDbTool", OutputTool = outputTool)
+ # from GeoModelTest.GeoModelTestConf import GeoModelTestAlg
+ GeoModelTestAlg = CompFactory.GeoModelTestAlg
+ # outputTool = CompFactory.AthenaOutputStreamTool("DbStreamTool", OutputFile = "FaserSCT_AlignDb.pool.root")
+ # alignDbTool = CompFactory.TrackerAlignDBTool("AlignDbTool", OutputTool = outputTool)
a.addEventAlgo(GeoModelTestAlg(name, **kwargs))
- a.getEventAlgo(name).FieldService = fieldSvc
- a.getEventAlgo(name).AlignDbTool = alignDbTool
+ # a.getEventAlgo(name).FieldService = fieldSvc
+ # a.getEventAlgo(name).AlignDbTool = alignDbTool
return a
@@ -42,7 +46,7 @@ def GeoModelTestCfg(flags, name="GeoModelTestAlg", **kwargs):
if __name__ == "__main__":
# from AthenaCommon.Logging import log, logging
from AthenaCommon.Configurable import Configurable
- from AthenaConfiguration.ComponentFactory import CompFactory
+ # from AthenaConfiguration.ComponentFactory import CompFactory
from CalypsoConfiguration.AllConfigFlags import ConfigFlags
Configurable.configurableRun3Behavior = True
diff --git a/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.cxx b/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.cxx
index 244a631cc255674a379e4a2e994e393de1ca553c..1c57b30825ad74504cbea33f878d29e84baf7aba 100644
--- a/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.cxx
+++ b/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.cxx
@@ -19,7 +19,7 @@
#include "GaudiKernel/PhysicalConstants.h"
GeoModelTestAlg::GeoModelTestAlg(const std::string& name, ISvcLocator* pSvcLocator)
-: AthAlgorithm(name, pSvcLocator), m_numSctStations {0}
+: AthReentrantAlgorithm(name, pSvcLocator), m_numSctStations {0}
{ }
GeoModelTestAlg::~GeoModelTestAlg() { }
@@ -27,12 +27,15 @@ GeoModelTestAlg::~GeoModelTestAlg() { }
StatusCode GeoModelTestAlg::initialize()
{
m_numSctStations = std::max(0, m_lastSctStation - m_firstSctStation + 1);
- ATH_CHECK(m_field.retrieve());
- ATH_CHECK(m_alignTool.retrieve());
+ // ATH_CHECK(m_field.retrieve());
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ATH_CHECK( m_fieldCondObjInputKey.initialize() );
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // ATH_CHECK(m_alignTool.retrieve());
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::execute()
+StatusCode GeoModelTestAlg::execute(const EventContext& ctx) const
{
GeoModelExperiment* theExpt = nullptr;
std::vector<std::string> listOfManagers;
@@ -71,18 +74,30 @@ StatusCode GeoModelTestAlg::execute()
ATH_CHECK(testSCT());
- ATH_CHECK(testField());
+ ATH_CHECK(testField(ctx));
- ATH_CHECK(m_alignTool->createDB());
- ATH_CHECK(m_alignTool->sortTrans());
- ATH_CHECK(m_alignTool->outputObjs());
- ATH_CHECK(m_alignTool->fillDB("",1,0,9999999,9999999));
+ // ATH_CHECK(m_alignTool->createDB());
+ // ATH_CHECK(m_alignTool->sortTrans());
+ // ATH_CHECK(m_alignTool->outputObjs());
+ // ATH_CHECK(m_alignTool->fillDB("",1,0,9999999,9999999));
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::testField()
+StatusCode GeoModelTestAlg::testField(const EventContext& ctx) const
{
+ MagField::FaserFieldCache fieldCache;
+ // Get field cache object
+ SG::ReadCondHandle<FaserFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
+ const FaserFieldCacheCondObj* fieldCondObj{*readHandle};
+
+ if (fieldCondObj == nullptr) {
+ ATH_MSG_ERROR("Failed to retrieve FaserFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
+ return StatusCode::FAILURE;
+ }
+ fieldCondObj->getInitializedCache (fieldCache);
+
+
int iPhi = 0;
const double r = 15.0; // millimeters
for (int z = -1700; z <= 2600; z+=50)
@@ -90,15 +105,16 @@ StatusCode GeoModelTestAlg::testField()
double phi = 15.0 * iPhi++;
double x = r * cos(phi * Gaudi::Units::pi/180.0);
double y = r * sin(phi * Gaudi::Units::pi/180.0);
- Amg::Vector3D pos(x, y, (double)z);
- Amg::Vector3D field(0., 0., 0.);
- m_field->getField(&pos, &field);
- ATH_MSG_ALWAYS("Field at (" << (int) x << "," << (int) y << "," << z << ") = (" << field.x()*1000 << ", " << field.y()*1000 << ", " << field.z()*1000 << ") Tesla");
+
+ double pos[] { x , y, (double)z };
+ double field[] { 0., 0., 0. };
+ fieldCache.getField(pos, field);
+ ATH_MSG_ALWAYS("Field at (" << (int) x << "," << (int) y << "," << z << ") = (" << field[0]*1000 << ", " << field[1]*1000 << ", " << field[2]*1000 << ") Tesla");
}
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::testSCT()
+StatusCode GeoModelTestAlg::testSCT() const
{
// Test retrieval of helper object directly from store
const FaserSCT_ID* helper = nullptr;
@@ -446,7 +462,7 @@ StatusCode GeoModelTestAlg::testSCT()
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::testVeto()
+StatusCode GeoModelTestAlg::testVeto() const
{
// Test retrieval of helper object directly from store
const VetoID* helper = nullptr;
@@ -600,7 +616,7 @@ StatusCode GeoModelTestAlg::testVeto()
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::testTrigger()
+StatusCode GeoModelTestAlg::testTrigger() const
{
// Test retrieval of helper object directly from store
const TriggerID* helper = nullptr;
@@ -754,7 +770,7 @@ StatusCode GeoModelTestAlg::testTrigger()
return StatusCode::SUCCESS;
}
-StatusCode GeoModelTestAlg::testPreshower()
+StatusCode GeoModelTestAlg::testPreshower() const
{
// Test retrieval of helper object directly from store
const PreshowerID* helper = nullptr;
diff --git a/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.h b/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.h
index b15b41f0dd01b3587f5fbc16a4519d1eac305a62..ff5244b175bfaeb49462fc5c1191dd42cbc8d9bd 100644
--- a/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.h
+++ b/Control/CalypsoExample/GeoModelTest/src/GeoModelTestAlg.h
@@ -1,27 +1,36 @@
-#include "AthenaBaseComps/AthAlgorithm.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+// #include "MagFieldInterfaces/IMagFieldSvc.h"
+// #include "TrackerAlignGenTools/ITrackerAlignDBTool.h"
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// MagField cache
+#include "MagFieldConditions/FaserFieldCacheCondObj.h"
+#include "MagFieldElements/FaserFieldCache.h"
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
-#include "MagFieldInterfaces/IMagFieldSvc.h"
-#include "TrackerAlignGenTools/ITrackerAlignDBTool.h"
// Minimalist algorithm to test retrieval of constructed geometry from DetStore
-class GeoModelTestAlg : public AthAlgorithm
+class GeoModelTestAlg : public AthReentrantAlgorithm
{
public:
GeoModelTestAlg(const std::string& name, ISvcLocator* pSvcLocator);
virtual ~GeoModelTestAlg();
- StatusCode initialize();
- StatusCode execute();
- StatusCode finalize();
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
private:
- StatusCode testVeto();
- StatusCode testTrigger();
- StatusCode testPreshower();
- StatusCode testSCT();
- StatusCode testField();
+ StatusCode testVeto() const;
+ StatusCode testTrigger() const;
+ StatusCode testPreshower() const;
+ StatusCode testSCT() const;
+ StatusCode testField(const EventContext& ctx) const;
+
// Independently specify the "right" number of elements, for comparison with what we get from detector store
Gaudi::Property<int> m_numVetoStations {this, "NumVetoStations", 2, "Number of stations in the Veto detector"};
@@ -44,7 +53,11 @@ class GeoModelTestAlg : public AthAlgorithm
Gaudi::Property<int> m_numSctStripsPerSensor {this, "NumSCTStripsPerSensor", 768,"Number of readout strips per sensor in the SCT detector"};
int m_numSctStations;
- ServiceHandle<MagField::IMagFieldSvc> m_field { this, "FieldService", "FaserFieldSvc" };
+ // ServiceHandle<MagField::IMagFieldSvc> m_field { this, "FieldService", "FaserFieldSvc" };
+ // Read handle for conditions object to get the field cache
+ SG::ReadCondHandleKey<FaserFieldCacheCondObj> m_fieldCondObjInputKey {this, "FaserFieldCacheCondObj", "fieldCondObj",
+ "Name of the Magnetic Field conditions object key"};
+
- ToolHandle<ITrackerAlignDBTool> m_alignTool { this, "AlignDbTool", "TrackerAlignDBTool" };
+ // ToolHandle<ITrackerAlignDBTool> m_alignTool { this, "AlignDbTool", "TrackerAlignDBTool" };
};
\ No newline at end of file
diff --git a/Control/CalypsoExample/RDOReadExample/README.md b/Control/CalypsoExample/RDOReadExample/README.md
index 713554db3bf98d63c24ff5f5763ff01ffa8941c5..667e6afc7122a18b5a73f64b6b7690fd6065a795 100644
--- a/Control/CalypsoExample/RDOReadExample/README.md
+++ b/Control/CalypsoExample/RDOReadExample/README.md
@@ -8,7 +8,7 @@ Then find the FaserSiHit corresponding to the particle with the same barcode col
And plots the RDO GroupSize versus the incident angle the particle made when it was detected
-Currently reads from a RDO root file named myRDO.pool.root, which can be generated from the digitization:
+Currently reads from a RDO root file named my.RDO.pool.root, which can be generated from the digitization:
https://gitlab.cern.ch/faser/calypso/tree/master/Tracker/TrackerDigitization/FaserSCT_Digitization
After calypso is installed and compiled & digitization generated
diff --git a/Control/CalypsoExample/RDOReadExample/python/RDOReadExampleConfig.py b/Control/CalypsoExample/RDOReadExample/python/RDOReadExampleConfig.py
index 7e39752325f3a87d391baf6b7664d413e71d9be1..907a7a6753b99d765b7e0825155081067a43a273 100644
--- a/Control/CalypsoExample/RDOReadExample/python/RDOReadExampleConfig.py
+++ b/Control/CalypsoExample/RDOReadExample/python/RDOReadExampleConfig.py
@@ -1,3 +1,5 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
#!/usr/bin/env python
import sys
from AthenaConfiguration.ComponentFactory import CompFactory
@@ -7,27 +9,17 @@ def RDOReadExampleCfg(flags, name="RDOReadExampleAlg", **kwargs):
from FaserGeoModel.FaserGeoModelConfig import FaserGeometryCfg
a = FaserGeometryCfg(flags)
-# from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
-# a.merge(MagneticFieldSvcCfg(flags))
-# fieldSvc = a.getService("FaserFieldSvc")
-
- from RDOReadExample.RDOReadExampleConf import RDOReadAlg
+ RDOReadAlg = CompFactory.RDOReadAlg
a.addEventAlgo(RDOReadAlg(name, **kwargs))
-# a.getEventAlgo(name).FieldService = fieldSvc
thistSvc = CompFactory.THistSvc()
thistSvc.Output += ["HIST DATAFILE='rdoReadHist.root' OPT='RECREATE'"]
a.addService(thistSvc)
-
-
return a
if __name__ == "__main__":
- # from AthenaCommon.Logging import log, logging
- from AthenaCommon.Constants import VERBOSE, INFO
from AthenaCommon.Configurable import Configurable
-
from CalypsoConfiguration.AllConfigFlags import ConfigFlags
Configurable.configurableRun3Behavior = True
@@ -37,7 +29,7 @@ if __name__ == "__main__":
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX" # Needed to bypass autoconfig, only the "OFLCOND" matters at the moment
ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Default FASER geometry
ConfigFlags.Detector.SimulateFaserSCT = True
- ConfigFlags.Input.Files = ["myRDO.pool.root"]
+ ConfigFlags.Input.Files = ["my.RDO.pool.root"]
ConfigFlags.lock()
# Configure components
@@ -48,9 +40,6 @@ if __name__ == "__main__":
# Set things up to create a conditions DB with neutral Tracker alignment transforms
acc.merge(RDOReadExampleCfg(ConfigFlags))
- # acc.addService(CompFactory.IOVRegistrationSvc(PayloadTable=False))
- # acc.getService("IOVRegistrationSvc").OutputLevel = VERBOSE
- # acc.getService("IOVDbSvc").dbConnection = "sqlite://;schema=ALLP200.db;dbname=OFLP200"
# Configure verbosity
# ConfigFlags.dump()
@@ -60,6 +49,4 @@ if __name__ == "__main__":
# log.setLevel(VERBOSE)
# Execute and finish
-
-
sys.exit(int(acc.run(maxEvents=-1).isFailure()))
diff --git a/Control/CalypsoExample/SimHitExample/share/SimHitExample_jobOptions.py b/Control/CalypsoExample/SimHitExample/share/SimHitExample_jobOptions.py
index 6b173f04181f98c411d11efc28905920d5409f44..85285711b027abd54d8704c10e6c569a6f26702b 100644
--- a/Control/CalypsoExample/SimHitExample/share/SimHitExample_jobOptions.py
+++ b/Control/CalypsoExample/SimHitExample/share/SimHitExample_jobOptions.py
@@ -4,7 +4,7 @@ globalflags.InputFormat.set_Value_and_Lock('pool')
import AthenaPoolCnvSvc.ReadAthenaPool
-svcMgr.EventSelector.InputCollections = ["g4.HITS.root"]
+svcMgr.EventSelector.InputCollections = ["my.HITS.pool.root"]
alg = CfgMgr.SimHitAlg()
athAlgSeq += alg
diff --git a/Control/CalypsoExample/WriteAlignment/CMakeLists.txt b/Control/CalypsoExample/WriteAlignment/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb20b727d83346566ce6816dff389a3239df9886
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/CMakeLists.txt
@@ -0,0 +1,38 @@
+################################################################################
+# Package: WriteAlignment
+################################################################################
+
+# Declare the package name:
+atlas_subdir( WriteAlignment )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PRIVATE
+ Control/AthenaBaseComps
+ DetectorDescription/GeoModel/GeoModelSvc
+ DetectorDescription/GeoModel/GeoModelInterfaces
+ DetectorDescription/GeoModel/GeoModelUtilities
+ Scintillator/ScintDetDescr/ScintReadoutGeometry
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ Tracker/TrackerAlignTools/TrackerAlignGenTools
+ )
+
+# External dependencies:
+find_package( GeoModelCore )
+
+# Component(s) in the package:
+atlas_add_component( WriteAlignment
+ src/WriteAlignmentAlg.cxx
+ src/components/WriteAlignment_entries.cxx
+ INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
+ LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaBaseComps GeoModelUtilities ScintReadoutGeometry TrackerReadoutGeometry )
+
+atlas_add_test( WriteAlignmentCheck
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/python/WriteAlignmentConfig.py
+ PROPERTIES WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+ PROPERTIES TIMEOUT 300 )
+
+# Install files from the package:
+#atlas_install_headers( WriteAlignment )
+#atlas_install_joboptions( share/*.py )
+atlas_install_python_modules( python/*.py )
+atlas_install_scripts( scripts/*.sh )
diff --git a/Control/CalypsoExample/WriteAlignment/README.md b/Control/CalypsoExample/WriteAlignment/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..abe557f63283be40452bfec8ae9bf8ca85faa0de
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/README.md
@@ -0,0 +1,29 @@
+This example package serves several purposes:
+
+
+* It illustrates how to initialize and access the detector description.
+
+* It checks that the expected number of detector elements are created.
+
+* It generates a set of neutral alignment constants for the Tracker, which can be folded into the conditions database.
+
+* It dumps a standalone GeoModel sqlite geometry database which could be used by external programs to display FASER without requiring any FASER software (only GeoModel)
+
+This example does NOT setup the magnetic field (see GeoModelTest for that)
+
+To run the algorithm, in a run directory where Calypso has been installed (displayed below as the command-line prompt `run >`), do
+
+```
+run > source ./setup.sh
+run > python python/WriteAlignment/WriteAlignmentConfig.py
+```
+
+The file `WriteAlignmentConfig.py` can be edited to change some run options.
+
+After running the algorithm, to add the alignment data into your local conditions DB, do:
+
+```
+run > CopyAlignFolder.sh
+```
+
+By default, Calypso uses a conditions database installed at /cvmfs/faser.cern.ch, so the end user should not need to generate them
diff --git a/Control/CalypsoExample/WriteAlignment/python/WriteAlignmentConfig.py b/Control/CalypsoExample/WriteAlignment/python/WriteAlignmentConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e99b3973e6b8721e537ffcfe8026fc3f70ec490
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/python/WriteAlignmentConfig.py
@@ -0,0 +1,75 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#!/usr/bin/env python
+import sys
+from AthenaCommon.Constants import VERBOSE
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def WriteAlignmentCfg(flags, name="WriteAlignmentAlg", **kwargs):
+
+ # Initialize GeoModel
+ from FaserGeoModel.FaserGeoModelConfig import FaserGeometryCfg
+ a = FaserGeometryCfg(flags)
+
+ # This section is to allow alignment to be written to a conditions DB file
+ from IOVDbSvc.IOVDbSvcConfig import IOVDbSvcCfg
+ result = IOVDbSvcCfg(flags)
+ iovDbSvc = result.getPrimary()
+ iovDbSvc.dbConnection="sqlite://;schema=ALLP200.db;dbname=OFLP200"
+ a.merge(result)
+
+ AthenaPoolCnvSvc=CompFactory.AthenaPoolCnvSvc
+ apcs=AthenaPoolCnvSvc()
+ a.addService(apcs)
+ EvtPersistencySvc=CompFactory.EvtPersistencySvc
+ a.addService(EvtPersistencySvc("EventPersistencySvc",CnvServices=[apcs.getFullJobOptName(),]))
+
+ a.addService(CompFactory.IOVRegistrationSvc(PayloadTable=False,OutputLevel=VERBOSE))
+
+ # Configure the algorithm itself
+ WriteAlignmentAlg = CompFactory.WriteAlignmentAlg
+ outputTool = CompFactory.AthenaOutputStreamTool("DbStreamTool", OutputFile = "FaserSCT_AlignDb.pool.root")
+ kwargs.setdefault("AlignDbTool", CompFactory.TrackerAlignDBTool("AlignDbTool", OutputTool = outputTool))
+ a.addEventAlgo(WriteAlignmentAlg(name, **kwargs))
+
+ return a
+
+
+if __name__ == "__main__":
+ # from AthenaCommon.Logging import log, logging
+ from AthenaCommon.Configurable import Configurable
+ # from AthenaConfiguration.ComponentFactory import CompFactory
+ from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+
+ Configurable.configurableRun3Behavior = True
+
+# Flags for this job
+ ConfigFlags.Input.isMC = True # Needed to bypass autoconfig
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX" # Needed to bypass autoconfig, only the "OFLCOND" matters at the moment
+ ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Default FASER geometry
+ ConfigFlags.GeoModel.GeoExportFile = "faserGeo.db" # Writes out a GeoModel file with the full geometry tree (optional, comment out to skip)
+ ConfigFlags.Detector.SimulateVeto = True
+ ConfigFlags.Detector.SimulateTrigger = True
+ ConfigFlags.Detector.SimulatePreshower= True
+ ConfigFlags.Detector.SimulateFaserSCT = True
+ ConfigFlags.Detector.SimulateUpstreamDipole = True
+ ConfigFlags.Detector.SimulateCentralDipole = True
+ ConfigFlags.Detector.SimulateDownstreamDipole = True
+ ConfigFlags.lock()
+
+# Configure components
+ from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
+ acc = MainServicesSerialCfg()
+
+# Set things up to create a conditions DB with neutral Tracker alignment transforms
+ acc.merge(WriteAlignmentCfg(ConfigFlags))
+
+# Configure verbosity
+ # ConfigFlags.dump()
+ # logging.getLogger('forcomps').setLevel(VERBOSE)
+ # acc.foreach_component("*").OutputLevel = VERBOSE
+ # acc.foreach_component("*ClassID*").OutputLevel = INFO
+ # log.setLevel(VERBOSE)
+
+# Execute and finish
+ sys.exit(int(acc.run(maxEvents=1).isFailure()))
diff --git a/Control/CalypsoExample/WriteAlignment/python/__init__.py b/Control/CalypsoExample/WriteAlignment/python/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3ff304a0f5154f1256f8f043d4efacdde547cde
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/python/__init__.py
@@ -0,0 +1 @@
+# __author__ = 'Dave Casper'
diff --git a/Control/CalypsoExample/GeoModelTest/scripts/CopyAlignFolder.sh b/Control/CalypsoExample/WriteAlignment/scripts/CopyAlignFolder.sh
similarity index 100%
rename from Control/CalypsoExample/GeoModelTest/scripts/CopyAlignFolder.sh
rename to Control/CalypsoExample/WriteAlignment/scripts/CopyAlignFolder.sh
diff --git a/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.cxx b/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..3974a519986d5fa7a8bf8c29da8c126bf970efcb
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.cxx
@@ -0,0 +1,895 @@
+#include "WriteAlignmentAlg.h"
+
+#include "GeoModelKernel/GeoVDetectorManager.h"
+#include "GeoModelUtilities/GeoModelExperiment.h"
+
+#include "ScintReadoutGeometry/VetoDetectorManager.h"
+#include "ScintReadoutGeometry/TriggerDetectorManager.h"
+#include "ScintReadoutGeometry/PreshowerDetectorManager.h"
+#include "TrackerReadoutGeometry/SCT_DetectorManager.h"
+
+#include "ScintReadoutGeometry/ScintDetectorElement.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+
+#include "ScintIdentifier/VetoID.h"
+#include "ScintIdentifier/TriggerID.h"
+#include "ScintIdentifier/PreshowerID.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "GaudiKernel/PhysicalConstants.h"
+
+WriteAlignmentAlg::WriteAlignmentAlg(const std::string& name, ISvcLocator* pSvcLocator)
+: AthReentrantAlgorithm(name, pSvcLocator), m_numSctStations {0}
+{ }
+
+WriteAlignmentAlg::~WriteAlignmentAlg() { }
+
+StatusCode WriteAlignmentAlg::initialize()
+{
+ m_numSctStations = std::max(0, m_lastSctStation - m_firstSctStation + 1);
+ ATH_CHECK(m_alignTool.retrieve());
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::execute(const EventContext&) const
+{
+ GeoModelExperiment* theExpt = nullptr;
+ std::vector<std::string> listOfManagers;
+ ATH_CHECK(detStore()->retrieve(theExpt, "FASER"));
+ if (theExpt != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved top-level FASER experiment geometry from DetStore.");
+ listOfManagers = theExpt->getListOfManagers();
+ ATH_MSG_ALWAYS("Experiment has defined " << listOfManagers.size() << " detector managers:");
+ for (auto mgr : listOfManagers)
+ {
+ const GeoVDetectorManager* pMgr = nullptr;
+ pMgr = theExpt->getManager(mgr);
+ if (pMgr != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved (generic) manager " << mgr << " from top-level experiment.");
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve manager " << mgr);
+ return StatusCode::FAILURE;
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve top-level FASER experiment geometry from DetStore.");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_CHECK(testVeto());
+
+ ATH_CHECK(testTrigger());
+
+ ATH_CHECK(testPreshower());
+
+ ATH_CHECK(testSCT());
+
+ ATH_CHECK(m_alignTool->createDB());
+ ATH_CHECK(m_alignTool->sortTrans());
+ ATH_CHECK(m_alignTool->outputObjs());
+ ATH_CHECK(m_alignTool->fillDB("",1,0,9999999,9999999));
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::testSCT() const
+{
+ // Test retrieval of helper object directly from store
+ const FaserSCT_ID* helper = nullptr;
+ ATH_CHECK(detStore()->retrieve(helper, "FaserSCT_ID"));
+ if (helper != nullptr)
+ {
+ // Test neighbors with helper function
+ const IdContext& context = helper->wafer_context();
+ ATH_MSG_ALWAYS("Retrieved FaserSCT_ID helper from DetStore.");
+
+ // Print list of identifiers
+ // for (FaserSCT_ID::const_id_iterator it = helper->wafer_begin(); it != helper->wafer_end(); ++it)
+ // {
+ // ATH_MSG_ALWAYS("Wafer ID: " << (it->get_compact() >>32));
+ // }
+
+ for (int iStation = m_firstSctStation; iStation <= m_lastSctStation; iStation++)
+ {
+ // if (m_numSctStations%2 == 0 && iStation == 0) continue;
+ for (int iPlane = 0; iPlane < m_numSctPlanesPerStation; iPlane++)
+ {
+ for (int iRow = 0; iRow < m_numSctRowsPerPlane; iRow++)
+ {
+ for (int iModule = -m_numSctModulesPerRow/2; iModule <= m_numSctModulesPerRow/2; iModule++)
+ {
+ if (m_numSctModulesPerRow%2 == 0 && iModule == 0) continue;
+ for (int iSensor = 0; iSensor < 2; iSensor++)
+ {
+ Identifier thisId = helper->wafer_id(iStation, iPlane, iRow, iModule, iSensor, true);
+ IdentifierHash thisHash = helper->wafer_hash(thisId);
+ IdentifierHash prevHash;
+ IdentifierHash nextHash;
+ IdentifierHash flipHash;
+ Identifier prevId;
+ Identifier nextId;
+ Identifier flipId;
+ const int INVALID = std::numeric_limits<int>::min();
+ int prevPhiStation { INVALID };
+ int nextPhiStation { INVALID };
+ int prevPhiPlane { INVALID };
+ int nextPhiPlane { INVALID };
+ int prevPhiRow { INVALID };
+ int nextPhiRow { INVALID };
+ int prevPhiModule { INVALID };
+ int nextPhiModule { INVALID };
+ int prevPhiSensor { INVALID };
+ int nextPhiSensor { INVALID };
+ int prevPhiStat = helper->get_prev_in_phi(thisHash, prevHash);
+ if (prevPhiStat == 0)
+ {
+ IdentifierHash testHash;
+ int nextPhiStat = helper->get_next_in_phi(prevHash, testHash);
+ if (nextPhiStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Next SCT module in phi (" << testHash << ") of previous in phi (" << prevHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ prevPhiStat = helper->get_id(prevHash, prevId, &context);
+ if (prevPhiStat == 0)
+ {
+ prevPhiStation = helper->station(prevId);
+ prevPhiPlane = helper->layer(prevId);
+ prevPhiRow = helper->phi_module(prevId);
+ prevPhiModule = helper->eta_module(prevId);
+ prevPhiSensor = helper->side(prevId);
+ }
+ }
+ int nextPhiStat = helper->get_next_in_phi(thisHash, nextHash);
+ if (nextPhiStat == 0)
+ {
+ IdentifierHash testHash;
+ prevPhiStat = helper->get_prev_in_phi(nextHash, testHash);
+ if (prevPhiStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Previous SCT Module in phi (" << testHash << ") of next in phi (" << nextHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ nextPhiStat = helper->get_id(nextHash, nextId, &context);
+ if (nextPhiStat == 0)
+ {
+ nextPhiStation = helper->station(nextId);
+ nextPhiPlane = helper->layer(nextId);
+ nextPhiRow = helper->phi_module(nextId);
+ nextPhiModule = helper->eta_module(nextId);
+ nextPhiSensor = helper->side(nextId);
+ }
+ }
+ int prevEtaStation { INVALID };
+ int nextEtaStation { INVALID };
+ int prevEtaPlane { INVALID };
+ int nextEtaPlane { INVALID };
+ int prevEtaRow { INVALID };
+ int nextEtaRow { INVALID };
+ int prevEtaModule { INVALID };
+ int nextEtaModule { INVALID };
+ int prevEtaSensor { INVALID };
+ int nextEtaSensor { INVALID };
+ int prevEtaStat = helper->get_prev_in_eta(thisHash, prevHash);
+ if (prevEtaStat == 0)
+ {
+ IdentifierHash testHash;
+ int nextEtaStat = helper->get_next_in_eta(prevHash, testHash);
+ if (nextEtaStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Next SCT module in eta (" << testHash << ") of previous in eta (" << prevHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ prevEtaStat = helper->get_id(prevHash, prevId, &context);
+ if (prevEtaStat == 0)
+ {
+ prevEtaStation = helper->station(prevId);
+ prevEtaPlane = helper->layer(prevId);
+ prevEtaRow = helper->phi_module(prevId);
+ prevEtaModule = helper->eta_module(prevId);
+ prevEtaSensor = helper->side(prevId);
+ }
+ }
+ int nextEtaStat = helper->get_next_in_eta(thisHash, nextHash);
+ if (nextEtaStat == 0)
+ {
+ IdentifierHash testHash;
+ prevEtaStat = helper->get_prev_in_eta(nextHash, testHash);
+ if (prevEtaStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Previous SCT Module in eta (" << testHash << ") of next in eta (" << nextHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ nextEtaStat = helper->get_id(nextHash, nextId, &context);
+ if (nextEtaStat == 0)
+ {
+ nextEtaStation = helper->station(nextId);
+ nextEtaPlane = helper->layer(nextId);
+ nextEtaRow = helper->phi_module(nextId);
+ nextEtaModule = helper->eta_module(nextId);
+ nextEtaSensor = helper->side(nextId);
+ }
+ }
+ int flipStation { INVALID };
+ int flipPlane { INVALID };
+ int flipRow { INVALID };
+ int flipModule { INVALID };
+ int flipSensor { INVALID };
+ int flipStat = helper->get_other_side(thisHash, flipHash);
+ if (flipStat == 0)
+ {
+ IdentifierHash testHash;
+ int flipStat = helper->get_other_side(flipHash, testHash);
+ if (flipStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Flip side of SCT sensor (" << testHash << ") of flip side (" << flipHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ flipStat = helper->get_id(flipHash, prevId, &context);
+ if (flipStat == 0)
+ {
+ flipStation = helper->station(prevId);
+ flipPlane = helper->layer(prevId);
+ flipRow = helper->phi_module(prevId);
+ flipModule = helper->eta_module(prevId);
+ flipSensor = helper->side(prevId);
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("SCT sensor " << thisHash << " has no other side!");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_ALWAYS("Sct Sensor " << iStation << "/" << iPlane << "/" << iRow << "/" << iModule << "/" << iSensor <<
+ " (" << thisHash << ") " <<
+ ": prev phi = " << (prevPhiStation == INVALID ? "-" : std::to_string(prevPhiStation)) << "/" <<
+ (prevPhiPlane == INVALID ? "-" : std::to_string(prevPhiPlane)) << "/" <<
+ (prevPhiRow == INVALID ? "-": std::to_string(prevPhiRow)) << "/" <<
+ (prevPhiModule == INVALID ? "-" : std::to_string(prevPhiModule)) << "/" <<
+ (prevPhiSensor == INVALID ? "-" : std::to_string(prevPhiSensor)) <<
+ " , next phi = " << (nextPhiStation == INVALID ? "-" : std::to_string(nextPhiStation)) << "/" <<
+ (nextPhiPlane == INVALID ? "-" : std::to_string(nextPhiPlane)) << "/" <<
+ (nextPhiRow == INVALID ? "-": std::to_string(nextPhiRow)) << "/" <<
+ (nextPhiModule == INVALID ? "-" : std::to_string(nextPhiModule)) << "/" <<
+ (nextPhiSensor == INVALID ? "-" : std::to_string(nextPhiSensor)) <<
+ " , prev eta = " << (prevEtaStation == INVALID ? "-" : std::to_string(prevEtaStation)) << "/" <<
+ (prevEtaPlane == INVALID ? "-" : std::to_string(prevEtaPlane)) << "/" <<
+ (prevEtaRow == INVALID ? "-": std::to_string(prevEtaRow)) << "/" <<
+ (prevEtaModule == INVALID ? "-" : std::to_string(prevEtaModule)) << "/" <<
+ (prevEtaSensor == INVALID ? "-" : std::to_string(prevEtaSensor)) <<
+ " , next eta = " << (nextEtaStation == INVALID ? "-" : std::to_string(nextEtaStation)) << "/" <<
+ (nextEtaPlane == INVALID ? "-" : std::to_string(nextEtaPlane)) << "/" <<
+ (nextEtaRow == INVALID ? "-": std::to_string(nextEtaRow)) << "/" <<
+ (nextEtaModule == INVALID ? "-" : std::to_string(nextEtaModule)) << "/" <<
+ (nextEtaSensor == INVALID ? "-" : std::to_string(nextEtaSensor)) <<
+ " , other side = " << flipStation << "/" <<
+ flipPlane << "/" <<
+ flipRow << "/" <<
+ flipModule << "/" <<
+ flipSensor
+ );
+
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve FaserSCT_ID helper from DetStore.");
+ return StatusCode::FAILURE;
+ }
+
+ // Test direct retrieval of typed managers from DetStore
+ const TrackerDD::SCT_DetectorManager* sctMgr = nullptr;
+ ATH_CHECK(detStore()->retrieve(sctMgr, "SCT"));
+ if (sctMgr != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved (typed) SCT detector manager with " << sctMgr->getNumTreeTops() << " treetops directly from DetStore.");
+ // Compare numerology with the "right" answers from our properties
+ if (sctMgr->numerology().numStations() != m_numSctStations || sctMgr->getNumTreeTops() != (size_t) m_numSctStations)
+ {
+ ATH_MSG_FATAL("Disagreement in number of SCT stations.");
+ return StatusCode::FAILURE;
+ }
+ if (sctMgr->numerology().numLayers() != m_numSctPlanesPerStation)
+ {
+ ATH_MSG_FATAL("Disagreement in number of layers per SCT station.");
+ return StatusCode::FAILURE;
+ }
+ if (sctMgr->numerology().numPhiModulesForLayer() != m_numSctRowsPerPlane)
+ {
+ ATH_MSG_FATAL("Disagreement in number of rows per SCT plane.");
+ return StatusCode::FAILURE;
+ }
+ if (sctMgr->numerology().numEtaModulesForLayer() != m_numSctModulesPerRow)
+ {
+ ATH_MSG_FATAL("Disagreement in number of modules per SCT row.");
+ return StatusCode::FAILURE;
+ }
+ if (sctMgr->numerology().maxNumStrips() != m_numSctStripsPerSensor)
+ {
+ ATH_MSG_FATAL("Disagreement in number of strips per SCT sensor.");
+ return StatusCode::FAILURE;
+ }
+
+ // Test detector elements
+ const TrackerDD::SiDetectorElementCollection* elements = sctMgr->getDetectorElementCollection();
+ for (int station = m_firstSctStation; station <= m_lastSctStation; station++)
+ {
+ // if (m_numSctStations%2 == 0 && station == 0) continue;
+ for (int plane = 0; plane < m_numSctPlanesPerStation; plane++)
+ {
+ for (int row = 0; row < m_numSctRowsPerPlane; row++)
+ {
+ for (int module = -m_numSctModulesPerRow/2; module <= m_numSctModulesPerRow/2; module++)
+ {
+ if (m_numSctModulesPerRow%2 == 0 && module == 0) continue;
+ for (int sensor = 0; sensor < 2; sensor++)
+ {
+ Identifier id = helper->wafer_id(station, plane, row, module, sensor, true);
+ if (!sctMgr->identifierBelongs(id))
+ {
+ ATH_MSG_FATAL("Valid SCT sensor identifier does not pass identifierBelongs.");
+ return StatusCode::FAILURE;
+ }
+ IdentifierHash hash = helper->wafer_hash(id);
+ TrackerDD::SiDetectorElement* elementByLevels = sctMgr->getDetectorElement(station, plane, row, module, sensor);
+ TrackerDD::SiDetectorElement* elementById = sctMgr->getDetectorElement(id);
+ TrackerDD::SiDetectorElement* elementByHash = sctMgr->getDetectorElement(hash);
+ TrackerDD::SiDetectorElement* element = (*elements)[hash];
+ if (elementByLevels != element || elementById != element || elementByHash != element)
+ {
+ ATH_MSG_FATAL("Inconsistent retrieval of SCT detector elements");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_ALWAYS("Found SCT sensor (" << station << "/" << plane << "/" << row << "/" << module << "/" << sensor << ") with global center at (" <<
+ element->center().x() << ", " <<
+ element->center().y() << ", " <<
+ element->center().z() << ")."
+ );
+ const TrackerDD::SiDetectorElement* nextPhi = element->nextInPhi();
+ if (nextPhi != nullptr)
+ {
+ if (nextPhi->prevInPhi() != element)
+ {
+ ATH_MSG_FATAL("Previous phi neighbor of next SCT element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ const TrackerDD::SiDetectorElement* prevPhi = element->prevInPhi();
+ if (prevPhi != nullptr)
+ {
+ if (prevPhi->nextInPhi() != element)
+ {
+ ATH_MSG_FATAL("Next phi neighbor of previous SCT element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ if (nextPhi == nullptr && prevPhi == nullptr)
+ {
+ ATH_MSG_FATAL("SCT element " << hash << " has no previous OR next phi neighbor.");
+ return StatusCode::FAILURE;
+ }
+ const TrackerDD::SiDetectorElement* nextEta = element->nextInEta();
+ if (nextEta != nullptr)
+ {
+ if (nextEta->prevInEta() != element)
+ {
+ ATH_MSG_FATAL("Previous eta neighbor of next SCT element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ const TrackerDD::SiDetectorElement* prevEta = element->prevInEta();
+ if (prevEta != nullptr)
+ {
+ if (prevEta->nextInEta() != element)
+ {
+ ATH_MSG_FATAL("Next eta neighbor of previous SCT element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ if (nextEta == nullptr && prevEta == nullptr)
+ {
+ ATH_MSG_FATAL("SCT element " << hash << " has no previous OR next eta neighbor.");
+ return StatusCode::FAILURE;
+ }
+ const TrackerDD::SiDetectorElement* flip = element->otherSide();
+ if (flip == nullptr)
+ {
+ ATH_MSG_FATAL("SCT element " << hash << " has no other side.");
+ return StatusCode::FAILURE;
+ }
+ if (flip->otherSide() != element)
+ {
+ ATH_MSG_FATAL("Other side of other side of SCT sensor is not this sensor.");
+ return StatusCode::FAILURE;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve (typed) SCT detector manager directly from DetStore.");
+ return StatusCode::FAILURE;
+ }
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::testVeto() const
+{
+ // Test retrieval of helper object directly from store
+ const VetoID* helper = nullptr;
+ ATH_CHECK(detStore()->retrieve(helper, "VetoID"));
+ if (helper != nullptr)
+ {
+ // Test neighbors with helper function
+ const IdContext& context = helper->plate_context();
+ ATH_MSG_ALWAYS("Retrieved VetoID helper from DetStore.");
+ for (int iStation = 0; iStation < m_numVetoStations; iStation++)
+ {
+ for (int iPlate = 0; iPlate < m_numVetoPlatesPerStation; iPlate++)
+ {
+ Identifier thisId = helper->plate_id(iStation, iPlate, true);
+ IdentifierHash thisHash = helper->plate_hash(thisId);
+ IdentifierHash prevHash;
+ IdentifierHash nextHash;
+ Identifier prevId;
+ Identifier nextId;
+ int prevStation {-1};
+ int prevPlate {-1};
+ int nextStation {-1};
+ int nextPlate {-1};
+ int prevStat = helper->get_prev_in_z(thisHash, prevHash);
+ if (prevStat == 0)
+ {
+ IdentifierHash testHash;
+ int nextStat = helper->get_next_in_z(prevHash, testHash);
+ if (nextStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Next Veto plate (" << testHash << ") of previous (" << prevHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ prevStat = helper->get_id(prevHash, prevId, &context);
+ if (prevStat == 0)
+ {
+ prevStation = helper->station(prevId);
+ prevPlate = helper->plate(prevId);
+ }
+ }
+ int nextStat = helper->get_next_in_z(thisHash, nextHash);
+ if (nextStat == 0)
+ {
+ IdentifierHash testHash;
+ prevStat = helper->get_prev_in_z(nextHash, testHash);
+ if (prevStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Previous veto plate (" << testHash << ") of next (" << nextHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ nextStat = helper->get_id(nextHash, nextId, &context);
+ if (nextStat == 0)
+ {
+ nextStation = helper->station(nextId);
+ nextPlate = helper->plate(nextId);
+ }
+ }
+ ATH_MSG_ALWAYS("Station/Plate " << iStation << "/" << iPlate <<
+ " (" << thisHash << ") " <<
+ " : prev = " << prevStation << "/" << prevPlate <<
+ " , next = " << nextStation << "/" << nextPlate );
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve VetoID helper from DetStore.");
+ return StatusCode::FAILURE;
+ }
+
+ // Test direct retrieval of typed managers from DetStore
+ const ScintDD::VetoDetectorManager* vetoMgr = nullptr;
+ ATH_CHECK(detStore()->retrieve(vetoMgr, "Veto"));
+ if (vetoMgr != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved (typed) Veto detector manager with " << vetoMgr->getNumTreeTops() << " treetops directly from DetStore.");
+ // Compare numerology with the "right" answers from our properties
+ if (vetoMgr->numerology().numStations() != m_numVetoStations || vetoMgr->getNumTreeTops() != m_numVetoStations)
+ {
+ ATH_MSG_FATAL("Disagreement in number of veto stations.");
+ return StatusCode::FAILURE;
+ }
+ if (vetoMgr->numerology().numPlatesPerStation() != m_numVetoPlatesPerStation)
+ {
+ ATH_MSG_FATAL("Disagreement in number of plates per veto station.");
+ return StatusCode::FAILURE;
+ }
+ if (vetoMgr->numerology().numPmtsPerPlate() != m_numVetoPmtsPerPlate)
+ {
+ ATH_MSG_FATAL("Disagreement in number of pmts per veto plate.");
+ return StatusCode::FAILURE;
+ }
+ // Test detector elements
+ const ScintDD::ScintDetectorElementCollection* elements = vetoMgr->getDetectorElementCollection();
+ for (int station = 0; station < m_numVetoStations; station++)
+ {
+ for (int plate = 0; plate < m_numVetoPlatesPerStation; plate++)
+ {
+ Identifier id = helper->plate_id(station, plate, true);
+ if (!vetoMgr->identifierBelongs(id))
+ {
+ ATH_MSG_FATAL("Valid Veto identifier does not pass identifierBelongs.");
+ return StatusCode::FAILURE;
+ }
+ IdentifierHash hash = helper->plate_hash(id);
+ ScintDD::ScintDetectorElement* elementByLevels = vetoMgr->getDetectorElement(station, plate);
+ ScintDD::ScintDetectorElement* elementById = vetoMgr->getDetectorElement(id);
+ ScintDD::ScintDetectorElement* elementByHash = vetoMgr->getDetectorElement(hash);
+ ScintDD::ScintDetectorElement* element = (*elements)[hash];
+ if (elementByLevels != element || elementById != element || elementByHash != element)
+ {
+ ATH_MSG_FATAL("Inconsistent retrieval of Veto detector elements");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_ALWAYS("Found Veto plate (" << station << ", " << plate << ") with global center at (" <<
+ element->center().x() << ", " <<
+ element->center().y() << ", " <<
+ element->center().z() << ")."
+ );
+ const ScintDD::ScintDetectorElement* next = element->nextInZ();
+ if (next != nullptr)
+ {
+ if (next->prevInZ() != element)
+ {
+ ATH_MSG_FATAL("Previous neighbor of next Veto element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ const ScintDD::ScintDetectorElement* prev = element->prevInZ();
+ if (prev != nullptr)
+ {
+ if (prev->nextInZ() != element)
+ {
+ ATH_MSG_FATAL("Next neighbor of previous Veto element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ if (next == nullptr && prev == nullptr)
+ {
+ ATH_MSG_FATAL("Veto element " << hash << " has no previous OR next neighbor.");
+ return StatusCode::FAILURE;
+ }
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve (typed) Veto detector manager directly from DetStore.");
+ return StatusCode::FAILURE;
+ }
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::testTrigger() const
+{
+ // Test retrieval of helper object directly from store
+ const TriggerID* helper = nullptr;
+ ATH_CHECK(detStore()->retrieve(helper, "TriggerID"));
+ if (helper != nullptr)
+ {
+ // Test neighbors with helper function
+ const IdContext& context = helper->plate_context();
+ ATH_MSG_ALWAYS("Retrieved TriggerID helper from DetStore.");
+ for (int iStation = 0; iStation < m_numTriggerStations; iStation++)
+ {
+ for (int iPlate = 0; iPlate < m_numTriggerPlatesPerStation; iPlate++)
+ {
+ Identifier thisId = helper->plate_id(iStation, iPlate, true);
+ IdentifierHash thisHash = helper->plate_hash(thisId);
+ IdentifierHash prevHash;
+ IdentifierHash nextHash;
+ Identifier prevId;
+ Identifier nextId;
+ int prevStation {-1};
+ int prevPlate {-1};
+ int nextStation {-1};
+ int nextPlate {-1};
+ int prevStat = helper->get_prev_in_z(thisHash, prevHash);
+ if (prevStat == 0)
+ {
+ IdentifierHash testHash;
+ int nextStat = helper->get_next_in_z(prevHash, testHash);
+ if (nextStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Next Trigger plate (" << testHash << ") of previous (" << prevHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ prevStat = helper->get_id(prevHash, prevId, &context);
+ if (prevStat == 0)
+ {
+ prevStation = helper->station(prevId);
+ prevPlate = helper->plate(prevId);
+ }
+ }
+ int nextStat = helper->get_next_in_z(thisHash, nextHash);
+ if (nextStat == 0)
+ {
+ IdentifierHash testHash;
+ prevStat = helper->get_prev_in_z(nextHash, testHash);
+ if (prevStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Previous Trigger plate (" << testHash << ") of next (" << nextHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ nextStat = helper->get_id(nextHash, nextId, &context);
+ if (nextStat == 0)
+ {
+ nextStation = helper->station(nextId);
+ nextPlate = helper->plate(nextId);
+ }
+ }
+ ATH_MSG_ALWAYS("Station/Plate " << iStation << "/" << iPlate <<
+ " (" << thisHash << ") " <<
+ " : prev = " << prevStation << "/" << prevPlate <<
+ " , next = " << nextStation << "/" << nextPlate );
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve TriggerID helper from DetStore.");
+ return StatusCode::FAILURE;
+ }
+
+ // Test direct retrieval of typed managers from DetStore
+ const ScintDD::TriggerDetectorManager* triggerMgr = nullptr;
+ ATH_CHECK(detStore()->retrieve(triggerMgr, "Trigger"));
+ if (triggerMgr != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved (typed) Trigger detector manager with " << triggerMgr->getNumTreeTops() << " treetops directly from DetStore.");
+ // Compare numerology with the "right" answers from our properties
+ if (triggerMgr->numerology().numStations() != m_numTriggerStations || triggerMgr->getNumTreeTops() != m_numTriggerStations)
+ {
+ ATH_MSG_FATAL("Disagreement in number of Trigger stations.");
+ return StatusCode::FAILURE;
+ }
+ if (triggerMgr->numerology().numPlatesPerStation() != m_numTriggerPlatesPerStation)
+ {
+ ATH_MSG_FATAL("Disagreement in number of plates per Trigger station.");
+ return StatusCode::FAILURE;
+ }
+ if (triggerMgr->numerology().numPmtsPerPlate() != m_numTriggerPmtsPerPlate)
+ {
+ ATH_MSG_FATAL("Disagreement in number of pmts per Trigger plate.");
+ return StatusCode::FAILURE;
+ }
+ // Test detector elements
+ const ScintDD::ScintDetectorElementCollection* elements = triggerMgr->getDetectorElementCollection();
+ for (int station = 0; station < m_numTriggerStations; station++)
+ {
+ for (int plate = 0; plate < m_numTriggerPlatesPerStation; plate++)
+ {
+ Identifier id = helper->plate_id(station, plate, true);
+ if (!triggerMgr->identifierBelongs(id))
+ {
+ ATH_MSG_FATAL("Valid Trigger identifier does not pass identifierBelongs.");
+ return StatusCode::FAILURE;
+ }
+ IdentifierHash hash = helper->plate_hash(id);
+ ScintDD::ScintDetectorElement* elementByLevels = triggerMgr->getDetectorElement(station, plate);
+ ScintDD::ScintDetectorElement* elementById = triggerMgr->getDetectorElement(id);
+ ScintDD::ScintDetectorElement* elementByHash = triggerMgr->getDetectorElement(hash);
+ ScintDD::ScintDetectorElement* element = (*elements)[hash];
+ if (elementByLevels != element || elementById != element || elementByHash != element)
+ {
+ ATH_MSG_FATAL("Inconsistent retrieval of Trigger detector elements");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_ALWAYS("Found Trigger plate (" << station << ", " << plate << ") with global center at (" <<
+ element->center().x() << ", " <<
+ element->center().y() << ", " <<
+ element->center().z() << ")."
+ );
+ const ScintDD::ScintDetectorElement* next = element->nextInZ();
+ if (next != nullptr)
+ {
+ if (next->prevInZ() != element)
+ {
+ ATH_MSG_FATAL("Previous neighbor of next Trigger element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ const ScintDD::ScintDetectorElement* prev = element->prevInZ();
+ if (prev != nullptr)
+ {
+ if (prev->nextInZ() != element)
+ {
+ ATH_MSG_FATAL("Next neighbor of previous Trigger element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ if (next == nullptr && prev == nullptr)
+ {
+ ATH_MSG_FATAL("Trigger element " << hash << " has no previous OR next neighbor.");
+ return StatusCode::FAILURE;
+ }
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve (typed) Trigger detector manager directly from DetStore.");
+ return StatusCode::FAILURE;
+ }
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::testPreshower() const
+{
+ // Test retrieval of helper object directly from store
+ const PreshowerID* helper = nullptr;
+ ATH_CHECK(detStore()->retrieve(helper, "PreshowerID"));
+ if (helper != nullptr)
+ {
+ // Test neighbors with helper function
+ const IdContext& context = helper->plate_context();
+ ATH_MSG_ALWAYS("Retrieved PreshowerID helper from DetStore.");
+ for (int iStation = 0; iStation < m_numPreshowerStations; iStation++)
+ {
+ for (int iPlate = 0; iPlate < m_numPreshowerPlatesPerStation; iPlate++)
+ {
+ Identifier thisId = helper->plate_id(iStation, iPlate, true);
+ IdentifierHash thisHash = helper->plate_hash(thisId);
+ IdentifierHash prevHash;
+ IdentifierHash nextHash;
+ Identifier prevId;
+ Identifier nextId;
+ int prevStation {-1};
+ int prevPlate {-1};
+ int nextStation {-1};
+ int nextPlate {-1};
+ int prevStat = helper->get_prev_in_z(thisHash, prevHash);
+ if (prevStat == 0)
+ {
+ IdentifierHash testHash;
+ int nextStat = helper->get_next_in_z(prevHash, testHash);
+ if (nextStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Next Preshower plate (" << testHash << ") of previous (" << prevHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ prevStat = helper->get_id(prevHash, prevId, &context);
+ if (prevStat == 0)
+ {
+ prevStation = helper->station(prevId);
+ prevPlate = helper->plate(prevId);
+ }
+ }
+ int nextStat = helper->get_next_in_z(thisHash, nextHash);
+ if (nextStat == 0)
+ {
+ IdentifierHash testHash;
+ prevStat = helper->get_prev_in_z(nextHash, testHash);
+ if (prevStat != 0 || testHash != thisHash)
+ {
+ ATH_MSG_FATAL("Previous veto plate (" << testHash << ") of next (" << nextHash << ") is not the original (" << thisHash <<")" );
+ return StatusCode::FAILURE;
+ }
+ nextStat = helper->get_id(nextHash, nextId, &context);
+ if (nextStat == 0)
+ {
+ nextStation = helper->station(nextId);
+ nextPlate = helper->plate(nextId);
+ }
+ }
+ ATH_MSG_ALWAYS("Station/Plate " << iStation << "/" << iPlate <<
+ " (" << thisHash << ") " <<
+ " : prev = " << prevStation << "/" << prevPlate <<
+ " , next = " << nextStation << "/" << nextPlate );
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve PreshowerID helper from DetStore.");
+ return StatusCode::FAILURE;
+ }
+
+ // Test direct retrieval of typed managers from DetStore
+ const ScintDD::PreshowerDetectorManager* preshowerMgr = nullptr;
+ ATH_CHECK(detStore()->retrieve(preshowerMgr, "Preshower"));
+ if (preshowerMgr != nullptr)
+ {
+ ATH_MSG_ALWAYS("Retrieved (typed) Preshower detector manager with " << preshowerMgr->getNumTreeTops() << " treetops directly from DetStore.");
+ // Compare numerology with the "right" answers from our properties
+ if (preshowerMgr->numerology().numStations() != m_numPreshowerStations || preshowerMgr->getNumTreeTops() != m_numPreshowerStations)
+ {
+ ATH_MSG_FATAL("Disagreement in number of preshower stations.");
+ return StatusCode::FAILURE;
+ }
+ if (preshowerMgr->numerology().numPlatesPerStation() != m_numPreshowerPlatesPerStation)
+ {
+ ATH_MSG_FATAL("Disagreement in number of plates per preshower station.");
+ return StatusCode::FAILURE;
+ }
+ if (preshowerMgr->numerology().numPmtsPerPlate() != m_numPreshowerPmtsPerPlate)
+ {
+ ATH_MSG_FATAL("Disagreement in number of pmts per preshower plate.");
+ return StatusCode::FAILURE;
+ }
+ // Test detector elements
+ const ScintDD::ScintDetectorElementCollection* elements = preshowerMgr->getDetectorElementCollection();
+ for (int station = 0; station < m_numPreshowerStations; station++)
+ {
+ for (int plate = 0; plate < m_numPreshowerPlatesPerStation; plate++)
+ {
+ Identifier id = helper->plate_id(station, plate, true);
+ if (!preshowerMgr->identifierBelongs(id))
+ {
+ ATH_MSG_FATAL("Valid Preshower identifier does not pass identifierBelongs.");
+ return StatusCode::FAILURE;
+ }
+ IdentifierHash hash = helper->plate_hash(id);
+ ScintDD::ScintDetectorElement* elementByLevels = preshowerMgr->getDetectorElement(station, plate);
+ ScintDD::ScintDetectorElement* elementById = preshowerMgr->getDetectorElement(id);
+ ScintDD::ScintDetectorElement* elementByHash = preshowerMgr->getDetectorElement(hash);
+ ScintDD::ScintDetectorElement* element = (*elements)[hash];
+ if (elementByLevels != element || elementById != element || elementByHash != element)
+ {
+ ATH_MSG_FATAL("Inconsistent retrieval of Preshower detector elements");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_ALWAYS("Found Preshower plate (" << station << ", " << plate << ") with global center at (" <<
+ element->center().x() << ", " <<
+ element->center().y() << ", " <<
+ element->center().z() << ")."
+ );
+ const ScintDD::ScintDetectorElement* next = element->nextInZ();
+ if (next != nullptr)
+ {
+ if (next->prevInZ() != element)
+ {
+ ATH_MSG_FATAL("Previous neighbor of next Preshower element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ const ScintDD::ScintDetectorElement* prev = element->prevInZ();
+ if (prev != nullptr)
+ {
+ if (prev->nextInZ() != element)
+ {
+ ATH_MSG_FATAL("Next neighbor of previous Preshower element is not this element.");
+ return StatusCode::FAILURE;
+ }
+ }
+ if (next == nullptr && prev == nullptr)
+ {
+ ATH_MSG_FATAL("Preshower element " << hash << " has no previous OR next neighbor.");
+ return StatusCode::FAILURE;
+ }
+ }
+ }
+ }
+ else
+ {
+ ATH_MSG_FATAL("Failed to retrieve (typed) Preshower detector manager directly from DetStore.");
+ return StatusCode::FAILURE;
+ }
+ return StatusCode::SUCCESS;
+}
+
+StatusCode WriteAlignmentAlg::finalize()
+{
+
+ return StatusCode::SUCCESS;
+}
diff --git a/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.h b/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..0797a34fdb88cdecb14021d10f4c188c5134d430
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/src/WriteAlignmentAlg.h
@@ -0,0 +1,47 @@
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "TrackerAlignGenTools/ITrackerAlignDBTool.h"
+
+// Minimalist algorithm to test retrieval of constructed geometry from DetStore
+
+class WriteAlignmentAlg : public AthReentrantAlgorithm
+{
+ public:
+ WriteAlignmentAlg(const std::string& name, ISvcLocator* pSvcLocator);
+
+ virtual ~WriteAlignmentAlg();
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+
+ private:
+ StatusCode testVeto() const;
+ StatusCode testTrigger() const;
+ StatusCode testPreshower() const;
+ StatusCode testSCT() const;
+
+ // Independently specify the "right" number of elements, for comparison with what we get from detector store
+ Gaudi::Property<int> m_numVetoStations {this, "NumVetoStations", 2, "Number of stations in the Veto detector"};
+ Gaudi::Property<int> m_numVetoPlatesPerStation {this, "NumVetoPlatesPerStation", 2, "Number of plates per station in the Veto detector"};
+ Gaudi::Property<int> m_numVetoPmtsPerPlate {this, "NumVetoPmtsPerPlate", 1, "Number of pmts per plate in the Veto detector"};
+
+ Gaudi::Property<int> m_numTriggerStations {this, "NumTriggerStations", 1, "Number of stations in the Trigger detector"};
+ Gaudi::Property<int> m_numTriggerPlatesPerStation {this, "NumTriggerPlatesPerStation", 2, "Number of plates per station in the Trigger detector"};
+ Gaudi::Property<int> m_numTriggerPmtsPerPlate {this, "NumTriggerPmtsPerPlate", 2, "Number of pmts per plate in the Trigger detector"};
+
+ Gaudi::Property<int> m_numPreshowerStations {this, "NumPreshowerStations", 1, "Number of stations in the Preshower detector"};
+ Gaudi::Property<int> m_numPreshowerPlatesPerStation {this, "NumPreshowerPlatesPerStation", 2, "Number of plates per station in the Preshower detector"};
+ Gaudi::Property<int> m_numPreshowerPmtsPerPlate {this, "NumPreshowerPmtsPerPlate", 1, "Number of pmts per plate in the Preshower detector"};
+
+ Gaudi::Property<int> m_firstSctStation {this, "FirstSCTStation", 1, "Identifier of the first SCT station (0 w/FaserNu, 1 otherwise)"};
+ Gaudi::Property<int> m_lastSctStation {this, "LastSCTStation", 3, "Identifier of the last SCT station (normally 3)"};
+ Gaudi::Property<int> m_numSctPlanesPerStation {this, "NumSCTPlanesPerStation", 3, "Number of planes per station in the SCT detector"};
+ Gaudi::Property<int> m_numSctRowsPerPlane {this, "NumSCTRowsPerPlane", 4, "Number of rows of modules per plane in the SCT detector"};
+ Gaudi::Property<int> m_numSctModulesPerRow {this, "NumSCTModulesPerRow", 2, "Number of modules per row in the SCT detector"};
+ Gaudi::Property<int> m_numSctStripsPerSensor {this, "NumSCTStripsPerSensor", 768,"Number of readout strips per sensor in the SCT detector"};
+
+ int m_numSctStations;
+
+ ToolHandle<ITrackerAlignDBTool> m_alignTool { this, "AlignDbTool", "TrackerAlignDBTool" };
+};
\ No newline at end of file
diff --git a/Control/CalypsoExample/WriteAlignment/src/components/WriteAlignment_entries.cxx b/Control/CalypsoExample/WriteAlignment/src/components/WriteAlignment_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e3e937b60465ab48c1f21adf32985168a5696222
--- /dev/null
+++ b/Control/CalypsoExample/WriteAlignment/src/components/WriteAlignment_entries.cxx
@@ -0,0 +1,3 @@
+#include "../WriteAlignmentAlg.h"
+
+DECLARE_COMPONENT( WriteAlignmentAlg )
diff --git a/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml b/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
index a74612ac707da709d3c33ff514bf5a746a676511..91ba81751aec848daa4b45e63b874fb288d013a0 100644
--- a/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
+++ b/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
@@ -2,18 +2,20 @@
<servicelist>
<logicalservice name="FASERDD">
- <service name="sqlite_file:data/geomDB_sqlite" accessMode="read" />
- <service name="sqlite_file:DetectorDescription/GeoModel/FaserGeoModel/geomDB_sqlite" accessMode="read" />
+ <service name="sqlite_file:///cvmfs/faser.cern.ch/repo/sw/database/DBRelease/current/geomDB/geomDB_sqlite" accessMode="read" />
</logicalservice>
<logicalservice name="COOLOFL_SCT">
- <service name="sqlite_file:data/ALLP200.db" accessMode="read" />
- <service name="sqlite_file:Tracker/TrackerConditions/FaserSCT_ConditionsData/ALLP200.db" accessMode="read" />
+ <service name="sqlite_file:///cvmfs/faser.cern.ch/repo/sw/database/DBRelease/current/sqlite200/ALLP200.db" accessMode="read" />
</logicalservice>
<logicalservice name="COOLOFL_DCS">
- <service name="sqlite_file:data/ALLP200.db" accessMode="read" />
- <service name="sqlite_file:Tracker/TrackerConditions/FaserSCT_ConditionsData/ALLP200.db" accessMode="read" />
+ <service name="sqlite_file:///cvmfs/faser.cern.ch/repo/sw/database/DBRelease/current/sqlite200/ALLP200.db" accessMode="read" />
</logicalservice>
+<logicalservice name="COOLOFL_GLOBAL">
+ <service name="sqlite_file:///cvmfs/faser.cern.ch/repo/sw/database/DBRelease/current/sqlite200/ALLP200.db" accessMode="read" />
+</logicalservice>
+
+
</servicelist>
diff --git a/DetectorDescription/DetDescrCnvSvc/python/DetDescrCnvSvcConfig.py b/DetectorDescription/DetDescrCnvSvc/python/DetDescrCnvSvcConfig.py
index 5a5c2fbea7b3b938992a636e289c4a77a2ddd487..7c7ec3f4f32c305cf78db01d76bb6e2c82c95f20 100644
--- a/DetectorDescription/DetDescrCnvSvc/python/DetDescrCnvSvcConfig.py
+++ b/DetectorDescription/DetDescrCnvSvc/python/DetDescrCnvSvcConfig.py
@@ -1,8 +1,11 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
def DetDescrCnvSvcCfg(configFlags=None):
- from DetDescrCnvSvc.DetDescrCnvSvcConf import DetDescrCnvSvc
- from GaudiSvc.GaudiSvcConf import EvtPersistencySvc
+ DetDescrCnvSvc=CompFactory.DetDescrCnvSvc
+ EvtPersistencySvc=CompFactory.EvtPersistencySvc
acc=ComponentAccumulator()
# Specify primary Identifier dictionary to be use
detDescrCnvSvc=DetDescrCnvSvc(IdDictName = "FaserGeoModel/FASER_IDS.xml",IdDictFromRDB = True)
diff --git a/DetectorDescription/DetDescrCnvSvc/src/DetDescrCnvSvc.cxx b/DetectorDescription/DetDescrCnvSvc/src/DetDescrCnvSvc.cxx
index 22e7ed16543981004fabc0b5e93535e4afd1c6e0..3db58a375ea681e9982655fe90961c450a2d8613 100644
--- a/DetectorDescription/DetDescrCnvSvc/src/DetDescrCnvSvc.cxx
+++ b/DetectorDescription/DetDescrCnvSvc/src/DetDescrCnvSvc.cxx
@@ -165,7 +165,13 @@ StatusCode DetDescrCnvSvc::createAddress( long /* svc_type */,
log << MSG::FATAL << "Could not cast to DetDescrAddress." << endmsg;
return StatusCode::FAILURE;
}
- ddAddr->fromString(refAddress);
+ StatusCode sc = ddAddr->fromString(refAddress);
+ if (sc.isFailure())
+ {
+ MsgStream log(msgSvc(), name());
+ log << MSG::FATAL << "Unable to create opaque address" << endmsg;
+ return sc;
+ }
}
catch(...) {
refpAddress = 0;
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/CMakeLists.txt b/DetectorDescription/GeoModel/FaserGeoModel/CMakeLists.txt
index 2e739f4fe1091a06b220841dbfddffcd55a3599a..2086d60b12f50e223aa3bf0f0230ca8717aee6c7 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/CMakeLists.txt
+++ b/DetectorDescription/GeoModel/FaserGeoModel/CMakeLists.txt
@@ -1,21 +1,25 @@
###############################
# Package: FaserGeoModel
###############################
+option( INSTALL_GEOMDB "Generate and install a geometry database" OFF )
# Declare package name
atlas_subdir( FaserGeoModel )
+if (INSTALL_GEOMDB)
add_custom_command (
- OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/geomDB_sqlite
+ OUTPUT ${CMAKE_BINARY_DIR}/data/geomDB_sqlite
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/geomDB.sql
- COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/data/geomDB.sql | sqlite3 ${CMAKE_CURRENT_BINARY_DIR}/geomDB_sqlite
+ COMMAND mkdir -p ${CMAKE_BINARY_DIR}/data
+ COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/data/geomDB.sql | sqlite3 ${CMAKE_BINARY_DIR}/data/geomDB_sqlite
)
-add_custom_target( geomDB ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/geomDB_sqlite )
+ add_custom_target( geomDB ALL DEPENDS ${CMAKE_BINARY_DIR}/data/geomDB_sqlite )
-# Install the generated file:
-install( FILES ${CMAKE_CURRENT_BINARY_DIR}/geomDB_sqlite
- DESTINATION ${CMAKE_INSTALL_DATADIR} )
+ # Install the generated file:
+ install( FILES ${CMAKE_BINARY_DIR}/data/geomDB_sqlite
+ DESTINATION ${CMAKE_INSTALL_DATADIR} )
+endif()
# Install python files from the package:
atlas_install_python_modules( python/*.py )
@@ -26,6 +30,6 @@ atlas_install_xmls( data/*.xml data/*.dtd )
atlas_install_scripts( test/*.py )
atlas_add_test( EVNT_InputGeo_test
- SCRIPT test/FaserGeometryConfig_EVNT_test.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/FaserGeometryConfig_EVNT_test.py
PROPERTIES TIMEOUT 300
- PROPERTIES WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+ PROPERTIES WORKING_DIRECTORY ${CMAKE_BINARY_DIR} )
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/python/DipoleGMConfig.py b/DetectorDescription/GeoModel/FaserGeoModel/python/DipoleGMConfig.py
index bd096f18362225f9499d4a0c57afc5996dc14b13..3c78e5f70734f2ad43c7d3589e6fb89f097f1048 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/python/DipoleGMConfig.py
+++ b/DetectorDescription/GeoModel/FaserGeoModel/python/DipoleGMConfig.py
@@ -12,7 +12,7 @@ def DipoleGeometryCfg (flags):
if __name__ == "__main__":
- import os
+ # import os
from AthenaCommon.Logging import log
from AthenaCommon.Constants import DEBUG
from AthenaCommon.Configurable import Configurable
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/python/FaserGeoModelConfig.py b/DetectorDescription/GeoModel/FaserGeoModel/python/FaserGeoModelConfig.py
index 37baa0e45cc652d9b5ea16e2bafca4a4dd938a4b..e42d3c12cfcea8422b79c94427ed5acb607170d3 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/python/FaserGeoModelConfig.py
+++ b/DetectorDescription/GeoModel/FaserGeoModel/python/FaserGeoModelConfig.py
@@ -10,7 +10,7 @@ def FaserGeometryCfg (flags):
# Hack to avoid randomly failing to find sqlite file
poolSvc = CompFactory.PoolSvc()
- poolSvc.SortReplicas = False
+ # poolSvc.SortReplicas = False
acc.addService(poolSvc)
if flags.Detector.SimulateScintillator or flags.Detector.GeometryScintillator:
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/python/GeoModelConfig.py b/DetectorDescription/GeoModel/FaserGeoModel/python/GeoModelConfig.py
index 40675be179b6a7a443daa260b3ce5d3ab17dd1b9..2b14e217fb20ec6f7abc72075420dd98fc251d0c 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/python/GeoModelConfig.py
+++ b/DetectorDescription/GeoModel/FaserGeoModel/python/GeoModelConfig.py
@@ -1,7 +1,10 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
from __future__ import print_function
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaCommon.Configurable import Configurable
-from AthenaCommon.Constants import VERBOSE
+# from AthenaCommon.Constants import VERBOSE
def GeoModelCfg(configFlags):
version = configFlags.GeoModel.FaserVersion
@@ -15,7 +18,7 @@ def GeoModelCfg(configFlags):
result=ComponentAccumulator()
- from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
+ GeoModelSvc=CompFactory.GeoModelSvc
gms=GeoModelSvc(FaserVersion=version,
GeoExportFile = geoExportFile,
SupportedGeometry = int(relversion[0])
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/python/ScintGMConfig.py b/DetectorDescription/GeoModel/FaserGeoModel/python/ScintGMConfig.py
index cecd5e6bcf2b36d5ece6fa4ea2e4e6a00ca92913..10488b0a881178756230345835ab8bc0f00d971d 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/python/ScintGMConfig.py
+++ b/DetectorDescription/GeoModel/FaserGeoModel/python/ScintGMConfig.py
@@ -20,7 +20,7 @@ def ScintGeometryCfg (flags):
if __name__ == "__main__":
- import os
+ # import os
from AthenaCommon.Logging import log
from AthenaCommon.Constants import DEBUG
from AthenaCommon.Configurable import Configurable
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/test/FaserGeometryConfig_EVNT_test.py b/DetectorDescription/GeoModel/FaserGeoModel/test/FaserGeometryConfig_EVNT_test.py
index 4ceb868f1c986d8e8b303a3f793db5ce119b9019..7320c4ae9f2304d05839b07f2a95f3824e2d4452 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/test/FaserGeometryConfig_EVNT_test.py
+++ b/DetectorDescription/GeoModel/FaserGeoModel/test/FaserGeometryConfig_EVNT_test.py
@@ -50,7 +50,7 @@ if __name__ == "__main__":
acc.printConfig(withDetails=True)
f=open('FaserGeoModelCfg_EVNT.pkl','w')
- acc.store(f, useBootStrapFile = False)
+ acc.store(f)
f.close()
ConfigFlags.dump()
# Execute and finish
diff --git a/MagneticField/FaserBFieldData/CMakeLists.txt b/MagneticField/FaserBFieldData/CMakeLists.txt
index efc21479e2cf582f2138a313b023ad3f10147a45..fa3f6c6e9058a02d1f2c96256d0b3365f4b1b7e7 100644
--- a/MagneticField/FaserBFieldData/CMakeLists.txt
+++ b/MagneticField/FaserBFieldData/CMakeLists.txt
@@ -1,6 +1,7 @@
################################################################################
# Package: FaserBFieldData
################################################################################
+option( INSTALL_BFIELD "Generate and install a field map" OFF )
# Declare the package name:
atlas_subdir( FaserBFieldData )
@@ -9,17 +10,19 @@ find_package( ROOT REQUIRED COMPONENTS Core )
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/share/doTranslation.C.in ${CMAKE_CURRENT_BINARY_DIR}/share/doTranslation.C)
-add_custom_command (
- OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/FaserFieldTable.root
- DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/FieldTable.csv ${CMAKE_CURRENT_SOURCE_DIR}/share/*.C ${CMAKE_CURRENT_SOURCE_DIR}/share/*.in
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/share
- COMMAND ${ROOTSYS}/bin/root -l -b -q -e '.x doTranslation.C'
- )
-
-add_custom_target( FieldTable ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/FaserFieldTable.root )
-
-# Install the generated file:
-install( FILES ${CMAKE_CURRENT_BINARY_DIR}/FaserFieldTable.root
- DESTINATION ${CMAKE_INSTALL_DATADIR} )
-
+if (INSTALL_BFIELD)
+ add_custom_command (
+ OUTPUT ${CMAKE_BINARY_DIR}/data/MagneticFieldMaps/FaserFieldTable.root
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/FieldTable.csv ${CMAKE_CURRENT_SOURCE_DIR}/share/*.C ${CMAKE_CURRENT_SOURCE_DIR}/share/*.in
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/share
+ COMMAND mkdir -p ${CMAKE_BINARY_DIR}/data/MagneticFieldMaps
+ COMMAND ${ROOTSYS}/bin/root -l -b -q -e '.x doTranslation.C'
+ )
+
+ add_custom_target( FieldTable ALL DEPENDS ${CMAKE_BINARY_DIR}/data/MagneticFieldMaps/FaserFieldTable.root )
+
+ # Install the generated file:
+ install( FILES ${CMAKE_BINARY_DIR}/data/MagneticFieldMaps/FaserFieldTable.root
+ DESTINATION ${CMAKE_INSTALL_DATADIR}/MagneticFieldMaps )
+endif()
diff --git a/MagneticField/FaserBFieldData/share/doTranslation.C.in b/MagneticField/FaserBFieldData/share/doTranslation.C.in
index de3c618617a0afb4b5d439c49a640a9b3630a81a..010990a6abdf50ee4553b7446a5ab90075c98a1c 100644
--- a/MagneticField/FaserBFieldData/share/doTranslation.C.in
+++ b/MagneticField/FaserBFieldData/share/doTranslation.C.in
@@ -2,5 +2,5 @@
void doTranslation()
{
// could not get this to work directly on root the command line
- translateBFieldMap("${CMAKE_CURRENT_SOURCE_DIR}/data/FieldTable.csv","${CMAKE_CURRENT_BINARY_DIR}/FaserFieldTable.root",1.0,1.0);
+ translateBFieldMap("${CMAKE_CURRENT_SOURCE_DIR}/data/FieldTable.csv","${CMAKE_BINARY_DIR}/data/MagneticFieldMaps/FaserFieldTable.root",1.0,1.0);
}
\ No newline at end of file
diff --git a/MagneticField/MagFieldConditions/CMakeLists.txt b/MagneticField/MagFieldConditions/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d54b1e2dcc6d7091c2c37bee70cbe32c24d89db
--- /dev/null
+++ b/MagneticField/MagFieldConditions/CMakeLists.txt
@@ -0,0 +1,27 @@
+################################################################################
+# Package: MagFieldConditions
+################################################################################
+
+# Declare the package name:
+atlas_subdir( MagFieldConditions )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/StoreGate
+ MagneticField/MagFieldInterfaces
+ GaudiKernel
+ PRIVATE
+ MagneticField/MagFieldElements
+ )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( MagFieldConditions
+ src/*.cxx
+ PUBLIC_HEADERS MagFieldConditions
+ PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES SGTools GaudiKernel StoreGateLib
+ PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} MagFieldElements)
+
diff --git a/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldCacheCondObj.h b/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldCacheCondObj.h
new file mode 100644
index 0000000000000000000000000000000000000000..1571a71ea52f8174c35855d3df2c762b86215f65
--- /dev/null
+++ b/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldCacheCondObj.h
@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MAGFIELDCONDITIONS_FASERFIELDCACHECONDOBJ
+#define MAGFIELDCONDITIONS_FASERFIELDCACHECONDOBJ
+
+// MagField includes
+#include "AthenaKernel/CondCont.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "MagFieldElements/FaserFieldCache.h"
+
+// forward declarations
+namespace MagField {
+ class FaserFieldMap;
+}
+
+
+class FaserFieldCacheCondObj {
+
+public:
+ FaserFieldCacheCondObj();
+
+ ~FaserFieldCacheCondObj();
+
+ /** get B field cache for evaluation as a function of 2-d (solenoid) or 3-d (toroid) position.
+ Resets cache to an initialized state */
+ inline void getInitializedCache (MagField::FaserFieldCache& cache) const;
+
+ double dipoleFieldScaleFactor() const { return m_dipoleFieldScale; }
+
+ /** set values for field scale and service to be able to build the cache **/
+ bool initialize(double dipoleFieldScale,
+ const MagField::FaserFieldMap* fieldMap);
+
+private:
+ /// Temporary flag for switching between 'old' and 'new' magField usage
+ double m_dipoleFieldScale{1};
+ const MagField::FaserFieldMap* m_fieldMap{nullptr};
+};
+
+// inline function(s)
+
+void
+FaserFieldCacheCondObj::getInitializedCache (MagField::FaserFieldCache& cache) const
+{
+
+ // setup with field scale and magnetic field service for first access to field */
+ cache = MagField::FaserFieldCache(m_dipoleFieldScale, m_fieldMap);
+}
+
+
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserFieldCacheCondObj, 246495246, 1)
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF (FaserFieldCacheCondObj, 90336330);
+
+
+#endif // MAGFIELDCONDITIONS_FASERFIELDCACHECONDOBJ
+
diff --git a/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldMapCondObj.h b/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldMapCondObj.h
new file mode 100644
index 0000000000000000000000000000000000000000..9eebd95344980ada7e5ed742a55a5ecf085f71be
--- /dev/null
+++ b/MagneticField/MagFieldConditions/MagFieldConditions/FaserFieldMapCondObj.h
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MAGFIELDCONDITIONS_FASERFIELDMAPCONDOBJ
+#define MAGFIELDCONDITIONS_FASERFIELDMAPCONDOBJ
+
+// MagField includes
+#include "AthenaKernel/CondCont.h"
+#include "MagFieldElements/FaserFieldMap.h"
+
+class FaserFieldMapCondObj {
+
+public:
+ FaserFieldMapCondObj();
+
+ ~FaserFieldMapCondObj();
+
+ // access to field map
+ const MagField::FaserFieldMap* fieldMap () const;
+
+ // setter
+ void setFieldMap(std::unique_ptr<MagField::FaserFieldMap> fieldMap);
+
+private:
+ // field map
+ std::unique_ptr<MagField::FaserFieldMap> m_fieldMap;
+};
+
+
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserFieldMapCondObj, 218239424, 1)
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF (FaserFieldMapCondObj, 16498296);
+
+
+#endif // MAGFIELDCONDITIONS_FASERFIELDMAPCONDOBJ
+
diff --git a/MagneticField/MagFieldConditions/src/FaserFieldCacheCondObj.cxx b/MagneticField/MagFieldConditions/src/FaserFieldCacheCondObj.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..81deb3d8d6174f7de471074bdd73953f57c25c39
--- /dev/null
+++ b/MagneticField/MagFieldConditions/src/FaserFieldCacheCondObj.cxx
@@ -0,0 +1,20 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+#include "MagFieldConditions/FaserFieldCacheCondObj.h"
+
+FaserFieldCacheCondObj::FaserFieldCacheCondObj()
+{}
+
+FaserFieldCacheCondObj::~FaserFieldCacheCondObj() {}
+
+
+bool
+FaserFieldCacheCondObj::initialize(double dipFieldScale,
+ const MagField::FaserFieldMap* fieldMap)
+{
+ m_dipoleFieldScale = dipFieldScale;
+ m_fieldMap = fieldMap;
+ return (m_fieldMap) != nullptr; // return false if cast failed
+}
+
diff --git a/MagneticField/MagFieldConditions/src/FaserFieldMapCondObj.cxx b/MagneticField/MagFieldConditions/src/FaserFieldMapCondObj.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b6f5aa841ba0b3fab559999f196fb6e7f82fb63b
--- /dev/null
+++ b/MagneticField/MagFieldConditions/src/FaserFieldMapCondObj.cxx
@@ -0,0 +1,23 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#include "MagFieldConditions/FaserFieldMapCondObj.h"
+
+FaserFieldMapCondObj::FaserFieldMapCondObj() {}
+
+FaserFieldMapCondObj::~FaserFieldMapCondObj() {}
+
+// access to field map
+const MagField::FaserFieldMap*
+FaserFieldMapCondObj::fieldMap () const
+{
+ return m_fieldMap.get();
+}
+
+// setter
+void
+FaserFieldMapCondObj::setFieldMap(std::unique_ptr<MagField::FaserFieldMap> fieldMap)
+{
+ m_fieldMap = std::move(fieldMap);
+}
+
diff --git a/MagneticField/MagFieldElements/CMakeLists.txt b/MagneticField/MagFieldElements/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b6245f834186ab4056614f714a32152926b48c3
--- /dev/null
+++ b/MagneticField/MagFieldElements/CMakeLists.txt
@@ -0,0 +1,35 @@
+################################################################################
+# Package: MagFieldElements
+################################################################################
+
+# Declare the package name:
+atlas_subdir( MagFieldElements )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaBaseComps
+ MagneticField/MagFieldInterfaces
+ MagneticField/MagFieldConditions
+ Control/CxxUtils
+ PRIVATE
+ MagneticField/MagFieldElements
+ Control/StoreGate
+ Database/AthenaPOOL/AthenaPoolUtilities
+ GaudiKernel
+ Tools/PathResolver )
+
+# External dependencies:
+find_package( CLHEP )
+find_package( Eigen )
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( MagFieldElements
+ src/*.cxx
+ PUBLIC_HEADERS MagFieldElements
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} ${EIGEN_LIBRARIES} AthenaBaseComps GaudiKernel CxxUtils)
+
+# Install files from the package:
+atlas_install_headers( MagFieldElements )
+
diff --git a/MagneticField/MagFieldElements/MagFieldElements/ATLAS_CHECK_THREAD_SAFETY b/MagneticField/MagFieldElements/MagFieldElements/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..20f688aa3dfdd023a247a09b37697a89dfac0df4
--- /dev/null
+++ b/MagneticField/MagFieldElements/MagFieldElements/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+MagneticField/FaserMagFieldElements
\ No newline at end of file
diff --git a/MagneticField/MagFieldServices/src/BFieldCache.h b/MagneticField/MagFieldElements/MagFieldElements/BFieldCache.h
similarity index 73%
rename from MagneticField/MagFieldServices/src/BFieldCache.h
rename to MagneticField/MagFieldElements/MagFieldElements/BFieldCache.h
index 194aaef5d31dd562a5c603da1db5df70d089bdb5..41e7dd8c5f030af701b7de81cc8f0677e55924a1 100644
--- a/MagneticField/MagFieldServices/src/BFieldCache.h
+++ b/MagneticField/MagFieldElements/MagFieldElements/BFieldCache.h
@@ -1,12 +1,12 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
//
// BFieldCache.h
//
-// Cache of one bin of the magnetic field map.
-// Defined by ranges in x, y, z, and the B vectors at the 8 corners of the "bin".
+// Cashe of one bin of the magnetic field map.
+// Defined by ranges in z, r, phi, and the B vectors at the 8 corners of the "bin".
//
// Masahiro Morii, Harvard University
//
@@ -15,7 +15,7 @@
#include <iostream>
#include <cmath>
-#include "BFieldVector.h"
+#include "MagFieldElements/BFieldVector.h"
class BFieldCache {
public:
@@ -23,24 +23,28 @@ public:
BFieldCache() : m_xmin(0.0), m_xmax(0.0), m_ymin(0.0), m_ymax(0.0), m_zmin(0.0), m_zmax(-1.0) {;}
// make this cache invalid, so that inside() will fail
void invalidate() { m_zmin = 0.0; m_zmax = -1.0; }
- // set the x, y, z range that defines the bin
+ // set the z, r, phi range that defines the bin
void setRange( double xmin, double xmax, double ymin, double ymax, double zmin, double zmax )
{ m_xmin = xmin; m_xmax = xmax; m_ymin = ymin; m_ymax = ymax; m_zmin = zmin; m_zmax = zmax;
m_invx = 1.0/(xmax-xmin); m_invy = 1.0/(ymax-ymin); m_invz = 1.0/(zmax-zmin); }
- // set the field values at each corner
- void setField( int i, const BFieldVector<double> &field ) { for(int j=0; j<3; j++) m_field[j][i] = field[j]; }
- void setField( int i, const BFieldVector<short> &field ) { for(int j=0; j<3; j++) m_field[j][i] = field[j]; } // set the multiplicative factor for the field vectors
+ // set the field values at each corner (rescale for current scale factor)
+ void setField( int i, const BFieldVector<double> &field, double scaleFactor = 1.0 )
+ { for(int j=0; j<3; j++) m_field[j][i] = scaleFactor * field[j]; }
+ void setField( int i, const BFieldVector<short> &field, double scaleFactor = 1.0 )
+ { for(int j=0; j<3; j++) m_field[j][i] = scaleFactor * field[j]; }
+ // set the multiplicative factor for the field vectors
void setBscale( double bscale ) { m_scale = bscale; }
- // test if (x, y, z) is inside this bin
+ float bscale() { return m_scale; }
+ // test if (z, r, phi) is inside this bin
bool inside( double x, double y, double z ) const
- { return ( x >= m_xmin && x <= m_xmax && y >= m_ymin && y <= m_ymax && z >= m_zmin && z <= m_zmax ); }
+ { return ( z >= m_zmin && z <= m_zmax && x >= m_xmin && x <= m_xmax && y >= m_ymin && y <= m_ymax ); }
// interpolate the field and return B[3].
// also compute field derivatives if deriv[9] is given.
- inline void getB( const double *xyz, double *B, double *deriv=0 ) const;
+ inline void getB( const double *xyz, double *B, double *deriv=nullptr ) const;
private:
- double m_xmin, m_xmax; // bin range in x
- double m_ymin, m_ymax; // bin range in y
- double m_zmin, m_zmax; // bin range in z
+ double m_xmin, m_xmax; // bin range in z
+ double m_ymin, m_ymax; // bin range in r
+ double m_zmin, m_zmax; // bin range in phi
float m_invx, m_invy, m_invz; // 1/(bin size) in x, y, z
float m_field[3][8]; // (Bx,By,Bz) at 8 corners of the bin
float m_scale; // unit of m_field in kT
@@ -75,7 +79,9 @@ BFieldCache::getB( const double *xyz, double *B, double *deriv ) const
float sx = m_scale*m_invx;
float sy = m_scale*m_invy;
float sz = m_scale*m_invz;
- float dBdx[3], dBdy[3], dBdz[3];
+ float dBdx[3];
+ float dBdy[3];
+ float dBdz[3];
for ( int j = 0; j < 3; j++ ) { // Bz, Br, Bphi components
const float *field = m_field[j];
dBdx[j] = sx*( gy*( gz*(field[4]-field[0]) + fz*(field[5]-field[1]) ) +
diff --git a/MagneticField/MagFieldServices/src/BFieldMesh.h b/MagneticField/MagFieldElements/MagFieldElements/BFieldMesh.h
similarity index 90%
rename from MagneticField/MagFieldServices/src/BFieldMesh.h
rename to MagneticField/MagFieldElements/MagFieldElements/BFieldMesh.h
index 40a30dc36f3180bf2f1cc7a71145167d5f33b939..06cc7d4214349cf0f18c86cec76832d60d26ea5e 100644
--- a/MagneticField/MagFieldServices/src/BFieldMesh.h
+++ b/MagneticField/MagFieldElements/MagFieldElements/BFieldMesh.h
@@ -16,8 +16,8 @@
#include <iostream>
#include <vector>
#include <cmath>
-#include "BFieldVector.h"
-#include "BFieldCache.h"
+#include "MagFieldElements/BFieldVector.h"
+#include "MagFieldElements/BFieldCache.h"
template <class T>
class BFieldMesh {
@@ -46,9 +46,9 @@ public:
// test if a point is inside this zone
inline bool inside( double x, double y, double z ) const;
// find the bin
- inline void getCache( double x, double y, double z, BFieldCache & cache ) const;
+ inline void getCache( double x, double y, double z, BFieldCache & cache, double scaleFactor = 1.0 ) const;
// get the B field
- void getB( const double *xyz, double *B, double* deriv=0 ) const;
+ void getB( const double *xyz, double *B, double* deriv=nullptr ) const;
// accessors
double min( int i ) const { return m_min[i]; }
double max( int i ) const { return m_max[i]; }
@@ -107,7 +107,7 @@ bool BFieldMesh<T>::inside( double x, double y, double z ) const
// Find and return the cache of the bin containing (x,y,z)
//
template <class T>
-void BFieldMesh<T>::getCache( double x, double y, double z, BFieldCache & cache ) const
+void BFieldMesh<T>::getCache( double x, double y, double z, BFieldCache & cache, double scaleFactor ) const
{
// find the mesh, and relative location in the mesh
// x
@@ -137,17 +137,16 @@ void BFieldMesh<T>::getCache( double x, double y, double z, BFieldCache & cache
// cache.setField( 5, m_field[im0+m_zoff +1] ); // z+1,r,phi+1 => x+1,y,z+1
// cache.setField( 6, m_field[im0+m_zoff+m_roff ] );// z+1,r+1,phi => x+1,y+1,z
// cache.setField( 7, m_field[im0+m_zoff+m_roff+1] );// z+1,r+1,phi+1 => x+1,y+1,z+1
- cache.setField( 0, m_field[im0 ] ); // z,r,phi => x,y,z
- cache.setField( 1, m_field[im0 +1] ); // z,r,phi+1 => x,y,z+1
- cache.setField( 2, m_field[im0 +m_yoff ] ); // z,r+1,phi => x,y+1,z
- cache.setField( 3, m_field[im0 +m_yoff+1] ); // z,r+1,phi+1 => x,y+1,z+1
- cache.setField( 4, m_field[im0+m_xoff ] ); // z+1,r,phi => x+1,y,z
- cache.setField( 5, m_field[im0+m_xoff +1] ); // z+1,r,phi+1 => x+1,y,z+1
- cache.setField( 6, m_field[im0+m_xoff+m_yoff ] ); // z+1,r+1,phi => x+1,y+1,z
- cache.setField( 7, m_field[im0+m_xoff+m_yoff+1] ); // z+1,r+1,phi+1 => x+1,y+1,z+1
+ cache.setField( 0, m_field[im0 ], scaleFactor ); // z,r,phi => x,y,z
+ cache.setField( 1, m_field[im0 +1], scaleFactor ); // z,r,phi+1 => x,y,z+1
+ cache.setField( 2, m_field[im0 +m_yoff ], scaleFactor ); // z,r+1,phi => x,y+1,z
+ cache.setField( 3, m_field[im0 +m_yoff+1], scaleFactor ); // z,r+1,phi+1 => x,y+1,z+1
+ cache.setField( 4, m_field[im0+m_xoff ], scaleFactor ); // z+1,r,phi => x+1,y,z
+ cache.setField( 5, m_field[im0+m_xoff +1], scaleFactor ); // z+1,r,phi+1 => x+1,y,z+1
+ cache.setField( 6, m_field[im0+m_xoff+m_yoff ], scaleFactor ); // z+1,r+1,phi => x+1,y+1,z
+ cache.setField( 7, m_field[im0+m_xoff+m_yoff+1], scaleFactor ); // z+1,r+1,phi+1 => x+1,y+1,z+1
// store the B scale
cache.setBscale( m_scale );
- return;
}
//
@@ -212,7 +211,9 @@ void BFieldMesh<T>::getB( const double *xyz, double *B, double* deriv ) const
double sx = m_scale/(mx[ix+1]-mx[ix]);
double sy = m_scale/(my[iy+1]-my[iy]);
double sz = m_scale/(mz[iz+1]-mz[iz]);
- double dBdx[3], dBdy[3], dBdz[3];
+ double dBdx[3];
+ double dBdy[3];
+ double dBdz[3];
for ( int j = 0; j < 3; j++ ) { // Bz, Br, Bphi components
dBdx[j] = sx*( gy*( gz*(field[4][j]-field[0][j]) + fz*(field[5][j]-field[1][j]) ) +
fy*( gz*(field[6][j]-field[2][j]) + fz*(field[7][j]-field[3][j]) ) );
@@ -231,7 +232,6 @@ void BFieldMesh<T>::getB( const double *xyz, double *B, double* deriv ) const
deriv[7] = dBdy[2];
deriv[8] = dBdz[2];
}
- return;
}
//
diff --git a/MagneticField/MagFieldServices/src/BFieldVector.h b/MagneticField/MagFieldElements/MagFieldElements/BFieldVector.h
similarity index 100%
rename from MagneticField/MagFieldServices/src/BFieldVector.h
rename to MagneticField/MagFieldElements/MagFieldElements/BFieldVector.h
diff --git a/MagneticField/MagFieldServices/src/BFieldZone.h b/MagneticField/MagFieldElements/MagFieldElements/BFieldZone.h
similarity index 56%
rename from MagneticField/MagFieldServices/src/BFieldZone.h
rename to MagneticField/MagFieldElements/MagFieldElements/BFieldZone.h
index 40c64f3287e5fb622df8cadf97aec5e25805811f..efc2e18d26aee944ede7e85b27c49461e04ab7ad 100644
--- a/MagneticField/MagFieldServices/src/BFieldZone.h
+++ b/MagneticField/MagFieldElements/MagFieldElements/BFieldZone.h
@@ -13,8 +13,7 @@
#define BFIELDZONE_H
#include <vector>
-#include "BFieldMesh.h"
-// #include "MagFieldServices/BFieldCond.h"
+#include "MagFieldElements/BFieldMesh.h"
class BFieldZone : public BFieldMesh<short> {
public:
@@ -22,18 +21,11 @@ public:
BFieldZone( int id, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax,
double scale )
: BFieldMesh<short>(xmin,xmax,ymin,ymax,zmin,zmax,scale), m_id(id) {;}
- // add elements to vectors
- // void appendCond( const BFieldCond& cond ) { m_cond.push_back(cond); }
- // compute Biot-Savart magnetic field and add to B[3]
- // inline void addBiotSavart( const double *xyz, double *B, double *deriv=0 ) const;
// scale B field by a multiplicative factor
void scaleField( double factor )
{ scaleBscale(factor); /*for (unsigned i=0; i<ncond(); i++) { m_cond[i].scaleCurrent(factor); }*/ }
// accessors
int id() const { return m_id; }
- // unsigned ncond() const { return m_cond.size(); }
- // const BFieldCond& cond(int i) const { return m_cond[i]; }
- // const std::vector<BFieldCond> *condVector() const { return &m_cond; }
int memSize() const
{ return BFieldMesh<short>::memSize() /*+ sizeof(int) + sizeof(BFieldCond)*m_cond.capacity()*/; }
// adjust the min/max edges to a new value
@@ -41,20 +33,6 @@ public:
void adjustMax( int i, double x ) { m_max[i] = x; m_mesh[i].back() = x; }
private:
int m_id; // zone ID number
- // std::vector<BFieldCond> m_cond; // list of current conductors
};
-// inline functions
-
-//
-// Compute magnetic field due to the conductors
-//
-// void
-// BFieldZone::addBiotSavart( const double *xyz, double *B, double *deriv ) const
-// {
-// for ( unsigned i = 0; i < m_cond.size(); i++ ) {
-// m_cond[i].addBiotSavart( xyz, B, deriv );
-// }
-// }
-
#endif
diff --git a/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h
new file mode 100644
index 0000000000000000000000000000000000000000..6011b4658c310962a68f6dd63d65caa81435617e
--- /dev/null
+++ b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h
@@ -0,0 +1,211 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @author R.D.Schaffer -at- cern.ch
+ * @date July 2019
+ * @brief Local cache for magnetic field (based on MagFieldServices/FaserFieldSvcTLS.h)
+ */
+
+#ifndef MAGFIELDELEMENTS_FASERFIELDCACHE_H
+#define MAGFIELDELEMENTS_FASERFIELDCACHE_H 1
+
+// MagField includes
+#include "MagFieldElements/FaserFieldMap.h"
+#include "MagFieldElements/BFieldCache.h"
+// #include "MagFieldElements/BFieldCacheZR.h"
+// #include "MagFieldElements/BFieldCond.h"
+#include "MagFieldElements/BFieldZone.h"
+// #include "MagFieldElements/BFieldMeshZR.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "CxxUtils/restrict.h"
+// CLHEP
+#include "CLHEP/Units/SystemOfUnits.h"
+#include<iostream>
+#include <memory>
+namespace MagField {
+
+
+/** @class FaserFieldCache
+ *
+ * @brief Local cache for magnetic field (based on MagFieldServices/FaserFieldSvcTLS.h)
+ *
+ * @author R.D.Schaffer -at- cern.ch
+ */
+ class FaserFieldCache
+ // : public ::AthMessaging
+ {
+ public:
+ FaserFieldCache();
+ // ** constructor to setup with field scale and magnetic field service for first access to field */
+ FaserFieldCache(double fieldScale,
+ const FaserFieldMap* fieldMap);
+ FaserFieldCache& operator= (FaserFieldCache&& other) = default;
+ ~FaserFieldCache() = default;
+
+ /** get B field value at given position */
+ /** xyz[3] is in mm, bxyz[3] is in kT */
+ /** if deriv[9] is given, field derivatives are returned in kT/mm */
+ inline void getField (const double* ATH_RESTRICT xyz,
+ double* ATH_RESTRICT bxyz,
+ double* ATH_RESTRICT deriv = nullptr);
+ // inline void getFieldZR(const double* ATH_RESTRICT xyz,
+ // double* ATH_RESTRICT bxyz,
+ // double* ATH_RESTRICT deriv = nullptr);
+
+ private:
+
+ FaserFieldCache(const FaserFieldCache& other) = delete;
+ FaserFieldCache& operator= (const FaserFieldCache& other) = delete;
+ FaserFieldCache(FaserFieldCache&& other) = delete;
+
+ inline bool fillFieldCache(double x, double y, double z);
+ // inline bool fillFieldCacheZR(double z, double r);
+
+ /// magnetic field scales from currents
+ // double m_solScale{1};
+ // double m_torScale{1};
+ double m_scale{1};
+ double m_scaleToUse{1};
+ // Solenoid zone ID number - needed to set solScale. Assumes only one Solenoid zone!
+ // int m_solZoneId{-1};
+
+ /// handle to the magnetic field service - not owner
+ const FaserFieldMap* m_fieldMap;
+
+ /// Pointer to the conductors in the current field zone (to compute Biot-Savart component)
+ /// Owned by AtlasFieldMap.
+ // const std::vector<BFieldCond>* m_cond{nullptr};
+
+ /// Full 3d field
+ BFieldCache m_cache3d;
+
+ /// Fast 2d field
+ // BFieldCacheZR m_cacheZR;
+
+ // fast 2d map (made of one zone)
+ /// Owned by AtlasFieldMap.
+ // const BFieldMeshZR* m_meshZR{nullptr};
+
+ };
+
+} // namespace MagField
+
+
+/** fill given magnetic field zone */
+bool
+MagField::FaserFieldCache::fillFieldCache(double x, double y, double z)
+{
+ // search for the zone
+ const BFieldZone* zone = m_fieldMap->findBFieldZone( x, y, z );
+ if ( zone == nullptr ) {
+ // outsize all zones
+ return false;
+ }
+
+ // set scale for field - preserve logic for possible dipole-dependent zones
+ // if (zone->id() == m_solZoneId) {
+ // m_scaleToUse = m_solScale;
+ // }
+ // else {
+ // m_scaleToUse = m_torScale;
+ // }
+ m_scaleToUse = m_scale;
+
+ // fill the cache, pass in current scale factor
+ zone->getCache( x, y, z, m_cache3d, m_scaleToUse );
+
+ // save pointer to the conductors in the zone
+ // m_cond = zone->condVector();
+
+ return true;
+}
+
+/** fill Z-R cache for solenoid */
+// bool
+// MagField::AtlasFieldCache::fillFieldCacheZR(double z, double r)
+// {
+// // is it inside the solenoid zone?
+// if ( m_meshZR && m_meshZR->inside( z, r ) ) {
+
+// // fill the cache, pass in current scale factor
+// m_meshZR->getCache( z, r, m_cacheZR, m_solScale );
+
+// } else {
+// // outside solenoid
+// return false;
+// }
+// return true;
+// }
+
+
+void
+MagField::FaserFieldCache::getField(const double* ATH_RESTRICT xyz,
+ double* ATH_RESTRICT bxyz,
+ double* ATH_RESTRICT deriv)
+{
+ const double &x(xyz[0]);
+ const double &y(xyz[1]);
+ const double &z(xyz[2]);
+ // double r = std::sqrt(x * x + y * y);
+ // double phi = std::atan2(y, x);
+
+ // test if initialised and the cache is valid
+ if ( !m_cache3d.inside(x, y, z) ) {
+ // cache is invalid -> refresh cache
+ if (!fillFieldCache(x, y, z)) {
+ // caching failed -> outside the valid map volume
+ // return default field (0.1 gauss)
+ const double defaultB(0.1*CLHEP::gauss);
+ bxyz[0] = bxyz[1] = bxyz[2] = defaultB;
+ // return zero gradient if requested
+ if ( deriv ) {
+ for ( int i = 0; i < 9; i++ ) {
+ deriv[i] = 0.;
+ }
+ }
+ return;
+ }
+ }
+
+ // do interpolation (cache3d has correct scale factor)
+ m_cache3d.getB(xyz, bxyz, deriv);
+ // add biot savart component - must add in scale factor to avoid changing conductor SF since the
+ // conductor is part of the static magnetic field model
+ // if (m_cond) {
+ // const size_t condSize = m_cond->size();
+ // for (size_t i = 0; i < condSize; i++) {
+ // (*m_cond)[i].addBiotSavart(m_scaleToUse, xyz, bxyz, deriv);
+ // }
+ // }
+}
+
+// void
+// MagField::AtlasFieldCache::getFieldZR(const double* ATH_RESTRICT xyz,
+// double* ATH_RESTRICT bxyz,
+// double* ATH_RESTRICT deriv)
+// {
+// const double &x(xyz[0]);
+// const double &y(xyz[1]);
+// const double &z(xyz[2]);
+// double r = sqrt(x * x + y * y);
+
+// // test if the cache was initialized and the ZR cache is valid for current position
+// if ( !m_cacheZR.inside(z, r) ) {
+
+// // cache is invalid -> refresh cache
+// if (!fillFieldCacheZR(z, r)) {
+
+// // caching failed -> outside the valid z-r map volume
+// // call the full version of getField()
+// getField(xyz, bxyz, deriv);
+// return;
+
+// }
+// }
+// // do interpolation
+// m_cacheZR.getB(xyz, r, bxyz, deriv);
+// }
+
+#endif // MAGFIELDELEMENTS_FASERFIELDCACHE_H
diff --git a/MagneticField/MagFieldElements/MagFieldElements/FaserFieldMap.h b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldMap.h
new file mode 100644
index 0000000000000000000000000000000000000000..77ac3c772a0a0ffcfdeb64d96ee56c2deb363820
--- /dev/null
+++ b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldMap.h
@@ -0,0 +1,120 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @author R.D.Schaffer -at- cern.ch
+ * @date end 2019
+ * @brief Local cache for magnetic field (based on MagFieldServices/FaserFieldSvcTLS.h)
+ */
+
+#ifndef MAGFIELDELEMENTS_FASERFIELDMAP_H
+#define MAGFIELDELEMENTS_FASERFIELDMAP_H 1
+
+// MagField includes
+#include "MagFieldElements/BFieldCache.h"
+// #include "MagFieldElements/BFieldCacheZR.h"
+// #include "MagFieldElements/BFieldCond.h"
+#include "MagFieldElements/BFieldZone.h"
+// #include "MagFieldElements/BFieldMeshZR.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "CxxUtils/restrict.h"
+// CLHEP
+#include "CLHEP/Units/SystemOfUnits.h"
+#include<iostream>
+#include <memory>
+
+// forward declarations
+class TFile;
+
+namespace MagField {
+
+
+/** @class FaserFieldMap
+ *
+ * @brief Map for magnetic field
+ *
+ * @author R.D.Schaffer -at- cern.ch
+ */
+ class FaserFieldMap
+ {
+ public:
+ FaserFieldMap();
+ ~FaserFieldMap();
+
+ // initialize map from root file
+ bool initializeMap( TFile* rootfile );
+
+ // Functions used by getField[ZR] in FaserFieldCache
+ // search for a "zone" to which the point (z,r,phi) belongs
+ const BFieldZone* findBFieldZone( double z, double r, double phi ) const;
+
+ // fast 2d map (made of one zone)
+ // const BFieldMeshZR* getBFieldMesh() const;
+
+ /** status of the magnets */
+ // bool solenoidOn() const { return solenoidCurrent() > 0.0; }
+ // bool toroidOn() const { return toroidCurrent() > 0.0; }
+ // magnet currents read with map - needed for scaling
+ // float solenoidCurrent() const { return m_solenoidCurrent; }
+ // float toroidCurrent() const { return m_toroidCurrent; }
+ int dipoleZoneId() const { return m_dipoleZoneId; }
+ private:
+
+ FaserFieldMap& operator= (FaserFieldMap&& other) = delete;
+ FaserFieldMap(const FaserFieldMap& other) = delete;
+ FaserFieldMap& operator= (const FaserFieldMap& other) = delete;
+ FaserFieldMap(FaserFieldMap&& other) = delete;
+
+ // slow zone search is used during initialization to build the LUT
+ BFieldZone* findZoneSlow( double z, double r, double phi );
+
+ // utility functions used by readMap
+ int read_packed_data( std::istream& input, std::vector<int>& data ) const;
+ int read_packed_int( std::istream& input, int &n ) const;
+ void buildLUT();
+ // void buildZR();
+
+ /** approximate memory footprint in bytes */
+ int memSize() const;
+
+ /** Data Members **/
+
+ // field map name
+ std::string m_filename;
+
+ // currents read in with map
+ // float m_solenoidCurrent{0}; // solenoid current in ampere
+ // float m_toroidCurrent{0}; // toroid current in ampere
+ int m_dipoleZoneId{-1}; // dipole zone id
+
+ // full 3d map (made of multiple zones)
+ std::vector<BFieldZone> m_zone;
+
+ // fast 2d map (made of one zone)
+ // BFieldMeshZR* m_meshZR{nullptr};
+
+ // data members used in zone-finding
+ std::vector<double> m_edge[3]; // zone boundaries in z, r, phi
+ std::vector<int> m_edgeLUT[3]; // look-up table for zone edges
+ double m_invq[3]; // 1/stepsize in m_edgeLUT
+ std::vector<const BFieldZone*> m_zoneLUT; // look-up table for zones
+ // more data members to speed up zone-finding
+ double m_xmin{0}; // minimum x
+ double m_xmax{0}; // maximum x
+ int m_nx {0}; // number of x bins in zoneLUT
+ double m_ymin{0}; // minimum y
+ double m_ymax{0}; // maximum y
+ int m_ny {0}; // number of r bins in zoneLUT
+ double m_zmin{0}; // minimum z
+ double m_zmax{0}; // maximum z
+ int m_nz {0}; // number of z bins in zoneLUT
+ bool m_mapIsInitialized{false};
+
+ };
+
+} // namespace MagField
+
+
+
+#endif // MAGFIELDELEMENTS_FASERFIELDMAP_H
diff --git a/MagneticField/MagFieldElements/src/FaserFieldCache.cxx b/MagneticField/MagFieldElements/src/FaserFieldCache.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5d08317efd2b4e9847046bee2393b6e808a489e6
--- /dev/null
+++ b/MagneticField/MagFieldElements/src/FaserFieldCache.cxx
@@ -0,0 +1,30 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//
+// FaserFieldCache.cxx
+//
+// Local cache for magnetic field (based on MagFieldServices/FieldFieldSvcTLS.h)
+//
+// R.D.Schaffer -at- cern.ch
+//
+#include "MagFieldElements/FaserFieldCache.h"
+
+/// Constructor
+MagField::FaserFieldCache::FaserFieldCache()
+{}
+
+MagField::FaserFieldCache::FaserFieldCache(double scale,
+ const FaserFieldMap* fieldMap)
+ :
+ // temporary flag
+ m_scale(scale),
+ // set field service
+ m_fieldMap(fieldMap)
+
+{
+
+}
+
+
diff --git a/MagneticField/MagFieldElements/src/FaserFieldMap.cxx b/MagneticField/MagFieldElements/src/FaserFieldMap.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d9aa5df831bcf46d44fdb95775e3c9cb8e049734
--- /dev/null
+++ b/MagneticField/MagFieldElements/src/FaserFieldMap.cxx
@@ -0,0 +1,302 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserFieldMap.cxx, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+// ISF_Services include
+#include "MagFieldElements/FaserFieldMap.h"
+
+// PathResolver
+#include "PathResolver/PathResolver.h"
+
+// CLHEP
+#include "CLHEP/Units/SystemOfUnits.h"
+
+// ROOT
+#include "TFile.h"
+#include "TTree.h"
+
+/** Constructor **/
+MagField::FaserFieldMap::FaserFieldMap()
+{}
+
+
+MagField::FaserFieldMap::~FaserFieldMap()
+{}
+
+// Search for the zone that contains a point (z, r, phi)
+// Fast version utilizing the LUT.
+//
+const BFieldZone*
+MagField::FaserFieldMap::findBFieldZone( double x, double y, double z ) const
+{
+ // make sure it's inside the largest zone
+ // NB: the sign of the logic is chosen in order to return 0 on NaN inputs
+ if ( x >= m_xmin && x <= m_xmax && y >= m_ymin && y <= m_ymax && z >= m_zmin && z <= m_zmax) {
+ // find the edges of the zone
+ // x
+ const std::vector<double>& edgex(m_edge[0]);
+ int ix = int(m_invq[0]*(x-m_xmin)); // index to LUT
+ ix = m_edgeLUT[0][ix]; // tentative index from LUT
+ if ( x > edgex[ix+1] ) ix++;
+ // y
+ const std::vector<double>& edgey(m_edge[1]);
+ int iy = int(m_invq[1]*(y-m_ymin)); // index to LUT
+ iy = m_edgeLUT[1][iy]; // tentative index from LUT
+ if ( y > edgey[iy+1] ) iy++;
+ // z
+ const std::vector<double>& edgez(m_edge[2]);
+ int iz = int(m_invq[2]*(z-m_zmin)); // index to LUT
+ iz = m_edgeLUT[2][iz]; // tentative index from LUT
+ if ( z > edgez[iz+1] ) iz++;
+ // use LUT to get the zone
+ return m_zoneLUT[(ix*m_ny+iy)*m_nz+iz];
+ } else {
+ return nullptr;
+ }
+}
+
+
+//
+// read the map from a ROOT file.
+// returns true if successful.
+//
+bool
+MagField::FaserFieldMap::initializeMap( TFile* rootfile )
+{
+ // open the tree
+ TTree* tree = (TTree*)rootfile->Get("BFieldMap");
+
+ int id;
+ double xmin;
+ double xmax;
+ double ymin;
+ double ymax;
+ double zmin;
+ double zmax;
+ double bscale;
+ int nmeshx;
+ int nmeshy;
+ int nmeshz;
+ double* meshx;
+ double* meshy;
+ double* meshz;
+ int nfield;
+ short* fieldx;
+ short* fieldy;
+ short* fieldz;
+ // define the fixed-sized branches first
+ tree->SetBranchAddress( "id", &id );
+ tree->SetBranchAddress( "xmin", &xmin );
+ tree->SetBranchAddress( "xmax", &xmax );
+ tree->SetBranchAddress( "ymin", &ymin );
+ tree->SetBranchAddress( "ymax", &ymax );
+ tree->SetBranchAddress( "zmin", &zmin );
+ tree->SetBranchAddress( "zmax", &zmax );
+ tree->SetBranchAddress( "bscale", &bscale );
+ // tree->SetBranchAddress( "ncond", &ncond );
+ tree->SetBranchAddress( "nmeshx", &nmeshx );
+ tree->SetBranchAddress( "nmeshy", &nmeshy );
+ tree->SetBranchAddress( "nmeshz", &nmeshz );
+ tree->SetBranchAddress( "nfield", &nfield );
+ // prepare arrays - need to know the maximum sizes
+ // open the tree of buffer sizes (may not exist in old maps)
+ unsigned /*maxcond(0),*/ maxmeshx(0), maxmeshy(0), maxmeshz(0), maxfield(0);
+ TTree* tmax = (TTree*)rootfile->Get("BFieldMapSize");
+ if ( tmax != 0 ) {
+ // tmax->SetBranchAddress( "maxcond", &maxcond );
+ tmax->SetBranchAddress( "maxmeshx", &maxmeshx );
+ tmax->SetBranchAddress( "maxmeshy", &maxmeshy );
+ tmax->SetBranchAddress( "maxmeshz", &maxmeshz );
+ tmax->SetBranchAddress( "maxfield", &maxfield );
+ tmax->GetEntry(0);
+ } else { // "BFieldMapSize" tree does not exist
+ for ( int i = 0; i < tree->GetEntries(); i++ ) {
+ tree->GetEntry(i);
+ // maxcond = std::max( maxcond, (unsigned)ncond );
+ maxmeshx = std::max( maxmeshx, (unsigned)nmeshx );
+ maxmeshy = std::max( maxmeshy, (unsigned)nmeshy );
+ maxmeshz = std::max( maxmeshz, (unsigned)nmeshz );
+ maxfield = std::max( maxfield, (unsigned)nfield );
+ }
+ }
+ meshx = new double[maxmeshx];
+ meshy = new double[maxmeshy];
+ meshz = new double[maxmeshz];
+ fieldx = new short[maxfield];
+ fieldy = new short[maxfield];
+ fieldz = new short[maxfield];
+ // define the variable length branches
+ tree->SetBranchAddress( "meshx", meshx );
+ tree->SetBranchAddress( "meshy", meshy );
+ tree->SetBranchAddress( "meshz", meshz );
+ tree->SetBranchAddress( "fieldx", fieldx );
+ tree->SetBranchAddress( "fieldy", fieldy );
+ tree->SetBranchAddress( "fieldz", fieldz );
+
+ // reserve the space for m_zone so that it won't move as the vector grows
+ m_zone.reserve( tree->GetEntries() );
+ // read all tree and store
+ for ( int i = 0; i < tree->GetEntries(); i++ ) {
+ tree->GetEntry(i);
+ BFieldZone z( id, xmin, xmax, ymin, ymax, zmin, zmax, bscale );
+ m_zone.push_back(z);
+ m_zone.back().reserve( nmeshx, nmeshy, nmeshz );
+ for ( int j = 0; j < nmeshx; j++ ) {
+ m_zone.back().appendMesh( 0, meshx[j] );
+ }
+ for ( int j = 0; j < nmeshy; j++ ) {
+ m_zone.back().appendMesh( 1, meshy[j] );
+ }
+ for ( int j = 0; j < nmeshz; j++ ) {
+ m_zone.back().appendMesh( 2, meshz[j] );
+ }
+ for ( int j = 0; j < nfield; j++ ) {
+ BFieldVector<short> field( fieldx[j], fieldy[j], fieldz[j] ); // z should change most rapidly, then y, then x
+ m_zone.back().appendField( field );
+ }
+ }
+ // clean up
+ tree->Delete();
+ delete[] meshx;
+ delete[] meshy;
+ delete[] meshz;
+ delete[] fieldx;
+ delete[] fieldy;
+ delete[] fieldz;
+ // build the LUTs
+ buildLUT();
+ // buildZR();
+
+ return true;
+}
+
+//
+// Search for the zone that contains a point (x, y, z)
+// This is a linear-search version, used only to construct the LUT.
+//
+BFieldZone* MagField::FaserFieldMap::findZoneSlow( double x, double y, double z )
+{
+ for ( int j = m_zone.size()-1; j >= 0; --j ) {
+ if ( m_zone[j].inside( x, y, z ) ) return &m_zone[j];
+ }
+ return nullptr;
+}
+
+//
+// Build the look-up table used by FindZone().
+// Called by readMap()
+// It also calls buildLUT() for all zones.
+//
+void MagField::FaserFieldMap::buildLUT()
+{
+ // make lists of (x,y,z) edges of all zones
+ for ( int j = 0; j < 3; j++ ) { // x, y, z
+ for ( unsigned i = 0; i < m_zone.size(); i++ ) {
+ double e[2];
+ e[0] = m_zone[i].min(j);
+ e[1] = m_zone[i].max(j);
+ for ( int k = 0; k < 2; k++ ) {
+ m_edge[j].push_back(e[k]);
+ }
+ }
+ // add -pi and +pi to phi, just in case
+ // m_edge[2].push_back(-M_PI);
+ // m_edge[2].push_back(M_PI);
+ // sort
+ sort( m_edge[j].begin(), m_edge[j].end() );
+ // remove duplicates
+ // must do this by hand to allow small differences due to rounding in phi
+ int i = 0;
+ for ( unsigned k = 1; k < m_edge[j].size(); k++ ) {
+ if ( fabs(m_edge[j][i] - m_edge[j][k]) < 1.0e-6 ) continue;
+ m_edge[j][++i] = m_edge[j][k];
+ }
+ m_edge[j].resize( i+1 );
+ // because of the small differences allowed in the comparison above,
+ // m_edge[][] values do not exactly match the m_zone[] boundaries.
+ // we have to fix this up in order to avoid invalid field values
+ // very close to the zone boundaries.
+ for ( unsigned i = 0; i < m_zone.size(); i++ ) {
+ for ( unsigned k = 0; k < m_edge[j].size(); k++ ) {
+ if ( fabs(m_zone[i].min(j) - m_edge[j][k]) < 1.0e-6 ) {
+ m_zone[i].adjustMin(j,m_edge[j][k]);
+ }
+ if ( fabs(m_zone[i].max(j) - m_edge[j][k]) < 1.0e-6 ) {
+ m_zone[i].adjustMax(j,m_edge[j][k]);
+ }
+ }
+ }
+ }
+ // build LUT for edge finding
+ for ( int j = 0; j < 3; j++ ) { // x, y, z
+ // find the size of the smallest interval
+ double width = m_edge[j].back() - m_edge[j].front();
+ double q(width);
+ for ( unsigned i = 0; i < m_edge[j].size()-1; i++ ) {
+ q = std::min( q, m_edge[j][i+1] - m_edge[j][i] );
+ }
+ // find the number of cells in the LUT
+ int n = int(width/q) + 1;
+ q = width/(n+0.5);
+ m_invq[j] = 1.0/q;
+ n++;
+ // fill the LUT
+ int m = 0;
+ for ( int i = 0; i < n; i++ ) { // index of LUT
+ if ( q*i+m_edge[j].front() > m_edge[j][m+1] ) m++;
+ m_edgeLUT[j].push_back(m);
+ }
+ }
+ // store min/max for speedup
+ m_xmin=m_edge[0].front();
+ m_xmax=m_edge[0].back();
+ m_ymin=m_edge[1].front();
+ m_ymax=m_edge[1].back();
+ m_zmin=m_edge[2].front();
+ m_zmax=m_edge[2].back();
+ // build LUT for zone finding
+ m_nx = m_edge[0].size() - 1;
+ m_ny = m_edge[1].size() - 1;
+ m_nz = m_edge[2].size() - 1;
+ m_zoneLUT.reserve( m_nx*m_ny*m_nz );
+ for ( int ix = 0; ix < m_nx; ix++ ) {
+ double x = 0.5*(m_edge[0][ix]+m_edge[0][ix+1]);
+ for ( int iy = 0; iy < m_ny; iy++ ) {
+ double y = 0.5*(m_edge[1][iy]+m_edge[1][iy+1]);
+ for ( int iz = 0; iz < m_nz; iz++ ) {
+ double z = 0.5*(m_edge[2][iz]+m_edge[2][iz+1]);
+ const BFieldZone* zone = findZoneSlow( x, y, z );
+ m_zoneLUT.push_back( zone );
+ }
+ }
+ }
+ // build LUT in each zone
+ for ( unsigned i = 0; i < m_zone.size(); i++ ) {
+ m_zone[i].buildLUT();
+ }
+}
+
+//
+// Approximate memory footprint
+//
+int MagField::FaserFieldMap::memSize() const
+{
+ int size = 0;
+ size += sizeof(BFieldCache);
+ // size += sizeof(BFieldCacheZR);
+ for ( unsigned i = 0; i < m_zone.size(); i++ ) {
+ size += m_zone[i].memSize();
+ }
+ for ( int i = 0; i < 3; i++ ) {
+ size += sizeof(double)*m_edge[i].capacity();
+ size += sizeof(int)*m_edgeLUT[i].capacity();
+ }
+ size += sizeof(BFieldZone*)*m_zoneLUT.capacity();
+ return size;
+}
+
+
diff --git a/MagneticField/MagFieldServices/CMakeLists.txt b/MagneticField/MagFieldServices/CMakeLists.txt
index ebe2ab4c0582459f2cc6041f1ebbe3138b93f4f3..186b51a089184df8da091b4d71da2e3ccc8f8cf1 100644
--- a/MagneticField/MagFieldServices/CMakeLists.txt
+++ b/MagneticField/MagFieldServices/CMakeLists.txt
@@ -9,7 +9,10 @@ atlas_subdir( MagFieldServices )
atlas_depends_on_subdirs( PUBLIC
Control/AthenaBaseComps
MagneticField/MagFieldInterfaces
+ MagneticField/MagFieldConditions
+ Control/CxxUtils
PRIVATE
+ MagneticField/MagFieldElements
Control/StoreGate
Database/AthenaPOOL/AthenaPoolUtilities
GaudiKernel
@@ -24,7 +27,7 @@ atlas_add_component( MagFieldServices
src/*.cxx
src/components/*.cxx
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
- LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} AthenaBaseComps MagFieldInterfaces StoreGateLib SGtests AthenaPoolUtilities GaudiKernel PathResolver )
+ LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} MagFieldElements MagFieldConditions CxxUtils AthenaBaseComps MagFieldInterfaces StoreGateLib SGtests AthenaPoolUtilities GaudiKernel PathResolver )
# Install files from the package:
# Headers should not need to be installed
diff --git a/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py b/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
index 7ef8dacde08d27c5c62c60a9e58be76735786840..aa5462ea795cb5410ad33e95d85b35d04b362962 100644
--- a/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
+++ b/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
@@ -1,50 +1,62 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-# JobOption fragment to set up the AtlasFieldSvc
+# JobOption fragment to set up the FaserFieldSvc and conditions algorithms
# Valerio Ippolito - Harvard University
-# inspired by https://svnweb.cern.ch/trac/atlasoff/browser/MuonSpectrometer/MuonCnv/MuonCnvExample/trunk/python/MuonCalibConfig.py
-
-from AthenaCommon.Logging import logging
-logging.getLogger().info("Importing %s", __name__)
-
-from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
-from AthenaCommon.GlobalFlags import GlobalFlags
-from AthenaCommon import CfgMgr
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from MagFieldServices.MagFieldServicesConf import MagField__FaserFieldSvc
+
+# from MagFieldServices.MagFieldServicesConf import MagField__FaserFieldCacheCondAlg
+# from MagFieldServices.MagFieldServicesConf import MagField__FaserFieldMapCondAlg
#--------------------------------------------------------------
-def FaserFieldSvc(name="FaserFieldSvc",**kwargs):
- # configure properties of service, if any
- return CfgMgr.MagField__FaserFieldSvc(name,**kwargs)
+# def FaserFieldSvc(name="FaserFieldSvc",**kwargs):
+# # configure properties of service, if any
+# # kwargs.setdefault( "UseDCS", False )
+# return CfgMgr.MagField__FaserFieldSvc(name,**kwargs)
+
+# def FaserFieldCacheCondAlg(name="FaserFieldCacheCondAlg",**kwargs):
+# # kwargs.setdefault( "UseDCS", False )
+# return CfgMgr.MagField__FaserFieldCacheCondAlg(name,**kwargs)
+
+# def FaserFieldMapCondAlg(name="FaserFieldMapCondAlg",**kwargs):
+# kwargs.setdefault( "UseMapsFromCOOL", False )
+# return CfgMgr.MagField__FaserFieldMapCondAlg(name,**kwargs)
+
-def GetFieldSvc(name="FaserFieldSvc",**kwargs):
- return FaserFieldSvc(name, **kwargs)
+# def GetFieldSvc(name="FaserFieldSvc",**kwargs):
+# return FaserFieldSvc(name, **kwargs)
+
+# def GetFieldCacheCondAlg(name="FaserFieldCacheCondAlg",**kwargs):
+# return FaserFieldCacheCondAlg(name, **kwargs)
+# def GetFieldMapCondAlg(name="FaserFieldMapCondAlg",**kwargs):
+# return FaserFieldMapCondAlg(name, **kwargs)
+
+
# The magneticfields is going to need a big update for MT, so this is all temporary. Ed
def MagneticFieldSvcCfg(flags, **kwargs):
result=ComponentAccumulator()
# Hack to avoid randomly failing to find sqlite file
poolSvc = CompFactory.PoolSvc()
- poolSvc.SortReplicas = False
+ # poolSvc.SortReplicas = False
result.addService(poolSvc)
# initialise required conditions DB folders
- # from IOVDbSvc.IOVDbSvcConfig import addFolders
+ from IOVDbSvc.IOVDbSvcConfig import addFolders
# This handles addFolderSplitMC https://gitlab.cern.ch/atlas/athena/blob/master/Database/IOVDbSvc/python/CondDB.py#L240
# i.e. replaces conddb.addFolderSplitMC('GLOBAL','/GLOBAL/BField/Maps <noover/>','/GLOBAL/BField/Maps <noover/>')
# def addFolders(configFlags,folderstrings,detDb=None,className=None):
- # if flags.Input.isMC:
- # db='GLOBAL_OFL'
- # else:
- # db='GLOBAL'
+ if flags.Input.isMC:
+ db='GLOBAL_OFL'
+ else:
+ db='GLOBAL'
- # result.merge(addFolders(flags,['/GLOBAL/BField/Maps <noover/>'],detDb=db) )
+ result.merge(addFolders(flags,['/GLOBAL/BField/Maps <noover/>'],detDb=db, className="CondAttrListCollection") )
+ result.merge(addFolders(flags,['/GLOBAL/BField/Scales <noover/>'],detDb=db, className="CondAttrListCollection") )
# if not flags.Common.isOnline:
# result.merge(addFolders(flags, ['/EXT/DCS/MAGNETS/SENSORDATA'], detDb='DCS_OFL', className="CondAttrListCollection") )
@@ -54,8 +66,30 @@ def MagneticFieldSvcCfg(flags, **kwargs):
# else:
# kwargs.setdefault( "UseDCS", True )
- mag_field_svc = GetFieldSvc("FaserFieldSvc",**kwargs)
- result.addService(mag_field_svc,primary=True)
+ # FaserFieldSvc - old one
+ afsArgs = {
+ "name": "FaserFieldSvc",
+ }
+ # afsArgs.update( UseDCS = False )
+ mag_field_svc = CompFactory.MagField.FaserFieldSvc(**afsArgs)
+ result.addService(mag_field_svc, primary=True)
+
+ # FaserFieldMapCondAlg - for reading in map
+ afmArgs = {
+ "name": "FaserFieldMapCondAlg",
+ }
+ afmArgs.update( UseMapsFromCOOL = True )
+ mag_field_map_cond_alg = CompFactory.MagField.FaserFieldMapCondAlg(**afmArgs)
+ result.addCondAlgo(mag_field_map_cond_alg)
+
+ # FaserFieldCacheCondAlg - for reading in scale factor
+ afcArgs = {
+ "name": "FaserFieldCacheCondAlg",
+ }
+ afcArgs.update( UseDCS = True )
+
+ mag_field_cache_cond_alg = CompFactory.MagField.FaserFieldCacheCondAlg(**afcArgs)
+ result.addCondAlgo(mag_field_cache_cond_alg)
return result
if __name__=="__main__":
diff --git a/MagneticField/MagFieldServices/python/MagFieldServicesConfigDb.py b/MagneticField/MagFieldServices/python/MagFieldServicesConfigDb.py
index 359550d33606068da2da2a278ebee44453f4842c..fe87df4dd19e58d7a52705c9598e860d564654bc 100644
--- a/MagneticField/MagFieldServices/python/MagFieldServicesConfigDb.py
+++ b/MagneticField/MagFieldServices/python/MagFieldServicesConfigDb.py
@@ -2,6 +2,8 @@
# database entries for https://twiki.cern.ch/twiki/bin/view/AtlasComputing/ConfiguredFactory#Factory_functions_vs_derived_cla
# Valerio Ippolito - Harvard University
-from AthenaCommon.CfgGetter import addService
+from AthenaCommon.CfgGetter import addService, addAlgorithm
addService('MagFieldServices.MagFieldServicesConfig.GetFieldSvc', 'FaserFieldSvc')
+addAlgorithm('MagFieldServices.MagFieldServicesConfig.GetFieldMapCondAlg', 'FaserFieldMapCondAlg')
+addAlgorithm('MagFieldServices.MagFieldServicesConfig.GetFieldCacheCondAlg', 'FaserFieldCacheCondAlg')
diff --git a/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.cxx b/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..9ec8b8413268294c99b00d21f527391ce5035630
--- /dev/null
+++ b/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.cxx
@@ -0,0 +1,213 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ @class FaserFieldCacheCondAlg
+ @authors RD Schaffer <r.d.schaffer -at- cern.ch>, C Anastopoulos
+ @brief create a MagField object for tracking clients
+
+ Purpose: for each event, create a MagField object for tracking clients and store in conditions
+ Store
+
+**/
+
+// ISF_Services include
+#include "FaserFieldCacheCondAlg.h"
+
+// Concurrency
+#include "GaudiKernel/ConcurrencyFlags.h"
+
+// PathResolver
+#include "PathResolver/PathResolver.h"
+
+// ROOT
+#include "TFile.h"
+#include "TTree.h"
+
+MagField::FaserFieldCacheCondAlg::FaserFieldCacheCondAlg(const std::string& name,
+ ISvcLocator* pSvcLocator)
+ :AthReentrantAlgorithm(name, pSvcLocator){
+}
+
+MagField::FaserFieldCacheCondAlg::~FaserFieldCacheCondAlg(){ }
+
+StatusCode
+MagField::FaserFieldCacheCondAlg::initialize() {
+
+ ATH_MSG_INFO ("Initialize");
+ // CondSvc
+ ATH_CHECK( m_condSvc.retrieve() );
+
+ // Read handle for the field scale factors conditions object
+ ATH_CHECK( m_scaleInputKey.initialize() );
+
+ // Read handle for the field map cond object
+ ATH_CHECK( m_mapCondObjInputKey.initialize() );
+
+ // Output handle for scale factors/cache
+ ATH_CHECK( m_condObjOutputKey.initialize() );
+
+ // Register write handle for scale factors/cache
+ if (m_condSvc->regHandle(this, m_condObjOutputKey).isFailure()) {
+ ATH_MSG_ERROR("Unable to register WriteCondHandle " << m_condObjOutputKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_MSG_INFO ( "Initialize: Key " << m_condObjOutputKey.fullKey() << " has been succesfully registered " );
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldCacheCondAlg::execute(const EventContext& ctx) const {
+
+ ATH_MSG_INFO ( "execute: entering");
+
+ // Check if output conditions object with field cache object is still valid, if not replace it
+ // with new current scale factors
+ SG::WriteCondHandle<FaserFieldCacheCondObj> writeHandle{m_condObjOutputKey, ctx};
+ if (writeHandle.isValid()) {
+ ATH_MSG_DEBUG("execute: CondHandle " << writeHandle.fullKey()
+ << " is already valid. "
+ <<" May happen if multiple concurrent events are being processed out of order.");
+ return StatusCode::SUCCESS;
+ }
+
+ //This will need to be filled before we construct the condition object
+ Cache cache{};
+
+ // set current scale factor from either conditions or from jobOption parameters
+ if (m_useDCS) {
+ ATH_CHECK( updateScaleFromConditions(ctx, cache) );
+ }
+ else {
+ ATH_CHECK( updateScaleFromParameters(cache) );
+ }
+
+ // Must read map cond object to get previously created map
+ SG::ReadCondHandle<FaserFieldMapCondObj> mapReadHandle{m_mapCondObjInputKey, ctx};
+ const FaserFieldMapCondObj* mapCondObj{*mapReadHandle};
+ if (mapCondObj == nullptr) {
+ ATH_MSG_ERROR("execute: Could not access conditions map for key: " << m_mapCondObjInputKey.fullKey());
+ return StatusCode::FAILURE;
+ }
+
+ // simple pointer to the map, to be give to the AtlasFieldCacheCondObj, used for the cache field map access
+ const MagField::FaserFieldMap* fieldMap = mapCondObj->fieldMap();
+
+ // save current scale factor in conditions object
+ auto fieldCondObj = std::make_unique<FaserFieldCacheCondObj>();
+
+ // initialize cond obj with current scale factors and the field svc (needed to setup cache)
+ if (!fieldCondObj->initialize(cache.m_dipScaleFactor,
+ fieldMap)) {
+ ATH_MSG_ERROR("execute: Could not initialize conditions field object with field map "
+ << cache.m_dipScaleFactor );
+ return StatusCode::FAILURE;
+ }
+
+ // Record in conditions store the conditions object with scale factors and map pointer for cache
+ if(writeHandle.record(cache.m_condObjOutputRange, std::move(fieldCondObj)).isFailure()) {
+ ATH_MSG_ERROR("execute: Could not record FaserFieldCacheCondObj object with "
+ << writeHandle.key() << " with EventRange " << cache.m_condObjOutputRange
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_MSG_INFO ( "execute: initialized FaserFieldCacheCondObj and cache with scale factor "
+ << cache.m_dipScaleFactor );
+ ATH_MSG_INFO ( "execute: dipole zone id " << fieldMap->dipoleZoneId());
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldCacheCondAlg::updateScaleFromConditions(const EventContext& ctx, Cache& cache) const
+{
+ ATH_MSG_INFO ( "UpdateScaleFromConditions " );
+
+ // readin current value
+ SG::ReadCondHandle<CondAttrListCollection> readHandle {m_scaleInputKey, ctx};
+ const CondAttrListCollection* attrListColl{*readHandle};
+ if (attrListColl == nullptr) {
+ ATH_MSG_ERROR("Failed to retrieve CondAttributeListCollection with key " << m_scaleInputKey.key());
+ return StatusCode::FAILURE;
+ }
+
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (!readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ cache.m_condObjOutputRange = rangeW;
+ ATH_MSG_INFO("Range of input/output is " << cache.m_condObjOutputRange);
+
+ bool gotscale{false};
+ double dipscale {0.};
+
+ // Channel names don't seem to be read even when they are present...
+ bool hasChanNames {false};
+ for ( CondAttrListCollection::const_iterator itr = attrListColl->begin(); itr != attrListColl->end(); ++itr ) {
+ const std::string& name = attrListColl->chanName(itr->first);
+ ATH_MSG_INFO( "Trying to read from DCS: [channel name, index, value] "
+ << name << " , " << itr->first << " , " << itr->second["value"].data<float>() );
+ if (name.compare("") != 0) {
+ hasChanNames = true;
+ }
+ if ( name.compare("Dipole_Scale") == 0 ) {
+ dipscale = itr->second["value"].data<float>();
+ gotscale = true;
+ }
+ }
+ if ( !hasChanNames ) {
+ ATH_MSG_INFO( "UpdateCurrentFromConditions: Attempt 2 at reading currents from DCS (using channel index)" );
+ // in no channel is named, try again using channel index instead
+ for ( CondAttrListCollection::const_iterator itr = attrListColl->begin(); itr != attrListColl->end(); ++itr ) {
+
+ if ( itr->first == 1 ) {
+ // channel 1 is dipole scale
+ dipscale = itr->second["value"].data<float>();
+ gotscale = true;
+ }
+ }
+ }
+
+ if ( !gotscale ) {
+ ATH_MSG_ERROR( "Missing dipole scale factor in DCS information" );
+ return StatusCode::FAILURE;
+ }
+
+ if (dipscale < m_dipoMinScale)
+ {
+ dipscale = 0.0;
+ ATH_MSG_INFO("Dipole is off.");
+ }
+
+ cache.m_dipScaleFactor = dipscale;
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldCacheCondAlg::updateScaleFromParameters(Cache& cache) const
+{
+
+ ATH_MSG_INFO( "updateCurrentFromParameters" );
+ // take the current value from JobOptions
+ double dipscale{m_useDipoScale};
+ if ( dipscale < m_dipoMinScale ) {
+ dipscale = 0.0;
+ ATH_MSG_INFO( "Dipole is off" );
+ }
+ cache.m_dipScaleFactor = dipscale;
+ ATH_MSG_INFO("Update from job options: Range of input/output is " << cache.m_condObjOutputRange);
+ ATH_MSG_INFO("Magnetic field scale taken from jobOption parameters " );
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldCacheCondAlg::finalize() {
+ ATH_MSG_INFO ( " in finalize " );
+ return StatusCode::SUCCESS;
+}
diff --git a/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.h b/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..6db17ae6ef7179db72935dca5d5071979bcfc6e2
--- /dev/null
+++ b/MagneticField/MagFieldServices/src/FaserFieldCacheCondAlg.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+///////////////////////////////////////////////////////////////////
+// FaserFieldCacheCondAlg.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef MAGFIELDSERVICES_FASERFIELDCACHECONDALG_H
+#define MAGFIELDSERVICES_FASERFIELDCACHECONDALG_H
+
+// FrameWork includes
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "GaudiKernel/ICondSvc.h"
+
+// #include "MagFieldInterfaces/IMTMagFieldSvc.h"
+
+#include "MagFieldConditions/FaserFieldCacheCondObj.h"
+#include "MagFieldConditions/FaserFieldMapCondObj.h"
+
+namespace MagField {
+
+ class FaserFieldCacheCondAlg : public AthReentrantAlgorithm
+ {
+ public:
+ FaserFieldCacheCondAlg(const std::string& name,ISvcLocator* pSvcLocator);
+ virtual ~FaserFieldCacheCondAlg();
+
+ StatusCode initialize() override final;
+ StatusCode execute(const EventContext& ctx) const override final;
+ StatusCode finalize() override final;
+
+ private:
+
+ /*
+ * Cache of the variables to be updated before we write the conditions object
+ */
+ struct Cache{
+ // float m_solenoidCurrent{0}; // solenoid current in ampere
+ // float m_toroidCurrent{0}; // toroid current in ampere
+ // double m_solScaleFactor{1}; // solenoid current scale factor
+ // double m_torScaleFactor{1}; // toroid current scale factor
+ double m_dipScaleFactor{1};
+ //"infinite in case we do not update from DCS" - full run/event range
+ EventIDRange m_condObjOutputRange {EventIDRange(EventIDBase(0,0), EventIDBase(EventIDBase::UNDEFNUM-1, EventIDBase::UNDEFEVT-1))};
+ };
+ StatusCode updateScaleFromConditions(const EventContext& ctx, Cache& cache) const;
+ StatusCode updateScaleFromParameters(Cache& cache) const;
+
+ // threshold below which currents are considered zero
+ Gaudi::Property<double> m_dipoMinScale {this,
+ "DipoMinScale", 0.01, "Minimum dipole scale factor for which dipole is considered ON"};
+
+ // flag to use magnet current from DCS in COOL
+ Gaudi::Property<bool> m_useDCS {this,
+ "UseDCS", false, "Get magnet scale factor from DCS through ConditionsSvc"};
+
+ // COOL folder name containing current information
+ // current input key
+ SG::ReadCondHandleKey<CondAttrListCollection> m_scaleInputKey
+ {this,
+ "COOLCurrentsFolderName", "/GLOBAL/BField/Scales", "Name of the COOL folder containing magnet scale factor"};
+
+ // FaserFieldMapCondObj - read handle to access magnet field conditions object containing the map file names
+ SG::ReadCondHandleKey<FaserFieldMapCondObj> m_mapCondObjInputKey
+ {this,
+ "FaserFieldMapCondObj", "fieldMapCondObj", "Name of key for the Magnetic Field conditions object with the map file names"};
+
+ // FaserFieldCacheCondObj - magnet field conditions object containing the current scale factors
+ SG::WriteCondHandleKey<FaserFieldCacheCondObj> m_condObjOutputKey
+ {this,
+ "FaserFieldCacheCondObj", "fieldCondObj", "Name of the key for the Magnetic Field conditions object with currents for scaling"};
+
+ Gaudi::Property<double> m_useDipoScale {this,
+ "UseDipoScale", 1.0, "Set actual dipole scale factor"};
+
+ ServiceHandle<ICondSvc> m_condSvc { this,
+ "CondSvc", "CondSvc", "conditions service" };
+
+ };
+}
+
+#endif //> !MAGFIELDSERVICES_FASERFIELDCACHECONDALG_H
diff --git a/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.cxx b/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..c1246f85b0bc8a33cd7f0922136784d66c085757
--- /dev/null
+++ b/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.cxx
@@ -0,0 +1,231 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ @class FaserFieldMapCondAlg
+ @authors RD Schaffer <r.d.schaffer -at- cern.ch>, C Anastopoulos
+ @brief create a MagField object for tracking clients
+
+ Purpose: create a MagField map object, filling from a file whose name is taken normally from
+ COOL, and save the map in a conditions object for the FaserFieldCacheCondAlg
+
+**/
+
+// ISF_Services include
+#include "FaserFieldMapCondAlg.h"
+
+// Concurrency
+#include "GaudiKernel/ConcurrencyFlags.h"
+
+// PathResolver
+#include "PathResolver/PathResolver.h"
+
+// ROOT
+#include "TFile.h"
+#include "TTree.h"
+
+MagField::FaserFieldMapCondAlg::FaserFieldMapCondAlg(const std::string& name,
+ ISvcLocator* pSvcLocator)
+ :AthReentrantAlgorithm(name, pSvcLocator){
+}
+
+MagField::FaserFieldMapCondAlg::~FaserFieldMapCondAlg(){ }
+
+StatusCode
+MagField::FaserFieldMapCondAlg::initialize() {
+
+ ATH_MSG_INFO ("Initialize");
+ // CondSvc
+ ATH_CHECK( m_condSvc.retrieve() );
+
+ // Read Handle for the map
+ ATH_CHECK( m_mapsInputKey.initialize() );
+
+ // Output handle for the field map
+ ATH_CHECK( m_mapCondObjOutputKey.initialize() );
+
+ // Register write handles for scale factors/cache and the field map
+ if (m_condSvc->regHandle(this, m_mapCondObjOutputKey).isFailure()) {
+ ATH_MSG_ERROR("Unable to register WriteCondHandle " << m_mapCondObjOutputKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_MSG_INFO ( "Initialize: Key " << m_mapCondObjOutputKey.fullKey() << " has been succesfully registered " );
+ if (m_useMapsFromCOOL) {
+ ATH_MSG_INFO ( "Initialize: Will update the field map from conditions"); //
+ }
+ else {
+ ATH_MSG_INFO ( "Initialize: Will update the field map from jobOpt file name");
+ }
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldMapCondAlg::execute(const EventContext& ctx) const {
+
+ ATH_MSG_INFO ( "execute: entering ");
+
+ // Check if output conditions object with field map object is still valid, if not replace it
+ // with new map
+ SG::WriteCondHandle<FaserFieldMapCondObj> mapWriteHandle{m_mapCondObjOutputKey, ctx};
+ if (mapWriteHandle.isValid()) {
+ ATH_MSG_DEBUG("execute: CondHandle " << mapWriteHandle.fullKey()
+ << " is still valid. ");
+ return StatusCode::SUCCESS;
+ }
+
+ //This will need to be filled before we construct the condition object
+ Cache cache{};
+
+ ATH_CHECK( updateFieldMap(ctx, cache) );
+
+
+ ATH_MSG_INFO ( "execute: dipole zone id " << cache.m_fieldMap->dipoleZoneId());
+
+
+ // Save newly created map in conditions object, and record it in the conditions store, with its
+ // own range
+ auto fieldMapCondObj = std::make_unique<FaserFieldMapCondObj>();
+ // move ownership of the field map to the fieldMapCondObj
+ fieldMapCondObj->setFieldMap(std::move(cache.m_fieldMap));
+ if(mapWriteHandle.record(cache.m_mapCondObjOutputRange, std::move(fieldMapCondObj)).isFailure()) {
+ ATH_MSG_ERROR("execute: Could not record FaserFieldMapCondObj object with "
+ << mapWriteHandle.key()
+ << " with EventRange " << cache.m_mapCondObjOutputRange
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO ( "execute: recored FaserFieldMapCondObj with field map");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+MagField::FaserFieldMapCondAlg::updateFieldMap(const EventContext& ctx, Cache& cache) const
+{
+ // We get here only for the first creation of the field map, or if the FaserFieldMapCondObj
+ // object, where the map is stored, is no longer valid, i.e. the IOV is out of range
+
+ // Update the map either with the file names from cool or from alg properties, according to m_useMapsFromCOOL
+
+ // Get file names from COOL, or use local ones:
+ std::string fullMapFilename;
+
+ if (m_useMapsFromCOOL) {
+
+ ATH_MSG_INFO("updateFieldMap: Update map from conditions");
+
+ // readin map file name from cool
+ SG::ReadCondHandle<CondAttrListCollection> readHandle {m_mapsInputKey, ctx};
+ const CondAttrListCollection* attrListColl{*readHandle};
+ if (attrListColl == nullptr) {
+ ATH_MSG_ERROR("updateFieldMap: Failed to retrieve CondAttributeListCollection with key " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+
+ // // handle for COOL field map filenames
+ // const DataHandle<CondAttrListCollection> mapHandle;
+
+
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (!readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("updateFieldMap: Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ cache.m_mapCondObjOutputRange = rangeW;
+ ATH_MSG_INFO("updateFieldMap: Update map from conditions: Range of input/output is "
+ << cache.m_mapCondObjOutputRange);
+
+ ATH_MSG_INFO( "updateFieldMap: reading magnetic field map filename from COOL" );
+
+ for (CondAttrListCollection::const_iterator itr = attrListColl->begin(); itr != attrListColl->end(); ++itr) {
+ const coral::AttributeList &attr = itr->second;
+ const std::string &mapType = attr["FieldType"].data<std::string>();
+ const std::string &mapFile = attr["MapFileName"].data<std::string>();
+
+ ATH_MSG_INFO("updateFieldMap: found map of type " << mapType << " (path " << mapFile << ")");
+
+ // first 5 letters are reserved (like "file:")
+ const std::string mapFile_decoded = mapFile.substr(5);
+ if (mapType == "GlobalMap") {
+ fullMapFilename = mapFile_decoded;
+ break;
+ }
+ }
+
+ }
+ else
+ {
+ // not m_useMapsFromCOOL - set values from job options
+ fullMapFilename = m_fullMapFilename;
+ }
+ // Select map file according to the value of the currents which indicate which map is 'on'
+
+ // determine the map to load
+ std::string mapFile { fullMapFilename };
+
+ ATH_MSG_INFO ( "updateFieldMap: Use map file " << mapFile);
+
+
+ // find the path to the map file
+ std::string resolvedMapFile = PathResolver::find_file( mapFile.c_str(), "DATAPATH" );
+ if ( resolvedMapFile.empty() ) {
+ ATH_MSG_ERROR( "updateFieldMap: Field map file " << mapFile << " not found" );
+ return StatusCode::FAILURE;
+ }
+ // Do checks and extract root file to initialize the map
+ if ( resolvedMapFile.find(".root") == std::string::npos ) {
+ ATH_MSG_ERROR("updateFieldMap: input file name '" << resolvedMapFile << "' does not end with .root");
+ return StatusCode::FAILURE;
+ }
+ TFile* rootfile = new TFile(resolvedMapFile.c_str(), "OLD");
+ if ( ! rootfile ) {
+ ATH_MSG_ERROR("updateFieldMap: failed to open " << resolvedMapFile);
+ return StatusCode::FAILURE;
+ }
+ if ( !rootfile->cd() ) {
+ // could not make it current directory
+ ATH_MSG_ERROR("updateFieldMap: unable to cd() into the ROOT field map TFile");
+ rootfile->Close();
+ delete rootfile;
+ return StatusCode::FAILURE;
+ }
+ // open the tree
+ TTree* tree = (TTree*)rootfile->Get("BFieldMap");
+ if ( tree == nullptr ) {
+ // no tree
+ ATH_MSG_ERROR("updateFieldMap: TTree 'BFieldMap' does not exist in ROOT field map");
+ rootfile->Close();
+ delete rootfile;
+ return StatusCode::FAILURE;
+ }
+
+ // create map
+ cache.m_fieldMap = std::make_unique<MagField::FaserFieldMap>();
+
+ // initialize map
+ if (!cache.m_fieldMap->initializeMap( rootfile )) {
+ // failed to initialize the map
+ ATH_MSG_ERROR("updateFieldMap: unable to initialize the map for FaserFieldMap for file " << resolvedMapFile);
+ rootfile->Close();
+ delete rootfile;
+ return StatusCode::FAILURE;
+ }
+
+ rootfile->Close();
+ delete rootfile;
+
+
+ ATH_MSG_INFO( "updateFieldMap: Initialized the field map from " << resolvedMapFile );
+
+ return StatusCode::SUCCESS;
+}
+
+
+StatusCode
+MagField::FaserFieldMapCondAlg::finalize() {
+ ATH_MSG_INFO ( " in finalize " );
+ return StatusCode::SUCCESS;
+}
diff --git a/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.h b/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1a4c29260b1c402c947fa8fe9ffda69cc64f571
--- /dev/null
+++ b/MagneticField/MagFieldServices/src/FaserFieldMapCondAlg.h
@@ -0,0 +1,79 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+///////////////////////////////////////////////////////////////////
+// FaserFieldMapCondAlg.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef MAGFIELDSERVICES_FASERFIELDMAPCONDALG_H
+#define MAGFIELDSERVICES_FASERFIELDMAPCONDALG_H
+
+// FrameWork includes
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "GaudiKernel/ICondSvc.h"
+
+// #include "MagFieldInterfaces/IMTMagFieldSvc.h"
+
+#include "MagFieldConditions/FaserFieldMapCondObj.h"
+
+namespace MagField {
+
+ class FaserFieldMapCondAlg : public AthReentrantAlgorithm
+ {
+ public:
+ FaserFieldMapCondAlg(const std::string& name,ISvcLocator* pSvcLocator);
+ virtual ~FaserFieldMapCondAlg();
+
+ StatusCode initialize() override final;
+ StatusCode execute(const EventContext& ctx) const override final;
+ StatusCode finalize() override final;
+
+ private:
+
+ /*
+ * Cache of the variables to be updated before we write the conditions object
+ */
+ struct Cache{
+ // field map names
+ std::string m_fullMapFilename{"data/FaserFieldTable.root"}; // all magnets on
+ // field map - pointer and event id range
+ std::unique_ptr<MagField::FaserFieldMap> m_fieldMap;
+
+ //"infinite in case we do not update from COOL"
+ EventIDRange m_mapCondObjOutputRange {EventIDRange()}; // default range covers everything (run/event and timestamp)
+ };
+
+ StatusCode updateFieldMap(const EventContext& ctx, Cache& cache) const;
+
+ /// map file names - if not read from cool
+ Gaudi::Property<std::string> m_fullMapFilename {this,
+ "FullMapFile", "data/FaserFieldTable.root",
+ "File storing the full magnetic field map"};
+
+ // flag to read magnet map filenames from COOL
+ Gaudi::Property<bool> m_useMapsFromCOOL {this,
+ "UseMapsFromCOOL", true , "Get magnetic field map filenames from COOL"};
+
+ // COOL folder name containing field maps
+ // map input key
+ SG::ReadCondHandleKey<CondAttrListCollection> m_mapsInputKey
+ {this,
+ "COOLMapsFolderName", "/GLOBAL/BField/Maps", "Name of the COOL folder containing field maps"};
+
+ // FaserFieldMapCondObj - magnet field conditions object containing the map file names
+ SG::WriteCondHandleKey<FaserFieldMapCondObj> m_mapCondObjOutputKey
+ {this,
+ "FaserFieldMapCondObj", "fieldMapCondObj", "Name of key for the Magnetic Field conditions object with the map file names"};
+
+ ServiceHandle<ICondSvc> m_condSvc { this,
+ "CondSvc", "CondSvc", "conditions service" };
+
+ };
+}
+
+#endif //> !MAGFIELDSERVICES_FASERFIELDMAPCONDALG_H
diff --git a/MagneticField/MagFieldServices/src/FaserFieldSvc.cxx b/MagneticField/MagFieldServices/src/FaserFieldSvc.cxx
index 7f937139f48f96fb6693d0a6ee34b7753fc4ab91..bfd1c7ba26298bf89a7e27f0974c4a6f658f9bc1 100644
--- a/MagneticField/MagFieldServices/src/FaserFieldSvc.cxx
+++ b/MagneticField/MagFieldServices/src/FaserFieldSvc.cxx
@@ -34,7 +34,7 @@
/** Constructor **/
MagField::FaserFieldSvc::FaserFieldSvc(const std::string& name,ISvcLocator* svc) :
base_class(name,svc),
- m_fullMapFilename("data/FaserFieldTable.root"),
+ m_fullMapFilename("MagneticFieldMaps/FaserFieldTable.root"),
m_zone(),
m_edge(),
m_edgeLUT(),
diff --git a/MagneticField/MagFieldServices/src/FaserFieldSvc.h b/MagneticField/MagFieldServices/src/FaserFieldSvc.h
index 942e6e99eea1ca852a9366520e311bcd8b172f7e..64742a0f843a20442a749b834fe9e3fd14f2cce4 100644
--- a/MagneticField/MagFieldServices/src/FaserFieldSvc.h
+++ b/MagneticField/MagFieldServices/src/FaserFieldSvc.h
@@ -17,17 +17,16 @@
// MagField includes
#include "MagFieldInterfaces/IMagFieldSvc.h"
#include "FaserFieldSvcTLS.h"
-#include "BFieldCache.h"
-// #include "MagFieldServices/BFieldCacheZR.h"
-// #include "MagFieldServices/BFieldCond.h"
-#include "BFieldZone.h"
-// #include "MagFieldServices/BFieldMeshZR.h"
+#include "MagFieldElements/BFieldCache.h"
+#include "MagFieldElements/BFieldZone.h"
// // #include "MagFieldInterfaces/IMagFieldManipulator.h"
// STL includes
#include <vector>
#include <iostream>
+#include "CxxUtils/checker_macros.h"
+
// forward declarations
// class CondAttrListCollection;
class BFieldZone;
@@ -43,21 +42,18 @@ namespace MagField {
public:
//** Constructor with parameters */
- FaserFieldSvc( const std::string& name, ISvcLocator* pSvcLocator );
+ FaserFieldSvc( const std::string& name, ISvcLocator* pSvcLocator ) ATLAS_CTORDTOR_NOT_THREAD_SAFE;
/** Destructor */
- virtual ~FaserFieldSvc();
+ virtual ~FaserFieldSvc() ATLAS_CTORDTOR_NOT_THREAD_SAFE;
/** Athena algorithm's interface methods */
- virtual StatusCode initialize() override;
+ virtual StatusCode initialize ATLAS_NOT_THREAD_SAFE () override;
virtual StatusCode finalize() override;
/** Read **/
virtual void handle(const Incident& runIncident) override;
- /** Call back for possible magnet current update **/
- // StatusCode updateCurrent(IOVSVC_CALLBACK_ARGS);
-
/** Call back for possible magnet filename update **/
// StatusCode updateMapFilenames(IOVSVC_CALLBACK_ARGS);
diff --git a/MagneticField/MagFieldServices/src/FaserFieldSvcTLS.h b/MagneticField/MagFieldServices/src/FaserFieldSvcTLS.h
index 7ce79f8cfa11fe394b21f607535d58e090adb267..728d082ab5a272955fbc6a8bb47a23c3a9e7692a 100644
--- a/MagneticField/MagFieldServices/src/FaserFieldSvcTLS.h
+++ b/MagneticField/MagFieldServices/src/FaserFieldSvcTLS.h
@@ -13,9 +13,7 @@
#define MAGFIELDSERVICES_FASERFIELDSVCTLS_H 1
// MagField includes
-// #include "BFieldCond.h"
-#include "BFieldZone.h"
-// #include "BFieldMeshZR.h"
+#include "MagFieldElements/BFieldZone.h"
namespace MagField {
diff --git a/MagneticField/MagFieldServices/src/components/MagFieldServices_entries.cxx b/MagneticField/MagFieldServices/src/components/MagFieldServices_entries.cxx
index 7ee83ce90ee1a46be259daa9839cce45ea3ef75e..f70a38735f5528daf9c302377a2fbf07f451ab10 100644
--- a/MagneticField/MagFieldServices/src/components/MagFieldServices_entries.cxx
+++ b/MagneticField/MagFieldServices/src/components/MagFieldServices_entries.cxx
@@ -1,4 +1,8 @@
#include "../FaserFieldSvc.h"
+#include "../FaserFieldCacheCondAlg.h"
+#include "../FaserFieldMapCondAlg.h"
DECLARE_COMPONENT( MagField::FaserFieldSvc )
+DECLARE_COMPONENT( MagField::FaserFieldMapCondAlg )
+DECLARE_COMPONENT( MagField::FaserFieldCacheCondAlg )
diff --git a/README.md b/README.md
index 89c1f663e12a3b50ec42442f9f7ec062af6c97b0..d2e2cc4cfdd11a35571ea372d32f1a3dec7d61af 100644
--- a/README.md
+++ b/README.md
@@ -9,10 +9,12 @@ git clone https://:@gitlab.cern.ch:8443/$USERNAME/calypso.git
#The next three lines are used to setup the ATLAS release environment
export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase
source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh
-asetup master,latest,Athena
+asetup --input=calypso/asetup.faser master,latest,Athena
#create build directory
mkdir build
cd build
#build calypso
cmake -DCMAKE_INSTALL_PREFIX=../run ../calypso ; make ; make install
+
+It can be convenient to alias the "asetup --input=calypso/asetup.faser" to something like "fsetup"
\ No newline at end of file
diff --git a/Scintillator/ScintDetDescr/PreshowerGeoModel/python/PreshowerGeoModelConfig.py b/Scintillator/ScintDetDescr/PreshowerGeoModel/python/PreshowerGeoModelConfig.py
index 78f1ed88dbdba501b82f13bed284d37b71e9fb8f..d0e538cf233ff3e70564970c56f37fc57ca64b6b 100644
--- a/Scintillator/ScintDetDescr/PreshowerGeoModel/python/PreshowerGeoModelConfig.py
+++ b/Scintillator/ScintDetDescr/PreshowerGeoModel/python/PreshowerGeoModelConfig.py
@@ -1,32 +1,17 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-
-def getPreshowerDetectorTool(name="PreshowerDetectorTool", **kwargs):
- kwargs.setdefault("DetectorName", "Preshower");
- kwargs.setdefault("Alignable", True);
- kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc");
- kwargs.setdefault("GeometryDBSvc", "ScintGeometryDBSvc");
- kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc");
- return CfgMgr.PreshowerDetectorTool(name, **kwargs)
-
-from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+from AthenaConfiguration.ComponentFactory import CompFactory
+# from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
def PreshowerGeometryCfg( flags ):
from FaserGeoModel.GeoModelConfig import GeoModelCfg
acc = GeoModelCfg( flags )
geoModelSvc = acc.getPrimary()
- from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
+ GeometryDBSvc = CompFactory.GeometryDBSvc
acc.addService(GeometryDBSvc("ScintGeometryDBSvc"))
- from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
- acc.addService(RDBAccessSvc("RDBAccessSvc"))
-
- from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
- acc.addService(DBReplicaSvc("DBReplicaSvc"))
-
- from PreshowerGeoModel.PreshowerGeoModelConf import PreshowerDetectorTool
+ PreshowerDetectorTool = CompFactory.PreshowerDetectorTool
preshowerDetectorTool = PreshowerDetectorTool()
preshowerDetectorTool.useDynamicAlignFolders = flags.GeoModel.Align.Dynamic
diff --git a/Scintillator/ScintDetDescr/TriggerGeoModel/python/TriggerGeoModelConfig.py b/Scintillator/ScintDetDescr/TriggerGeoModel/python/TriggerGeoModelConfig.py
index 34dda703f0c7bbd48602723586ed2b45ca1dc904..b92891b22bdcae940622a667f3c537be46c29305 100644
--- a/Scintillator/ScintDetDescr/TriggerGeoModel/python/TriggerGeoModelConfig.py
+++ b/Scintillator/ScintDetDescr/TriggerGeoModel/python/TriggerGeoModelConfig.py
@@ -1,32 +1,17 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-
-def getTriggerDetectorTool(name="TriggerDetectorTool", **kwargs):
- kwargs.setdefault("DetectorName", "Trigger");
- kwargs.setdefault("Alignable", True);
- kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc");
- kwargs.setdefault("GeometryDBSvc", "ScintGeometryDBSvc");
- kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc");
- return CfgMgr.TriggerDetectorTool(name, **kwargs)
-
-from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+from AthenaConfiguration.ComponentFactory import CompFactory
+# from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
def TriggerGeometryCfg( flags ):
from FaserGeoModel.GeoModelConfig import GeoModelCfg
acc = GeoModelCfg( flags )
geoModelSvc = acc.getPrimary()
- from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
+ GeometryDBSvc=CompFactory.GeometryDBSvc
acc.addService(GeometryDBSvc("ScintGeometryDBSvc"))
- from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
- acc.addService(RDBAccessSvc("RDBAccessSvc"))
-
- from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
- acc.addService(DBReplicaSvc("DBReplicaSvc"))
-
- from TriggerGeoModel.TriggerGeoModelConf import TriggerDetectorTool
+ TriggerDetectorTool = CompFactory.TriggerDetectorTool
triggerDetectorTool = TriggerDetectorTool()
triggerDetectorTool.useDynamicAlignFolders = flags.GeoModel.Align.Dynamic
diff --git a/Scintillator/ScintDetDescr/VetoGeoModel/python/VetoGeoModelConfig.py b/Scintillator/ScintDetDescr/VetoGeoModel/python/VetoGeoModelConfig.py
index fe6dca0b6ad1c8ced0ffa9253ed0085d2f4f9e6e..4e3497dc2e8452e951e98f8988e611027be1a093 100644
--- a/Scintillator/ScintDetDescr/VetoGeoModel/python/VetoGeoModelConfig.py
+++ b/Scintillator/ScintDetDescr/VetoGeoModel/python/VetoGeoModelConfig.py
@@ -1,32 +1,17 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-
-def getVetoDetectorTool(name="VetoDetectorTool", **kwargs):
- kwargs.setdefault("DetectorName", "Veto");
- kwargs.setdefault("Alignable", True);
- kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc");
- kwargs.setdefault("GeometryDBSvc", "ScintGeometryDBSvc");
- kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc");
- return CfgMgr.VetoDetectorTool(name, **kwargs)
-
-from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+from AthenaConfiguration.ComponentFactory import CompFactory
+# from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
def VetoGeometryCfg( flags ):
from FaserGeoModel.GeoModelConfig import GeoModelCfg
acc = GeoModelCfg( flags )
geoModelSvc = acc.getPrimary()
- from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
+ GeometryDBSvc=CompFactory.GeometryDBSvc
acc.addService(GeometryDBSvc("ScintGeometryDBSvc"))
- from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
- acc.addService(RDBAccessSvc("RDBAccessSvc"))
-
- from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
- acc.addService(DBReplicaSvc("DBReplicaSvc"))
-
- from VetoGeoModel.VetoGeoModelConf import VetoDetectorTool
+ VetoDetectorTool = CompFactory.VetoDetectorTool
vetoDetectorTool = VetoDetectorTool()
vetoDetectorTool.useDynamicAlignFolders = flags.GeoModel.Align.Dynamic
diff --git a/Scintillator/ScintG4/PreshowerG4_SD/CMakeLists.txt b/Scintillator/ScintG4/PreshowerG4_SD/CMakeLists.txt
index 385164f2ce7112196b468ea547de1f08bfe8f8ff..d98580ad6fe7abfa4041f5318e0fb3166826fadf 100644
--- a/Scintillator/ScintG4/PreshowerG4_SD/CMakeLists.txt
+++ b/Scintillator/ScintG4/PreshowerG4_SD/CMakeLists.txt
@@ -27,7 +27,7 @@ atlas_add_component( PreshowerG4_SD
LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel ScintSimEvent G4AtlasToolsLib FaserMCTruth )
atlas_add_test( PreshowerG4_SDToolConfig_test
- SCRIPT test/PreshowerG4_SDToolConfig_test.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/PreshowerG4_SDToolConfig_test.py
PROPERTIES TIMEOUT 300 )
# Install files from the package:
diff --git a/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDConfig.py b/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDConfig.py
index 1b801ae1d5168187febe1c149ae30574ff337574..0c2d30defd8d204ea9067ee449c0cb96c17996bc 100644
--- a/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDConfig.py
+++ b/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDConfig.py
@@ -1,19 +1,22 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-from G4AtlasApps.SimFlags import simFlags
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-from ISF_Algorithms.collection_merger_helpers import generate_mergeable_collection_name
+PreshowerSensorSDTool=CompFactory.PreshowerSensorSDTool
+def getPreshowerSensorSD(ConfigFlags, name="PreshowerSensorSD", **kwargs):
-def getPreshowerSensorSD(name="PreshowerSensorSD", **kwargs):
+ result = ComponentAccumulator()
bare_collection_name = "PreshowerHits"
mergeable_collection_suffix = "_G4"
merger_input_property = "PreshowerHits"
- hits_collection_name = generate_mergeable_collection_name(bare_collection_name,
- mergeable_collection_suffix,
- merger_input_property)
+
+ acc, hits_collection_name = CollectionMergerCfg(ConfigFlags, bare_collection_name, mergeable_collection_suffix, merger_input_property)
kwargs.setdefault("LogicalVolumeNames", ["Preshower::Plate"])
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
- return CfgMgr.PreshowerSensorSDTool(name, **kwargs)
+
+ result.merge(acc)
+ return result, PreshowerSensorSDTool(name, **kwargs)
diff --git a/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDToolConfig.py b/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDToolConfig.py
index 9f7200d5f4ca28b4d75a4f5b1c5e93e04e63c660..9bd507ee27e7d8d17ce1b55cbd05fcf968494b5e 100644
--- a/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDToolConfig.py
+++ b/Scintillator/ScintG4/PreshowerG4_SD/python/PreshowerG4_SDToolConfig.py
@@ -1,10 +1,10 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-# from PreshowerG4_SD.PreshowerG4_SDConf import PreshowerSensorSDTool
-from PreshowerG4_SD.PreshowerG4_SDConfig import getPreshowerSensorSD
+PreshowerSensorSDTool=CompFactory.PreshowerSensorSDTool
def PreshowerSensorSDCfg(ConfigFlags, name="PreshowerSensorSD", **kwargs):
@@ -18,4 +18,4 @@ def PreshowerSensorSDCfg(ConfigFlags, name="PreshowerSensorSD", **kwargs):
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
result.merge(acc)
- return result, getPreshowerSensorSD(name, **kwargs)
+ return result, PreshowerSensorSDTool(name, **kwargs)
diff --git a/Scintillator/ScintG4/TriggerG4_SD/CMakeLists.txt b/Scintillator/ScintG4/TriggerG4_SD/CMakeLists.txt
index aa07da6a8f9ef725b393379068bf734db98baad4..543bbe34217d142e9146e4030fb733ee877ebecd 100644
--- a/Scintillator/ScintG4/TriggerG4_SD/CMakeLists.txt
+++ b/Scintillator/ScintG4/TriggerG4_SD/CMakeLists.txt
@@ -27,7 +27,7 @@ atlas_add_component( TriggerG4_SD
LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel ScintSimEvent G4AtlasToolsLib FaserMCTruth )
atlas_add_test( TriggerG4_SDToolConfig_test
- SCRIPT test/TriggerG4_SDToolConfig_test.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/TriggerG4_SDToolConfig_test.py
PROPERTIES TIMEOUT 300 )
# Install files from the package:
diff --git a/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDConfig.py b/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDConfig.py
index b8da576f86c8d27e2f3cd7bd91f143340f658fe5..abd56a67f8b2dd9e2841a0d67ebe783f6b84dc7f 100644
--- a/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDConfig.py
+++ b/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDConfig.py
@@ -1,19 +1,22 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-from G4AtlasApps.SimFlags import simFlags
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-from ISF_Algorithms.collection_merger_helpers import generate_mergeable_collection_name
+TriggerSensorSDTool=CompFactory.TriggerSensorSDTool
+def getTriggerSensorSD(ConfigFlags, name="TriggerSensorSD", **kwargs):
-def getTriggerSensorSD(name="TriggerSensorSD", **kwargs):
+ result = ComponentAccumulator()
bare_collection_name = "TriggerHits"
mergeable_collection_suffix = "_G4"
merger_input_property = "TriggerHits"
- hits_collection_name = generate_mergeable_collection_name(bare_collection_name,
- mergeable_collection_suffix,
- merger_input_property)
+
+ acc, hits_collection_name = CollectionMergerCfg(ConfigFlags, bare_collection_name, mergeable_collection_suffix, merger_input_property)
kwargs.setdefault("LogicalVolumeNames", ["Trigger::Plate"])
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
- return CfgMgr.TriggerSensorSDTool(name, **kwargs)
+
+ result.merge(acc)
+ return result, TriggerSensorSDTool(name, **kwargs)
diff --git a/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDToolConfig.py b/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDToolConfig.py
index 757de83619b99df40f6e0b2e63024f6cd4c6cd7e..6e49a4e52c01c4b04b67d56adc7844221afe5047 100644
--- a/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDToolConfig.py
+++ b/Scintillator/ScintG4/TriggerG4_SD/python/TriggerG4_SDToolConfig.py
@@ -1,10 +1,10 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-# from TriggerG4_SD.TriggerG4_SDConf import TriggerSensorSDTool
-from TriggerG4_SD.TriggerG4_SDConfig import getTriggerSensorSD
+TriggerSensorSDTool=CompFactory.TriggerSensorSDTool
def TriggerSensorSDCfg(ConfigFlags, name="TriggerSensorSD", **kwargs):
@@ -18,4 +18,4 @@ def TriggerSensorSDCfg(ConfigFlags, name="TriggerSensorSD", **kwargs):
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
result.merge(acc)
- return result, getTriggerSensorSD(name, **kwargs)
+ return result, TriggerSensorSDTool(name, **kwargs)
diff --git a/Scintillator/ScintG4/VetoG4_SD/CMakeLists.txt b/Scintillator/ScintG4/VetoG4_SD/CMakeLists.txt
index 2338c04efc4002166a1290f7b742b7ac47d8fc95..a0091083f8830c5f7638ea1632c28b0a83b450b5 100644
--- a/Scintillator/ScintG4/VetoG4_SD/CMakeLists.txt
+++ b/Scintillator/ScintG4/VetoG4_SD/CMakeLists.txt
@@ -27,7 +27,7 @@ atlas_add_component( VetoG4_SD
LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel ScintSimEvent G4AtlasToolsLib FaserMCTruth )
atlas_add_test( VetoG4_SDToolConfig_test
- SCRIPT test/VetoG4_SDToolConfig_test.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/VetoG4_SDToolConfig_test.py
PROPERTIES TIMEOUT 300 )
# Install files from the package:
diff --git a/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDConfig.py b/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDConfig.py
index de3fe9618e6f0cc48b5156c9779ad7505893b206..07295e3fde39963c6a3d6176758d00747c4b3871 100644
--- a/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDConfig.py
+++ b/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDConfig.py
@@ -1,19 +1,22 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-from G4AtlasApps.SimFlags import simFlags
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-from ISF_Algorithms.collection_merger_helpers import generate_mergeable_collection_name
+VetoSensorSDTool=CompFactory.VetoSensorSDTool
+def getVetoSensorSD(ConfigFlags, name="VetoSensorSD", **kwargs):
-def getVetoSensorSD(name="VetoSensorSD", **kwargs):
+ result = ComponentAccumulator()
bare_collection_name = "VetoHits"
mergeable_collection_suffix = "_G4"
merger_input_property = "VetoHits"
- hits_collection_name = generate_mergeable_collection_name(bare_collection_name,
- mergeable_collection_suffix,
- merger_input_property)
+
+ acc, hits_collection_name = CollectionMergerCfg(ConfigFlags, bare_collection_name, mergeable_collection_suffix, merger_input_property)
kwargs.setdefault("LogicalVolumeNames", ["Veto::Plate"])
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
- return CfgMgr.VetoSensorSDTool(name, **kwargs)
+
+ result.merge(acc)
+ return result, VetoSensorSDTool(name, **kwargs)
diff --git a/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDToolConfig.py b/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDToolConfig.py
index 5503826fc952d4266b32c5b732f5efeea83feac8..fcb32ace739465f64727ec0c26d24c002eb566c0 100644
--- a/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDToolConfig.py
+++ b/Scintillator/ScintG4/VetoG4_SD/python/VetoG4_SDToolConfig.py
@@ -1,10 +1,10 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-# from VetoG4_SD.VetoG4_SDConf import VetoSensorSDTool
-from VetoG4_SD.VetoG4_SDConfig import getVetoSensorSD
+VetoSensorSDTool=CompFactory.VetoSensorSDTool
def VetoSensorSDCfg(ConfigFlags, name="VetoSensorSD", **kwargs):
@@ -18,4 +18,4 @@ def VetoSensorSDCfg(ConfigFlags, name="VetoSensorSD", **kwargs):
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
result.merge(acc)
- return result, getVetoSensorSD(name, **kwargs)
+ return result, VetoSensorSDTool(name, **kwargs)
diff --git a/Simulation/G4Faser/G4FaserAlg/CMakeLists.txt b/Simulation/G4Faser/G4FaserAlg/CMakeLists.txt
index 24998f6b73920cba30fa427553fb7f2a89bc83c4..3b55f60e4b02b3d9db944a676d9971128a8a5041 100644
--- a/Simulation/G4Faser/G4FaserAlg/CMakeLists.txt
+++ b/Simulation/G4Faser/G4FaserAlg/CMakeLists.txt
@@ -45,7 +45,7 @@ atlas_add_component( G4FaserAlg
LINK_LIBRARIES ${GEANT4_LIBRARIES} ${EIGEN_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} ${HEPMC_LIBRARIES} AthenaBaseComps AthenaKernel GaudiKernel G4AtlasInterfaces G4FaserAlgLib G4AtlasAlgLib SGTools StoreGateLib SGtests EventInfo GeneratorObjects FaserMCTruthBaseLib )
atlas_add_test( G4FaserAlgConfig_Test
- SCRIPT test/runG4.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/runG4.py
PROPERTIES TIMEOUT 300
PROPERTIES WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
diff --git a/Simulation/G4Faser/G4FaserAlg/python/G4FaserAlgConfigNew.py b/Simulation/G4Faser/G4FaserAlg/python/G4FaserAlgConfigNew.py
index d1fe2d7a2bb67bbc87b9d5bf71dff267c802b1de..292682b4f23b9aa149672aca026e305f8f0d2b4f 100644
--- a/Simulation/G4Faser/G4FaserAlg/python/G4FaserAlgConfigNew.py
+++ b/Simulation/G4Faser/G4FaserAlg/python/G4FaserAlgConfigNew.py
@@ -1,22 +1,21 @@
#
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
#
-from AthenaCommon.AppMgr import *
-
+from AthenaConfiguration.ComponentFactory import CompFactory
#
# Manager classes for detector geometry and sensitive detectors
#
-from G4FaserServices.G4FaserServicesConfigNew import DetectorGeometrySvcCfg
+from G4FaserServices.G4FaserServicesConfigNew import DetectorGeometrySvcCfg, PhysicsListSvcCfg
from G4FaserTools.G4FaserToolsConfigNew import SensitiveDetectorMasterToolCfg
from G4FaserServices.G4FaserUserActionConfigNew import UserActionSvcCfg
-from G4AtlasServices.G4AtlasServicesConfigNew import PhysicsListSvcCfg
# from G4AtlasApps.G4Atlas_MetadataNew import writeSimulationParametersMetadata
#
# Framework utilities
#
from FaserISF_Services.FaserISF_ServicesConfigNew import FaserTruthServiceCfg, FaserInputConverterCfg, FaserGeoIDSvcCfg
#
-from G4FaserAlg.G4FaserAlgConf import G4FaserAlg
+# from G4FaserAlg.G4FaserAlgConf import G4FaserAlg
+G4FaserAlg=CompFactory.G4FaserAlg
def G4FaserAlgCfg(ConfigFlags, name='G4FaserAlg', **kwargs):
#
@@ -110,11 +109,10 @@ def G4FaserAlgCfg(ConfigFlags, name='G4FaserAlg', **kwargs):
## G4AtlasAlg verbosities (available domains = Navigator, Propagator, Tracking, Stepping, Stacking, Event)
## Set stepper verbose = 1 if the Athena logging level is <= DEBUG
# TODO: Why does it complain that G4AtlasAlgConf.G4AtlasAlg has no "Verbosities" object? Fix.
- verbosities=dict()
- #from AthenaCommon.AppMgr import ServiceMgr
- #if ServiceMgr.MessageSvc.OutputLevel <= 2:
- # verbosities["Tracking"]='1'
- # print verbosities
+ verbosities=dict(Placeholder = '0')
+ if "OutputLevel" in kwargs and kwargs["OutputLevel"] <= 2 :
+ verbosities["Tracking"]='1'
+ print (verbosities)
kwargs.setdefault('Verbosities', verbosities)
#
# Set commands for the G4FaserAlg
diff --git a/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.cxx b/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.cxx
index 448aa3a762ec8d4603e8a60bc9accc3154c78782..20108eca13ca73095fef59dfd7c1c6830e7f25a9 100644
--- a/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.cxx
+++ b/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.cxx
@@ -53,8 +53,6 @@ static std::once_flag releaseGeoModelOnceFlag;
G4FaserAlg::G4FaserAlg(const std::string& name, ISvcLocator* pSvcLocator)
: AthAlgorithm(name, pSvcLocator)
{
- // Verbosities
- declareProperty("Verbosities", m_verbosities);
}
@@ -382,9 +380,12 @@ StatusCode G4FaserAlg::execute()
ATH_CHECK(m_senDetTool->EndOfAthenaEvent());
ATH_CHECK(m_fastSimTool->EndOfAthenaEvent());
- for (size_t iEvt = 0; iEvt < outputTruthCollection->size(); ++iEvt)
+ if ((int) msg().level() <= (int) MSG::DEBUG)
{
- outputTruthCollection->at(iEvt)->print(msg(MSG::DEBUG).stream());
+ for (size_t iEvt = 0; iEvt < outputTruthCollection->size(); ++iEvt)
+ {
+ outputTruthCollection->at(iEvt)->print(msg().stream());
+ }
}
ATH_CHECK( m_truthRecordSvc->releaseEvent() );
diff --git a/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.h b/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.h
index cf18bac1291c9ab2e7ec3729375169a57e5ed70a..7960c9a25d294acb51b76521d055d28c10a0a3c0 100644
--- a/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.h
+++ b/Simulation/G4Faser/G4FaserAlg/src/G4FaserAlg.h
@@ -101,7 +101,8 @@ private:
ServiceHandle<ISF::IFaserTruthSvc> m_truthRecordSvc{this, "TruthRecordService", "ISF_FaserTruthRecordSvc", ""};
/// Verbosity settings for Geant4
- std::map<std::string,std::string> m_verbosities;
+ // std::map<std::string,std::string> m_verbosities;
+ Gaudi::Property<std::map<std::string,std::string> > m_verbosities {this, "Verbosities", {}, "Verbosities for G4 components"};
/// @}
/// @name Configurable Properties (common with TransportTool)
diff --git a/Simulation/G4Faser/G4FaserAlg/test/runG4.py b/Simulation/G4Faser/G4FaserAlg/test/runG4.py
index 7bb2ca4caffd86f071319facd07f0cac905d4973..b46088b319143929ee4370e1940a4587c223c67e 100644
--- a/Simulation/G4Faser/G4FaserAlg/test/runG4.py
+++ b/Simulation/G4Faser/G4FaserAlg/test/runG4.py
@@ -5,6 +5,7 @@ if __name__ == "__main__":
import GaudiPython
import ParticleGun as PG
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+ from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaCommon.AppMgr import *
from AthenaCommon.Logging import log, logging
from AthenaCommon.SystemOfUnits import TeV
@@ -54,7 +55,7 @@ if __name__ == "__main__":
#
# Output settings
#
- ConfigFlags.Output.HITSFileName = "g4.HITS.root"
+ ConfigFlags.Output.HITSFileName = "my.HITS.pool.root"
ConfigFlags.GeoModel.GeoExportFile = "faserGeo.db" # Optional dump of geometry for browsing in vp1light
#
# Geometry-related settings
@@ -112,7 +113,7 @@ if __name__ == "__main__":
"McEventCollection#GEN_EVENT",
"ScintHitCollection#*",
"FaserSiHitCollection#*"
- ]))
+ ], disableEventTag=True))
acc.getEventAlgo("OutputStreamHITS").AcceptAlgs = ["G4FaserAlg"] # optional
acc.getEventAlgo("OutputStreamHITS").WritingTool.ProcessingTag = "StreamHITS" # required
#
@@ -130,7 +131,7 @@ if __name__ == "__main__":
# acc.foreach_component("*ClassID*").OutputLevel = INFO
# acc.getService("StoreGateSvc").Dump=True
# acc.getService("ConditionStore").Dump=True
-# acc.printConfig(withDetails=True)
+# acc.printConfig()
f=open('FaserG4AppCfg_EVNT.pkl','w')
acc.store(f)
f.close()
diff --git a/Simulation/G4Faser/G4FaserServices/python/G4FaserFieldServices.py b/Simulation/G4Faser/G4FaserServices/python/G4FaserFieldServices.py
index 38ab3e8b1056e52b3203e86122afe0d0ac21eb99..4d7b81ed2a62f1e56cfbad723faececef0c42c8e 100644
--- a/Simulation/G4Faser/G4FaserServices/python/G4FaserFieldServices.py
+++ b/Simulation/G4Faser/G4FaserServices/python/G4FaserFieldServices.py
@@ -1,13 +1,12 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
#
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from G4AtlasServices.G4AtlasServicesConf import StandardFieldSvc, ConstantFieldSvc
+from AthenaConfiguration.ComponentFactory import CompFactory
+StandardFieldSvc=CompFactory.StandardFieldSvc
+ConstantFieldSvc=CompFactory.ConstantFieldSvc
+
from AthenaCommon.SystemOfUnits import tesla
from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
-#to prevent unit tests failing when just running over simulation
-# import os
-# if "AthSimulation_DIR" not in os.environ:
-# from ForwardRegionMgField.ForwardRegionMgFieldConf import MagField__ForwardRegionFieldSvc
def StandardFieldSvcCfg(ConfigFlags,name="StandardField", **kwargs):
result = ComponentAccumulator()
diff --git a/Simulation/G4Faser/G4FaserServices/python/G4FaserServicesConfigNew.py b/Simulation/G4Faser/G4FaserServices/python/G4FaserServicesConfigNew.py
index 115634e5eda0d9fb6908124659fdc87dfd85c620..8b5e7718687b0315aeded2d62ecd39250738bd00 100644
--- a/Simulation/G4Faser/G4FaserServices/python/G4FaserServicesConfigNew.py
+++ b/Simulation/G4Faser/G4FaserServices/python/G4FaserServicesConfigNew.py
@@ -1,10 +1,9 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-#
+from __future__ import print_function
+from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-#
-# The code of these services is experiment-agnostic, so we just have to configure them here for FASER instead of ATLAS
-#
-from G4AtlasServices.G4AtlasServicesConf import DetectorGeometrySvc, G4AtlasSvc, G4GeometryNotifierSvc
+
+DetectorGeometrySvc, G4AtlasSvc, G4GeometryNotifierSvc, PhysicsListSvc=CompFactory.getComps("DetectorGeometrySvc","G4AtlasSvc","G4GeometryNotifierSvc","PhysicsListSvc",)
#
# Physics region tools
#
@@ -28,7 +27,7 @@ from G4FaserTools.G4FieldConfigNew import TrackerFieldManagerToolCfg, DipoleFiel
def getFASER_RegionCreatorList(ConfigFlags):
regionCreatorList = []
- from G4AtlasApps.SimFlags import simFlags
+ # from G4AtlasApps.SimFlags import simFlags
# Settings to widen the region of study - not yet supported by FASER
# if ConfigFlags.Beam.Type == 'cosmics' or ConfigFlags.Sim.CavernBG != 'Signal':
# regionCreatorList += [SX1PhysicsRegionToolCfg(ConfigFlags), BedrockPhysicsRegionToolCfg(ConfigFlags), CavernShaftsConcretePhysicsRegionToolCfg(ConfigFlags)]
@@ -131,3 +130,26 @@ def G4GeometryNotifierSvcCfg(ConfigFlags, name="G4GeometryNotifierSvc", **kwargs
kwargs.setdefault("ActivateLVNotifier", True)
kwargs.setdefault("ActivatePVNotifier", False)
return G4GeometryNotifierSvc(name, **kwargs)
+
+def PhysicsListSvcCfg(ConfigFlags, name="PhysicsListSvc", **kwargs):
+ result = ComponentAccumulator()
+ G4StepLimitationTool = CompFactory.G4StepLimitationTool
+ PhysOptionList = [G4StepLimitationTool("G4StepLimitationTool")]
+ #PhysOptionList += ConfigFlags.Sim.PhysicsOptions # FIXME Missing functionality
+ PhysDecaysList = []
+ kwargs.setdefault("PhysOption", PhysOptionList)
+ kwargs.setdefault("PhysicsDecay", PhysDecaysList)
+ kwargs.setdefault("PhysicsList", ConfigFlags.Sim.PhysicsList)
+ if 'PhysicsList' in kwargs:
+ if kwargs['PhysicsList'].endswith('_EMV') or kwargs['PhysicsList'].endswith('_EMX'):
+ raise RuntimeError( 'PhysicsList not allowed: '+kwargs['PhysicsList'] )
+ kwargs.setdefault("GeneralCut", 1.)
+ if ConfigFlags.Sim.NeutronTimeCut > 0.:
+ kwargs.setdefault("NeutronTimeCut", ConfigFlags.Sim.NeutronTimeCut)
+
+ if ConfigFlags.Sim.NeutronEnergyCut > 0.:
+ kwargs.setdefault("NeutronEnergyCut", ConfigFlags.Sim.NeutronEnergyCut)
+
+ kwargs.setdefault("ApplyEMCuts", ConfigFlags.Sim.ApplyEMCuts)
+ result.addService(PhysicsListSvc(name, **kwargs))
+ return result
diff --git a/Simulation/G4Faser/G4FaserServices/python/G4FaserUserActionConfigNew.py b/Simulation/G4Faser/G4FaserServices/python/G4FaserUserActionConfigNew.py
index cf994348807ec1d8f447ee86ede7db49085c8bae..3c54dd5db871f7c19f004d3b9e803a509e798500 100644
--- a/Simulation/G4Faser/G4FaserServices/python/G4FaserUserActionConfigNew.py
+++ b/Simulation/G4Faser/G4FaserServices/python/G4FaserUserActionConfigNew.py
@@ -1,9 +1,10 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
# from FaserMCTruthBase.FaserMCTruthBaseConfigNew import MCTruthSteppingActionToolCfg
-from G4AtlasServices.G4AtlasServicesConf import G4UA__UserActionSvc
+G4UA__UserActionSvc=CompFactory.G4UA.UserActionSvc
from G4UserActions.G4UserActionsConfigNew import AthenaStackingActionToolCfg, AthenaTrackingActionToolCfg
@@ -67,11 +68,11 @@ def UserActionSvcCfg(ConfigFlags, name="G4UA::UserActionSvc", **kwargs):
result = ComponentAccumulator()
#how to convert this flag?
- from G4AtlasApps.SimFlags import simFlags
- optActions = simFlags.OptionalUserActionList.get_Value()
+ # from G4AtlasApps.SimFlags import simFlags
+ # optActions = simFlags.OptionalUserActionList.get_Value()
# new user action tools
kwargs.setdefault('UserActionTools',
- getDefaultActions(ConfigFlags) + optActions['General'])
+ getDefaultActions(ConfigFlags))
# placeholder for more advanced config, if needed
result.addService ( G4UA__UserActionSvc(name, **kwargs) )
diff --git a/Simulation/G4Faser/G4FaserTools/python/G4FieldConfigNew.py b/Simulation/G4Faser/G4FaserTools/python/G4FieldConfigNew.py
index 0bfaf6b6e5827c099d8d8d65f82574ae1029c773..bd6ad12d684d744f39e281e783e50ffe77759ce0 100644
--- a/Simulation/G4Faser/G4FaserTools/python/G4FieldConfigNew.py
+++ b/Simulation/G4Faser/G4FaserTools/python/G4FieldConfigNew.py
@@ -1,88 +1,53 @@
#
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
#
-from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from CalypsoConfiguration.AllConfigFlags import ConfigFlags
-from G4AtlasApps.SimFlags import simFlags
-#
-# These field tools and services are generic and can be reused by reconfiguring them
-#
-from G4AtlasTools.G4AtlasToolsConf import GlobalFieldManagerTool, DetectorFieldManagerTool
+from AthenaConfiguration.ComponentFactory import CompFactory
+GlobalFieldManagerTool, DetectorFieldManagerTool=CompFactory.getComps("GlobalFieldManagerTool","DetectorFieldManagerTool",)
#
from G4FaserServices.G4FaserFieldServices import StandardFieldSvcCfg, ConstantFieldSvcCfg
#
# Field Managers
#
def FASERFieldManagerToolCfg(ConfigFlags, name='FaserFieldManager', **kwargs):
- result = ComponentAccumulator()
- kwargs.setdefault("IntegratorStepper", simFlags.G4Stepper.get_Value())
-
- acc = StandardFieldSvcCfg(ConfigFlags)
- kwargs.setdefault("FieldSvc", acc.getService("StandardField"))
- # acc = ConstantFieldSvcCfg(ConfigFlags)
- # kwargs.setdefault("FieldSvc", acc.getService("ConstantField"))
- result.merge(acc)
-
+ result = StandardFieldSvcCfg(ConfigFlags)
+ kwargs.setdefault("IntegratorStepper", ConfigFlags.Sim.G4Stepper)
+ kwargs.setdefault("FieldSvc", result.getService("StandardField"))
kwargs.setdefault("UseTightMuonStepping", False)
- if simFlags.EquationOfMotion.statusOn:
- kwargs.setdefault("EquationOfMotion", simFlags.EquationOfMotion.get_Value())
+ if len(ConfigFlags.Sim.G4EquationOfMotion)>0:
+ kwargs.setdefault("EquationOfMotion", ConfigFlags.Sim.G4EquationOfMotion )
result.setPrivateTools(GlobalFieldManagerTool(name, **kwargs))
return result
def TightMuonsFASERFieldManagerToolCfg(ConfigFlags, name='TightMuonsFASERFieldManager', **kwargs):
- result = ComponentAccumulator()
- kwargs.setdefault("IntegratorStepper", simFlags.G4Stepper.get_Value())
-
- acc = StandardFieldSvcCfg(ConfigFlags)
- kwargs.setdefault("FieldSvc", acc.getService("StandardField"))
- # acc = ConstantFieldSvcCfg(ConfigFlags)
- # kwargs.setdefault("FieldSvc", acc.getService("ConstantField"))
- result.merge(acc)
-
+ result = StandardFieldSvcCfg(ConfigFlags)
+ kwargs.setdefault("IntegratorStepper", ConfigFlags.Sim.G4Stepper)
+ kwargs.setdefault("FieldSvc", result.getService("StandardField"))
kwargs.setdefault("UseTightMuonStepping",True)
- if simFlags.EquationOfMotion.statusOn:
- kwargs.setdefault("EquationOfMotion", simFlags.EquationOfMotion.get_Value() )
-
+ if len(ConfigFlags.Sim.G4EquationOfMotion)>0:
+ kwargs.setdefault("EquationOfMotion", ConfigFlags.Sim.G4EquationOfMotion )
result.setPrivateTools(GlobalFieldManagerTool(name, **kwargs))
return result
-# #not used in G4AtlasServicesConfigNew?
-# def ClassicFieldManagerToolCfg(ConfigFlags, name='ClassicFieldManager', **kwargs):
-# kwargs.setdefault("IntegratorStepper", "ClassicalRK4")
-# return ATLASFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-#
def BasicDetectorFieldManagerToolCfg(ConfigFlags, name='BasicDetectorFieldManager', **kwargs):
- result = ComponentAccumulator()
- kwargs.setdefault("IntegratorStepper", simFlags.G4Stepper.get_Value())
-
- acc = StandardFieldSvcCfg(ConfigFlags)
- kwargs.setdefault("FieldSvc", acc.getService("StandardField"))
- result.merge(acc)
-
+ result = StandardFieldSvcCfg(ConfigFlags)
+ kwargs.setdefault("IntegratorStepper", ConfigFlags.Sim.G4Stepper)
+ kwargs.setdefault("FieldSvc", result.getService("StandardField"))
kwargs.setdefault('MuonOnlyField', False)
- if simFlags.EquationOfMotion.statusOn:
- kwargs.setdefault("EquationOfMotion", simFlags.EquationOfMotion.get_Value() )
-
+ if len(ConfigFlags.Sim.G4EquationOfMotion)>0:
+ kwargs.setdefault("EquationOfMotion", ConfigFlags.Sim.G4EquationOfMotion )
result.setPrivateTools(DetectorFieldManagerTool(name, **kwargs))
return result
#
# Simple constant field everywhere
#
def BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name='BasicDetectorConstantFieldManager', **kwargs):
- result = ComponentAccumulator()
- kwargs.setdefault("IntegratorStepper", simFlags.G4Stepper.get_Value())
-
- # acc = StandardFieldSvcCfg(ConfigFlags)
- # kwargs.setdefault("FieldSvc", acc.getService("StandardField"))
- acc = ConstantFieldSvcCfg(ConfigFlags)
- kwargs.setdefault("FieldSvc", acc.getService("ConstantField"))
- result.merge(acc)
-
- kwargs.setdefault('MuonOnlyField', False)
- if simFlags.EquationOfMotion.statusOn:
- kwargs.setdefault("EquationOfMotion", simFlags.EquationOfMotion.get_Value() )
-
- result.setPrivateTools(DetectorFieldManagerTool(name, **kwargs))
+ result = ConstantFieldSvcCfg(ConfigFlags)
+ kwargs.setdefault("IntegratorStepper", ConfigFlags.Sim.G4Stepper)
+ kwargs.setdefault("FieldSvc", result.getService("ConstantField"))
+ kwargs.setdefault("UseTightMuonStepping", False)
+ if len(ConfigFlags.Sim.G4EquationOfMotion)>0:
+ kwargs.setdefault("EquationOfMotion", ConfigFlags.Sim.G4EquationOfMotion )
+ result.setPrivateTools(GlobalFieldManagerTool(name, **kwargs))
return result
#
# Same numerical values as ATLAS Inner Detector
@@ -94,7 +59,6 @@ def VetoFieldManagerToolCfg(ConfigFlags, name='VetoFieldManager', **kwargs):
kwargs.setdefault('DeltaOneStep', 0.0001)
kwargs.setdefault('MaximumEpsilonStep', 0.001)
kwargs.setdefault('MinimumEpsilonStep', 0.00001)
- # return BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name, **kwargs)
return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
@@ -105,7 +69,6 @@ def TriggerFieldManagerToolCfg(ConfigFlags, name='TriggerFieldManager', **kwargs
kwargs.setdefault('DeltaOneStep', 0.0001)
kwargs.setdefault('MaximumEpsilonStep', 0.001)
kwargs.setdefault('MinimumEpsilonStep', 0.00001)
- # return BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name, **kwargs)
return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
@@ -116,7 +79,6 @@ def PreshowerFieldManagerToolCfg(ConfigFlags, name='PreshowerFieldManager', **kw
kwargs.setdefault('DeltaOneStep', 0.0001)
kwargs.setdefault('MaximumEpsilonStep', 0.001)
kwargs.setdefault('MinimumEpsilonStep', 0.00001)
- # return BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name, **kwargs)
return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
@@ -127,7 +89,6 @@ def TrackerFieldManagerToolCfg(ConfigFlags, name='TrackerFieldManager', **kwargs
kwargs.setdefault('DeltaOneStep', 0.0001)
kwargs.setdefault('MaximumEpsilonStep', 0.001)
kwargs.setdefault('MinimumEpsilonStep', 0.00001)
- # return BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name, **kwargs)
return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
def DipoleFieldManagerToolCfg(ConfigFlags, name='DipoleFieldManager', **kwargs):
@@ -137,240 +98,6 @@ def DipoleFieldManagerToolCfg(ConfigFlags, name='DipoleFieldManager', **kwargs):
kwargs.setdefault('DeltaOneStep', 0.0001)
kwargs.setdefault('MaximumEpsilonStep', 0.001)
kwargs.setdefault('MinimumEpsilonStep', 0.00001)
- # return BasicDetectorConstantFieldManagerToolCfg(ConfigFlags, name, **kwargs)
return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# def BeamPipeFieldManagerToolCfg(ConfigFlags, name='BeamPipeFieldManager', **kwargs):
-# kwargs.setdefault("LogicalVolumes", ['BeamPipe::BeamPipe'])
-# #kwargs.setdefault('DeltaChord', 0.00001)
-# kwargs.setdefault('DeltaIntersection', 0.00001)
-# kwargs.setdefault('DeltaOneStep', 0.0001)
-# kwargs.setdefault('MaximumEpsilonStep', 0.001)
-# kwargs.setdefault('MinimumEpsilonStep', 0.00001)
-# return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-
-# def InDetFieldManagerToolCfg(ConfigFlags, name='InDetFieldManager', **kwargs):
-# kwargs.setdefault("LogicalVolumes", ['IDET::IDET'])
-# #kwargs.setdefault('DeltaChord', 0.00001)
-# kwargs.setdefault('DeltaIntersection', 0.00001)
-# kwargs.setdefault('DeltaOneStep', 0.0001)
-# kwargs.setdefault('MaximumEpsilonStep', 0.001)
-# kwargs.setdefault('MinimumEpsilonStep', 0.00001)
-# return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-
-# def MuonsOnlyInCaloFieldManagerToolCfg(ConfigFlags, name='MuonsOnlyInCaloFieldManager', **kwargs):
-# kwargs.setdefault("LogicalVolumes", ['CALO::CALO'])
-# #kwargs.setdefault('DeltaChord', 0.00000002)
-# kwargs.setdefault('DeltaIntersection', 0.00000002)
-# kwargs.setdefault('DeltaOneStep', 0.000001)
-# kwargs.setdefault('MaximumEpsilonStep', 0.0000009)
-# kwargs.setdefault('MinimumEpsilonStep', 0.000001)
-# kwargs.setdefault('MuonOnlyField', True)
-# return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-
-# def MuonFieldManagerToolCfg(ConfigFlags, name='MuonFieldManager', **kwargs):
-# kwargs.setdefault("LogicalVolumes", ['MUONQ02::MUONQ02'])
-# #kwargs.setdefault('DeltaChord', 0.00000002)
-# kwargs.setdefault('DeltaIntersection', 0.00000002)
-# kwargs.setdefault('DeltaOneStep', 0.000001)
-# kwargs.setdefault('MaximumEpsilonStep', 0.0000009)
-# kwargs.setdefault('MinimumEpsilonStep', 0.000001)
-# return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-
-#not used in G4AtlasServicesConfigNew?
-# def BasicFwdFieldManagerToolCfg(ConfigFlags, name='FwdFieldManagerTool', **kwargs):
-# result=ComponentAccumulator()
-
-# #kwargs.setdefault('DeltaChord', 0.00000002)
-# kwargs.setdefault('DeltaIntersection', 1e-9)
-# kwargs.setdefault('DeltaOneStep', 1e-8)
-# kwargs.setdefault('MaximumEpsilonStep', 1e-8)
-# kwargs.setdefault('MinimumEpsilonStep', 1e-9)
-
-# accForwardField = ForwardFieldSvcCfg(ConfigFlags)
-# #kwargs.setdefault("FieldSvc", ForwardFieldSvcCfg(ConfigFlags))
-# kwargs.setdefault("FieldSvc", accForwardField.getService("ForwardField")) #accessing the right service?
-# result.merge(accForwardField)
-
-# #from G4AtlasApps.SimFlags import simFlags
-# #if simFlags.FwdStepLimitation.statusOn:
-# # kwargs.setdefault("MaximumStep", simFlags.FwdStepLimitation())
-# if False:
-# kwargs.setdefault("MaximumStep", 1000.)
-# acc = BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-
-# def Q1FwdFieldManagerToolCfg(ConfigFlags, name='Q1FwdFieldManager', **kwargs):
-# result = Q1FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q1FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAA.1R1MagQ1'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q2FwdFieldManagerToolCfg(ConfigFlags, name='Q2FwdFieldManager', **kwargs):
-# result=Q2FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q2FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXBA.2R1MagQ2a', 'FwdRegion::LQXBA.2R1MagQ2b'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q3FwdFieldManagerToolCfg(ConfigFlags, name='Q3FwdFieldManager', **kwargs):
-# result=Q3FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q3FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAG.3R1MagQ3'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def D1FwdFieldManagerToolCfg(ConfigFlags, name='D1FwdFieldManager', **kwargs):
-# result=D1FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('D1FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::MBXW.A4R1MagD1a', 'FwdRegion::MBXW.B4R1MagD1b',
-# 'FwdRegion::MBXW.C4R1MagD1c', 'FwdRegion::MBXW.D4R1MagD1d',
-# 'FwdRegion::MBXW.E4R1MagD1e', 'FwdRegion::MBXW.F4R1MagD1f'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def D2FwdFieldManagerToolCfg(ConfigFlags, name='D2FwdFieldManager', **kwargs):
-# result=D2FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('D2FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LBRCD.4R1MagD2'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q4FwdFieldManagerToolCfg(ConfigFlags, name='Q4FwdFieldManager', **kwargs):
-# result=Q4FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q4FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQYCH.4R1MagQ4'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q5FwdFieldManagerToolCfg(ConfigFlags, name='Q5FwdFieldManager', **kwargs):
-# result=Q5FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q5FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQNDC.5R1MagQ5'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q6FwdFieldManagerToolCfg(ConfigFlags, name='Q6FwdFieldManager', **kwargs):
-# result=Q6FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q6FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQNDD.6R1MagQ6'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q7FwdFieldManagerToolCfg(ConfigFlags, name='Q7FwdFieldManager', **kwargs):
-# result=Q7FwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q7FwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQNFD.7R1MagQ7a', 'FwdRegion::LQNFD.7R1MagQ7b'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q1HKickFwdFieldManagerToolCfg(ConfigFlags, name='Q1HKickFwdFieldManager', **kwargs):
-# result=Q1HKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q1HKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAA.1R1MagQ1HKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q1VKickFwdFieldManagerToolCfg(ConfigFlags, name='Q1VKickFwdFieldManager', **kwargs):
-# result=Q1VKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q1VKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAA.1R1MagQ1VKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q2HKickFwdFieldManagerToolCfg(ConfigFlags, name='Q2HKickFwdFieldManager', **kwargs):
-# result=Q2HKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q2HKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXBA.2R1MagQ2HKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q2VKickFwdFieldManagerToolCfg(ConfigFlags, name='Q2VKickFwdFieldManager', **kwargs):
-# result=Q2VKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q2VKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXBA.2R1MagQ2VKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q3HKickFwdFieldManagerToolCfg(ConfigFlags, name='Q3HKickFwdFieldManager', **kwargs):
-# result=Q3HKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q3HKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAG.3R1MagQ3HKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q3VKickFwdFieldManagerToolCfg(ConfigFlags, name='Q3VKickFwdFieldManager', **kwargs):
-# result=Q3VKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q3VKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQXAG.3R1MagQ3VKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q4VKickAFwdFieldManagerToolCfg(ConfigFlags, name='Q4VKickAFwdFieldManager', **kwargs):
-# result=Q4VKickAFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q4VKickAFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQYCH.4R1MagQ4VKickA'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q4HKickFwdFieldManagerToolCfg(ConfigFlags, name='Q4HKickFwdFieldManager', **kwargs):
-# result=Q4HKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q4HKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQYCH.4R1MagQ4HKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q4VKickBFwdFieldManagerToolCfg(ConfigFlags, name='Q4VKickBFwdFieldManager', **kwargs):
-# result=Q4VKickBFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q4VKickBFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQYCH.4R1MagQ4VKickB'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q5HKickFwdFieldManagerToolCfg(ConfigFlags, name='Q5HKickFwdFieldManager', **kwargs):
-# result=Q5HKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q5HKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQNDC.5R1MagQ5HKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-# def Q6VKickFwdFieldManagerToolCfg(ConfigFlags, name='Q6VKickFwdFieldManager', **kwargs):
-# result=Q6VKickFwdG4FieldSvcCfg(ConfigFlags)
-# kwargs.setdefault("FieldSvc", result.getService('Q6VKickFwdG4FieldSvc'))
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::LQNDD.6R1MagQ6VKick'])
-# acc=BasicFwdFieldManagerToolCfg(ConfigFlags, name, **kwargs)
-# tool = result.popToolsAndMerge(acc)
-# result.setPrivateTools(tool)
-# return result
-
-# def FwdRegionFieldManagerToolCfg(ConfigFlags, name='FwdRegionFieldManager', **kwargs):
-# kwargs.setdefault("LogicalVolumes", ['FwdRegion::ForwardRegionGeoModel'])
-# #from G4AtlasApps.SimFlags import simFlags
-# #if simFlags.FwdStepLimitation.statusOn:
-# # kwargs.setdefault("MaximumStep", simFlags.FwdStepLimitation())
-# if False:
-# kwargs.setdefault("MaximumStep", 1000.)
-# return BasicDetectorFieldManagerToolCfg(ConfigFlags, name, **kwargs)
diff --git a/Simulation/G4Faser/G4FaserTools/python/G4GeometryToolConfig.py b/Simulation/G4Faser/G4FaserTools/python/G4GeometryToolConfig.py
index 97dd909e6f500eeeec44340be2198fa024af5392..181a57b6ccc8fe9c16c073852e5c2638ee400b42 100644
--- a/Simulation/G4Faser/G4FaserTools/python/G4GeometryToolConfig.py
+++ b/Simulation/G4Faser/G4FaserTools/python/G4GeometryToolConfig.py
@@ -1,11 +1,14 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+from __future__ import print_function
+
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
-from Geo2G4.Geo2G4Conf import GeoDetectorTool
+GeoDetectorTool=CompFactory.GeoDetectorTool
-from G4AtlasTools.G4AtlasToolsConf import CylindricalEnvelope, PolyconicalEnvelope, MaterialDescriptionTool,G4AtlasDetectorConstructionTool, BoxEnvelope #(check)
+BoxEnvelope,MaterialDescriptionTool,G4AtlasDetectorConstructionTool=CompFactory.getComps("BoxEnvelope","MaterialDescriptionTool","G4AtlasDetectorConstructionTool",)
-from AthenaCommon.SystemOfUnits import mm, cm, m
+from AthenaCommon.SystemOfUnits import mm
from VetoGeoModel.VetoGeoModelConfig import VetoGeometryCfg
from TriggerGeoModel.TriggerGeoModelConfig import TriggerGeometryCfg
from PreshowerGeoModel.PreshowerGeoModelConfig import PreshowerGeometryCfg
diff --git a/Simulation/G4Faser/G4FaserTools/python/G4PhysicsRegionConfigNew.py b/Simulation/G4Faser/G4FaserTools/python/G4PhysicsRegionConfigNew.py
index 092950bd0a8cfa7bea901fab22bb4305780a3cfb..38dd5952d0e6d40239250b2428140f66a882a623 100644
--- a/Simulation/G4Faser/G4FaserTools/python/G4PhysicsRegionConfigNew.py
+++ b/Simulation/G4Faser/G4FaserTools/python/G4PhysicsRegionConfigNew.py
@@ -1,6 +1,7 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from G4AtlasTools.G4AtlasToolsConf import RegionCreator
+from AthenaConfiguration.ComponentFactory import CompFactory
+RegionCreator=CompFactory.RegionCreator
# Beampipe Regions
# def BeampipeFwdCutPhysicsRegionToolCfg(ConfigFlags, name='BeampipeFwdCutPhysicsRegionTool', **kwargs):
# kwargs.setdefault("RegionName", 'BeampipeFwdCut')
diff --git a/Simulation/G4Utilities/G4UserActions/python/G4UserActionsConfigNew.py b/Simulation/G4Utilities/G4UserActions/python/G4UserActionsConfigNew.py
index bd282bbd91945a6eba4f591b99e4140013f40789..4f37ffb40ce67bc563cc4898660e42b414691379 100644
--- a/Simulation/G4Utilities/G4UserActions/python/G4UserActionsConfigNew.py
+++ b/Simulation/G4Utilities/G4UserActions/python/G4UserActionsConfigNew.py
@@ -1,7 +1,9 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from G4UserActions.G4UserActionsConf import G4UA__AthenaStackingActionTool, G4UA__AthenaTrackingActionTool
+from AthenaConfiguration.ComponentFactory import CompFactory
+G4UA__AthenaStackingActionTool=CompFactory.G4UA.AthenaStackingActionTool
+G4UA__AthenaTrackingActionTool=CompFactory.G4UA.AthenaTrackingActionTool
# this is a bit cumbersome, but it seems ike it is a lot easier to separate
# the getter functionality from all the rest (i.e. adding the action).
diff --git a/Simulation/ISF/ISF_Core/FaserISF_Services/python/FaserISF_ServicesConfigNew.py b/Simulation/ISF/ISF_Core/FaserISF_Services/python/FaserISF_ServicesConfigNew.py
index ccf7a86cde860c0eefc4b772c1dd92040c6a64e5..589c9480d4d37255486e86b78ec4a0b9b3907cf4 100644
--- a/Simulation/ISF/ISF_Core/FaserISF_Services/python/FaserISF_ServicesConfigNew.py
+++ b/Simulation/ISF/ISF_Core/FaserISF_Services/python/FaserISF_ServicesConfigNew.py
@@ -17,7 +17,7 @@ from FaserISF_HepMC_Tools.FaserISF_HepMC_ToolsConfigNew import FaserTruthStrateg
# from SubDetectorEnvelopes.SubDetectorEnvelopesConfigNew import EnvelopeDefSvcCfg
-ISF__FaserTruthSvc, ISF__FaserGeoIDSvc, ISF__FaserInputConverter = CompFactory.getComps("ISF__FaserTruthSvc","ISF__FaserGeoIDSvc","ISF__FaserInputConverter")
+ISF__FaserTruthSvc, ISF__FaserGeoIDSvc, ISF__FaserInputConverter = CompFactory.getComps("ISF::FaserTruthSvc","ISF::FaserGeoIDSvc","ISF::FaserInputConverter")
#Functions yet to be migrated:
#getParticleBrokerSvcNoOrdering, getParticleBrokerSvc, getAFIIParticleBrokerSvc, getAFIIEnvelopeDefSvc, getAFIIGeoIDSvc
diff --git a/Simulation/ISF/ISF_HepMC/FaserISF_HepMC_Tools/python/FaserISF_HepMC_ToolsConfigNew.py b/Simulation/ISF/ISF_HepMC/FaserISF_HepMC_Tools/python/FaserISF_HepMC_ToolsConfigNew.py
index 8b9637bf15a8f637639e9e22785a1a811627fc8f..6260adb1df35d12af4c2a2cd82cfcef4b597248d 100644
--- a/Simulation/ISF/ISF_HepMC/FaserISF_HepMC_Tools/python/FaserISF_HepMC_ToolsConfigNew.py
+++ b/Simulation/ISF/ISF_HepMC/FaserISF_HepMC_Tools/python/FaserISF_HepMC_ToolsConfigNew.py
@@ -8,9 +8,9 @@ KG Tan, 17/06/2012
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
-ISF__FaserTruthStrategy, ISF__FaserGenParticlePositionFilter, ISF__FaserGenParticleGenericFilter=CompFactory.getComps("ISF__FaserTruthStrategy","ISF__FaserGenParticlePositionFilter","ISF__FaserGenParticleGenericFilter")
+ISF__FaserTruthStrategy, ISF__FaserGenParticlePositionFilter, ISF__FaserGenParticleGenericFilter=CompFactory.getComps("ISF::FaserTruthStrategy","ISF::FaserGenParticlePositionFilter","ISF::FaserGenParticleGenericFilter")
-from AthenaCommon.SystemOfUnits import MeV, mm
+# from AthenaCommon.SystemOfUnits import MeV, mm
#Functions yet to be migrated:
#getParticleSimWhiteList, getParticlePositionFilterMS
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt b/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt
index bee3a568e8fb7b6ce9800513d1f6e5521b2a6b36..2b6f3035dd7dd93a4bcdf5beaa3be6ecac1d7245 100644
--- a/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt
@@ -2,6 +2,7 @@
# Package: FaserSCT_ConditionsData
################################################################################
+option( INSTALL_CONDB "Generate and install a conditions database" OFF )
# Declare the package name:
atlas_subdir( FaserSCT_ConditionsData )
@@ -18,16 +19,18 @@ atlas_add_library( FaserSCT_ConditionsData
PUBLIC_HEADERS FaserSCT_ConditionsData
LINK_LIBRARIES AthenaPoolUtilities Identifier )
-add_custom_command (
- OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
- DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
- COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
- )
+if (INSTALL_CONDB)
+ add_custom_command (
+ OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
+ COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ )
-add_custom_target( ALLP200 ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db )
-
-# Install the generated file:
-install( FILES ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
- DESTINATION ${CMAKE_INSTALL_DATADIR} )
+ add_custom_target( ALLP200 ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db )
+ # Install the generated file:
+ install( FILES ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
+ DESTINATION ${CMAKE_INSTALL_DATADIR}
+ )
+endif()
\ No newline at end of file
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py b/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py
index 2855d6611316fe09718a3638dc1db8280dcfa45c..7e4a9dca06ba7ddecc1e682e72d884f75810e673 100644
--- a/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py
@@ -21,7 +21,7 @@ from PyCool import cool, coral
dbSvc = cool.DatabaseSvcFactory.databaseService()
connectString = 'sqlite://;schema=ALLP200.db;dbname=OFLP200'
-print 'recreating database'
+print('recreating database')
dbSvc.dropDatabase( connectString )
db = dbSvc.createDatabase( connectString )
@@ -118,4 +118,30 @@ modtempFolder = db.createFolder('/SCT/DCS/MODTEMP', modtempFolderSpec, descripti
for channel in sctChannels:
modtempFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, modtempRecord, int(channel) )
+mapSpec = cool.RecordSpecification()
+mapSpec.extend( 'FieldType', cool.StorageType.String4k )
+mapSpec.extend( 'MapFileName', cool.StorageType.String4k )
+
+mapRecord = cool.Record(mapSpec)
+mapRecord['FieldType'] = "GlobalMap"
+mapRecord['MapFileName'] = "file:MagneticFieldMaps/FaserFieldTable.root"
+
+mapFolderSpec = cool.FolderSpecification(mapSpec)
+mapFolder = db.createFolder('/GLOBAL/BField/Maps', mapFolderSpec, descriptionDCS, True)
+
+mapFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, mapRecord, 1 )
+
+scaleSpec = cool.RecordSpecification()
+scaleSpec.extend( 'value', cool.StorageType.Float )
+
+scaleRecord = cool.Record(scaleSpec)
+scaleRecord['value'] = 1.0
+
+scaleFolderSpec = cool.FolderSpecification(scaleSpec)
+scaleFolder = db.createFolder('/GLOBAL/BField/Scales', scaleFolderSpec, descriptionDCS, True)
+
+# Channel names don't seem to be handled properly by Athena
+scaleFolder.createChannel( 1, "Dipole_Scale" )
+scaleFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, scaleRecord, 1 )
+
db.closeDatabase()
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt
index 5ce3bdfcd0e3eea4f718a62ad32455b764162278..a6a19e68b8109687b981504b1f347ffc5879d054 100644
--- a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt
@@ -22,7 +22,9 @@ atlas_depends_on_subdirs( PUBLIC
DetectorDescription/Identifier
InnerDetector/InDetConditions/InDetConditionsSummaryService
Tracker/TrackerDetDescr/TrackerIdentifier
- Tracker/TrackerDetDescr/TrackerReadoutGeometry )
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ MagneticField/MagFieldElements
+ MagneticField/MagFieldConditions )
# External dependencies:
find_package( Eigen )
@@ -32,7 +34,7 @@ atlas_add_component( FaserSiLorentzAngleTool
src/*.cxx
src/components/*.cxx
INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
- LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthenaKernel StoreGateLib SGtests GeoPrimitives GaudiKernel FaserSiPropertiesToolLib MagFieldInterfaces AthenaPoolUtilities Identifier TrackerIdentifier TrackerReadoutGeometry )
+ LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthenaKernel StoreGateLib SGtests GeoPrimitives GaudiKernel FaserSiPropertiesToolLib MagFieldInterfaces AthenaPoolUtilities Identifier TrackerIdentifier TrackerReadoutGeometry MagFieldElements MagFieldConditions )
# Run tests:
#atlas_add_test( TestSCTLorentzAngle
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx
index 32f942869d0d7b1a04285b24023aef3d34e25e79..dc6fbd524fbdbedd59b64d3ab09fb3a1135521c7 100644
--- a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx
@@ -49,6 +49,9 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::initialize()
if (m_useMagFieldSvc.value()) {
// MagFieldSvc
ATH_CHECK(m_magFieldSvc.retrieve());
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ATH_CHECK( m_fieldCondObjInputKey.initialize() );
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Read Cond handle
// if (m_useMagFieldDcs.value()) {
// ATH_CHECK(m_readKeyBFieldSensor.initialize());
@@ -110,7 +113,7 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::execute(const EventContext& ctx) cons
return StatusCode::FAILURE;
}
- bool validSCT{false};
+ // bool validSCT{false};
if ((not m_sctDefaults.value()) and (not m_useGeoModel.value())) {
// Read Cond Handle (temperature)
SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleTemp{m_readKeyTemp, ctx};
@@ -146,11 +149,23 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::execute(const EventContext& ctx) cons
ATH_MSG_FATAL("Invalid intersection rangeSCT: " << rangeSCT);
return StatusCode::FAILURE;
}
- validSCT = true;
+ // validSCT = true;
}
// bool validBField{false};
- // if (m_useMagFieldSvc.value()) {
+ MagField::FaserFieldCache fieldCache;
+ if (m_useMagFieldSvc.value()) {
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Get field cache object
+ SG::ReadCondHandle<FaserFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
+ const FaserFieldCacheCondObj* fieldCondObj{*readHandle};
+
+ if (fieldCondObj == nullptr) {
+ ATH_MSG_ERROR("FaserSCT_SiLorentzAngleCondAlg : Failed to retrieve FaserFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
+ return StatusCode::FAILURE;
+ }
+ fieldCondObj->getInitializedCache (fieldCache);
+////////////////////////////////////////////////////////////////////////////////////////////////////
// if (m_useMagFieldDcs.value()) {
// // Read Cond Handle (B field sensor)
// SG::ReadCondHandle<CondAttrListCollection> readHandleBFieldSensor{m_readKeyBFieldSensor, ctx};
@@ -174,7 +189,7 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::execute(const EventContext& ctx) cons
// }
// validBField = true;
// }
- // }
+ }
// Combined the validity ranges of temp and HV
EventIDRange rangeW{rangeSCT};
@@ -239,7 +254,7 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::execute(const EventContext& ctx) cons
double mobility{siProperties.signedHallMobility(element->carrierType())};
// Get magnetic field. This first checks that field cache is valid.
- Amg::Vector3D magneticField{getMagneticField(element)};
+ Amg::Vector3D magneticField{getMagneticField(fieldCache, element)};
// The angles are in the hit frame. This is because that is what is needed by the digization and also
// gives a more physical sign of the angle (ie dosen't flip sign when the detector is flipped).
@@ -292,16 +307,18 @@ StatusCode FaserSCT_SiLorentzAngleCondAlg::finalize()
return StatusCode::SUCCESS;
}
-Amg::Vector3D FaserSCT_SiLorentzAngleCondAlg::getMagneticField(const TrackerDD::SiDetectorElement* element) const {
+Amg::Vector3D FaserSCT_SiLorentzAngleCondAlg::getMagneticField(MagField::FaserFieldCache& fieldCache, const TrackerDD::SiDetectorElement* element) const {
if (m_useMagFieldSvc.value()) {
Amg::Vector3D pointvec{element->center()};
- ATH_MSG_VERBOSE("Getting magnetic field from magnetic field service.");
+ ATH_MSG_VERBOSE("Getting magnetic field from MT magnetic field service.");
double point[3];
point[0] = pointvec[0];
point[1] = pointvec[1];
point[2] = pointvec[2];
double field[3];
- m_magFieldSvc->getField(point, field);
+ // m_magFieldSvc->getField(point, field);
+ fieldCache.getField (point, field);
+
return Amg::Vector3D(field[0], field[1], field[2]);
} else {
ATH_MSG_VERBOSE("Using Nominal Field");
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h
index 1fc9c8ee0d9810bec08a8d6ea3b89d715b5e84f2..732af895289fc5709481e5dc80d5cd3f3820da17 100644
--- a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h
@@ -27,11 +27,17 @@
#include "GaudiKernel/SystemOfUnits.h"
#include "GaudiKernel/ToolHandle.h"
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// MagField cache
+#include "MagFieldConditions/FaserFieldCacheCondObj.h"
+#include "MagFieldElements/FaserFieldCache.h"
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
// forward declarations
-// namespace MagField {
-// class IMagFieldSvc;
-// }
-#include "MagFieldInterfaces/IMagFieldSvc.h"
+namespace MagField {
+ class IMagFieldSvc;
+}
+// #include "MagFieldInterfaces/IMagFieldSvc.h"
/**
* @class FaserSCTSiLorentzAngleCondAlg
@@ -77,7 +83,13 @@ class FaserSCT_SiLorentzAngleCondAlg: public AthReentrantAlgorithm
BooleanProperty m_useGeoModel{this, "UseGeoModel", false};
unsigned int m_maxHash;
- Amg::Vector3D getMagneticField(const TrackerDD::SiDetectorElement* element) const;
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ Amg::Vector3D getMagneticField(MagField::FaserFieldCache& fieldCache, const TrackerDD::SiDetectorElement* element) const;
+
+ // Read handle for conditions object to get the field cache
+ SG::ReadCondHandleKey<FaserFieldCacheCondObj> m_fieldCondObjInputKey {this, "FaserFieldCacheCondObj", "fieldCondObj",
+ "Name of the Magnetic Field conditions object key"};
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
};
#endif // FaserSCTSiLorentzAngleCondAlg_h
diff --git a/Tracker/TrackerDetDescr/DipoleGeoModel/python/DipoleGeoModelConfig.py b/Tracker/TrackerDetDescr/DipoleGeoModel/python/DipoleGeoModelConfig.py
index f569ea6b30e62ce795c8f012f468d0d35b6227a1..c45d13a1ecc56a7b0f905964bea65399c89b7e75 100644
--- a/Tracker/TrackerDetDescr/DipoleGeoModel/python/DipoleGeoModelConfig.py
+++ b/Tracker/TrackerDetDescr/DipoleGeoModel/python/DipoleGeoModelConfig.py
@@ -1,12 +1,12 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
+from AthenaConfiguration.ComponentFactory import CompFactory
-def getDipoleTool(name="DipoleTool", **kwargs):
- kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc")
- kwargs.setdefault("GeometryDBSvc", "TrackerGeometryDBSvc")
- kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc")
- return CfgMgr.DipoleTool(name, **kwargs)
+# def getDipoleTool(name="DipoleTool", **kwargs):
+# kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc")
+# kwargs.setdefault("GeometryDBSvc", "TrackerGeometryDBSvc")
+# kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc")
+# return CfgMgr.DipoleTool(name, **kwargs)
def DipoleGeometryCfg( flags ):
@@ -14,16 +14,16 @@ def DipoleGeometryCfg( flags ):
acc = GeoModelCfg( flags )
geoModelSvc=acc.getPrimary()
- from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
+ GeometryDBSvc = CompFactory.GeometryDBSvc
acc.addService(GeometryDBSvc("TrackerGeometryDBSvc"))
- from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
- acc.addService(RDBAccessSvc("RDBAccessSvc"))
+ # from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
+ # acc.addService(RDBAccessSvc("RDBAccessSvc"))
- from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
- acc.addService(DBReplicaSvc("DBReplicaSvc"))
+ # from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
+ # acc.addService(DBReplicaSvc("DBReplicaSvc"))
- from DipoleGeoModel.DipoleGeoModelConf import DipoleTool
+ DipoleTool = CompFactory.DipoleTool
dipoleTool = DipoleTool()
geoModelSvc.DetectorTools += [ dipoleTool ]
diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
index 753fb6ebd3be32e2b47b948f0fad83f9c1565005..0bb74e31f60e015bbe8246dece4c867acf2c2c48 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
@@ -1,32 +1,30 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
from AthenaConfiguration.ComponentFactory import CompFactory
-
-def getFaserSCT_DetectorTool(name="FaserSCT_DetectorTool", **kwargs):
- kwargs.setdefault("DetectorName", "SCT")
- kwargs.setdefault("Alignable", True)
- kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc")
- kwargs.setdefault("GeometryDBSvc", "TrackerGeometryDBSvc")
- kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc")
- return CfgMgr.FaserSCT_DetectorTool(name, **kwargs)
-
-
from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+# def getFaserSCT_DetectorTool(name="FaserSCT_DetectorTool", **kwargs):
+# kwargs.setdefault("DetectorName", "SCT")
+# kwargs.setdefault("Alignable", True)
+# kwargs.setdefault("RDBAccessSvc", "RDBAccessSvc")
+# kwargs.setdefault("GeometryDBSvc", "TrackerGeometryDBSvc")
+# kwargs.setdefault("GeoDbTagSvc", "GeoDbTagSvc")
+# FaserSCT_DetectorTool = CompFactory.FaserSCT_DetectorTool
+# return FaserSCT_DetectorTool(name, **kwargs)
+
def FaserSCT_GeometryCfg( flags ):
from FaserGeoModel.GeoModelConfig import GeoModelCfg
acc = GeoModelCfg( flags )
geoModelSvc=acc.getPrimary()
- from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
+ GeometryDBSvc = CompFactory.GeometryDBSvc
acc.addService(GeometryDBSvc("TrackerGeometryDBSvc"))
- from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
- acc.addService(RDBAccessSvc("RDBAccessSvc"))
+ # from RDBAccessSvc.RDBAccessSvcConf import RDBAccessSvc
+ # acc.addService(RDBAccessSvc("RDBAccessSvc"))
- from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
- acc.addService(DBReplicaSvc("DBReplicaSvc"))
+ # from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
+ # acc.addService(DBReplicaSvc("DBReplicaSvc"))
FaserSCT_DetectorTool = CompFactory.FaserSCT_DetectorTool
sctDetectorTool = FaserSCT_DetectorTool()
@@ -38,13 +36,13 @@ def FaserSCT_GeometryCfg( flags ):
# acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL1/ID","/Indet/AlignL1/ID",className="CondAttrListCollection"))
# acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL2/SCT","/Indet/AlignL2/SCT",className="CondAttrListCollection"))
# acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL3","/Indet/AlignL3",className="AlignableTransformContainer"))
- print "FaserSCT dynamic align flag is not supported!"
+ print("FaserSCT dynamic align flag is not supported!")
else:
if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
acc.merge(addFoldersSplitOnline(flags,"SCT","/Tracker/Onl/Align","/Tracker/Align",className="AlignableTransformContainer"))
# else:
# acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/Align","/Indet/Align"))
- if flags.Common.Project is not "AthSimulation": # Protection for AthSimulation builds
+ if flags.Common.Project != "AthSimulation": # Protection for AthSimulation builds
if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
FaserSCT_AlignCondAlg = CompFactory.FaserSCT_AlignCondAlg
sctAlignCondAlg = FaserSCT_AlignCondAlg(name = "FaserSCT_AlignCondAlg",
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/README.md b/Tracker/TrackerDigitization/FaserSCT_Digitization/README.md
index 46401952478f7bdc43e628223cd69c99c67992e6..a8c064cf8258dc6a5bb6b8a65f492d0845befecd 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/README.md
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/README.md
@@ -12,21 +12,7 @@ This sets up the runtime environment after building. The "." is mandatory.
run > runG4.py >& runG4.log
```
-This will create a HITS file.
-
-```
-run > python python/GeoModelTest/GeoModelTestConfig.py
-```
-
-This will generate a set of neutral alignment data
-
-```
-run > CopyAlignFolder.sh
-```
-
-This will merge the alignment data into the conditions DB.
-
-All the above steps need only be done once after building calypso (but the last two steps must be repeated each time you do `make install`).
+This will create a HITS file named my.HITS.pool.root.
Now you can run digitization on the HITS file you generated with the command:
@@ -34,5 +20,5 @@ Now you can run digitization on the HITS file you generated with the command:
run > FaserSCT_DigitizationDbg.py >& digi.log
```
-This will read your `g4.HITS.root` and generate an RDO data file with digitized raw data objects.
+This will read your `my.HITS.pool.root` and generate an RDO data file 'my.RDO.pool.root' with digitized raw data objects.
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
index a0108cf58b15244f4b59452752dbaa9d9b26122d..75dd5793b1614eceb9f556b4a02598efa1cc011a 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
@@ -5,14 +5,7 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaCommon.Logging import logging
-from FaserSCT_Digitization.FaserSCT_DigitizationConf import (
- FaserSCT_RandomDisabledCellGenerator,
- FaserSCT_Amp,
- FaserSCT_SurfaceChargesGenerator,
- FaserSCT_FrontEnd,
- FaserSCT_DigitizationTool,
- FaserSCT_Digitization
-)
+
PileUpXingFolder=CompFactory.PileUpXingFolder
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
#SCT_RadDamageSummaryTool=CompFactory.SCT_RadDamageSummaryTool
@@ -53,6 +46,7 @@ def FaserSCT_DigitizationCommonCfg(flags, name="FaserSCT_DigitizationToolCommon"
if flags.Digitization.DoXingByXingPileUp:
kwargs.setdefault("FirstXing", FaserSCT_FirstXing())
kwargs.setdefault("LastXing", FaserSCT_LastXing() )
+ FaserSCT_DigitizationTool=CompFactory.FaserSCT_DigitizationTool
tool = FaserSCT_DigitizationTool(name, **kwargs)
# attach ToolHandles
tool.FrontEnd = acc.popToolsAndMerge(FaserSCT_FrontEndCfg(flags))
@@ -122,6 +116,7 @@ def FaserSCT_DigitizationToolGeantinoTruthCfg(flags, name="FaserSCT_GeantinoTrut
def FaserSCT_RandomDisabledCellGeneratorCfg(flags, name="FaserSCT_RandomDisabledCellGenerator", **kwargs):
"""Return configured random cell disabling tool"""
kwargs.setdefault("TotalBadChannels", 0.01)
+ FaserSCT_RandomDisabledCellGenerator=CompFactory.FaserSCT_RandomDisabledCellGenerator
return FaserSCT_RandomDisabledCellGenerator(name, **kwargs)
@@ -133,6 +128,7 @@ def FaserSCT_AmpCfg(flags, name="FaserSCT_Amp", **kwargs):
kwargs.setdefault("deltaT", 1.0)
kwargs.setdefault("Tmin", -25.0)
kwargs.setdefault("Tmax", 150.0)
+ FaserSCT_Amp=CompFactory.FaserSCT_Amp
return FaserSCT_Amp(name, **kwargs)
@@ -149,8 +145,8 @@ def FaserSCT_SurfaceChargesGeneratorCfg(flags, name="FaserSCT_SurfaceChargesGene
kwargs.setdefault("isOverlay", flags.Detector.Overlay)
# kwargs.setdefault("doTrapping", True) # ATL-INDET-INT-2016-019
# experimental SCT_DetailedSurfaceChargesGenerator config dropped here
+ FaserSCT_SurfaceChargesGenerator=CompFactory.FaserSCT_SurfaceChargesGenerator
tool = FaserSCT_SurfaceChargesGenerator(name, **kwargs)
- #tool.RadDamageSummaryTool = SCT_RadDamageSummaryTool()
DCSCondTool = acc.popToolsAndMerge(FaserSCT_DCSConditionsCfg(flags))
SiliCondTool = FaserSCT_SiliconConditionsToolCfg(flags)
SiliCondAcc = FaserSCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSCondTool)
@@ -211,6 +207,7 @@ def FaserSCT_FrontEndCfg(flags, name="FaserSCT_FrontEnd", **kwargs):
kwargs.setdefault("DataReadOutMode", 0)
else:
kwargs.setdefault("DataReadOutMode", 1)
+ FaserSCT_FrontEnd=CompFactory.FaserSCT_FrontEnd
acc.setPrivateTools(FaserSCT_FrontEnd(name, **kwargs))
return acc
@@ -238,6 +235,7 @@ def FaserSCT_RangeCfg(flags, name="SiliconRange", **kwargs):
kwargs.setdefault("LastXing", FaserSCT_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0) # default 0 no dataproxy reset
kwargs.setdefault("ItemList", ["FaserSiHitCollection#SCT_Hits"] )
+ PileUpXingFolder=CompFactory.PileUpXingFolder
return PileUpXingFolder(name, **kwargs)
@@ -249,6 +247,8 @@ def FaserSCT_OutputCfg(flags):
ItemList += ["TrackerSimDataCollection#*"]
acc.merge(TruthDigitizationOutputCfg(flags))
acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
+ ostream = acc.getEventAlgo("OutputStreamRDO")
+ ostream.TakeItemsFromInput = True
return acc
@@ -268,6 +268,7 @@ def FaserSCT_OverlayDigitizationBasicCfg(flags, **kwargs):
if "DigitizationTool" not in kwargs:
tool = acc.popToolsAndMerge(FaserSCT_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
+ FaserSCT_Digitization=CompFactory.FaserSCT_Digitization
acc.addEventAlgo(FaserSCT_Digitization(**kwargs))
return acc
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
index 507e3bbd08e3e9ff67bff0cbc6ea9fbf33085397..eafe8ba77abcdbddfa4a48b7663f39faa46df55b 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
@@ -27,5 +27,5 @@ StatusCode FaserSCT_Digitization::initialize() {
StatusCode FaserSCT_Digitization::execute() {
ATH_MSG_DEBUG("execute()");
- return m_sctDigitizationTool->processAllSubEvents();
+ return m_sctDigitizationTool->processAllSubEvents(Gaudi::Hive::currentContext());
}
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
index 41e5d7ef6b5f9ecdad576a78f6d8c44e287ffc78..67cc2ceb8d454f5b0a10bf96e96421b08682d057 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
@@ -185,18 +185,18 @@ StatusCode FaserSCT_DigitizationTool::initDisabledCells() {
return StatusCode::SUCCESS;
}
-StatusCode FaserSCT_DigitizationTool::processAllSubEvents() {
- if (prepareEvent(0).isFailure()) {
+StatusCode FaserSCT_DigitizationTool::processAllSubEvents(const EventContext& ctx) {
+ if (prepareEvent(ctx, 0).isFailure()) {
return StatusCode::FAILURE;
}
// Set the RNG to use for this event.
ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
- rngWrapper->setSeed( name(), Gaudi::Hive::currentContext() );
- CLHEP::HepRandomEngine *rndmEngine = *rngWrapper;
+ rngWrapper->setSeed( name(), ctx );
+ CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
ATH_MSG_VERBOSE("Begin digitizeAllHits");
- if (m_enableHits and (not getNextEvent().isFailure())) {
- digitizeAllHits(&m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi, rndmEngine);
+ if (m_enableHits and (not getNextEvent(ctx).isFailure())) {
+ digitizeAllHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi, rndmEngine);
} else {
ATH_MSG_DEBUG("no hits found in event!");
}
@@ -204,7 +204,7 @@ StatusCode FaserSCT_DigitizationTool::processAllSubEvents() {
// loop over elements without hits
if (not m_onlyHitElements) {
- digitizeNonHits(&m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
+ digitizeNonHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
ATH_MSG_DEBUG("Digitized Elements without Hits");
}
@@ -218,15 +218,15 @@ StatusCode FaserSCT_DigitizationTool::processAllSubEvents() {
// ======================================================================
// prepareEvent
// ======================================================================
-StatusCode FaserSCT_DigitizationTool::prepareEvent(unsigned int /*index*/) {
+StatusCode FaserSCT_DigitizationTool::prepareEvent(const EventContext& ctx, unsigned int /*index*/) {
ATH_MSG_VERBOSE("FaserSCT_DigitizationTool::prepareEvent()");
// Create the IdentifiableContainer to contain the digit collections Create
// a new RDO container
- m_rdoContainer = SG::makeHandle(m_rdoContainerKey);
+ m_rdoContainer = SG::makeHandle(m_rdoContainerKey, ctx);
ATH_CHECK(m_rdoContainer.record(std::make_unique<FaserSCT_RDO_Container>(m_detID->wafer_hash_max())));
// Create a map for the SDO and register it into StoreGate
- m_simDataCollMap = SG::makeHandle(m_simDataCollMapKey);
+ m_simDataCollMap = SG::makeHandle(m_simDataCollMapKey, ctx);
ATH_CHECK(m_simDataCollMap.record(std::make_unique<TrackerSimDataCollection>()));
m_processedElements.clear();
@@ -240,20 +240,20 @@ StatusCode FaserSCT_DigitizationTool::prepareEvent(unsigned int /*index*/) {
// =========================================================================
// mergeEvent
// =========================================================================
-StatusCode FaserSCT_DigitizationTool::mergeEvent() {
+StatusCode FaserSCT_DigitizationTool::mergeEvent(const EventContext& ctx) {
ATH_MSG_VERBOSE("FaserSCT_DigitizationTool::mergeEvent()");
// Set the RNG to use for this event.
ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
- rngWrapper->setSeed( name(), Gaudi::Hive::currentContext() );
- CLHEP::HepRandomEngine *rndmEngine = *rngWrapper;
+ rngWrapper->setSeed( name(), ctx );
+ CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
if (m_enableHits) {
- digitizeAllHits(&m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi, rndmEngine);
+ digitizeAllHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi, rndmEngine);
}
if (not m_onlyHitElements) {
- digitizeNonHits(&m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
+ digitizeNonHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
}
for (FaserSiHitCollection* hit: m_hitCollPtrs) {
@@ -269,7 +269,7 @@ StatusCode FaserSCT_DigitizationTool::mergeEvent() {
return StatusCode::SUCCESS;
}
-void FaserSCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_DigitizationTool::digitizeAllHits(const EventContext& ctx, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
/////////////////////////////////////////////////
//
// In order to process all element rather than just those with hits we
@@ -282,7 +282,7 @@ void FaserSCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Con
SiChargedDiodeCollection chargedDiodes;
- while (digitizeElement(&chargedDiodes, thpcsi, rndmEngine)) {
+ while (digitizeElement(ctx, &chargedDiodes, thpcsi, rndmEngine)) {
ATH_MSG_DEBUG("Hit collection ID=" << m_detID->show_to_string(chargedDiodes.identify()));
hitcount++; // Hitcount will be a number in the hit collection minus
@@ -320,9 +320,9 @@ void FaserSCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Con
}
// digitize elements without hits
-void FaserSCT_DigitizationTool::digitizeNonHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_DigitizationTool::digitizeNonHits(const EventContext& ctx, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const {
// Get SCT_DetectorElementCollection
- SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey);
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
const TrackerDD::SiDetectorElementCollection* elements{sctDetEle.retrieve()};
if (elements==nullptr) {
ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
@@ -369,7 +369,7 @@ void FaserSCT_DigitizationTool::digitizeNonHits(SG::WriteHandle<FaserSCT_RDO_Con
return;
}
-bool FaserSCT_DigitizationTool::digitizeElement(SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
+bool FaserSCT_DigitizationTool::digitizeElement(const EventContext& ctx, SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
if (nullptr == thpcsi) {
ATH_MSG_ERROR("thpcsi should not be nullptr!");
@@ -395,7 +395,7 @@ bool FaserSCT_DigitizationTool::digitizeElement(SiChargedDiodeCollection* charge
IdentifierHash waferHash{m_detID->wafer_hash(id)};
// Get SCT_DetectorElementCollection
- SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey);
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
const TrackerDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
if (elements==nullptr) {
ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
@@ -684,7 +684,7 @@ FaserSCT_RDO_Collection* FaserSCT_DigitizationTool::createRDO(SiChargedDiodeColl
// ------------------------------------------------------------
// Get next event and extract collection of hit collections:
// ------------------------------------------------------------
-StatusCode FaserSCT_DigitizationTool::getNextEvent() {
+StatusCode FaserSCT_DigitizationTool::getNextEvent(const EventContext& ctx) {
ATH_MSG_DEBUG("FaserSCT_DigitizationTool::getNextEvent()");
// get the container(s)
typedef PileUpMergeSvc::TimedList<FaserSiHitCollection>::type TimedHitCollList;
@@ -692,7 +692,7 @@ StatusCode FaserSCT_DigitizationTool::getNextEvent() {
// In case of single hits container just load the collection using read handles
if (!m_onlyUseContainerName) {
- SG::ReadHandle<FaserSiHitCollection> hitCollection(m_hitsContainerKey);
+ SG::ReadHandle<FaserSiHitCollection> hitCollection(m_hitsContainerKey, ctx);
if (!hitCollection.isValid()) {
ATH_MSG_ERROR("Could not get SCT SiHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
return StatusCode::FAILURE;
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
index b96a8c21efb42a21bc4d65e7dd6bcf186b184ba7..1aa62a313d57840b16ac5e60dd9e389d09e4dc61 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
@@ -60,18 +60,18 @@ public:
/**
@brief Called before processing physics events
*/
- virtual StatusCode prepareEvent(unsigned int) override final;
+ virtual StatusCode prepareEvent(const EventContext& ctx, unsigned int) override final;
virtual StatusCode processBunchXing(int bunchXing,
SubEventIterator bSubEvents,
SubEventIterator eSubEvents) override final;
- virtual StatusCode mergeEvent() override final;
+ virtual StatusCode mergeEvent(const EventContext& ctx) override final;
virtual StatusCode initialize() override final;
- virtual StatusCode processAllSubEvents() override final;
+ virtual StatusCode processAllSubEvents(const EventContext& ctx) override final;
protected:
- bool digitizeElement(SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const ; //!
+ bool digitizeElement(const EventContext& ctx, SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const ; //!
void applyProcessorTools(SiChargedDiodeCollection* chargedDiodes, CLHEP::HepRandomEngine * rndmEngine) const; //!
void addSDO(SiChargedDiodeCollection* collection, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap) const;
@@ -108,9 +108,9 @@ private:
*/
FaserSCT_RDO_Collection* createRDO(SiChargedDiodeCollection* collection) const;
- StatusCode getNextEvent();
- void digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize all hits
- void digitizeNonHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize SCT without hits
+ StatusCode getNextEvent(const EventContext& ctx);
+ void digitizeAllHits(const EventContext& ctx, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize all hits
+ void digitizeNonHits(const EventContext& ctx, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize SCT without hits
/**
@brief Called when m_WriteSCT1_RawData is altered. Does nothing, but required by Gaudi.
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
index 00b2e80da08fafa45891ff11d18d056ebf9e1710..ad9d5c8c34eaa38c5de4a5aeb6b8fc4df79ed7f4 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
@@ -22,8 +22,8 @@ log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
# Configure
-ConfigFlags.Input.Files = ['g4.HITS.root']
-ConfigFlags.Output.RDOFileName = "myRDO.pool.root"
+ConfigFlags.Input.Files = ['my.HITS.pool.root']
+ConfigFlags.Output.RDOFileName = "my.RDO.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
@@ -47,23 +47,19 @@ acc.merge(PoolWriteCfg(ConfigFlags))
# Inner Detector
acc.merge(FaserSCT_DigitizationCfg(ConfigFlags))
-# Output Stream customization
-oStream = acc.getEventAlgo("OutputStreamRDO")
-oStream.TakeItemsFromInput = True
-
# Timing
#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
# Dump config
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
-acc.foreach_component("*ClassID*").OutputLevel = INFO
-acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
-acc.getService("StoreGateSvc").Dump = True
-acc.getService("ConditionStore").Dump = True
-acc.printConfig(withDetails=True)
-ConfigFlags.dump()
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+# acc.foreach_component("*").OutputLevel = VERBOSE
+# acc.foreach_component("*ClassID*").OutputLevel = INFO
+# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
# Execute and finish
sc = acc.run(maxEvents=-1)
# Success should be 0
diff --git a/Tracker/TrackerG4/FaserSCT_G4_SD/CMakeLists.txt b/Tracker/TrackerG4/FaserSCT_G4_SD/CMakeLists.txt
index c9334be672207d144438dfde72459c832903482f..c9d3d373378fd7c570c7d373da306abaaf35989b 100644
--- a/Tracker/TrackerG4/FaserSCT_G4_SD/CMakeLists.txt
+++ b/Tracker/TrackerG4/FaserSCT_G4_SD/CMakeLists.txt
@@ -27,7 +27,7 @@ atlas_add_component( FaserSCT_G4_SD
LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel TrackerSimEvent G4AtlasToolsLib FaserMCTruth )
atlas_add_test( FaserSCT_G4_SDToolConfig_test
- SCRIPT test/FaserSCT_G4_SDToolConfig_test.py
+ SCRIPT python ${CMAKE_CURRENT_SOURCE_DIR}/test/FaserSCT_G4_SDToolConfig_test.py
PROPERTIES TIMEOUT 300 )
# Install files from the package:
diff --git a/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDConfig.py b/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDConfig.py
index 57f860eb09e03351e8a362c17ed81a132742ec5c..308e6e5b7a5741f885c9ebe3cc29e8d8f5eb6c74 100644
--- a/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDConfig.py
+++ b/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDConfig.py
@@ -1,19 +1,22 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon import CfgMgr
-from G4AtlasApps.SimFlags import simFlags
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-from ISF_Algorithms.collection_merger_helpers import generate_mergeable_collection_name
+FaserSctSensorSDTool=CompFactory.FaserSctSensorSDTool
+def getSctSensorSD(ConfigFlags, name="SctSensorSD", **kwargs):
-def getSctSensorSD(name="SctSensorSD", **kwargs):
+ result = ComponentAccumulator()
bare_collection_name = "SCT_Hits"
mergeable_collection_suffix = "_G4"
- merger_input_property = "SCTHits"
- hits_collection_name = generate_mergeable_collection_name(bare_collection_name,
- mergeable_collection_suffix,
- merger_input_property)
+ merger_input_property = "SCT_Hits"
+
+ acc, hits_collection_name = CollectionMergerCfg(ConfigFlags, bare_collection_name, mergeable_collection_suffix, merger_input_property)
kwargs.setdefault("LogicalVolumeNames", ["SCT::BRLSensor"])
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
- return CfgMgr.FaserSctSensorSDTool(name, **kwargs)
+
+ result.merge(acc)
+ return result, FaserSctSensorSDTool(name, **kwargs)
diff --git a/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDToolConfig.py b/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDToolConfig.py
index 46002551def5d67f776966b149255403ed2e299b..4c9f7576f93399a316b3aa9aa9e977a6de081709 100644
--- a/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDToolConfig.py
+++ b/Tracker/TrackerG4/FaserSCT_G4_SD/python/FaserSCT_G4_SDToolConfig.py
@@ -1,9 +1,10 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
from ISF_Algorithms.collection_merger_helpersNew import CollectionMergerCfg
-from FaserSCT_G4_SD.FaserSCT_G4_SDConfig import getSctSensorSD
+FaserSctSensorSDTool=CompFactory.FaserSctSensorSDTool
def SctSensorSDCfg(ConfigFlags, name="SctSensorSD", **kwargs):
@@ -17,4 +18,4 @@ def SctSensorSDCfg(ConfigFlags, name="SctSensorSD", **kwargs):
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
result.merge(acc)
- return result, getSctSensorSD(name, **kwargs)
+ return result, FaserSctSensorSDTool(name, **kwargs)
diff --git a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/python/TrackerPrepRawDataFormationConfig.py b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/python/TrackerPrepRawDataFormationConfig.py
index fa451680033df679d9d53ea9610344d6c88d84d4..a4051d50a5baadd3ccdbaa9cd5d0efcdb336ed30 100644
--- a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/python/TrackerPrepRawDataFormationConfig.py
+++ b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/python/TrackerPrepRawDataFormationConfig.py
@@ -4,16 +4,11 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
-from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConf import Tracker__FaserSCT_Clusterization
-#from FaserSCT_ClusteringTool.FaserSCT_ClusteringToolConf import FaserSCT_ClusteringTool
PileUpXingFolder=CompFactory.PileUpXingFolder
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
-#SCT_RadDamageSummaryTool=CompFactory.SCT_RadDamageSummaryTool
from FaserGeoModel.SCTGMConfig import SctGeometryCfg
-#from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsCfg
-#from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsToolCfg
from FaserSiLorentzAngleTool.FaserSCT_LorentzAngleConfig import FaserSCT_LorentzAngleCfg
@@ -22,15 +17,14 @@ def FaserSCT_ClusterizationCommonCfg(flags, name="FaserSCT_ClusterizationToolCom
acc = SctGeometryCfg(flags)
kwargs.setdefault("InputObjectName", "SCT_RDOs")
- #kwargs.setdefault("BarrelOnly", False)
- from FaserSiClusterizationTool.FaserSiClusterizationToolConf import Tracker__TrackerClusterMakerTool, Tracker__FaserSCT_ClusteringTool
+ Tracker__TrackerClusterMakerTool,Tracker__FaserSCT_ClusteringTool=CompFactory.getComps("Tracker::TrackerClusterMakerTool", "Tracker::FaserSCT_ClusteringTool")
trackerClusterMakerTool = Tracker__TrackerClusterMakerTool(name = "TrackerClusterMakerTool")
faserSCT_LorentzAngleTool=acc.popToolsAndMerge(FaserSCT_LorentzAngleCfg(flags))
clusteringTool = Tracker__FaserSCT_ClusteringTool(name, globalPosAlg = trackerClusterMakerTool, FaserSiLorentzAngleTool=faserSCT_LorentzAngleTool)
clusteringTool.timeBins = "01X"
# attach ToolHandles
acc.setPrivateTools(clusteringTool)
- return acc
+ return acc
def FaserSCT_ClusterizationToolCfg(flags, name="FaserSCT_ClusterizationTool", **kwargs):
@@ -46,7 +40,8 @@ def FaserSCT_ClusterizationBasicCfg(flags, **kwargs):
kwargs.setdefault("SCT_ClusteringTool", clusterTool)
kwargs.setdefault("DataObjectName", "SCT_RDOs")
kwargs.setdefault("ClustersName", "SCT_ClusterContainer")
- kwargs.setdefault("SCT_FlaggedCondData", "SCT_Flags");
+ kwargs.setdefault("SCT_FlaggedCondData", "SCT_Flags")
+ Tracker__FaserSCT_Clusterization=CompFactory.Tracker.FaserSCT_Clusterization
acc.addEventAlgo(Tracker__FaserSCT_Clusterization(**kwargs))
return acc
@@ -54,9 +49,9 @@ def FaserSCT_OutputCfg(flags):
"""Return ComponentAccumulator with Output for SCT. Not standalone."""
acc = ComponentAccumulator()
ItemList = ["Tracker::FaserSCT_ClusterContainer#*"]
- acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
- ostream = acc.getEventAlgo("OutputStreamRDO")
- ostream.TakeItemsFromInput=True
+ acc.merge(OutputStreamCfg(flags, "ESD", ItemList))
+ ostream = acc.getEventAlgo("OutputStreamESD")
+ ostream.TakeItemsFromInput = True
return acc
diff --git a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/test/FaserSCT_ClusterizationDbg.py b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/test/FaserSCT_ClusterizationDbg.py
index 53d79d195e168ddc2860b0279805d0d7f3ead22e..0cec89191af71e980f5109f60577fc9d1c323c7b 100644
--- a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/test/FaserSCT_ClusterizationDbg.py
+++ b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/test/FaserSCT_ClusterizationDbg.py
@@ -22,13 +22,12 @@ log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
# Configure
-ConfigFlags.Input.Files = ['myRDO.pool.root']
-ConfigFlags.Output.RDOFileName = "myRDO_cluster.pool.root"
+ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ConfigFlags.Output.ESDFileName = "myClusters.ESD.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
-#ConfigFlags.Detector.SimulateFaserSCT = True
ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig; value ignored
@@ -44,29 +43,23 @@ acc.merge(PoolWriteCfg(ConfigFlags))
# Inner Detector
acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
-
-# Output Stream customization
-# oStream = acc.getEventAlgo("OutputStreamRDO")
-# oStream.ItemList += ["EventInfo#*",
-# "McEventCollection#TruthEvent",
-# "McEventCollection#GEN_EVENT",
-# "Tracker::FaserSCT_ClusterContainer#*"
-# ]
-
+
# Timing
#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
# Dump config
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
-acc.foreach_component("*ClassID*").OutputLevel = INFO
-acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
-acc.getService("StoreGateSvc").Dump = True
-acc.getService("ConditionStore").Dump = True
-acc.printConfig(withDetails=True)
-ConfigFlags.dump()
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+# acc.foreach_component("*").OutputLevel = VERBOSE
+# acc.foreach_component("*ClassID*").OutputLevel = INFO
+# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
+
# Execute and finish
sc = acc.run(maxEvents=-1)
+
# Success should be 0
sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
index 014ff6e2851b32acadff54a01f39e5f8bd4093a0..9760e36277f013aa6f0ef6eb03ecfbcee3f1635e 100644
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
@@ -4,27 +4,14 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
-from TrackerSpacePointFormation.TrackerSpacePointFormationConf import Tracker__TrackerSpacePointFinder, Tracker__StatisticsAlg, TrackerDD__SiElementPropertiesTableCondAlg
-PileUpXingFolder=CompFactory.PileUpXingFolder
+PileUpXingFolder, Tracker__TrackerSpacePointFinder, Tracker__StatisticsAlg, TrackerDD__SiElementPropertiesTableCondAlg, Tracker__TrackerSpacePointMakerTool = CompFactory.getComps("PileUpXingFolder", "Tracker::TrackerSpacePointFinder", "Tracker::StatisticsAlg", "TrackerDD::SiElementPropertiesTableCondAlg", "Tracker::TrackerSpacePointMakerTool")
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
-#SCT_RadDamageSummaryTool=CompFactory.SCT_RadDamageSummaryTool
from FaserGeoModel.SCTGMConfig import SctGeometryCfg
-#from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsCfg
-#from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsToolCfg
-from AthenaCommon.AlgSequence import AthSequencer
-condSeq = AthSequencer("AthCondSeq")
-condSeq += TrackerDD__SiElementPropertiesTableCondAlg(name = "SiElementPropertiesTableCondAlg")
-from GaudiSvc.GaudiSvcConf import THistSvc
-histSvc= THistSvc()
-histSvc.Output += [ "StatisticsAlg DATAFILE='statistics.root' OPT='RECREATE'" ]
-
-
-
def TrackerDDSiElementPropertiesTableCondAlgCfg(flags, **kwargs):
acc = ComponentAccumulator()
- acc.addCondAlgo(CompFactory.TrackerDD__SiElementPropertiesTableCondAlg(name = "TrackerDDSiElementPropertiesTableCondAlg", **kwargs))
+ acc.addCondAlgo(TrackerDD__SiElementPropertiesTableCondAlg(name = "TrackerDDSiElementPropertiesTableCondAlg", **kwargs))
return acc
@@ -33,8 +20,6 @@ def TrackerSpacePointMakerCommonCfg(flags, name="TrackerSpacePointMakerTool", **
acc = SctGeometryCfg(flags)
kwargs.setdefault("InputObjectName", "SCT_ClusterContainer")
- from FaserSiSpacePointTool.FaserSiSpacePointToolConf import Tracker__TrackerSpacePointMakerTool
-# fieldSvc = acc.getService("FaserFieldSvc")
trackerSpacePointMakerTool = Tracker__TrackerSpacePointMakerTool(name)
# attach ToolHandles
acc.setPrivateTools(trackerSpacePointMakerTool)
@@ -70,11 +55,9 @@ def StatisticsBasicCfg(flags, **kwargs):
def TrackerSpacePointFinder_OutputCfg(flags):
"""Return ComponentAccumulator with Output for SCT. Not standalone."""
acc = ComponentAccumulator()
- # ItemList = ["SpacePointContainer#*"]
- ItemList = [""]
- acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
- ostream = acc.getEventAlgo("OutputStreamRDO")
- ostream.TakeItemsFromInput=True
+ acc.merge(OutputStreamCfg(flags, "ESD"))
+ ostream = acc.getEventAlgo("OutputStreamESD")
+ ostream.TakeItemsFromInput = True
return acc
# with output defaults
@@ -86,8 +69,10 @@ def TrackerSpacePointFinderCfg(flags, **kwargs):
return acc
def StatisticsCfg(flags, **kwargs):
- #acc=ComponentAccumulator(flags)
acc=StatisticsBasicCfg(flags, **kwargs)
+ THistSvc=CompFactory.THistSvc
+ histSvc= THistSvc()
+ histSvc.Output += [ "StatisticsAlg DATAFILE='statistics.root' OPT='RECREATE'" ]
acc.addService(histSvc)
acc.merge(TrackerSpacePointFinder_OutputCfg(flags))
return acc
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
index 37db71adedb02ef02b6eee58a372c45a58a47b23..bf8b17d4fc16103c45cb0256bd3d7c644a3afc9e 100755
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
@@ -40,11 +40,11 @@ StatisticsAlg::StatisticsAlg(const std::string& name,
, m_hist_y(0)
, m_hist_z(0)
, m_hist_r(0)
- , m_hist_phi(0)
, m_hist_eta(0)
- , m_hist_layer(0)
- , m_hist_strip(0)
+ , m_hist_phi(0)
, m_hist_station(0)
+ , m_hist_strip(0)
+ , m_hist_layer(0)
, m_hist_x_y_plane0(0)
, m_hist_x_y_plane1(0)
, m_hist_x_y_plane2(0)
@@ -152,10 +152,10 @@ StatusCode StatisticsAlg::execute (const EventContext& ctx) const
for (; it != itend; ++it){
const SpacePointCollection *colNext=&(**it);
- int nReceivedSPSCT = colNext->size();
+ // int nReceivedSPSCT = colNext->size();
// Create SpacePointCollection
- IdentifierHash idHash = colNext->identifyHash();
+ // IdentifierHash idHash = colNext->identifyHash();
Identifier elementID = colNext->identify();
int istation = m_idHelper->station(elementID);
int ilayer = m_idHelper->layer(elementID);
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
index 738a0b50939ecefc4ec3f4b91ab5623c6082fee6..2310699cd43d759ecf026c8ddc7159bcf4de694f 100644
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
@@ -23,13 +23,12 @@ log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
# Configure
-ConfigFlags.Input.Files = ['myRDO.pool.root']
-ConfigFlags.Output.RDOFileName = "myRDO_sp.pool.root"
+ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ConfigFlags.Output.ESDFileName = "mySpacePoints.ESD.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
-#ConfigFlags.Detector.SimulateFaserSCT = True
ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig; value ignored
@@ -47,30 +46,23 @@ acc.merge(PoolWriteCfg(ConfigFlags))
acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
acc.merge(StatisticsCfg(ConfigFlags))
-
-# Output Stream customization
-oStream = acc.getEventAlgo("OutputStreamRDO")
-oStream.TakeItemsFromInput = True
-# oStream.ItemList += ["EventInfo#*",
-# "McEventCollection#TruthEvent",
-# "McEventCollection#GEN_EVENT",
-# "FaserSCT_ClusterCollection#*"
-# ]
-
+
# Timing
#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
# Dump config
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
-acc.foreach_component("*ClassID*").OutputLevel = INFO
-acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
-acc.getService("StoreGateSvc").Dump = True
-acc.getService("ConditionStore").Dump = True
-acc.printConfig(withDetails=True)
-ConfigFlags.dump()
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+# acc.foreach_component("*").OutputLevel = VERBOSE
+# acc.foreach_component("*ClassID*").OutputLevel = INFO
+# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
+
# Execute and finish
sc = acc.run(maxEvents=-1)
+
# Success should be 0
sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/TrackerSpacePointFormationDbg.py b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/TrackerSpacePointFormationDbg.py
index d9ac5ceae2f221fd57e7f528f046da3cd4f85e9b..469f2308694d1bb6082bc5bb0822e976a742c667 100644
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/TrackerSpacePointFormationDbg.py
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/TrackerSpacePointFormationDbg.py
@@ -23,13 +23,12 @@ log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
# Configure
-ConfigFlags.Input.Files = ['myRDO.pool.root']
-ConfigFlags.Output.RDOFileName = "myRDO_sp.pool.root"
+ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ConfigFlags.Output.ESDFileName = "mySpacePoints.ESD.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
-#ConfigFlags.Detector.SimulateFaserSCT = True
ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig; value ignored
@@ -46,30 +45,22 @@ acc.merge(PoolWriteCfg(ConfigFlags))
# Inner Detector
acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
-
-# Output Stream customization
-oStream = acc.getEventAlgo("OutputStreamRDO")
-oStream.TakeItemsFromInput = True
-# oStream.ItemList += ["EventInfo#*",
-# "McEventCollection#TruthEvent",
-# "McEventCollection#GEN_EVENT",
-# "FaserSCT_ClusterContainer#*"
-# ]
-
+
# Timing
#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
# Dump config
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
-acc.foreach_component("*ClassID*").OutputLevel = INFO
-acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
-acc.getService("StoreGateSvc").Dump = True
-acc.getService("ConditionStore").Dump = True
-acc.printConfig(withDetails=True)
-ConfigFlags.dump()
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+# acc.foreach_component("*").OutputLevel = VERBOSE
+# acc.foreach_component("*ClassID*").OutputLevel = INFO
+# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
+
# Execute and finish
-sc = acc.run(maxEvents=1000)
+sc = acc.run(maxEvents=-1)
# Success should be 0
sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/python/TruthSeededTrackFinderConfig.py b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/python/TruthSeededTrackFinderConfig.py
index ab1eb199758151b6c79a5e503ff3c535e096602d..671f16ffd7cc43b38dcb1ed1f35bf3cb0d0da685 100644
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/python/TruthSeededTrackFinderConfig.py
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/python/TruthSeededTrackFinderConfig.py
@@ -4,13 +4,9 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
-from TruthSeededTrackFinder.TruthSeededTrackFinderConf import Tracker__TruthSeededTrackFinder
-PileUpXingFolder=CompFactory.PileUpXingFolder
+Tracker__TruthSeededTrackFinder, THistSvc=CompFactory.getComps("Tracker::TruthSeededTrackFinder", "THistSvc")
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
-from GaudiSvc.GaudiSvcConf import THistSvc
-histSvc= THistSvc()
-histSvc.Output += [ "TruthTrackSeeds DATAFILE='truthtrackseeds.root' OPT='RECREATE'" ]
def TruthSeededTrackFinderBasicCfg(flags, **kwargs):
@@ -24,13 +20,15 @@ def TruthSeededTrackFinderBasicCfg(flags, **kwargs):
def TruthSeededTrackFinder_OutputCfg(flags):
"""Return ComponentAccumulator with Output for SCT. Not standalone."""
acc = ComponentAccumulator()
- #ItemList = ["FaserSCT_ClusterContainer#*"]
- acc.merge(OutputStreamCfg(flags, "RDO"))
+ acc.merge(OutputStreamCfg(flags, "ESD"))
+ ostream = acc.getEventAlgo("OutputStreamESD")
+ ostream.TakeItemsFromInput = True
return acc
def TruthSeededTrackFinderCfg(flags, **kwargs):
- #acc=ComponentAccumulator(flags)
acc=TruthSeededTrackFinderBasicCfg(flags, **kwargs)
+ histSvc= THistSvc()
+ histSvc.Output += [ "TruthTrackSeeds DATAFILE='truthtrackseeds.root' OPT='RECREATE'" ]
acc.addService(histSvc)
acc.merge(TruthSeededTrackFinder_OutputCfg(flags))
return acc
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
index 49ef727fb7568300f16c48b33570bdf997ea3b4c..7c63367f8b313f2c4b6615cb016c3d45fbd847a7 100755
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
@@ -58,6 +58,13 @@ TruthSeededTrackFinder::TruthSeededTrackFinder(const std::string& name,
, m_hist_x_y_plane8(0)
, m_hist_x_z(0)
, m_hist_y_z(0)
+ , m_hist_sp_sensor(0)
+ , m_hist_sp_module (0)
+ , m_hist_sp_row (0)
+ , m_hist_sp_plane (0)
+ , m_hist_sp_layer (0)
+ , m_hist_sp_station (0)
+
, m_thistSvc("THistSvc", name)
{
}
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
index db32348e96d4245fc8f240e538832d1d33e42ff4..f115049cff7c963a43d3150faaa45c17819b74aa 100755
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
@@ -82,24 +82,16 @@ class TruthSeededTrackFinder:public AthReentrantAlgorithm {
mutable std::atomic<int> m_numberOfHits{0};
mutable std::atomic<int> m_numberOfMatchSP{0};
mutable std::atomic<int> m_numberOfFills{0};
- TH1* m_hist_x;
TH1* m_hist_n;
+ TH1* m_hist_x;
TH1* m_hist_y;
TH1* m_hist_z;
TH1* m_hist_r;
- TH1* m_hist_eta;
TH1* m_hist_phi;
- TH1* m_hist_sp_station;
- TH1* m_hist_sp_layer;
- TH1* m_hist_sp_plane;
- TH1* m_hist_sp_row;
- TH1* m_hist_sp_module;
- TH1* m_hist_sp_sensor;
- TH1* m_hist_station;
- TH1* m_hist_strip;
+ TH1* m_hist_eta;
TH1* m_hist_layer;
- TH2* m_hist_x_z;
- TH2* m_hist_y_z;
+ TH1* m_hist_strip;
+ TH1* m_hist_station;
TH2* m_hist_x_y_plane0;
TH2* m_hist_x_y_plane1;
TH2* m_hist_x_y_plane2;
@@ -109,6 +101,14 @@ class TruthSeededTrackFinder:public AthReentrantAlgorithm {
TH2* m_hist_x_y_plane6;
TH2* m_hist_x_y_plane7;
TH2* m_hist_x_y_plane8;
+ TH2* m_hist_x_z;
+ TH2* m_hist_y_z;
+ TH1* m_hist_sp_sensor;
+ TH1* m_hist_sp_module;
+ TH1* m_hist_sp_row;
+ TH1* m_hist_sp_plane;
+ TH1* m_hist_sp_layer;
+ TH1* m_hist_sp_station;
ServiceHandle<ITHistSvc> m_thistSvc;
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/test/TruthSeededTrackFinderDbg.py b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/test/TruthSeededTrackFinderDbg.py
index cf5c7cdc06a8729500ced233cce6f16ae6699e86..0acc887c5a02a95625706d6fc2c4235f188fa356 100644
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/test/TruthSeededTrackFinderDbg.py
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/test/TruthSeededTrackFinderDbg.py
@@ -24,13 +24,12 @@ log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
# Configure
-ConfigFlags.Input.Files = ['myRDO.pool.root']
-ConfigFlags.Output.RDOFileName = "myRDO_seeds.pool.root"
+ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ConfigFlags.Output.ESDFileName = "mySeeds.ESD.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
-#ConfigFlags.Detector.SimulateFaserSCT = True
ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig; value ignored
@@ -42,7 +41,6 @@ acc = MainServicesSerialCfg()
acc.merge(PoolReadCfg(ConfigFlags))
acc.merge(PoolWriteCfg(ConfigFlags))
-
#acc.merge(writeDigitizationMetadata(ConfigFlags))
# Inner Detector
@@ -54,16 +52,18 @@ acc.merge(TruthSeededTrackFinderCfg(ConfigFlags))
#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
# Dump config
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
-acc.foreach_component("*ClassID*").OutputLevel = INFO
-acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
-acc.getService("StoreGateSvc").Dump = True
-acc.getService("ConditionStore").Dump = True
-acc.printConfig(withDetails=True)
-ConfigFlags.dump()
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+# acc.foreach_component("*").OutputLevel = VERBOSE
+# acc.foreach_component("*ClassID*").OutputLevel = INFO
+# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
+
# Execute and finish
sc = acc.run(maxEvents=-1)
+
# Success should be 0
sys.exit(not sc.isSuccess())
diff --git a/asetup.faser b/asetup.faser
new file mode 100644
index 0000000000000000000000000000000000000000..e623dfb08e8abd20f8c4ae0fa6d32b16b85333d1
--- /dev/null
+++ b/asetup.faser
@@ -0,0 +1,8 @@
+[defaults]
+
+dbarea = /cvmfs/faser.cern.ch/repo/sw/database
+envvarsNotSet = ATLAS_RELEASEDATA,ATLAS_POOLCOND_PATH
+
+[prolog.sh]
+export ATLAS_RELEASEDATA=/cvmfs/faser.cern.ch/repo/sw/software/22.0/faser/offline/ReleaseData
+export ATLAS_POOLCOND_PATH=/cvmfs/faser.cern.ch/repo/sw/database/DBRelease/current
diff --git a/graphics/VTI12/VTI12Algs/share/vti12.py b/graphics/VTI12/VTI12Algs/share/vti12.py
index 3b07e0a37d3bc2914e72fdd97b662c625414a708..58669c867ed8c3bb22d23e7b477dd39b7da7a927 100644
--- a/graphics/VTI12/VTI12Algs/share/vti12.py
+++ b/graphics/VTI12/VTI12Algs/share/vti12.py
@@ -425,7 +425,7 @@ include('VP1Algs/vp1FragmentFixDBReplica.py')
if vp1NoSortDBReplicas:
PoolSvc = Service( "PoolSvc" )
- PoolSvc.SortReplicas = False
+ # PoolSvc.SortReplicas = False
from FaserGeoModel import SetGeometryVersion
from FaserGeoModel import GeoModelInit
diff --git a/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.cxx b/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.cxx
index df675231f8e6bc6fa0ca38e008185581757540be..d79d628073d4b2d5552805ce1d52644c05f4e635 100644
--- a/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.cxx
+++ b/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.cxx
@@ -3,25 +3,31 @@
// Local include(s):
#include "xAODStripClusterAuxContainerCnv.h"
-#include "AthContainers/tools/copyThinned.h"
-#include "AthenaKernel/IThinningSvc.h"
+#include "AthContainers/tools/copyAuxStoreThinned.h"
+#include "AthenaKernel/ThinningDecisionBase.h"
xAODStripClusterAuxContainerCnv::
-xAODStripClusterAuxContainerCnv( ISvcLocator* svcLoc )
- : xAODStripClusterAuxContainerCnvBase( svcLoc ) {
+xAODStripClusterAuxContainerCnv( ISvcLocator* svcLoc, const char* name )
+ : xAODStripClusterAuxContainerCnvBase( svcLoc, name ) {
}
xAOD::StripClusterAuxContainer*
xAODStripClusterAuxContainerCnv::
-createPersistent( xAOD::StripClusterAuxContainer* trans ) {
+createPersistentWithKey( xAOD::StripClusterAuxContainer* trans, const std::string& /*key*/ ) {
// Create a copy of the container:
- return SG::copyThinned (*trans, IThinningSvc::instance());
+ if (static_cast<const SG::IAuxStore&>(*trans).size() > 0)
+ {
+ auto pers = new xAOD::StripClusterAuxContainer();
+ SG::copyAuxStoreThinned(*trans, *pers, static_cast<SG::ThinningDecisionBase*>(nullptr));
+ return pers;
+ }
+ return new xAOD::StripClusterAuxContainer(*trans);
}
xAOD::StripClusterAuxContainer*
-xAODStripClusterAuxContainerCnv::createTransient() {
+xAODStripClusterAuxContainerCnv::createTransientWithKey(const std::string& /*key*/) {
// The known ID(s) for this container:
static const pool::Guid v1_guid( "61B62A1A-4C51-43A2-8364-1B9E910A81E8" );
diff --git a/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.h b/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.h
index 5e2b1e1efc98d94d0f40be9c06b830dca025b203..4479996cc691bcd12498b9f32b7e15ac77e550a3 100644
--- a/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.h
+++ b/xAOD/xAODFaserTrackingAthenaPool/src/xAODStripClusterAuxContainerCnv.h
@@ -8,7 +8,7 @@
#include "xAODFaserTracking/StripClusterAuxContainer.h"
/// Base class for the converter
-typedef T_AthenaPoolCustomCnv< xAOD::StripClusterAuxContainer,
+typedef T_AthenaPoolCustomCnvWithKey< xAOD::StripClusterAuxContainer,
xAOD::StripClusterAuxContainer >
xAODStripClusterAuxContainerCnvBase;
@@ -21,14 +21,14 @@ class xAODStripClusterAuxContainerCnv :
public:
/// Converter constructor
- xAODStripClusterAuxContainerCnv( ISvcLocator* svcLoc );
+ xAODStripClusterAuxContainerCnv( ISvcLocator* svcLoc, const char* name = nullptr );
protected:
/// Function preparing the container to be written out
virtual xAOD::StripClusterAuxContainer*
- createPersistent( xAOD::StripClusterAuxContainer* trans );
+ createPersistentWithKey( xAOD::StripClusterAuxContainer* trans, const std::string& key );
/// Function reading in the object from the input file
- virtual xAOD::StripClusterAuxContainer* createTransient();
+ virtual xAOD::StripClusterAuxContainer* createTransientWithKey( const std::string& key );
}; // class xAODStripClusterAuxContainerCnv