diff --git a/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt b/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt index 63d19e77dde05384b09f69fd594ac0f1ace10295..90c62199cfa81e32689062ce94d0c1ea93463a78 100644 --- a/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt +++ b/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt @@ -12,12 +12,14 @@ atlas_depends_on_subdirs( PRIVATE InnerDetector/InDetSimEvent Simulation/G4Atlas/G4AtlasTools Simulation/G4Sim/MCTruth + AtlasTest/TestTools ) # External dependencies: find_package( CLHEP ) find_package( Geant4 ) find_package( XercesC ) +find_package( GTest ) # Component(s) in the package: atlas_add_component( SCT_G4_SD @@ -26,10 +28,28 @@ atlas_add_component( SCT_G4_SD INCLUDE_DIRS ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth ) +atlas_add_library( SCT_G4_SDLib + src/*.cxx + NO_PUBLIC_HEADERS SCT_G4_SD + INCLUDE_DIRS ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS} + LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} ${GMOCK_LIBRARIES} CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth ) + atlas_add_test( SCT_G4_SDToolConfig_test SCRIPT test/SCT_G4_SDToolConfig_test.py PROPERTIES TIMEOUT 300 ) +atlas_add_test( SctSensorSD_gtest + SOURCES test/SctSensorSD_gtest.cxx + INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} + LINK_LIBRARIES TestTools ${GTEST_LIBRARIES} ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} SCT_G4_SDLib CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth +) + +atlas_add_test( SctSensor_CTB_gtest + SOURCES test/SctSensor_CTB_gtest.cxx + INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} + LINK_LIBRARIES TestTools ${GTEST_LIBRARIES} ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} SCT_G4_SDLib CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth +) + # Install files from the package: atlas_install_python_modules( python/*.py ) - +atlas_install_joboptions( share/optionForTest.txt ) diff --git a/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt b/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt new file mode 100644 index 0000000000000000000000000000000000000000..9d326fe9edfdf697b28f4407761e0dd2b1b3f9f7 --- /dev/null +++ b/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt @@ -0,0 +1,3 @@ +ApplicationMgr.ExtSvc += { "StoreGateSvc/DetectorStore", "StoreGateSvc/HistoryStore" }; +AuditorSvc.Auditors += { "AlgContextAuditor"}; + diff --git a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h index 417901b891f485f7d3838558c58778d32a5e04cb..2695af0528bff124219a3fbe3a802ee3a75a16e5 100644 --- a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h +++ b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h @@ -15,6 +15,7 @@ // For the hits #include "InDetSimEvent/SiHitCollection.h" #include "StoreGate/WriteHandle.h" +#include <gtest/gtest_prod.h> // G4 needed classes class G4Step; @@ -22,6 +23,11 @@ class G4TouchableHistory; class SctSensorSD : public G4VSensitiveDetector { + + FRIEND_TEST( SctSensorSDtest, Initialize ); + FRIEND_TEST( SctSensorSDtest, ProcessHits ); + FRIEND_TEST( SctSensorSDtest, indexMethod ); + FRIEND_TEST( SctSensorSDtest, AddHit ); public: // Constructor SctSensorSD(const std::string& name, const std::string& hitCollectionName); @@ -39,7 +45,6 @@ public: could get rather tricky, but the idea is to allow fast simulations to use the very same SD classes as the standard simulation. */ template <class... Args> void AddHit(Args&&... args){ m_HitColl->Emplace( args... ); } - private: void indexMethod(const G4TouchableHistory *myTouch, double coord1z, int &brlEcap, int &layerDisk, int &etaMod, int &phiMod, int &side); protected: diff --git a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h index f50fccae53866c6cddd799c210946a3987610780..28d1a14e919c5c38e2ac36bc7cd8e01523b71b63 100644 --- a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h +++ b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h @@ -16,6 +16,7 @@ // For the hits #include "StoreGate/WriteHandle.h" #include "InDetSimEvent/SiHitCollection.h" +#include <gtest/gtest_prod.h> // G4 needed classes class G4Step; @@ -25,6 +26,10 @@ class G4TouchableHistory; class SctSensor_CTB : public G4VSensitiveDetector { + + FRIEND_TEST( SctSensor_CTBtest, Initialize ); + FRIEND_TEST( SctSensor_CTBtest, ProcessHits ); + FRIEND_TEST( SctSensor_CTBtest, AddHit ); public: // Constructor SctSensor_CTB( const std::string& name, const std::string& hitCollectionName ); diff --git a/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx new file mode 100644 index 0000000000000000000000000000000000000000..41fe752ec2aebf85c58448bb9d43ff4b2c14d504 --- /dev/null +++ b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx @@ -0,0 +1,211 @@ +/* + Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration +*/ + +#include "src/SctSensorSD.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 "G4AtlasTools/DerivedG4PhysicalVolume.h" +#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h" +#include "MCTruth/TrackHelper.h" + +//set environment +class GaudiEnvironment : public ::testing::Environment { + protected: + virtual void SetUp() override { + Athena_test::initGaudi("SCT_G4_SD/optionForTest.txt", m_svcLoc); + } + ISvcLocator* m_svcLoc = nullptr; +}; +class SctSensorSDtest : public ::testing::Test { + protected: + virtual void SetUp() override { + } + + virtual void TearDown() override { + } +}; +//end of environment setting + +TEST_F( SctSensorSDtest, Initialize ) { + G4HCofThisEvent hce; + SctSensorSD sd1("name1", "name1" ); + sd1.Initialize( &hce ); + ASSERT_TRUE(sd1.m_HitColl.isValid()); //check if initialization of m_HitColl is successful +} + +TEST_F( SctSensorSDtest, ProcessHits ) +{ + G4Step sp; + G4TouchableHistory th; + G4HCofThisEvent hce; + + G4double totalenergydeposit = 3.0; + G4String physicalname = "physicalName"; + G4String logicalname = "BBBBBBBBBTubeGas"; + G4int copyno = 1000; + G4ThreeVector preStepPos = G4ThreeVector(0,0,1); + G4ThreeVector postStepPos = G4ThreeVector(0,0,2); + G4double globaltime0 = 0.5; + G4double kineticenergy0 = 1.5; + G4double velocity0 = 99.93100; + G4double globaltime = 5.0; + G4double kineticenergy = 0.5; + G4double globaltime1 = 0.5; + G4double kineticenergy1 = 0.5; + G4double velocity1 = 99.93100; + 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); + + SctSensorSD sd2("name2", "name2"); + sd2.Initialize( &hce ); + sd2.ProcessHits(&sp, &th ); + + HepGeom::Point3D<double> P1,P2; + P1[SiHit::xEta] = 1; + P1[SiHit::xPhi] = 0; + P1[SiHit::xDep] = 0; + P2[SiHit::xEta] = 2; + P2[SiHit::xPhi] = 0; + P2[SiHit::xDep] = 0; + + int barcode = 0; + HepMcParticleLink plink(barcode); + + SiHitCollection* a = sd2.m_HitColl.ptr(); + ASSERT_EQ(a->begin()->localStartPosition(), P1); //test if the localStartPosition value of the Hit generated by this member function is right, the same below + ASSERT_EQ(a->begin()->localEndPosition(), P2); + ASSERT_EQ(a->begin()->energyLoss(), 3.0); + ASSERT_EQ(a->begin()->meanTime(), 0.5); + ASSERT_EQ(a->begin()->particleLink(), plink); + ASSERT_EQ(a->begin()->identify(),4101273733); + + ASSERT_EQ(a->size(), 1); //test the current size of the Hit container +} + +TEST_F( SctSensorSDtest, indexMethod ) +{ +// decorate G4TouchableHistory object that will be used as the actual para of indexMethod + 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(box, material, name); + G4String name1 = "physicalName"; + G4VPhysicalVolume* pPhysical = NULL; + G4MyPhysicalVolume physicalVolume(0, G4ThreeVector(0,0,0), name1, &fLogical, pPhysical); + physicalVolume.SetCopyNo(1000); + 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 th(*navigationHistory); +// end + + G4HCofThisEvent hce; + + double coord1z = 1; + int brlEcap = 0; + int layerDisk = 0; + int etaMod = 0; + int phiMod = 0; + int side = 0; + + SctSensorSD sd3("name3", "name3"); + sd3.Initialize( &hce ); + sd3.indexMethod(&th, coord1z, brlEcap, layerDisk, etaMod, phiMod, side ); + + ASSERT_EQ(brlEcap, 0); //test the value of brlEcap changed by the member function indexMethod, it should be 0 in this case. The same below + ASSERT_EQ(layerDisk, 1000); + ASSERT_EQ(etaMod, 1000); + ASSERT_EQ(phiMod, 1000); + ASSERT_EQ(side, 1000); + +} + +TEST_F( SctSensorSDtest, AddHit ) +{ + HepGeom::Point3D<double> lP1,lP2; + lP1[SiHit::xEta] = 1; + lP1[SiHit::xPhi] = 0; + lP1[SiHit::xDep] = 0; + lP2[SiHit::xEta] = 2; + lP2[SiHit::xPhi] = 0; + lP2[SiHit::xDep] = 0; + + G4DynamicParticle* dynamicPar = new G4DynamicParticle(); + G4double aValueTime = 1; + G4ThreeVector ValuePosition(1.0, 1.0, 1.0); + G4Track track(dynamicPar, aValueTime, ValuePosition); + TrackHelper trHelp(&track); + + int brlEcap = 0; + int layerDisk = 0; + int etaMod = 0; + int phiMod = 0; + int side = 0; + SctSensorSD sd4("name4", "name4"); + G4HCofThisEvent hce; + sd4.Initialize( &hce ); + sd4.AddHit(lP1, lP2, 2.0, 1.0, trHelp.GetParticleLink(), 1, brlEcap, layerDisk, etaMod, phiMod, side); + + HepGeom::Point3D<double> P1,P2; + P1[SiHit::xEta] = 1; + P1[SiHit::xPhi] = 0; + P1[SiHit::xDep] = 0; + P2[SiHit::xEta] = 2; + P2[SiHit::xPhi] = 0; + P2[SiHit::xDep] = 0; + + int barcode = 0; + HepMcParticleLink plink(barcode); + + SiHitCollection* a = sd4.m_HitColl.ptr(); + ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit generated by the member function AddHit, the same below + ASSERT_EQ(a->begin()->localEndPosition(), P2); + ASSERT_EQ(a->begin()->energyLoss(), 2.0); + ASSERT_EQ(a->begin()->meanTime(), 1.0); + ASSERT_EQ(a->begin()->particleLink(), plink); + ASSERT_EQ(a->begin()->identify(), 10245); + ASSERT_EQ(a->size(), 1); //test the current size of the Hit container + +} + +int main( int argc, char** argv ) { + + auto g=new GaudiEnvironment; + ::testing::AddGlobalTestEnvironment(g); + ::testing::InitGoogleTest( &argc, argv ); + return RUN_ALL_TESTS(); + +} + diff --git a/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx new file mode 100644 index 0000000000000000000000000000000000000000..c025887a67935d363dcf07d1d70c4ab76d0fff24 --- /dev/null +++ b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx @@ -0,0 +1,167 @@ +/* + Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration +*/ + +#include "src/SctSensor_CTB.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 "G4AtlasTools/DerivedG4PhysicalVolume.h" +#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h" +#include "MCTruth/TrackHelper.h" + +//set environment +class GaudiEnvironment : public ::testing::Environment { + protected: + virtual void SetUp() override { + Athena_test::initGaudi("SCT_G4_SD/optionForTest.txt", m_svcLoc); + } + ISvcLocator* m_svcLoc = nullptr; +}; +class SctSensor_CTBtest : public ::testing::Test { + protected: + virtual void SetUp() override { + } + + virtual void TearDown() override { + } +}; +//end of environment setting + +TEST_F( SctSensor_CTBtest, Initialize ) +{ + G4HCofThisEvent hce; + SctSensor_CTB sd1("name1", "name1" ); + sd1.Initialize( &hce ); + ASSERT_TRUE(sd1.m_HitColl.isValid());//check if initialization of m_HitColl is successful +} + +TEST_F( SctSensor_CTBtest, ProcessHits ) +{ + G4Step sp; + G4TouchableHistory th; + G4HCofThisEvent hce; + + G4double totalenergydeposit = 3.0; + G4String physicalname = "physicalName"; + G4String logicalname = "BBBBBBBBBTubeGas"; + G4int copyno = 1000; + G4ThreeVector preStepPos = G4ThreeVector(0,0,1); + G4ThreeVector postStepPos = G4ThreeVector(0,0,2); + G4double globaltime0 = 0.5; + G4double kineticenergy0 = 1.5; + G4double velocity0 = 99.93100; + G4double globaltime = 5.0; + G4double kineticenergy = 0.5; + G4double globaltime1 = 0.5; + G4double kineticenergy1 = 0.5; + G4double velocity1 = 99.93100; + 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); + + SctSensor_CTB sd2("name2", "name2"); + sd2.Initialize( &hce ); + sd2.ProcessHits(&sp, &th ); + + HepGeom::Point3D<double> P1,P2; + P1[SiHit::xEta] = 1; + P1[SiHit::xPhi] = 0; + P1[SiHit::xDep] = 0; + P2[SiHit::xEta] = 2; + P2[SiHit::xPhi] = 0; + P2[SiHit::xDep] = 0; + + int barcode = 0; + HepMcParticleLink plink(barcode); + + SiHitCollection* a = sd2.m_HitColl.ptr(); + ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit generated by the member function ProcessHits, and it should be P1 according to my setting, the same below + ASSERT_EQ(a->begin()->localEndPosition(), P2); + ASSERT_EQ(a->begin()->energyLoss(), 3.0); + ASSERT_EQ(a->begin()->meanTime(), 0.5); + ASSERT_EQ(a->begin()->particleLink(), plink); + ASSERT_EQ(a->begin()->identify(),4093651781); + + ASSERT_EQ(a->size(), 1); //test the size of the Hit container, it should be 1 since just 1 Hit was stored in it +} + +TEST_F( SctSensor_CTBtest, AddHit ) +{ + HepGeom::Point3D<double> lP1,lP2; + lP1[SiHit::xEta] = 1; + lP1[SiHit::xPhi] = 0; + lP1[SiHit::xDep] = 0; + lP2[SiHit::xEta] = 2; + lP2[SiHit::xPhi] = 0; + lP2[SiHit::xDep] = 0; + + G4DynamicParticle* dynamicPar = new G4DynamicParticle(); + G4double aValueTime = 1; + G4ThreeVector ValuePosition(1.0, 1.0, 1.0); + G4Track track(dynamicPar, aValueTime, ValuePosition); + TrackHelper trHelp(&track); + + int brlEcap = 0; + int layerDisk = 0; + int etaMod = 0; + int phiMod = 0; + int side = 0; + SctSensor_CTB sd4("name4", "name4"); + G4HCofThisEvent hce; + sd4.Initialize( &hce ); + sd4.AddHit(lP1, lP2, 2.0, 1.0, trHelp.GetParticleLink(), 1, brlEcap, layerDisk, etaMod, phiMod, side); + + HepGeom::Point3D<double> P1,P2; + P1[SiHit::xEta] = 1; + P1[SiHit::xPhi] = 0; + P1[SiHit::xDep] = 0; + P2[SiHit::xEta] = 2; + P2[SiHit::xPhi] = 0; + P2[SiHit::xDep] = 0; + + int barcode = 0; + HepMcParticleLink plink(barcode); + + SiHitCollection* a = sd4.m_HitColl.ptr(); + ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit added by the member function AddHit, and it should be P1 based on the setting, the same below + ASSERT_EQ(a->begin()->localEndPosition(), P2); + ASSERT_EQ(a->begin()->energyLoss(), 2.0); + ASSERT_EQ(a->begin()->meanTime(), 1.0); + ASSERT_EQ(a->begin()->particleLink(), plink); + ASSERT_EQ(a->begin()->identify(), 10245); + ASSERT_EQ(a->size(), 1); //test the current size of the Hit container + +} + +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/src/G4FieldManagerToolBase.cxx b/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx index ae3efd9378b38ca012f4f6cd12bab0eb450e9777..9b82794ab97f1d82717bc475a73ccbb2dd03c7eb 100644 --- a/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx +++ b/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx @@ -16,18 +16,7 @@ #include "G4NystromRK4.hh" #include "G4ClassicalRK4.hh" #include "G4AtlasRK4.hh" -#include "G4BogackiShampine23.hh" -#include "G4BogackiShampine45.hh" -#include "G4CashKarpRKF45.hh" -#include "G4DoLoMcPriRK34.hh" -#include "G4DormandPrince745.hh" -#include "G4DormandPrinceRK56.hh" -#include "G4DormandPrinceRK78.hh" -#include "G4RK547FEq1.hh" -#include "G4RK547FEq2.hh" -#include "G4RK547FEq3.hh" -#include "G4RKG3_Stepper.hh" -#include "G4TsitourasRK45.hh" + // CLHEP includes #include "CLHEP/Units/SystemOfUnits.h" @@ -120,18 +109,6 @@ G4FieldManagerToolBase::getStepper(std::string name, G4MagneticField* field) con else if (name=="NystromRK4") return new G4NystromRK4(eqRhs); else if (name=="ClassicalRK4") return new G4ClassicalRK4(eqRhs); else if (name=="AtlasRK4") return new G4AtlasRK4(eqRhs); - else if (name=="BogackiShampine23") return new G4BogackiShampine23(eqRhs); - else if (name=="BogackiShampine45") return new G4BogackiShampine45(eqRhs); - else if (name=="CashKarpRKF45") return new G4CashKarpRKF45(eqRhs); - else if (name=="DoLoMcPriRK34") return new G4DoLoMcPriRK34(eqRhs); - else if (name=="DormandPrince745") return new G4DormandPrince745(eqRhs); - else if (name=="DormandPrinceRK56") return new G4DormandPrinceRK56(eqRhs); - else if (name=="DormandPrinceRK78") return new G4DormandPrinceRK78(eqRhs); - else if (name=="RK547FEq1") return new G4RK547FEq1(eqRhs); - else if (name=="RK547FEq2") return new G4RK547FEq2(eqRhs); - else if (name=="RK547FEq3") return new G4RK547FEq3(eqRhs); - else if (name=="RKG3_Stepper") return new G4RKG3_Stepper(eqRhs); - else if (name=="TsitourasRK45") return new G4TsitourasRK45(eqRhs); else { ATH_MSG_ERROR("Stepper " << name << " not available! returning NystromRK4!"); return new G4NystromRK4(eqRhs);