diff --git a/Inputs/DetectorConfiguration/Miniball.detector b/Inputs/DetectorConfiguration/Miniball.detector
new file mode 100644
index 0000000000000000000000000000000000000000..9976a96e08f73070186a02fdcf1b506333e82957
--- /dev/null
+++ b/Inputs/DetectorConfiguration/Miniball.detector
@@ -0,0 +1,61 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+GeneralTarget
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Target
+ THICKNESS= 10
+ RADIUS= 20
+ MATERIAL= CD2
+ ANGLE= 0
+ X= 0
+ Y= 0
+ Z= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 125
+ PHI= 320
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 125
+ PHI= 220
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 67
+ PHI= 320
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 67
+ PHI= 220
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 67
+ PHI= 40
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 67
+ PHI= 140
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 125
+ PHI= 40
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Miniball
+ R= 110
+ THETA= 125
+ PHI= 140
+ Shape= Square
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
diff --git a/Inputs/EventGenerator/24Nadp.reaction b/Inputs/EventGenerator/24Nadp.reaction
index bbf681d3b20a44e3f2eb0bcc6bcb0a1bb0e54e68..89e3e5c4383c0ec716770b879b456ff2da52117b 100644
--- a/Inputs/EventGenerator/24Nadp.reaction
+++ b/Inputs/EventGenerator/24Nadp.reaction
@@ -1,5 +1,6 @@
%%%%%%%%%%%%%%%%%%%%%% S1107 at Triumf %%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Beam
Particle= 24Na
ExcitationEnergy= 0
@@ -16,7 +17,6 @@ Beam
%EnergyProfilePath=
%XThetaXProfilePath=
%YPhiYProfilePath=
-
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
TwoBodyReaction
Beam= 24Na
@@ -25,16 +25,17 @@ TwoBodyReaction
Heavy= 25Na
ExcitationEnergyLight= 0.0
ExcitationEnergyHeavy= 2.2
- CrossSectionPath= flat.txt CSR
+ CrossSectionPath= flat.txt CSR
ShootLight= 1
ShootHeavy= 1
-
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%GammaDecay 25Na
- Cascade
- BranchingRatio= 70
- Energies= 2.2
- DifferentialCrossSection= 11Li(d,3He)10He.txt Gamma25Na
- Cascade
- BranchingRatio= 30
- Energies= 1.0 1.2
+GammaDecay 25Na
+Cascade
+ BranchingRatio= 70
+ Energies= 2.2
+ DifferentialCrossSection= 11Li(d,3He)10He.txt Gamma25Na
+Cascade
+ BranchingRatio= 30
+ Energies= 1.0 1.2
+
+
diff --git a/NPLib/Detectors/Miniball/CMakeLists.txt b/NPLib/Detectors/Miniball/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56254714f37e01bcb16d16062da6d869a7900ef7
--- /dev/null
+++ b/NPLib/Detectors/Miniball/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_custom_command(OUTPUT TMiniballPhysicsDict.cxx COMMAND ../../scripts/build_dict.sh TMiniballPhysics.h TMiniballPhysicsDict.cxx TMiniballPhysics.rootmap libNPMiniball.dylib DEPENDS TMiniballPhysics.h)
+add_custom_command(OUTPUT TMiniballDataDict.cxx COMMAND ../../scripts/build_dict.sh TMiniballData.h TMiniballDataDict.cxx TMiniballData.rootmap libNPMiniball.dylib DEPENDS TMiniballData.h)
+add_library(NPMiniball SHARED TMiniballSpectra.cxx TMiniballData.cxx TMiniballPhysics.cxx TMiniballDataDict.cxx TMiniballPhysicsDict.cxx )
+target_link_libraries(NPMiniball ${ROOT_LIBRARIES} NPCore)
+install(FILES TMiniballData.h TMiniballPhysics.h TMiniballSpectra.h DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
+
diff --git a/NPLib/Detectors/Miniball/TMiniballData.cxx b/NPLib/Detectors/Miniball/TMiniballData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6b8f79458387deefedbd8633cbc50f79cb1606bf
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballData.cxx
@@ -0,0 +1,93 @@
+/*****************************************************************************
+ * 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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Raw data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+#include "TMiniballData.h"
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+using namespace std;
+
+ClassImp(TMiniballData)
+
+
+//////////////////////////////////////////////////////////////////////
+TMiniballData::TMiniballData() {
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+TMiniballData::~TMiniballData() {
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+void TMiniballData::Clear() {
+ // Energy
+ fMiniball_E_DetectorNbr.clear();
+ fMiniball_Energy.clear();
+
+ // Angle
+ fMiniball_A_DetectorNbr.clear();
+ fMiniball_Angle.clear();
+
+ // Time
+ fMiniball_T_DetectorNbr.clear();
+ fMiniball_Time.clear();
+}
+
+
+//////////////////////////////////////////////////////////////////////
+void TMiniballData::Dump() const {
+ // This method is very useful for debuging and worth the dev.
+ cout << "XXXXXXXXXXXXXXXXXXXXXXXX New Event [TMiniballData::Dump()] XXXXXXXXXXXXXXXXX" << endl;
+
+ // Energy
+ size_t mysize = fMiniball_E_DetectorNbr.size();
+ cout << "Miniball_E_Mult: " << mysize << endl;
+
+ for (size_t i = 0 ; i < mysize ; i++){
+ cout << "DetNbr: " << fMiniball_E_DetectorNbr[i]
+ << " Energy: " << fMiniball_Energy[i];
+ }
+
+ // Angle
+ mysize = fMiniball_A_DetectorNbr.size();
+ cout << "Miniball_E_Mult: " << mysize << endl;
+
+ for (size_t i = 0 ; i < mysize ; i++){
+ cout << "DetNbr: " << fMiniball_A_DetectorNbr[i]
+ << " Angle: " << fMiniball_Angle[i];
+ }
+
+
+ // Time
+ mysize = fMiniball_T_DetectorNbr.size();
+ cout << "Miniball_T_Mult: " << mysize << endl;
+
+ for (size_t i = 0 ; i < mysize ; i++){
+ cout << "DetNbr: " << fMiniball_T_DetectorNbr[i]
+ << " Time: " << fMiniball_Time[i];
+ }
+}
diff --git a/NPLib/Detectors/Miniball/TMiniballData.h b/NPLib/Detectors/Miniball/TMiniballData.h
new file mode 100644
index 0000000000000000000000000000000000000000..41ee5719a351931318b10a59aa9e3de2b1b9f5b7
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballData.h
@@ -0,0 +1,139 @@
+#ifndef __MiniballDATA__
+#define __MiniballDATA__
+/*****************************************************************************
+ * 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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Raw data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// STL
+#include <vector>
+using namespace std;
+
+// ROOT
+#include "TObject.h"
+
+class TMiniballData : public TObject {
+ //////////////////////////////////////////////////////////////
+ // data members are hold into vectors in order
+ // to allow multiplicity treatment
+ private:
+ // Energy
+ vector<UShort_t> fMiniball_E_DetectorNbr;
+ vector<Double_t> fMiniball_Energy;
+
+ // Angle
+ vector<UShort_t> fMiniball_A_DetectorNbr;
+ vector<Double_t> fMiniball_Angle;
+
+ // Time
+ vector<UShort_t> fMiniball_T_DetectorNbr;
+ vector<Double_t> fMiniball_Time;
+
+
+ //////////////////////////////////////////////////////////////
+ // Constructor and destructor
+ public:
+ TMiniballData();
+ virtual ~TMiniballData();
+
+
+ //////////////////////////////////////////////////////////////
+ // 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 ////////////////////////
+ // Energy
+ inline void SetE_DetectorNbr(const UShort_t& DetNbr)
+ {fMiniball_E_DetectorNbr.push_back(DetNbr);} //!
+ inline void Set_Energy(const Double_t& Energy)
+ {fMiniball_Energy.push_back(Energy);}//!
+ // Prefer global setter so that all vectors have the same size
+ inline void SetEnergy(const UShort_t& DetNbr,const Double_t& Energy) {
+ SetE_DetectorNbr(DetNbr);
+ Set_Energy(Energy);
+ };//!
+
+ // Angle
+ inline void SetA_DetectorNbr(const UShort_t& DetNbr)
+ {fMiniball_A_DetectorNbr.push_back(DetNbr);} //!
+ inline void Set_Angle(const Double_t& Angle)
+ {fMiniball_Angle.push_back(Angle);}//!
+ // Prefer global setter so that all vectors have the same size
+ inline void SetAngle(const UShort_t& DetNbr,const Double_t& Angle) {
+ SetA_DetectorNbr(DetNbr);
+ Set_Angle(Angle);
+ };//!
+
+
+ // Time
+ inline void SetT_DetectorNbr(const UShort_t& DetNbr)
+ {fMiniball_T_DetectorNbr.push_back(DetNbr);} //!
+ inline void Set_Time(const Double_t& Time)
+ {fMiniball_Time.push_back(Time);}//!
+ // Prefer global setter so that all vectors have the same size
+ inline void SetTime(const UShort_t& DetNbr,const Double_t& Time) {
+ SetT_DetectorNbr(DetNbr);
+ Set_Time(Time);
+ };//!
+
+
+ ////////////////////// GETTERS ////////////////////////
+ // Energy
+ inline UShort_t GetMultEnergy() const
+ {return fMiniball_E_DetectorNbr.size();}
+ inline UShort_t GetE_DetectorNbr(const unsigned int &i) const
+ {return fMiniball_E_DetectorNbr[i];}//!
+ inline Double_t Get_Energy(const unsigned int &i) const
+ {return fMiniball_Energy[i];}//!
+
+ // Angle
+ inline UShort_t GetMultAngle() const
+ {return fMiniball_A_DetectorNbr.size();}
+ inline UShort_t GetA_DetectorNbr(const unsigned int &i) const
+ {return fMiniball_A_DetectorNbr[i];}//!
+ inline Double_t Get_Angle(const unsigned int &i) const
+ {return fMiniball_Angle[i];}//!
+
+
+ // Time
+ inline UShort_t GetMultTime() const
+ {return fMiniball_T_DetectorNbr.size();}
+ inline UShort_t GetT_DetectorNbr(const unsigned int &i) const
+ {return fMiniball_T_DetectorNbr[i];}//!
+ inline Double_t Get_Time(const unsigned int &i) const
+ {return fMiniball_Time[i];}//!
+
+
+ //////////////////////////////////////////////////////////////
+ // Required for ROOT dictionnary
+ ClassDef(TMiniballData,1) // MiniballData structure
+};
+
+#endif
diff --git a/NPLib/Detectors/Miniball/TMiniballPhysics.cxx b/NPLib/Detectors/Miniball/TMiniballPhysics.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5ff42cdfcdce17281f8f81c0b481142442992aff
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballPhysics.cxx
@@ -0,0 +1,399 @@
+/*****************************************************************************
+ * 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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Treated data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+#include "TMiniballPhysics.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"
+
+// ROOT
+#include "TChain.h"
+
+ClassImp(TMiniballPhysics)
+
+
+ ///////////////////////////////////////////////////////////////////////////
+TMiniballPhysics::TMiniballPhysics()
+ : m_EventData(new TMiniballData),
+ m_PreTreatedData(new TMiniballData),
+ m_EventPhysics(this),
+ m_Spectra(0),
+ m_E_RAW_Threshold(0), // adc channels
+ m_E_Threshold(0), // MeV
+ m_NumberOfDetectors(0) {
+ }
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::BuildSimplePhysicalEvent() {
+ BuildPhysicalEvent();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::BuildPhysicalEvent() {
+ // apply thresholds and calibration
+ PreTreat();
+ // match energy and time together
+ for (UShort_t e = 0; e < m_PreTreatedData->GetMultEnergy(); e++) {
+ for (UShort_t t = 0; t < m_PreTreatedData->GetMultTime(); t++) {
+ for (UShort_t a = 0; a < m_PreTreatedData->GetMultAngle(); a++) {
+
+ if (m_PreTreatedData->GetE_DetectorNbr(e) == m_PreTreatedData->GetT_DetectorNbr(t)
+ && m_PreTreatedData->GetE_DetectorNbr(e) == m_PreTreatedData->GetA_DetectorNbr(a)) {
+ DetectorNumber.push_back(m_PreTreatedData->GetE_DetectorNbr(e));
+ Energy.push_back(m_PreTreatedData->Get_Energy(e));
+ Angle.push_back(m_PreTreatedData->Get_Angle(a));
+ Time.push_back(m_PreTreatedData->Get_Time(t));
+ }
+ }
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::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
+
+ for (UShort_t i = 0; i < m_EventData->GetMultEnergy(); ++i) {
+ if (m_EventData->Get_Energy(i) > m_E_RAW_Threshold) {
+ Double_t Energy = Cal->ApplyCalibration("Miniball/ENERGY"+NPL::itoa(m_EventData->GetE_DetectorNbr(i)),m_EventData->Get_Energy(i));
+ if (Energy > m_E_Threshold) {
+ m_PreTreatedData->SetEnergy(m_EventData->GetE_DetectorNbr(i), Energy);
+ }
+ }
+ }
+
+ // Angle
+ for (UShort_t i = 0; i < m_EventData->GetMultAngle(); ++i) {
+ Double_t Angle = m_EventData->Get_Angle(i);
+ m_PreTreatedData->SetAngle(m_EventData->GetA_DetectorNbr(i), Angle);
+ }
+
+ // Time
+ for (UShort_t i = 0; i < m_EventData->GetMultTime(); ++i) {
+ Double_t Time= Cal->ApplyCalibration("Miniball/TIME"+NPL::itoa(m_EventData->GetT_DetectorNbr(i)),m_EventData->Get_Time(i));
+ m_PreTreatedData->SetTime(m_EventData->GetT_DetectorNbr(i), Time);
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::ReadAnalysisConfig() {
+ bool ReadingStatus = false;
+
+ // path to file
+ string FileName = "./configs/ConfigMiniball.dat";
+
+ // open analysis config file
+ ifstream AnalysisConfigFile;
+ AnalysisConfigFile.open(FileName.c_str());
+
+ if (!AnalysisConfigFile.is_open()) {
+ cout << " No ConfigMiniball.dat found: Default parameter loaded for Analayis " << FileName << endl;
+ return;
+ }
+ cout << " Loading user parameter for Analysis from ConfigMiniball.dat " << endl;
+
+ // Save it in a TAsciiFile
+ TAsciiFile* asciiConfig = RootOutput::getInstance()->GetAsciiFileAnalysisConfig();
+ asciiConfig->AppendLine("%%% ConfigMiniball.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 = "ConfigMiniball";
+ 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 TMiniballPhysics::Clear() {
+ DetectorNumber.clear();
+ Energy.clear();
+ Angle.clear();
+ Time.clear();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::ReadConfiguration(string Path) {
+ ifstream ConfigFile ;
+ ConfigFile.open(Path.c_str()) ;
+ string LineBuffer ;
+ string DataBuffer ;
+
+ bool check_Theta = false ;
+ bool check_Phi = false ;
+ bool check_R = false ;
+ bool ReadingStatus = false ;
+
+ while (!ConfigFile.eof()){
+
+ getline(ConfigFile, LineBuffer);
+
+ // If line is a Start Up Miniball bloc, Reading toggle to true
+ string name="Miniball";
+ if (LineBuffer.compare(0, name.length(), name) == 0){
+ cout << "///" << endl ;
+ cout << "Miniball found: " << endl ;
+ ReadingStatus = true ;
+ }
+
+ // Reading Block
+ while(ReadingStatus)
+ {
+ // Pickup Next Word
+ ConfigFile >> DataBuffer ;
+
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {
+ ConfigFile.ignore ( std::numeric_limits<std::streamsize>::max(), '\n' );
+ }
+
+ // Finding another telescope (safety), toggle out
+ else if (DataBuffer.compare(0, name.length(), name) == 0) {
+ cout << "\033[1;311mWARNING: Another detector is find before standard sequence of Token, Error may occured in detector definition\033[0m" << endl ;
+ ReadingStatus = false ;
+ }
+
+ //Angle method
+ else if (DataBuffer=="THETA=") {
+ check_Theta = true;
+ ConfigFile >> DataBuffer ;
+ cout << "Theta: " << atof(DataBuffer.c_str()) << "deg" << endl;
+ }
+
+ else if (DataBuffer=="PHI=") {
+ check_Phi = true;
+ ConfigFile >> DataBuffer ;
+ cout << "Phi: " << atof( DataBuffer.c_str() ) << "deg" << endl;
+ }
+
+ else if (DataBuffer=="R=") {
+ check_R = true;
+ ConfigFile >> DataBuffer ;
+ cout << "R: " << atof( DataBuffer.c_str() ) << "mm" << endl;
+ }
+
+ ///////////////////////////////////////////////////
+ // If no Detector Token and no comment, toggle out
+ else{
+ ReadingStatus = false; cout << "Wrong Token Sequence: Getting out " << DataBuffer << endl ;
+ }
+
+ /////////////////////////////////////////////////
+ // If All necessary information there, toggle out
+
+ if (check_Theta && check_Phi && check_R){
+ m_NumberOfDetectors++;
+
+ // Reinitialisation of Check Boolean
+ check_Theta = false ;
+ check_Phi = false ;
+ check_R = false ;
+ ReadingStatus = false ;
+ cout << "///"<< endl ;
+ }
+ }
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::InitSpectra() {
+ m_Spectra = new TMiniballSpectra(m_NumberOfDetectors);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::FillSpectra() {
+ m_Spectra -> FillRawSpectra(m_EventData);
+ m_Spectra -> FillPreTreatedSpectra(m_PreTreatedData);
+ m_Spectra -> FillPhysicsSpectra(m_EventPhysics);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::CheckSpectra() {
+ m_Spectra->CheckSpectra();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::ClearSpectra() {
+ // To be done
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+map< string , TH1*> TMiniballPhysics::GetSpectra() {
+ if(m_Spectra)
+ return m_Spectra->GetMapHisto();
+ else{
+ map< string , TH1*> empty;
+ return empty;
+ }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+vector<TCanvas*> TMiniballPhysics::GetCanvas() {
+ if(m_Spectra)
+ return m_Spectra->GetCanvas();
+ else{
+ vector<TCanvas*> empty;
+ return empty;
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::WriteSpectra() {
+ m_Spectra->WriteSpectra();
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::AddParameterToCalibrationManager() {
+ CalibrationManager* Cal = CalibrationManager::getInstance();
+ for (int i = 0; i < m_NumberOfDetectors; ++i) {
+ Cal->AddParameter("Miniball", "D"+ NPL::itoa(i+1)+"_ENERGY","Miniball_D"+ NPL::itoa(i+1)+"_ENERGY");
+ Cal->AddParameter("Miniball", "D"+ NPL::itoa(i+1)+"_TIME","Miniball_D"+ NPL::itoa(i+1)+"_TIME");
+ }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::InitializeRootInputRaw() {
+ TChain* inputChain = RootInput::getInstance()->GetChain();
+ inputChain->SetBranchStatus("Miniball", true );
+ inputChain->SetBranchAddress("Miniball", &m_EventData );
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::InitializeRootInputPhysics() {
+ TChain* inputChain = RootInput::getInstance()->GetChain();
+ inputChain->SetBranchAddress("Miniball", &m_EventPhysics);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+void TMiniballPhysics::InitializeRootOutput() {
+ TTree* outputTree = RootOutput::getInstance()->GetTree();
+ outputTree->Branch("Miniball", "TMiniballPhysics", &m_EventPhysics);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPL::VDetector* TMiniballPhysics::Construct() {
+ return (NPL::VDetector*) new TMiniballPhysics();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern "C"{
+class proxy_Miniball{
+ public:
+ proxy_Miniball(){
+ NPL::DetectorFactory::getInstance()->AddToken("Miniball","Miniball");
+ NPL::DetectorFactory::getInstance()->AddDetector("Miniball",TMiniballPhysics::Construct);
+ }
+};
+
+proxy_Miniball p_Miniball;
+}
+
diff --git a/NPLib/Detectors/Miniball/TMiniballPhysics.h b/NPLib/Detectors/Miniball/TMiniballPhysics.h
new file mode 100644
index 0000000000000000000000000000000000000000..41d0a1fb46ed3bb699ead1d4dd3b9fbed841b08d
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballPhysics.h
@@ -0,0 +1,180 @@
+#ifndef TMiniballPHYSICS_H
+#define TMiniballPHYSICS_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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Treated data *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// C++ headers
+#include <vector>
+#include <map>
+#include <string>
+using namespace std;
+
+// ROOT headers
+#include "TObject.h"
+#include "TH1.h"
+#include "TCanvas.h"
+
+// NPTool headers
+#include "TMiniballData.h"
+#include "TMiniballSpectra.h"
+#include "NPCalibrationManager.h"
+#include "NPVDetector.h"
+
+// forward declaration
+class TMiniballSpectra;
+
+
+
+class TMiniballPhysics : public TObject, public NPL::VDetector {
+ //////////////////////////////////////////////////////////////
+ // constructor and destructor
+ public:
+ TMiniballPhysics();
+ ~TMiniballPhysics() {};
+
+
+ //////////////////////////////////////////////////////////////
+ // 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<double> Energy;
+ vector<double> Angle;
+ vector<double> Time;
+
+
+ //////////////////////////////////////////////////////////////
+ // methods inherited from the VDetector ABC class
+ public:
+ // read stream from ConfigFile to pick-up detector parameters
+ void ReadConfiguration(string);
+
+ // 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 TMiniballSpectra class
+ // instantiate the TMiniballSpectra 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 Miniball 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 TMiniballData object to TMiniballPhysics.
+ // needed for online analysis for example
+ void SetRawDataPointer(TMiniballData* rawDataPointer) {m_EventData = rawDataPointer;}
+
+ // objects are not written in the TTree
+ private:
+ TMiniballData* m_EventData; //!
+ TMiniballData* m_PreTreatedData; //!
+ TMiniballPhysics* m_EventPhysics; //!
+
+ // getters for raw and pre-treated data object
+ public:
+ TMiniballData* GetRawData() const {return m_EventData;}
+ TMiniballData* 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:
+ TMiniballSpectra* m_Spectra; // !
+
+ // spectra getter
+ public:
+ map<string, TH1*> GetSpectra();
+ vector<TCanvas*> GetCanvas();
+
+ // Static constructor to be passed to the Detector Factory
+ public:
+ static NPL::VDetector* Construct();
+
+ ClassDef(TMiniballPhysics,1) // MiniballPhysics structure
+};
+#endif
diff --git a/NPLib/Detectors/Miniball/TMiniballSpectra.cxx b/NPLib/Detectors/Miniball/TMiniballSpectra.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..64d0db3517182ebf081b352a20a0de6163bd1155
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballSpectra.cxx
@@ -0,0 +1,174 @@
+/*****************************************************************************
+ * 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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Spectra *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// class header
+#include "TMiniballSpectra.h"
+
+// STL
+#include <iostream>
+#include <string>
+using namespace std;
+
+// NPTool header
+#include "NPOptionManager.h"
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TMiniballSpectra::TMiniballSpectra()
+ : fNumberOfDetectors(0) {
+ SetName("Miniball");
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TMiniballSpectra::TMiniballSpectra(unsigned int NumberOfDetectors) {
+ if(NPOptionManager::getInstance()->GetVerboseLevel()>0)
+ cout << "************************************************" << endl
+ << "TMiniballSpectra : Initalizing control spectra for "
+ << NumberOfDetectors << " Detectors" << endl
+ << "************************************************" << endl ;
+ SetName("Miniball");
+ fNumberOfDetectors = NumberOfDetectors;
+
+ InitRawSpectra();
+ InitPreTreatedSpectra();
+ InitPhysicsSpectra();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+TMiniballSpectra::~TMiniballSpectra() {
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::InitRawSpectra() {
+ static string name;
+ for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
+ // Energy
+ name = "Miniball"+NPL::itoa(i+1)+"_ENERGY_RAW";
+ AddHisto1D(name, name, 4096, 0, 16384, "Miniball/RAW");
+ // Time
+ name = "Miniball"+NPL::itoa(i+1)+"_TIME_RAW";
+ AddHisto1D(name, name, 4096, 0, 16384, "Miniball/RAW");
+ } // end loop on number of detectors
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::InitPreTreatedSpectra() {
+ static string name;
+ for (unsigned int i = 0; i < fNumberOfDetectors; i++) { // loop on number of detectors
+ // Energy
+ name = "Miniball"+NPL::itoa(i+1)+"_ENERGY_CAL";
+ AddHisto1D(name, name, 500, 0, 25, "Miniball/CAL");
+ // Time
+ name = "Miniball"+NPL::itoa(i+1)+"_TIME_CAL";
+ AddHisto1D(name, name, 500, 0, 25, "Miniball/CAL");
+
+
+ } // end loop on number of detectors
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::InitPhysicsSpectra() {
+ static string name;
+ // Kinematic Plot
+ name = "Miniball_ENERGY_TIME";
+ AddHisto2D(name, name, 500, 0, 500, 500, 0, 50, "Miniball/PHY");
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::FillRawSpectra(TMiniballData* RawData) {
+ static string name;
+ static string family;
+
+ // Energy
+ unsigned int sizeE = RawData->GetMultEnergy();
+ for (unsigned int i = 0; i < sizeE; i++) {
+ name = "Miniball"+NPL::itoa(RawData->GetE_DetectorNbr(i))+"_ENERGY_RAW";
+ family = "Miniball/RAW";
+
+ GetHisto(family,name) -> Fill(RawData->Get_Energy(i));
+ }
+
+ // Time
+ unsigned int sizeT = RawData->GetMultTime();
+ for (unsigned int i = 0; i < sizeT; i++) {
+ name = "Miniball"+NPL::itoa(RawData->GetT_DetectorNbr(i))+"_TIME_RAW";
+ family = "Miniball/RAW";
+
+ GetHisto(family,name) -> Fill(RawData->Get_Time(i));
+ }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::FillPreTreatedSpectra(TMiniballData* PreTreatedData) {
+ static string name;
+ static string family;
+
+ // Energy
+ unsigned int sizeE = PreTreatedData->GetMultEnergy();
+ for (unsigned int i = 0; i < sizeE; i++) {
+ name = "Miniball"+NPL::itoa(PreTreatedData->GetE_DetectorNbr(i))+"_ENERGY_CAL";
+ family = "Miniball/CAL";
+
+ GetHisto(family,name) -> Fill(PreTreatedData->Get_Energy(i));
+ }
+
+ // Time
+ unsigned int sizeT = PreTreatedData->GetMultTime();
+ for (unsigned int i = 0; i < sizeT; i++) {
+ name = "Miniball"+NPL::itoa(PreTreatedData->GetT_DetectorNbr(i))+"_TIME_CAL";
+ family = "Miniball/CAL";
+
+ GetHisto(family,name) -> Fill(PreTreatedData->Get_Time(i));
+ }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+void TMiniballSpectra::FillPhysicsSpectra(TMiniballPhysics* Physics) {
+ static string name;
+ static string family;
+ family= "Miniball/PHY";
+
+ // Energy vs time
+ unsigned int sizeE = Physics->Energy.size();
+ for(unsigned int i = 0 ; i < sizeE ; i++){
+ name = "Miniball_ENERGY_TIME";
+ GetHisto(family,name) -> Fill(Physics->Energy[i],Physics->Time[i]);
+ }
+}
+
diff --git a/NPLib/Detectors/Miniball/TMiniballSpectra.h b/NPLib/Detectors/Miniball/TMiniballSpectra.h
new file mode 100644
index 0000000000000000000000000000000000000000..76194081ede48368a023d6014b9d579fd9f920d1
--- /dev/null
+++ b/NPLib/Detectors/Miniball/TMiniballSpectra.h
@@ -0,0 +1,62 @@
+#ifndef TMiniballSPECTRA_H
+#define TMiniballSPECTRA_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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class hold Miniball Spectra *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ * *
+ *****************************************************************************/
+
+// NPLib headers
+#include "NPVSpectra.h"
+#include "TMiniballData.h"
+#include "TMiniballPhysics.h"
+
+// Forward Declaration
+class TMiniballPhysics;
+
+
+class TMiniballSpectra : public VSpectra {
+ //////////////////////////////////////////////////////////////
+ // constructor and destructor
+ public:
+ TMiniballSpectra();
+ TMiniballSpectra(unsigned int NumberOfDetectors);
+ ~TMiniballSpectra();
+
+ //////////////////////////////////////////////////////////////
+ // Initialization methods
+ private:
+ void InitRawSpectra();
+ void InitPreTreatedSpectra();
+ void InitPhysicsSpectra();
+
+ //////////////////////////////////////////////////////////////
+ // Filling methods
+ public:
+ void FillRawSpectra(TMiniballData*);
+ void FillPreTreatedSpectra(TMiniballData*);
+ void FillPhysicsSpectra(TMiniballPhysics*);
+
+ //////////////////////////////////////////////////////////////
+ // Detector parameters
+ private:
+ unsigned int fNumberOfDetectors;
+};
+
+#endif
diff --git a/NPSimulation/Core/CalorimeterScorers.cc b/NPSimulation/Core/CalorimeterScorers.cc
index c6f8e8223884253aa6c90196e1957764f3731e6f..ab14ef8ebe964cd4122947e4f1015a4649841a3c 100644
--- a/NPSimulation/Core/CalorimeterScorers.cc
+++ b/NPSimulation/Core/CalorimeterScorers.cc
@@ -40,6 +40,7 @@ G4bool PS_Calorimeter::ProcessHits(G4Step* aStep, G4TouchableHistory*){
G4double* Infos = new G4double[2+mysize];
Infos[0] = aStep->GetTotalEnergyDeposit();
Infos[1] = aStep->GetPreStepPoint()->GetGlobalTime();
+
for(unsigned int i = 0 ; i < mysize ; i++){
Infos[i+2] = aStep->GetPreStepPoint()->GetTouchableHandle()->GetCopyNumber(m_NestingLevel[i]);
}
@@ -97,4 +98,89 @@ void PS_Calorimeter::PrintAll(){
G4cout << " PrimitiveScorer " << GetName() << G4endl ;
G4cout << " Number of entries " << EvtMap->entries() << G4endl ;
}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+PS_CalorimeterWithInteraction::PS_CalorimeterWithInteraction(G4String name, vector<G4int> NestingLevel,G4int depth)
+:G4VPrimitiveScorer(name, depth),HCID(-1){
+ m_NestingLevel = NestingLevel;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+PS_CalorimeterWithInteraction::~PS_CalorimeterWithInteraction(){
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+G4bool PS_CalorimeterWithInteraction::ProcessHits(G4Step* aStep, G4TouchableHistory*){
+ // Contain Energy, Time + as many copy number as nested volume
+ unsigned int mysize = m_NestingLevel.size();
+ G4double* Infos = new G4double[6+mysize];
+ Infos[0] = aStep->GetTotalEnergyDeposit();
+ Infos[1] = aStep->GetPreStepPoint()->GetGlobalTime();
+ // Interaction coordinates (used to fill the InteractionCoordinates branch)
+ G4ThreeVector m_Position = aStep->GetPreStepPoint()->GetPosition();
+
+ Infos[2] = m_Position.x();
+ Infos[3] = m_Position.y();
+ Infos[4] = m_Position.z();
+ Infos[5] = m_Position.theta();
+ Infos[6] = m_Position.phi();
+
+
+ for(unsigned int i = 0 ; i < mysize ; i++){
+ Infos[i+7] = aStep->GetPreStepPoint()->GetTouchableHandle()->GetCopyNumber(m_NestingLevel[i]);
+ }
+
+ m_Index = 0 ;
+ G4int multiplier = 1;
+ for(unsigned int i = 0 ; i < mysize ; i++){
+ m_Index+= aStep->GetPreStepPoint()->GetTouchableHandle()->GetCopyNumber(m_NestingLevel[i])*multiplier;
+ multiplier*=10;
+ }
+
+ // Check if the particle has interact before, if yes, add up the energies.
+ map<G4int, G4double**>::iterator it;
+ it= EvtMap->GetMap()->find(m_Index);
+ if(it!=EvtMap->GetMap()->end()){
+ G4double* dummy = *(it->second);
+ Infos[0]+=dummy[0];
+ }
+
+ EvtMap->set(m_Index, Infos);
+ return TRUE;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void PS_CalorimeterWithInteraction::Initialize(G4HCofThisEvent* HCE){
+ EvtMap = new G4THitsMap<G4double*>(GetMultiFunctionalDetector()->GetName(), GetName());
+ if (HCID < 0) {
+ HCID = GetCollectionID(0);
+ }
+ HCE->AddHitsCollection(HCID, (G4VHitsCollection*)EvtMap);
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void PS_CalorimeterWithInteraction::EndOfEvent(G4HCofThisEvent*){
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void PS_CalorimeterWithInteraction::clear(){
+ std::map<G4int, G4double**>::iterator MapIterator;
+ for (MapIterator = EvtMap->GetMap()->begin() ; MapIterator != EvtMap->GetMap()->end() ; MapIterator++){
+ delete *(MapIterator->second);
+ }
+
+ EvtMap->clear();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void PS_CalorimeterWithInteraction::DrawAll(){
+
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void PS_CalorimeterWithInteraction::PrintAll(){
+ G4cout << " MultiFunctionalDet " << detector->GetName() << G4endl ;
+ G4cout << " PrimitiveScorer " << GetName() << G4endl ;
+ G4cout << " Number of entries " << EvtMap->entries() << G4endl ;
+}
diff --git a/NPSimulation/Core/CalorimeterScorers.hh b/NPSimulation/Core/CalorimeterScorers.hh
index 8e6e281d020af798dad37609d205620e86b7f5d9..132b8142097b1420679074aeac72e13712a08f54 100644
--- a/NPSimulation/Core/CalorimeterScorers.hh
+++ b/NPSimulation/Core/CalorimeterScorers.hh
@@ -59,6 +59,35 @@ namespace CALORIMETERSCORERS {
G4int HCID;
G4THitsMap<G4double*>* EvtMap;
};
+
+ //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+ class PS_CalorimeterWithInteraction : public G4VPrimitiveScorer{
+
+ public: // with description
+ PS_CalorimeterWithInteraction(G4String name, vector<G4int> NestingLevel,G4int depth=0);
+ ~PS_CalorimeterWithInteraction();
+
+ protected: // with description
+ G4bool ProcessHits(G4Step*, G4TouchableHistory*);
+ G4ThreeVector m_Position;
+ public:
+ void Initialize(G4HCofThisEvent*);
+ void EndOfEvent(G4HCofThisEvent*);
+ void clear();
+ void DrawAll();
+ void PrintAll();
+
+ private: // How much level of volume nesting should be considered
+ // Give the list of the nesting level at which the copy number should be return.
+ // 0 is the lowest level possible (the actual volume copy number in which the interaction happen)
+ vector<G4int> m_NestingLevel;
+ G4int m_Index;
+
+ private: // inherited from G4VPrimitiveScorer
+ G4int HCID;
+ G4THitsMap<G4double*>* EvtMap;
+ };
}
+
#endif
diff --git a/NPSimulation/Detectors/Miniball/CMakeLists.txt b/NPSimulation/Detectors/Miniball/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b10ddc4e14dd1ac41159d89dac632ef1ca0f2a67
--- /dev/null
+++ b/NPSimulation/Detectors/Miniball/CMakeLists.txt
@@ -0,0 +1,5 @@
+# Check for gdml support
+if(Geant4_gdml_FOUND)
+add_library(NPSMiniball SHARED Miniball.cc)
+target_link_libraries(NPSMiniball NPSCore ${ROOT_LIBRARIES} ${Geant4_LIBRARIES} ${NPLib_LIBRARIES} -lNPMiniball)
+endif()
diff --git a/NPSimulation/Detectors/Miniball/Miniball.cc b/NPSimulation/Detectors/Miniball/Miniball.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cf86a6395cc6b9559c556ee4bd665b58bb872744
--- /dev/null
+++ b/NPSimulation/Detectors/Miniball/Miniball.cc
@@ -0,0 +1,383 @@
+/*****************************************************************************
+ * 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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Miniball 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"
+
+// NPTool header
+#include "Miniball.hh"
+#include "CalorimeterScorers.hh"
+#include "RootOutput.h"
+#include "MaterialManager.hh"
+#include "NPSDetectorFactory.hh"
+// CLHEP header
+#include "CLHEP/Random/RandGauss.h"
+
+using namespace std;
+using namespace CLHEP;
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+namespace Miniball_NS{
+ // Energy and time Resolution
+ const double EnergyThreshold = 0.01*MeV;
+ const double ResoTime = 4.5*ns ;
+ const double ResoEnergy = 0.003*MeV ;
+ const double ResoAngle = 4.2*deg;
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Miniball Specific Method
+Miniball::Miniball(){
+ m_Event = new TMiniballData() ;
+ m_MiniballScorer = 0;
+ m_ClusterDetector = 0;
+ m_NumberOfPlacedVolume = 0;
+}
+
+Miniball::~Miniball(){
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void Miniball::AddMiniball(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* Miniball::BuildClusterDetector(){
+ if(!m_ClusterDetector){
+ m_ClusterDetector= new G4AssemblyVolume();
+ cout << "Miniball geometry is based on Munich Group Simulation exported in GDML"<< endl;
+ string basepath = getenv("NPTOOL");
+ string path=basepath+"/NPSimulation/Detectors/Miniball/Miniball.gdml";
+ m_gdmlparser.Read(path);
+
+ G4VisAttributes* Red = new G4VisAttributes(G4Color(1,0.5,0.5));
+ G4VisAttributes* Green= new G4VisAttributes(G4Color(0.5,1,0.5));
+ G4VisAttributes* Blue = new G4VisAttributes(G4Color(0.5,0.5,1));
+ G4VisAttributes* Caps = new G4VisAttributes(G4Color(0.5,0.5,0.5,0.5));
+
+ G4LogicalVolume* World = m_gdmlparser.GetVolume("expHall_log");
+ string name;
+ for(int i = 0 ; i < World->GetNoDaughters () ;i++){
+ G4VPhysicalVolume* VPV = World->GetDaughter(i);
+ name = VPV->GetLogicalVolume()->GetName();
+
+ if(name == "cluster0_0_HPGe_A_0_det_env_log"){
+ G4LogicalVolume* HPGE = VPV->GetLogicalVolume();
+ HPGE->GetDaughter(0)->GetLogicalVolume()->SetSensitiveDetector(m_MiniballScorer);
+ HPGE->SetVisAttributes(Red);
+ G4RotationMatrix* Rot = VPV->GetObjectRotation();
+ G4ThreeVector Pos = VPV->GetObjectTranslation();
+ G4Transform3D Trans(*Rot,Pos);
+ m_ClusterDetector->AddPlacedVolume(HPGE,Trans);
+ m_NumberOfPlacedVolume++;
+ }
+ else if(name == "cluster0_0_HPGe_B_1_det_env_log"){
+ G4LogicalVolume* HPGE = VPV->GetLogicalVolume();
+ HPGE->GetDaughter(0)->GetLogicalVolume()->SetSensitiveDetector(m_MiniballScorer);
+ HPGE->SetVisAttributes(Green);
+ G4RotationMatrix* Rot = VPV->GetObjectRotation();
+ G4ThreeVector Pos = VPV->GetObjectTranslation();
+ G4Transform3D Trans(*Rot,Pos);
+ m_ClusterDetector->AddPlacedVolume(HPGE,Trans);
+ m_NumberOfPlacedVolume++;
+ }
+ else if(name == "cluster0_0_HPGe_C_2_det_env_log"){
+ G4LogicalVolume* HPGE = VPV->GetLogicalVolume();
+ HPGE->GetDaughter(0)->GetLogicalVolume()->SetSensitiveDetector(m_MiniballScorer);
+ HPGE->SetVisAttributes(Blue);
+ G4RotationMatrix* Rot = VPV->GetObjectRotation();
+ G4ThreeVector Pos = VPV->GetObjectTranslation();
+ G4Transform3D Trans(*Rot,Pos);
+ m_ClusterDetector->AddPlacedVolume(HPGE,Trans);
+ m_NumberOfPlacedVolume++;
+ }
+ else if(name.compare(0,8,"cluster0")==0 || name == "nozzle_log"){
+ G4LogicalVolume* Capsule= VPV->GetLogicalVolume();
+ Capsule->SetVisAttributes(Caps);
+ G4RotationMatrix* Rot = VPV->GetObjectRotation();
+ G4ThreeVector Pos = VPV->GetObjectTranslation();
+ G4Transform3D Trans(*Rot,Pos);
+ m_ClusterDetector->AddPlacedVolume(Capsule,Trans);
+ m_NumberOfPlacedVolume++;
+ }
+ }
+ delete World;
+ }
+ return m_ClusterDetector;
+}
+
+//....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 Miniball::ReadConfiguration(string Path){
+ ifstream ConfigFile ;
+ ConfigFile.open(Path.c_str()) ;
+ string LineBuffer ;
+ string DataBuffer ;
+
+ double Theta = 0 , Phi = 0 , R = 0 ;
+
+ bool check_Theta = false ;
+ bool check_Phi = false ;
+ bool check_R = false ;
+ bool ReadingStatus = false ;
+
+
+ while (!ConfigFile.eof()) {
+ getline(ConfigFile, LineBuffer);
+
+ // If line is a Start Up Miniball bloc, Reading toggle to true
+ string name = "Miniball";
+
+ if (LineBuffer.compare(0, name.length(), name) == 0) {
+ G4cout << "///" << G4endl ;
+ G4cout << "Miniball found: " << G4endl ;
+ ReadingStatus = true ;
+ }
+
+ // Else don't toggle to Reading Block Status
+ else ReadingStatus = false ;
+
+ // Reading Block
+ while(ReadingStatus){
+ // Pickup Next Word
+ ConfigFile >> DataBuffer ;
+
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {
+ ConfigFile.ignore ( std::numeric_limits<std::streamsize>::max(), '\n' );
+ }
+
+ // Finding another telescope (safety), toggle out
+ else if (DataBuffer.compare(0, name.length(),name) == 0) {
+ G4cout << "WARNING: Another Detector is find before standard sequence of Token, Error may occured in Telecope definition" << G4endl ;
+ ReadingStatus = false ;
+ }
+
+ //Angle method
+ else if (DataBuffer.compare(0, 6, "THETA=") == 0) {
+ check_Theta = true;
+ ConfigFile >> DataBuffer ;
+ Theta = atof(DataBuffer.c_str()) ;
+ Theta = Theta * deg;
+ G4cout << "Theta: " << Theta / deg << G4endl;
+ }
+
+ else if (DataBuffer.compare(0, 4, "PHI=") == 0) {
+ check_Phi = true;
+ ConfigFile >> DataBuffer ;
+ Phi = atof(DataBuffer.c_str()) ;
+ Phi = Phi * deg;
+ G4cout << "Phi: " << Phi / deg << G4endl;
+ }
+
+ else if (DataBuffer.compare(0, 2, "R=") == 0) {
+ check_R = true;
+ ConfigFile >> DataBuffer ;
+ R = atof(DataBuffer.c_str()) ;
+ R = R * mm;
+ G4cout << "R: " << R/mm << G4endl;
+ }
+
+ ///////////////////////////////////////////////////
+ // If no Detector Token and no comment, toggle out
+ else{
+ ReadingStatus = false;
+ G4cout << "Wrong Token Sequence: Getting out " << DataBuffer << G4endl ;
+ }
+
+ /////////////////////////////////////////////////
+ // If All necessary information there, toggle out
+
+ if (check_Theta && check_Phi && check_R){
+ AddMiniball(R,Theta,Phi);
+
+ // Reinitialisation of Check Boolean
+ check_Theta = false ;
+ check_Phi = false ;
+ check_R = false ;
+ ReadingStatus = false ;
+ G4cout << "///"<< G4endl ;
+ }
+ }
+ }
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+
+// Construct detector and inialise sensitive part.
+// Called After DetecorConstruction::AddDetector Method
+void Miniball::ConstructDetector(G4LogicalVolume* world){
+ BuildClusterDetector();
+ 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) ;
+ G4ThreeVector d = Det_pos.unit();
+ Det_pos= Det_pos-d*100*mm;
+ // 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);
+ G4Transform3D Trans(*Rot,Det_pos);
+ Det_pos=G4ThreeVector(0,0,0);
+ m_ClusterDetector->MakeImprint(world,Det_pos, Rot,i+1);
+ // set a nicer name
+ std::vector< G4VPhysicalVolume * >::iterator it = m_ClusterDetector->GetVolumesIterator();
+ it+=m_ClusterDetector->GetImprintsCount()*m_NumberOfPlacedVolume-1;
+ for(unsigned int l = 0 ; l < m_NumberOfPlacedVolume-3 ; l++){
+ it--;
+ (*it)->SetName("Capsule");
+ (*it)->SetCopyNo(i+1);
+ }
+
+ (*it)->SetName("HPGe_A");
+ (*it)->SetCopyNo(i+1);
+ it--;
+ (*it)->SetName("HPGe_B");
+ (*it)->SetCopyNo(i+1);
+ it--;
+ (*it)->SetName("HPGe_C");
+ (*it)->SetCopyNo(i+1);;
+ }
+}
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Add Detector branch to the EventTree.
+// Called After DetecorConstruction::AddDetector Method
+void Miniball::InitializeRootOutput(){
+ RootOutput *pAnalysis = RootOutput::getInstance();
+ TTree *pTree = pAnalysis->GetTree();
+ pTree->Branch("Miniball", "TMiniballData", &m_Event) ;
+ pTree->SetBranchAddress("Miniball", &m_Event) ;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+// Read sensitive part and fill the Root tree.
+// Called at in the EventAction::EndOfEventAvtion
+void Miniball::ReadSensitive(const G4Event* event){
+ m_Event->Clear();
+
+ ///////////
+ // Calorimeter scorer
+ G4THitsMap<G4double*>* CaloHitMap;
+ std::map<G4int, G4double**>::iterator Calo_itr;
+
+ G4int CaloCollectionID = G4SDManager::GetSDMpointer()->GetCollectionID("MiniballScorer/Crystal");
+ CaloHitMap = (G4THitsMap<G4double*>*)(event->GetHCofThisEvent()->GetHC(CaloCollectionID));
+
+ // Loop on the Calo map
+ for (Calo_itr = CaloHitMap->GetMap()->begin() ; Calo_itr != CaloHitMap->GetMap()->end() ; Calo_itr++){
+
+ G4double* Info = *(Calo_itr->second);
+ //(Info[0]/2.35)*((Info[0]*1.02)*pow((Info[0]*1.8),.5))
+ // double Energy = RandGauss::shoot(Info[0],((Info[0]*1000*1.02/2.35)*pow((Info[0]*1000*1.8),.5)) );
+ double Energy = RandGauss::shoot(Info[0],Miniball_NS::ResoEnergy);
+ if(Energy>Miniball_NS::EnergyThreshold){
+ double Time = RandGauss::shoot(Info[1],Miniball_NS::ResoTime);
+ int DetectorNbr = (int) Info[7];
+ double Angle = Info[5]/deg;
+ m_Event->SetEnergy(DetectorNbr,Energy);
+ m_Event->SetAngle(DetectorNbr,Angle);
+ m_Event->SetTime(DetectorNbr,Time);
+ }
+ }
+ // clear map for next event
+ CaloHitMap->clear();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////
+void Miniball::InitializeScorers() {
+ // This check is necessary in case the geometry is reloaded
+ bool already_exist = false;
+ m_MiniballScorer = CheckScorer("MiniballScorer",already_exist) ;
+
+ if(already_exist)
+ return ;
+
+ // Otherwise the scorer is initialised
+ vector<int> level; level.push_back(1);
+ G4VPrimitiveScorer* Calorimeter= new CALORIMETERSCORERS::PS_CalorimeterWithInteraction("Crystal",level, 0) ;
+ //and register it to the multifunctionnal detector
+ m_MiniballScorer->RegisterPrimitive(Calorimeter);
+ G4SDManager::GetSDMpointer()->AddNewDetector(m_MiniballScorer) ;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPS::VDetector* Miniball::Construct(){
+ return (NPS::VDetector*) new Miniball();
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern"C" {
+ class proxy_nps_plastic{
+ public:
+ proxy_nps_plastic(){
+ NPS::DetectorFactory::getInstance()->AddToken("Miniball","Miniball");
+ NPS::DetectorFactory::getInstance()->AddDetector("Miniball",Miniball::Construct);
+ }
+ };
+
+ proxy_nps_plastic p_nps_plastic;
+}
diff --git a/NPSimulation/Detectors/Miniball/Miniball.hh b/NPSimulation/Detectors/Miniball/Miniball.hh
new file mode 100644
index 0000000000000000000000000000000000000000..ab3fe1989eaacb14132e56be02b8dc5fd7752965
--- /dev/null
+++ b/NPSimulation/Detectors/Miniball/Miniball.hh
@@ -0,0 +1,112 @@
+#ifndef Miniball_h
+#define Miniball_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: Adrien Matta contact address: a.matta@surrey.ac.uk *
+ * *
+ * Creation Date : January 2016 *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Miniball simulation *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+// C++ header
+#include <string>
+#include <vector>
+using namespace std;
+
+// G4 headers
+#include "G4ThreeVector.hh"
+#include "G4RotationMatrix.hh"
+#include "G4LogicalVolume.hh"
+#include "G4AssemblyVolume.hh"
+#include "G4MultiFunctionalDetector.hh"
+#include "G4GDMLParser.hh"
+
+// NPTool header
+#include "NPSVDetector.hh"
+#include "TMiniballData.h"
+
+class Miniball : public NPS::VDetector{
+ ////////////////////////////////////////////////////
+ /////// Default Constructor and Destructor /////////
+ ////////////////////////////////////////////////////
+ public:
+ Miniball() ;
+ virtual ~Miniball() ;
+
+ ////////////////////////////////////////////////////
+ /////// Specific Function of this Class ///////////
+ ////////////////////////////////////////////////////
+ public:
+ // Cylindric plastic
+ void AddMiniball(double R,
+ double Theta,
+ double Phi);
+
+ G4AssemblyVolume* BuildClusterDetector();
+
+ private:
+ G4GDMLParser m_gdmlparser;
+ G4AssemblyVolume* m_ClusterDetector;
+ double m_NumberOfPlacedVolume;
+ ////////////////////////////////////////////////////
+ ////// Inherite from NPS::VDetector class /////////
+ ////////////////////////////////////////////////////
+ public:
+ // Read stream at Configfile to pick-up parameters of detector (Position,...)
+ // Called in DetecorConstruction::ReadDetextorConfiguration Method
+ void ReadConfiguration(string Path) ;
+
+ // Construct detector and inialise sensitive part.
+ // Called After DetecorConstruction::AddDetector Method
+ void ConstructDetector(G4LogicalVolume* world) ;
+
+ // Add Detector branch to the EventTree.
+ // Called After DetecorConstruction::AddDetector Method
+ void InitializeRootOutput() ;
+
+ // 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_MiniballScorer ;
+ ////////////////////////////////////////////////////
+ ///////////Event class to store Data////////////////
+ ////////////////////////////////////////////////////
+ private:
+ TMiniballData* m_Event ;
+
+ ////////////////////////////////////////////////////
+ ///////////////Private intern Data//////////////////
+ ////////////////////////////////////////////////////
+ private: // Geometry
+ // Detector Coordinate
+ vector<double> m_R;
+ vector<double> m_Theta;
+ vector<double> m_Phi;
+
+ // Shape type
+ vector<string> m_Shape ;
+
+ // Needed for dynamic loading of the library
+ public:
+ static NPS::VDetector* Construct();
+};
+#endif
diff --git a/NPSimulation/PhysicsListOption.txt b/NPSimulation/PhysicsListOption.txt
index b7cfa348dcc3aa0f810fb35589c6ba03a69c302a..80d2aac3dfead32db7c2b57de517cb186cecb38c 100644
--- a/NPSimulation/PhysicsListOption.txt
+++ b/NPSimulation/PhysicsListOption.txt
@@ -7,3 +7,4 @@ StoppingPhysics 0
OpticalPhysics 0
HadronPhysicsQGSP_BIC_HP 0
Decay 1
+