* Initial commit of SuperX3 based on file provided by Hari Pai (ELI-NP)

Examples/Example1/Analysis.cxx

@@ -61,10 +61,10 @@ void Analysis::Init(){
   Si_Y_M2 = 0;
   TargetThickness = m_DetectorManager->GetTargetThickness();
   //	Energy loss table: the G4Table are generated by the simulation
-  He3CD2  = EnergyLoss("Example/He3_CD2.G4table","G4Table",100 );
-  He3Al   = EnergyLoss("Example/He3_Al.G4table","G4Table",10);
-  He3Si   = EnergyLoss("Example/He3_Si.G4table","G4Table",10);
-  Li11CD2 = EnergyLoss("Example/Li11_CD2.G4table","G4Table",100);
+  He3CD2  = EnergyLoss("energy_loss/He3_CD2.G4table","G4Table",100 );
+  He3Al   = EnergyLoss("energy_loss/He3_Al.G4table","G4Table",10);
+  He3Si   = EnergyLoss("energy_loss/He3_Si.G4table","G4Table",10);
+  Li11CD2 = EnergyLoss("energy_loss/Li11_CD2.G4table","G4Table",100);
 }
 
 ////////////////////////////////////////////////////////////////////////////////

Examples/Example1/ShowResults.C

@@ -16,7 +16,7 @@ void LoadCuts(){
 ////////////////////////////////////////////////////////////////////////////////
 void LoadChain(){
     chain = new TChain("PhysicsTree");
-    chain->Add("../../Outputs/Analysis/Example1.root");
+    chain->Add("root/analysis/Example1.root");
 }
 
 ////////////////////////////////////////////////////////////////////////////////

Inputs/EventGenerator/np.source

@@ -11,7 +11,7 @@ Isotropic
  x0= 0 mm
  y0= 0 mm 
  z0= 0 mm 
- Multiplicity= 1 1
- Particle= neutron proton
+ Multiplicity= 1 1 1
+ Particle= neutron proton 8He
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Supported particle type: proton, neutron, deuton, triton, He3 , alpha 

NPLib/Detectors/Minos/TMinosPhysics.cxx

@@ -101,7 +101,7 @@ void TMinosPhysics::PreTreat() {
         vector<unsigned short>* Time   = m_EventData->GetTimePtr(i);
         m_utility.Calibrate(Time,Charge,i,T,Q);      
 
-        if(T>0){
+        if(T>0&&Q<77000){
           PadNumber = m_EventData->GetPadNumber(i);
           double x_mm = m_X[PadNumber];
           double y_mm = m_Y[PadNumber];
@@ -111,16 +111,12 @@ void TMinosPhysics::PreTreat() {
           double calV= cal->GetValue(cal_v,0);
           double calO=cal->GetValue(cal_o,0);
 
-          // regular case
-          //double z_mm = (T*m_TimeBin+cal->GetValue(cal_o,0))*cal->GetValue(cal_v,0);    
-          
-          // testing dependency:
-          //calV+=-calV*30./100.;// -5%
-          //calO+=+calO*60./100;
-          double z_mm = (T*m_TimeBin+calO)*calV;    
+          double z_mm = (T*m_TimeBin+calO/*-0.7-0.04*ring*/)*calV;    
+          //cout << T*m_TimeBin+calO << endl;
           TVector3 Pos=TVector3(x_mm+m_Position.X(),y_mm+m_Position.Y(),z_mm+m_Position.Z());
           Pos.RotateZ(m_ZRotation); 
           // Calibrate the Pad:
+          
           X_Pad.push_back(Pos.X());
           Y_Pad.push_back(Pos.Y());
           Z_Pad.push_back(Pos.Z());    

NPLib/Detectors/SuperX3/CMakeLists.txt

+add_custom_command(OUTPUT TSuperX3PhysicsDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TSuperX3Physics.h TSuperX3PhysicsDict.cxx TSuperX3Physics.rootmap libNPSuperX3.dylib DEPENDS TSuperX3Physics.h)
+add_custom_command(OUTPUT TSuperX3DataDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TSuperX3Data.h TSuperX3DataDict.cxx TSuperX3Data.rootmap libNPSuperX3.dylib DEPENDS TSuperX3Data.h)
+add_library(NPSuperX3 SHARED TSuperX3Spectra.cxx TSuperX3Data.cxx TSuperX3Physics.cxx TSuperX3DataDict.cxx TSuperX3PhysicsDict.cxx )
+target_link_libraries(NPSuperX3 ${ROOT_LIBRARIES} NPCore) 
+install(FILES TSuperX3Data.h TSuperX3Physics.h TSuperX3Spectra.h DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
+

NPLib/Detectors/SuperX3/TSuperX3Data.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2016   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  : january 2011                                             *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *     This class holds the raw data storage for the SuperX3 detector from Micron *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+#include "TSuperX3Data.h"
+
+#include <iostream>
+using namespace std;
+
+ClassImp(TSuperX3Data)
+
+    TSuperX3Data::TSuperX3Data() {
+  // Default constructor
+  Clear();
+}
+
+TSuperX3Data::~TSuperX3Data() {}
+
+void TSuperX3Data::Clear() {
+  // (Up, E)
+  fSuperX3_UpE_DetectorNbr.clear();
+  fSuperX3_UpE_StripNbr.clear();
+  fSuperX3_UpE_Energy.clear();
+  // (Up, T)
+  fSuperX3_UpT_DetectorNbr.clear();
+  fSuperX3_UpT_StripNbr.clear();
+  fSuperX3_UpT_Time.clear();
+  // (Down, E)
+  fSuperX3_DownE_DetectorNbr.clear();
+  fSuperX3_DownE_StripNbr.clear();
+  fSuperX3_DownE_Energy.clear();
+  // (Down, T)
+  fSuperX3_DownT_DetectorNbr.clear();
+  fSuperX3_DownT_StripNbr.clear();
+  fSuperX3_DownT_Time.clear();
+
+  // (Back, E)
+  fSuperX3_BackE_DetectorNbr.clear();
+  fSuperX3_BackE_Energy.clear();
+  // (Back, T)
+  fSuperX3_BackT_DetectorNbr.clear();
+  fSuperX3_BackT_Time.clear();
+}
+
+void TSuperX3Data::Dump() const {}

NPLib/Detectors/SuperX3/TSuperX3Data.h

+#ifndef __SuperX3DATA__
+#define __SuperX3DATA__
+/*****************************************************************************
+ * Copyright (C) 2009-2016    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  : january 2011                                             *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *     This class holds the raw data storage for the SuperX3 detector from Micron *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+// C++ headers
+#include <vector>
+using namespace std;
+
+// ROOT headers
+#include "TObject.h"
+
+class TSuperX3Data : public TObject {
+ private:
+  // Front
+  // Up
+  // Energy
+  vector<UShort_t> fSuperX3_UpE_DetectorNbr;
+  vector<UShort_t> fSuperX3_UpE_StripNbr;
+  vector<Double_t> fSuperX3_UpE_Energy;
+  // Time
+  vector<UShort_t> fSuperX3_UpT_DetectorNbr;
+  vector<UShort_t> fSuperX3_UpT_StripNbr;
+  vector<Double_t> fSuperX3_UpT_Time;
+  // Energy
+  vector<UShort_t> fSuperX3_DownE_DetectorNbr;
+  vector<UShort_t> fSuperX3_DownE_StripNbr;
+  vector<Double_t> fSuperX3_DownE_Energy;
+  // Time
+  vector<UShort_t> fSuperX3_DownT_DetectorNbr;
+  vector<UShort_t> fSuperX3_DownT_StripNbr;
+  vector<Double_t> fSuperX3_DownT_Time;
+
+  // Back
+  // Energy
+  vector<Double_t> fSuperX3_BackE_Energy;
+  vector<UShort_t> fSuperX3_BackE_DetectorNbr;
+  // Time
+  vector<Double_t> fSuperX3_BackT_Time;
+  vector<UShort_t> fSuperX3_BackT_DetectorNbr;
+
+ public:
+  TSuperX3Data();
+  virtual ~TSuperX3Data();
+
+  void Clear();
+  void Clear(const Option_t*){};
+  void Dump() const;
+
+  /////////////////////           SETTERS           ////////////////////////
+  // up
+  void SetUpE(UShort_t DetNbr, UShort_t StripNbr, Double_t Energy) {
+    fSuperX3_UpE_DetectorNbr.push_back(DetNbr);
+    fSuperX3_UpE_StripNbr.push_back(StripNbr);
+    fSuperX3_UpE_Energy.push_back(Energy);
+  }
+  void SetUpT(UShort_t DetNbr, UShort_t StripNbr, Double_t Time) {
+    fSuperX3_UpT_DetectorNbr.push_back(DetNbr);
+    fSuperX3_UpT_StripNbr.push_back(StripNbr);
+    fSuperX3_UpT_Time.push_back(Time);
+  }
+  // down
+  void SetDownE(UShort_t DetNbr, UShort_t StripNbr, Double_t Energy) {
+    fSuperX3_DownE_DetectorNbr.push_back(DetNbr);
+    fSuperX3_DownE_StripNbr.push_back(StripNbr);
+    fSuperX3_DownE_Energy.push_back(Energy);
+  }
+  void SetDownT(UShort_t DetNbr, UShort_t StripNbr, Double_t Time) {
+    fSuperX3_DownT_DetectorNbr.push_back(DetNbr);
+    fSuperX3_DownT_StripNbr.push_back(StripNbr);
+    fSuperX3_DownT_Time.push_back(Time);
+  }
+
+  // Back E
+  void SetBackE(UShort_t DetNbr, Double_t Energy) {
+    fSuperX3_BackE_DetectorNbr.push_back(DetNbr);
+    fSuperX3_BackE_Energy.push_back(Energy);
+  }
+  // Back T
+  void SetBackT(UShort_t DetNbr, Double_t Time) {
+    fSuperX3_BackT_DetectorNbr.push_back(DetNbr);
+    fSuperX3_BackT_Time.push_back(Time);
+  }
+
+  /////////////////////           GETTERS           ////////////////////////
+  // DSSD
+  // (Up, E)
+  UShort_t GetUpEMult() const { return fSuperX3_UpE_DetectorNbr.size(); }
+  UShort_t GetUpEDetectorNbr(Int_t i) const { return fSuperX3_UpE_DetectorNbr[i]; }
+  UShort_t GetUpEStripNbr(Int_t i) const { return fSuperX3_UpE_StripNbr[i]; }
+  Double_t GetUpEEnergy(Int_t i) const { return fSuperX3_UpE_Energy[i]; }
+  // (Up, T)
+  UShort_t GetUpTMult() const { return fSuperX3_UpT_DetectorNbr.size(); }
+  UShort_t GetUpTDetectorNbr(Int_t i) const { return fSuperX3_UpT_DetectorNbr[i]; }
+  UShort_t GetUpTStripNbr(Int_t i) const { return fSuperX3_UpT_StripNbr[i]; }
+  Double_t GetUpTTime(Int_t i) const { return fSuperX3_UpT_Time[i]; }
+  // (Down, E)
+  UShort_t GetDownEMult() const { return fSuperX3_DownE_DetectorNbr.size(); }
+  UShort_t GetDownEDetectorNbr(Int_t i) const { return fSuperX3_DownE_DetectorNbr[i]; }
+  UShort_t GetDownEStripNbr(Int_t i) const { return fSuperX3_DownE_StripNbr[i]; }
+  Double_t GetDownEEnergy(Int_t i) const { return fSuperX3_DownE_Energy[i]; }
+  // (Down, T)
+  UShort_t GetDownTMult() const { return fSuperX3_DownT_DetectorNbr.size(); }
+  UShort_t GetDownTDetectorNbr(Int_t i) const { return fSuperX3_DownT_DetectorNbr[i]; }
+  UShort_t GetDownTStripNbr(Int_t i) const { return fSuperX3_DownT_StripNbr[i]; }
+  Double_t GetDownTTime(Int_t i) const { return fSuperX3_DownT_Time[i]; }
+
+  // (Back, E)
+  UShort_t GetBackEMult() const { return fSuperX3_BackE_DetectorNbr.size(); }
+  UShort_t GetBackEDetectorNbr(Int_t i) const { return fSuperX3_BackE_DetectorNbr[i]; }
+  Double_t GetBackEEnergy(Int_t i) const { return fSuperX3_BackE_Energy[i]; }
+  // (Back, T)
+  UShort_t GetBackTMult() const { return fSuperX3_BackT_DetectorNbr.size(); }
+  UShort_t GetBackTDetectorNbr(Int_t i) const { return fSuperX3_BackT_DetectorNbr[i]; }
+  Double_t GetBackTTime(Int_t i) const { return fSuperX3_BackT_Time[i]; }
+
+  ClassDef(TSuperX3Data, 1) // TSuperX3Data raw data
+};
+
+#endif

NPLib/Detectors/SuperX3/TSuperX3Physics.h

+#ifndef __SuperX3Physics__
+#define __SuperX3Physics__
+/*****************************************************************************
+ * Copyright (C) 2009-2016    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  : january 2011                                             *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *     This class holds the physics class for the SuperX3 detector from Micron    *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+// C++ headers
+#include <map>
+#include <vector>
+using namespace std;
+
+// ROOT headers
+#include "TCanvas.h"
+#include "TH1.h"
+#include "TObject.h"
+#include "TVector2.h"
+#include "TVector3.h"
+
+// NPTool headers
+#include "NPCalibrationManager.h"
+#include "NPInputParser.h"
+#include "NPVDetector.h"
+#include "TSuperX3Data.h"
+#include "TSuperX3Spectra.h"
+
+// forward declaration
+class TSuperX3Spectra;
+
+class TSuperX3Physics : public TObject, public NPL::VDetector {
+ public: //   Constructor and Destructor
+  TSuperX3Physics();
+  ~TSuperX3Physics(){};
+
+ public:
+  void Clear();
+  void Clear(const Option_t*){};
+
+ private: // data obtained after BuildPhysicalEvent() and stored in ROOT output file
+  vector<Int_t> fEventType;
+  vector<Int_t> fDetectorNumber;
+  vector<Double_t> fFrontEnergy;
+  vector<Double_t> fBackEnergy;
+  vector<Double_t> fHalfEnergy;
+  vector<Double_t> fFrontTime;
+  vector<Double_t> fBackTime;
+  vector<Int_t> fFrontStrip;
+  vector<Int_t> fBackStrip;
+
+ public:
+  // setters
+  void SetEventType(Int_t evtType) { fEventType.push_back(evtType); }
+  void SetDetectorNumber(Int_t moduleNbr) { fDetectorNumber.push_back(moduleNbr); }
+  void SetFrontEnergy(Double_t ener) { fFrontEnergy.push_back(ener); }
+  void SetBackEnergy(Double_t ener) { fBackEnergy.push_back(ener); }
+  void SethalfEnergy(Double_t ener) { fHalfEnergy.push_back(ener); }
+  void SetFrontTime(Double_t time) { fFrontTime.push_back(time); }
+  void SetBackTime(Double_t time) { fBackTime.push_back(time); }
+  void SetFrontStrip(Int_t x) { fFrontStrip.push_back(x); }
+  void SetBackStrip(Int_t y) { fBackStrip.push_back(y); }
+
+  // getters
+  Int_t GetEventMultiplicity() { return fFrontEnergy.size(); }
+  Int_t GetEventType(Int_t i) { return fEventType[i]; }
+  Int_t GetDetectorNumber(Int_t i) { return fDetectorNumber[i]; }
+  Double_t GetFrontEnergy(Int_t i) { return fFrontEnergy[i]; }
+  Double_t GetBackEnergy(Int_t i) { return fBackEnergy[i]; }
+  Double_t GetHalfEnergy(Int_t i) { return fHalfEnergy[i]; }
+  Double_t GetFrontTime(Int_t i) { return fFrontTime[i]; }
+  Double_t GetBackTime(Int_t i) { return fBackTime[i]; }
+  Int_t GetFrontStrip(Int_t i) { return fFrontStrip[i]; }
+  Int_t GetBackStrip(Int_t i) { return fBackStrip[i]; }
+
+ public:
+  Int_t m_nCounter;     //!
+  Bool_t m_Counter[10]; //!
+
+ public: // inherited from VDetector
+  // Read stream at ConfigFile to pick-up parameters of detector (Position,...) using Token
+  void ReadConfiguration(NPL::InputParser);
+
+  // Add parameters to the CalibrationManger
+  void AddParameterToCalibrationManager();
+
+  // Activate associated branches and link them to the private member object m_EventData
+  void InitializeRootInputRaw();
+
+  // Activate associated branches and link them to the private member m_EventPhysics
+  void InitializeRootInputPhysics();
+
+  // Create associated branches and associated private member m_EventPhysics
+  void InitializeRootOutput();
+
+  // This method is called at each event read from the Input Tree. Aime is to build treat Raw dat in order to extract
+  // physical parameter.
+  void BuildPhysicalEvent();
+
+  // Same as above, but only the simplest event and/or simple method are used (low multiplicity, faster algorythm but
+  // less efficient ...). This method aimed to be used for analysis performed during experiment, when speed is
+  // requiered. NB: This method can eventually be the same as BuildPhysicalEvent.
+  void BuildSimplePhysicalEvent();
+
+  // Same as above but for online analysis
+  void BuildOnlinePhysicalEvent() { BuildPhysicalEvent(); };
+
+  // Clear raw and physics data
+  void ClearEventPhysics() { Clear(); }
+  void ClearEventData() { m_EventData->Clear(); }
+
+  // Methods related to the TSuperX3Spectra classes
+  // Instantiate the TSuperX3Spectra class and the histograms
+  void InitSpectra();
+  // Fill the spectra defined in TSuperX3Spectra
+  void FillSpectra();
+  // Used for Online mainly, perform check on the histo and for example change their color if issues are found
+  void CheckSpectra();
+  // Used for Online only, clear all the spectra hold by the Spectra class
+  void ClearSpectra();
+  // Write Spectra to file
+  void WriteSpectra();
+
+ public: //   Specific to SuperX3
+  // Remove bad channel, calibrate the data and apply thresholds
+  void PreTreat();
+
+  // Clear the pre treated object
+  void ClearPreTreatedData() { m_PreTreatedData->Clear(); }
+
+  // Return false if the channel is disabled by user
+  // Frist argument is either "Front" or "Back"
+  bool IsValidChannel(string Type, int detector, int channel);
+
+  // Initialize the standard parameters for analysis, i.e.: all channel enable,
+  // maximum multiplicity for strip = number of telescope
+  void InitializeStandardParameters();
+
+  //   Read the user configuration file; if no file found, load standard one
+  void ReadAnalysisConfig();
+
+  // Add detector using cartesian coordinates
+  void AddDetector(TVector3 C_X1_Y1, TVector3 C_X16_Y1, TVector3 C_X1_Y16, TVector3 C_X16_Y16);
+
+  // Add detector using spherical coordinates
+  void AddDetector(double theta, double phi, double distance, double beta_u, double beta_v, double beta_w);
+
+  // Give an external TSuperX3Data object to TSuperX3Physics. Needed for online analysis for example.
+  void SetRawDataPointer(TSuperX3Data* rawDataPointer) { m_EventData = rawDataPointer; }
+
+  // Use for reading Calibration Run, very simple methods; only apply calibration, no condition
+  void ReadCalibrationRun(){};
+
+ public: // Methods used for event treatement
+  Int_t EventType();
+  vector<TVector2> Match_Front_Back();
+
+ private:                          // Data not written in the tree
+  TSuperX3Data* m_EventData;       //!
+  TSuperX3Data* m_PreTreatedData;  //!
+  TSuperX3Physics* m_EventPhysics; //!
+
+ public:
+  TSuperX3Data* GetRawData() const { return m_EventData; }
+  TSuperX3Data* GetPreTreatedData() const { return m_PreTreatedData; }
+
+ private:                                      // Map of activated Channel
+  map<int, vector<bool>> m_FrontChannelStatus; //!
+  map<int, vector<bool>> m_BackChannelStatus;  //!
+
+ private: // Parameters used in the analysis
+  // If multiplicity is greater than m_MaximumStripMultiplicityAllowed
+  // after PreTreat(), event is not treated
+  int m_MaximumStripMultiplicityAllowed; //!
+
+  // Tolerance for front / back energy match
+  double m_StripEnergyMatchingSigma;         //!
+  double m_StripEnergyMatchingNumberOfSigma; //!
+
+  // Energy thresholds
+  // Raw Threshold
+  int m_FrontE_Raw_Threshold; //!
+  int m_BackE_Raw_Threshold;  //!
+  // Calibrated Threshold
+  double m_FrontE_Calib_Threshold; //!
+  double m_BackE_Calib_Threshold;  //!
+
+ private:                                          // Spatial Position of Strip Calculated on bases of detector position
+  int m_NumberOfDetectors;                         //!
+  vector<vector<vector<double>>> m_StripPositionX; //!
+  vector<vector<vector<double>>> m_StripPositionY; //!
+  vector<vector<vector<double>>> m_StripPositionZ; //!
+
+ public:
+  double GetNumberOfDetectors() { return m_NumberOfDetectors; };
+  double GetStripPositionX(int N, int Front, int Back) { return m_StripPositionX[N - 1][Front - 1][Back - 1]; };
+  double GetStripPositionY(int N, int Front, int Back) { return m_StripPositionY[N - 1][Front - 1][Back - 1]; };
+  double GetStripPositionZ(int N, int Front, int Back) { return m_StripPositionZ[N - 1][Front - 1][Back - 1]; };
+  TVector3 GetPositionOfInteraction(int i);
+  TVector3 GetDetectorNormal(int i);
+  void DumpStrippingScheme(Int_t detecNumber);
+
+ private:               // Geometry and strip number
+  double m_SiliconFace; //!     // mm
+  int m_NumberOfStrips; //!
+  double m_StripPitch;  //!
+
+ private:                     // Spectra Class
+  TSuperX3Spectra* m_Spectra; // !
+
+ public: // Spectra Getter
+  map<string, TH1*> GetSpectra();
+
+ public: // Static constructor to be passed to the Detector Factory
+  static NPL::VDetector* Construct();
+
+  ClassDef(TSuperX3Physics, 1) // TSuperX3Physics
+};
+
+namespace SuperX3_LOCAL {
+  Double_t fSuperX3_Front_E(TSuperX3Data* EventData, Int_t i);
+  Double_t fSuperX3_Front_T(TSuperX3Data* EventData, Int_t i);
+  Double_t fSuperX3_Back_E(TSuperX3Data* EventData, Int_t i);
+  Double_t fSuperX3_Back_T(TSuperX3Data* EventData, Int_t i);
+} // namespace SuperX3_LOCAL
+
+#endif

NPLib/Detectors/SuperX3/TSuperX3Spectra.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2016   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         address: deserevi@ipno.in2p3.fr  *
+ *                                                                           *
+ * Creation Date  : November 2015                                            *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *  This class holds all the online spectra needed for SuperX3                    *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *****************************************************************************/
+
+// class header
+#include "TSuperX3Spectra.h"
+
+// C++ headers
+#include <iostream>
+#include <string>
+using namespace std;
+
+// NPTool headers
+#include "NPOptionManager.h"
+
+////////////////////////////////////////////////////////////////////////////////
+TSuperX3Spectra::TSuperX3Spectra()
+    : fNumberOfDetectors(0), fNumberOfStripsFront(16), fNumberOfStripsBack(16), fNumberOfCounters(10) {
+  SetName("SuperX3");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TSuperX3Spectra::TSuperX3Spectra(unsigned int NumberOfDetectors) {
+  InitRawSpectra();
+  InitPreTreatedSpectra();
+  InitPhysicsSpectra();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TSuperX3Spectra::~TSuperX3Spectra() {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::InitRawSpectra() {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::InitPreTreatedSpectra() {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::InitPhysicsSpectra() {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::FillRawSpectra(TSuperX3Data* RawData) {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::FillPreTreatedSpectra(TSuperX3Data* PreTreatedData) {}
+
+////////////////////////////////////////////////////////////////////////////////
+void TSuperX3Spectra::FillPhysicsSpectra(TSuperX3Physics* Physics) {}
+

NPLib/Detectors/SuperX3/TSuperX3Spectra.h

+#ifndef TSuperX3SPECTRA_H
+#define TSuperX3SPECTRA_H
+/*****************************************************************************
+ * Copyright (C) 2009-2016   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        address: deserevi@ipno.in2p3.fr   *
+ *                                                                           *
+ * Creation Date  : November 2015                                            *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription:                                                               *
+ *  This class holds all the online spectra needed for SuperX3                    *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *****************************************************************************/
+
+// NPLib headers
+#include "NPVSpectra.h"
+#include "TSuperX3Data.h"
+#include "TSuperX3Physics.h"
+
+// ForwardDeclaration
+class TSuperX3Physics;
+
+class TSuperX3Spectra : public VSpectra {
+ public:
+  // constructor and destructor
+  TSuperX3Spectra();
+  TSuperX3Spectra(unsigned int NumberOfDetectors);
+  ~TSuperX3Spectra();
+
+ private:
+  // Initialization methods
+  void InitRawSpectra();
+  void InitPreTreatedSpectra();
+  void InitPhysicsSpectra();
+
+ public:
+  // Filling methods
+  void FillRawSpectra(TSuperX3Data*);
+  void FillPreTreatedSpectra(TSuperX3Data*);
+  void FillPhysicsSpectra(TSuperX3Physics*);
+
+ private: // Information on SuperX3
+  unsigned int fNumberOfDetectors;
+  unsigned int fNumberOfStripsFront;
+  unsigned int fNumberOfStripsBack;
+  Int_t fNumberOfCounters;
+};
+
+#endif

NPSimulation/Detectors/SuperX3/CMakeLists.txt

+add_library(NPSSuperX3 SHARED  SuperX3.cc )
+target_link_libraries(NPSSuperX3 NPSCore ${ROOT_LIBRARIES} ${Geant4_LIBRARIES} NPSuperX3)

NPSimulation/Detectors/SuperX3/SuperX3.cc

+/*****************************************************************************
+ * Copyright (C) 2009-2016   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  : 12/01/11                                                 *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription: Define the SuperX3 detector from Micron *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+// C++ headers
+#include <cmath>
+#include <sstream>
+#include <string>
+
+// G4 Geometry headers
+#include "G4Box.hh"
+#include "G4Tubs.hh"
+
+// G4 various headers
+#include "G4Colour.hh"
+#include "G4Material.hh"
+#include "G4PVDivision.hh"
+#include "G4PVPlacement.hh"
+#include "G4RotationMatrix.hh"
+#include "G4Transform3D.hh"
+#include "G4VisAttributes.hh"
+
+// G4 sensitive
+#include "G4MultiFunctionalDetector.hh"
+#include "G4SDManager.hh"
+
+// NPTool headers
+#include "DSSDScorers.hh"
+#include "MaterialManager.hh"
+#include "NPOptionManager.h"
+#include "NPSDetectorFactory.hh"
+#include "ObsoleteGeneralScorers.hh"
+#include "RootOutput.h"
+#include "SuperX3.hh"
+#include "TSuperX3Data.h"
+
+// CLHEP
+#include "CLHEP/Random/RandGauss.h"
+
+using namespace std;
+using namespace CLHEP;
+using namespace SuperX3SQUARE;
+
+SuperX3::SuperX3() : m_Event(new TSuperX3Data) { InitializeMaterials(); }
+
+SuperX3::~SuperX3() { delete m_Event; }
+
+void SuperX3::AddDetector(G4ThreeVector X1_Y1, G4ThreeVector X16_Y1, G4ThreeVector X1_Y16, G4ThreeVector X16_Y16) {
+  m_DefinitionType.push_back(true);
+
+  m_X1_Y1.push_back(X1_Y1);
+  m_X16_Y1.push_back(X16_Y1);
+  m_X1_Y16.push_back(X1_Y16);
+  m_X16_Y16.push_back(X16_Y16);
+
+  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);
+}
+
+void SuperX3::AddDetector(G4double R, G4double Theta, G4double Phi, G4double beta_u, G4double beta_v, G4double beta_w) {
+  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_X1_Y1.push_back(empty);
+  m_X16_Y1.push_back(empty);
+  m_X1_Y16.push_back(empty);
+  m_X16_Y16.push_back(empty);
+}
+
+void SuperX3::VolumeMaker(G4int DetecNumber, G4ThreeVector position, G4RotationMatrix* rotation,
+                          G4LogicalVolume* world) {
+  G4double NbrTelescopes = DetecNumber;
+  G4String DetectorNumber;
+  ostringstream Number;
+  Number << NbrTelescopes;
+  DetectorNumber = Number.str();
+
+  ////////////////////////////////////////////////////////////////
+  ////////////// Starting Volume Definition //////////////////////
+  ////////////////////////////////////////////////////////////////
+  G4String Name = "SuperX3Square" + DetectorNumber;
+
+  // Definition of the volume containing the sensitive detector
+  G4Box* solidSuperX3 = new G4Box(Name, 0.5 * FaceFront, 0.5 * SiliconFaceLength * mm, 0.5 * Length);
+  G4LogicalVolume* logicSuperX3 = new G4LogicalVolume(solidSuperX3, m_MaterialVacuum, Name, 0, 0, 0);
+
+  new G4PVPlacement(G4Transform3D(*rotation, position), logicSuperX3, Name, world, false, 0);
+
+  logicSuperX3->SetVisAttributes(G4VisAttributes::Invisible);
+  if (m_non_sensitive_part_visiualisation)
+    logicSuperX3->SetVisAttributes(G4VisAttributes(G4Colour(0.90, 0.90, 0.90)));
+
+  // Aluminium dead layers
+  G4ThreeVector positionAluStripFront = G4ThreeVector(0, 0, AluStripBack_PosZ);
+  G4ThreeVector positionAluStripBack = G4ThreeVector(0, 0, AluStripFront_PosZ);
+
+  G4Box* solidAluStrip = new G4Box("AluBox", 0.5 * SiliconFaceWidth, 0.5 * SiliconFaceLength, 0.5 * AluStripThickness);
+  //   G4LogicalVolume* logicAluStrip = new G4LogicalVolume(solidAluStrip,
+  //   m_MaterialAluminium, "logicAluStrip", 0, 0, 0);
+  G4LogicalVolume* logicAluStrip = new G4LogicalVolume(solidAluStrip, m_MaterialVacuum, "logicAluStrip", 0, 0, 0);
+
+  new G4PVPlacement(0, positionAluStripFront, logicAluStrip, Name + "_AluStripFront", logicSuperX3, false, 0);
+  new G4PVPlacement(0, positionAluStripBack, logicAluStrip, Name + "_AluStripBack", logicSuperX3, false, 0);
+
+  logicAluStrip->SetVisAttributes(G4VisAttributes(G4Colour(1.90, 0.0, 0.0)));
+
+  // Silicon detector itself
+  G4ThreeVector positionSilicon = G4ThreeVector(0, 0, Silicon_PosZ);
+
+  G4Box* solidSilicon =
+      new G4Box("solidSilicon", 0.5 * SiliconFaceWidth, 0.5 * SiliconFaceLength * mm, 0.5 * SiliconThickness);
+  G4LogicalVolume* logicSilicon = new G4LogicalVolume(solidSilicon, m_MaterialSilicon, "logicSilicon", 0, 0, 0);
+
+  new G4PVPlacement(0, positionSilicon, logicSilicon, Name + "_Silicon", logicSuperX3, false, 0);
+
+  // Set Silicon strip sensible
+  logicSilicon->SetSensitiveDetector(m_Scorer);
+
+  /// Visualisation of Silicon Strip
+  G4VisAttributes* SiliconVisAtt = new G4VisAttributes(G4Colour(0.0, 0.0, 0.9));
+  logicSilicon->SetVisAttributes(SiliconVisAtt);
+}
+
+// Read stream at Configfile to pick-up parameters of detector (Position,...)
+// Called in DetecorConstruction::ReadDetextorConfiguration Method
+void SuperX3::ReadConfiguration(NPL::InputParser parser) {
+  vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("SuperX3");
+  if (NPOptionManager::getInstance()->GetVerboseLevel())
+    cout << "//// " << blocks.size() << " detectors found " << endl;
+  for (unsigned int i = 0; i < blocks.size(); i++) {
+    // Cartesian Case
+    vector<string> cart = {"X1_Y1", "X1_Y16", "X16_Y1", "X16_Y16", "VIS"};
+    // Spherical Case
+    vector<string> sphe = {"R", "THETA", "PHI", "BETA", "VIS"};
+
+    if (blocks[i]->HasTokenList(cart)) {
+      cout << endl << "////  SuperX3 " << i + 1 << endl;
+      G4ThreeVector A = NPS::ConvertVector(blocks[i]->GetTVector3("X1_Y1", "mm"));
+      G4ThreeVector B = NPS::ConvertVector(blocks[i]->GetTVector3("X16_Y1", "mm"));
+      G4ThreeVector C = NPS::ConvertVector(blocks[i]->GetTVector3("X1_Y16", "mm"));
+      G4ThreeVector D = NPS::ConvertVector(blocks[i]->GetTVector3("X16_Y16", "mm"));
+      if (blocks[i]->GetInt("VIS"))
+        m_non_sensitive_part_visiualisation = true;
+      AddDetector(A, B, C, D);
+    }
+
+    else if (blocks[i]->HasTokenList(sphe)) {
+      cout << endl << "////  SuperX3 " << i + 1 << endl;
+      double Theta = blocks[i]->GetDouble("THETA", "deg");
+      double Phi = blocks[i]->GetDouble("PHI", "deg");
+      double R = blocks[i]->GetDouble("R", "mm");
+      vector<double> beta = blocks[i]->GetVectorDouble("BETA", "deg");
+      if (blocks[i]->GetInt("VIS"))
+        m_non_sensitive_part_visiualisation = true;
+
+      AddDetector(Theta, Phi, R, beta[0], beta[1], beta[2]);
+    }
+
+    else {
+      cout << "ERROR: Missing token for SuperX3 blocks, check your input file" << endl;
+      exit(1);
+    }
+  }
+}
+
+// Construct detector and inialise sensitive part.
+// Called After DetecorConstruction::AddDetector Method
+void SuperX3::ConstructDetector(G4LogicalVolume* world) {
+  G4RotationMatrix* SuperX3rot = NULL;
+  G4ThreeVector SuperX3pos = G4ThreeVector(0, 0, 0);
+  G4ThreeVector SuperX3u = G4ThreeVector(0, 0, 0);
+  G4ThreeVector SuperX3v = G4ThreeVector(0, 0, 0);
+  G4ThreeVector SuperX3w = G4ThreeVector(0, 0, 0);
+  G4ThreeVector SuperX3Center = G4ThreeVector(0, 0, 0);
+
+  G4int NumberOfDetector = m_DefinitionType.size();
+  for (G4int i = 0; i < NumberOfDetector; 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
+      SuperX3u = m_X16_Y1[i] - m_X1_Y1[i];
+      SuperX3u = SuperX3u.unit();
+
+      SuperX3v = m_X1_Y16[i] - m_X1_Y1[i];
+      SuperX3v = SuperX3v.unit();
+
+      SuperX3w = SuperX3u.cross(SuperX3v);
+      SuperX3w = SuperX3w.unit();
+
+      SuperX3Center = (m_X1_Y1[i] + m_X1_Y16[i] + m_X16_Y1[i] + m_X16_Y16[i]) / 4;
+
+      // Passage Matrix from Lab Referential to Telescope Referential
+      SuperX3rot = new G4RotationMatrix(SuperX3u, SuperX3v, SuperX3w);
+      // translation to place Telescope
+      SuperX3pos = SuperX3w * Length * 0.5 + SuperX3Center;
+    }
+
+    // By Angle
+    else {
+      G4double Theta = m_Theta[i];
+      G4double Phi = m_Phi[i];
+
+      // (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);
+      SuperX3w = G4ThreeVector(wX, wY, wZ);
+
+      // vector corresponding to the center of the module
+      SuperX3Center = SuperX3w;
+
+      // vector parallel to one axis of silicon plane
+      G4double ii = cos(Theta / rad) * cos(Phi / rad);
+      G4double jj = cos(Theta / rad) * sin(Phi / rad);
+      G4double kk = -sin(Theta / rad);
+      G4ThreeVector Y = G4ThreeVector(ii, jj, kk);
+
+      SuperX3w = SuperX3w.unit();
+      SuperX3u = SuperX3w.cross(Y);
+      SuperX3v = SuperX3w.cross(SuperX3u);
+      SuperX3v = SuperX3v.unit();
+      SuperX3u = SuperX3u.unit();
+
+      // Passage Matrix from Lab Referential to Telescope Referential
+      // MUST2
+      SuperX3rot = new G4RotationMatrix(SuperX3u, SuperX3v, SuperX3w);
+      // Telescope is rotate of Beta angle around SuperX3v axis.
+      SuperX3rot->rotate(m_beta_u[i], SuperX3u);
+      SuperX3rot->rotate(m_beta_v[i], SuperX3v);
+      SuperX3rot->rotate(m_beta_w[i], SuperX3w);
+      // translation to place Telescope
+      SuperX3pos = SuperX3w * Length * 0.5 + SuperX3Center;
+    }
+
+    VolumeMaker(i + 1, SuperX3pos, SuperX3rot, world);
+  }
+
+  delete SuperX3rot;
+}
+
+// Connect the GaspardTrackingData class to the output TTree
+// of the simulation
+void SuperX3::InitializeRootOutput() {
+  RootOutput* pAnalysis = RootOutput::getInstance();
+  TTree* pTree = pAnalysis->GetTree();
+  if (!pTree->FindBranch("SuperX3")) {
+    pTree->Branch("SuperX3", "TSuperX3Data", &m_Event);
+  }
+  pTree->SetBranchAddress("SuperX3", &m_Event);
+}
+
+// Read sensitive part and fill the Root tree.
+// Called at in the EventAction::EndOfEventAvtion
+void SuperX3::ReadSensitive(const G4Event*) {
+  // Clear ROOT objects
+  m_Event->Clear();
+
+  auto resistive = (DSSDScorers::PS_Resistive*)m_Scorer->GetPrimitive(0);
+  auto sizeUp = resistive->GetUpMult();
+  for (unsigned int i = 0; i < sizeUp; i++) {
+    double energy = resistive->GetEnergyUp(i);
+    double time = resistive->GetTimeUp(i);
+    int det = resistive->GetDetectorUp(i);
+    int strip = resistive->GetStripUp(i);
+    m_Event->SetUpE(det, strip, energy);
+    m_Event->SetUpT(det, strip, time);
+  }
+  auto sizeDown = resistive->GetDownMult();
+  for (unsigned int i = 0; i < sizeDown; i++) {
+    double energy = resistive->GetEnergyDown(i);
+    double time = resistive->GetTimeDown(i);
+    int det = resistive->GetDetectorDown(i);
+    int strip = resistive->GetStripDown(i);
+    m_Event->SetDownE(det, strip, energy);
+    m_Event->SetDownT(det, strip, time);
+  }
+  auto sizeBack = resistive->GetBackMult();
+  for (unsigned int i = 0; i < sizeBack; i++) {
+    double energy = resistive->GetEnergyBack(i);
+    double time = resistive->GetTimeBack(i);
+    int det = resistive->GetDetectorBack(i);
+    m_Event->SetBackE(det, energy);
+    m_Event->SetBackT(det, time);
+  }
+}
+
+void SuperX3::InitializeMaterials() {
+  m_MaterialSilicon = MaterialManager::getInstance()->GetMaterialFromLibrary("Si");
+  m_MaterialAluminium = MaterialManager::getInstance()->GetMaterialFromLibrary("Al");
+  m_MaterialIron = MaterialManager::getInstance()->GetMaterialFromLibrary("Fe");
+  m_MaterialVacuum = MaterialManager::getInstance()->GetMaterialFromLibrary("Vacuum");
+}
+
+void SuperX3::InitializeScorers() {
+  bool already_exist = false;
+  // Associate Scorer
+  m_Scorer = CheckScorer("ScorerSuperX3", already_exist);
+  if (already_exist)
+    return;
+
+  //..... resistive starts..
+  G4VPrimitiveScorer* resistivestrip =
+      new DSSDScorers::PS_Resistive("resistivestrip", 1, SiliconFaceLength, SiliconFaceWidth, NbStrips);
+  //... resistive ends......
+  // and register it to the multifunctionnal detector
+  //.... resistive starts...
+  m_Scorer->RegisterPrimitive(resistivestrip);
+  //.....resistive ends...
+
+  //  Add All Scorer to the Global Scorer Manager
+  G4SDManager::GetSDMpointer()->AddNewDetector(m_Scorer);
+}
+////////////////////////////////////////////////////////////////////////////////
+//            Construct Method to be pass to the DetectorFactory              //
+////////////////////////////////////////////////////////////////////////////////
+NPS::VDetector* SuperX3::Construct() { return (NPS::VDetector*)new SuperX3(); }
+
+////////////////////////////////////////////////////////////////////////////////
+//            Registering the construct method to the factory                 //
+////////////////////////////////////////////////////////////////////////////////
+extern "C" {
+class proxy_nps_w1 {
+ public:
+  proxy_nps_w1() {
+    NPS::DetectorFactory::getInstance()->AddToken("SuperX3", "SuperX3");
+    NPS::DetectorFactory::getInstance()->AddDetector("SuperX3", SuperX3::Construct);
+  }
+};
+
+proxy_nps_w1 p_nps_w1;
+}

NPSimulation/Detectors/SuperX3/SuperX3.hh

+#ifndef SuperX3_h
+#define SuperX3_h 1
+/*****************************************************************************
+ * Copyright (C) 2009-2016   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  : 12/01/11                                                 *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription: Define the SuperX3 detector from Micron *
+ *                                                                           *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+// C++ headers
+#include <vector>
+
+// NPTool header
+#include "NPSVDetector.hh"
+
+// Geant4 headers
+#include "G4MultiFunctionalDetector.hh"
+
+// NPTool - ROOT headers
+#include "NPInputParser.h"
+#include "TSuperX3Data.h"
+using namespace std;
+using namespace CLHEP;
+
+class SuperX3 : public NPS::VDetector {
+  ////////////////////////////////////////////////////
+  /////// Default Constructor and Destructor /////////
+  ////////////////////////////////////////////////////
+ public:
+  SuperX3();
+  virtual ~SuperX3();
+
+  ////////////////////////////////////////////////////
+  //////// Specific Function of this Class ///////////
+  ////////////////////////////////////////////////////
+ public:
+  // Detector positionning
+  // By Position Method
+  void AddDetector(G4ThreeVector TL, G4ThreeVector BL, G4ThreeVector BR,
+                   G4ThreeVector CT);
+  // By Angle Method
+  void AddDetector(G4double R, G4double Theta, G4double Phi, G4double beta_u,
+                   G4double beta_v, G4double beta_w);
+
+  // Effectively construct Volume
+  // Avoid to have two time same code for Angle and Point definition
+  void VolumeMaker(G4int DetecNumber, G4ThreeVector pos, G4RotationMatrix* rot,
+                   G4LogicalVolume* world);
+
+  /////////////////////////////////////////
+  ////  Inherite from NPS::VDetector class /////
+  /////////////////////////////////////////
+ public:
+  // Read stream at Configfile to pick-up parameters of detector (Position,...)
+  // Called in DetecorConstruction::ReadDetextorConfiguration Method
+  void ReadConfiguration(NPL::InputParser);
+
+  // 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);
+
+  ////////////////////////////////////////////////////
+  ///////////Event class to store Data////////////////
+  ////////////////////////////////////////////////////
+ private:
+  TSuperX3Data* m_Event;
+
+  ////////////////////////////////////////////////////
+  //////////////////// Scorers ///////////////////////
+  ////////////////////////////////////////////////////
+ private:
+  G4MultiFunctionalDetector* m_Scorer;
+
+  ////////////////////////////////////////////////////
+  //////////////////// Material //////////////////////
+  ////////////////////////////////////////////////////
+ private:
+  // Declare all material used by theSuperX3 detector
+  void InitializeMaterials();
+
+  //  Vacuum
+  G4Material* m_MaterialVacuum;
+  // Si
+  G4Material* m_MaterialSilicon;
+  // Al
+  G4Material* m_MaterialAluminium;
+  // Iron
+  G4Material* m_MaterialIron;
+
+  ////////////////////////////////////////////////////
+  ///////////////Private intern Data//////////////////
+  ////////////////////////////////////////////////////
+ private:
+  // 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_Y16;   // Bottom Left Corner Position Vector
+  vector<G4ThreeVector> m_X16_Y1;   // Bottom Right Corner Position Vector
+  vector<G4ThreeVector> m_X16_Y16;  // 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;  //  |
+
+  // Set to true if you want to see Telescope Frame in your visualisation
+  bool m_non_sensitive_part_visiualisation;
+
+ public:
+  static NPS::VDetector* Construct();
+};
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+namespace SuperX3SQUARE {
+// Energy/Time resolutions for the different layers
+const G4double EnergyResolution = 12.8e-3;  // 30 keV FWHM
+const G4double TimeResolution = 0.638;      // 1.5 ns (FWHM)
+
+// Geometry
+const G4double FaceFront = 40 * mm;
+const G4double Length = 10 * mm;
+
+// First stage
+//   const G4double AluStripThickness = 0.00000001*micrometer;
+const G4double AluStripThickness = 0.4 * micrometer;
+const G4double SiliconThickness = 1000 * micrometer;
+const G4double SiliconFace = 40.0 * mm;
+const G4double SiliconFaceWidth = 40.0 * mm;
+const G4double SiliconFaceLength = 75.0 * mm;
+// const G4double SiliconFaceWidtht  = 75*mm;
+// const G4double SiliconFaceLengtht = 39.6*mm;
+// Characteristics
+const G4int NbStrips = 4;
+
+// Starting at the front and going in direction of third stage
+const G4double AluStripFront_PosZ = Length * -0.5 + 0.5 * AluStripThickness;
+const G4double Silicon_PosZ =
+    AluStripFront_PosZ + 0.5 * AluStripThickness + 0.5 * SiliconThickness;
+const G4double AluStripBack_PosZ =
+    Silicon_PosZ + 0.5 * SiliconThickness + 0.5 * AluStripThickness;
+}  // namespace SuperX3SQUARE
+
+#endif

Projects/S034/PhysicsListOption.txt

 EmPhysicsList Option4
-DefaultCutOff 1
+DefaultCutOff 10
 IonBinaryCascadePhysics 0
 NPIonInelasticPhysics 0
 EmExtraPhysics 0

Projects/Strasse/PhysicsListOption.txt

 EmPhysicsList Option4
-DefaultCutOff 1000000
+DefaultCutOff 1000
 IonBinaryCascadePhysics 0
 NPIonInelasticPhysics 0
 EmExtraPhysics 0

Projects/Strasse/geometry/catana_only.detector

@@ -11,7 +11,7 @@ Target
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%1
 Catana CSV
- Path= geometry/Catana.csv 
+ Path= geometry/CATANA_nptool_sim.csv 
  Pos= 0 0 100 mm
  Rshift= 100 micrometer
 

Projects/Strasse/geometry/strasse_CAD.detector

@@ -87,15 +87,15 @@ Strasse Outer
   Ref= 0 0 0 mm
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%Strasse InactiveMaterial
-% Chamber= ./geometry/STRASSE_Chamber.stl
-% Stars= ./geometry/STRASSE_StarSupports.stl
-% Base= ./geometry/STRASSE_Base.stl
-% Blades= ./geometry/STRASSE_Blades.stl
+Strasse InactiveMaterial
+ Chamber= ./geometry/STRASSE_Chamber.stl
+ Stars= ./geometry/STRASSE_StarSupports.stl
+ Base= ./geometry/STRASSE_Base.stl
+ Blades= ./geometry/STRASSE_Blades.stl
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%1
-%Catana CSV
-% Path= geometry/Catana.csv 
-% Pos= 0 0 100 mm
-% Rshift= 100 micrometer
+Catana CSV
+ Path= geometry/Catana.csv 
+ Pos= 0 0 100 mm
+ Rshift= 100 micrometer
 
 

Projects/Strasse/geometry/strasse_July2021.detector

@@ -93,9 +93,9 @@ Strasse Outer
 % Base= ./geometry/STRASSE_Base.stl
 % Blades= ./geometry/STRASSE_Blades.stl
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%1
-%Catana CSV
-% Path= geometry/Catana.csv 
-% Pos= 0 0 100 mm
-% Rshift= 100 micrometer
+Catana CSV
+ Path= geometry/Catana.csv 
+ Pos= 0 0 100 mm
+ Rshift= 100 micrometer
 
 

Projects/Strasse/reaction/C12_p2p.reaction

@@ -20,7 +20,7 @@ QFSReaction
  KnockedOut= 1H
  Heavy= 11B
  ExcitationEnergyBeam= 0.0 MeV
- ExcitationEnergyHeavy= 0.0 MeV
+ ExcitationEnergyHeavy= 1.0 MeV
  MomentumSigma= 50.0 
  ShootHeavy= 1
  ShootLight= 1