* Progress on S034

        - fixing unit of velocity in NPParticle

NPLib/Core/NPDetectorManager.cxx

@@ -413,7 +413,7 @@ void NPL::DetectorManager::InitThreadPool(){
 ////////////////////////////////////////////////////////////////////////////////
 void NPL::DetectorManager::StartThread(NPL::VDetector* det,unsigned int id){ 
   // Let the main thread start 
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  std::this_thread::sleep_for(std::chrono::milliseconds(250));
   while(true){
     // Do the job if possible
     if(m_Ready[id]){

NPLib/Detectors/Nebula/TNebulaData.h

@@ -100,24 +100,44 @@ class TNebulaData : public TObject {
     fNebula_Td_ID.push_back(ID);
     fNebula_Td_Time.push_back(Time);
     };//!
-/*
-    //////////////////////    GETTERS    ////////////////////////
-    // Energy
-    inline UShort_t GetMultEnergy() const
-      {return fNebula_E_DetectorNbr.size();}
-    inline UShort_t GetE_DetectorNbr(const unsigned int &i) const 
-      {return fNebula_E_DetectorNbr[i];}//!
-    inline Double_t Get_Energy(const unsigned int &i) const 
-      {return fNebula_Energy[i];}//!
 
+    //////////////////////    GETTERS    ////////////////////////
+    // MULT //
+    // Charge 
+    inline unsigned int GetChargeUpMult() const
+      {return fNebula_Qu_ID.size();};
+    // Time
+    inline unsigned int GetTimeUpMult() const
+      {return fNebula_Tu_ID.size();};
+    // Charge
+    inline unsigned int GetChargeDownMult() const
+      {return fNebula_Qd_ID.size();};
     // Time
-    inline UShort_t GetMultTime() const
-      {return fNebula_T_DetectorNbr.size();}
-    inline UShort_t GetT_DetectorNbr(const unsigned int &i) const 
-      {return fNebula_T_DetectorNbr[i];}//!
-    inline Double_t Get_Time(const unsigned int &i) const 
-      {return fNebula_Time[i];}//!
-*/
+    inline unsigned int GetTimeDownMult() const
+      {return fNebula_Td_ID.size();};
+
+    // Value // 
+    // Charge 
+    inline UShort_t GetChargeUpID(unsigned int& i) const
+      {return fNebula_Qu_ID[i];};
+    inline double GetChargeUp(unsigned int& i) const
+      {return fNebula_Qu_Charge[i];};
+    // Time 
+    inline UShort_t GetTimeUpID(unsigned int& i) const
+      {return fNebula_Tu_ID[i];};
+    inline double GetTimeUp(unsigned int& i) const
+      {return fNebula_Tu_Time[i];};
+    // Charge 
+    inline UShort_t GetChargeDownID(unsigned int& i) const
+      {return fNebula_Qd_ID[i];};
+    inline double GetChargeDown(unsigned int& i) const
+      {return fNebula_Qd_Charge[i];};
+    // Time 
+    inline UShort_t GetTimeDownID(unsigned int& i) const
+      {return fNebula_Td_ID[i];};
+    inline double GetTimeDown(unsigned int& i) const
+      {return fNebula_Td_Time[i];};
+
 
   //////////////////////////////////////////////////////////////
   // Required for ROOT dictionnary

NPLib/Detectors/Nebula/TNebulaPhysics.cxx

@@ -35,28 +35,61 @@ using namespace std;
 #include "RootOutput.h"
 #include "NPDetectorFactory.h"
 #include "NPOptionManager.h"
-
+#include "NPSystemOfUnits.h"
 //   ROOT
 #include "TChain.h"
 
 ClassImp(TNebulaPhysics)
 
 
-///////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////
 TNebulaPhysics::TNebulaPhysics()
-   : m_EventData(new TNebulaData),
-     m_PreTreatedData(new TNebulaData),
-     m_EventPhysics(this),
-     m_Spectra(0),
-     m_E_RAW_Threshold(0), // adc channels
-     m_E_Threshold(0),     // MeV
-     m_NumberOfBars(0) {
-}
+  : m_EventData(new TNebulaData),
+  m_EventPhysics(this),
+  m_Spectra(0),
+  m_Q_RAW_Threshold(0), // adc channels
+  m_Q_Threshold(7),     // normal bars in MeV
+  m_V_Threshold(1),     // veto bars in MeV
+  m_NumberOfBars(0) {
+  }
 
 ///////////////////////////////////////////////////////////////////////////
 /// A usefull method to bundle all operation to add a detector
 void TNebulaPhysics::ReadXML(NPL::XmlParser xml){ 
-  m_NumberOfBars++;
+  std::vector<NPL::XML::block*> b = xml.GetAllBlocksWithName("NEBULA");  
+
+  for(unsigned int i = 0 ; i < b.size() ; i++){
+    m_NumberOfBars++;
+    unsigned int id = b[i]->AsInt("ID");
+
+    // position
+    PositionX[id] = b[i]->AsDouble("PosX"); 
+    PositionY[id] = b[i]->AsDouble("PosY"); 
+    PositionZ[id] = b[i]->AsDouble("PosZ"); 
+    // linear cal
+    aQu[id] = b[i]->AsDouble("QUCal");
+    bQu[id] = b[i]->AsDouble("QUPed");
+    aQd[id] = b[i]->AsDouble("QDCal");
+    bQd[id] = b[i]->AsDouble("QDPed");
+    aTu[id] = b[i]->AsDouble("TUCal");
+    bTu[id] = b[i]->AsDouble("TUOff");
+    aTd[id] = b[i]->AsDouble("TDCal");
+    bTd[id] = b[i]->AsDouble("TDOff");
+
+    // T average offset
+    avgT0[id] = b[i]->AsDouble("TAveOff");
+
+    // slew correction T= tcal +slwT/sqrt(Qcal)
+    slwTu[id] = b[i]->AsDouble("TUSlw");
+    slwTd[id] = b[i]->AsDouble("TDSlw");
+
+    // DT position cal
+    DTa[id] = b[i]->AsDouble("DTCal");//!
+    DTb[id] = b[i]->AsDouble("DTOff");//!
+
+
+  } 
+  cout << " -> " << m_NumberOfBars << " bars found" << endl;;
 } 
 
 ///////////////////////////////////////////////////////////////////////////
@@ -69,115 +102,109 @@ void TNebulaPhysics::BuildSimplePhysicalEvent() {
 ///////////////////////////////////////////////////////////////////////////
 void TNebulaPhysics::BuildPhysicalEvent() {
   // apply thresholds and calibration
-  PreTreat();
-/*
-  // match energy and time together
-  unsigned int mysizeE = m_PreTreatedData->GetMultEnergy();
-  unsigned int mysizeT = m_PreTreatedData->GetMultTime();
-  for (UShort_t e = 0; e < mysizeE ; e++) {
-    for (UShort_t t = 0; t < mysizeT ; t++) {
-      if (m_PreTreatedData->GetE_DetectorNbr(e) == m_PreTreatedData->GetT_DetectorNbr(t)) {
-        DetectorNumber.push_back(m_PreTreatedData->GetE_DetectorNbr(e));
-        Energy.push_back(m_PreTreatedData->Get_Energy(e));
-        Time.push_back(m_PreTreatedData->Get_Time(t));
-      }
-    }
-  }*/
-}
-
-///////////////////////////////////////////////////////////////////////////
-void TNebulaPhysics::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->GetMultEnergy();
-  for (UShort_t i = 0; i < mysize ; ++i) {
-    if (m_EventData->Get_Energy(i) > m_E_RAW_Threshold) {
-      Double_t Energy = Cal->ApplyCalibration("Nebula/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);
+  static double rawQup,calQup,rawQdown,calQdown,rawTup,calTup,rawTdown,calTdown,calQ,calT,Y;
+  static unsigned int ID;
+  // All vector size 
+  static unsigned int QUsize, QDsize, TUsize, TDsize ; 
+  QUsize = m_EventData->GetChargeUpMult();
+  QDsize = m_EventData->GetChargeDownMult();
+  TUsize = m_EventData->GetTimeUpMult();
+  TDsize = m_EventData->GetTimeDownMult();
+  static double threshold;
+  // loop on Qup
+  for (unsigned int qup = 0; qup < QUsize ; qup++) {
+
+    rawQup = m_EventData->GetChargeUp(qup);
+    rawTup=-1;
+    rawQdown=-1;
+    rawTdown=-1;
+    if (rawQup > m_Q_RAW_Threshold) {
+      ID = m_EventData->GetChargeUpID(qup);
+      if(ID<121)
+        threshold=m_Q_Threshold;
+      else
+        threshold=m_V_Threshold;
+
+      // look for associated Charge down
+      for(unsigned int qdown = 0 ; qdown < QDsize ; qdown++){
+        if(m_EventData->GetChargeDownID(qdown)==ID){
+          rawQdown=m_EventData->GetChargeDown(qdown); 
+          if(rawQdown > m_Q_RAW_Threshold){
+            // Look for the associate time 
+            for(unsigned int tdown = 0 ; tdown < TDsize; tdown++){
+              if(m_EventData->GetTimeDownID(qdown)==ID) {
+                rawTdown=m_EventData->GetTimeDown(qdown);
+                break;
+              }
+            }// TDown
+          }//if raw threshold down
+
+          break;
+        } //if match ID 
+
+      }// Qdwown 
+
+      if(rawTdown>0){ // Tdown is found, means Qdown as well
+        // look for Tup  
+        for(unsigned int tup = 0 ; tup < TUsize ; tup++){
+          if(m_EventData->GetTimeUpID(tup)==ID){
+            rawTup = m_EventData->GetTimeUp(tup);
+            break;
+          }
+        }
+      }
+      // Got everything, do the math
+      if(rawTup>0){
+        calQup=aQu[ID]*(rawQup-bQu[ID]);
+        calQdown=aQd[ID]*(rawQdown-bQd[ID]);
+        // cal T 
+        calTup=aTu[ID]*rawTup+bTu[ID];
+        // slew correction
+        calTup -= slwTu[ID]/sqrt(rawQup-bQu[ID]);
+
+        // cal T
+        calTdown=aTd[ID]*rawTdown+bTd[ID];
+
+        // slew correction
+        calTdown -= slwTd[ID]/sqrt(rawQdown-bQd[ID]);
+
+        // average value of Up and Down
+        calQ=sqrt(calQup*calQdown); 
+        if(calQ>threshold){
+          calT= (calTdown+calTup)*0.5+avgT0[ID]+Cal->GetPedestal("NEBULA_T_ID"+NPL::itoa(ID)); 
+          Y=(calTdown-calTup)*DTa[ID]+DTb[ID]+Cal->GetPedestal("NEBULA_Y_ID"+NPL::itoa(ID));
+
+          DetectorNumber.push_back(ID);
+          Charge.push_back(calQ);
+          TOF.push_back(calT);
+          PosY.push_back(Y+PositionY[ID]);
+          PosX.push_back(PositionX[ID]);
+          PosZ.push_back(PositionZ[ID]);
+
+          if(ID<120)
+            IsVeto.push_back(0);
+          else
+            IsVeto.push_back(1);
+
+        }
       }
-    }
-  }
 
-  // Time 
-  mysize = m_EventData->GetMultTime();
-  for (UShort_t i = 0; i < mysize; ++i) {
-    Double_t Time= Cal->ApplyCalibration("Nebula/TIME"+NPL::itoa(m_EventData->GetT_DetectorNbr(i)),m_EventData->Get_Time(i));
-    m_PreTreatedData->SetTime(m_EventData->GetT_DetectorNbr(i), Time);
-  }
-  */
+    }// if raw threshold up
+  } // Qup
 }
 
-
-
 ///////////////////////////////////////////////////////////////////////////
-void TNebulaPhysics::ReadAnalysisConfig() {
-  bool ReadingStatus = false;
-
-  // path to file
-  string FileName = "./configs/ConfigNebula.dat";
-
-  // open analysis config file
-  ifstream AnalysisConfigFile;
-  AnalysisConfigFile.open(FileName.c_str());
+void TNebulaPhysics::PreTreat() {
 
-  if (!AnalysisConfigFile.is_open()) {
-    cout << " No ConfigNebula.dat found: Default parameter loaded for Analayis " << FileName << endl;
-    return;
-  }
-  cout << " Loading user parameter for Analysis from ConfigNebula.dat " << endl;
-
-  // Save it in a TAsciiFile
-  TAsciiFile* asciiConfig = RootOutput::getInstance()->GetAsciiFileAnalysisConfig();
-  asciiConfig->AppendLine("%%% ConfigNebula.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 = "ConfigNebula";
-    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 TNebulaPhysics::ReadAnalysisConfig() {
 }
 
 
@@ -185,8 +212,12 @@ void TNebulaPhysics::ReadAnalysisConfig() {
 ///////////////////////////////////////////////////////////////////////////
 void TNebulaPhysics::Clear() {
   DetectorNumber.clear();
-  Energy.clear();
-  Time.clear();
+  Charge.clear();
+  TOF.clear();
+  PosY.clear();
+  PosX.clear();
+  PosZ.clear();
+  IsVeto.clear();
 }
 
 
@@ -227,7 +258,6 @@ void TNebulaPhysics::InitSpectra() {
 ///////////////////////////////////////////////////////////////////////////
 void TNebulaPhysics::FillSpectra() {
   m_Spectra -> FillRawSpectra(m_EventData);
-  m_Spectra -> FillPreTreatedSpectra(m_PreTreatedData);
   m_Spectra -> FillPhysicsSpectra(m_EventPhysics);
 }
 
@@ -268,8 +298,8 @@ void TNebulaPhysics::WriteSpectra() {
 void TNebulaPhysics::AddParameterToCalibrationManager() {
   CalibrationManager* Cal = CalibrationManager::getInstance();
   for (int i = 0; i < m_NumberOfBars; ++i) {
-    Cal->AddParameter("NEBULA_ID"+ NPL::itoa(i+1)+"_T");
-    Cal->AddParameter("NEBULA_ID"+ NPL::itoa(i+1)+"_Y");
+    Cal->AddParameter("NEBULA_T_ID"+ NPL::itoa(i+1));
+    Cal->AddParameter("NEBULA_Y_ID"+ NPL::itoa(i+1));
   }
 }
 
@@ -313,14 +343,14 @@ NPL::VDetector* TNebulaPhysics::Construct() {
 //            Registering the construct method to the factory                 //
 ////////////////////////////////////////////////////////////////////////////////
 extern "C"{
-class proxy_Nebula{
-  public:
-    proxy_Nebula(){
-      NPL::DetectorFactory::getInstance()->AddToken("NEBULA","Nebula");
-      NPL::DetectorFactory::getInstance()->AddDetector("NEBULA",TNebulaPhysics::Construct);
-    }
-};
+  class proxy_Nebula{
+    public:
+      proxy_Nebula(){
+        NPL::DetectorFactory::getInstance()->AddToken("NEBULA","Nebula");
+        NPL::DetectorFactory::getInstance()->AddDetector("NEBULA",TNebulaPhysics::Construct);
+      }
+  };
 
-proxy_Nebula p_Nebula;
+  proxy_Nebula p_Nebula;
 }
 

NPLib/Detectors/Nebula/TNebulaPhysics.h

@@ -52,26 +52,64 @@ class TNebulaPhysics : public TObject, public NPL::VDetector {
     ~TNebulaPhysics() {};
 
 
-  //////////////////////////////////////////////////////////////
-  // Inherited from TObject and overriden to avoid warnings
+    //////////////////////////////////////////////////////////////
+    // 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
+    //////////////////////////////////////////////////////////////
+    // data obtained after BuildPhysicalEvent() and stored in
+    // output ROOT file
   public:
     vector<int>      DetectorNumber;
-    vector<double>   Energy;
-    vector<double>   Time;
+    vector<double>   Charge;
+    vector<double>   TOF;
+    vector<double>   PosY;
+    vector<double>   PosX;
+    vector<double>   PosZ;
+    vector<bool>     IsVeto;
 
-  /// A usefull method to bundle all operation to add a detector
-  void ReadXML(NPL::XmlParser); 
-  
-  //////////////////////////////////////////////////////////////
-  // methods inherited from the VDetector ABC class
+  public:
+    TVector3 GetPos(const unsigned int& i) const{
+      return TVector3(PosX[i],PosY[i],PosZ[i]);
+    }
+
+    // Return true if one veto fired
+    bool HasVeto(){
+      unsigned int size = IsVeto.size();
+      for(unsigned int i = 0 ; i < size ; i++){
+        if(IsVeto[i])
+          return true;
+      }
+      return false;
+    };
+
+    /////////// Get index of fastest neutron
+    int GetFirstHit(){
+      unsigned int size = TOF.size();
+      unsigned int index=0;
+
+      if(!size)
+        return -1;
+
+      double tof = TOF[0];
+      for(unsigned int i = 1 ; i < size ; i++){
+        if(tof<TOF[i]){
+          tof=TOF[i];
+          index=i;
+        }
+      }
+      return index;
+    };
+
+  public:
+    /// A usefull method to bundle all operation to add a detector
+    void ReadXML(NPL::XmlParser); 
+
+    //////////////////////////////////////////////////////////////
+    // methods inherited from the VDetector ABC class
   public:
     // read stream from ConfigFile to pick-up detector parameters
     void ReadConfiguration(NPL::InputParser);
@@ -126,40 +164,36 @@ class TNebulaPhysics : public TObject, public NPL::VDetector {
     void WriteSpectra();
 
 
-  //////////////////////////////////////////////////////////////
-  // specific methods to Nebula array
+    //////////////////////////////////////////////////////////////
+    // specific methods to Nebula 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 TNebulaData object to TNebulaPhysics. 
     // needed for online analysis for example
     void SetRawDataPointer(TNebulaData* rawDataPointer) {m_EventData = rawDataPointer;}
-    
-  // objects are not written in the TTree
+
+    // objects are not written in the TTree
   private:
     TNebulaData*         m_EventData;        //!
-    TNebulaData*         m_PreTreatedData;   //!
     TNebulaPhysics*      m_EventPhysics;     //!
 
-  // getters for raw and pre-treated data object
+    // getters for raw and pre-treated data object
   public:
     TNebulaData* GetRawData()        const {return m_EventData;}
-    TNebulaData* GetPreTreatedData() const {return m_PreTreatedData;}
 
-  // parameters used in the analysis
+    // parameters used in the analysis
   private:
     // thresholds
-    double m_E_RAW_Threshold; //!
-    double m_E_Threshold;     //!
+    double m_Q_RAW_Threshold; //!
+    double m_Q_Threshold;     //!
+    double m_V_Threshold;     //!
 
-  // number of detectors
+    // number of detectors
   private:
     int m_NumberOfBars;  //!
 
@@ -168,16 +202,43 @@ class TNebulaPhysics : public TObject, public NPL::VDetector {
     std::map<unsigned int, bool> m_invertX;//!
     std::map<unsigned int, bool> m_invertY;//!
 
+  private: // xml calibration
+    // position
+    std::map<unsigned int , double > PositionX;//!
+    std::map<unsigned int , double > PositionY;//!
+    std::map<unsigned int , double > PositionZ;//!
+
+    // linear cal
+    std::map<unsigned int , double > aQu;//!
+    std::map<unsigned int , double > bQu;//!
+    std::map<unsigned int , double > aQd;//!
+    std::map<unsigned int , double > bQd;//!
+    std::map<unsigned int , double > aTu;//!
+    std::map<unsigned int , double > bTu;//!
+    std::map<unsigned int , double > aTd;//!
+    std::map<unsigned int , double > bTd;//!
+
+    // T average offset
+    std::map<unsigned int , double > avgT0;//!
+
+    // slew correction T= tcal +slwT/sqrt(Qcal)
+    std::map<unsigned int , double > slwTu;//!
+    std::map<unsigned int , double > slwTd;//!
+
+    // DT position cal
+    std::map<unsigned int , double > DTa;//!
+    std::map<unsigned int , double > DTb;//!
+
 
-  // spectra class
+    // spectra class
   private:
     TNebulaSpectra* m_Spectra; // !
 
-  // spectra getter
+    // spectra getter
   public:
     map<string, TH1*>   GetSpectra(); 
 
-  // Static constructor to be passed to the Detector Factory
+    // Static constructor to be passed to the Detector Factory
   public:
     static NPL::VDetector* Construct();
 

NPLib/Physics/NPParticle.cxx

@@ -510,7 +510,7 @@ void Particle::BetaToGamma(){
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 
 void Particle::BetaToVelocity(){
-  fVelocity = (c_light*1e6)*fBeta*1e-7;
+  fVelocity = c_light*fBeta;
 }
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 

NPLib/Physics/NPParticle.h

@@ -139,6 +139,7 @@ namespace NPL {
       EnergyToBeta();
       BetaToGamma();
       BetaToVelocity();}
+
     void SetExcitationEnergy(double Ex) {fExcitationEnergy=Ex;}
     void				SetBeta(double beta)					{fBeta = beta; BetaToGamma(); BetaToEnergy(); EnergyToTof(); EnergyToBrho();BetaToVelocity();}
       double GetEnergyCM(double EnergyLab, double ThetaLab, double PhiLab, double relativisticboost);

NPLib/TrackReconstruction/NPDCReconstructionMT.cxx

@@ -229,7 +229,7 @@ void DCReconstructionMT::StartThread(unsigned int id){
   mini->SetPrintLevel(0);
 
   // Let the main thread start
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  std::this_thread::sleep_for(std::chrono::milliseconds(250));
   while(true){
     // Do the job if possible
     if(m_Ready[id]){

Projects/S034/Analysis.h

@@ -22,6 +22,7 @@
  *****************************************************************************/
 
 #include"NPVAnalysis.h"
+#include"NPEnergyLoss.h"
 #include"TMinosPhysics.h"
 #include"TNebulaPhysics.h"
 #include"TSamuraiBDCPhysics.h"
@@ -50,18 +51,18 @@ class Analysis: public NPL::VAnalysis{
     TSamuraiFDC2Physics* FDC2;
     TSamuraiHodoscopePhysics* Hodo;
     SamuraiFieldMap m_field ;
-    ofstream file;
+//    ofstream file;
   private: // output variable
-    double Brho,BrhoP,BDCX,BDCY,Z;
+    double Brho,BDCX,BDCY,X,Y,Z,Erel;
     double Beta_f;
+    double Beta_n;
     int    Trigger;
+  private: // Energy loss table
+   NPL::EnergyLoss FragmentTarget ;
   public:
     void  Clear();
     void  InitOutputBranch();
     void  InitInputBranch();
-
 };
 
-// use for broh calculation
-double r_fit(double *x) ;
 #endif

Projects/S034/Calibration/Nebula/Nebula_T.txt

-NEBULA_ID1_T 19.2852
-NEBULA_ID2_T 19.2846
-NEBULA_ID3_T 19.4056
-NEBULA_ID4_T 19.1069
-NEBULA_ID5_T 19.4713
-NEBULA_ID6_T 19.2863
-NEBULA_ID7_T 19.2007
-NEBULA_ID8_T 19.3881
-NEBULA_ID9_T 19.1476
-NEBULA_ID10_T 19.0105
-NEBULA_ID11_T 19.1384
-NEBULA_ID12_T 19.1565
-NEBULA_ID13_T 18.9115
-NEBULA_ID14_T 19.0286
-NEBULA_ID15_T 19.4379
-NEBULA_ID16_T 18.9817
-NEBULA_ID17_T 18.8992
-NEBULA_ID18_T 18.6782
-NEBULA_ID19_T 19.0459
-NEBULA_ID20_T 18.8453
-NEBULA_ID21_T 18.7874
-NEBULA_ID22_T 18.9267
-NEBULA_ID23_T 18.6575
-NEBULA_ID24_T 18.8422
-NEBULA_ID25_T 19.072
-NEBULA_ID26_T 19.5044
-NEBULA_ID27_T 19.4049
-NEBULA_ID28_T 19.0738
-NEBULA_ID29_T 19.3946
-NEBULA_ID30_T 19.4726
-NEBULA_ID31_T 19.121
-NEBULA_ID32_T 19.1251
-NEBULA_ID33_T 19.2008
-NEBULA_ID34_T 18.9232
-NEBULA_ID35_T 18.8517
-NEBULA_ID36_T 18.9349
-NEBULA_ID37_T 19.2574
-NEBULA_ID38_T 18.7397
-NEBULA_ID39_T 19.0286
-NEBULA_ID40_T 18.5307
-NEBULA_ID41_T 19.006
-NEBULA_ID42_T 18.634
-NEBULA_ID43_T 19.2158
-NEBULA_ID44_T 18.8532
-NEBULA_ID45_T 18.8342
-NEBULA_ID46_T 18.9721
-NEBULA_ID47_T 18.968
-NEBULA_ID48_T 19.1271
-NEBULA_ID49_T 18.816
-NEBULA_ID50_T 18.952
-NEBULA_ID51_T 18.9897
-NEBULA_ID52_T 19.0074
-NEBULA_ID53_T 19.2299
-NEBULA_ID54_T 19.0185
-NEBULA_ID55_T 19.2308
-NEBULA_ID56_T 19.0939
-NEBULA_ID57_T 19.3677
-NEBULA_ID58_T 19.5316
-NEBULA_ID59_T 19.8612
-NEBULA_ID60_T 19.6356
-NEBULA_ID61_T 18.6837
-NEBULA_ID62_T 18.6049
-NEBULA_ID63_T 20.3056
-NEBULA_ID64_T 19.1702
-NEBULA_ID65_T 19.3322
-NEBULA_ID66_T 19.6835
-NEBULA_ID67_T 19.0867
-NEBULA_ID68_T 18.6978
-NEBULA_ID69_T 17.9037
-NEBULA_ID70_T 18.9826
-NEBULA_ID71_T 18.6267
-NEBULA_ID72_T 18.2024
-NEBULA_ID73_T 19.0313
-NEBULA_ID74_T 18.8189
-NEBULA_ID75_T 18.6591
-NEBULA_ID76_T 19.3614
-NEBULA_ID77_T 19.2587
-NEBULA_ID78_T 18.1176
-NEBULA_ID79_T 18.7292
-NEBULA_ID80_T 19.3139
-NEBULA_ID81_T 18.8809
-NEBULA_ID82_T 17.6727
-NEBULA_ID83_T 19.1507
-NEBULA_ID84_T 18.8959
-NEBULA_ID85_T 18.0162
-NEBULA_ID86_T 19.2333
-NEBULA_ID87_T 18.5977
-NEBULA_ID88_T 17.6151
-NEBULA_ID89_T 19.0762
-NEBULA_ID90_T 18.4975
-NEBULA_ID91_T 19.0267
-NEBULA_ID92_T 19.0031
-NEBULA_ID93_T 19.0938
-NEBULA_ID94_T 18.7937
-NEBULA_ID95_T 19.1556
-NEBULA_ID96_T 19.1339
-NEBULA_ID97_T 19.3789
-NEBULA_ID98_T 18.9279
-NEBULA_ID99_T 19.3174
-NEBULA_ID100_T 19.3137
-NEBULA_ID101_T 19.0579
-NEBULA_ID102_T 18.775
-NEBULA_ID103_T 19.3587
-NEBULA_ID104_T 18.874
-NEBULA_ID105_T 19.4789
-NEBULA_ID106_T 19.4282
-NEBULA_ID107_T 19.1013
-NEBULA_ID108_T 18.9991
-NEBULA_ID109_T 19.0751
-NEBULA_ID110_T 18.0316
-NEBULA_ID111_T 18.9544
-NEBULA_ID112_T 19.4328
-NEBULA_ID113_T 18.7139
-NEBULA_ID114_T 19.893
-NEBULA_ID115_T 18.3269
-NEBULA_ID116_T 18.545
-NEBULA_ID117_T 20.0339
-NEBULA_ID118_T 18.9662
-NEBULA_ID119_T 20.0821
-NEBULA_ID120_T 19.4934
+NEBULA_T_ID1 19.2852
+NEBULA_T_ID2 19.2846
+NEBULA_T_ID3 19.4056
+NEBULA_T_ID4 19.1069
+NEBULA_T_ID5 19.4713
+NEBULA_T_ID6 19.2863
+NEBULA_T_ID7 19.2007
+NEBULA_T_ID8 19.3881
+NEBULA_T_ID9 19.1476
+NEBULA_T_ID10 19.0105
+NEBULA_T_ID11 19.1384
+NEBULA_T_ID12 19.1565
+NEBULA_T_ID13 18.9115
+NEBULA_T_ID14 19.0286
+NEBULA_T_ID15 19.4379
+NEBULA_T_ID16 18.9817
+NEBULA_T_ID17 18.8992
+NEBULA_T_ID18 18.6782
+NEBULA_T_ID19 19.0459
+NEBULA_T_ID20 18.8453
+NEBULA_T_ID21 18.7874
+NEBULA_T_ID22 18.9267
+NEBULA_T_ID23 18.6575
+NEBULA_T_ID24 18.8422
+NEBULA_T_ID25 19.072
+NEBULA_T_ID26 19.5044
+NEBULA_T_ID27 19.4049
+NEBULA_T_ID28 19.0738
+NEBULA_T_ID29 19.3946
+NEBULA_T_ID30 19.4726
+NEBULA_T_ID31 19.121
+NEBULA_T_ID32 19.1251
+NEBULA_T_ID33 19.2008
+NEBULA_T_ID34 18.9232
+NEBULA_T_ID35 18.8517
+NEBULA_T_ID36 18.9349
+NEBULA_T_ID37 19.2574
+NEBULA_T_ID38 18.7397
+NEBULA_T_ID39 19.0286
+NEBULA_T_ID40 18.5307
+NEBULA_T_ID41 19.006
+NEBULA_T_ID42 18.634
+NEBULA_T_ID43 19.2158
+NEBULA_T_ID44 18.8532
+NEBULA_T_ID45 18.8342
+NEBULA_T_ID46 18.9721
+NEBULA_T_ID47 18.968
+NEBULA_T_ID48 19.1271
+NEBULA_T_ID49 18.816
+NEBULA_T_ID50 18.952
+NEBULA_T_ID51 18.9897
+NEBULA_T_ID52 19.0074
+NEBULA_T_ID53 19.2299
+NEBULA_T_ID54 19.0185
+NEBULA_T_ID55 19.2308
+NEBULA_T_ID56 19.0939
+NEBULA_T_ID57 19.3677
+NEBULA_T_ID58 19.5316
+NEBULA_T_ID59 19.8612
+NEBULA_T_ID60 19.6356
+NEBULA_T_ID61 18.6837
+NEBULA_T_ID62 18.6049
+NEBULA_T_ID63 20.3056
+NEBULA_T_ID64 19.1702
+NEBULA_T_ID65 19.3322
+NEBULA_T_ID66 19.6835
+NEBULA_T_ID67 19.0867
+NEBULA_T_ID68 18.6978
+NEBULA_T_ID69 17.9037
+NEBULA_T_ID70 18.9826
+NEBULA_T_ID71 18.6267
+NEBULA_T_ID72 18.2024
+NEBULA_T_ID73 19.0313
+NEBULA_T_ID74 18.8189
+NEBULA_T_ID75 18.6591
+NEBULA_T_ID76 19.3614
+NEBULA_T_ID77 19.2587
+NEBULA_T_ID78 18.1176
+NEBULA_T_ID79 18.7292
+NEBULA_T_ID80 19.3139
+NEBULA_T_ID81 18.8809
+NEBULA_T_ID82 17.6727
+NEBULA_T_ID83 19.1507
+NEBULA_T_ID84 18.8959
+NEBULA_T_ID85 18.0162
+NEBULA_T_ID86 19.2333
+NEBULA_T_ID87 18.5977
+NEBULA_T_ID88 17.6151
+NEBULA_T_ID89 19.0762
+NEBULA_T_ID90 18.4975
+NEBULA_T_ID91 19.0267
+NEBULA_T_ID92 19.0031
+NEBULA_T_ID93 19.0938
+NEBULA_T_ID94 18.7937
+NEBULA_T_ID95 19.1556
+NEBULA_T_ID96 19.1339
+NEBULA_T_ID97 19.3789
+NEBULA_T_ID98 18.9279
+NEBULA_T_ID99 19.3174
+NEBULA_T_ID100 19.3137
+NEBULA_T_ID101 19.0579
+NEBULA_T_ID102 18.775
+NEBULA_T_ID103 19.3587
+NEBULA_T_ID104 18.874
+NEBULA_T_ID105 19.4789
+NEBULA_T_ID106 19.4282
+NEBULA_T_ID107 19.1013
+NEBULA_T_ID108 18.9991
+NEBULA_T_ID109 19.0751
+NEBULA_T_ID110 18.0316
+NEBULA_T_ID111 18.9544
+NEBULA_T_ID112 19.4328
+NEBULA_T_ID113 18.7139
+NEBULA_T_ID114 19.893
+NEBULA_T_ID115 18.3269
+NEBULA_T_ID116 18.545
+NEBULA_T_ID117 20.0339
+NEBULA_T_ID118 18.9662
+NEBULA_T_ID119 20.0821
+NEBULA_T_ID120 19.4934

Projects/S034/Calibration/Nebula/Nebula_Y.txt

-NEBULA_ID1_Y 1.38638
-NEBULA_ID2_Y -3.8305
-NEBULA_ID3_Y 3.07288
-NEBULA_ID4_Y -4.23115
-NEBULA_ID5_Y -2.90823
-NEBULA_ID6_Y 2.06144
-NEBULA_ID7_Y -6.14942
-NEBULA_ID8_Y -4.20327
-NEBULA_ID9_Y 13.9879
-NEBULA_ID10_Y -3.06973
-NEBULA_ID11_Y -1.99039
-NEBULA_ID12_Y -4.86424
-NEBULA_ID13_Y 5.29633
-NEBULA_ID14_Y -0.662125
-NEBULA_ID15_Y 3.04338
-NEBULA_ID16_Y -4.29256
-NEBULA_ID17_Y -2.30441
-NEBULA_ID18_Y 0.160267
-NEBULA_ID19_Y -9.17392
-NEBULA_ID20_Y 7.05093
-NEBULA_ID21_Y 2.09011
-NEBULA_ID22_Y -6.41303
-NEBULA_ID23_Y 0.530808
-NEBULA_ID24_Y 4.12012
-NEBULA_ID25_Y 0.363813
-NEBULA_ID26_Y -4.18461
-NEBULA_ID27_Y -4.88908
-NEBULA_ID28_Y 1.10303
-NEBULA_ID29_Y 6.93376
-NEBULA_ID30_Y -0.585477
-NEBULA_ID31_Y 3.24728
-NEBULA_ID32_Y -0.673857
-NEBULA_ID33_Y -0.00853288
-NEBULA_ID34_Y 0.436468
-NEBULA_ID35_Y 2.1838
-NEBULA_ID36_Y 1.45213
-NEBULA_ID37_Y 3.2373
-NEBULA_ID38_Y -2.325
-NEBULA_ID39_Y -3.20755
-NEBULA_ID40_Y -1.26772
-NEBULA_ID41_Y 0.887659
-NEBULA_ID42_Y 2.37744
-NEBULA_ID43_Y -1.16329
-NEBULA_ID44_Y -3.6847
-NEBULA_ID45_Y 3.10103
-NEBULA_ID46_Y 2.02808
-NEBULA_ID47_Y -0.509373
-NEBULA_ID48_Y 6.99985
-NEBULA_ID49_Y -1.29247
-NEBULA_ID50_Y -0.304723
-NEBULA_ID51_Y 3.23443
-NEBULA_ID52_Y -5.04529
-NEBULA_ID53_Y -1.669
-NEBULA_ID54_Y 4.07673
-NEBULA_ID55_Y -2.16088
-NEBULA_ID56_Y 4.10968
-NEBULA_ID57_Y -5.66633
-NEBULA_ID58_Y 5.72757
-NEBULA_ID59_Y -0.284415
-NEBULA_ID60_Y 4.61204
-NEBULA_ID61_Y -11.215
-NEBULA_ID62_Y 2.20483
-NEBULA_ID63_Y 3.65855
-NEBULA_ID64_Y -6.00011
-NEBULA_ID65_Y -4.83289
-NEBULA_ID66_Y 4.86074
-NEBULA_ID67_Y -5.8572
-NEBULA_ID68_Y 4.79375
-NEBULA_ID69_Y -4.77623
-NEBULA_ID70_Y -2.30597
-NEBULA_ID71_Y -5.44358
-NEBULA_ID72_Y 5.76698
-NEBULA_ID73_Y -4.52093
-NEBULA_ID74_Y 0.669192
-NEBULA_ID75_Y 5.2536
-NEBULA_ID76_Y -3.06509
-NEBULA_ID77_Y -4.24188
-NEBULA_ID78_Y 2.02627
-NEBULA_ID79_Y -4.03842
-NEBULA_ID80_Y 3.1809
-NEBULA_ID81_Y -5.90454
-NEBULA_ID82_Y 1.81077
-NEBULA_ID83_Y -5.46129
-NEBULA_ID84_Y -1.16729
-NEBULA_ID85_Y 2.94024
-NEBULA_ID86_Y -3.34849
-NEBULA_ID87_Y -8.60917
-NEBULA_ID88_Y -1.84303
-NEBULA_ID89_Y 1.29457
-NEBULA_ID90_Y -1.06823
-NEBULA_ID91_Y 5.69821
-NEBULA_ID92_Y -5.7119
-NEBULA_ID93_Y 7.594
-NEBULA_ID94_Y 4.47444
-NEBULA_ID95_Y 3.8241
-NEBULA_ID96_Y -10.6418
-NEBULA_ID97_Y 14.1286
-NEBULA_ID98_Y -5.54334
-NEBULA_ID99_Y 5.50645
-NEBULA_ID100_Y -5.75486
-NEBULA_ID101_Y -3.05549
-NEBULA_ID102_Y 7.65411
-NEBULA_ID103_Y 0.353753
-NEBULA_ID104_Y -5.75768
-NEBULA_ID105_Y 4.14771
-NEBULA_ID106_Y -0.914708
-NEBULA_ID107_Y 3.08513
-NEBULA_ID108_Y 0.902261
-NEBULA_ID109_Y -0.553475
-NEBULA_ID110_Y 5.95105
-NEBULA_ID111_Y -2.47195
-NEBULA_ID112_Y -5.24212
-NEBULA_ID113_Y 13.0663
-NEBULA_ID114_Y -2.03506
-NEBULA_ID115_Y 5.80118
-NEBULA_ID116_Y -2.23628
-NEBULA_ID117_Y 6.53639
-NEBULA_ID118_Y 2.23348
-NEBULA_ID119_Y -6.16759
-NEBULA_ID120_Y 0.972052
+NEBULA_Y_ID1 1.38638
+NEBULA_Y_ID2 -3.8305
+NEBULA_Y_ID3 3.07288
+NEBULA_Y_ID4 -4.23115
+NEBULA_Y_ID5 -2.90823
+NEBULA_Y_ID6 2.06144
+NEBULA_Y_ID7 -6.14942
+NEBULA_Y_ID8 -4.20327
+NEBULA_Y_ID9 13.9879
+NEBULA_Y_ID10 -3.06973
+NEBULA_Y_ID11 -1.99039
+NEBULA_Y_ID12 -4.86424
+NEBULA_Y_ID13 5.29633
+NEBULA_Y_ID14 -0.662125
+NEBULA_Y_ID15 3.04338
+NEBULA_Y_ID16 -4.29256
+NEBULA_Y_ID17 -2.30441
+NEBULA_Y_ID18 0.160267
+NEBULA_Y_ID19 -9.17392
+NEBULA_Y_ID20 7.05093
+NEBULA_Y_ID21 2.09011
+NEBULA_Y_ID22 -6.41303
+NEBULA_Y_ID23 0.530808
+NEBULA_Y_ID24 4.12012
+NEBULA_Y_ID25 0.363813
+NEBULA_Y_ID26 -4.18461
+NEBULA_Y_ID27 -4.88908
+NEBULA_Y_ID28 1.10303
+NEBULA_Y_ID29 6.93376
+NEBULA_Y_ID30 -0.585477
+NEBULA_Y_ID31 3.24728
+NEBULA_Y_ID32 -0.673857
+NEBULA_Y_ID33 -0.00853288
+NEBULA_Y_ID34 0.436468
+NEBULA_Y_ID35 2.1838
+NEBULA_Y_ID36 1.45213
+NEBULA_Y_ID37 3.2373
+NEBULA_Y_ID38 -2.325
+NEBULA_Y_ID39 -3.20755
+NEBULA_Y_ID40 -1.26772
+NEBULA_Y_ID41 0.887659
+NEBULA_Y_ID42 2.37744
+NEBULA_Y_ID43 -1.16329
+NEBULA_Y_ID44 -3.6847
+NEBULA_Y_ID45 3.10103
+NEBULA_Y_ID46 2.02808
+NEBULA_Y_ID47 -0.509373
+NEBULA_Y_ID48 6.99985
+NEBULA_Y_ID49 -1.29247
+NEBULA_Y_ID50 -0.304723
+NEBULA_Y_ID51 3.23443
+NEBULA_Y_ID52 -5.04529
+NEBULA_Y_ID53 -1.669
+NEBULA_Y_ID54 4.07673
+NEBULA_Y_ID55 -2.16088
+NEBULA_Y_ID56 4.10968
+NEBULA_Y_ID57 -5.66633
+NEBULA_Y_ID58 5.72757
+NEBULA_Y_ID59 -0.284415
+NEBULA_Y_ID60 4.61204
+NEBULA_Y_ID61 -11.215
+NEBULA_Y_ID62 2.20483
+NEBULA_Y_ID63 3.65855
+NEBULA_Y_ID64 -6.00011
+NEBULA_Y_ID65 -4.83289
+NEBULA_Y_ID66 4.86074
+NEBULA_Y_ID67 -5.8572
+NEBULA_Y_ID68 4.79375
+NEBULA_Y_ID69 -4.77623
+NEBULA_Y_ID70 -2.30597
+NEBULA_Y_ID71 -5.44358
+NEBULA_Y_ID72 5.76698
+NEBULA_Y_ID73 -4.52093
+NEBULA_Y_ID74 0.669192
+NEBULA_Y_ID75 5.2536
+NEBULA_Y_ID76 -3.06509
+NEBULA_Y_ID77 -4.24188
+NEBULA_Y_ID78 2.02627
+NEBULA_Y_ID79 -4.03842
+NEBULA_Y_ID80 3.1809
+NEBULA_Y_ID81 -5.90454
+NEBULA_Y_ID82 1.81077
+NEBULA_Y_ID83 -5.46129
+NEBULA_Y_ID84 -1.16729
+NEBULA_Y_ID85 2.94024
+NEBULA_Y_ID86 -3.34849
+NEBULA_Y_ID87 -8.60917
+NEBULA_Y_ID88 -1.84303
+NEBULA_Y_ID89 1.29457
+NEBULA_Y_ID90 -1.06823
+NEBULA_Y_ID91 5.69821
+NEBULA_Y_ID92 -5.7119
+NEBULA_Y_ID93 7.594
+NEBULA_Y_ID94 4.47444
+NEBULA_Y_ID95 3.8241
+NEBULA_Y_ID96 -10.6418
+NEBULA_Y_ID97 14.1286
+NEBULA_Y_ID98 -5.54334
+NEBULA_Y_ID99 5.50645
+NEBULA_Y_ID100 -5.75486
+NEBULA_Y_ID101 -3.05549
+NEBULA_Y_ID102 7.65411
+NEBULA_Y_ID103 0.353753
+NEBULA_Y_ID104 -5.75768
+NEBULA_Y_ID105 4.14771
+NEBULA_Y_ID106 -0.914708
+NEBULA_Y_ID107 3.08513
+NEBULA_Y_ID108 0.902261
+NEBULA_Y_ID109 -0.553475
+NEBULA_Y_ID110 5.95105
+NEBULA_Y_ID111 -2.47195
+NEBULA_Y_ID112 -5.24212
+NEBULA_Y_ID113 13.0663
+NEBULA_Y_ID114 -2.03506
+NEBULA_Y_ID115 5.80118
+NEBULA_Y_ID116 -2.23628
+NEBULA_Y_ID117 6.53639
+NEBULA_Y_ID118 2.23348
+NEBULA_Y_ID119 -6.16759
+NEBULA_Y_ID120 0.972052

Projects/S034/Calibration/Nebula/convert.cxx

@@ -7,7 +7,7 @@ void convert(){
  double val;
  getline(in,buffer); // ignore first line
  while(in >> id >> buffer){
-    out << "NEBULA_ID" << id << "_T " << buffer  << endl;
+    out << "NEBULA_T_ID" << id << " " << buffer  << endl;
  }
  out.close();
  in.close();
@@ -16,7 +16,7 @@ void convert(){
 
  getline(in,buffer); // ignore first line
  while(in >> id >> buffer){
-    out << "NEBULA_ID" << id << "_Y " << buffer  << endl;
+    out << "NEBULA_Y_ID" << id << " " << buffer  << endl;
  }
  out.close();
  in.close();

Projects/S034/db/s034_list.txt

@@ -7,3 +7,4 @@ db/SAMURAIFDC0_20200109.xml
 db/SAMURAIHOD_s034_all40mV_s037_20170702.xml
 db/SAMURAIBDC1.xml
 db/SAMURAIBDC2.xml
+db/SAMURAIPlastic.s034.2.xml

Projects/S034/s034.detector

@@ -9,8 +9,6 @@ SAMURAIBDC 1
 %%%%%%%%%%%%
 SAMURAIBDC 2
  XML= db/SAMURAIBDC2.xml
-% Offset= +0.25 +1.6 -5876.7 mm
-% Offset= 0 0 -5876.7 mm
  Offset= -0.0686464 0.294288 -5876.7 mm
  InvertX= 0 
  InvertY= 0