* Add Hyde2 to NPLib

NPLib/HYDE2/Hyde2Tracker.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 31/08/09                                                 *
+ * Last update    : 10/09/09                                                 *
+ *---------------------------------------------------------------------------*
+ * Decription: This class is mainly an interface to the                      *
+ *             THyde2TrackerPhysics class and it deals with the geometrical*
+ *             correspondance between strip number and absolute coordinates  *
+ *             (X, Y, Z) of interaction.                                     *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *   + 10/09/09: Add support for Square and DummyShape shapes                *
+ *               (N. de Sereville)                                           *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#include "Hyde2Tracker.h"
+
+// C++ headers
+#include <iostream>   
+#include <fstream>
+#include <string>
+#include <cmath>
+#include <stdlib.h>
+
+// NPL headers
+#include "RootInput.h"
+#include "RootOutput.h"
+
+// ROOT headers
+#include "TChain.h"
+
+// Hyde2 headers
+#include "Hyde2TrackerTrapezoid1.h"
+#include "Hyde2TrackerTrapezoid2.h"
+#include "Hyde2TrackerSquare1.h"
+
+using namespace std ;   
+
+
+
+
+Hyde2Tracker::Hyde2Tracker()
+   : m_EventData (new THyde2TrackerData()),
+     m_EventPhysics (new THyde2TrackerPhysics())
+{
+}   
+
+
+
+Hyde2Tracker::~Hyde2Tracker()
+{
+   delete m_EventData;
+   delete m_EventPhysics;
+}   
+
+
+
+void Hyde2Tracker::Clear()
+{
+}
+
+
+
+// Read stream at ConfigFile to pick-up parameters of detector (Position,...) using Token
+void Hyde2Tracker::ReadConfiguration(string Path)    
+{
+   // open configuration file
+   ifstream ConfigFile;
+   ConfigFile.open(Path.c_str());
+
+   bool HYD2TrkTrapezoid1  = false;
+   bool HYD2TrkTrapezoid2  = false;
+   bool HYD2TrkSquare1     = false;
+
+   string LineBuffer;
+   while (!ConfigFile.eof()) {
+      getline(ConfigFile, LineBuffer);
+      if (LineBuffer.compare(0, 11, "HYD2Square1") == 0  &&  HYD2TrkSquare1 == false) {
+         HYD2TrkSquare1 = true;
+
+         // instantiate a new "detector" corresponding to the Shape elements
+         Hyde2TrackerModule* myDetector = new Hyde2TrackerSquare1(m_ModulesMap, m_EventPhysics);
+
+         // Pass the data object to the Hyde2Tracker*** object
+         myDetector->SetHyde2DataPointer(m_EventData);
+
+         // read part of the configuration file corresponding to shape elements
+         ConfigFile.close();
+         myDetector->ReadConfiguration(Path);
+         ConfigFile.open(Path.c_str());
+      }
+      else if (LineBuffer.compare(0, 14, "HYD2Trapezoid1") == 0  &&  HYD2TrkTrapezoid1 == false) {
+         HYD2TrkTrapezoid1 = true;
+
+         // instantiate a new "detector" corresponding to the Trapezoid elements
+         Hyde2TrackerModule* myDetector = new Hyde2TrackerTrapezoid1(m_ModulesMap, m_EventPhysics);
+
+         // Pass the data object to the Hyde2Tracker*** object
+         myDetector->SetHyde2DataPointer(m_EventData);
+
+         // read part of the configuration file corresponding to trapezoid elements
+         ConfigFile.close();
+         myDetector->ReadConfiguration(Path);
+         ConfigFile.open(Path.c_str());
+      }
+      else if (LineBuffer.compare(0, 14, "HYD2Trapezoid2") == 0  &&  HYD2TrkTrapezoid2 == false) {
+         HYD2TrkTrapezoid2 = true;
+
+         // instantiate a new "detector" corresponding to the Trapezoid elements
+         Hyde2TrackerModule* myDetector = new Hyde2TrackerTrapezoid2(m_ModulesMap, m_EventPhysics);
+
+         // Pass the data object to the Hyde2Tracker*** object
+         myDetector->SetHyde2DataPointer(m_EventData);
+
+         // read part of the configuration file corresponding to trapezoid elements
+         ConfigFile.close();
+         myDetector->ReadConfiguration(Path);
+         ConfigFile.open(Path.c_str());
+      }
+   }
+}
+
+
+// Read stream at Path and pick-up calibration parameter using Token
+// If argument is "Simulation" no change calibration is loaded
+void Hyde2Tracker::ReadCalibrationFile(string Path)   
+{
+   Path.c_str();   // remove warning at compilation time
+
+/*   // Order of Polynom function used for calibration
+   int Calibration_Si_E_Order;
+   int Calibration_Si_T_Order;
+   int Calibration_SiLi_E_Order;
+   int Calibration_CsI_E_Order;
+
+   // Calibration_Si_X_E[DetectorNumber][StripNumber][Order of Coeff]
+   vector< vector< vector< double > > >   Calibration_Si_X_E   ;
+   vector< vector< vector< double > > >   Calibration_Si_X_T   ;
+   vector< vector< vector< double > > >   Calibration_Si_Y_E   ;
+   vector< vector< vector< double > > >   Calibration_Si_Y_T   ;
+
+   // Calibration_SiLi_E[DetectorNumber][PadNumber][Order of Coeff]
+   vector< vector< vector< double > > >   Calibration_SiLi_E   ;
+
+   // Calibration_SiLi_E[DetectorNumber][CrystalNumber][Order of Coeff]
+   vector< vector< vector< double > > >   Calibration_CsI_E   ;
+
+   if (Path == "Simulation") {   // Simulation case: data already calibrated
+      Calibration_Si_E_Order   = 1;
+      Calibration_Si_T_Order   = 1;
+      Calibration_SiLi_E_Order = 1;
+      Calibration_CsI_E_Order  = 1;
+
+      vector<double> Coef;
+      // Order 0            Order 1
+      Coef.push_back(0) ; Coef.push_back(1)    ;
+
+      vector< vector<double> > StripLine       ;
+      StripLine.resize( 128 , Coef)         ;
+
+      Calibration_Si_X_E.resize( m_NumberOfModule , StripLine)   ;
+      Calibration_Si_X_T.resize( m_NumberOfModule , StripLine)   ;
+      Calibration_Si_Y_E.resize( m_NumberOfModule , StripLine)   ;
+      Calibration_Si_Y_T.resize( m_NumberOfModule , StripLine)   ;
+            
+      Calibration_SiLi_E.resize( m_NumberOfModule , StripLine)   ;
+      Calibration_CsI_E .resize( m_NumberOfModule , StripLine)   ;
+   }
+   else {
+   }
+*/
+}      
+
+   
+
+// Activated associated Branches and link it to the private member DetectorData address
+// In this method mother Branches (Detector) AND daughter leaf (fDetector_parameter) have to be activated
+void Hyde2Tracker::InitializeRootInput()       
+{
+   TChain* inputChain = RootInput::getInstance()->GetChain();
+   inputChain->SetBranchStatus("HYDE2", true);
+   inputChain->SetBranchStatus("fHYD2*", true);
+   inputChain->SetBranchAddress("HYDE2", &m_EventData);
+}
+
+
+
+// Create associated branches and associated private member DetectorPhysics address
+void Hyde2Tracker::InitializeRootOutput()    
+{
+   TTree* outputTree = RootOutput::getInstance()->GetTree();
+   outputTree->Branch("HYDE2", "THyde2TrackerPhysics", &m_EventPhysics);
+}
+
+
+
+// This method is called at each event read from the Input Tree. Aime is to build treat Raw dat in order to extract physical parameter. 
+void Hyde2Tracker::BuildPhysicalEvent()      
+{
+   if (m_EventData->GetHYD2TrkFirstStageFrontEMult() > 0) {
+      for (UInt_t i = 0; i < m_EventData->GetHYD2TrkFirstStageFrontEMult(); i++) {
+         UShort_t detecNbr = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(i);
+         m_ModulesMap[detecNbr]->BuildPhysicalEvent();
+      }
+   }
+}
+
+
+
+// Same as above, but only the simplest event and/or simple method are used (low multiplicity, faster algorythm but less efficient ...).
+// This method aimed to be used for analysis performed during experiment, when speed is requiered.
+// NB: This method can eventually be the same as BuildPhysicalEvent.
+void Hyde2Tracker::BuildSimplePhysicalEvent()   
+{
+   BuildPhysicalEvent();
+}
+
+
+
+void Hyde2Tracker::DumpModulesMap()
+{
+   cout << "Hyde2Tracker::DumpMap()" << endl;
+
+   map<int, Hyde2TrackerModule*>::iterator it;
+
+   for (it = m_ModulesMap.begin(); it != m_ModulesMap.end(); ++it) {
+      cout << "Module " << it->first << " -> Address " << it->second << endl;
+   }
+}
+
+
+
+void Hyde2Tracker::DumpStrippingScheme(int moduleNumber)
+{
+   cout << "Hyde2Tracker::DumpStrippingScheme()" << endl;
+
+   for (int i = 1; i < 128; i++) {   // front part
+      for (int j = 1; j < 128; j++) {   // back part
+         cout << "strips X, Y: " << i << "  " << j << "\t--->\t (X,Y,Z) mm: "
+              << m_ModulesMap[moduleNumber]->GetStripPositionX(moduleNumber, i, j) << "\t"
+              << m_ModulesMap[moduleNumber]->GetStripPositionY(moduleNumber, i, j) << "\t"
+              << m_ModulesMap[moduleNumber]->GetStripPositionZ(moduleNumber, i, j) << endl;
+      }
+   }
+}
+
+
+
+double Hyde2Tracker::GetEnergyDeposit()      
+{ 
+   if (m_EventPhysics->GetEventMultiplicity() > 0) {
+      return m_EventPhysics->GetTotalEnergy(0); 
+   }
+   else
+      return -1000;
+}
+
+
+
+TVector3 Hyde2Tracker::GetPositionOfInteraction()
+{
+   TVector3 Position = TVector3(-1000,-1000,-1000);
+
+   if (m_EventPhysics->GetEventMultiplicity() == 1) {
+      Int_t ModuleNbr = m_EventPhysics->GetModuleNumber(0);
+      Int_t FrontPos  = m_EventPhysics->GetFirstStageFrontPosition(0);
+      Int_t BackPos   = m_EventPhysics->GetFirstStageBackPosition(0);
+      Position = TVector3(m_ModulesMap[ModuleNbr]->GetStripPositionX(ModuleNbr, FrontPos, BackPos),
+                          m_ModulesMap[ModuleNbr]->GetStripPositionY(ModuleNbr, FrontPos, BackPos),
+                          m_ModulesMap[ModuleNbr]->GetStripPositionZ(ModuleNbr, FrontPos, BackPos));
+   }
+
+   return Position;
+}

NPLib/HYDE2/Hyde2Tracker.h

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 31/08/09                                                 *
+ * Last update    : 10/09/09                                                 *
+ *---------------------------------------------------------------------------*
+ * Decription: This class is mainly an interface to the                      *
+ *             THyde2TrackerPhysics class and it deals with the geometrical*
+ *             correspondance between strip number and absolute coordinates  *
+ *             (X, Y, Z) of interaction.                                     *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *   + 10/09/09: Add support for Square and DummyShape shapes                *
+ *               (N. de Sereville)                                           *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#ifndef Hyde2Tracker_H
+#define Hyde2Tracker_H
+
+// NPL
+#include "../include/VDetector.h"
+#include "THyde2TrackerData.h"
+#include "THyde2TrackerPhysics.h"
+#include "Hyde2TrackerModule.h"
+
+// C++
+#include <map>
+#include <vector>
+
+// Root
+#include "TObject.h"
+#include "TVector3.h"
+
+class Hyde2Tracker : public NPA::VDetector
+{
+public:
+   Hyde2Tracker();
+   virtual ~Hyde2Tracker();
+
+public:
+  void Clear();
+  void Clear(const Option_t*) {};
+
+public:
+   /////////////////////////////////////
+   // Innherited from VDetector Class //
+   /////////////////////////////////////
+   // Read stream at ConfigFile to pick-up parameters of detector (Position,...) using Token
+   void ReadConfiguration(string);
+
+   // Read stream at CalibFile and pick-up calibration parameter using Token
+   // If argument is "Simulation" no change calibration is loaded
+   void ReadCalibrationFile(string);
+
+   // Activated associated Branches and link it to the private member DetectorData address
+   // In this method mother Branches (Detector) AND daughter leaf (fDetector_parameter) have to be activated
+   void InitializeRootInput();
+
+   // Create associated branches and associated private member DetectorPhysics address
+   void InitializeRootOutput();
+
+   // This method is called at each event read from the Input Tree. 
+   // The aim is to build treat Raw dat in order to extract physical parameter. 
+   void BuildPhysicalEvent();
+   
+   // Same as above, but only the simplest event and/or simple method are used (low multiplicity, faster algorythm but less efficient ...).
+   // This method aimed to be used for analysis performed during experiment, when speed is requiered.
+   // NB: This method can eventually be the same as BuildPhysicalEvent.
+   void BuildSimplePhysicalEvent();
+
+   // Those two method all to clear the Event Physics or Data
+   void ClearEventPhysics()   {m_EventPhysics->Clear();}
+   void ClearEventData()      {m_EventData->Clear();}
+
+
+public:
+   void DumpModulesMap();
+   void DumpStrippingScheme(int moduleNumber);
+
+private:
+   map<int, Hyde2TrackerModule*>   m_ModulesMap;
+
+public:
+   // Get Root input and output objects
+   THyde2TrackerData*    GetEventData()      {return m_EventData;}
+   THyde2TrackerPhysics* GetEventPhysics()   {return m_EventPhysics;}
+
+   // To be called after a build Physical Event 
+   double   GetEnergyDeposit();
+   TVector3 GetPositionOfInteraction();
+
+
+private:
+   ////////////////////////////////////////
+   // Root Input and Output tree classes //
+   ////////////////////////////////////////
+   THyde2TrackerData*      m_EventData;
+   THyde2TrackerPhysics*   m_EventPhysics;
+};
+
+#endif

NPLib/HYDE2/Hyde2TrackerModule.cxx

+#include "Hyde2TrackerModule.h"
+
+
+
+Hyde2TrackerModule::Hyde2TrackerModule()
+{
+   InitializeIndex();
+}
+
+
+
+Hyde2TrackerModule::~Hyde2TrackerModule()
+{
+}
+
+
+
+void Hyde2TrackerModule::InitializeIndex()
+{
+   m_index["Square1"]     = 2000;
+   m_index["Trapezoid1"]  = 2200;
+   m_index["Trapezoid2"]  = 2300;
+}

NPLib/HYDE2/Hyde2TrackerModule.h

+#ifndef Hyde2TrackerModule_h
+#define Hyde2TrackerModule_h 1
+
+// C++ headers
+#include <string>
+#include <map>
+
+// NPTool - ROOT headers
+#include "THyde2TrackerData.h"
+
+using namespace std;
+
+
+
+class Hyde2TrackerModule
+{
+public:
+   Hyde2TrackerModule();
+   virtual ~Hyde2TrackerModule();
+
+public:
+   // Read stream at Configfile to pick-up parameters of detector (Position,...)
+   virtual void ReadConfiguration(string Path) = 0;
+
+   // The goal of this method is to extract physical parameters from raw data
+   // Method called at each event read from the Input Tree
+   virtual void BuildPhysicalEvent() = 0;
+
+   // Same as before but with a simpler treatment
+   virtual void BuildSimplePhysicalEvent() = 0;
+
+   // Initialize the Index map for the different modules of Hyde2
+   void InitializeIndex();
+
+   // Pass the THyde2TrackerData object from THyde2TrackerPhysics to the 
+   // classes deriving from Hyde2TrackerModule
+   virtual void SetHyde2DataPointer(THyde2TrackerData* hyde2Data) = 0;
+
+   //
+   virtual double GetStripPositionX(Int_t DetectorNumber, Int_t stripX, Int_t stripY) = 0;
+   virtual double GetStripPositionY(Int_t DetectorNumber, Int_t stripX, Int_t stripY) = 0;
+   virtual double GetStripPositionZ(Int_t DetectorNumber, Int_t stripX, Int_t stripY) = 0;
+
+protected:
+   map<string, int> m_index;
+};
+
+#endif

NPLib/HYDE2/Hyde2TrackerSquare1.h

+#ifndef Hyde2TrackerSquare1_h
+#define Hyde2TrackerSquare1_h 1
+
+// C++ headers
+#include <string>
+#include <map>
+#include <vector>
+
+// ROOT headers
+#include "TVector3.h"
+
+// Hyde2 headers
+#include "THyde2TrackerData.h"
+#include "THyde2TrackerPhysics.h"
+#include "Hyde2TrackerModule.h"
+
+using namespace std;
+
+
+
+class Hyde2TrackerSquare1 : public Hyde2TrackerModule
+{
+public:
+   ////////////////////////////////////////////////////
+   /////// Default Constructor and Destructor /////////
+   ////////////////////////////////////////////////////
+   Hyde2TrackerSquare1(map<int, Hyde2TrackerModule*> &Module, THyde2TrackerPhysics* &EventPhysics);
+   virtual ~Hyde2TrackerSquare1();
+
+public:
+   ////////////////////////////////////////////////////
+   ////  Inherite from Hyde2TrackerModule class /////
+   ////////////////////////////////////////////////////
+   // Read stream at Configfile to pick-up parameters of detector (Position,...)
+   void ReadConfiguration(string Path);
+
+   // The goal of this method is to extract physical parameters from raw data
+   // Method called at each event read from the Input Tree
+   void BuildPhysicalEvent();
+
+   // Same as before but with a simpler treatment
+   void BuildSimplePhysicalEvent();
+
+private:
+   map<int, Hyde2TrackerModule*>  &m_ModuleTest;
+   THyde2TrackerPhysics*          &m_EventPhysics;
+
+public:
+   void SetHyde2DataPointer(THyde2TrackerData* hyde2Data) {m_EventData = hyde2Data;};
+   void PreTreat();
+
+private:
+   // Hyde2 data coming from THyde2TrackerPhysics through the 
+   // SetHyde2DataPointer method
+   THyde2TrackerData* m_EventData;
+   THyde2TrackerData* m_PreTreatData;
+
+public:
+   ////////////////////////////////
+   // Specific to Hyde2Tracker //
+   ////////////////////////////////
+   // Add a Module using Corner Coordinate information
+   void AddModule(TVector3 C_X1_Y1,
+                  TVector3 C_X128_Y1,
+                  TVector3 C_X1_Y128,
+                  TVector3 C_X128_Y128);
+
+   // Add a Module using R Theta Phi of Si center information
+   void AddModule(double theta,
+                  double phi,
+                  double distance,
+                  double beta_u,
+                  double beta_v,
+                  double beta_w);
+
+   // Getters to retrieve the (X,Y,Z) coordinates of a pixel defined by strips (X,Y)
+   double GetStripPositionX(int N ,int X ,int Y)        { return m_StripPositionX[N-1-m_index["Square1"]][X-1][Y-1]; }
+   double GetStripPositionY(int N ,int X ,int Y)        { return m_StripPositionY[N-1-m_index["Square1"]][X-1][Y-1]; }
+   double GetStripPositionZ(int N ,int X ,int Y)        { return m_StripPositionZ[N-1-m_index["Square1"]][X-1][Y-1]; }
+   double GetNumberOfModule()                           { return m_NumberOfModule; }
+
+private:
+   // Spatial Position of Strip Calculated on basis of detector position
+   int m_NumberOfModule;
+   vector< vector < vector < double > > >       m_StripPositionX;
+   vector< vector < vector < double > > >       m_StripPositionY;
+   vector< vector < vector < double > > >       m_StripPositionZ;
+
+private:
+   //////////////////////////////
+   // Geometry and stip number //
+   //////////////////////////////
+   double m_FirstStageFace;     // mm
+   int    m_NumberOfStrips;
+   double m_StripPitch;
+};
+
+#endif

NPLib/HYDE2/Hyde2TrackerTrapezoid1.h

+#ifndef Hyde2TrackerTrapezoid1_h
+#define Hyde2TrackerTrapezoid1_h 1
+
+// C++ headers
+#include <string>
+#include <map>
+#include <vector>
+
+// ROOT headers
+#include "TVector3.h"
+
+// Hyde2 headers
+#include "THyde2TrackerData.h"
+#include "THyde2TrackerPhysics.h"
+#include "Hyde2TrackerModule.h"
+
+using namespace std;
+
+
+
+class Hyde2TrackerTrapezoid1 : public Hyde2TrackerModule
+{
+public:
+   ////////////////////////////////////////////////////
+   /////// Default Constructor and Destructor /////////
+   ////////////////////////////////////////////////////
+   Hyde2TrackerTrapezoid1(map<int, Hyde2TrackerModule*> &Module, THyde2TrackerPhysics* &EventPhysics);
+   virtual ~Hyde2TrackerTrapezoid1();
+
+public:
+   ////////////////////////////////////////////////////
+   ////  Inherite from Hyde2TrackerModule class /////
+   ////////////////////////////////////////////////////
+   // Read stream at Configfile to pick-up parameters of detector (Position,...)
+   void ReadConfiguration(string Path);
+
+   // The goal of this method is to extract physical parameters from raw data
+   // Method called at each event read from the Input Tree
+   void BuildPhysicalEvent();
+
+   // Same as before but with a simpler treatment
+   void BuildSimplePhysicalEvent();
+
+private:
+   map<int, Hyde2TrackerModule*> &m_ModuleTest;
+   THyde2TrackerPhysics*         &m_EventPhysics;
+
+public:
+   void SetHyde2DataPointer(THyde2TrackerData* hyde2Data) {m_EventData = hyde2Data;};
+   void PreTreat();
+
+private:
+   // Hyde2 data coming from THyde2TrackerPhysics through the 
+   // SetHyde2DataPointer method
+   THyde2TrackerData* m_EventData;
+   THyde2TrackerData* m_PreTreatData;
+
+public:
+   ////////////////////////////////
+   // Specific to Hyde2Tracker //
+   ////////////////////////////////
+   // Add a Module using Corner Coordinate information
+   void AddModule(TVector3 C_X1_Y1,
+                  TVector3 C_X128_Y1,
+                  TVector3 C_X1_Y128,
+                  TVector3 C_X128_Y128);
+
+   // Add a Module using R Theta Phi of Si center information
+   void AddModule(double theta,
+                  double phi,
+                  double distance,
+                  double beta_u,
+                  double beta_v,
+                  double beta_w);
+
+   // Getters to retrieve the (X,Y,Z) coordinates of a pixel defined by strips (X,Y)
+   double GetStripPositionX(int N ,int X ,int Y)        { return m_StripPositionX[N-1-m_index["Trapezoid1"]][X-1][Y-1]; }
+   double GetStripPositionY(int N ,int X ,int Y)        { return m_StripPositionY[N-1-m_index["Trapezoid1"]][X-1][Y-1]; }
+   double GetStripPositionZ(int N ,int X ,int Y)        { return m_StripPositionZ[N-1-m_index["Trapezoid1"]][X-1][Y-1]; }
+   double GetNumberOfModule()                           { return m_NumberOfModule; }
+
+private:
+   // Spatial Position of Strip Calculated on basis of detector position
+   int m_NumberOfModule;
+   vector< vector < vector < double > > >       m_StripPositionX;
+   vector< vector < vector < double > > >       m_StripPositionY;
+   vector< vector < vector < double > > >       m_StripPositionZ;
+
+private:
+   //////////////////////////////
+   // Geometry and stip number //
+   //////////////////////////////
+   double m_FirstStageHeight;      // mm
+   double m_FirstStageBaseLarge;   // mm
+   double m_FirstStageBaseSmall;   // mm
+   int    m_NumberOfStripsX;
+   int    m_NumberOfStripsY;
+   double m_StripPitchX;      // mm
+   double m_StripPitchY;      // mm
+};
+
+#endif

NPLib/HYDE2/Hyde2TrackerTrapezoid2.h

+#ifndef Hyde2TrackerTrapezoid2_h
+#define Hyde2TrackerTrapezoid2_h 1
+
+// C++ headers
+#include <string>
+#include <map>
+#include <vector>
+
+// ROOT headers
+#include "TVector3.h"
+
+// Hyde2 headers
+#include "THyde2TrackerData.h"
+#include "THyde2TrackerPhysics.h"
+#include "Hyde2TrackerModule.h"
+
+using namespace std;
+
+
+
+class Hyde2TrackerTrapezoid2 : public Hyde2TrackerModule
+{
+public:
+   ////////////////////////////////////////////////////
+   /////// Default Constructor and Destructor /////////
+   ////////////////////////////////////////////////////
+   Hyde2TrackerTrapezoid2(map<int, Hyde2TrackerModule*> &Module, THyde2TrackerPhysics* &EventPhysics);
+   virtual ~Hyde2TrackerTrapezoid2();
+
+public:
+   ////////////////////////////////////////////////////
+   ////  Inherite from Hyde2TrackerModule class /////
+   ////////////////////////////////////////////////////
+   // Read stream at Configfile to pick-up parameters of detector (Position,...)
+   void ReadConfiguration(string Path);
+
+   // The goal of this method is to extract physical parameters from raw data
+   // Method called at each event read from the Input Tree
+   void BuildPhysicalEvent();
+
+   // Same as before but with a simpler treatment
+   void BuildSimplePhysicalEvent();
+
+private:
+   map<int, Hyde2TrackerModule*> &m_ModuleTest;
+   THyde2TrackerPhysics*         &m_EventPhysics;
+
+public:
+   void SetHyde2DataPointer(THyde2TrackerData* hyde2Data) {m_EventData = hyde2Data;};
+   void PreTreat();
+
+private:
+   // Hyde2 data coming from THyde2TrackerPhysics through the 
+   // SetHyde2DataPointer method
+   THyde2TrackerData* m_EventData;
+   THyde2TrackerData* m_PreTreatData;
+
+public:
+   ////////////////////////////////
+   // Specific to Hyde2Tracker //
+   ////////////////////////////////
+   // Add a Module using Corner Coordinate information
+   void AddModule(TVector3 C_X1_Y1,
+                  TVector3 C_X128_Y1,
+                  TVector3 C_X1_Y128,
+                  TVector3 C_X128_Y128);
+
+   // Add a Module using R Theta Phi of Si center information
+   void AddModule(double theta,
+                  double phi,
+                  double distance,
+                  double beta_u,
+                  double beta_v,
+                  double beta_w);
+
+   // Getters to retrieve the (X,Y,Z) coordinates of a pixel defined by strips (X,Y)
+   double GetStripPositionX(int N ,int X ,int Y)        { return m_StripPositionX[N-1-m_index["Trapezoid2"]][X-1][Y-1]; }
+   double GetStripPositionY(int N ,int X ,int Y)        { return m_StripPositionY[N-1-m_index["Trapezoid2"]][X-1][Y-1]; }
+   double GetStripPositionZ(int N ,int X ,int Y)        { return m_StripPositionZ[N-1-m_index["Trapezoid2"]][X-1][Y-1]; }
+   double GetNumberOfModule()                           { return m_NumberOfModule; }
+
+private:
+   // Spatial Position of Strip Calculated on basis of detector position
+   int m_NumberOfModule;
+   vector< vector < vector < double > > >       m_StripPositionX;
+   vector< vector < vector < double > > >       m_StripPositionY;
+   vector< vector < vector < double > > >       m_StripPositionZ;
+
+private:
+   //////////////////////////////
+   // Geometry and stip number //
+   //////////////////////////////
+   double m_FirstStageHeight;      // mm
+   double m_FirstStageBaseLarge;   // mm
+   double m_FirstStageBaseSmall;   // mm
+   int    m_NumberOfStripsX;
+   int    m_NumberOfStripsY;
+   double m_StripPitchX;      // mm
+   double m_StripPitchY;      // mm
+};
+
+#endif

NPLib/HYDE2/Makefile

+include ../Makefile.arch
+ 
+#------------------------------------------------------------------------------
+SHARELIB      =  libHyde2Data.so	\
+		 libHyde2TrackerModules.so 	libHyde2Physics.so
+all:            $(SHARELIB)
+#------------------------------------------------------------------------------
+############### Detector ##############
+
+## Hyde2 ##
+libHyde2Data.so:	THyde2TrackerData.o THyde2TrackerDataDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerDataDict.cxx:	THyde2TrackerData.h
+			rootcint -f $@ -c $^
+
+libHyde2Physics.so:	Hyde2Tracker.o THyde2TrackerPhysics.o \
+				THyde2TrackerPhysicsDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerPhysicsDict.cxx:	THyde2TrackerPhysics.h
+			rootcint -f $@ -c $^
+
+libHyde2TrackerModules.so:       Hyde2TrackerModule.o Hyde2TrackerSquare1.o \
+	                         Hyde2TrackerTrapezoid1.o Hyde2TrackerTrapezoid2.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+
+
+# dependances
+Hyde2Tracker.o:	Hyde2Tracker.cxx	Hyde2Tracker.h
+THyde2TrackerData.o:	THyde2TrackerData.cxx	THyde2TrackerData.h
+THyde2TrackerPhysics.o:	THyde2TrackerPhysics.cxx	THyde2TrackerPhysics.h
+Hyde2TrackerModule.o:		Hyde2TrackerModule.cxx	Hyde2TrackerModule.h
+Hyde2TrackerSquare1.o:		Hyde2TrackerSquare1.cxx	Hyde2TrackerSquare1.h
+Hyde2TrackerTrapezoid1.o:	Hyde2TrackerTrapezoid1.cxx	Hyde2TrackerTrapezoid1.h
+Hyde2TrackerTrapezoid2.o:	Hyde2TrackerTrapezoid2.cxx	Hyde2TrackerTrapezoid2.h
+#######################################
+
+############# Clean and More ##########
+clean:
+	@rm -f core *~ *.o *Dict*
+
+distclean:
+	  make clean; rm -f *.so
+
+.SUFFIXES: .$(SrcSuf)
+
+###
+
+.$(SrcSuf).$(ObjSuf):
+	$(CXX) $(CXXFLAGS) $(INCLUDE) -c $<
+
+

NPLib/HYDE2/Makefile_longer

+include ../Makefile.arch
+ 
+#------------------------------------------------------------------------------
+SHARELIB      =  libHyde2Data.so	\
+		 libHyde2TrackerModules.so 	libHyde2Physics.so
+all:            $(SHARELIB)
+#------------------------------------------------------------------------------
+############### Detector ##############
+
+## Hyde2 ##
+libHyde2Data.so:	THyde2TrackerData.o THyde2TrackerDataDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerDataDict.cxx:	THyde2TrackerData.h
+			rootcint -f $@ -c $^
+
+libHyde2Physics.so:	Hyde2Tracker.o THyde2TrackerPhysics.o \
+				THyde2TrackerPhysicsDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerPhysicsDict.cxx:	THyde2TrackerPhysics.h
+			rootcint -f $@ -c $^
+
+libHyde2TrackerModules.so:       Hyde2TrackerModule.o Hyde2TrackerSquare1.o \
+	                         Hyde2TrackerTrapezoid1.o Hyde2TrackerTrapezoid2.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+
+
+# dependances
+Hyde2Tracker.o:	Hyde2Tracker.cxx	Hyde2Tracker.h
+THyde2TrackerData.o:	THyde2TrackerData.cxx	THyde2TrackerData.h
+THyde2TrackerPhysics.o:	THyde2TrackerPhysics.cxx	THyde2TrackerPhysics.h
+Hyde2TrackerModule.o:		Hyde2TrackerModule.cxx	Hyde2TrackerModule.h
+Hyde2TrackerSquare1.o:		Hyde2TrackerSquare1.cxx	Hyde2TrackerSquare1.h
+Hyde2TrackerTrapezoid1.o:	Hyde2TrackerTrapezoid1.cxx	Hyde2TrackerTrapezoid1.h
+Hyde2TrackerTrapezoid2.o:	Hyde2TrackerTrapezoid2.cxx	Hyde2TrackerTrapezoid2.h
+#######################################
+
+############# Clean and More ##########
+clean:
+	@rm -f core *~ *.o *Dict*
+
+distclean:
+	  make clean; rm -f *.so
+
+.SUFFIXES: .$(SrcSuf)
+
+###
+
+.$(SrcSuf).$(ObjSuf):
+	$(CXX) $(CXXFLAGS) $(INCLUDE) -c $<
+
+

NPLib/HYDE2/Makefile_shorter

+include ../Makefile.arch
+ 
+#------------------------------------------------------------------------------
+SHARELIB      =  libHyde2Data.so	libHyde2Physics.so
+all:            $(SHARELIB)
+#------------------------------------------------------------------------------
+############### Detector ##############
+
+## Hyde2 ##
+libHyde2Data.so:	THyde2TrackerData.o THyde2TrackerDataDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerDataDict.cxx:	THyde2TrackerData.h
+			rootcint -f $@ -c $^
+
+libHyde2Physics.so:	Hyde2Tracker.o THyde2TrackerPhysics.o THyde2TrackerPhysicsDict.o
+			$(LD) $(SOFLAGS) $^ $(OutPutOpt) $@
+
+THyde2TrackerPhysicsDict.cxx:	THyde2TrackerPhysics.h
+			rootcint -f $@ -c $^
+
+# dependances
+Hyde2Tracker.o:	Hyde2Tracker.cxx	Hyde2Tracker.h
+THyde2TrackerData.o:	THyde2TrackerData.cxx	THyde2TrackerData.h
+THyde2TrackerPhysics.o:	THyde2TrackerPhysics.cxx	THyde2TrackerPhysics.h
+#######################################
+
+############# Clean and More ##########
+clean:
+	@rm -f core *~ *.o *Dict*
+
+distclean:
+	  make clean; rm -f *.so
+
+.SUFFIXES: .$(SrcSuf)
+
+###
+
+.$(SrcSuf).$(ObjSuf):
+	$(CXX) $(CXXFLAGS) $(INCLUDE) -c $<
+
+

NPLib/HYDE2/README.txt

+In case we want to create just the following shared libraries:
+
+libHyde2Physics.so
+libHyde2Data.so
+
+use the makefile Makefile_shorter. Only the following files are needed:
+
+HydeTracker.(cxx,h)
+THydeTrackerData.(cxx,h)
+THydeTrackerPhysics.(cxx,h)

NPLib/HYDE2/THyde2TrackerData.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 10/06/09                                                 *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription: This class stores the results of the G4 simulation for the    *
+ *             tracker part of the Hyde2 detector.                         *
+ *             The format mimics what was used for the GANIL experiments     *
+ *             after conversion of the raw data with GRU. Ask                *
+ *             N. de Sereville for more informations.                        *
+ *             This class derives from TObject (ROOT) and its aim is to be   *
+ *             stored in the output TTree of the G4 simulation               *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#include <iostream>
+using namespace std;
+
+#include "THyde2TrackerData.h"
+
+ClassImp(THyde2TrackerData)
+
+THyde2TrackerData::THyde2TrackerData()
+{
+   // Default constructor
+
+   Clear();
+}
+
+
+
+THyde2TrackerData::~THyde2TrackerData()
+{
+}
+
+
+
+void THyde2TrackerData::Clear()
+{
+   // DSSD
+   // (X,E)
+   fHYD2Trk_FirstStage_FrontE_DetectorNbr.clear();
+   fHYD2Trk_FirstStage_FrontE_StripNbr.clear()  ;
+   fHYD2Trk_FirstStage_FrontE_Energy.clear()    ;
+   // (X,T)
+   fHYD2Trk_FirstStage_FrontT_DetectorNbr.clear()  ;
+   fHYD2Trk_FirstStage_FrontT_StripNbr.clear()  ;
+   fHYD2Trk_FirstStage_FrontT_Time.clear()      ;
+   // (Y,E)
+   fHYD2Trk_FirstStage_BackE_DetectorNbr.clear()  ;
+   fHYD2Trk_FirstStage_BackE_StripNbr.clear()  ;
+   fHYD2Trk_FirstStage_BackE_Energy.clear()    ;
+   // (Y,T)
+   fHYD2Trk_FirstStage_BackT_DetectorNbr.clear()  ;
+   fHYD2Trk_FirstStage_BackT_StripNbr.clear()  ;
+   fHYD2Trk_FirstStage_BackT_Time.clear()      ;
+
+   // Second Stage
+   // E
+   fHYD2Trk_SecondStage_E_DetectorNbr.clear() ;
+   fHYD2Trk_SecondStage_E_PadNbr.clear()      ;
+   fHYD2Trk_SecondStage_E_Energy.clear()      ;
+   // T
+   fHYD2Trk_SecondStage_T_DetectorNbr.clear() ;
+   fHYD2Trk_SecondStage_T_PadNbr.clear()      ;
+   fHYD2Trk_SecondStage_T_Time.clear()        ;
+
+   // Third Stage
+   // E
+   fHYD2Trk_ThirdStage_E_DetectorNbr.clear()  ;
+   fHYD2Trk_ThirdStage_E_PadNbr.clear()      ;
+   fHYD2Trk_ThirdStage_E_Energy.clear()       ;
+   // T
+   fHYD2Trk_ThirdStage_T_DetectorNbr.clear()  ;
+   fHYD2Trk_ThirdStage_T_PadNbr.clear()      ;
+   fHYD2Trk_ThirdStage_T_Time.clear()         ;
+   
+   // Fourth Stage
+   // E
+   fHYD2Trk_FourthStage_E_DetectorNbr.clear()  ;
+   fHYD2Trk_FourthStage_E_PadNbr.clear()      ;
+   fHYD2Trk_FourthStage_E_Energy.clear()       ;
+   // T
+   fHYD2Trk_FourthStage_T_DetectorNbr.clear()  ;
+   fHYD2Trk_FourthStage_T_PadNbr.clear()      ;
+   fHYD2Trk_FourthStage_T_Time.clear()         ;
+
+   // Fifth Stage
+   // E
+   fHYD2Trk_FifthStage_E_DetectorNbr.clear()  ;
+   fHYD2Trk_FifthStage_E_PadNbr.clear()      ;
+   fHYD2Trk_FifthStage_E_Energy.clear()       ;
+   // T
+   fHYD2Trk_FifthStage_T_DetectorNbr.clear()  ;
+   fHYD2Trk_FifthStage_T_PadNbr.clear()      ;
+   fHYD2Trk_FifthStage_T_Time.clear()         ;
+
+   // Sixth Stage
+   // E
+   fHYD2Trk_SixthStage_E_DetectorNbr.clear()  ;
+   fHYD2Trk_SixthStage_E_PadNbr.clear()      ;
+   fHYD2Trk_SixthStage_E_Energy.clear()       ;
+   // T
+   fHYD2Trk_SixthStage_T_DetectorNbr.clear()  ;
+   fHYD2Trk_SixthStage_T_PadNbr.clear()      ;
+   fHYD2Trk_SixthStage_T_Time.clear()         ;
+
+}
+
+
+
+void THyde2TrackerData::Dump() const
+{
+   cout << "XXXXXXXXXXXXXXXXXXXXXXXX New Event XXXXXXXXXXXXXXXXX" << endl;
+
+   // DSSD
+   // (X,E)
+   cout << "HYD2Trk_FirstStage_FrontE_Mult = " << fHYD2Trk_FirstStage_FrontE_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FirstStage_FrontE_DetectorNbr.size(); i++)
+      cout << "DetNbr: " << fHYD2Trk_FirstStage_FrontE_DetectorNbr[i] << " Strip: " << fHYD2Trk_FirstStage_FrontE_StripNbr[i] << " Energy: " << fHYD2Trk_FirstStage_FrontE_Energy[i] << endl;
+   // (X,T)
+   cout << "HYD2Trk_FirstStage_FrontT_Mult = " << fHYD2Trk_FirstStage_FrontT_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FirstStage_FrontT_DetectorNbr.size(); i++)
+      cout << "DetNbr: " << fHYD2Trk_FirstStage_FrontT_DetectorNbr[i] << " Strip: " << fHYD2Trk_FirstStage_FrontT_StripNbr[i] << " Time: " << fHYD2Trk_FirstStage_FrontT_Time[i] << endl;
+   // (Y,E)
+   cout << "HYD2Trk_FirstStage_BackE_Mult = " << fHYD2Trk_FirstStage_BackE_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FirstStage_BackE_DetectorNbr.size(); i++)
+      cout << "DetNbr: " << fHYD2Trk_FirstStage_BackE_DetectorNbr[i] << " Strip: " << fHYD2Trk_FirstStage_BackE_StripNbr[i] << " Energy: " << fHYD2Trk_FirstStage_BackE_Energy[i] << endl;
+   // (Y,T)
+   cout << "HYD2Trk_FirstStage_BackT_Mult = " << fHYD2Trk_FirstStage_BackT_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FirstStage_BackT_DetectorNbr.size(); i++)
+      cout << "DetNbr: " << fHYD2Trk_FirstStage_BackT_DetectorNbr[i] << " Strip: " << fHYD2Trk_FirstStage_BackT_StripNbr[i] << " Time: " << fHYD2Trk_FirstStage_BackT_Time[i] << endl;
+
+   // Second Stage
+   // Energy
+   cout << "HYD2Trk_SecondStage_E_Mult = " << fHYD2Trk_SecondStage_E_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_SecondStage_E_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_SecondStage_E_DetectorNbr[i] << " Pad: " << fHYD2Trk_SecondStage_E_PadNbr[i] << " Energy: " << fHYD2Trk_SecondStage_E_Energy[i] << endl;
+   // Time
+   cout << "HYD2Trk_SecondStage_T_Mult = " << fHYD2Trk_SecondStage_T_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_SecondStage_T_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_SecondStage_T_DetectorNbr[i] << " Pad: " << fHYD2Trk_SecondStage_T_PadNbr[i] << " Time: " << fHYD2Trk_SecondStage_T_Time[i] << endl;
+
+   // Third Stage
+   // Energy
+   cout << "HYD2Trk_ThirdStage_E_Mult = " << fHYD2Trk_ThirdStage_E_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_ThirdStage_E_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_ThirdStage_E_DetectorNbr[i] << " Pad: " << fHYD2Trk_ThirdStage_E_PadNbr[i] << " Energy: " << fHYD2Trk_ThirdStage_E_Energy[i] << endl;
+   // Time
+   cout << "HYD2Trk_ThirdStage_T_Mult = " << fHYD2Trk_ThirdStage_T_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_ThirdStage_T_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_ThirdStage_T_DetectorNbr[i] << " Pad: " << fHYD2Trk_ThirdStage_T_PadNbr[i] << " Time: " << fHYD2Trk_ThirdStage_T_Time[i] << endl;
+
+   // Fourth Stage
+   // Energy
+   cout << "HYD2Trk_FourthStage_E_Mult = " << fHYD2Trk_FourthStage_E_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FourthStage_E_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_FourthStage_E_DetectorNbr[i] << " Pad: " << fHYD2Trk_FourthStage_E_PadNbr[i] << " Energy: " << fHYD2Trk_FourthStage_E_Energy[i] << endl;
+   // Time
+   cout << "HYD2Trk_FourthStage_T_Mult = " << fHYD2Trk_FourthStage_T_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FourthStage_T_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_FourthStage_T_DetectorNbr[i] << " Pad: " << fHYD2Trk_FourthStage_T_PadNbr[i] << " Time: " << fHYD2Trk_FourthStage_T_Time[i] << endl;
+
+   // Fifth Stage
+   // Energy
+   cout << "HYD2Trk_FifthStage_E_Mult = " << fHYD2Trk_FifthStage_E_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FifthStage_E_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_FifthStage_E_DetectorNbr[i] << " Pad: " << fHYD2Trk_FifthStage_E_PadNbr[i] << " Energy: " << fHYD2Trk_FifthStage_E_Energy[i] << endl;
+   // Time
+   cout << "HYD2Trk_FifthStage_T_Mult = " << fHYD2Trk_FifthStage_T_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_FifthStage_T_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_FifthStage_T_DetectorNbr[i] << " Pad: " << fHYD2Trk_FifthStage_T_PadNbr[i] << " Time: " << fHYD2Trk_FifthStage_T_Time[i] << endl;
+
+   // Sixth Stage
+   // Energy
+   cout << "HYD2Trk_SixthStage_E_Mult = " << fHYD2Trk_SixthStage_E_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_SixthStage_E_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_SixthStage_E_DetectorNbr[i] << " Pad: " << fHYD2Trk_SixthStage_E_PadNbr[i] << " Energy: " << fHYD2Trk_SixthStage_E_Energy[i] << endl;
+   // Time
+   cout << "HYD2Trk_SixthStage_T_Mult = " << fHYD2Trk_SixthStage_T_DetectorNbr.size() << endl;
+   for (UShort_t i = 0; i < fHYD2Trk_SixthStage_T_DetectorNbr.size(); i++)
+      cout << "Det: " << fHYD2Trk_SixthStage_T_DetectorNbr[i] << " Pad: " << fHYD2Trk_SixthStage_T_PadNbr[i] << " Time: " << fHYD2Trk_SixthStage_T_Time[i] << endl;
+
+}

NPLib/HYDE2/THyde2TrackerData.h

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 10/06/09                                                 *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription: This class stores the results of the G4 simulation for the    *
+ *             tracker part of the Hyde2 detector.                         *
+ *             The format mimics what was used for the GANIL experiments     *
+ *             after conversion of the raw data with GRU. Ask                *
+ *             N. de Sereville for more informations.                        *
+ *             This class derives from TObject (ROOT) and its aim is to be   *
+ *             stored in the output TTree of the G4 simulation               *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#ifndef __HYDE2TRACKERDATA__
+#define __HYDE2TRACKERDATA__
+
+#include <vector>
+#include "TObject.h"
+
+using namespace std ;
+
+class THyde2TrackerData : public TObject
+{
+protected:
+   // First Stage
+   // Double Sided Silicon Detector
+   // Front
+   // Energy
+   vector<UShort_t>  fHYD2Trk_FirstStage_FrontE_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FirstStage_FrontE_StripNbr;
+   vector<Double_t>  fHYD2Trk_FirstStage_FrontE_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_FirstStage_FrontT_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FirstStage_FrontT_StripNbr;
+   vector<Double_t>  fHYD2Trk_FirstStage_FrontT_Time;
+   // Back
+   // Energy
+   vector<UShort_t>  fHYD2Trk_FirstStage_BackE_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FirstStage_BackE_StripNbr;
+   vector<Double_t>  fHYD2Trk_FirstStage_BackE_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_FirstStage_BackT_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FirstStage_BackT_StripNbr;
+   vector<Double_t>  fHYD2Trk_FirstStage_BackT_Time;
+
+   // Second Stage
+   // Energy
+   vector<UShort_t>  fHYD2Trk_SecondStage_E_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_SecondStage_E_PadNbr;
+   vector<Double_t>  fHYD2Trk_SecondStage_E_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_SecondStage_T_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_SecondStage_T_PadNbr;
+   vector<Double_t>  fHYD2Trk_SecondStage_T_Time;
+
+   // Third Stage
+   // Energy
+   vector<UShort_t>  fHYD2Trk_ThirdStage_E_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_ThirdStage_E_PadNbr;
+   vector<Double_t>  fHYD2Trk_ThirdStage_E_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_ThirdStage_T_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_ThirdStage_T_PadNbr;
+   vector<Double_t>  fHYD2Trk_ThirdStage_T_Time;
+
+   // Fourth Stage
+   // Energy
+   vector<UShort_t>  fHYD2Trk_FourthStage_E_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FourthStage_E_PadNbr;
+   vector<Double_t>  fHYD2Trk_FourthStage_E_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_FourthStage_T_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FourthStage_T_PadNbr;
+   vector<Double_t>  fHYD2Trk_FourthStage_T_Time;
+
+   // Fifth Stage
+   // Energy
+   vector<UShort_t>  fHYD2Trk_FifthStage_E_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FifthStage_E_PadNbr;
+   vector<Double_t>  fHYD2Trk_FifthStage_E_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_FifthStage_T_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_FifthStage_T_PadNbr;
+   vector<Double_t>  fHYD2Trk_FifthStage_T_Time;
+
+   // Sixth Stage
+   // Energy
+   vector<UShort_t>  fHYD2Trk_SixthStage_E_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_SixthStage_E_PadNbr;
+   vector<Double_t>  fHYD2Trk_SixthStage_E_Energy;
+   // Time
+   vector<UShort_t>  fHYD2Trk_SixthStage_T_DetectorNbr;
+   vector<UShort_t>  fHYD2Trk_SixthStage_T_PadNbr;
+   vector<Double_t>  fHYD2Trk_SixthStage_T_Time;
+
+public:
+   THyde2TrackerData();
+   virtual ~THyde2TrackerData();
+
+   void  Clear();
+   void  Clear(const Option_t*) {};
+   void  Dump() const;
+
+   /////////////////////           SETTERS           ////////////////////////
+   // DSSD
+   // (Front, E)
+   void  SetHYD2TrkFirstStageFrontEDetectorNbr(UShort_t DetNbr) {
+      fHYD2Trk_FirstStage_FrontE_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFirstStageFrontEStripNbr(UShort_t StripNbr)  {
+      fHYD2Trk_FirstStage_FrontE_StripNbr.push_back(StripNbr);
+   }
+   void  SetHYD2TrkFirstStageFrontEEnergy(Double_t Energy)      {
+      fHYD2Trk_FirstStage_FrontE_Energy.push_back(Energy);
+   }
+   // (Front, T)
+   void  SetHYD2TrkFirstStageFrontTDetectorNbr(UShort_t DetNbr) {
+      fHYD2Trk_FirstStage_FrontT_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFirstStageFrontTStripNbr(UShort_t StripNbr)  {
+      fHYD2Trk_FirstStage_FrontT_StripNbr.push_back(StripNbr);
+   }
+   void  SetHYD2TrkFirstStageFrontTTime(Double_t Time)          {
+      fHYD2Trk_FirstStage_FrontT_Time.push_back(Time);
+   }
+
+   // (Back, E)
+   void  SetHYD2TrkFirstStageBackEDetectorNbr(UShort_t DetNbr) {
+      fHYD2Trk_FirstStage_BackE_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFirstStageBackEStripNbr(UShort_t StripNbr)  {
+      fHYD2Trk_FirstStage_BackE_StripNbr.push_back(StripNbr);
+   }
+   void  SetHYD2TrkFirstStageBackEEnergy(Double_t Energy)      {
+      fHYD2Trk_FirstStage_BackE_Energy.push_back(Energy);
+   }
+   // (Back, T)
+   void  SetHYD2TrkFirstStageBackTDetectorNbr(UShort_t DetNbr) {
+      fHYD2Trk_FirstStage_BackT_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFirstStageBackTStripNbr(UShort_t StripNbr)  {
+      fHYD2Trk_FirstStage_BackT_StripNbr.push_back(StripNbr);
+   }
+   void  SetHYD2TrkFirstStageBackTTime(Double_t Time)          {
+      fHYD2Trk_FirstStage_BackT_Time.push_back(Time);
+   }
+
+   // Second Stage
+   // (E)
+   void  SetHYD2TrkSecondStageEDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_SecondStage_E_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkSecondStageEPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_SecondStage_E_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkSecondStageEEnergy(Double_t Energy)        {
+      fHYD2Trk_SecondStage_E_Energy.push_back(Energy);
+   }
+   // (T)
+   void  SetHYD2TrkSecondStageTDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_SecondStage_T_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkSecondStageTPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_SecondStage_T_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkSecondStageTTime(Double_t Time)            {
+      fHYD2Trk_SecondStage_T_Time.push_back(Time);
+   }
+
+   // Third Stage
+   // (E)
+   void  SetHYD2TrkThirdStageEDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_ThirdStage_E_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkThirdStageEPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_ThirdStage_E_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkThirdStageEEnergy(Double_t Energy)        {
+      fHYD2Trk_ThirdStage_E_Energy.push_back(Energy);
+   }
+   // (T)
+   void  SetHYD2TrkThirdStageTDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_ThirdStage_T_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkThirdStageTPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_ThirdStage_T_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkThirdStageTTime(Double_t Time)            {
+      fHYD2Trk_ThirdStage_T_Time.push_back(Time);
+   }
+
+   // Fourth Stage
+   // (E)
+   void  SetHYD2TrkFourthStageEDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_FourthStage_E_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFourthStageEPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_FourthStage_E_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkFourthStageEEnergy(Double_t Energy)        {
+      fHYD2Trk_FourthStage_E_Energy.push_back(Energy);
+   }
+   // (T)
+   void  SetHYD2TrkFourthStageTDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_FourthStage_T_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFourthStageTPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_FourthStage_T_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkFourthStageTTime(Double_t Time)            {
+      fHYD2Trk_FourthStage_T_Time.push_back(Time);
+   }
+
+   // Fifth Stage
+   // (E)
+   void  SetHYD2TrkFifthStageEDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_FifthStage_E_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFifthStageEPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_FifthStage_E_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkFifthStageEEnergy(Double_t Energy)        {
+      fHYD2Trk_FifthStage_E_Energy.push_back(Energy);
+   }
+   // (T)
+   void  SetHYD2TrkFifthStageTDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_FifthStage_T_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkFifthStageTPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_FifthStage_T_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkFifthStageTTime(Double_t Time)            {
+      fHYD2Trk_FifthStage_T_Time.push_back(Time);
+   }
+   
+   // Sixth Stage
+   // (E)
+   void  SetHYD2TrkSixthStageEDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_SixthStage_E_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkSixthStageEPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_SixthStage_E_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkSixthStageEEnergy(Double_t Energy)        {
+      fHYD2Trk_SixthStage_E_Energy.push_back(Energy);
+   }
+   // (T)
+   void  SetHYD2TrkSixthStageTDetectorNbr(UShort_t DetNbr)   {
+      fHYD2Trk_SixthStage_T_DetectorNbr.push_back(DetNbr);
+   }
+   void  SetHYD2TrkSixthStageTPadNbr(UShort_t PadNbr)        {
+      fHYD2Trk_SixthStage_T_PadNbr.push_back(PadNbr);
+   }
+   void  SetHYD2TrkSixthStageTTime(Double_t Time)            {
+      fHYD2Trk_SixthStage_T_Time.push_back(Time);
+   }
+
+
+   /////////////////////           GETTERS           ////////////////////////
+   // DSSD
+   // (Front, E)
+   UShort_t GetHYD2TrkFirstStageFrontEMult()               {
+      return fHYD2Trk_FirstStage_FrontE_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFirstStageFrontEDetectorNbr(Int_t i) {
+      return fHYD2Trk_FirstStage_FrontE_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFirstStageFrontEStripNbr(Int_t i)    {
+      return fHYD2Trk_FirstStage_FrontE_StripNbr.at(i);
+   }
+   Double_t GetHYD2TrkFirstStageFrontEEnergy(Int_t i)      {
+      return fHYD2Trk_FirstStage_FrontE_Energy.at(i);
+   }
+   // (Front, T)
+   UShort_t GetHYD2TrkFirstStageFrontTMult()               {
+      return fHYD2Trk_FirstStage_FrontT_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFirstStageFrontTDetectorNbr(Int_t i) {
+      return fHYD2Trk_FirstStage_FrontT_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFirstStageFrontTStripNbr(Int_t i)    {
+      return fHYD2Trk_FirstStage_FrontT_StripNbr.at(i);
+   }
+   Double_t GetHYD2TrkFirstStageFrontTTime(Int_t i)      {
+      return fHYD2Trk_FirstStage_FrontT_Time.at(i);
+   }
+   // (Back, E)
+   UShort_t GetHYD2TrkFirstStageBackEMult()               {
+      return fHYD2Trk_FirstStage_BackE_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFirstStageBackEDetectorNbr(Int_t i) {
+      return fHYD2Trk_FirstStage_BackE_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFirstStageBackEStripNbr(Int_t i)    {
+      return fHYD2Trk_FirstStage_BackE_StripNbr.at(i);
+   }
+   Double_t GetHYD2TrkFirstStageBackEEnergy(Int_t i)      {
+      return fHYD2Trk_FirstStage_BackE_Energy.at(i);
+   }
+   // (Back, T)
+   UShort_t GetHYD2TrkFirstStageBackTMult()               {
+      return fHYD2Trk_FirstStage_BackT_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFirstStageBackTDetectorNbr(Int_t i) {
+      return fHYD2Trk_FirstStage_BackT_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFirstStageBackTStripNbr(Int_t i)    {
+      return fHYD2Trk_FirstStage_BackT_StripNbr.at(i);
+   }
+   Double_t GetHYD2TrkFirstStageBackTTime(Int_t i)      {
+      return fHYD2Trk_FirstStage_BackT_Time.at(i);
+   }
+
+   // Second Stage
+   // (E)
+   UShort_t GetHYD2TrkSecondStageEMult()           {
+      return fHYD2Trk_SecondStage_E_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkSecondStageEDetectorNbr(Int_t i)  {
+      return fHYD2Trk_SecondStage_E_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkSecondStageEPadNbr(Int_t i)       {
+      return fHYD2Trk_SecondStage_E_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkSecondStageEEnergy(Int_t i)       {
+      return fHYD2Trk_SecondStage_E_Energy.at(i);
+   }
+   // (T)
+   UShort_t GetHYD2TrkSecondStageTMult()           {
+      return fHYD2Trk_SecondStage_T_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkSecondStageTDetectorNbr(Int_t i)  {
+      return fHYD2Trk_SecondStage_T_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkSecondStageTPadNbr(Int_t i)       {
+      return fHYD2Trk_SecondStage_T_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkSecondStageTTime(Int_t i)         {
+      return fHYD2Trk_SecondStage_T_Time.at(i);
+   }
+
+   // Third Stage
+   // (E)
+   UShort_t GetHYD2TrkThirdStageEMult()           {
+      return fHYD2Trk_ThirdStage_E_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkThirdStageEDetectorNbr(Int_t i)  {
+      return fHYD2Trk_ThirdStage_E_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkThirdStageEPadNbr(Int_t i)       {
+      return fHYD2Trk_ThirdStage_E_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkThirdStageEEnergy(Int_t i)       {
+      return fHYD2Trk_ThirdStage_E_Energy.at(i);
+   }
+   // (T)
+   UShort_t GetHYD2TrkThirdStageTMult()           {
+      return fHYD2Trk_ThirdStage_T_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkThirdStageTDetectorNbr(Int_t i)  {
+      return fHYD2Trk_ThirdStage_T_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkThirdStageTPadNbr(Int_t i)       {
+      return fHYD2Trk_ThirdStage_T_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkThirdStageTTime(Int_t i)         {
+      return fHYD2Trk_ThirdStage_T_Time.at(i);
+   }
+
+   // Fourth Stage
+   // (E)
+   UShort_t GetHYD2TrkFourthStageEMult()           {
+      return fHYD2Trk_FourthStage_E_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFourthStageEDetectorNbr(Int_t i)  {
+      return fHYD2Trk_FourthStage_E_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFourthStageEPadNbr(Int_t i)       {
+      return fHYD2Trk_FourthStage_E_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkFourthStageEEnergy(Int_t i)       {
+      return fHYD2Trk_FourthStage_E_Energy.at(i);
+   }
+   // (T)
+   UShort_t GetHYD2TrkFourthStageTMult()           {
+      return fHYD2Trk_FourthStage_T_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFourthStageTDetectorNbr(Int_t i)  {
+      return fHYD2Trk_FourthStage_T_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFourthStageTPadNbr(Int_t i)       {
+      return fHYD2Trk_FourthStage_T_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkFourthStageTTime(Int_t i)         {
+      return fHYD2Trk_FourthStage_T_Time.at(i);
+   }
+
+   // Fifth Stage
+   // (E)
+   UShort_t GetHYD2TrkFifthStageEMult()           {
+      return fHYD2Trk_FifthStage_E_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFifthStageEDetectorNbr(Int_t i)  {
+      return fHYD2Trk_FifthStage_E_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFifthStageEPadNbr(Int_t i)       {
+      return fHYD2Trk_FifthStage_E_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkFifthStageEEnergy(Int_t i)       {
+      return fHYD2Trk_FifthStage_E_Energy.at(i);
+   }
+   // (T)
+   UShort_t GetHYD2TrkFifthStageTMult()           {
+      return fHYD2Trk_FifthStage_T_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkFifthStageTDetectorNbr(Int_t i)  {
+      return fHYD2Trk_FifthStage_T_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkFifthStageTPadNbr(Int_t i)       {
+      return fHYD2Trk_FifthStage_T_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkFifthStageTTime(Int_t i)         {
+      return fHYD2Trk_FifthStage_T_Time.at(i);
+   }
+
+   // Sixth Stage
+   // (E)
+   UShort_t GetHYD2TrkSixthStageEMult()           {
+      return fHYD2Trk_SixthStage_E_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkSixthStageEDetectorNbr(Int_t i)  {
+      return fHYD2Trk_SixthStage_E_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkSixthStageEPadNbr(Int_t i)       {
+      return fHYD2Trk_SixthStage_E_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkSixthStageEEnergy(Int_t i)       {
+      return fHYD2Trk_SixthStage_E_Energy.at(i);
+   }
+   // (T)
+   UShort_t GetHYD2TrkSixthStageTMult()           {
+      return fHYD2Trk_SixthStage_T_DetectorNbr.size();
+   }
+   UShort_t GetHYD2TrkSixthStageTDetectorNbr(Int_t i)  {
+      return fHYD2Trk_SixthStage_T_DetectorNbr.at(i);
+   }
+   UShort_t GetHYD2TrkSixthStageTPadNbr(Int_t i)       {
+      return fHYD2Trk_SixthStage_T_PadNbr.at(i);
+   }
+   Double_t GetHYD2TrkSixthStageTTime(Int_t i)         {
+      return fHYD2Trk_SixthStage_T_Time.at(i);
+   }
+
+
+   ClassDef(THyde2TrackerData, 1) // Hyde2TrackerData structure
+};
+
+#endif

NPLib/HYDE2/THyde2TrackerPhysics.cxx

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 31/08/09                                                 *
+ * Last update    :                                                          *
+ *---------------------------------------------------------------------------*
+ * Decription: This class stores the physical results after NPAnalysis is run*
+ *             for the tracker part of the Hyde2 detector.                 *
+ *             This class derives from TObject (ROOT) and its aim is to be   *
+ *             stored in the output TTree of NPAnalysis.                     *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#include "THyde2TrackerPhysics.h"
+
+
+ClassImp(THyde2TrackerPhysics)
+
+
+THyde2TrackerPhysics::THyde2TrackerPhysics() 
+{
+}
+
+
+
+THyde2TrackerPhysics::~THyde2TrackerPhysics()
+{
+   Clear();
+}
+
+
+
+void THyde2TrackerPhysics::Clear()
+{
+   // General members
+   fEventType.clear();
+   fModuleNumber.clear();
+   fTotalEnergy.clear();
+
+   // First stage
+   fFirstStage_Energy.clear();
+   fFirstStage_Time.clear();
+   fFirstStage_FrontPosition.clear();
+   fFirstStage_BackPosition.clear();
+
+   // Second stage
+   fSecondStage_Energy.clear();
+   fSecondStage_Time.clear();
+   fSecondStage_Position.clear();
+
+   // Third stage
+   fThirdStage_Energy.clear();
+   fThirdStage_Time.clear();
+   fThirdStage_Position.clear();
+
+   // Fourth stage
+   fFourthStage_Energy.clear();
+   fFourthStage_Time.clear();
+   fFourthStage_Position.clear();
+}

NPLib/HYDE2/THyde2TrackerPhysics.h

+/*****************************************************************************
+ * Copyright (C) 2009-2010   this file is part of the NPTool Project         *
+ *                                                                           *
+ * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
+ * For the list of contributors see $NPTOOL/Licence/Contributors             *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Original Author: N. de Sereville  contact address: deserevi@ipno.in2p3.fr *
+ *                                                                           *
+ * Creation Date  : 31/08/09                                                 *
+ * Last update    : 08/10/10                                                 *
+ *---------------------------------------------------------------------------*
+ * Decription: This class stores the physical results after NPAnalysis is run*
+ *             for the tracker part of the Hyde2 detector.                 *
+ *             This class derives from TObject (ROOT) and its aim is to be   *
+ *             stored in the output TTree of NPAnalysis.                     *
+ *---------------------------------------------------------------------------*
+ * Comment:                                                                  *
+ *    + 08/10/10: Change private member names and add setters and getters    *
+ *                methods. BuildPhysicalEvent() method is moved to the       *
+ *                THyde2Tracker*** classes (N. de Sereville)               *
+ *                                                                           *
+ *                                                                           *
+ *****************************************************************************/
+
+#ifndef THYDE2TRACKERPHYSICS_H
+#define THYDE2TRACKERPHYSICS_H
+
+#include "THyde2TrackerData.h"
+
+// ROOT
+#include "TObject.h"
+
+// C++
+#include <vector>
+
+using namespace std ;
+
+
+class THyde2TrackerPhysics : public TObject
+{
+public:
+   THyde2TrackerPhysics();
+   ~THyde2TrackerPhysics();
+
+public: 
+   void Clear();   
+   void Clear(const Option_t*) {};
+
+
+private:
+   vector<Int_t>   fEventType;
+   vector<Int_t>   fModuleNumber;
+
+   // First stage
+   vector<Double_t>  fFirstStage_Energy;
+   vector<Double_t>  fFirstStage_Time;
+   vector<Int_t>     fFirstStage_FrontPosition;
+   vector<Int_t>     fFirstStage_BackPosition;
+
+   // Second stage
+   vector<Double_t>  fSecondStage_Energy;
+   vector<Double_t>  fSecondStage_Time;
+   vector<Int_t>     fSecondStage_Position;
+
+   // Third stage
+   vector<Double_t>  fThirdStage_Energy;
+   vector<Double_t>  fThirdStage_Time;
+   vector<Int_t>     fThirdStage_Position;
+
+   // Fourth stage
+   vector<Double_t>  fFourthStage_Energy;
+   vector<Double_t>  fFourthStage_Time;
+   vector<Int_t>     fFourthStage_Position;
+
+   // Fifth stage
+   vector<Double_t>  fFifthStage_Energy;
+   vector<Double_t>  fFifthStage_Time;
+   vector<Int_t>     fFifthStage_Position;
+
+   // Sixth stage
+   vector<Double_t>  fSixthStage_Energy;
+   vector<Double_t>  fSixthStage_Time;
+   vector<Int_t>     fSixthStage_Position;
+
+   vector<Double_t>  fTotalEnergy;
+
+
+public:
+   /////////////////////////////////////
+   //            SETTERS              //
+   /////////////////////////////////////
+   // General
+   void SetEventType(Int_t evtType)      {fEventType.push_back(evtType);}
+   void SetModuleNumber(Int_t moduleNbr)   {fModuleNumber.push_back(moduleNbr);}
+   void SetTotalEnergy(Double_t ener)      {fTotalEnergy.push_back(ener);}
+
+   // First stage
+   void SetFirstStageEnergy(Double_t ener)   {fFirstStage_Energy.push_back(ener);}
+   void SetFirstStageTime(Double_t time)   {fFirstStage_Time.push_back(time);}
+   void SetFirstStageFrontPosition(Int_t x)   {fFirstStage_FrontPosition.push_back(x);}
+   void SetFirstStageBackPosition(Int_t y)   {fFirstStage_BackPosition.push_back(y);}
+
+   // Second stage
+   void SetSecondStageEnergy(Double_t ener)   {fSecondStage_Energy.push_back(ener);}
+   void SetSecondStageTime(Double_t time)   {fSecondStage_Time.push_back(time);}
+   void SetSecondStagePosition(Int_t pos)   {fSecondStage_Position.push_back(pos);}
+
+   // Third stage
+   void SetThirdStageEnergy(Double_t ener)   {fThirdStage_Energy.push_back(ener);}
+   void SetThirdStageTime(Double_t time)   {fThirdStage_Time.push_back(time);}
+   void SetThirdStagePosition(Int_t pos)   {fThirdStage_Position.push_back(pos);}
+
+   // Fourth stage
+   void SetFourthStageEnergy(Double_t ener)   {fFourthStage_Energy.push_back(ener);}
+   void SetFourthStageTime(Double_t time)   {fFourthStage_Time.push_back(time);}
+   void SetFourthStagePosition(Int_t pos)   {fFourthStage_Position.push_back(pos);}
+
+   // Fifth stage
+   void SetFifthStageEnergy(Double_t ener)   {fFifthStage_Energy.push_back(ener);}
+   void SetFifthStageTime(Double_t time)   {fFifthStage_Time.push_back(time);}
+   void SetFifthStagePosition(Int_t pos)   {fFifthStage_Position.push_back(pos);}
+
+   // Sixth stage
+   void SetSixthStageEnergy(Double_t ener)   {fSixthStage_Energy.push_back(ener);}
+   void SetSixthStageTime(Double_t time)   {fSixthStage_Time.push_back(time);}
+   void SetSixthStagePosition(Int_t pos)   {fSixthStage_Position.push_back(pos);}
+
+   /////////////////////////////////////
+   //            GETTERS              //
+   /////////////////////////////////////
+   // General
+   Int_t   GetEventMultiplicity()         {return fTotalEnergy.size();}
+   Int_t   GetEventType(Int_t i)         {return fEventType.at(i);}
+   Int_t   GetModuleNumber(Int_t i)      {return fModuleNumber.at(i);}
+   Double_t   GetTotalEnergy(Int_t i)         {return fTotalEnergy.at(i);}
+
+   // First stage
+   Double_t   GetFirstStageEnergy(Int_t i)      {return fFirstStage_Energy.at(i);}
+   Double_t   GetFirstStageTime(Int_t i)      {return fFirstStage_Time.at(i);}
+   Int_t   GetFirstStageFrontPosition(Int_t i)   {return fFirstStage_FrontPosition.at(i);}
+   Int_t   GetFirstStageBackPosition(Int_t i)   {return fFirstStage_BackPosition.at(i);}
+
+   // Second stage
+   Double_t   GetSecondStageEnergy(Int_t i)      {return fSecondStage_Energy.at(i);}
+   Double_t   GetSecondStageTime(Int_t i)      {return fSecondStage_Time.at(i);}
+   Int_t   GetSecondStagePosition(Int_t i)      {return fSecondStage_Position.at(i);}
+
+   // Third stage
+   Double_t   GetThirdStageEnergy(Int_t i)      {return fThirdStage_Energy.at(i);}
+   Double_t   GetThirdStageTime(Int_t i)      {return fThirdStage_Time.at(i);}
+   Int_t   GetThirdStagePosition(Int_t i)      {return fThirdStage_Position.at(i);}
+
+   // Fourth stage
+   Double_t   GetFourthStageEnergy(Int_t i)      {return fFourthStage_Energy.at(i);}
+   Double_t   GetFourthStageTime(Int_t i)      {return fFourthStage_Time.at(i);}
+   Int_t   GetFourthStagePosition(Int_t i)      {return fFourthStage_Position.at(i);}
+
+   // Fifth stage
+   Double_t   GetFifthStageEnergy(Int_t i)      {return fFifthStage_Energy.at(i);}
+   Double_t   GetFifthStageTime(Int_t i)      {return fFifthStage_Time.at(i);}
+   Int_t   GetFifthStagePosition(Int_t i)      {return fFifthStage_Position.at(i);}
+
+   // Sixth stage
+   Double_t   GetSixthStageEnergy(Int_t i)      {return fSixthStage_Energy.at(i);}
+   Double_t   GetSixthStageTime(Int_t i)      {return fSixthStage_Time.at(i);}
+   Int_t   GetSixthStagePosition(Int_t i)      {return fSixthStage_Position.at(i);}
+
+   ClassDef(THyde2TrackerPhysics,1)  // THyde2TrackerPhysics structure
+};
+
+#endif