diff --git a/NPLib/Detectors/GASPARD/TGaspardTrackerData.h b/NPLib/Detectors/GASPARD/TGaspardTrackerData.h
index 89ab8774f095de08cbf29e2051965af80c29767d..a8048332c3f20d280121f21fe719ec533e72cf9f 100644
--- a/NPLib/Detectors/GASPARD/TGaspardTrackerData.h
+++ b/NPLib/Detectors/GASPARD/TGaspardTrackerData.h
@@ -87,88 +87,88 @@ public:
///////////////////// SETTERS ////////////////////////
// DSSD
// (Front, E)
- void SetGPDTrkFirstStageFrontEDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkFirstStageFrontEDetectorNbr(UShort_t DetNbr){
fGPDTrk_FirstStage_FrontE_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkFirstStageFrontEStripNbr(UShort_t StripNbr) {
+ void SetGPDTrkFirstStageFrontEStripNbr(UShort_t StripNbr){
fGPDTrk_FirstStage_FrontE_StripNbr.push_back(StripNbr);
}
- void SetGPDTrkFirstStageFrontEEnergy(Double_t Energy) {
+ void SetGPDTrkFirstStageFrontEEnergy(Double_t Energy){
fGPDTrk_FirstStage_FrontE_Energy.push_back(Energy);
}
// (Front, T)
- void SetGPDTrkFirstStageFrontTDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkFirstStageFrontTDetectorNbr(UShort_t DetNbr){
fGPDTrk_FirstStage_FrontT_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkFirstStageFrontTStripNbr(UShort_t StripNbr) {
+ void SetGPDTrkFirstStageFrontTStripNbr(UShort_t StripNbr){
fGPDTrk_FirstStage_FrontT_StripNbr.push_back(StripNbr);
}
- void SetGPDTrkFirstStageFrontTTime(Double_t Time) {
+ void SetGPDTrkFirstStageFrontTTime(Double_t Time){
fGPDTrk_FirstStage_FrontT_Time.push_back(Time);
}
// (Back, E)
- void SetGPDTrkFirstStageBackEDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkFirstStageBackEDetectorNbr(UShort_t DetNbr){
fGPDTrk_FirstStage_BackE_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkFirstStageBackEStripNbr(UShort_t StripNbr) {
+ void SetGPDTrkFirstStageBackEStripNbr(UShort_t StripNbr){
fGPDTrk_FirstStage_BackE_StripNbr.push_back(StripNbr);
}
- void SetGPDTrkFirstStageBackEEnergy(Double_t Energy) {
+ void SetGPDTrkFirstStageBackEEnergy(Double_t Energy){
fGPDTrk_FirstStage_BackE_Energy.push_back(Energy);
}
// (Back, T)
- void SetGPDTrkFirstStageBackTDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkFirstStageBackTDetectorNbr(UShort_t DetNbr){
fGPDTrk_FirstStage_BackT_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkFirstStageBackTStripNbr(UShort_t StripNbr) {
+ void SetGPDTrkFirstStageBackTStripNbr(UShort_t StripNbr){
fGPDTrk_FirstStage_BackT_StripNbr.push_back(StripNbr);
}
- void SetGPDTrkFirstStageBackTTime(Double_t Time) {
+ void SetGPDTrkFirstStageBackTTime(Double_t Time){
fGPDTrk_FirstStage_BackT_Time.push_back(Time);
}
// Second Stage
// (E)
- void SetGPDTrkSecondStageEDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkSecondStageEDetectorNbr(UShort_t DetNbr){
fGPDTrk_SecondStage_E_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkSecondStageEPadNbr(UShort_t PadNbr) {
+ void SetGPDTrkSecondStageEPadNbr(UShort_t PadNbr){
fGPDTrk_SecondStage_E_PadNbr.push_back(PadNbr);
}
- void SetGPDTrkSecondStageEEnergy(Double_t Energy) {
+ void SetGPDTrkSecondStageEEnergy(Double_t Energy){
fGPDTrk_SecondStage_E_Energy.push_back(Energy);
}
// (T)
- void SetGPDTrkSecondStageTDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkSecondStageTDetectorNbr(UShort_t DetNbr){
fGPDTrk_SecondStage_T_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkSecondStageTPadNbr(UShort_t PadNbr) {
+ void SetGPDTrkSecondStageTPadNbr(UShort_t PadNbr){
fGPDTrk_SecondStage_T_PadNbr.push_back(PadNbr);
}
- void SetGPDTrkSecondStageTTime(Double_t Time) {
+ void SetGPDTrkSecondStageTTime(Double_t Time){
fGPDTrk_SecondStage_T_Time.push_back(Time);
}
// Third Stage
// (E)
- void SetGPDTrkThirdStageEDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkThirdStageEDetectorNbr(UShort_t DetNbr){
fGPDTrk_ThirdStage_E_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkThirdStageEPadNbr(UShort_t PadNbr) {
+ void SetGPDTrkThirdStageEPadNbr(UShort_t PadNbr){
fGPDTrk_ThirdStage_E_PadNbr.push_back(PadNbr);
}
- void SetGPDTrkThirdStageEEnergy(Double_t Energy) {
+ void SetGPDTrkThirdStageEEnergy(Double_t Energy){
fGPDTrk_ThirdStage_E_Energy.push_back(Energy);
}
// (T)
- void SetGPDTrkThirdStageTDetectorNbr(UShort_t DetNbr) {
+ void SetGPDTrkThirdStageTDetectorNbr(UShort_t DetNbr){
fGPDTrk_ThirdStage_T_DetectorNbr.push_back(DetNbr);
}
- void SetGPDTrkThirdStageTPadNbr(UShort_t PadNbr) {
+ void SetGPDTrkThirdStageTPadNbr(UShort_t PadNbr){
fGPDTrk_ThirdStage_T_PadNbr.push_back(PadNbr);
}
- void SetGPDTrkThirdStageTTime(Double_t Time) {
+ void SetGPDTrkThirdStageTTime(Double_t Time){
fGPDTrk_ThirdStage_T_Time.push_back(Time);
}
@@ -182,118 +182,118 @@ public:
return fGPDTrk_FirstStage_FrontE_DetectorNbr.size();
}
- UShort_t GetGPDTrkFirstStageFrontEDetectorNbr(Int_t i) {
- return fGPDTrk_FirstStage_FrontE_DetectorNbr.at(i);
+ UShort_t GetGPDTrkFirstStageFrontEDetectorNbr(const int& i){
+ return fGPDTrk_FirstStage_FrontE_DetectorNbr[i];
}
- UShort_t GetGPDTrkFirstStageFrontEStripNbr(Int_t i) {
- return fGPDTrk_FirstStage_FrontE_StripNbr.at(i);
+ UShort_t GetGPDTrkFirstStageFrontEStripNbr(const int& i){
+ return fGPDTrk_FirstStage_FrontE_StripNbr[i];
}
- Double_t GetGPDTrkFirstStageFrontEEnergy(Int_t i) {
- return fGPDTrk_FirstStage_FrontE_Energy.at(i);
+ Double_t GetGPDTrkFirstStageFrontEEnergy(const int& i){
+ return fGPDTrk_FirstStage_FrontE_Energy[i];
}
// (Front, T)
- UShort_t GetGPDTrkFirstStageFrontTMult() {
+ UShort_t GetGPDTrkFirstStageFrontTMult(){
if(fGPDTrk_FirstStage_FrontT_DetectorNbr.size()!= fGPDTrk_FirstStage_FrontT_StripNbr.size() || fGPDTrk_FirstStage_FrontT_DetectorNbr.size()!= fGPDTrk_FirstStage_FrontT_Time.size())
return 0;
return fGPDTrk_FirstStage_FrontT_DetectorNbr.size();
}
- UShort_t GetGPDTrkFirstStageFrontTDetectorNbr(Int_t i) {
- return fGPDTrk_FirstStage_FrontT_DetectorNbr.at(i);
+ UShort_t GetGPDTrkFirstStageFrontTDetectorNbr(const int& i){
+ return fGPDTrk_FirstStage_FrontT_DetectorNbr[i];
}
- UShort_t GetGPDTrkFirstStageFrontTStripNbr(Int_t i) {
- return fGPDTrk_FirstStage_FrontT_StripNbr.at(i);
+ UShort_t GetGPDTrkFirstStageFrontTStripNbr(const int& i){
+ return fGPDTrk_FirstStage_FrontT_StripNbr[i];
}
- Double_t GetGPDTrkFirstStageFrontTTime(Int_t i) {
- return fGPDTrk_FirstStage_FrontT_Time.at(i);
+ Double_t GetGPDTrkFirstStageFrontTTime(const int& i){
+ return fGPDTrk_FirstStage_FrontT_Time[i];
}
// (Back, E)
- UShort_t GetGPDTrkFirstStageBackEMult() {
+ UShort_t GetGPDTrkFirstStageBackEMult(){
if(fGPDTrk_FirstStage_BackE_DetectorNbr.size()!= fGPDTrk_FirstStage_BackE_StripNbr.size() || fGPDTrk_FirstStage_BackE_DetectorNbr.size()!= fGPDTrk_FirstStage_BackE_Energy.size())
return 0;
return fGPDTrk_FirstStage_BackE_DetectorNbr.size();
}
- UShort_t GetGPDTrkFirstStageBackEDetectorNbr(Int_t i) {
- return fGPDTrk_FirstStage_BackE_DetectorNbr.at(i);
+ UShort_t GetGPDTrkFirstStageBackEDetectorNbr(const int& i){
+ return fGPDTrk_FirstStage_BackE_DetectorNbr[i];
}
- UShort_t GetGPDTrkFirstStageBackEStripNbr(Int_t i) {
- return fGPDTrk_FirstStage_BackE_StripNbr.at(i);
+ UShort_t GetGPDTrkFirstStageBackEStripNbr(const int& i){
+ return fGPDTrk_FirstStage_BackE_StripNbr[i];
}
- Double_t GetGPDTrkFirstStageBackEEnergy(Int_t i) {
- return fGPDTrk_FirstStage_BackE_Energy.at(i);
+ Double_t GetGPDTrkFirstStageBackEEnergy(const int& i){
+ return fGPDTrk_FirstStage_BackE_Energy[i];
}
// (Back, T)
- UShort_t GetGPDTrkFirstStageBackTMult() {
+ UShort_t GetGPDTrkFirstStageBackTMult(){
if(fGPDTrk_FirstStage_BackT_DetectorNbr.size()!= fGPDTrk_FirstStage_BackT_StripNbr.size() || fGPDTrk_FirstStage_BackT_DetectorNbr.size()!= fGPDTrk_FirstStage_BackT_Time.size())
return 0;
return fGPDTrk_FirstStage_BackT_DetectorNbr.size();
}
- UShort_t GetGPDTrkFirstStageBackTDetectorNbr(Int_t i) {
- return fGPDTrk_FirstStage_BackT_DetectorNbr.at(i);
+ UShort_t GetGPDTrkFirstStageBackTDetectorNbr(const int& i){
+ return fGPDTrk_FirstStage_BackT_DetectorNbr[i];
}
- UShort_t GetGPDTrkFirstStageBackTStripNbr(Int_t i) {
- return fGPDTrk_FirstStage_BackT_StripNbr.at(i);
+ UShort_t GetGPDTrkFirstStageBackTStripNbr(const int& i){
+ return fGPDTrk_FirstStage_BackT_StripNbr[i];
}
- Double_t GetGPDTrkFirstStageBackTTime(Int_t i) {
- return fGPDTrk_FirstStage_BackT_Time.at(i);
+ Double_t GetGPDTrkFirstStageBackTTime(const int& i){
+ return fGPDTrk_FirstStage_BackT_Time[i];
}
// Second Stage
// (E)
- UShort_t GetGPDTrkSecondStageEMult() {
+ UShort_t GetGPDTrkSecondStageEMult(){
return fGPDTrk_SecondStage_E_DetectorNbr.size();
}
- UShort_t GetGPDTrkSecondStageEDetectorNbr(Int_t i) {
- return fGPDTrk_SecondStage_E_DetectorNbr.at(i);
+ UShort_t GetGPDTrkSecondStageEDetectorNbr(const int& i){
+ return fGPDTrk_SecondStage_E_DetectorNbr[i];
}
- UShort_t GetGPDTrkSecondStageEPadNbr(Int_t i) {
- return fGPDTrk_SecondStage_E_PadNbr.at(i);
+ UShort_t GetGPDTrkSecondStageEPadNbr(const int& i){
+ return fGPDTrk_SecondStage_E_PadNbr[i];
}
- Double_t GetGPDTrkSecondStageEEnergy(Int_t i) {
- return fGPDTrk_SecondStage_E_Energy.at(i);
+ Double_t GetGPDTrkSecondStageEEnergy(const int& i){
+ return fGPDTrk_SecondStage_E_Energy[i];
}
// (T)
- UShort_t GetGPDTrkSecondStageTMult() {
+ UShort_t GetGPDTrkSecondStageTMult(){
return fGPDTrk_SecondStage_T_DetectorNbr.size();
}
- UShort_t GetGPDTrkSecondStageTDetectorNbr(Int_t i) {
- return fGPDTrk_SecondStage_T_DetectorNbr.at(i);
+ UShort_t GetGPDTrkSecondStageTDetectorNbr(const int& i){
+ return fGPDTrk_SecondStage_T_DetectorNbr[i];
}
- UShort_t GetGPDTrkSecondStageTPadNbr(Int_t i) {
- return fGPDTrk_SecondStage_T_PadNbr.at(i);
+ UShort_t GetGPDTrkSecondStageTPadNbr(const int& i){
+ return fGPDTrk_SecondStage_T_PadNbr[i];
}
- Double_t GetGPDTrkSecondStageTTime(Int_t i) {
- return fGPDTrk_SecondStage_T_Time.at(i);
+ Double_t GetGPDTrkSecondStageTTime(const int& i){
+ return fGPDTrk_SecondStage_T_Time[i];
}
// Third Stage
// (E)
- UShort_t GetGPDTrkThirdStageEMult() {
+ UShort_t GetGPDTrkThirdStageEMult(){
return fGPDTrk_ThirdStage_E_DetectorNbr.size();
}
- UShort_t GetGPDTrkThirdStageEDetectorNbr(Int_t i) {
- return fGPDTrk_ThirdStage_E_DetectorNbr.at(i);
+ UShort_t GetGPDTrkThirdStageEDetectorNbr(const int& i){
+ return fGPDTrk_ThirdStage_E_DetectorNbr[i];
}
- UShort_t GetGPDTrkThirdStageEPadNbr(Int_t i) {
- return fGPDTrk_ThirdStage_E_PadNbr.at(i);
+ UShort_t GetGPDTrkThirdStageEPadNbr(const int& i){
+ return fGPDTrk_ThirdStage_E_PadNbr[i];
}
- Double_t GetGPDTrkThirdStageEEnergy(Int_t i) {
- return fGPDTrk_ThirdStage_E_Energy.at(i);
+ Double_t GetGPDTrkThirdStageEEnergy(const int& i){
+ return fGPDTrk_ThirdStage_E_Energy[i];
}
// (T)
- UShort_t GetGPDTrkThirdStageTMult() {
+ UShort_t GetGPDTrkThirdStageTMult(){
return fGPDTrk_ThirdStage_T_DetectorNbr.size();
}
- UShort_t GetGPDTrkThirdStageTDetectorNbr(Int_t i) {
- return fGPDTrk_ThirdStage_T_DetectorNbr.at(i);
+ UShort_t GetGPDTrkThirdStageTDetectorNbr(const int& i) {
+ return fGPDTrk_ThirdStage_T_DetectorNbr[i];
}
- UShort_t GetGPDTrkThirdStageTPadNbr(Int_t i) {
- return fGPDTrk_ThirdStage_T_PadNbr.at(i);
+ UShort_t GetGPDTrkThirdStageTPadNbr(const int& i){
+ return fGPDTrk_ThirdStage_T_PadNbr[i];
}
- Double_t GetGPDTrkThirdStageTTime(Int_t i) {
- return fGPDTrk_ThirdStage_T_Time.at(i);
+ Double_t GetGPDTrkThirdStageTTime(const int& i){
+ return fGPDTrk_ThirdStage_T_Time[i];
}
ClassDef(TGaspardTrackerData, 1) // GaspardTrackerData structure
diff --git a/NPLib/Detectors/MUST2/TMust2Physics.cxx b/NPLib/Detectors/MUST2/TMust2Physics.cxx
index d30e04984bdcb4fccaa7c7f22f0b1b1e31c7131d..075a2174b2ea3ad26b586e7ae89b8d67c1b1150f 100644
--- a/NPLib/Detectors/MUST2/TMust2Physics.cxx
+++ b/NPLib/Detectors/MUST2/TMust2Physics.cxx
@@ -1451,6 +1451,6 @@ class proxy_must2{
}
};
-proxy_must2 p;
+proxy_must2 p_must2;
}
diff --git a/NPLib/Physics/NPEnergyLoss.h b/NPLib/Physics/NPEnergyLoss.h
index 698e1f0d95a9379d7f42bc06777effaf128d05c3..427b82c204e43882adcaecc8a9f2761824e49178 100644
--- a/NPLib/Physics/NPEnergyLoss.h
+++ b/NPLib/Physics/NPEnergyLoss.h
@@ -31,7 +31,7 @@
* Based on N.Desereville previous classes *
* *
*****************************************************************************/
-
+
#include <string>
#include <vector>
using namespace std ;
@@ -51,83 +51,82 @@ using namespace NPUNITS;
#include "Math/Interpolator.h"
using namespace ROOT::Math;
-namespace NPL
- {
- class EnergyLoss {
-
- public : // Constructor
- EnergyLoss();
- EnergyLoss( string Path , // Path of dE/dX table file
- string Source , // Type of file : Geant4,Lise,SRIM
- int NumberOfSlice , // Low number = Faster, High Number = more accurate / typical: 100 to 1000
- int LiseColumns=0 , // Indicate which model to read in a lise File, set to 0 (Default value) for a SRIM / Geant4 file
- int NumberOfMass=1 );// Number of mass A of the nucleus (used only for Lise file)
- ~EnergyLoss();
-
- private : // dE/dX, slice parameter
- int fNumberOfSlice ; // Number Of Slice used to evaluate energy loss
- int fNumberOfMass ; // Number of mass A of the nucleus (used only for Lise file)
- double fMax; // Max energy value of the table
- double fMin; // Min energy value of the tahble
- vector<double> fEnergy ; // Energy
- vector<double> fdEdX_Nuclear ; // Nuclear Stopping Power
- vector<double> fdEdX_Electronic ; // Electronic Stopping Power
- vector<double> fdEdX_Total ; // Total Stopping Power
- Interpolator* fInter ; // Interpolator Used to evaluate Energy loss at given energy
-
- double Eval(double ener) const; // return the evaluated energy
-
- public : // General Function on dE/dX table
- double EvaluateNuclearLoss (double ener) const;
- double EvaluateElectronicLoss (double ener) const;
- double EvaluateTotalLoss (double ener) const;
-
- public : // Function to Slow down particle or reconstruct their initial energy
-
- // Calculate Energy of a particle after crossing material
- double Slow( double Energy , // Energy of the detected particle
- double TargetThickness , // Target Thickness at 0 degree
- double Angle ) // Particle Angle
- const;
-
- // Calculate Energy Loss of a particle inside a material
- double EnergyLossCalulation( double Energy , // Energy of the detected particle
- double TargetThickness , // Target Thickness at 0 degree
- double Angle ) // Particle Angle
- const;
-
- // Evaluate Initial Energy of particle before crossing material knowing Angle, final Energy
- // and Target Thickness.
- double EvaluateInitialEnergy( double energy , // Energy of the detected particle
- double TargetThickness , // Target Thickness at 0 degree
- double Angle ) // Particle Angle
- const ;
-
- // Evaluate Total Energy of particle from Energy loss in a giver thickness
- double EvaluateEnergyFromDeltaE( double DeltaE , // Energy of the detected particle
- double TargetThickness , // Target Thickness at 0 degree
- double Angle , // Particle Angle
- double EnergyMin , // Starting Energy
- double EnergyMax , // Maximum Energy allowed
- double EnergyResolution , // Resolution at which function stop
- int MaxStep = 1000000 ) // Stop after MaxStep Whatever Precision is reached
- const ;
-
- // Evaluate the thickness the particle has been through using the energy loss and initial energy
- // usefull for thickness measurement using particle sources
- double EvaluateMaterialThickness( double InitialEnergy, // Energy of the detected particle
- double FinalEnergy,
- double ThicknessLimit ,
- double ThicknessStep = 0.1*micrometer) // Target Thickness at 0 degree
- const ;
-
- public : // Usefull function
- // Display parameter
- void Print() const;
- // Draw (CERN ROOT)
- void Draw() const;
-
- };
- }
+namespace NPL{
+ class EnergyLoss{
+
+ public : // Constructor
+ EnergyLoss();
+ EnergyLoss( string Path , // Path of dE/dX table file
+ string Source , // Type of file : Geant4,Lise,SRIM
+ int NumberOfSlice , // Low number = Faster, High Number = more accurate / typical: 100 to 1000
+ int LiseColumns=0 , // Indicate which model to read in a lise File, set to 0 (Default value) for a SRIM / Geant4 file
+ int NumberOfMass=1 );// Number of mass A of the nucleus (used only for Lise file)
+ ~EnergyLoss();
+
+ private : // dE/dX, slice parameter
+ int fNumberOfSlice ; // Number Of Slice used to evaluate energy loss
+ int fNumberOfMass ; // Number of mass A of the nucleus (used only for Lise file)
+ double fMax; // Max energy value of the table
+ double fMin; // Min energy value of the tahble
+ vector<double> fEnergy ; // Energy
+ vector<double> fdEdX_Nuclear ; // Nuclear Stopping Power
+ vector<double> fdEdX_Electronic ; // Electronic Stopping Power
+ vector<double> fdEdX_Total ; // Total Stopping Power
+ Interpolator* fInter ; // Interpolator Used to evaluate Energy loss at given energy
+
+ double Eval(double ener) const; // return the evaluated energy
+
+ public : // General Function on dE/dX table
+ double EvaluateNuclearLoss (double ener) const;
+ double EvaluateElectronicLoss (double ener) const;
+ double EvaluateTotalLoss (double ener) const;
+
+ public : // Function to Slow down particle or reconstruct their initial energy
+
+ // Calculate Energy of a particle after crossing material
+ double Slow( double Energy , // Energy of the detected particle
+ double TargetThickness , // Target Thickness at 0 degree
+ double Angle ) // Particle Angle
+ const;
+
+ // Calculate Energy Loss of a particle inside a material
+ double EnergyLossCalulation( double Energy , // Energy of the detected particle
+ double TargetThickness , // Target Thickness at 0 degree
+ double Angle ) // Particle Angle
+ const;
+
+ // Evaluate Initial Energy of particle before crossing material knowing Angle, final Energy
+ // and Target Thickness.
+ double EvaluateInitialEnergy( double energy , // Energy of the detected particle
+ double TargetThickness , // Target Thickness at 0 degree
+ double Angle ) // Particle Angle
+ const ;
+
+ // Evaluate Total Energy of particle from Energy loss in a giver thickness
+ double EvaluateEnergyFromDeltaE( double DeltaE , // Energy of the detected particle
+ double TargetThickness , // Target Thickness at 0 degree
+ double Angle , // Particle Angle
+ double EnergyMin , // Starting Energy
+ double EnergyMax , // Maximum Energy allowed
+ double EnergyResolution , // Resolution at which function stop
+ int MaxStep = 1000000 ) // Stop after MaxStep Whatever Precision is reached
+ const ;
+
+ // Evaluate the thickness the particle has been through using the energy loss and initial energy
+ // usefull for thickness measurement using particle sources
+ double EvaluateMaterialThickness( double InitialEnergy, // Energy of the detected particle
+ double FinalEnergy,
+ double ThicknessLimit ,
+ double ThicknessStep = 0.1*micrometer) // Target Thickness at 0 degree
+ const ;
+
+ public : // Usefull function
+ // Display parameter
+ void Print() const;
+ // Draw (CERN ROOT)
+ void Draw() const;
+
+ };
+}
#endif
diff --git a/NPLib/Utility/npanalysis.cxx b/NPLib/Utility/npanalysis.cxx
index 9ff49f7eb6e51412130d7373d1c87f9218ef3f1b..805b484443c3d6851cc78a9cdcba489c338ca9a0 100644
--- a/NPLib/Utility/npanalysis.cxx
+++ b/NPLib/Utility/npanalysis.cxx
@@ -18,7 +18,7 @@
#include"TEnv.h"
void ProgressDisplay(clock_t&,clock_t&,unsigned long&, unsigned long&, unsigned long&, double&, unsigned long&, int&, int&);
-
+////////////////////////////////////////////////////////////////////////////////
int main(int argc , char** argv){
// command line parsing
NPOptionManager* myOptionManager = NPOptionManager::getInstance(argc,argv);
diff --git a/Projects/MUGAST/Analysis.cxx b/Projects/MUGAST/Analysis.cxx
index bb07b382e69a4ca52bcc7f5fb995fcb840bf1037..e48381a55665f70ab71447a88147a96d32d50608 100644
--- a/Projects/MUGAST/Analysis.cxx
+++ b/Projects/MUGAST/Analysis.cxx
@@ -45,9 +45,8 @@ void Analysis::Init() {
GD = (GaspardTracker*) m_DetectorManager -> GetDetector("GaspardTracker");
// get reaction information
- myReaction = new NPL::Reaction();
- myReaction->ReadConfigurationFile(NPOptionManager::getInstance()->GetReactionFile());
- OriginalBeamEnergy = myReaction->GetBeamEnergy();
+ myReaction.ReadConfigurationFile(NPOptionManager::getInstance()->GetReactionFile());
+ OriginalBeamEnergy = myReaction.GetBeamEnergy();
// target thickness
TargetThickness = m_DetectorManager->GetTargetThickness()*micrometer;
@@ -57,8 +56,8 @@ void Analysis::Init() {
string WindowsMaterial = m_DetectorManager->GetWindowsMaterial();
// energy losses
- string light=NPL::ChangeNameToG4Standard(myReaction->GetNucleus3().GetName());
- string beam=NPL::ChangeNameToG4Standard(myReaction->GetNucleus1().GetName());
+ string light=NPL::ChangeNameToG4Standard(myReaction.GetNucleus3().GetName());
+ string beam=NPL::ChangeNameToG4Standard(myReaction.GetNucleus1().GetName());
LightCD2 = NPL::EnergyLoss(light+"_"+TargetMaterial+".G4table","G4Table",100 );
LightAl = NPL::EnergyLoss(light+"_Al.G4table","G4Table",100);
@@ -95,7 +94,7 @@ void Analysis::Init() {
FinalBeamEnergy = BeamCD2.Slow(FinalBeamEnergy, TargetThickness*0.5, 0);
- myReaction->SetBeamEnergy(FinalBeamEnergy);
+ myReaction.SetBeamEnergy(FinalBeamEnergy);
cout << "//// Slow down Beam in the target ////" << endl;
cout << "Initial beam energy : " << OriginalBeamEnergy << endl;
@@ -164,14 +163,14 @@ void Analysis::TreatEvent() {
/************************************************/
// Part 3 : Excitation Energy Calculation
- Ex = myReaction -> ReconstructRelativistic( ELab , ThetaLab );
+ Ex = myReaction.ReconstructRelativistic( ELab , ThetaLab );
ThetaLab=ThetaLab/deg;
/************************************************/
/************************************************/
// Part 4 : Theta CM Calculation
- ThetaCM = myReaction -> EnergyLabToThetaCM( ELab , ThetaLab)/deg;
+ ThetaCM = myReaction.EnergyLabToThetaCM( ELab , ThetaLab)/deg;
/************************************************/
}//end loop MUST2
@@ -208,13 +207,13 @@ void Analysis::TreatEvent() {
/************************************************/
// Part 3 : Excitation Energy Calculation
- Ex = myReaction -> ReconstructRelativistic( ELab , ThetaLab );
+ Ex = myReaction.ReconstructRelativistic( ELab , ThetaLab );
/************************************************/
/************************************************/
// Part 4 : Theta CM Calculation
- ThetaCM = myReaction -> EnergyLabToThetaCM( ELab , ThetaLab)/deg;
+ ThetaCM = myReaction.EnergyLabToThetaCM( ELab , ThetaLab)/deg;
ThetaLab=ThetaLab/deg;
/************************************************/
diff --git a/Projects/MUGAST/Analysis.h b/Projects/MUGAST/Analysis.h
index 227f2e1c5c74c02f1501ad050354599ec13cf5ab..4b5e01a46bca723f910f31b1c49f4cec904a0f59 100644
--- a/Projects/MUGAST/Analysis.h
+++ b/Projects/MUGAST/Analysis.h
@@ -53,7 +53,7 @@ class Analysis: public NPL::VAnalysis{
double ELab;
double ThetaLab;
double ThetaCM;
- NPL::Reaction* myReaction;
+ NPL::Reaction myReaction;
// Energy loss table: the G4Table are generated by the simulation
NPL::EnergyLoss LightCD2;
NPL::EnergyLoss LightAl;