diff --git a/Inputs/DetectorConfiguration/gaspardTestSpheric.detector b/Inputs/DetectorConfiguration/gaspardTestSpheric.detector
new file mode 100644
index 0000000000000000000000000000000000000000..d91b0f62dd3a046226ce8e4998cb115f59d2b51c
--- /dev/null
+++ b/Inputs/DetectorConfiguration/gaspardTestSpheric.detector
@@ -0,0 +1,146 @@
+%Fichier de configuration manip E225
+%%%%%%%%%%%Target%%%%%%%%%%%%%%%%%%%1
+%Thickness in micrometer
+%Radius in mm
+%Temperature in K, Pressure in bar
+%Material name according to the target library
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+GeneralTarget
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Target
+ THICKNESS= 1
+ RADIUS= 45
+ MATERIAL= CD2
+ X= 0
+ Y= 0
+ Z= 0
+%%%%%%%%%%Detector%%%%%%%%%%%%%%%%%%%
+%%Position and R given in mm
+%%Angle given in degree
+%%Option: 0,1 for Si SiLi and CsI
+%%Option: all or sensible for VISualisation
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+GaspardTracker
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%1
+GPDDummyShape
+ THETA= 0
+ PHI= 0
+ R= 100
+ BETA= 0 -0 -0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%2
+GPDDummyShape
+ THETA= 30
+ PHI= 0
+ R= 100
+ BETA= 0 -0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%3
+GPDDummyShape
+ THETA= 60
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%4
+GPDDummyShape
+ THETA= 90
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5
+GPDDummyShape
+ THETA= 120
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%6
+GPDDummyShape
+ THETA= 150
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%7
+GPDDummyShape
+ THETA= 180
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%8
+GPDDummyShape
+ THETA= -30
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%9
+GPDDummyShape
+ THETA= -60
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%10
+GPDDummyShape
+ THETA= -90
+ PHI= 0
+ R= 100
+ BETA= 0 -0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%11
+GPDDummyShape
+ THETA= -120
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%12
+GPDDummyShape
+ THETA= -150
+ PHI= 0
+ R= 100
+ BETA= 0 0 0
+ FIRSTSTAGE= 1
+ SECONDSTAGE= 1
+ THIRDSTAGE= 1
+ VIS= all
+
diff --git a/Inputs/Reaction/60Fe.reaction b/Inputs/Reaction/60Fe.reaction
index 08f034ccd0ef305144af5b2316b641ab0179c0fb..24ad16495a31473e7834bce73a9580995111e626 100644
--- a/Inputs/Reaction/60Fe.reaction
+++ b/Inputs/Reaction/60Fe.reaction
@@ -16,6 +16,6 @@ Transfert
BeamEmmitancePhi= 0.01
CrossSectionPath= ni69_g7_01.n
ShootLight= 1
- ShootHeavy= 1
+ ShootHeavy= 0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/NPAnalysis/Gaspard/Result/myResult.root b/NPAnalysis/Gaspard/Result/myResult.root
index 0755f976467bb0675c74645bbfe2ac7fe6cf7dcf..a365f49d0df5471e69c5967e89c2ee1d42372d56 100644
Binary files a/NPAnalysis/Gaspard/Result/myResult.root and b/NPAnalysis/Gaspard/Result/myResult.root differ
diff --git a/NPAnalysis/Gaspard/src/ConfigurationReader.cc b/NPAnalysis/Gaspard/src/ConfigurationReader.cc
index 2d50b31816a3057daf03a3e6557a32e341e5471a..827855f119ecf7c4073a5b1e828cfcf7d4fe3184 100644
--- a/NPAnalysis/Gaspard/src/ConfigurationReader.cc
+++ b/NPAnalysis/Gaspard/src/ConfigurationReader.cc
@@ -52,7 +52,7 @@ void ReadConfiguration( string Path , array* myArray)
if(LineBuffer.compare(0,1,"%")==0) {;}
//Search for Telescope
- else if(LineBuffer.compare(0,9,"GPDSquare")==0)
+ else if(LineBuffer.compare(0,9,"GPDSquare")==0 || LineBuffer.compare(0,13,"GPDDummyShape")==0)
{
//A MUST2 Telescope is detected:
diff --git a/NPSimulation/include/GaspardScorers.hh b/NPSimulation/include/GaspardScorers.hh
index 27ed2083442c5d823ac1b0b7188d4930f3459343..2a4bc972b20b5e4960da250c4d4a0030b71274fc 100644
--- a/NPSimulation/include/GaspardScorers.hh
+++ b/NPSimulation/include/GaspardScorers.hh
@@ -121,6 +121,56 @@ private:
+class GPDScorerFirstStageFrontStripDummyShape : public G4VPrimitiveScorer
+{
+public: // with description
+ GPDScorerFirstStageFrontStripDummyShape(G4String name, G4int depth = 0, G4double StripPlaneSize = 98, G4int NumberOfStrip = 128);
+ virtual ~GPDScorerFirstStageFrontStripDummyShape();
+
+protected: // with description
+ virtual G4bool ProcessHits(G4Step*, G4TouchableHistory*);
+
+public:
+ virtual void Initialize(G4HCofThisEvent*);
+ virtual void EndOfEvent(G4HCofThisEvent*);
+ virtual void Clear();
+ virtual void DrawAll();
+ virtual void PrintAll();
+
+private:
+ G4double m_StripPlaneSize;
+ G4int m_NumberOfStrip ;
+ G4int HCID;
+ G4THitsMap<G4double>* EvtMap;
+};
+
+
+
+class GPDScorerFirstStageBackStripDummyShape : public G4VPrimitiveScorer
+{
+public: // with description
+ GPDScorerFirstStageBackStripDummyShape(G4String name, G4int depth = 0, G4double StripPlaneSize = 98, G4int NumberOfStrip = 128);
+ virtual ~GPDScorerFirstStageBackStripDummyShape();
+
+protected: // with description
+ virtual G4bool ProcessHits(G4Step*, G4TouchableHistory*);
+
+public:
+ virtual void Initialize(G4HCofThisEvent*);
+ virtual void EndOfEvent(G4HCofThisEvent*);
+ virtual void Clear();
+ virtual void DrawAll();
+ virtual void PrintAll();
+
+private:
+ G4double m_StripPlaneSize;
+ G4int m_NumberOfStrip ;
+ G4int HCID;
+ G4THitsMap<G4double>* EvtMap;
+};
+
+
+
class GPDScorerFirstStageFrontStripSquare : public G4VPrimitiveScorer
{
public: // with description
diff --git a/NPSimulation/include/GaspardTrackerDummyShape.hh b/NPSimulation/include/GaspardTrackerDummyShape.hh
new file mode 100644
index 0000000000000000000000000000000000000000..3d2bb067380c0b299eebe35f2f715b90937cc0d4
--- /dev/null
+++ b/NPSimulation/include/GaspardTrackerDummyShape.hh
@@ -0,0 +1,183 @@
+/*****************************************************************************
+ * Copyright (C) 2009 this file is part of the NPTool Project *
+ * *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence *
+ * For the list of contributors see $NPTOOL/Licence/Contributors *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville contact address: deserevi@ipno.in2p3.fr *
+ * *
+ * Creation Date : 03/09/09 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: Define a dummy module for the Gaspard tracker *
+ * The goal of this class is to be a starting point to create a *
+ * new shape to be added to the Gaspard tracker. *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+#ifndef GaspardTrackerDummyShape_h
+#define GaspardTrackerDummyShape_h 1
+
+// C++ headers
+#include <vector>
+
+// NPTool header
+#include "GaspardTrackerModule.hh"
+#include "TInteractionCoordinates.h"
+
+using namespace std;
+
+#define INDEX 1000
+
+
+class GaspardTrackerDummyShape : public GaspardTrackerModule
+{
+ ////////////////////////////////////////////////////
+ /////// Default Constructor and Destructor /////////
+ ////////////////////////////////////////////////////
+public:
+ GaspardTrackerDummyShape();
+ virtual ~GaspardTrackerDummyShape();
+
+ ////////////////////////////////////////////////////
+ //////// Specific Function of this Class ///////////
+ ////////////////////////////////////////////////////
+public:
+ // By Position Method
+ void AddModule(G4ThreeVector TL ,
+ G4ThreeVector BL ,
+ G4ThreeVector BR ,
+ G4ThreeVector CT ,
+ bool wFirstStage ,
+ bool wSecondStage ,
+ bool wThirdStage);
+
+ // By Angle Method
+ void AddModule(G4double R ,
+ G4double Theta ,
+ G4double Phi ,
+ G4double beta_u ,
+ G4double beta_v ,
+ G4double beta_w ,
+ bool wFirstStage ,
+ bool wSecondStage ,
+ bool wThirdStage);
+
+ // Effectively construct Volume
+ // Avoid to have two time same code for Angle and Point definition
+ void VolumeMaker(G4int TelescopeNumber ,
+ G4ThreeVector MMpos ,
+ G4RotationMatrix* MMrot ,
+ bool wFirstStage ,
+ bool wSecondStage ,
+ bool wThirdStage ,
+ G4LogicalVolume* world);
+
+
+ ////////////////////////////////////////////////////
+ //// Inherite from GaspardTrackerModule class /////
+ ////////////////////////////////////////////////////
+public:
+ // Read stream at Configfile to pick-up parameters of detector (Position,...)
+ // Called in DetecorConstruction::ReadDetextorConfiguration Method
+ void ReadConfiguration(string Path);
+
+ // Construct detector and inialise sensitive part.
+ // Called After DetecorConstruction::AddDetector Method
+ void ConstructDetector(G4LogicalVolume* world);
+
+ // Add Detector branch to the EventTree.
+ // Called After DetecorConstruction::AddDetector Method
+ void InitializeRootOutput();
+
+ // Initialize all scorers necessary for the detector
+ void InitializeScorers();
+
+ // Read sensitive part and fill the Root tree.
+ // Called at in the EventAction::EndOfEventAvtion
+ void ReadSensitive(const G4Event* event);
+
+ // Give the static TInteractionCoordinates from VDetector to the classes
+ // deriving from GaspardTrackerModule
+ // This is mandatory since the GaspardTracker*** does not derive from VDetector
+ void SetInterCoordPointer(TInteractionCoordinates* interCoord);
+ TInteractionCoordinates* GetInterCoordPointer() {return ms_InterCoord;};
+
+
+ ////////////////////////////////////////////////////
+ ///////////////Private intern Data//////////////////
+ ////////////////////////////////////////////////////
+private:
+ // Interaction Coordinates coming from VDetector through the
+ // SetInteractionCoordinatesPointer method
+ TInteractionCoordinates* ms_InterCoord;
+
+ // True if Define by Position, False is Define by angle
+ vector<bool> m_DefinitionType ;
+
+ // Used for "By Point Definition"
+ vector<G4ThreeVector> m_X1_Y1 ; // Top Left Corner Position Vector
+ vector<G4ThreeVector> m_X1_Y128 ; // Bottom Left Corner Position Vector
+ vector<G4ThreeVector> m_X128_Y1 ; // Bottom Right Corner Position Vector
+ vector<G4ThreeVector> m_X128_Y128 ; // Center Corner Position Vector
+
+ // Used for "By Angle Definition"
+ vector<G4double> m_R ; // |
+ vector<G4double> m_Theta ; // > Spherical coordinate of Strips Silicium Plate
+ vector<G4double> m_Phi ; // |
+
+ vector<G4double> m_beta_u ; // |
+ vector<G4double> m_beta_v ; // > Tilt angle of the Telescope
+ vector<G4double> m_beta_w ; // |
+
+ // for debugging purpose
+ G4ThreeVector MMpos;
+ G4ThreeVector MMu;
+ G4ThreeVector MMv;
+ G4ThreeVector MMw;
+ G4ThreeVector CT;
+};
+
+
+
+namespace GPDDUMMYSHAPE
+{
+ // Resolution
+ const G4double ResoFirstStage = 0 ;// = 52keV of Resolution // Unit is MeV/2.35
+// const G4double ResoFirstStage = 0.022 ;// = 52keV of Resolution // Unit is MeV/2.35
+ const G4double ResoSecondStage = 0.055 ;// = 130 keV of resolution // Unit is MeV/2.35
+ const G4double ResoThirdStage = 0 ;// = 100 keV of resolution // Unit is MeV/2.35
+// const G4double ResoThirdStage = 0.043 ;// = 100 kev of resolution // Unit is MeV/2.35
+ const G4double ResoTimeGpd = 0.212765957 ;// = 500ps // Unit is ns/2.35
+
+ // Geometry for the mother volume containing the different layers of your dummy shape module
+ const G4double FaceFront = 5.1*cm;
+ const G4double FaceBack = 5.1*cm;
+ const G4double Length = 3.0*cm;
+ const G4double InterStageDistance = 5*mm;
+
+ // First stage
+ const G4double FirstStageFace = 5.0*cm;
+ const G4double FirstStageThickness = 300*micrometer ;
+
+ // Second stage
+ const G4double SecondStageFace = FirstStageFace;
+ const G4double SecondStageThickness = 1*mm;
+
+ // Third stage
+ const G4double ThirdStageFace = FirstStageFace;
+ const G4double ThirdStageThickness = 1*mm;
+
+ // Starting at the front of the first stage and going to the third stage
+ const G4double FirstStage_PosZ = Length* -0.5 + 0.5*FirstStageThickness;
+ const G4double SecondStage_PosZ = Length* -0.5 + 0.5*SecondStageThickness + 1*InterStageDistance;
+ const G4double ThirdStage_PosZ = Length* -0.5 + 0.5*ThirdStageThickness + 2*InterStageDistance;
+}
+
+#endif
diff --git a/NPSimulation/src/GaspardScorers.cc b/NPSimulation/src/GaspardScorers.cc
index 2df19e9a11e4112a2c4c61e615d11cb6b327a97c..156ccf9fa27c6d72a89b16dafb42937283404e8d 100644
--- a/NPSimulation/src/GaspardScorers.cc
+++ b/NPSimulation/src/GaspardScorers.cc
@@ -22,12 +22,14 @@
#include "GaspardScorers.hh"
#include "G4UnitsTable.hh"
+#include "GaspardTrackerDummyShape.hh"
#include "GaspardTrackerSquare.hh"
#include "GaspardTrackerTrapezoid.hh"
#include "GaspardTrackerAnnular.hh"
using namespace GPDSQUARE;
using namespace GPDTRAP;
using namespace GPDANNULAR;
+using namespace GPDDUMMYSHAPE;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -284,6 +286,130 @@ void GPDScorerDetectorNumber::PrintAll()
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// FirstStage Front Strip position Scorer for DummyShape geometry
+GPDScorerFirstStageFrontStripDummyShape::GPDScorerFirstStageFrontStripDummyShape(G4String name, G4int depth, G4double StripPlaneSize, G4int NumberOfStrip)
+ : G4VPrimitiveScorer(name, depth), HCID(-1)
+{
+ m_StripPlaneSize = StripPlaneSize ;
+ m_NumberOfStrip = NumberOfStrip ;
+}
+
+GPDScorerFirstStageFrontStripDummyShape::~GPDScorerFirstStageFrontStripDummyShape()
+{
+}
+
+G4bool GPDScorerFirstStageFrontStripDummyShape::ProcessHits(G4Step* aStep, G4TouchableHistory*)
+{
+ G4ThreeVector POS = aStep->GetPreStepPoint()->GetPosition();
+ POS = aStep->GetPreStepPoint()->GetTouchableHandle()->GetHistory()->GetTopTransform().TransformPoint(POS);
+
+ G4double StripPitch = m_StripPlaneSize / m_NumberOfStrip;
+
+ G4double temp = (POS(0) + m_StripPlaneSize / 2.) / StripPitch ;
+ G4double X = int(temp) + 1 ;
+ //Rare case where particle is close to edge of silicon plan
+ if (X == 129) X = 128;
+ G4double edep = aStep->GetTotalEnergyDeposit();
+ if (edep < 100*keV) return FALSE;
+ G4int index = aStep->GetTrack()->GetTrackID();
+ EvtMap->set(index, X);
+ return TRUE;
+}
+
+void GPDScorerFirstStageFrontStripDummyShape::Initialize(G4HCofThisEvent* HCE)
+{
+ EvtMap = new G4THitsMap<G4double>(GetMultiFunctionalDetector()->GetName(), GetName());
+ if (HCID < 0) {
+ HCID = GetCollectionID(0);
+ }
+ HCE->AddHitsCollection(HCID, (G4VHitsCollection*)EvtMap);
+}
+
+void GPDScorerFirstStageFrontStripDummyShape::EndOfEvent(G4HCofThisEvent*)
+{
+}
+
+void GPDScorerFirstStageFrontStripDummyShape::Clear()
+{
+ EvtMap->clear();
+}
+
+void GPDScorerFirstStageFrontStripDummyShape::DrawAll()
+{
+}
+
+void GPDScorerFirstStageFrontStripDummyShape::PrintAll()
+{
+ G4cout << " MultiFunctionalDet " << detector->GetName() << G4endl ;
+ G4cout << " PrimitiveScorer " << GetName() << G4endl ;
+ G4cout << " Number of entries " << EvtMap->entries() << G4endl ;
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// FirstStage Back Strip position Scorer for DummyShape geometry
+GPDScorerFirstStageBackStripDummyShape::GPDScorerFirstStageBackStripDummyShape(G4String name, G4int depth, G4double StripPlaneSize, G4int NumberOfStrip)
+ : G4VPrimitiveScorer(name, depth), HCID(-1)
+{
+ m_StripPlaneSize = StripPlaneSize ;
+ m_NumberOfStrip = NumberOfStrip ;
+}
+
+GPDScorerFirstStageBackStripDummyShape::~GPDScorerFirstStageBackStripDummyShape()
+{
+}
+
+G4bool GPDScorerFirstStageBackStripDummyShape::ProcessHits(G4Step* aStep, G4TouchableHistory*)
+{
+ G4ThreeVector POS = aStep->GetPreStepPoint()->GetPosition();
+ POS = aStep->GetPreStepPoint()->GetTouchableHandle()->GetHistory()->GetTopTransform().TransformPoint(POS);
+
+ G4double StripPitch = m_StripPlaneSize / m_NumberOfStrip;
+
+ G4double temp = (POS(0) + m_StripPlaneSize / 2.) / StripPitch ;
+ G4double X = int(temp) + 1 ;
+ //Rare case where particle is close to edge of silicon plan
+ if (X == 129) X = 128;
+ G4double edep = aStep->GetTotalEnergyDeposit();
+ if (edep < 100*keV) return FALSE;
+ G4int index = aStep->GetTrack()->GetTrackID();
+ EvtMap->set(index, X);
+ return TRUE;
+}
+
+void GPDScorerFirstStageBackStripDummyShape::Initialize(G4HCofThisEvent* HCE)
+{
+ EvtMap = new G4THitsMap<G4double>(GetMultiFunctionalDetector()->GetName(), GetName());
+ if (HCID < 0) {
+ HCID = GetCollectionID(0);
+ }
+ HCE->AddHitsCollection(HCID, (G4VHitsCollection*)EvtMap);
+}
+
+void GPDScorerFirstStageBackStripDummyShape::EndOfEvent(G4HCofThisEvent*)
+{
+}
+
+void GPDScorerFirstStageBackStripDummyShape::Clear()
+{
+ EvtMap->clear();
+}
+
+void GPDScorerFirstStageBackStripDummyShape::DrawAll()
+{
+}
+
+void GPDScorerFirstStageBackStripDummyShape::PrintAll()
+{
+ G4cout << " MultiFunctionalDet " << detector->GetName() << G4endl ;
+ G4cout << " PrimitiveScorer " << GetName() << G4endl ;
+ G4cout << " Number of entries " << EvtMap->entries() << G4endl ;
+}
+
+
+
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// FirstStage Front Strip position Scorer for Square geometry
GPDScorerFirstStageFrontStripSquare::GPDScorerFirstStageFrontStripSquare(G4String name, G4int depth, G4double StripPlaneSize, G4int NumberOfStrip)
diff --git a/NPSimulation/src/GaspardTracker.cc b/NPSimulation/src/GaspardTracker.cc
index bc2baf42d952eed8036512be77a82989b602c77c..c822520055818fe99167a955f3ad8c184284ae8e 100644
--- a/NPSimulation/src/GaspardTracker.cc
+++ b/NPSimulation/src/GaspardTracker.cc
@@ -31,6 +31,7 @@
#include "GaspardTrackerSquare.hh"
#include "GaspardTrackerTrapezoid.hh"
#include "GaspardTrackerAnnular.hh"
+#include "GaspardTrackerDummyShape.hh"
using namespace std;
@@ -55,10 +56,10 @@ void GaspardTracker::ReadConfiguration(string Path)
ifstream ConfigFile;
ConfigFile.open(Path.c_str());
- bool GPDTrkSquare = false;
- bool GPDTrkTrapezoid = false;
- bool GPDTrkAnnular = false;
- bool GPDTrkShape = false;
+ bool GPDTrkSquare = false;
+ bool GPDTrkTrapezoid = false;
+ bool GPDTrkAnnular = false;
+ bool GPDTrkDummyShape = false;
string LineBuffer;
while (!ConfigFile.eof()) {
@@ -114,13 +115,13 @@ void GaspardTracker::ReadConfiguration(string Path)
// store GaspardTrackerTrapezoid "detector"
m_Modules.push_back(myDetector);
}
- else if (LineBuffer.compare(0, 12, "GPDShape") == 0 && GPDTrkShape == false) {
- GPDTrkShape = true;
+ else if (LineBuffer.compare(0, 13, "GPDDummyShape") == 0 && GPDTrkDummyShape == false) {
+ GPDTrkDummyShape = true;
// instantiate a new "detector" corresponding to the Shape elements
// The GaspardTrackerSquare class should be replaced by the
// GaspardTrackerShape class you need to define
- GaspardTrackerModule* myDetector = new GaspardTrackerSquare();
+ GaspardTrackerModule* myDetector = new GaspardTrackerDummyShape();
// read part of the configuration file corresponding to shape elements
ConfigFile.close();
diff --git a/NPSimulation/src/GaspardTrackerDummyShape.cc b/NPSimulation/src/GaspardTrackerDummyShape.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b533d50394b547dc60ae28b6649b1aa0547ca1c2
--- /dev/null
+++ b/NPSimulation/src/GaspardTrackerDummyShape.cc
@@ -0,0 +1,1007 @@
+/*****************************************************************************
+ * Copyright (C) 2009 this file is part of the NPTool Project *
+ * *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence *
+ * For the list of contributors see $NPTOOL/Licence/Contributors *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville contact address: deserevi@ipno.in2p3.fr *
+ * *
+ * Creation Date : 03/09/09 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: Define a dummy module for the Gaspard tracker *
+ * The goal of this class is to be a starting point to create a *
+ * new shape to be added to the Gaspard tracker. *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// C++ headers
+#include <sstream>
+#include <string>
+#include <cmath>
+
+// G4 Geometry headers
+#include "G4Trd.hh"
+#include "G4Box.hh"
+#include "G4Trap.hh"
+
+// G4 various headers
+#include "G4MaterialTable.hh"
+#include "G4Element.hh"
+#include "G4ElementTable.hh"
+#include "G4VisAttributes.hh"
+#include "G4Colour.hh"
+#include "G4RotationMatrix.hh"
+#include "G4Transform3D.hh"
+#include "G4PVPlacement.hh"
+#include "G4PVDivision.hh"
+
+// G4 sensitive
+#include "G4SDManager.hh"
+#include "G4MultiFunctionalDetector.hh"
+
+// NPTool headers
+#include "GaspardTrackerDummyShape.hh"
+#include "GeneralScorers.hh"
+#include "GaspardScorers.hh"
+#include "RootOutput.h"
+#include "MUST2Array.hh"
+
+// CLHEP
+#include "CLHEP/Random/RandGauss.h"
+
+using namespace std;
+using namespace CLHEP;
+using namespace GPDDUMMYSHAPE;
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+GaspardTrackerDummyShape::GaspardTrackerDummyShape()
+{
+ ms_InterCoord = 0;
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+GaspardTrackerDummyShape::~GaspardTrackerDummyShape()
+{
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void GaspardTrackerDummyShape::AddModule(G4ThreeVector X1_Y1 ,
+ G4ThreeVector X128_Y1 ,
+ G4ThreeVector X1_Y128 ,
+ G4ThreeVector X128_Y128 ,
+ bool wFirstStage ,
+ bool wSecondStage ,
+ bool wThirdStage)
+{
+ m_DefinitionType.push_back(true) ;
+
+ m_X1_Y1.push_back(X1_Y1) ;
+ m_X128_Y1.push_back(X128_Y1) ;
+ m_X1_Y128.push_back(X1_Y128) ;
+ m_X128_Y128.push_back(X128_Y128) ;
+ m_wFirstStage.push_back(wFirstStage) ;
+ m_wSecondStage.push_back(wSecondStage) ;
+ m_wThirdStage.push_back(wThirdStage) ;
+
+ m_R.push_back(0) ;
+ m_Theta.push_back(0) ;
+ m_Phi.push_back(0) ;
+ m_beta_u.push_back(0) ;
+ m_beta_v.push_back(0) ;
+ m_beta_w.push_back(0) ;
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void GaspardTrackerDummyShape::AddModule(G4double R ,
+ G4double Theta ,
+ G4double Phi ,
+ G4double beta_u ,
+ G4double beta_v ,
+ G4double beta_w ,
+ bool wFirstStage ,
+ bool wSecondStage ,
+ bool wThirdStage)
+{
+ G4ThreeVector empty = G4ThreeVector(0, 0, 0);
+
+ m_DefinitionType.push_back(false);
+
+ m_R.push_back(R) ;
+ m_Theta.push_back(Theta) ;
+ m_Phi.push_back(Phi) ;
+ m_beta_u.push_back(beta_u) ;
+ m_beta_v.push_back(beta_v) ;
+ m_beta_w.push_back(beta_w) ;
+ m_wFirstStage.push_back(wFirstStage) ;
+ m_wSecondStage.push_back(wSecondStage) ;
+ m_wThirdStage.push_back(wThirdStage) ;
+
+ m_X1_Y1.push_back(empty) ;
+ m_X128_Y1.push_back(empty) ;
+ m_X1_Y128.push_back(empty) ;
+ m_X128_Y128.push_back(empty) ;
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void GaspardTrackerDummyShape::VolumeMaker(G4int TelescopeNumber,
+ G4ThreeVector MMpos,
+ G4RotationMatrix* MMrot,
+ bool wFirstStage,
+ bool wSecondStage,
+ bool wThirdStage,
+ G4LogicalVolume* world)
+{
+ G4double NbrTelescopes = TelescopeNumber ;
+ G4String DetectorNumber ;
+ ostringstream Number ;
+ Number << NbrTelescopes ;
+ DetectorNumber = Number.str() ;
+
+ /////////////////////////////////////////////////////////////////
+ /////////////////Element Definition ///////////////////////////
+ ////////////////////////////////////////////////////////////////
+ G4String symbol;
+ G4double density = 0. , a = 0, z = 0;
+ G4int ncomponents = 0;
+
+ ////////////////////////////////////////////////////////////////
+ /////////////////Material Definition ///////////////////////////
+ ////////////////////////////////////////////////////////////////
+ // Si
+ a = 28.0855 * g / mole;
+ density = 2.321 * g / cm3;
+ G4Material* Silicon = new G4Material("Si", z = 14., a, density);
+
+ // Vacuum
+ G4Element* N = new G4Element("Nitrogen" , symbol = "N" , z = 7 , a = 14.01 * g / mole);
+ G4Element* O = new G4Element("Oxigen" , symbol = "O" , z = 8 , a = 16.00 * g / mole);
+
+ density = 0.000000001 * mg / cm3;
+ G4Material* Vacuum = new G4Material("Vacuum", density, ncomponents = 2);
+ Vacuum->AddElement(N, .7);
+ Vacuum->AddElement(O, .3);
+
+ ////////////////////////////////////////////////////////////////
+ ////////////// Starting Volume Definition //////////////////////
+ ////////////////////////////////////////////////////////////////
+ // Little trick to avoid warning in compilation: Use a PVPlacement "buffer".
+ // If don't you will have a Warning unused variable 'myPVP'
+ G4PVPlacement* PVPBuffer;
+ G4String Name = "GPDDummyShape" + DetectorNumber ;
+
+ G4Box* solidGPDDummyShape = new G4Box(Name, 0.5*FaceFront, 0.5*FaceFront, 0.5*Length);
+ G4LogicalVolume* logicGPDDummyShape = new G4LogicalVolume(solidGPDDummyShape, Vacuum, Name, 0, 0, 0);
+
+ PVPBuffer = new G4PVPlacement(G4Transform3D(*MMrot, MMpos) ,
+ logicGPDDummyShape ,
+ Name ,
+ world ,
+ false ,
+ 0);
+
+ logicGPDDummyShape->SetVisAttributes(G4VisAttributes::Invisible);
+ if (m_non_sensitive_part_visiualisation) logicGPDDummyShape->SetVisAttributes(G4VisAttributes(G4Colour(0.90, 0.90, 0.90)));
+
+ //Place two marker to identify the u and v axis on silicon face:
+ //marker are placed a bit before the silicon itself so they don't perturbate simulation
+ //Uncomment to help debugging or if you want to understand the way the code work.
+ //I should recommand to Comment it during simulation to avoid perturbation of simulation
+ //Remember G4 is limitationg step on geometry constraints.
+ /*
+ G4ThreeVector positionMarkerU = CT*0.98 + MMu*SiliconFace/4;
+ G4Box* solidMarkerU = new G4Box( "solidMarkerU" , SiliconFace/4 , 1*mm , 1*mm ) ;
+ G4LogicalVolume* logicMarkerU = new G4LogicalVolume( solidMarkerU , Vacuum , "logicMarkerU",0,0,0) ;
+ PVPBuffer = new G4PVPlacement(G4Transform3D(*MMrot,positionMarkerU),logicMarkerU,"MarkerU",world,false,0) ;
+
+ G4VisAttributes* MarkerUVisAtt= new G4VisAttributes(G4Colour(0.,0.,0.5));//blue
+ logicMarkerU->SetVisAttributes(MarkerUVisAtt);
+
+ G4ThreeVector positionMarkerV = CT*0.98 + MMv*SiliconFace/4;
+ G4Box* solidMarkerV = new G4Box( "solidMarkerU" , 1*mm , SiliconFace/4 , 1*mm ) ;
+ G4LogicalVolume* logicMarkerV = new G4LogicalVolume( solidMarkerV , Vacuum , "logicMarkerV",0,0,0) ;
+ PVPBuffer = new G4PVPlacement(G4Transform3D(*MMrot,positionMarkerV),logicMarkerV,"MarkerV",world,false,0) ;
+
+ G4VisAttributes* MarkerVVisAtt= new G4VisAttributes(G4Colour(0.,0.5,0.5));//green
+ logicMarkerV->SetVisAttributes(MarkerVVisAtt);
+ */
+
+ ////////////////////////////////////////////////////////////////
+ ///////////////// First Stage Construction /////////////////////
+ ////////////////////////////////////////////////////////////////
+ if (wFirstStage) {
+ // Silicon detector itself
+ G4ThreeVector positionFirstStage = G4ThreeVector(0, 0, FirstStage_PosZ);
+
+ G4Box* solidFirstStage = new G4Box("solidFirstStage", 0.5*FirstStageFace, 0.5*FirstStageFace, 0.5*FirstStageThickness);
+ G4LogicalVolume* logicFirstStage = new G4LogicalVolume(solidFirstStage, Silicon, "logicFirstStage", 0, 0, 0);
+
+ PVPBuffer = new G4PVPlacement(0,
+ positionFirstStage,
+ logicFirstStage,
+ "G" + DetectorNumber + "FirstStage",
+ logicGPDDummyShape,
+ false,
+ 0);
+
+ // Set First Stage sensible
+ logicFirstStage->SetSensitiveDetector(m_FirstStageScorer);
+
+ ///Visualisation of FirstStage Strip
+ G4VisAttributes* FirstStageVisAtt = new G4VisAttributes(G4Colour(0.2, 0.2, 0.2));
+ logicFirstStage->SetVisAttributes(FirstStageVisAtt);
+ }
+
+ ////////////////////////////////////////////////////////////////
+ //////////////////// Second Stage Construction ////////////////
+ ////////////////////////////////////////////////////////////////
+ if (wSecondStage) {
+ // Silicon detector itself
+ G4ThreeVector positionSecondStage = G4ThreeVector(0, 0, SecondStage_PosZ);
+
+ G4Box* solidSecondStage = new G4Box("solidSecondStage", 0.5*SecondStageFace, 0.5*SecondStageFace, 0.5*SecondStageThickness);
+ G4LogicalVolume* logicSecondStage = new G4LogicalVolume(solidSecondStage, Silicon, "logicSecondStage", 0, 0, 0);
+
+ PVPBuffer = new G4PVPlacement(0,
+ positionSecondStage,
+ logicSecondStage,
+ "G" + DetectorNumber + "SecondStage",
+ logicGPDDummyShape,
+ false,
+ 0);
+
+ // Set Second Stage sensible
+ logicSecondStage->SetSensitiveDetector(m_SecondStageScorer);
+
+ ///Visualisation of SecondStage Strip
+ G4VisAttributes* SecondStageVisAtt = new G4VisAttributes(G4Colour(0.5, 0.5, 0.5)) ;
+ logicSecondStage->SetVisAttributes(SecondStageVisAtt) ;
+ }
+
+ ////////////////////////////////////////////////////////////////
+ ///////////////// Third Stage Construction /////////////////////
+ ////////////////////////////////////////////////////////////////
+ if (wThirdStage) {
+ // Third stage silicon detector
+ G4ThreeVector positionThirdStage = G4ThreeVector(0, 0, ThirdStage_PosZ);
+
+ G4Box* solidThirdStage = new G4Box("solidThirdStage", 0.5*ThirdStageFace, 0.5*ThirdStageFace, 0.5*ThirdStageThickness);
+ G4LogicalVolume* logicThirdStage = new G4LogicalVolume(solidThirdStage, Silicon, "logicThirdStage", 0, 0, 0);
+
+ PVPBuffer = new G4PVPlacement(0,
+ positionThirdStage,
+ logicThirdStage,
+ "G" + DetectorNumber + "ThirdStage",
+ logicGPDDummyShape,
+ false,
+ 0);
+
+ // Set Third Stage sensible
+ logicThirdStage->SetSensitiveDetector(m_ThirdStageScorer);
+
+ ///Visualisation of Third Stage
+ G4VisAttributes* ThirdStageVisAtt = new G4VisAttributes(G4Colour(0.7, 0.7, 0.7));
+ logicThirdStage->SetVisAttributes(ThirdStageVisAtt);
+ }
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Virtual Method of VDetector class
+
+// Read stream at Configfile to pick-up parameters of detector (Position,...)
+// Called in DetecorConstruction::ReadDetextorConfiguration Method
+void GaspardTrackerDummyShape::ReadConfiguration(string Path)
+{
+ ifstream ConfigFile ;
+ ConfigFile.open(Path.c_str()) ;
+ string LineBuffer ;
+ string DataBuffer ;
+
+ // A:X1_Y1 --> X:1 Y:1
+ // B:X128_Y1 --> X:128 Y:1
+ // C:X1_Y128 --> X:1 Y:128
+ // D:X128_Y128 --> X:128 Y:128
+
+ G4double Ax , Bx , Cx , Dx , Ay , By , Cy , Dy , Az , Bz , Cz , Dz ;
+ G4ThreeVector A , B , C , D ;
+ G4double Theta = 0 , Phi = 0 , R = 0 , beta_u = 0 , beta_v = 0 , beta_w = 0 ;
+ int FIRSTSTAGE = 0 , SECONDSTAGE = 0 , THIRDSTAGE = 0 ;
+
+ bool ReadingStatus = false ;
+
+ bool check_A = false ;
+ bool check_C = false ;
+ bool check_B = false ;
+ bool check_D = false ;
+
+ bool check_Theta = false ;
+ bool check_Phi = false ;
+ bool check_R = false ;
+ bool check_beta = false ;
+
+ bool check_FirstStage = false ;
+ bool check_SecondStage = false ;
+ bool check_ThirdStage = false ;
+ bool checkVis = false ;
+
+ while (!ConfigFile.eof()) {
+ getline(ConfigFile, LineBuffer);
+ if (LineBuffer.compare(0, 13, "GPDDummyShape") == 0) {
+ G4cout << "///" << G4endl ;
+ G4cout << "DummyShape element found: " << G4endl ;
+ ReadingStatus = true ;
+ }
+
+ while(ReadingStatus){
+
+ ConfigFile >> DataBuffer;
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {/*do nothing */;}
+
+ // Position method
+ else if (DataBuffer.compare(0, 6, "X1_Y1=") == 0) {
+ check_A = true;
+ ConfigFile >> DataBuffer ;
+ Ax = atof(DataBuffer.c_str()) ;
+ Ax = Ax * mm ;
+ ConfigFile >> DataBuffer ;
+ Ay = atof(DataBuffer.c_str()) ;
+ Ay = Ay * mm ;
+ ConfigFile >> DataBuffer ;
+ Az = atof(DataBuffer.c_str()) ;
+ Az = Az * mm ;
+
+ A = G4ThreeVector(Ax, Ay, Az);
+ cout << "X1 Y1 corner position : " << A << endl;
+ }
+
+ else if (DataBuffer.compare(0, 8, "X128_Y1=") == 0) {
+ check_B = true;
+ ConfigFile >> DataBuffer ;
+ Bx = atof(DataBuffer.c_str()) ;
+ Bx = Bx * mm ;
+ ConfigFile >> DataBuffer ;
+ By = atof(DataBuffer.c_str()) ;
+ By = By * mm ;
+ ConfigFile >> DataBuffer ;
+ Bz = atof(DataBuffer.c_str()) ;
+ Bz = Bz * mm ;
+
+ B = G4ThreeVector(Bx, By, Bz);
+ cout << "X128 Y1 corner position : " << B << endl;
+ }
+
+ else if (DataBuffer.compare(0, 8, "X1_Y128=") == 0) {
+ check_C = true;
+ ConfigFile >> DataBuffer ;
+ Cx = atof(DataBuffer.c_str()) ;
+ Cx = Cx * mm ;
+ ConfigFile >> DataBuffer ;
+ Cy = atof(DataBuffer.c_str()) ;
+ Cy = Cy * mm ;
+ ConfigFile >> DataBuffer ;
+ Cz = atof(DataBuffer.c_str()) ;
+ Cz = Cz * mm ;
+
+ C = G4ThreeVector(Cx, Cy, Cz);
+ cout << "X1 Y128 corner position : " << C << endl;
+ }
+
+ else if (DataBuffer.compare(0, 10, "X128_Y128=") == 0) {
+ check_D = true;
+ ConfigFile >> DataBuffer ;
+ Dx = atof(DataBuffer.c_str()) ;
+ Dx = Dx * mm ;
+ ConfigFile >> DataBuffer ;
+ Dy = atof(DataBuffer.c_str()) ;
+ Dy = Dy * mm ;
+ ConfigFile >> DataBuffer ;
+ Dz = atof(DataBuffer.c_str()) ;
+ Dz = Dz * mm ;
+
+ D = G4ThreeVector(Dx, Dy, Dz);
+ cout << "X128 Y128 corner position : " << D << endl;
+ }
+
+
+ // Angle method
+ else if (DataBuffer.compare(0, 6, "THETA=") == 0) {
+ check_Theta = true;
+ ConfigFile >> DataBuffer ;
+ Theta = atof(DataBuffer.c_str()) ;
+ Theta = Theta * deg;
+ cout << "Theta: " << Theta / deg << endl;
+ }
+
+ else if (DataBuffer.compare(0, 4, "PHI=") == 0) {
+ check_Phi = true;
+ ConfigFile >> DataBuffer ;
+ Phi = atof(DataBuffer.c_str()) ;
+ Phi = Phi * deg;
+ cout << "Phi: " << Phi / deg << endl;
+ }
+
+ else if (DataBuffer.compare(0, 2, "R=") == 0) {
+ check_R = true;
+ ConfigFile >> DataBuffer ;
+ R = atof(DataBuffer.c_str()) ;
+ R = R * mm;
+ cout << "R: " << R / mm << endl;
+ }
+
+ else if (DataBuffer.compare(0, 5, "BETA=") == 0) {
+ check_beta = true;
+ ConfigFile >> DataBuffer ;
+ beta_u = atof(DataBuffer.c_str()) ;
+ beta_u = beta_u * deg ;
+ ConfigFile >> DataBuffer ;
+ beta_v = atof(DataBuffer.c_str()) ;
+ beta_v = beta_v * deg ;
+ ConfigFile >> DataBuffer ;
+ beta_w = atof(DataBuffer.c_str()) ;
+ beta_w = beta_w * deg ;
+ G4cout << "Beta: " << beta_u / deg << " " << beta_v / deg << " " << beta_w / deg << G4endl ;
+ }
+
+ else if (DataBuffer.compare(0, 11, "FIRSTSTAGE=") == 0) {
+ check_FirstStage = true ;
+ ConfigFile >> DataBuffer;
+ FIRSTSTAGE = atof(DataBuffer.c_str()) ;
+ }
+
+ else if (DataBuffer.compare(0, 12, "SECONDSTAGE=") == 0) {
+ check_SecondStage = true ;
+ ConfigFile >> DataBuffer;
+ SECONDSTAGE = atof(DataBuffer.c_str()) ;
+ }
+
+ else if (DataBuffer.compare(0, 11, "THIRDSTAGE=") == 0) {
+ check_ThirdStage = true ;
+ ConfigFile >> DataBuffer;
+ THIRDSTAGE = atof(DataBuffer.c_str()) ;
+ }
+
+ else if (DataBuffer.compare(0, 4, "VIS=") == 0) {
+ checkVis = true ;
+ ConfigFile >> DataBuffer;
+ if (DataBuffer.compare(0, 3, "all") == 0) m_non_sensitive_part_visiualisation = true;
+ }
+
+ else G4cout << "WARNING: Wrong Token, GaspardTrackerDummyShape: DummyShape Element not added" << G4endl;
+
+ //Add The previously define telescope
+ //With position method
+ if ((check_A && check_B && check_C && check_D && check_FirstStage && check_SecondStage && check_ThirdStage && checkVis) && !(check_Theta && check_Phi && check_R)) {
+
+ ReadingStatus = false ;
+ check_A = false ;
+ check_C = false ;
+ check_B = false ;
+ check_D = false ;
+ check_FirstStage = false ;
+ check_SecondStage = false ;
+ check_ThirdStage = false ;
+ checkVis = false ;
+
+ AddModule(A ,
+ B ,
+ C ,
+ D ,
+ FIRSTSTAGE == 1 ,
+ SECONDSTAGE == 1 ,
+ THIRDSTAGE == 1);
+ }
+
+ //with angle method
+ if ((check_Theta && check_Phi && check_R && check_FirstStage && check_SecondStage && check_ThirdStage && checkVis) && !(check_A && check_B && check_C && check_D)) {
+ ReadingStatus = false ;
+ check_Theta = false ;
+ check_Phi = false ;
+ check_R = false ;
+ check_beta = false ;
+ check_FirstStage = false ;
+ check_SecondStage = false ;
+ check_ThirdStage = false ;
+ checkVis = false ;
+
+ AddModule(R ,
+ Theta ,
+ Phi ,
+ beta_u ,
+ beta_v ,
+ beta_w ,
+ FIRSTSTAGE == 1 ,
+ SECONDSTAGE == 1 ,
+ THIRDSTAGE == 1);
+ }
+
+
+ }
+ }
+}
+
+// Construct detector and inialise sensitive part.
+// Called After DetecorConstruction::AddDetector Method
+void GaspardTrackerDummyShape::ConstructDetector(G4LogicalVolume* world)
+{
+ G4RotationMatrix* MMrot = NULL ;
+/* G4ThreeVector MMpos = G4ThreeVector(0, 0, 0) ;
+ G4ThreeVector MMu = G4ThreeVector(0, 0, 0) ;
+ G4ThreeVector MMv = G4ThreeVector(0, 0, 0) ;
+ G4ThreeVector MMw = G4ThreeVector(0, 0, 0) ;*/
+ MMpos = G4ThreeVector(0, 0, 0) ;
+ MMu = G4ThreeVector(0, 0, 0) ;
+ MMv = G4ThreeVector(0, 0, 0) ;
+ MMw = G4ThreeVector(0, 0, 0) ;
+ G4ThreeVector MMCenter = G4ThreeVector(0, 0, 0) ;
+ bool FirstStage = true ;
+ bool SecondStage = true ;
+ bool ThirdStage = true ;
+
+ G4int NumberOfTelescope = m_DefinitionType.size() ;
+
+ for (G4int i = 0; i < NumberOfTelescope; i++) {
+ // By Point
+ if (m_DefinitionType[i]) {
+ // (u,v,w) unitary vector associated to telescope referencial
+ // (u,v) // to silicon plan
+ // w perpendicular to (u,v) plan and pointing ThirdStage
+ G4cout << "############ Gaspard " << i << " #############" << G4endl;
+ MMu = m_X128_Y1[i] - m_X1_Y1[i] ;
+ G4cout << "MMu: X = " << MMu(0) << " , Y = " << MMu(1) << " , Z = " << MMu(2) << G4endl;
+ MMu = MMu.unit() ;
+ G4cout << "Norm MMu: X = " << MMu(0) << " , Y = " << MMu(1) << " , Z = " << MMu(2) << G4endl;
+
+ MMv = m_X1_Y128[i] - m_X1_Y1[i] ;
+ G4cout << "MMv X = " << MMv(0) << " , Y = " << MMv(1) << " , Z = " << MMv(2) << G4endl;
+ MMv = MMv.unit() ;
+ G4cout << "Norm MMv X = " << MMv(0) << " , Y = " << MMv(1) << " , Z = " << MMv(2) << G4endl;
+
+ G4ThreeVector MMscal = MMu.dot(MMv);
+ G4cout << "Norm MMu.MMv X = " << MMv(0) << " , Y = " << MMv(1) << " , Z = " << MMv(2) << G4endl;
+
+ MMw = MMu.cross(MMv) ;
+// if (MMw.z() > 0) MMw = MMv.cross(MMu) ;
+ MMw = MMw.unit() ;
+
+ MMCenter = (m_X1_Y1[i] + m_X1_Y128[i] + m_X128_Y1[i] + m_X128_Y128[i]) / 4 ;
+
+ // Passage Matrix from Lab Referential to Telescope Referential
+ // MUST2
+ MMrot = new G4RotationMatrix(MMu, MMv, MMw) ;
+ // translation to place Telescope
+ MMpos = MMw * Length * 0.5 + MMCenter ;
+ }
+
+ // By Angle
+ else {
+ G4double Theta = m_Theta[i] ;
+ G4double Phi = m_Phi[i] ;
+ //This part because if Phi and Theta = 0 equation are false
+ if (Theta == 0) Theta = 0.0001 ;
+ if (Theta == 2*cos(0)) Theta = 2 * acos(0) - 0.00001 ;
+ if (Phi == 0) Phi = 0.0001 ;
+
+ // (u,v,w) unitary vector associated to telescope referencial
+ // (u,v) // to silicon plan
+ // w perpendicular to (u,v) plan and pointing ThirdStage
+ // Phi is angle between X axis and projection in (X,Y) plan
+ // Theta is angle between position vector and z axis
+ G4double wX = m_R[i] * sin(Theta / rad) * cos(Phi / rad) ;
+ G4double wY = m_R[i] * sin(Theta / rad) * sin(Phi / rad) ;
+ G4double wZ = m_R[i] * cos(Theta / rad) ;
+
+ MMw = G4ThreeVector(wX, wY, wZ) ;
+// G4ThreeVector CT = MMw ;
+ CT = MMw ;
+ MMw = MMw.unit() ;
+
+ G4ThreeVector Y = G4ThreeVector(0 , 1 , 0) ;
+
+ MMu = MMw.cross(Y) ;
+ MMv = MMw.cross(MMu) ;
+
+ MMv = MMv.unit();
+ MMu = MMu.unit();
+ // Passage Matrix from Lab Referential to Telescope Referential
+ // MUST2
+ MMrot = new G4RotationMatrix(MMu, MMv, MMw);
+ // Telescope is rotate of Beta angle around MMv axis.
+ MMrot->rotate(m_beta_u[i], MMu);
+ MMrot->rotate(m_beta_v[i], MMv);
+ MMrot->rotate(m_beta_w[i], MMw);
+ // translation to place Telescope
+ MMpos = MMw * Length * 0.5 + CT ;
+ }
+
+ FirstStage = m_wFirstStage[i] ;
+ SecondStage = m_wSecondStage[i] ;
+ ThirdStage = m_wThirdStage[i] ;
+
+ VolumeMaker(i + 1, MMpos, MMrot, FirstStage, SecondStage, ThirdStage , world);
+ }
+
+ delete MMrot ;
+}
+
+
+
+// Connect the GaspardTrackingData class to the output TTree
+// of the simulation
+void GaspardTrackerDummyShape::InitializeRootOutput()
+{
+}
+
+
+
+// Set the TinteractionCoordinates object from VDetector to the present class
+void GaspardTrackerDummyShape::SetInterCoordPointer(TInteractionCoordinates* interCoord)
+{
+ ms_InterCoord = interCoord;
+}
+
+
+
+// Read sensitive part and fill the Root tree.
+// Called at in the EventAction::EndOfEventAvtion
+void GaspardTrackerDummyShape::ReadSensitive(const G4Event* event)
+{
+ bool checkSi = false;
+ G4String DetectorNumber;
+
+//////////////////////////////////////////////////////////////////////////////////////
+//////////////////////// Used to Read Event Map of detector //////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////
+
+ // First Stage
+ std::map<G4int, G4int*>::iterator DetectorNumber_itr;
+ std::map<G4int, G4double*>::iterator Energy_itr;
+ std::map<G4int, G4double*>::iterator Time_itr;
+ std::map<G4int, G4double*>::iterator X_itr;
+ std::map<G4int, G4double*>::iterator Y_itr;
+ std::map<G4int, G4double*>::iterator Pos_X_itr;
+ std::map<G4int, G4double*>::iterator Pos_Y_itr;
+ std::map<G4int, G4double*>::iterator Pos_Z_itr;
+ std::map<G4int, G4double*>::iterator Ang_Theta_itr;
+ std::map<G4int, G4double*>::iterator Ang_Phi_itr;
+
+ G4THitsMap<G4int>* DetectorNumberHitMap;
+ G4THitsMap<G4double>* EnergyHitMap;
+ G4THitsMap<G4double>* TimeHitMap;
+ G4THitsMap<G4double>* XHitMap;
+ G4THitsMap<G4double>* YHitMap;
+ G4THitsMap<G4double>* PosXHitMap;
+ G4THitsMap<G4double>* PosYHitMap;
+ G4THitsMap<G4double>* PosZHitMap;
+ G4THitsMap<G4double>* AngThetaHitMap;
+ G4THitsMap<G4double>* AngPhiHitMap;
+
+ // NULL pointer are given to avoid warning at compilation
+ // Si(Li)
+ std::map<G4int, G4double*>::iterator SiLiEnergy_itr ;
+ G4THitsMap<G4double>* SiLiEnergyHitMap = NULL ;
+ // Third Stage
+ std::map<G4int, G4double*>::iterator ThirdStageEnergy_itr ;
+ G4THitsMap<G4double>* ThirdStageEnergyHitMap = NULL ;
+
+//////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////
+ G4int HitNumber = 0;
+ checkSi = false;
+
+ // Read the Scorer associate to the Silicon Strip
+ //Detector Number
+ G4int StripDetCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/DetectorNumber") ;
+ DetectorNumberHitMap = (G4THitsMap<G4int>*)(event->GetHCofThisEvent()->GetHC(StripDetCollectionID)) ;
+ DetectorNumber_itr = DetectorNumberHitMap->GetMap()->begin() ;
+
+ //Energy
+ G4int StripEnergyCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/StripEnergy") ;
+ EnergyHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(StripEnergyCollectionID)) ;
+ Energy_itr = EnergyHitMap->GetMap()->begin() ;
+
+ //Time of Flight
+ G4int StripTimeCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/StripTime") ;
+ TimeHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(StripTimeCollectionID)) ;
+ Time_itr = TimeHitMap->GetMap()->begin() ;
+
+ //Strip Number X
+ G4int StripXCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/StripIDFront") ;
+ XHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(StripXCollectionID)) ;
+ X_itr = XHitMap->GetMap()->begin() ;
+
+ //Strip Number Y
+ G4int StripYCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/StripIDBack");
+ YHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(StripYCollectionID)) ;
+ Y_itr = YHitMap->GetMap()->begin() ;
+
+ //Interaction Coordinate X
+ G4int InterCoordXCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/InterCoordX") ;
+ PosXHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(InterCoordXCollectionID)) ;
+ Pos_X_itr = PosXHitMap->GetMap()->begin() ;
+
+ //Interaction Coordinate Y
+ G4int InterCoordYCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/InterCoordY") ;
+ PosYHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(InterCoordYCollectionID)) ;
+ Pos_Y_itr = PosYHitMap->GetMap()->begin() ;
+
+ //Interaction Coordinate Z
+ G4int InterCoordZCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/InterCoordZ") ;
+ PosZHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(InterCoordZCollectionID)) ;
+ Pos_Z_itr = PosXHitMap->GetMap()->begin() ;
+
+ //Interaction Coordinate Angle Theta
+ G4int InterCoordAngThetaCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/InterCoordAngTheta") ;
+ AngThetaHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(InterCoordAngThetaCollectionID)) ;
+ Ang_Theta_itr = AngThetaHitMap->GetMap()->begin() ;
+
+ //Interaction Coordinate Angle Phi
+ G4int InterCoordAngPhiCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("FirstStageScorerGPDDummyShape/InterCoordAngPhi") ;
+ AngPhiHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(InterCoordAngPhiCollectionID)) ;
+ Ang_Phi_itr = AngPhiHitMap->GetMap()->begin() ;
+
+ // Read the Scorer associate to the SiLi
+ //Energy
+ G4int SiLiEnergyCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("SecondStageScorerGPDDummyShape/SecondStageEnergy") ;
+ SiLiEnergyHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(SiLiEnergyCollectionID)) ;
+ SiLiEnergy_itr = SiLiEnergyHitMap->GetMap()->begin() ;
+
+
+ // Read the Scorer associate to the CsI crystal
+ //Energy
+ G4int ThirdStageEnergyCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("ThirdStageScorerGPDDummyShape/ThirdStageEnergy");
+ ThirdStageEnergyHitMap = (G4THitsMap<G4double>*)(event->GetHCofThisEvent()->GetHC(ThirdStageEnergyCollectionID));
+ ThirdStageEnergy_itr = ThirdStageEnergyHitMap->GetMap()->begin();
+
+ // Check the size of different map
+ G4int sizeN = DetectorNumberHitMap->entries();
+ G4int sizeE = EnergyHitMap->entries();
+ G4int sizeT = TimeHitMap->entries();
+ G4int sizeX = XHitMap->entries();
+ G4int sizeY = YHitMap->entries();
+
+ if (sizeE != sizeT || sizeT != sizeX || sizeX != sizeY) {
+ G4cout << "No match size Si Event Map: sE:"
+ << sizeE << " sT:" << sizeT << " sX:" << sizeX << " sY:" << sizeY << endl ;
+ return;
+ }
+
+ // Loop on Strip energy
+ for (G4int l = 0 ; l < sizeE ; l++) {
+ G4int ETrackID = Energy_itr->first ;
+ G4double E = *(Energy_itr->second) ;
+ G4int N = 0;
+
+ if (E > 0) {
+ checkSi = true ;
+ ms_Event->SetGPDTrkFirstStageFrontEEnergy(RandGauss::shoot(E, ResoFirstStage)) ;
+ ms_Event->SetGPDTrkFirstStageBackEEnergy(RandGauss::shoot(E, ResoFirstStage)) ;
+
+ // Detector Number
+ DetectorNumber_itr = DetectorNumberHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeN ; h++) {
+ G4int NTrackID = DetectorNumber_itr->first ;
+ G4double Nl = *(DetectorNumber_itr->second) ;
+
+ if (NTrackID == ETrackID) {
+ N = Nl ;
+ ms_Event->SetGPDTrkFirstStageFrontEDetectorNbr(INDEX + N);
+ ms_Event->SetGPDTrkFirstStageFrontTDetectorNbr(INDEX + N);
+ ms_Event->SetGPDTrkFirstStageBackEDetectorNbr(INDEX + N);
+ ms_Event->SetGPDTrkFirstStageBackTDetectorNbr(INDEX + N);
+ }
+ DetectorNumber_itr++;
+ }
+
+ // Time
+ Time_itr = TimeHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeT ; h++) {
+ G4int TTrackID = Time_itr->first ;
+ G4double T = *(Time_itr->second) ;
+
+ if (TTrackID == ETrackID) {
+ T = RandGauss::shoot(T, ResoTimeGpd) ;
+ ms_Event->SetGPDTrkFirstStageFrontTTime(RandGauss::shoot(T, ResoTimeGpd)) ;
+ ms_Event->SetGPDTrkFirstStageBackTTime(RandGauss::shoot(T, ResoTimeGpd)) ;
+ }
+ Time_itr++;
+ }
+
+ // X
+ X_itr = XHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int XTrackID = X_itr->first ;
+ G4double X = *(X_itr->second) ;
+ if (XTrackID == ETrackID) {
+ ms_Event->SetGPDTrkFirstStageFrontEStripNbr(X) ;
+ ms_Event->SetGPDTrkFirstStageFrontTStripNbr(X) ;
+ }
+
+ X_itr++;
+ }
+
+ // Y
+ Y_itr = YHitMap->GetMap()->begin() ;
+ for (G4int h = 0 ; h < sizeY ; h++) {
+ G4int YTrackID = Y_itr->first ;
+ G4double Y = *(Y_itr->second) ;
+ if (YTrackID == ETrackID) {
+ ms_Event->SetGPDTrkFirstStageBackEStripNbr(Y) ;
+ ms_Event->SetGPDTrkFirstStageBackTStripNbr(Y) ;
+ }
+
+ Y_itr++;
+ }
+
+ // Pos X
+ Pos_X_itr = PosXHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int PosXTrackID = Pos_X_itr->first ;
+ G4double PosX = *(Pos_X_itr->second) ;
+ if (PosXTrackID == ETrackID) {
+ ms_InterCoord->SetDetectedPositionX(PosX) ;
+ }
+ Pos_X_itr++;
+ }
+
+ // Pos Y
+ Pos_Y_itr = PosYHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int PosYTrackID = Pos_Y_itr->first ;
+ G4double PosY = *(Pos_Y_itr->second) ;
+ if (PosYTrackID == ETrackID) {
+ ms_InterCoord->SetDetectedPositionY(PosY) ;
+ }
+ Pos_Y_itr++;
+ }
+
+ // Pos Z
+ Pos_Z_itr = PosZHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int PosZTrackID = Pos_Z_itr->first ;
+ G4double PosZ = *(Pos_Z_itr->second) ;
+ if (PosZTrackID == ETrackID) {
+ ms_InterCoord->SetDetectedPositionZ(PosZ) ;
+ }
+ Pos_Z_itr++;
+ }
+
+ // Angle Theta
+ Ang_Theta_itr = AngThetaHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int AngThetaTrackID = Ang_Theta_itr->first ;
+ G4double AngTheta = *(Ang_Theta_itr->second) ;
+ if (AngThetaTrackID == ETrackID) {
+ ms_InterCoord->SetDetectedAngleTheta(AngTheta) ;
+ }
+ Ang_Theta_itr++;
+ }
+
+ // Angle Phi
+ Ang_Phi_itr = AngPhiHitMap->GetMap()->begin();
+ for (G4int h = 0 ; h < sizeX ; h++) {
+ G4int AngPhiTrackID = Ang_Phi_itr->first ;
+ G4double AngPhi = *(Ang_Phi_itr->second) ;
+ if (AngPhiTrackID == ETrackID) {
+ ms_InterCoord->SetDetectedAnglePhi(AngPhi) ;
+ }
+ Ang_Phi_itr++;
+ }
+
+ // Second Stage
+ SiLiEnergy_itr = SiLiEnergyHitMap->GetMap()->begin() ;
+ for (G4int h = 0 ; h < SiLiEnergyHitMap->entries() ; h++) {
+ G4int SiLiEnergyTrackID = SiLiEnergy_itr->first ;
+ G4double SiLiEnergy = *(SiLiEnergy_itr->second) ;
+
+ if (SiLiEnergyTrackID == ETrackID) {
+ ms_Event->SetGPDTrkSecondStageEEnergy(RandGauss::shoot(SiLiEnergy, ResoSecondStage)) ;
+ ms_Event->SetGPDTrkSecondStageEPadNbr(1);
+ ms_Event->SetGPDTrkSecondStageTPadNbr(1);
+ ms_Event->SetGPDTrkSecondStageTTime(1);
+ ms_Event->SetGPDTrkSecondStageTDetectorNbr(INDEX + N);
+ ms_Event->SetGPDTrkSecondStageEDetectorNbr(INDEX + N);
+ }
+
+ SiLiEnergy_itr++;
+ }
+
+ // Third Stage
+ ThirdStageEnergy_itr = ThirdStageEnergyHitMap->GetMap()->begin() ;
+ for (G4int h = 0 ; h < ThirdStageEnergyHitMap->entries() ; h++) {
+ G4int ThirdStageEnergyTrackID = ThirdStageEnergy_itr->first ;
+ G4double ThirdStageEnergy = *(ThirdStageEnergy_itr->second) ;
+
+ if (ThirdStageEnergyTrackID == ETrackID) {
+ ms_Event->SetGPDTrkThirdStageEEnergy(RandGauss::shoot(ThirdStageEnergy, ResoThirdStage));
+ ms_Event->SetGPDTrkThirdStageEPadNbr(1);
+ ms_Event->SetGPDTrkThirdStageTPadNbr(1);
+ ms_Event->SetGPDTrkThirdStageTTime(1);
+ ms_Event->SetGPDTrkThirdStageTDetectorNbr(INDEX + N);
+ ms_Event->SetGPDTrkThirdStageEDetectorNbr(INDEX + N);
+ }
+
+ ThirdStageEnergy_itr++;
+ }
+
+ Energy_itr++;
+ if (checkSi) HitNumber++ ;
+ }
+ // clear map for next event
+ DetectorNumberHitMap ->clear();
+ EnergyHitMap ->clear() ;
+ TimeHitMap ->clear() ;
+ XHitMap ->clear() ;
+ YHitMap ->clear() ;
+ PosXHitMap ->clear();
+ PosYHitMap ->clear();
+ PosZHitMap ->clear();
+ AngThetaHitMap ->clear();
+ AngPhiHitMap ->clear();
+ SiLiEnergyHitMap ->clear() ;
+ ThirdStageEnergyHitMap ->clear() ;
+ }
+}
+
+
+
+void GaspardTrackerDummyShape::InitializeScorers()
+{
+ // First stage Associate Scorer
+ m_FirstStageScorer = new G4MultiFunctionalDetector("FirstStageScorerGPDDummyShape");
+ G4VPrimitiveScorer* DetNbr = new GPDScorerDetectorNumber("DetectorNumber", 0, "FirstStage");
+ G4VPrimitiveScorer* Energy = new GPDScorerFirstStageEnergy("StripEnergy", 0);
+ G4VPrimitiveScorer* TOF = new PSTOF("StripTime", 0);
+ G4VPrimitiveScorer* StripPositionX = new GPDScorerFirstStageFrontStripDummyShape("StripIDFront", 0, FirstStageFace, 128);
+ G4VPrimitiveScorer* StripPositionY = new GPDScorerFirstStageBackStripDummyShape("StripIDBack", 0, FirstStageFace, 128);
+ G4VPrimitiveScorer* InteractionCoordinatesX = new PSInteractionCoordinatesX("InterCoordX", 0);
+ G4VPrimitiveScorer* InteractionCoordinatesY = new PSInteractionCoordinatesY("InterCoordY", 0);
+ G4VPrimitiveScorer* InteractionCoordinatesZ = new PSInteractionCoordinatesZ("InterCoordZ", 0);
+ G4VPrimitiveScorer* InteractionCoordinatesAngleTheta = new PSInteractionCoordinatesAngleTheta("InterCoordAngTheta", 0);
+ G4VPrimitiveScorer* InteractionCoordinatesAnglePhi = new PSInteractionCoordinatesAnglePhi("InterCoordAngPhi", 0);
+
+ //and register it to the multifunctionnal detector
+ m_FirstStageScorer->RegisterPrimitive(DetNbr);
+ m_FirstStageScorer->RegisterPrimitive(Energy);
+ m_FirstStageScorer->RegisterPrimitive(TOF);
+ m_FirstStageScorer->RegisterPrimitive(StripPositionX);
+ m_FirstStageScorer->RegisterPrimitive(StripPositionY);
+ m_FirstStageScorer->RegisterPrimitive(InteractionCoordinatesX);
+ m_FirstStageScorer->RegisterPrimitive(InteractionCoordinatesY);
+ m_FirstStageScorer->RegisterPrimitive(InteractionCoordinatesZ);
+ m_FirstStageScorer->RegisterPrimitive(InteractionCoordinatesAngleTheta);
+ m_FirstStageScorer->RegisterPrimitive(InteractionCoordinatesAnglePhi);
+
+ // Second stage Associate Scorer
+ m_SecondStageScorer = new G4MultiFunctionalDetector("SecondStageScorerGPDDummyShape");
+ G4VPrimitiveScorer* SecondStageEnergy = new GPDScorerSecondStageEnergy("SecondStageEnergy", 0);
+ m_SecondStageScorer->RegisterPrimitive(SecondStageEnergy);
+
+ // Third stage Associate Scorer
+ m_ThirdStageScorer = new G4MultiFunctionalDetector("ThirdStageScorerGPDDummyShape");
+ G4VPrimitiveScorer* ThirdStageEnergy = new GPDScorerThirdStageEnergy("ThirdStageEnergy", 0);
+ m_ThirdStageScorer->RegisterPrimitive(ThirdStageEnergy);
+
+ // Add All Scorer to the Global Scorer Manager
+ G4SDManager::GetSDMpointer()->AddNewDetector(m_FirstStageScorer);
+ G4SDManager::GetSDMpointer()->AddNewDetector(m_SecondStageScorer);
+ G4SDManager::GetSDMpointer()->AddNewDetector(m_ThirdStageScorer);
+}