diff --git a/ForwardDetectors/ZDC/ZDC_SD/CMakeLists.txt b/ForwardDetectors/ZDC/ZDC_SD/CMakeLists.txt
index c76d6187855b11b7e27bf10173039b1151750842..9bc959d16ace51cedb129ab64ec5e5f13cc7f67f 100644
--- a/ForwardDetectors/ZDC/ZDC_SD/CMakeLists.txt
+++ b/ForwardDetectors/ZDC/ZDC_SD/CMakeLists.txt
@@ -9,9 +9,11 @@ atlas_subdir( ZDC_SD )
atlas_depends_on_subdirs( PUBLIC
GaudiKernel
PRIVATE
+ Control/CxxUtils
Control/StoreGate
ForwardDetectors/ZDC/ZDC_SimEvent
Simulation/G4Atlas/G4AtlasTools
+ AtlasTest/TestTools
)
# External dependencies:
@@ -20,13 +22,31 @@ find_package( Geant4 )
find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
find_package( XercesC )
+find_package( GTest )
+
# Component(s) in the package:
atlas_add_component( ZDC_SD
src/*.cxx
src/components/*.cxx
- INCLUDE_DIRS ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
- LINK_LIBRARIES ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} GaudiKernel StoreGateLib SGtests ZDC_SimEvent G4AtlasToolsLib )
+ INCLUDE_DIRS ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} GaudiKernel CxxUtils StoreGateLib SGtests ZDC_SimEvent G4AtlasToolsLib )
+
+atlas_add_library( ZDC_SDLib
+ src/*.cxx
+ NO_PUBLIC_HEADERS ZDC_SD
+ INCLUDE_DIRS ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} GaudiKernel CxxUtils StoreGateLib SGtests ZDC_SimEvent G4AtlasToolsLib )
+
+atlas_add_test( ZDC_StripSD_gtest
+ SOURCES test/ZDC_StripSD_gtest.cxx
+ INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES TestTools ZDC_SDLib G4AtlasToolsLib ${GTEST_LIBRARIES} ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES})
+
+atlas_add_test( ZDC_PixelSD_gtest
+ SOURCES test/ZDC_PixelSD_gtest.cxx
+ INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES TestTools ZDC_SDLib G4AtlasToolsLib ${GTEST_LIBRARIES} ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES})
# Install files from the package:
atlas_install_python_modules( python/*.py )
-
+atlas_install_joboptions( share/optionForTest.txt )
diff --git a/ForwardDetectors/ZDC/ZDC_SD/share/optionForTest.txt b/ForwardDetectors/ZDC/ZDC_SD/share/optionForTest.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d326fe9edfdf697b28f4407761e0dd2b1b3f9f7
--- /dev/null
+++ b/ForwardDetectors/ZDC/ZDC_SD/share/optionForTest.txt
@@ -0,0 +1,3 @@
+ApplicationMgr.ExtSvc += { "StoreGateSvc/DetectorStore", "StoreGateSvc/HistoryStore" };
+AuditorSvc.Auditors += { "AlgContextAuditor"};
+
diff --git a/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_PixelSD.h b/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_PixelSD.h
index 2748eaf494a8cc3b6b5301ffdd434b7008b0f462..14e5dd147c28f465eea0a01d7dadecd02887fdd8 100644
--- a/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_PixelSD.h
+++ b/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_PixelSD.h
@@ -11,6 +11,7 @@
// Athena headers
#include "ZDC_SimEvent/ZDC_SimPixelHit_Collection.h"
#include "StoreGate/WriteHandle.h"
+#include <gtest/gtest_prod.h>
// STL header
#include <string>
@@ -22,6 +23,11 @@ class G4HCofThisEvent;
class ZDC_PixelSD : public G4VSensitiveDetector
{
+ FRIEND_TEST( ZDC_PixelSDtest, ProcessHits );
+ FRIEND_TEST( ZDC_PixelSDtest, Initialize );
+ FRIEND_TEST( ZDC_PixelSDtest, StartOfAthenaEvent );
+ FRIEND_TEST( ZDC_PixelSDtest, EndOfAthenaEvent );
+ FRIEND_TEST( ZDC_PixelSDtest, AddHit );
public:
// Constructor
ZDC_PixelSD(const std::string& name, const std::string& hitCollectionName);
diff --git a/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_StripSD.h b/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_StripSD.h
index 0afa1ee36a1c7207ad6fc24d2bb19b2633f7901a..c90436396610210bb6f2e0a48bc7ee00affd4416 100644
--- a/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_StripSD.h
+++ b/ForwardDetectors/ZDC/ZDC_SD/src/ZDC_StripSD.h
@@ -14,6 +14,7 @@
// STL header
#include <string>
+#include <gtest/gtest_prod.h>
// G4 needed classes
class G4Step;
@@ -21,7 +22,11 @@ class G4HCofThisEvent;
class ZDC_StripSD : public G4VSensitiveDetector
{
-
+ FRIEND_TEST( ZDC_StripSDtest, ProcessHits );
+ FRIEND_TEST( ZDC_StripSDtest, Initialize );
+ FRIEND_TEST( ZDC_StripSDtest, StartOfAthenaEvent );
+ FRIEND_TEST( ZDC_StripSDtest, EndOfAthenaEvent );
+ FRIEND_TEST( ZDC_StripSDtest, AddHit );
public:
ZDC_StripSD(const std::string& name, const std::string& hitCollectionName);
diff --git a/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_PixelSD_gtest.cxx b/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_PixelSD_gtest.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..491e1c166baf6742fc50d0365a603a3af2af49cb
--- /dev/null
+++ b/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_PixelSD_gtest.cxx
@@ -0,0 +1,165 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/ZDC_PixelSD.h"
+
+#include "gtest/gtest.h"
+
+#include "TestTools/initGaudi.h"
+
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4TouchableHistory.hh"
+
+#include "G4Track.hh"
+#include "G4StepPoint.hh"
+#include "G4DynamicParticle.hh"
+#include "G4ThreeVector.hh"
+#include "G4Box.hh"
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4VPhysicalVolume.hh"
+#include "G4SystemOfUnits.hh"
+
+#include "G4AtlasTools/DerivedG4PhysicalVolume.h"
+#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h"
+
+//set environment
+class GaudiEnvironment : public ::testing::Environment {
+ protected:
+ virtual void SetUp() override {
+ Athena_test::initGaudi("ZDC_SD/optionForTest.txt", m_svcLoc);
+ }
+ ISvcLocator* m_svcLoc = nullptr;
+};
+class ZDC_PixelSDtest : public ::testing::Test {
+ protected:
+ virtual void SetUp() override {
+ }
+
+ virtual void TearDown() override {
+ }
+};
+//end of environment setting
+
+TEST_F( ZDC_PixelSDtest, Initialize )
+{
+ G4HCofThisEvent hce;
+ ZDC_PixelSD sd1( "name1", "name1" );
+ sd1.Initialize(&hce);
+ ASSERT_TRUE(sd1.m_HitColl.isValid());
+}
+
+TEST_F( ZDC_PixelSDtest, ProcessHits )
+{
+ G4HCofThisEvent hce;
+ G4Step sp;
+ G4TouchableHistory th;
+
+ G4double totalenergydeposit = 0.8;
+ G4String physicalname = "physicsTDQuarticBar[9]";
+ G4String logicalname = "BBBBBBBBBTubeGas";
+ G4int copyno = 21978;
+ G4ThreeVector preStepPos = G4ThreeVector(0,0,1);
+ G4ThreeVector postStepPos = G4ThreeVector(0,0,2);
+ G4double globaltime0 = 0.5;
+ G4double kineticenergy0 = 1.5;
+ G4double velocity0 = 250;
+ G4double globaltime = 5.0;
+ G4double kineticenergy = 0.5;
+ G4double globaltime1 = 0.5;
+ G4double kineticenergy1 = 0.5;
+ G4double velocity1 = 250;
+ G4double steplength = 1.0;
+ G4double charge = 1.0;
+ G4int encoding = 22;
+ G4int antiencoding = 22;
+ G4String astring = "Cerenkov";
+ G4ProcessType atype = (G4ProcessType)0;
+ G4String nop1 = "opticalphoton";
+ G4String nop2 = "opticalphoton";
+ G4String nop3 = "photon";
+ DerivedG4SensitiveDetectorTestSetting(sp, totalenergydeposit, physicalname, logicalname, copyno, preStepPos, postStepPos, globaltime0, kineticenergy0, velocity0, globaltime, kineticenergy, globaltime1, kineticenergy1, velocity1, steplength, charge, encoding, antiencoding, astring, atype, nop1, nop2, nop3);
+
+ ZDC_PixelSD sd2("name2", "name2");
+ sd2.Initialize(&hce);
+ sd2.StartOfAthenaEvent();
+ sd2.ProcessHits(&sp, &th);
+
+ ASSERT_FLOAT_EQ(sd2.m_Edep_Cherenkov_Pixel[1][1][78], 2.2452348e-05); //Based on my setting, Side=1, Module=1, Pixel_No=78, so m_Edep_Cherenkov_Pixel[1][1][78] was accumulated and finally it should be 2.2452348e-05.
+ ASSERT_EQ(sd2.m_NPhoton_Cherenkov_Pixel[1][1][78], 7); //Likewise, based on my setting, Side=1, Module=1, Pixel_No=78, so m_NPhoton_Cherenkov_Pixel[1][1][78] was accumulated and finally it should be 7
+}
+
+TEST_F( ZDC_PixelSDtest, StartOfAthenaEvent )
+{
+ G4HCofThisEvent hce;
+ ZDC_PixelSD sd3( "name3", "name3" );
+ sd3.Initialize(&hce);
+ sd3.StartOfAthenaEvent();
+
+ for (int I=0; I<=1; I++) //test if the Hit info is the same with what the member function StartOfAthenaEvent() sets
+ {
+ for (int J=0; J<=1; J++)
+ {
+ for (int K=0; K<80; K++)
+ {
+ ASSERT_TRUE(sd3.m_Edep_Cherenkov_Pixel [I][J][K] == 0);
+ ASSERT_TRUE(sd3.m_NPhoton_Cherenkov_Pixel[I][J][K] == 0);
+ }
+ }
+ }
+}
+
+TEST_F( ZDC_PixelSDtest, EndOfAthenaEvent )
+{
+ G4HCofThisEvent hce;
+ ZDC_PixelSD sd4( "name4", "name4" );
+ sd4.Initialize(&hce);
+ sd4.StartOfAthenaEvent();
+ sd4.EndOfAthenaEvent();
+
+ ZDC_SimPixelHit_Collection * a = sd4.m_HitColl.ptr();
+ ASSERT_TRUE(a->begin()->GetSide()==0); //test if the Side value is the same with what the member function EndOfAthenaEvent() sets, the same below
+ ASSERT_TRUE((a->end()-1)->GetSide()==1);
+ ASSERT_TRUE(a->begin()->GetMod()==0);
+ ASSERT_TRUE((a->end()-1)->GetMod()==1);
+ ASSERT_EQ(a->begin()->GetPix(),0);
+ ASSERT_EQ((a->end()-1)->GetPix(),23);
+ ASSERT_FLOAT_EQ(a->begin()->GetEdep(),0);
+ ASSERT_FLOAT_EQ((a->end()-1)->GetEdep(),0);
+ ASSERT_EQ(a->begin()->GetNPhotons(),0);
+ ASSERT_EQ((a->end()-1)->GetNPhotons(),0);
+}
+
+TEST_F( ZDC_PixelSDtest, AddHit )
+{
+ G4HCofThisEvent hce;
+ ZDC_PixelSD sd5( "name5", "name5" );
+ sd5.Initialize(&hce);
+
+ int i = 1;
+ int j = 2;
+ int k = 3;
+ int NPhoton = 4;
+ double energy = 5.0;
+ sd5.AddHit( i, j, k, NPhoton, energy );
+
+ ZDC_SimPixelHit_Collection * a = sd5.m_HitColl.ptr();
+ ASSERT_TRUE(a->begin()->GetSide()==1); //test if the Side value is the same with the input value 1, the same below
+ ASSERT_TRUE(a->begin()->GetMod()==2);
+ ASSERT_TRUE(a->begin()->GetPix()==3);
+ ASSERT_TRUE(a->begin()->GetEdep()==5.0);
+ ASSERT_TRUE(a->begin()->GetNPhotons()==4);
+}
+
+int main( int argc, char** argv ) {
+
+ auto g=new GaudiEnvironment;
+ ::testing::AddGlobalTestEnvironment(g);
+ ::testing::InitGoogleTest( &argc, argv );
+ return RUN_ALL_TESTS();
+
+}
+
+
diff --git a/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_StripSD_gtest.cxx b/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_StripSD_gtest.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..fe1ccad05a206f65db18da61e54e8600aac49616
--- /dev/null
+++ b/ForwardDetectors/ZDC/ZDC_SD/test/ZDC_StripSD_gtest.cxx
@@ -0,0 +1,159 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/ZDC_StripSD.h"
+#include "gtest/gtest.h"
+
+#include "TestTools/initGaudi.h"
+
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4TouchableHistory.hh"
+
+
+#include "G4Track.hh"
+#include "G4StepPoint.hh"
+#include "G4DynamicParticle.hh"
+#include "G4ThreeVector.hh"
+#include "G4Box.hh"
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4VPhysicalVolume.hh"
+#include "G4SystemOfUnits.hh"
+
+#include "G4AtlasTools/DerivedG4PhysicalVolume.h"
+#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h"
+
+//set environment
+class GaudiEnvironment : public ::testing::Environment {
+ protected:
+ virtual void SetUp() override {
+ Athena_test::initGaudi("ZDC_SD/optionForTest.txt", m_svcLoc);
+ }
+ ISvcLocator* m_svcLoc = nullptr;
+};
+class ZDC_StripSDtest : public ::testing::Test {
+ protected:
+ virtual void SetUp() override {
+ }
+
+ virtual void TearDown() override {
+ }
+};
+//end of environment setting
+
+TEST_F( ZDC_StripSDtest, Initialize )
+{
+ G4HCofThisEvent hce;
+ ZDC_StripSD sd1( "name1", "name1" );
+ sd1.Initialize(&hce);
+ ASSERT_TRUE(sd1.m_HitColl.isValid());
+}
+
+TEST_F( ZDC_StripSDtest, ProcessHits )
+{
+ G4HCofThisEvent hce;
+ G4Step sp;
+ G4TouchableHistory th;
+
+ G4double totalenergydeposit = 0.8;
+ G4String physicalname = "physicsTDQuarticBar[9]";
+ G4String logicalname = "BBBBBBBBBTubeGas";
+ G4int copyno = 11000;
+ G4ThreeVector preStepPos = G4ThreeVector(0,0,1);
+ G4ThreeVector postStepPos = G4ThreeVector(0,0,2);
+ G4double globaltime0 = 0.5;
+ G4double kineticenergy0 = 1.5;
+ G4double velocity0 = 2500;
+ G4double globaltime = 5.0;
+ G4double kineticenergy = 0.5;
+ G4double globaltime1 = 0.5;
+ G4double kineticenergy1 = 0.5;
+ G4double velocity1 = 2500;
+ G4double steplength = 1.0;
+ G4double charge = 1.0;
+ G4int encoding = 22;
+ G4int antiencoding = 22;
+ G4String astring = "Cerenkov";
+ G4ProcessType atype = (G4ProcessType)0;
+ G4String nop1 = "opticalphoton";
+ G4String nop2 = "opticalphoton";
+ G4String nop3 = "photon";
+ DerivedG4SensitiveDetectorTestSetting(sp, totalenergydeposit, physicalname, logicalname, copyno, preStepPos, postStepPos, globaltime0, kineticenergy0, velocity0, globaltime, kineticenergy, globaltime1, kineticenergy1, velocity1, steplength, charge, encoding, antiencoding, astring, atype, nop1, nop2, nop3);
+
+ ZDC_StripSD sd2("name2", "name2");
+ sd2.Initialize(&hce);
+ sd2.StartOfAthenaEvent();
+ sd2.ProcessHits(&sp, &th);
+
+ ASSERT_FLOAT_EQ(sd2.m_Edep_Cherenkov_Strip[0][0], 1.4782044e-05); //Based on my setting, Side=0, Zloc=0, so m_Edep_Cherenkov_Strip[0][0] was accumulated and finally its value should be 1.4782044e-05
+ ASSERT_EQ(sd2.m_NPhoton_Cherenkov_Strip[0][0], 5); //Similarly, based on my setting, Side=0, Zloc=0, so m_NPhoton_Cherenkov_Strip[0][0] was accumulated for five times and finally its value should be 5
+}
+
+TEST_F( ZDC_StripSDtest, StartOfAthenaEvent )
+{
+ G4HCofThisEvent hce;
+ ZDC_StripSD sd3( "name3", "name3" );
+ sd3.Initialize(&hce);
+ sd3.StartOfAthenaEvent();
+
+ for (int I=0; I<2; I++) //test if the Hit info is the same with what the member function StartOfAthenaEvent() sets
+ {
+ for (int J=0; J<4; J++)
+ {
+ ASSERT_TRUE( sd3.m_Edep_Cherenkov_Strip [I][J] == 0 );
+ ASSERT_TRUE( sd3.m_NPhoton_Cherenkov_Strip[I][J] == 0 );
+ }
+ }
+}
+
+TEST_F( ZDC_StripSDtest, EndOfAthenaEvent )
+{
+ G4HCofThisEvent hce;
+ ZDC_StripSD sd4( "name4", "name4" );
+ sd4.Initialize(&hce);
+ sd4.StartOfAthenaEvent();
+ sd4.EndOfAthenaEvent();
+
+ ZDC_SimStripHit_Collection * a = sd4.m_HitColl.ptr();
+ ASSERT_TRUE(a->begin()->GetSide()==0); //test if the Side value is the same with what the member function EndOfAthenaEvent() sets, the same below
+ ASSERT_TRUE((a->end()-1)->GetSide()==1);
+ ASSERT_TRUE(a->begin()->GetMod()==0);
+ ASSERT_TRUE((a->end()-1)->GetMod()==3);
+ ASSERT_FLOAT_EQ(a->begin()->GetEdep(),0);
+ ASSERT_FLOAT_EQ((a->end()-1)->GetEdep(),0);
+ ASSERT_EQ(a->begin()->GetNPhotons(),0);
+ ASSERT_EQ((a->end()-1)->GetNPhotons(),0);
+
+}
+
+TEST_F( ZDC_StripSDtest, AddHit )
+{
+ G4HCofThisEvent hce;
+ ZDC_StripSD sd5( "name5", "name5" );
+ sd5.Initialize(&hce);
+
+ int i = 1;
+ int j = 2;
+ int NPhoton = 4;
+ double energy = 5.0;
+ sd5.AddHit( i, j, NPhoton, energy );
+
+ ZDC_SimStripHit_Collection * a = sd5.m_HitColl.ptr();
+ ASSERT_TRUE(a->begin()->GetSide()==1); //test if the Side value is same with my input value 1, the same below
+ ASSERT_TRUE(a->begin()->GetMod()==2);
+ ASSERT_TRUE(a->begin()->GetEdep()==5.0);
+ ASSERT_TRUE(a->begin()->GetNPhotons()==4);
+
+}
+
+int main( int argc, char** argv ) {
+
+ auto g=new GaudiEnvironment;
+ ::testing::AddGlobalTestEnvironment(g);
+ ::testing::InitGoogleTest( &argc, argv );
+ return RUN_ALL_TESTS();
+
+}
+
diff --git a/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4PhysicalVolume.h b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4PhysicalVolume.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d39ffb333746ff8a173c5b5ba3f118ce1666d62
--- /dev/null
+++ b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4PhysicalVolume.h
@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef G4MyPhysicalVolume_h
+#define G4MyPhysicalVolume_h
+
+#include "G4VPhysicalVolume.hh"
+#include "G4RotationMatrix.hh"
+#include "G4ThreeVector.hh"
+#include "G4LogicalVolume.hh"
+#include "G4String.hh"
+#include "G4VPVParameterisation.hh"
+
+class G4MyPhysicalVolume : public G4VPhysicalVolume {
+
+public:
+
+ G4MyPhysicalVolume( G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String& pName, G4LogicalVolume* pLogical, G4VPhysicalVolume* pPhysical ) : G4VPhysicalVolume(pRot, tlate, pName, pLogical, pPhysical)
+ {
+
+ }
+
+ ~G4MyPhysicalVolume() {}
+
+ G4int GetCopyNo() const final
+ {
+ return copyNo;
+ }
+
+ void SetCopyNo(G4int CopyNo) final
+ {
+ copyNo = CopyNo;
+ }
+
+ G4bool IsMany() const final { return true; }
+
+ G4bool IsReplicated() const final { return true; }
+
+ G4bool IsParameterised() const final { return true; }
+
+ G4VPVParameterisation* GetParameterisation() const final { return nullptr; }
+
+ void GetReplicationData(EAxis& axis, G4int& nReplicas, G4double& width, G4double& offset, G4bool& consuming) const final
+ {
+ axis = (EAxis)1;
+ nReplicas = 0;
+ width = 0.0;
+ offset = 0.0;
+ consuming = true;
+ }
+
+ G4bool IsRegularStructure() const final { return true; }
+
+ G4int GetRegularStructureId() const final { return 0; }
+
+ G4int copyNo;
+
+};
+#endif
diff --git a/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4Process.h b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4Process.h
new file mode 100644
index 0000000000000000000000000000000000000000..649bbc83673bf9a35a52acaff315409c15ca6ae9
--- /dev/null
+++ b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4Process.h
@@ -0,0 +1,90 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef G4MyProcess_h
+#define G4MyProcess_h
+
+#include "G4VProcess.hh"
+
+class G4MyProcess : public G4VProcess {
+
+ public:
+
+ G4MyProcess( G4String& aName, G4ProcessType aType ) : G4VProcess( aName, aType )
+ {
+
+ }
+
+ ~G4MyProcess() {}
+
+ G4VParticleChange* PostStepDoIt(
+ const G4Track& track,
+ const G4Step& stepData
+ ) final
+ {
+ (void)track; //just for silence UNUSED warning! The same below
+ (void)stepData;
+ return nullptr;
+ }
+
+ G4VParticleChange* AlongStepDoIt(
+ const G4Track& track,
+ const G4Step& stepData
+ ) final
+ {
+ (void)track;
+ (void)stepData;
+ return nullptr;
+ }
+
+ G4VParticleChange* AtRestDoIt(
+ const G4Track& track,
+ const G4Step& stepData
+ ) final
+ {
+ (void)track;
+ (void)stepData;
+ return nullptr;
+ }
+
+ G4double AlongStepGetPhysicalInteractionLength(
+ const G4Track& track,
+ G4double previousStepSize,
+ G4double currentMinimumStep,
+ G4double& proposedSafety,
+ G4GPILSelection* selection) final
+ {
+ (void)track;
+ (void)previousStepSize;
+ (void)currentMinimumStep;
+ (void)proposedSafety;
+ (void)selection;
+ return 0.0;
+ }
+
+ G4double AtRestGetPhysicalInteractionLength(
+ const G4Track& track,
+ G4ForceCondition* condition
+ ) final
+ {
+ (void)track;
+ (void)condition;
+ return 0.0;
+ }
+
+ G4double PostStepGetPhysicalInteractionLength(
+ const G4Track& track,
+ G4double previousStepSize,
+ G4ForceCondition* condition
+ ) final
+ {
+ (void)track;
+ (void)previousStepSize;
+ (void)condition;
+ return 0.0;
+ }
+};
+
+#endif
+
diff --git a/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h
new file mode 100644
index 0000000000000000000000000000000000000000..af3dbc39dca83dad593e00e39e3c4e66fe3ca784
--- /dev/null
+++ b/Simulation/G4Atlas/G4AtlasTools/G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h
@@ -0,0 +1,142 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4TouchableHistory.hh"
+
+#include "G4Track.hh"
+#include "G4StepPoint.hh"
+#include "G4DynamicParticle.hh"
+#include "G4ThreeVector.hh"
+#include "G4Box.hh"
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4VPhysicalVolume.hh"
+#include "G4SystemOfUnits.hh"
+
+#include "DerivedG4Process.h"
+
+//In this function, the reasons why I use 'new' to define objects instead of using smart pointers are as follows:
+// 1. this function aims to set environment for test code, which means the objects that were defined in the function should exist throughout the whole code running. Therefore, defining the objects with 'new' can meet the requirement. If I define them with smart pointer, they will be destruct once they are out of scope.
+// 2. this function will only be used in the unit test code for testing the sensitive detector classes based on G4VSensitiveDetector. So it will never be responsible for memory leaks in production jobs.
+void DerivedG4SensitiveDetectorTestSetting(G4Step& sp, G4double& totalenergydeposit, G4String& physicalname, G4String& logicalname1, G4int& copyno, G4ThreeVector& preStepPos, G4ThreeVector& postStepPos, G4double& globaltime0/*for preSP*/, G4double& kineticenergy0/*for preSP*/, G4double& velocity0/*for preSP*/, G4double& globaltime/*for track*/, G4double& kineticenergy/*for track*/, G4double& globaltime1/*for postSP*/, G4double& kineticenergy1/*for postSP*/, G4double& velocity1/*for postSP*/, G4double& steplength, G4double& charge, G4int& encoding, G4int& antiencoding, G4String& astring, G4ProcessType& atype, G4String& nop1, G4String& nop2, G4String& nop3)
+{
+//decorate sp with the variable called TotalEnergyDeposit
+ G4double TotalEnergyDeposit = totalenergydeposit;//para(i.e. there is a parameter in this line)
+ sp.SetTotalEnergyDeposit( TotalEnergyDeposit );
+//end
+
+//decorate sp with a G4StepPoint object
+ G4StepPoint* stepPoint = new G4StepPoint();
+ stepPoint->SetPosition(preStepPos);//para
+ G4NavigationHistory* navigationHistory = new G4NavigationHistory();
+ G4String boxName = "name";
+ G4Box* box = new G4Box(boxName, 1.0, 1.0, 1.0);
+ G4NistManager* man = G4NistManager::Instance();
+ G4Material* material = man->FindOrBuildMaterial("G4_AIR");
+ G4String name = "logicalName";
+ G4LogicalVolume* fLogical = new G4LogicalVolume(box, material, name);
+ G4String PhysicalName = physicalname;//para
+ G4VPhysicalVolume* pPhysical = nullptr;
+ G4MyPhysicalVolume* physicalVolume = new G4MyPhysicalVolume(0, G4ThreeVector(0,0,0), PhysicalName, fLogical, pPhysical);
+ G4int CopyNo = copyno;
+ physicalVolume->SetCopyNo(CopyNo);//para
+ G4int nReplica = 2;
+ navigationHistory->SetFirstEntry(physicalVolume);
+ navigationHistory->NewLevel(physicalVolume, kNormal, nReplica);
+ navigationHistory->NewLevel(physicalVolume, kNormal, nReplica);
+ navigationHistory->NewLevel(physicalVolume, kNormal, nReplica);
+ navigationHistory->NewLevel(physicalVolume, kNormal, nReplica);
+ navigationHistory->NewLevel(physicalVolume, kNormal, nReplica);
+ G4TouchableHistory* touchableHistory = new G4TouchableHistory(*navigationHistory);
+ G4TouchableHandle touchableHandle(touchableHistory);
+ stepPoint->SetTouchableHandle(touchableHandle);
+ G4double GlobalTime0 = globaltime0;
+ G4double KineticEnergy0 = kineticenergy0;
+ G4double Velocity0 = velocity0;
+ stepPoint->SetGlobalTime(GlobalTime0);//para
+ stepPoint->SetKineticEnergy(KineticEnergy0);//para
+ stepPoint->SetVelocity(Velocity0);//para
+
+ sp.SetPreStepPoint(stepPoint);
+//end
+
+//decorate sp with another G4StepPoint object
+ G4StepPoint* stepPoint1 = new G4StepPoint();
+ stepPoint1->SetPosition(postStepPos);//para
+ G4double GlobalTime1 = globaltime1;
+ G4double KineticEnergy1 = kineticenergy1;
+ G4double Velocity1 = velocity1;
+ stepPoint1->SetGlobalTime(GlobalTime1);//para
+ stepPoint1->SetKineticEnergy(KineticEnergy1);//para
+ stepPoint1->SetVelocity(Velocity1);//para
+
+ sp.SetPostStepPoint(stepPoint1);
+//end
+
+//set step length for the step
+ G4double StepLength = steplength;
+ sp.SetStepLength(StepLength);//para
+//end
+
+//decorate sp with a G4Track object
+ G4double Charge = charge;
+ G4int Encoding = encoding;
+ G4int Antiencoding = antiencoding;
+ G4String NOP1 = nop1;
+ G4String NOP2 = nop2;
+ G4String NOP3 = nop3;
+ G4ParticleDefinition* particle = new G4ParticleDefinition(NOP1, 0.0*MeV, 0.0*MeV, Charge,//para
+ 2, -1, -1,
+ 0, 0, 0,
+ NOP2, 0, 0, Encoding,//para
+ true, -1.0, nullptr,
+ false, NOP3, Antiencoding//para
+ );
+ G4ThreeVector aMomentumDirection(0,0,0);
+ G4double aKineticEnergy = kineticenergy;//para
+ G4DynamicParticle* dynamicPar = new G4DynamicParticle(particle, aMomentumDirection, aKineticEnergy);
+ G4double aValueTime = 1;
+ G4ThreeVector ValuePosition(1.0, 1.0, 1.0);
+ G4Track* track = new G4Track(dynamicPar, aValueTime, ValuePosition);
+ G4double globalTime = globaltime;
+ track->SetGlobalTime(globalTime);//para
+ int trackID = 3;
+ track->SetTrackID(trackID);
+ G4String boxName1 = "name";
+ G4Box* box1 = new G4Box(boxName1, 1.0, 1.0, 1.0);
+ G4NistManager* man1 = G4NistManager::Instance();
+ G4Material* material1 = man1->FindOrBuildMaterial("G4_AIR");
+ G4String name2 = logicalname1;//para
+ G4LogicalVolume* fLogical1 = new G4LogicalVolume(box1, material1, name2);
+ track->SetLogicalVolumeAtVertex(fLogical1);
+ G4Step* stepForTrack = new G4Step();
+ G4StepPoint* stepPoint2 = new G4StepPoint();
+ G4Material* mat1 = man1->FindOrBuildMaterial("G4_AIR");
+ G4MaterialPropertiesTable* propertiesTable = new G4MaterialPropertiesTable();
+ G4double Energies[5] = {1,2,3,4,5};
+ G4double Values[5] = {1,2,3,4,5};
+ size_t VectorLength = 5;
+ G4MaterialPropertyVector* mpv = new G4MaterialPropertyVector(Energies, Values, VectorLength);
+ G4MaterialPropertyVector* mpv1 = new G4MaterialPropertyVector(Energies, Values, VectorLength);
+ propertiesTable->AddProperty("RINDEX", mpv);
+ propertiesTable->AddProperty("ABSLENGTH", mpv1);
+ mat1->SetMaterialPropertiesTable(propertiesTable);
+ stepPoint2->SetMaterial(mat1);
+ stepForTrack->SetPreStepPoint(stepPoint2);
+ track->SetStep(stepForTrack);
+
+ G4ProcessType aType = atype;
+ G4String aString = astring;
+ G4MyProcess* process = new G4MyProcess( aString, aType );//para para
+ track->SetCreatorProcess( process );
+
+ track->SetTouchableHandle(touchableHandle);
+
+ sp.SetTrack(track);
+//end
+
+ return;
+}