diff --git a/Inputs/CrossSection/sofia.txt b/Inputs/CrossSection/sofia.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f746adbf9d162c0542da29ded000378c368537be
--- /dev/null
+++ b/Inputs/CrossSection/sofia.txt
@@ -0,0 +1,53 @@
+0 1
+0.1 1
+0.2 1
+0.3 1
+0.4 1
+0.5 1
+0.6 1
+0.7 1
+0.8 1
+0.9 1
+1 1
+1.1 1
+1.2 1
+1.3 1
+1.4 1
+1.5 1
+1.6 1
+1.7 1
+1.8 1
+1.9 1
+2 1
+2.1 1
+2.2 1
+2.3 1
+2.4 1
+2.5 1
+2.6 1
+2.7 1
+2.8 1
+2.9 1
+3 1
+3.1 1
+3.2 1
+3.3 1
+3.4 1
+3.5 1
+3.6 1
+3.7 1
+3.8 1
+3.9 1
+4 1
+4.1 0
+4.2 0
+4.3 0
+4.4 0
+4.5 0
+4.6 0
+4.7 0
+4.8 0
+4.9 0
+5 0
+5.1 0
+180 0
diff --git a/Inputs/EventGenerator/sofia.reaction b/Inputs/EventGenerator/sofia.reaction
new file mode 100644
index 0000000000000000000000000000000000000000..c7c54e908a5cb9fcbf3d7f3663008c2222908f54
--- /dev/null
+++ b/Inputs/EventGenerator/sofia.reaction
@@ -0,0 +1,34 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%% Reaction file for 238U transfer reaction %%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%Beam energy given in MeV ; Excitation in MeV ; emmitance in rad
+Beam
+ Particle= 238U
+ Energy= 166000
+ SigmaEnergy= 2
+ SigmaX= 1 cm
+ SigmaY= 1 cm
+ SigmaThetaX= 0
+ SigmaPhiY= 0
+ MeanThetaX= 0
+ MeanPhiY= 0
+ MeanX= 0
+ MeanY= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+TwoBodyReaction
+ Beam= 238U
+ Target= 208Pb
+ Light= 208Pb
+ Heavy= 238U
+ ExcitationEnergyLight= 0.0
+ ExcitationEnergyHeavy= 15.0
+ CrossSectionPath= sofia.txt CS
+ ShootLight= 1
+ ShootHeavy= 1
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+FissionDecay
+ CompoundNucleus= 238U
+ FissionModel= GEF
+ Shoot_FF= 1
+ Shoot_neutron= 0
+ Shoot_gamma= 0
diff --git a/NPLib/Detectors/Sofia/CMakeLists.txt b/NPLib/Detectors/Sofia/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5669724d43fb231d151c6d86c7fa75fe33187cc8
--- /dev/null
+++ b/NPLib/Detectors/Sofia/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_custom_command(OUTPUT TSofiaPhysicsDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TSofiaPhysics.h TSofiaPhysicsDict.cxx TSofiaPhysics.rootmap libNPSofia.dylib DEPENDS TSofiaPhysics.h)
+add_custom_command(OUTPUT TSofiaDataDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TSofiaData.h TSofiaDataDict.cxx TSofiaData.rootmap libNPSofia.dylib DEPENDS TSofiaData.h)
+add_library(NPSofia SHARED TSofiaSpectra.cxx TSofiaData.cxx TSofiaPhysics.cxx TSofiaDataDict.cxx TSofiaPhysicsDict.cxx )
+target_link_libraries(NPSofia ${ROOT_LIBRARIES} NPCore)
+install(FILES TSofiaData.h TSofiaPhysics.h TSofiaSpectra.h DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
+
diff --git a/NPLib/Detectors/Sofia/TSofiaData.cxx b/NPLib/Detectors/Sofia/TSofiaData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b49f65f4a716d95bea17e53030ca19ecc1a025f7
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaData.cxx
@@ -0,0 +1,65 @@
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Raw data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+#include "TSofiaData.h"
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+using namespace std;
+
+ClassImp(TSofiaData)
+
+
+//////////////////////////////////////////////////////////////////////
+TSofiaData::TSofiaData() {
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+TSofiaData::~TSofiaData() {
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+void TSofiaData::Clear() {
+ // Energy
+ fTOF_DetectorNbr.clear();
+ fTOF_PlasticNbr.clear();
+ fTOF_Energy.clear();
+ fTOF_Time.clear();
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+void TSofiaData::Dump() const {
+ // This method is very useful for debuging and worth the dev.
+ cout << "XXXXXXXXXXXXXXXXXXXXXXXX New Event [TSofiaData::Dump()] XXXXXXXXXXXXXXXXX" << endl;
+
+ // Energy
+ size_t mysize = fTOF_DetectorNbr.size();
+ cout << "TOF_Mult: " << mysize << endl;
+
+}
diff --git a/NPLib/Detectors/Sofia/TSofiaData.h b/NPLib/Detectors/Sofia/TSofiaData.h
new file mode 100644
index 0000000000000000000000000000000000000000..492ae08bf288edc27a33c4b9e9e2dd065c5cd899
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaData.h
@@ -0,0 +1,87 @@
+#ifndef __SofiaDATA__
+#define __SofiaDATA__
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Raw data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// STL
+#include <vector>
+using namespace std;
+
+// ROOT
+#include "TObject.h"
+
+class TSofiaData : public TObject {
+ //////////////////////////////////////////////////////////////
+ // data members are hold into vectors in order
+ // to allow multiplicity treatment
+ private:
+ vector<int> fTOF_DetectorNbr;
+ vector<int> fTOF_PlasticNbr;
+ vector<double> fTOF_Energy;
+ vector<double> fTOF_Time;
+
+
+
+ //////////////////////////////////////////////////////////////
+ // Constructor and destructor
+ public:
+ TSofiaData();
+ ~TSofiaData();
+
+
+ //////////////////////////////////////////////////////////////
+ // Inherited from TObject and overriden to avoid warnings
+ public:
+ void Clear();
+ void Clear(const Option_t*) {};
+ void Dump() const;
+
+
+ //////////////////////////////////////////////////////////////
+ // Getters and Setters
+ // Prefer inline declaration to avoid unnecessary called of
+ // frequently used methods
+ // add //! to avoid ROOT creating dictionnary for the methods
+ public:
+ ////////////////////// SETTERS ////////////////////////
+ inline void SetDetectorNbr(int det){fTOF_DetectorNbr.push_back(det);};//!
+ inline void SetPlasticNbr(int plastic){fTOF_PlasticNbr.push_back(plastic);};//!
+ inline void SetEnergy(double Energy){fTOF_Energy.push_back(Energy);};//!
+ inline void SetTime(double Time){fTOF_Time.push_back(Time);};//!
+
+
+
+ ////////////////////// GETTERS ////////////////////////
+ // Energy
+ inline int GetMultiplicity() const {return fTOF_PlasticNbr.size();}
+ inline int GetDetectorNbr(const unsigned int &i) const {return fTOF_DetectorNbr[i];}//!
+ inline int GetPlasticNbr(const unsigned int &i) const {return fTOF_PlasticNbr[i];}//!
+ inline double GetEnergy(const unsigned int &i) const {return fTOF_Energy[i];}//!
+ inline double GetTime(const unsigned int &i) const {return fTOF_Time[i];}//!
+
+
+ //////////////////////////////////////////////////////////////
+ // Required for ROOT dictionnary
+ ClassDef(TSofiaData,1) // SofiaData structure
+};
+
+#endif
diff --git a/NPLib/Detectors/Sofia/TSofiaPhysics.cxx b/NPLib/Detectors/Sofia/TSofiaPhysics.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..ce6f5fc40da0551fc4dac3fbd078d0f01c74eeff
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaPhysics.cxx
@@ -0,0 +1,337 @@
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Treated data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+#include "TSofiaPhysics.h"
+
+// STL
+#include <sstream>
+#include <iostream>
+#include <cmath>
+#include <stdlib.h>
+#include <limits>
+using namespace std;
+
+// NPL
+#include "RootInput.h"
+#include "RootOutput.h"
+#include "NPDetectorFactory.h"
+#include "NPOptionManager.h"
+
+// ROOT
+#include "TChain.h"
+
+ClassImp(TSofiaPhysics)
+
+
+///////////////////////////////////////////////////////////////////////////
+TSofiaPhysics::TSofiaPhysics()
+ : m_EventData(new TSofiaData),
+ m_PreTreatedData(new TSofiaData),
+ m_EventPhysics(this),
+ m_Spectra(0),
+ m_E_RAW_Threshold(0), // adc channels
+ m_E_Threshold(0), // MeV
+ m_NumberOfDetectors(0) {
+}
+
+///////////////////////////////////////////////////////////////////////////
+/// A usefull method to bundle all operation to add a detector
+void TSofiaPhysics::AddDetector(TVector3 , string ){
+ // In That simple case nothing is done
+ // Typically for more complex detector one would calculate the relevant
+ // positions (stripped silicon) or angles (gamma array)
+ m_NumberOfDetectors++;
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::AddDetector(double R, double Theta, double Phi, string shape){
+ // Compute the TVector3 corresponding
+ TVector3 Pos(R*sin(Theta)*cos(Phi),R*sin(Theta)*sin(Phi),R*cos(Theta));
+ // Call the cartesian method
+ AddDetector(Pos,shape);
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::BuildSimplePhysicalEvent() {
+ BuildPhysicalEvent();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::BuildPhysicalEvent() {
+ // apply thresholds and calibration
+ PreTreat();
+
+ // match energy and time together
+ unsigned int mysizeE = m_PreTreatedData->GetMultiplicity();
+ for (UShort_t e = 0; e < mysizeE ; e++) {
+ DetectorNumber.push_back(m_PreTreatedData->GetDetectorNbr(e));
+ PlasticNumber.push_back(m_PreTreatedData->GetPlasticNbr(e));
+ Energy.push_back(m_PreTreatedData->GetEnergy(e));
+ Time.push_back(m_PreTreatedData->GetTime(e));
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::PreTreat() {
+ // This method typically applies thresholds and calibrations
+ // Might test for disabled channels for more complex detector
+
+ // clear pre-treated object
+ ClearPreTreatedData();
+
+ // instantiate CalibrationManager
+ static CalibrationManager* Cal = CalibrationManager::getInstance();
+
+ // Energy
+ unsigned int mysize = m_EventData->GetMultiplicity();
+ for (UShort_t i = 0; i < mysize ; ++i) {
+ if (m_EventData->GetEnergy(i) > m_E_RAW_Threshold) {
+ Double_t Energy = Cal->ApplyCalibration("Sofia/ENERGY"+NPL::itoa(m_EventData->GetPlasticNbr(i)),m_EventData->GetEnergy(i));
+ if (Energy > m_E_Threshold) {
+ m_PreTreatedData->SetDetectorNbr(m_EventData->GetDetectorNbr(i));
+ m_PreTreatedData->SetPlasticNbr(m_EventData->GetPlasticNbr(i));
+ m_PreTreatedData->SetTime(m_EventData->GetTime(i));
+ m_PreTreatedData->SetEnergy(Energy);
+ }
+ }
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::ReadAnalysisConfig() {
+ bool ReadingStatus = false;
+
+ // path to file
+ string FileName = "./configs/ConfigSofia.dat";
+
+ // open analysis config file
+ ifstream AnalysisConfigFile;
+ AnalysisConfigFile.open(FileName.c_str());
+
+ if (!AnalysisConfigFile.is_open()) {
+ cout << " No ConfigSofia.dat found: Default parameter loaded for Analayis " << FileName << endl;
+ return;
+ }
+ cout << " Loading user parameter for Analysis from ConfigSofia.dat " << endl;
+
+ // Save it in a TAsciiFile
+ TAsciiFile* asciiConfig = RootOutput::getInstance()->GetAsciiFileAnalysisConfig();
+ asciiConfig->AppendLine("%%% ConfigSofia.dat %%%");
+ asciiConfig->Append(FileName.c_str());
+ asciiConfig->AppendLine("");
+ // read analysis config file
+ string LineBuffer,DataBuffer,whatToDo;
+ while (!AnalysisConfigFile.eof()) {
+ // Pick-up next line
+ getline(AnalysisConfigFile, LineBuffer);
+
+ // search for "header"
+ string name = "ConfigSofia";
+ if (LineBuffer.compare(0, name.length(), name) == 0)
+ ReadingStatus = true;
+
+ // loop on tokens and data
+ while (ReadingStatus ) {
+ whatToDo="";
+ AnalysisConfigFile >> whatToDo;
+
+ // Search for comment symbol (%)
+ if (whatToDo.compare(0, 1, "%") == 0) {
+ AnalysisConfigFile.ignore(numeric_limits<streamsize>::max(), '\n' );
+ }
+
+ else if (whatToDo=="E_RAW_THRESHOLD") {
+ AnalysisConfigFile >> DataBuffer;
+ m_E_RAW_Threshold = atof(DataBuffer.c_str());
+ cout << whatToDo << " " << m_E_RAW_Threshold << endl;
+ }
+
+ else if (whatToDo=="E_THRESHOLD") {
+ AnalysisConfigFile >> DataBuffer;
+ m_E_Threshold = atof(DataBuffer.c_str());
+ cout << whatToDo << " " << m_E_Threshold << endl;
+ }
+
+ else {
+ ReadingStatus = false;
+ }
+ }
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::Clear() {
+ DetectorNumber.clear();
+ PlasticNumber.clear();
+ Energy.clear();
+ Time.clear();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::ReadConfiguration(NPL::InputParser parser) {
+ vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("Sofia");
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << "//// " << blocks.size() << " detectors found " << endl;
+
+ vector<string> cart = {"POS","Shape"};
+ vector<string> sphe = {"R","Theta","Phi","Shape"};
+
+ for(unsigned int i = 0 ; i < blocks.size() ; i++){
+ if(blocks[i]->HasTokenList(cart)){
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << endl << "//// Sofia " << i+1 << endl;
+
+ TVector3 Pos = blocks[i]->GetTVector3("POS","mm");
+ string Shape = blocks[i]->GetString("Shape");
+ AddDetector(Pos,Shape);
+ }
+ else if(blocks[i]->HasTokenList(sphe)){
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << endl << "//// Sofia " << i+1 << endl;
+ double R = blocks[i]->GetDouble("R","mm");
+ double Theta = blocks[i]->GetDouble("Theta","deg");
+ double Phi = blocks[i]->GetDouble("Phi","deg");
+ string Shape = blocks[i]->GetString("Shape");
+ AddDetector(R,Theta,Phi,Shape);
+ }
+ else{
+ cout << "ERROR: check your input file formatting " << endl;
+ exit(1);
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::InitSpectra() {
+ m_Spectra = new TSofiaSpectra(m_NumberOfDetectors);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::FillSpectra() {
+ m_Spectra -> FillRawSpectra(m_EventData);
+ m_Spectra -> FillPreTreatedSpectra(m_PreTreatedData);
+ m_Spectra -> FillPhysicsSpectra(m_EventPhysics);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::CheckSpectra() {
+ m_Spectra->CheckSpectra();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::ClearSpectra() {
+ // To be done
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+map< string , TH1*> TSofiaPhysics::GetSpectra() {
+ if(m_Spectra)
+ return m_Spectra->GetMapHisto();
+ else{
+ map< string , TH1*> empty;
+ return empty;
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::WriteSpectra() {
+ m_Spectra->WriteSpectra();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::AddParameterToCalibrationManager() {
+ CalibrationManager* Cal = CalibrationManager::getInstance();
+ for (int i = 0; i < m_NumberOfDetectors; ++i) {
+ Cal->AddParameter("Sofia", "D"+ NPL::itoa(i+1)+"_ENERGY","Sofia_D"+ NPL::itoa(i+1)+"_ENERGY");
+ Cal->AddParameter("Sofia", "D"+ NPL::itoa(i+1)+"_TIME","Sofia_D"+ NPL::itoa(i+1)+"_TIME");
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::InitializeRootInputRaw() {
+ TChain* inputChain = RootInput::getInstance()->GetChain();
+ inputChain->SetBranchStatus("Sofia", true );
+ inputChain->SetBranchAddress("Sofia", &m_EventData );
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::InitializeRootInputPhysics() {
+ TChain* inputChain = RootInput::getInstance()->GetChain();
+ inputChain->SetBranchAddress("Sofia", &m_EventPhysics);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TSofiaPhysics::InitializeRootOutput() {
+ TTree* outputTree = RootOutput::getInstance()->GetTree();
+ outputTree->Branch("Sofia", "TSofiaPhysics", &m_EventPhysics);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPL::VDetector* TSofiaPhysics::Construct() {
+ return (NPL::VDetector*) new TSofiaPhysics();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern "C"{
+class proxy_Sofia{
+ public:
+ proxy_Sofia(){
+ NPL::DetectorFactory::getInstance()->AddToken("Sofia","Sofia");
+ NPL::DetectorFactory::getInstance()->AddDetector("Sofia",TSofiaPhysics::Construct);
+ }
+};
+
+proxy_Sofia p_Sofia;
+}
+
diff --git a/NPLib/Detectors/Sofia/TSofiaPhysics.h b/NPLib/Detectors/Sofia/TSofiaPhysics.h
new file mode 100644
index 0000000000000000000000000000000000000000..984de993ee33784ace9fc9629592713dfe768b1c
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaPhysics.h
@@ -0,0 +1,181 @@
+#ifndef TSofiaPHYSICS_H
+#define TSofiaPHYSICS_H
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Treated data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// C++ headers
+#include <vector>
+#include <map>
+#include <string>
+using namespace std;
+
+// ROOT headers
+#include "TObject.h"
+#include "TH1.h"
+#include "TVector3.h"
+// NPTool headers
+#include "TSofiaData.h"
+#include "TSofiaSpectra.h"
+#include "NPCalibrationManager.h"
+#include "NPVDetector.h"
+#include "NPInputParser.h"
+// forward declaration
+class TSofiaSpectra;
+
+
+
+class TSofiaPhysics : public TObject, public NPL::VDetector {
+ //////////////////////////////////////////////////////////////
+ // constructor and destructor
+ public:
+ TSofiaPhysics();
+ ~TSofiaPhysics() {};
+
+
+ //////////////////////////////////////////////////////////////
+ // Inherited from TObject and overriden to avoid warnings
+ public:
+ void Clear();
+ void Clear(const Option_t*) {};
+
+
+ //////////////////////////////////////////////////////////////
+ // data obtained after BuildPhysicalEvent() and stored in
+ // output ROOT file
+ public:
+ vector<int> DetectorNumber;
+ vector<int> PlasticNumber;
+ vector<double> Energy;
+ vector<double> Time;
+
+ /// A usefull method to bundle all operation to add a detector
+ void AddDetector(TVector3 POS, string shape);
+ void AddDetector(double R, double Theta, double Phi, string shape);
+
+ //////////////////////////////////////////////////////////////
+ // methods inherited from the VDetector ABC class
+ public:
+ // read stream from ConfigFile to pick-up detector parameters
+ void ReadConfiguration(NPL::InputParser);
+
+ // add parameters to the CalibrationManger
+ void AddParameterToCalibrationManager();
+
+ // method called event by event, aiming at extracting the
+ // physical information from detector
+ void BuildPhysicalEvent();
+
+ // same as BuildPhysicalEvent() method but with a simpler
+ // treatment
+ void BuildSimplePhysicalEvent();
+
+ // same as above but for online analysis
+ void BuildOnlinePhysicalEvent() {BuildPhysicalEvent();};
+
+ // activate raw data object and branches from input TChain
+ // in this method mother branches (Detector) AND daughter leaves
+ // (fDetector_parameter) have to be activated
+ void InitializeRootInputRaw();
+
+ // activate physics data object and branches from input TChain
+ // in this method mother branches (Detector) AND daughter leaves
+ // (fDetector_parameter) have to be activated
+ void InitializeRootInputPhysics();
+
+ // create branches of output ROOT file
+ void InitializeRootOutput();
+
+ // clear the raw and physical data objects event by event
+ void ClearEventPhysics() {Clear();}
+ void ClearEventData() {m_EventData->Clear();}
+
+ // methods related to the TSofiaSpectra class
+ // instantiate the TSofiaSpectra class and
+ // declare list of histograms
+ void InitSpectra();
+
+ // fill the spectra
+ void FillSpectra();
+
+ // used for Online mainly, sanity check for histograms and
+ // change their color if issues are found, for example
+ void CheckSpectra();
+
+ // used for Online only, clear all the spectra
+ void ClearSpectra();
+
+ // write spectra to ROOT output file
+ void WriteSpectra();
+
+
+ //////////////////////////////////////////////////////////////
+ // specific methods to Sofia array
+ public:
+ // remove bad channels, calibrate the data and apply thresholds
+ void PreTreat();
+
+ // clear the pre-treated object
+ void ClearPreTreatedData() {m_PreTreatedData->Clear();}
+
+ // read the user configuration file. If no file is found, load standard one
+ void ReadAnalysisConfig();
+
+ // give and external TSofiaData object to TSofiaPhysics.
+ // needed for online analysis for example
+ void SetRawDataPointer(TSofiaData* rawDataPointer) {m_EventData = rawDataPointer;}
+
+ // objects are not written in the TTree
+ private:
+ TSofiaData* m_EventData; //!
+ TSofiaData* m_PreTreatedData; //!
+ TSofiaPhysics* m_EventPhysics; //!
+
+ // getters for raw and pre-treated data object
+ public:
+ TSofiaData* GetRawData() const {return m_EventData;}
+ TSofiaData* GetPreTreatedData() const {return m_PreTreatedData;}
+
+ // parameters used in the analysis
+ private:
+ // thresholds
+ double m_E_RAW_Threshold; //!
+ double m_E_Threshold; //!
+
+ // number of detectors
+ private:
+ int m_NumberOfDetectors; //!
+
+ // spectra class
+ private:
+ TSofiaSpectra* m_Spectra; // !
+
+ // spectra getter
+ public:
+ map<string, TH1*> GetSpectra();
+
+ // Static constructor to be passed to the Detector Factory
+ public:
+ static NPL::VDetector* Construct();
+
+ ClassDef(TSofiaPhysics,1) // SofiaPhysics structure
+};
+#endif
diff --git a/NPLib/Detectors/Sofia/TSofiaSpectra.cxx b/NPLib/Detectors/Sofia/TSofiaSpectra.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2cd43574b09af67e0a3ec8d84e78ed050c157df8
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaSpectra.cxx
@@ -0,0 +1,156 @@
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Spectra *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// class header
+#include "TSofiaSpectra.h"
+
+// STL
+#include <iostream>
+#include <string>
+using namespace std;
+
+// NPTool header
+#include "NPOptionManager.h"
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TSofiaSpectra::TSofiaSpectra()
+ : fNumberOfDetectors(0) {
+ SetName("Sofia");
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TSofiaSpectra::TSofiaSpectra(unsigned int NumberOfDetectors) {
+ if(NPOptionManager::getInstance()->GetVerboseLevel()>0)
+ cout << "************************************************" << endl
+ << "TSofiaSpectra : Initalizing control spectra for "
+ << NumberOfDetectors << " Detectors" << endl
+ << "************************************************" << endl ;
+ SetName("Sofia");
+ fNumberOfDetectors = NumberOfDetectors;
+
+ InitRawSpectra();
+ InitPreTreatedSpectra();
+ InitPhysicsSpectra();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TSofiaSpectra::~TSofiaSpectra() {
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::InitRawSpectra() {
+ static string name;
+ for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
+ // Energy
+ name = "Sofia"+NPL::itoa(i+1)+"_ENERGY_RAW";
+ AddHisto1D(name, name, 4096, 0, 16384, "Sofia/RAW");
+ // Time
+ name = "Sofia"+NPL::itoa(i+1)+"_TIME_RAW";
+ AddHisto1D(name, name, 4096, 0, 16384, "Sofia/RAW");
+ } // end loop on number of detectors
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::InitPreTreatedSpectra() {
+ static string name;
+ for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
+ // Energy
+ name = "Sofia"+NPL::itoa(i+1)+"_ENERGY_CAL";
+ AddHisto1D(name, name, 500, 0, 25, "Sofia/CAL");
+ // Time
+ name = "Sofia"+NPL::itoa(i+1)+"_TIME_CAL";
+ AddHisto1D(name, name, 500, 0, 25, "Sofia/CAL");
+
+
+ } // end loop on number of detectors
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::InitPhysicsSpectra() {
+ static string name;
+ // Kinematic Plot
+ name = "Sofia_ENERGY_TIME";
+ AddHisto2D(name, name, 500, 0, 500, 500, 0, 50, "Sofia/PHY");
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::FillRawSpectra(TSofiaData* RawData) {
+ static string name;
+ static string family;
+
+ // Energy
+ unsigned int sizeE = RawData->GetMultiplicity();
+ for (unsigned int i = 0; i < sizeE; i++) {
+ name = "Sofia"+NPL::itoa(RawData->GetPlasticNbr(i))+"_ENERGY_RAW";
+ family = "Sofia/RAW";
+
+ FillSpectra(family,name,RawData->GetEnergy(i));
+ }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::FillPreTreatedSpectra(TSofiaData* PreTreatedData) {
+ static string name;
+ static string family;
+
+ // Energy
+ unsigned int sizeE = PreTreatedData->GetMultiplicity();
+ for (unsigned int i = 0; i < sizeE; i++) {
+ name = "Sofia"+NPL::itoa(PreTreatedData->GetPlasticNbr(i))+"_ENERGY_CAL";
+ family = "Sofia/CAL";
+
+ FillSpectra(family,name,PreTreatedData->GetEnergy(i));
+ }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TSofiaSpectra::FillPhysicsSpectra(TSofiaPhysics* Physics) {
+ static string name;
+ static string family;
+ family= "Sofia/PHY";
+
+ // Energy vs time
+ unsigned int sizeE = Physics->Energy.size();
+ for(unsigned int i = 0 ; i < sizeE ; i++){
+ name = "Sofia_ENERGY_TIME";
+ FillSpectra(family,name,Physics->Energy[i],Physics->Time[i]);
+ }
+}
+
diff --git a/NPLib/Detectors/Sofia/TSofiaSpectra.h b/NPLib/Detectors/Sofia/TSofiaSpectra.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce0fef524a259cec57699f30c84c00dbcae12ee6
--- /dev/null
+++ b/NPLib/Detectors/Sofia/TSofiaSpectra.h
@@ -0,0 +1,62 @@
+#ifndef TSofiaSPECTRA_H
+#define TSofiaSPECTRA_H
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Sofia Spectra *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// NPLib headers
+#include "NPVSpectra.h"
+#include "TSofiaData.h"
+#include "TSofiaPhysics.h"
+
+// Forward Declaration
+class TSofiaPhysics;
+
+
+class TSofiaSpectra : public VSpectra {
+ //////////////////////////////////////////////////////////////
+ // constructor and destructor
+ public:
+ TSofiaSpectra();
+ TSofiaSpectra(unsigned int NumberOfDetectors);
+ ~TSofiaSpectra();
+
+ //////////////////////////////////////////////////////////////
+ // Initialization methods
+ private:
+ void InitRawSpectra();
+ void InitPreTreatedSpectra();
+ void InitPhysicsSpectra();
+
+ //////////////////////////////////////////////////////////////
+ // Filling methods
+ public:
+ void FillRawSpectra(TSofiaData*);
+ void FillPreTreatedSpectra(TSofiaData*);
+ void FillPhysicsSpectra(TSofiaPhysics*);
+
+ //////////////////////////////////////////////////////////////
+ // Detector parameters
+ private:
+ unsigned int fNumberOfDetectors;
+};
+
+#endif
diff --git a/NPLib/Physics/GEF.cxx b/NPLib/Physics/GEF.cxx
index e4b4ec5ca2b2c1fa40692fbd542159d6e004330b..91fe62db97e6fc50f6da7d2fb091cc5eaa605099 100644
--- a/NPLib/Physics/GEF.cxx
+++ b/NPLib/Physics/GEF.cxx
@@ -553,9 +553,10 @@ void GEF::FissionGENERAL()
{
float ZsqrA_fis;
- //ZsqrA_fis = Csng(I_Z_CN^2) / Csng(I_A_CN);
- ZsqrA_fis = pow(I_Z_CN,2)/I_A_CN;
- Escission_lim = 0;//900.0 * exp(-ZsqrA_fis/13.0); // from PRC 86 (2012) 034605
+ ZsqrA_fis = Csng(I_Z_CN^2) / Csng(I_A_CN);
+ //ZsqrA_fis = pow(I_Z_CN,2)/I_A_CN;
+ //Escission_lim = 0;//900.0 * exp(-ZsqrA_fis/13.0); // from PRC 86 (2012) 034605
+ Escission_lim = 900.0 * exp(-ZsqrA_fis/13.0); // from PRC 86 (2012) 034605
CentralZ_FM();
I_N_CN = I_A_CN - I_Z_CN;
MeanDefScission();
diff --git a/NPLib/include/NPXmlParser.cxx b/NPLib/include/NPXmlParser.cxx
deleted file mode 100644
index 55ad5f5917930b0335c59f225580ddf95728e53f..0000000000000000000000000000000000000000
--- a/NPLib/include/NPXmlParser.cxx
+++ /dev/null
@@ -1,144 +0,0 @@
-#include "NPXmlParser.h"
-#include <stdio.h>
-#include <iostream>
-using namespace NPL;
-
-////////////////////////////////////////////////////////////////////////////////
-block::block(){};
-block::~block(){};
-int block::AsInt(std::string name){
- parameter p(name,"void");
- auto it = m_parameters.find(p);
- if(it!=m_parameters.end()){
- std::string s = it->GetValue();
- return atoi(s.c_str());
- }
- else
- return -1000;
-}
-
-double block::AsDouble(std::string name){
- parameter p(name,"void");
- auto it = m_parameters.find(p);
- if(it!=m_parameters.end()){
- std::string s = it->GetValue();
- return atof(s.c_str());
- }
- else
- return -1000;
-}
-std::string block::AsString(std::string name){
- parameter p(name,"void");
- auto it = m_parameters.find(p);
- if(it!=m_parameters.end()){
- std::string s = it->GetValue();
- return s;
- }
- else
- return "void";
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-parameter::parameter(){};
-parameter::~parameter(){};
-
-////////////////////////////////////////////////////////////////////////////////
-Channel::Channel(){};
-Channel::~Channel(){};
-
-////////////////////////////////////////////////////////////////////////////////
-void XmlParser::LoadFile(std::string file){
- // First create engine
- TXMLEngine* xml = new TXMLEngine;
- // Now try to parse xml file
- // Only file with restricted xml syntax are supported
- XMLDocPointer_t xmldoc = xml->ParseFile(file.c_str());
- if (xmldoc==0) {
- delete xml;
- return;
- }
- // take access to main node
- XMLNodePointer_t mainnode = xml->DocGetRootElement(xmldoc);
- // display recursively all nodes and subnodes
- LoadNode(xml, mainnode, 1);
-
- // Release memory before exit
- xml->FreeDoc(xmldoc);
- delete xml;
- }
-
-//////////////////////////////////////////////////////////////////////////////////
-void XmlParser::DisplayNode(TXMLEngine* xml, XMLNodePointer_t node, Int_t level){
- // this function display all accessible information about xml node and its children
- printf("%*c node: %s\n",level,' ', xml->GetNodeName(node));
- // display namespace
- XMLNsPointer_t ns = xml->GetNS(node);
- if (ns!=0)
- printf("%*c namespace: %s refer: %s\n",level+2,' ', xml->GetNSName(ns), xml->GetNSReference(ns));
- // display attributes
- XMLAttrPointer_t attr = xml->GetFirstAttr(node);
- while (attr!=0) {
- printf("%*c attr: %s value: %s\n",level+2,' ', xml->GetAttrName(attr), xml->GetAttrValue(attr));
- attr = xml->GetNextAttr(attr);
- }
- // display content (if exists)
- const char* content = xml->GetNodeContent(node);
- if (content!=0)
- printf("%*c cont: %s\n",level+2,' ', content);
- // display all child nodes
- XMLNodePointer_t child = xml->GetChild(node);
- while (child!=0) {
- DisplayNode(xml, child, level+2);
- child = xml->GetNext(child);
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-void XmlParser::LoadNode(TXMLEngine* xml, XMLNodePointer_t node, Int_t level){
- // namespace
- XMLNsPointer_t ns = xml->GetNS(node);
- XMLNodePointer_t child = xml->GetChild(node);
- if(xml->GetNodeName(child)=="dataroot"){// main node
- std::cout <<" Loading XML file" << std::endl;
- }
- else{
- while(child!=0) {
- block b;
- // getting attribute:
- XMLNodePointer_t param = xml->GetChild(child);
- while (param!=0) {
- parameter p(xml->GetNodeName(param),xml->GetNodeContent(param));
- b.AddParameter(p);
- param=xml->GetNext(param);
- }
- std::string name = xml->GetNodeName(child);
- m_blocks[name].push_back(b);
- child = xml->GetNext(child);
- }
- std::cout << " XML file loaded for " <<m_blocks.size() << " detectors" << std::endl;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-std::vector<NPL::block*> XmlParser::GetAllBlocksWithName(std::string name){
- std::vector<NPL::block*> res;
- auto it=m_blocks.find(name);
-
- if(it!=m_blocks.end()){
- unsigned int size = it->second.size();
- for(unsigned int i = 0 ; i < size ; i++){
- res.push_back(&(it->second[i]));
- }
- }
-
- return res;
- }
-/////////////////////////////////////////////////////////////////////////////////
-std::vector<std::string> XmlParser::GetAllBlocksName(){
- std::vector<std::string> res;
- for(auto it=m_blocks.begin(); it!= m_blocks.end();++it){
- res.push_back(it->first);
- }
- return res;
- }
diff --git a/NPSimulation/Detectors/Sofia/CMakeLists.txt b/NPSimulation/Detectors/Sofia/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..57854b49ed30d7b99868c71c28384e9b166f801b
--- /dev/null
+++ b/NPSimulation/Detectors/Sofia/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_library(NPSSofia SHARED Sofia.cc)
+target_link_libraries(NPSSofia NPSCore ${ROOT_LIBRARIES} ${Geant4_LIBRARIES} ${NPLib_LIBRARIES} -lNPSofia)
diff --git a/NPSimulation/Detectors/Sofia/Sofia.cc b/NPSimulation/Detectors/Sofia/Sofia.cc
new file mode 100644
index 0000000000000000000000000000000000000000..437b3b60797ccae004eb6a08f19c37264b320ddb
--- /dev/null
+++ b/NPSimulation/Detectors/Sofia/Sofia.cc
@@ -0,0 +1,333 @@
+/******************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr*
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *----------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe a simple Sofia setup for simulation *
+ * *
+ *----------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ ******************************************************************************/
+
+// C++ headers
+#include <sstream>
+#include <cmath>
+#include <limits>
+//G4 Geometry object
+#include "G4Tubs.hh"
+#include "G4Box.hh"
+
+//G4 sensitive
+#include "G4SDManager.hh"
+#include "G4MultiFunctionalDetector.hh"
+
+//G4 various object
+#include "G4Material.hh"
+#include "G4Transform3D.hh"
+#include "G4PVPlacement.hh"
+#include "G4VisAttributes.hh"
+#include "G4Colour.hh"
+#include "G4FieldManager.hh"
+#include "G4UniformMagField.hh"
+#include "G4TransportationManager.hh"
+
+// NPTool header
+#include "Sofia.hh"
+#include "CalorimeterScorers.hh"
+#include "InteractionScorers.hh"
+#include "RootOutput.h"
+#include "MaterialManager.hh"
+#include "NPSDetectorFactory.hh"
+#include "NPOptionManager.h"
+#include "NPSHitsMap.hh"
+// CLHEP header
+#include "CLHEP/Random/RandGauss.h"
+
+using namespace std;
+using namespace CLHEP;
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+namespace Sofia_NS{
+ // Energy and time Resolution
+ const double EnergyThreshold = 0.1*MeV;
+ const double ResoTime = 0.007*ns;
+ const double ResoEnergy = 1.0*MeV;
+ const double tof_plastic_height = 660*mm;
+ const double tof_plastic_width = 32*mm;
+ const double tof_plastic_thickness = 0.5*mm;
+ const string Material = "BC400";
+
+ const double GLAD_height = 3*m;
+ const double GLAD_width = 5*m;
+ const double GLAD_length = 2*m;
+
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Sofia Specific Method
+Sofia::Sofia(){
+ m_Event = new TSofiaData() ;
+ m_TofScorer = 0;
+ m_PlasticTof = 0;
+ m_TofWall = 0;
+
+ m_GLAD_MagField = 0;
+ m_GLAD_DistanceFromTarget = 0;
+ // RGB Color + Transparency
+ m_VisSquare = new G4VisAttributes(G4Colour(0.3, 0.8, 0.2, 0.5));
+ m_VisGLAD = new G4VisAttributes(G4Colour(0.5, 0.5, 0.5, 0.5));
+}
+
+Sofia::~Sofia(){
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void Sofia::AddDetector(G4ThreeVector POS){
+ // Convert the POS value to R theta Phi as Spherical coordinate is easier in G4
+ m_R.push_back(POS.mag());
+ m_Theta.push_back(POS.theta());
+ m_Phi.push_back(POS.phi());
+}
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void Sofia::AddDetector(double R, double Theta, double Phi){
+ m_R.push_back(R);
+ m_Theta.push_back(Theta);
+ m_Phi.push_back(Phi);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+G4AssemblyVolume* Sofia::BuildTOFDetector(){
+ m_TofWall = new G4AssemblyVolume();
+
+ if(!m_PlasticTof){
+ G4Box* box = new G4Box("Sofia_Box",Sofia_NS::tof_plastic_height*0.5,
+ Sofia_NS::tof_plastic_width*0.5,Sofia_NS::tof_plastic_thickness*0.5);
+
+ G4Material* DetectorMaterial = MaterialManager::getInstance()->GetMaterialFromLibrary(Sofia_NS::Material);
+ m_PlasticTof = new G4LogicalVolume(box,DetectorMaterial,"logic_Sofia_Box",0,0,0);
+ m_PlasticTof->SetVisAttributes(m_VisSquare);
+ m_PlasticTof->SetSensitiveDetector(m_TofScorer);
+
+ G4RotationMatrix* Rv = new G4RotationMatrix(0,0,0);
+ G4ThreeVector Tv;
+ Tv.setX(0);
+ Tv.setY(0);
+ Tv.setZ(0);
+ for(unsigned int i=0; i<28; i++){
+ int k = -14+i;
+ Tv.setY(k*(Sofia_NS::tof_plastic_width+0.5));
+ m_TofWall->AddPlacedVolume(m_PlasticTof, Tv, Rv);
+ }
+
+ }
+ return m_TofWall;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+G4LogicalVolume* Sofia::BuildGLAD()
+{
+ G4Box* box = new G4Box("glad_Box",Sofia_NS::GLAD_width*0.5,
+ Sofia_NS::GLAD_height*0.5,Sofia_NS::GLAD_length*0.5);
+
+ G4Material* GLADMaterial = MaterialManager::getInstance()->GetMaterialFromLibrary("Vaccuum");
+ m_GLAD = new G4LogicalVolume(box,GLADMaterial,"logic_GLAD_Box",0,0,0);
+ m_GLAD->SetVisAttributes(m_VisGLAD);
+
+
+ G4UniformMagField* magField = new G4UniformMagField(G4ThreeVector(0,m_GLAD_MagField,0));
+ //G4FieldManager* fieldMgr = G4TransportationManager::GetTransportationManager()->GetFieldManager();
+ G4FieldManager* fieldMgr = new G4FieldManager(magField);
+
+ //fieldMgr->SetDetectorField(magField);
+
+ fieldMgr->CreateChordFinder(magField);
+
+ m_GLAD->SetFieldManager(fieldMgr,true);
+
+ return m_GLAD;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Virtual Method of NPS::VDetector class
+
+// Read stream at Configfile to pick-up parameters of detector (Position,...)
+// Called in DetecorConstruction::ReadDetextorConfiguration Method
+void Sofia::ReadConfiguration(NPL::InputParser parser){
+ vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("Sofia");
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << "//// " << blocks.size() << " detectors found " << endl;
+
+ vector<string> cart = {"POS","Build_GLAD"};
+ vector<string> sphe = {"R","Theta","Phi","Build_GLAD"};
+
+ for(unsigned int i = 0 ; i < blocks.size() ; i++){
+ if(blocks[i]->HasTokenList(cart)){
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << endl << "//// Sofia " << i+1 << endl;
+
+ G4ThreeVector Pos = NPS::ConvertVector(blocks[i]->GetTVector3("POS","mm"));
+ m_Build_GLAD = blocks[i]->GetInt("Build_GLAD");
+ AddDetector(Pos);
+ }
+ else if(blocks[i]->HasTokenList(sphe)){
+ if(NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << endl << "//// Sofia " << i+1 << endl;
+ double R = blocks[i]->GetDouble("R","mm");
+ double Theta = blocks[i]->GetDouble("Theta","deg");
+ double Phi = blocks[i]->GetDouble("Phi","deg");
+ m_Build_GLAD = blocks[i]->GetInt("Build_GLAD");
+ m_GLAD_MagField = blocks[i]->GetDouble("GLAD_MagField","T");
+ m_GLAD_DistanceFromTarget = blocks[i]->GetDouble("GLAD_DistanceFromTarget", "m");
+ AddDetector(R,Theta,Phi);
+ }
+ else{
+ cout << "ERROR: check your input file formatting " << endl;
+ exit(1);
+ }
+ }
+}
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+// Construct detector and inialise sensitive part.
+// Called After DetecorConstruction::AddDetector Method
+void Sofia::ConstructDetector(G4LogicalVolume* world){
+ for (unsigned short i = 0 ; i < m_R.size() ; i++) {
+
+ G4double wX = m_R[i] * sin(m_Theta[i] ) * cos(m_Phi[i] ) ;
+ G4double wY = m_R[i] * sin(m_Theta[i] ) * sin(m_Phi[i] ) ;
+ G4double wZ = m_R[i] * cos(m_Theta[i] ) ;
+ G4ThreeVector Det_pos = G4ThreeVector(wX, wY, wZ) ;
+ // So the face of the detector is at R instead of the middle
+ Det_pos+=Det_pos.unit()*Sofia_NS::tof_plastic_thickness*0.5;
+ // Building Detector reference frame
+ G4double ii = cos(m_Theta[i]) * cos(m_Phi[i]);
+ G4double jj = cos(m_Theta[i]) * sin(m_Phi[i]);
+ G4double kk = -sin(m_Theta[i]);
+
+ G4ThreeVector Y(ii,jj,kk);
+ G4ThreeVector w = Det_pos.unit();
+ G4ThreeVector u = w.cross(Y);
+ G4ThreeVector v = w.cross(u);
+ v = v.unit();
+ u = u.unit();
+
+ G4RotationMatrix* Rot = new G4RotationMatrix(u,v,w);
+
+ BuildTOFDetector()->MakeImprint(world,Det_pos,Rot);
+
+ if(m_Build_GLAD==1){
+ G4ThreeVector GLAD_pos = G4ThreeVector(0,0,m_GLAD_DistanceFromTarget+0.5*Sofia_NS::GLAD_length);
+ new G4PVPlacement(0, GLAD_pos,
+ BuildGLAD(),
+ "GLAD",
+ world, false, 0);
+ }
+
+
+ }
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Add Detector branch to the EventTree.
+// Called After DetecorConstruction::AddDetector Method
+void Sofia::InitializeRootOutput(){
+ RootOutput *pAnalysis = RootOutput::getInstance();
+ TTree *pTree = pAnalysis->GetTree();
+ if(!pTree->FindBranch("Sofia")){
+ pTree->Branch("Sofia", "TSofiaData", &m_Event) ;
+ }
+ pTree->SetBranchAddress("Sofia", &m_Event) ;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Read sensitive part and fill the Root tree.
+// Called at in the EventAction::EndOfEventAvtion
+void Sofia::ReadSensitive(const G4Event* ){
+ m_Event->Clear();
+
+ ///////////
+ // Calorimeter scorer
+ CalorimeterScorers::PS_Calorimeter* Scorer= (CalorimeterScorers::PS_Calorimeter*) m_TofScorer->GetPrimitive(0);
+
+ unsigned int size = Scorer->GetMult();
+ for(unsigned int i = 0 ; i < size ; i++){
+ vector<unsigned int> level = Scorer->GetLevel(i);
+ double Energy = RandGauss::shoot(Scorer->GetEnergy(i),Sofia_NS::ResoEnergy);
+ if(Energy>Sofia_NS::EnergyThreshold){
+ double Time = RandGauss::shoot(Scorer->GetTime(i),Sofia_NS::ResoTime);
+ int DetectorNbr = level[0];
+ int PlasticNbr = level[1]-1;
+ m_Event->SetDetectorNbr(DetectorNbr);
+ m_Event->SetPlasticNbr(PlasticNbr);
+ m_Event->SetEnergy(Energy);
+ m_Event->SetTime(Time);
+ //cout << DetectorNbr << " " << PlasticNbr << " " << Energy << " " << Time << endl;
+ }
+ }
+ //m_Event->Dump();
+ Scorer->clear();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////
+void Sofia::InitializeScorers() {
+ // This check is necessary in case the geometry is reloaded
+ bool already_exist = false;
+ m_TofScorer = CheckScorer("SofiaScorer",already_exist) ;
+
+ if(already_exist)
+ return ;
+
+ // Otherwise the scorer is initialised
+ vector<int> level;
+ level.push_back(1);
+ level.push_back(0);
+ G4VPrimitiveScorer* Calorimeter= new CalorimeterScorers::PS_Calorimeter("Calorimeter",level, 0) ;
+ G4VPrimitiveScorer* Interaction= new InteractionScorers::PS_Interactions("Interaction",ms_InterCoord, 0) ;
+ //and register it to the multifunctionnal detector
+ m_TofScorer->RegisterPrimitive(Calorimeter);
+ m_TofScorer->RegisterPrimitive(Interaction);
+ G4SDManager::GetSDMpointer()->AddNewDetector(m_TofScorer) ;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPS::VDetector* Sofia::Construct(){
+ return (NPS::VDetector*) new Sofia();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern"C" {
+ class proxy_nps_Sofia{
+ public:
+ proxy_nps_Sofia(){
+ NPS::DetectorFactory::getInstance()->AddToken("Sofia","Sofia");
+ NPS::DetectorFactory::getInstance()->AddDetector("Sofia",Sofia::Construct);
+ }
+ };
+
+ proxy_nps_Sofia p_nps_Sofia;
+}
diff --git a/NPSimulation/Detectors/Sofia/Sofia.hh b/NPSimulation/Detectors/Sofia/Sofia.hh
new file mode 100644
index 0000000000000000000000000000000000000000..0aa87f7a10c1b6d38284187a81729958f9cd54b2
--- /dev/null
+++ b/NPSimulation/Detectors/Sofia/Sofia.hh
@@ -0,0 +1,120 @@
+#ifndef Sofia_h
+#define Sofia_h 1
+/*****************************************************************************
+ * Copyright (C) 2009-2020 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: Pierre Morfouace contact address: pierre.morfouace2@cea.fr *
+ * *
+ * Creation Date : November 2020 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Sofia simulation *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+// C++ header
+#include <string>
+#include <vector>
+using namespace std;
+
+// G4 headers
+#include "G4ThreeVector.hh"
+#include "G4RotationMatrix.hh"
+#include "G4LogicalVolume.hh"
+#include "G4MultiFunctionalDetector.hh"
+#include "G4AssemblyVolume.hh"
+
+// NPTool header
+#include "NPSVDetector.hh"
+#include "TSofiaData.h"
+#include "NPInputParser.h"
+
+class Sofia : public NPS::VDetector{
+ ////////////////////////////////////////////////////
+ /////// Default Constructor and Destructor /////////
+ ////////////////////////////////////////////////////
+ public:
+ Sofia() ;
+ virtual ~Sofia() ;
+
+ ////////////////////////////////////////////////////
+ /////// Specific Function of this Class ///////////
+ ////////////////////////////////////////////////////
+ public:
+ // Cartesian
+ void AddDetector(G4ThreeVector POS);
+ // Spherical
+ void AddDetector(double R,double Theta,double Phi);
+
+
+ G4AssemblyVolume* BuildTOFDetector();
+ G4LogicalVolume* BuildGLAD();
+
+ private:
+ G4LogicalVolume* m_PlasticTof;
+ G4LogicalVolume* m_GLAD;
+ G4AssemblyVolume* m_TofWall;
+
+ ////////////////////////////////////////////////////
+ ////// 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() ;
+
+ // Read sensitive part and fill the Root tree.
+ // Called at in the EventAction::EndOfEventAvtion
+ void ReadSensitive(const G4Event* event) ;
+
+ public: // Scorer
+ // Initialize all Scorer used by the MUST2Array
+ void InitializeScorers() ;
+
+ // Associated Scorer
+ G4MultiFunctionalDetector* m_TofScorer ;
+ ////////////////////////////////////////////////////
+ ///////////Event class to store Data////////////////
+ ////////////////////////////////////////////////////
+ private:
+ TSofiaData* m_Event ;
+
+ ////////////////////////////////////////////////////
+ ///////////////Private intern Data//////////////////
+ ////////////////////////////////////////////////////
+ private: // Geometry
+ // Detector Coordinate
+ vector<double> m_R;
+ vector<double> m_Theta;
+ vector<double> m_Phi;
+
+ int m_Build_GLAD;
+ double m_GLAD_MagField;
+ double m_GLAD_DistanceFromTarget;
+
+ // Visualisation Attribute
+ G4VisAttributes* m_VisSquare;
+ G4VisAttributes* m_VisGLAD;
+
+ // Needed for dynamic loading of the library
+ public:
+ static NPS::VDetector* Construct();
+};
+#endif
diff --git a/Projects/Sofia/.gitignore b/Projects/Sofia/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3ed1a0bc5543756a8eec83cda3a6483250aa8556
--- /dev/null
+++ b/Projects/Sofia/.gitignore
@@ -0,0 +1 @@
+*.detector
diff --git a/Projects/Sofia/Analysis.cxx b/Projects/Sofia/Analysis.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..362615c9f7b31a4c867142ec975d6604901f9c8a
--- /dev/null
+++ b/Projects/Sofia/Analysis.cxx
@@ -0,0 +1,68 @@
+/*****************************************************************************
+ * 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: XAUTHORX contact address: XMAILX *
+ * *
+ * Creation Date : XMONTHX XYEARX *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Sofia analysis project *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+#include<iostream>
+using namespace std;
+#include"Analysis.h"
+#include"NPAnalysisFactory.h"
+#include"NPDetectorManager.h"
+////////////////////////////////////////////////////////////////////////////////
+Analysis::Analysis(){
+}
+////////////////////////////////////////////////////////////////////////////////
+Analysis::~Analysis(){
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::Init(){
+ Sofia= (TSofiaPhysicsPhysics*) m_DetectorManager->GetDetector("Sofia");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::TreatEvent(){
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::End(){
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPL::VAnalysis* Analysis::Construct(){
+ return (NPL::VAnalysis*) new Analysis();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern "C"{
+class proxy{
+ public:
+ proxy(){
+ NPL::AnalysisFactory::getInstance()->SetConstructor(Analysis::Construct);
+ }
+};
+
+proxy p;
+}
+
diff --git a/Projects/Sofia/Analysis.h b/Projects/Sofia/Analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4f50f8fa6873e70fd1fe525307f3aab84a684b2
--- /dev/null
+++ b/Projects/Sofia/Analysis.h
@@ -0,0 +1,42 @@
+#ifndef Analysis_h
+#define Analysis_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: XAUTHORX contact address: XMAILX *
+ * *
+ * Creation Date : XMONTHX XYEARX *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Sofia analysis project *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+#include"NPVAnalysis.h"
+#include"TSofiaPhysics.h"
+class Analysis: public NPL::VAnalysis{
+ public:
+ Analysis();
+ ~Analysis();
+
+ public:
+ void Init();
+ void TreatEvent();
+ void End();
+
+ static NPL::VAnalysis* Construct();
+
+ private:
+ TSofiaPhysics* Sofia;
+
+};
+#endif
diff --git a/Projects/Sofia/CMakeLists.txt b/Projects/Sofia/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22c74affdfc45019bdda2594f8439c52d4ab97ec
--- /dev/null
+++ b/Projects/Sofia/CMakeLists.txt
@@ -0,0 +1,5 @@
+cmake_minimum_required (VERSION 2.8)
+# Setting the policy to match Cmake version
+cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+# include the default NPAnalysis cmake file
+include("../../NPLib/ressources/CMake/NPAnalysis.cmake")
diff --git a/Projects/Sofia/PhysicsListOption.txt b/Projects/Sofia/PhysicsListOption.txt
new file mode 100644
index 0000000000000000000000000000000000000000..997b53714ff05b3378f2f0c0dd6837202358990a
--- /dev/null
+++ b/Projects/Sofia/PhysicsListOption.txt
@@ -0,0 +1,11 @@
+EmPhysicsList Option4
+DefaultCutOff 100
+IonBinaryCascadePhysics 0
+NPIonInelasticPhysics 0
+EmExtraPhysics 0
+HadronElasticPhysics 0
+StoppingPhysics 0
+OpticalPhysics 0
+HadronPhysicsINCLXX 0
+HadronPhysicsQGSP_BIC_HP 0
+Decay 0
diff --git a/Projects/Sofia/sofia.detector b/Projects/Sofia/sofia.detector
new file mode 100644
index 0000000000000000000000000000000000000000..2169ee897754ad40039862d6a07d1404ee009b4a
--- /dev/null
+++ b/Projects/Sofia/sofia.detector
@@ -0,0 +1,19 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Target
+ THICKNESS= 2 mm
+ RADIUS= 40 mm
+ MATERIAL= Pb
+ ANGLE= 0 deg
+ X= 0 mm
+ Y= 0 mm
+ Z= 0 m
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Sofia
+ R= 8 m
+ THETA= -9 deg
+ PHI= 0 deg
+ Build_GLAD= 1
+ GLAD_DistanceFromTarget= 3.5 m
+ GLAD_MagField= 1.8 T
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+