diff --git a/NPLib/HYDE2/Hyde2Tracker.cxx b/NPLib/HYDE2/Hyde2Tracker.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..ee29c1f1f1fb1d328a13e990ffcbb48812050983
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2Tracker.cxx
@@ -0,0 +1,284 @@
+/*****************************************************************************
+ * 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;
+}
diff --git a/NPLib/HYDE2/Hyde2Tracker.h b/NPLib/HYDE2/Hyde2Tracker.h
new file mode 100644
index 0000000000000000000000000000000000000000..36093b0c92dab10455d5a9bfac8364aeb33254e4
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2Tracker.h
@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * 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
diff --git a/NPLib/HYDE2/Hyde2TrackerModule.cxx b/NPLib/HYDE2/Hyde2TrackerModule.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e2334f9337e836a3f28b0d92f6ff71212ea3ddb4
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerModule.cxx
@@ -0,0 +1,23 @@
+#include "Hyde2TrackerModule.h"
+
+
+
+Hyde2TrackerModule::Hyde2TrackerModule()
+{
+ InitializeIndex();
+}
+
+
+
+Hyde2TrackerModule::~Hyde2TrackerModule()
+{
+}
+
+
+
+void Hyde2TrackerModule::InitializeIndex()
+{
+ m_index["Square1"] = 2000;
+ m_index["Trapezoid1"] = 2200;
+ m_index["Trapezoid2"] = 2300;
+}
diff --git a/NPLib/HYDE2/Hyde2TrackerModule.h b/NPLib/HYDE2/Hyde2TrackerModule.h
new file mode 100644
index 0000000000000000000000000000000000000000..69c9659836f19f1fc32532f9bb13021e7f08eb45
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerModule.h
@@ -0,0 +1,48 @@
+#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
diff --git a/NPLib/HYDE2/Hyde2TrackerSquare1.cxx b/NPLib/HYDE2/Hyde2TrackerSquare1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..705b5b8d140a6cddc0f09879c02673259fce8bb3
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerSquare1.cxx
@@ -0,0 +1,559 @@
+#include "Hyde2TrackerSquare1.h"
+
+// C++ headers
+#include <limits>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+#include <stdlib.h>
+
+// Hyde2
+#include "THyde2TrackerPhysics.h"
+
+
+Hyde2TrackerSquare1::Hyde2TrackerSquare1(map<int, Hyde2TrackerModule*> &Module,
+ THyde2TrackerPhysics* &EventPhysics)
+ : m_ModuleTest(Module),
+ m_EventPhysics(EventPhysics),
+ m_EventData(0),
+ m_PreTreatData(new THyde2TrackerData),
+ m_NumberOfModule(0),
+ m_FirstStageFace(87.42), // mm
+ m_NumberOfStrips(220)
+{
+ m_StripPitch = m_FirstStageFace / (double)m_NumberOfStrips;
+}
+
+
+
+Hyde2TrackerSquare1::~Hyde2TrackerSquare1()
+{
+ delete m_PreTreatData;
+}
+
+
+
+void Hyde2TrackerSquare1::ReadConfiguration(string Path)
+{
+ ifstream ConfigFile;
+ ConfigFile.open(Path.c_str());
+ string LineBuffer;
+ string DataBuffer;
+
+ // A:X1_Y1 --> X:1 Y:1
+ // B:X128_Y1 --> X:128 Y:1
+ // C:X1_Y128 --> X:1 Y:128
+ // D:X128_Y128 --> X:128 Y:128
+
+ double Ax, Bx, Cx, Dx, Ay, By, Cy, Dy, Az, Bz, Cz, Dz;
+ TVector3 A, B, C, D;
+ double Theta = 0, Phi = 0, R = 0, beta_u = 0 , beta_v = 0 , beta_w = 0;
+
+ bool check_A = false;
+ bool check_C = false;
+ bool check_B = false;
+ bool check_D = false;
+
+ bool check_Theta = false;
+ bool check_Phi = false;
+ bool check_R = false;
+ bool check_beta = false;
+
+ bool ReadingStatus = false;
+
+ while (!ConfigFile.eof()) {
+ getline(ConfigFile, LineBuffer);
+
+ // If line is a Hyde2XXX bloc, reading toggle to true
+ // and toggle to true flags indicating which shape is treated.
+ if (LineBuffer.compare(0, 9, "HYD2Square1") == 0) {
+ cout << "///////////////////////" << endl;
+ cout << "Square1 module found:" << endl;
+ ReadingStatus = true;
+ }
+
+ // Reading Block
+ while (ReadingStatus) {
+ ConfigFile >> DataBuffer ;
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {
+ ConfigFile.ignore(std::numeric_limits<std::streamsize>::max(), '\n' );
+ }
+ // Finding another telescope (safety), toggle out
+ else if (DataBuffer.compare(0, 11, "HYD2Square1") == 0) {
+ cout << "WARNING: Another Module is find before standard sequence of Token, Error may occured in Telecope definition" << endl;
+ ReadingStatus = false;
+ }
+
+ // Position method
+ else if (DataBuffer.compare(0, 6, "X1_Y1=") == 0) {
+ check_A = true;
+ ConfigFile >> DataBuffer;
+ Ax = atof(DataBuffer.c_str());
+ Ax = Ax;
+ ConfigFile >> DataBuffer;
+ Ay = atof(DataBuffer.c_str());
+ Ay = Ay;
+ ConfigFile >> DataBuffer;
+ Az = atof(DataBuffer.c_str());
+ Az = Az;
+
+ A = TVector3(Ax, Ay, Az);
+ cout << "X1 Y1 corner position : (" << A.X() << ";" << A.Y() << ";" << A.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X128_Y1=") == 0) {
+ check_B = true;
+ ConfigFile >> DataBuffer;
+ Bx = atof(DataBuffer.c_str());
+ Bx = Bx;
+ ConfigFile >> DataBuffer;
+ By = atof(DataBuffer.c_str());
+ By = By;
+ ConfigFile >> DataBuffer;
+ Bz = atof(DataBuffer.c_str());
+ Bz = Bz;
+
+ B = TVector3(Bx, By, Bz);
+ cout << "X128 Y1 corner position : (" << B.X() << ";" << B.Y() << ";" << B.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X1_Y128=") == 0) {
+ check_C = true;
+ ConfigFile >> DataBuffer;
+ Cx = atof(DataBuffer.c_str());
+ Cx = Cx;
+ ConfigFile >> DataBuffer;
+ Cy = atof(DataBuffer.c_str());
+ Cy = Cy;
+ ConfigFile >> DataBuffer;
+ Cz = atof(DataBuffer.c_str());
+ Cz = Cz;
+
+ C = TVector3(Cx, Cy, Cz);
+ cout << "X1 Y128 corner position : (" << C.X() << ";" << C.Y() << ";" << C.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 10, "X128_Y128=") == 0) {
+ check_D = true;
+ ConfigFile >> DataBuffer;
+ Dx = atof(DataBuffer.c_str());
+ Dx = Dx;
+ ConfigFile >> DataBuffer;
+ Dy = atof(DataBuffer.c_str());
+ Dy = Dy;
+ ConfigFile >> DataBuffer;
+ Dz = atof(DataBuffer.c_str());
+ Dz = Dz;
+
+ D = TVector3(Dx, Dy, Dz);
+ cout << "X128 Y128 corner position : (" << D.X() << ";" << D.Y() << ";" << D.Z() << ")" << endl;
+ } // End Position Method
+
+ // Angle method
+ else if (DataBuffer.compare(0, 6, "THETA=") == 0) {
+ check_Theta = true;
+ ConfigFile >> DataBuffer;
+ Theta = atof(DataBuffer.c_str());
+ Theta = Theta;
+ cout << "Theta: " << Theta << endl;
+ }
+ else if (DataBuffer.compare(0, 4, "PHI=") == 0) {
+ check_Phi = true;
+ ConfigFile >> DataBuffer;
+ Phi = atof(DataBuffer.c_str());
+ Phi = Phi;
+ cout << "Phi: " << Phi << endl;
+ }
+ else if (DataBuffer.compare(0, 2, "R=") == 0) {
+ check_R = true;
+ ConfigFile >> DataBuffer;
+ R = atof(DataBuffer.c_str());
+ R = R;
+ cout << "R: " << R << endl;
+ }
+ else if (DataBuffer.compare(0, 5, "BETA=") == 0) {
+ check_beta = true;
+ ConfigFile >> DataBuffer;
+ beta_u = atof(DataBuffer.c_str());
+ beta_u = beta_u;
+ ConfigFile >> DataBuffer;
+ beta_v = atof(DataBuffer.c_str());
+ beta_v = beta_v;
+ ConfigFile >> DataBuffer;
+ beta_w = atof(DataBuffer.c_str());
+ beta_w = beta_w;
+ cout << "Beta: " << beta_u << " " << beta_v << " " << beta_w << endl;
+ }
+
+ /////////////////////////////////////////////////
+ // If All necessary information there, toggle out
+ if ( (check_A && check_B && check_C && check_D) || (check_Theta && check_Phi && check_R && check_beta) ) {
+ ReadingStatus = false;
+
+ // Add The previously define telescope
+ // With position method
+ if ( check_A && check_B && check_C && check_D ) {
+ AddModule(A, B, C, D);
+ m_ModuleTest[m_index["Square1"] + m_NumberOfModule] = this;
+ }
+
+ // with angle method
+ else if ( check_Theta && check_Phi && check_R && check_beta ) {
+ AddModule(Theta, Phi, R, beta_u, beta_v, beta_w);
+ m_ModuleTest[m_index["Square1"] + m_NumberOfModule] = this;
+ }
+
+ // reset boolean flag for point positioning
+ check_A = false;
+ check_B = false;
+ check_C = false;
+ check_D = false;
+ // reset boolean flag for angle positioning
+ check_Theta = false;
+ check_Phi = false;
+ check_R = false;
+ check_beta = false;
+
+ } // end test for adding a module
+ } // end while for reading block
+ } // end while for reading file
+
+ cout << endl << "/////////////////////////////" << endl<<endl;
+}
+
+
+
+void Hyde2TrackerSquare1::PreTreat()
+{
+}
+
+
+
+void Hyde2TrackerSquare1::BuildPhysicalEvent()
+{
+ // Check flags
+// bool Check_FirstStage = false;
+ bool Check_SecondStage = false;
+ bool Check_ThirdStage = false;
+ bool Check_FourthStage = false;
+ bool Check_FifthStage = false;
+ bool Check_SixthStage = false;
+
+ // Thresholds
+/*
+ double FirstStage_Front_E_Threshold = 0; double FirstStage_Front_T_Threshold = 0;
+ double FirstStage_Back_E_Threshold = 0; double FirstStage_Back_T_Threshold = 0;
+ double SecondStage_E_Threshold = 0; double SecondStage_T_Threshold = 0;
+ double ThirdStage_E_Threshold = 0; double ThirdStage_T_Threshold = 0;
+*/
+ // calculate multipicity in the first stage
+ int multXE = m_EventData->GetHYD2TrkFirstStageFrontEMult();
+ int multYE = m_EventData->GetHYD2TrkFirstStageBackEMult();
+ int multXT = m_EventData->GetHYD2TrkFirstStageFrontTMult();
+ int multYT = m_EventData->GetHYD2TrkFirstStageBackTMult();
+ // calculate multiplicity of 2nd and third stages
+ int mult2E = m_EventData->GetHYD2TrkSecondStageEMult();
+ int mult2T = m_EventData->GetHYD2TrkSecondStageTMult();
+ int mult3E = m_EventData->GetHYD2TrkThirdStageEMult();
+ int mult3T = m_EventData->GetHYD2TrkThirdStageTMult();
+ int mult4E = m_EventData->GetHYD2TrkFourthStageEMult();
+ int mult4T = m_EventData->GetHYD2TrkFourthStageTMult();
+ int mult5E = m_EventData->GetHYD2TrkFifthStageEMult();
+ int mult5T = m_EventData->GetHYD2TrkFifthStageTMult();
+ int mult6E = m_EventData->GetHYD2TrkSixthStageEMult();
+ int mult6T = m_EventData->GetHYD2TrkSixthStageTMult();
+
+ // Deal with multiplicity 1 for the first layer
+ if (multXE==1 && multYE==1 && multXT==1 && multYT==1) {
+ // calculate detector number
+ int det_ref = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0);
+ int detecXE = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0) / det_ref;
+ int detecXT = m_EventData->GetHYD2TrkFirstStageFrontTDetectorNbr(0) / det_ref;
+ int detecYE = m_EventData->GetHYD2TrkFirstStageBackEDetectorNbr(0) / det_ref;
+ int detecYT = m_EventData->GetHYD2TrkFirstStageBackTDetectorNbr(0) / det_ref;
+
+ // case of same detector
+ if (detecXE*detecXT*detecYE*detecYT == 1) {
+ // store module number
+ m_EventPhysics->SetModuleNumber(det_ref);
+ // calculate strip number
+ int stripXE = m_EventData->GetHYD2TrkFirstStageFrontEStripNbr(0);
+ int stripXT = m_EventData->GetHYD2TrkFirstStageFrontTStripNbr(0);
+ int stripYE = m_EventData->GetHYD2TrkFirstStageBackEStripNbr(0);
+ int stripYT = m_EventData->GetHYD2TrkFirstStageBackTStripNbr(0);
+
+ // case of same strips on X and Y
+ if (stripXE == stripXT && stripYE == stripYT) { // here we have a good strip event
+ // various
+// Check_FirstStage = true;
+ // store strip ID
+ m_EventPhysics->SetFirstStageFrontPosition(stripXE);
+ m_EventPhysics->SetFirstStageBackPosition(stripYE);
+ // get energy from strips and store it
+ double EnergyStripFront = m_EventData->GetHYD2TrkFirstStageFrontEEnergy(0);
+ m_EventPhysics->SetFirstStageEnergy(EnergyStripFront);
+ double EnergyTot = EnergyStripFront;
+ // get time from strips and store it
+ double TimeStripBack = m_EventData->GetHYD2TrkFirstStageBackEEnergy(0);
+ m_EventPhysics->SetFirstStageTime(TimeStripBack);
+
+ // check if we have a 2nd stage event
+ if (mult2E==1 && mult2T==1) {
+ Check_SecondStage = true;
+ double EnergySecond = m_EventData->GetHYD2TrkSecondStageEEnergy(0);
+ m_EventPhysics->SetSecondStageEnergy(EnergySecond);
+ EnergyTot += EnergySecond;
+ }
+ else if (mult2E>1 || mult2T>1) {
+ cout << "Warning: multiplicity in second stage greater than in firststage" << endl;
+ }
+
+ // check if we have a third stage event
+ if (mult3E==1 && mult3T==1) {
+ Check_ThirdStage = true;
+ double EnergyThird = m_EventData->GetHYD2TrkThirdStageEEnergy(0);
+ m_EventPhysics->SetThirdStageEnergy(EnergyThird);
+ EnergyTot += EnergyThird;
+ }
+ else if (mult3E>1 || mult3T>1) {
+ cout << "Warning: multiplicity in third stage greater than in firststage" << endl;
+ }
+
+ // check if we have a Fourth stage event
+ if (mult4E==1 && mult4T==1) {
+ Check_FourthStage = true;
+ double EnergyFourth = m_EventData->GetHYD2TrkFourthStageEEnergy(0);
+ m_EventPhysics->SetFourthStageEnergy(EnergyFourth);
+ EnergyTot += EnergyFourth;
+ }
+ else if (mult4E>1 || mult4T>1) {
+ cout << "Warning: multiplicity in fourth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a Fifth stage event
+ if (mult5E==1 && mult5T==1) {
+ Check_FifthStage = true;
+ double EnergyFifth = m_EventData->GetHYD2TrkFifthStageEEnergy(0);
+ m_EventPhysics->SetFifthStageEnergy(EnergyFifth);
+ EnergyTot += EnergyFifth;
+ }
+ else if (mult5E>1 || mult5T>1) {
+ cout << "Warning: multiplicity in fifth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a Sixth stage event
+ if (mult6E==1 && mult6T==1) {
+ Check_SixthStage = true;
+ double EnergySixth = m_EventData->GetHYD2TrkSixthStageEEnergy(0);
+ m_EventPhysics->SetSixthStageEnergy(EnergySixth);
+ EnergyTot += EnergySixth;
+ }
+ else if (mult6E>1 || mult6T>1) {
+ cout << "Warning: multiplicity in sixth stage greater than in firststage" << endl;
+ }
+
+ // Fill total energy
+ m_EventPhysics->SetTotalEnergy(EnergyTot);
+
+ // check strip position
+/* cout << "strips X, Y : " << stripXE << " " << stripYE << endl;
+ cout << "position : " << endl;
+ cout << "\t X: " << GetStripPositionX(det_ref + m_index["Square1"], stripXE, stripYE) << endl;
+ cout << "\t Y: " << GetStripPositionY(det_ref + m_index["Square1"], stripXE, stripYE) << endl;
+ cout << "\t Z: " << GetStripPositionZ(det_ref + m_index["Square1"], stripXE, stripYE) << endl;
+*/
+ // Fill default values for second an third stages
+ if (!Check_SecondStage) {
+ m_EventPhysics->SetSecondStageEnergy(-1000);
+ m_EventPhysics->SetSecondStageTime(-1000);
+ m_EventPhysics->SetSecondStagePosition(-1000);
+ }
+ if (!Check_ThirdStage) {
+ m_EventPhysics->SetThirdStageEnergy(-1000);
+ m_EventPhysics->SetThirdStageTime(-1000);
+ m_EventPhysics->SetThirdStagePosition(-1000);
+ }
+ if (!Check_FourthStage) {
+ m_EventPhysics->SetFourthStageEnergy(-1000);
+ m_EventPhysics->SetFourthStageTime(-1000);
+ m_EventPhysics->SetFourthStagePosition(-1000);
+ }
+ if (!Check_FifthStage) {
+ m_EventPhysics->SetFifthStageEnergy(-1000);
+ m_EventPhysics->SetFifthStageTime(-1000);
+ m_EventPhysics->SetFifthStagePosition(-1000);
+ }
+ if (!Check_SixthStage) {
+ m_EventPhysics->SetSixthStageEnergy(-1000);
+ m_EventPhysics->SetSixthStageTime(-1000);
+ m_EventPhysics->SetSixthStagePosition(-1000);
+ }
+ }
+ else {
+ cout << "Not same strips" << endl;
+ }
+ }
+ else {
+ cout << "Not same detector" << endl;
+ }
+ }
+ else {
+/* cout << "Multiplicity is not one, it is: " << endl;
+ cout << "\tmultXE: " << multXE << endl;
+ cout << "\tmultXT: " << multXT << endl;
+ cout << "\tmultYE: " << multYE << endl;
+ cout << "\tmultYT: " << multYT << endl;*/
+ }
+}
+
+
+
+void Hyde2TrackerSquare1::BuildSimplePhysicalEvent()
+{
+}
+
+
+
+void Hyde2TrackerSquare1::AddModule(TVector3 C_X1_Y1,
+ TVector3 C_X128_Y1,
+ TVector3 C_X1_Y128,
+ TVector3 C_X128_Y128)
+{
+ m_NumberOfModule++;
+
+ // remove warning using C_X128_Y128
+ C_X128_Y128.Unit();
+
+ // Vector U on Module Face (paralelle to Y Strip) (NB: remember that Y strip are allong X axis)
+ TVector3 U = C_X128_Y1 - C_X1_Y1;
+ U = U.Unit();
+
+ // Vector V on Module Face (parallele to X Strip)
+ TVector3 V = C_X1_Y128 - C_X1_Y1;
+ V = V.Unit();
+
+ // Position Vector of Strip Center
+ TVector3 StripCenter = TVector3(0,0,0);
+ // Position Vector of X=1 Y=1 Strip
+ TVector3 Strip_1_1;
+
+ // Buffer object to fill Position Array
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ // Moving StripCenter to 1.1 corner:
+ Strip_1_1 = C_X1_Y1 + (U+V) * (m_StripPitch/2.);
+
+ for (int i = 0; i < m_NumberOfStrips; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < m_NumberOfStrips; j++) {
+ StripCenter = Strip_1_1 + m_StripPitch*(i*U + j*V);
+
+ lineX.push_back( StripCenter.X() );
+ lineY.push_back( StripCenter.Y() );
+ lineZ.push_back( StripCenter.Z() );
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
+
+
+
+void Hyde2TrackerSquare1::AddModule(double theta,
+ double phi,
+ double distance,
+ double beta_u,
+ double beta_v,
+ double beta_w)
+{
+ m_NumberOfModule++;
+
+ // convert from degree to radian:
+ theta *= M_PI/180;
+ phi *= M_PI/180;
+
+ // Vector U on Module Face (paralelle to Y Strip) (NB: remember that Y strip are allong X axis)
+ TVector3 U ;
+ // Vector V on Module Face (parallele to X Strip)
+ TVector3 V ;
+ // Vector W normal to Module Face (pointing CsI)
+ TVector3 W ;
+ // Vector position of Module Face center
+ TVector3 C ;
+
+ C = TVector3(distance * sin(theta) * cos(phi),
+ distance * sin(theta) * sin(phi),
+ distance * cos(theta));
+
+ TVector3 YperpW = TVector3( cos(theta) * cos(phi),
+ cos(theta) * sin(phi),
+ -sin(theta));
+
+ W = C.Unit();
+ U = W.Cross(YperpW);
+ V = W.Cross(U);
+
+ U = U.Unit();
+ V = V.Unit();
+
+ U.Rotate( beta_u * M_PI/180. , U ) ;
+ V.Rotate( beta_u * M_PI/180. , U ) ;
+
+ U.Rotate( beta_v * M_PI/180. , V ) ;
+ V.Rotate( beta_v * M_PI/180. , V ) ;
+
+ U.Rotate( beta_w * M_PI/180. , W ) ;
+ V.Rotate( beta_w * M_PI/180. , W ) ;
+
+ // Position Vector of Strip Center
+ TVector3 StripCenter = TVector3(0,0,0);
+ // Position Vector of X=1 Y=1 Strip
+ TVector3 Strip_1_1;
+
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ // Moving C to the 1.1 corner:
+ Strip_1_1 = C - 0.5 * (m_FirstStageFace - m_StripPitch) * (U + V);
+
+ for (int i = 0; i < m_NumberOfStrips; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < m_NumberOfStrips; j++) {
+ StripCenter = Strip_1_1 + m_StripPitch * (i*U + j*V);
+
+ lineX.push_back(StripCenter.X());
+ lineY.push_back(StripCenter.Y());
+ lineZ.push_back(StripCenter.Z());
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
diff --git a/NPLib/HYDE2/Hyde2TrackerSquare1.h b/NPLib/HYDE2/Hyde2TrackerSquare1.h
new file mode 100644
index 0000000000000000000000000000000000000000..364699f8f7545b3f729f2c3054111fa84a19d316
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerSquare1.h
@@ -0,0 +1,98 @@
+#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
diff --git a/NPLib/HYDE2/Hyde2TrackerTrapezoid1.cxx b/NPLib/HYDE2/Hyde2TrackerTrapezoid1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e83e1394917c8b64f803c241def5f196909b977a
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerTrapezoid1.cxx
@@ -0,0 +1,560 @@
+#include "Hyde2TrackerTrapezoid1.h"
+
+// C++ headers
+#include <limits>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+#include <stdlib.h>
+
+// Hyde2
+#include "THyde2TrackerPhysics.h"
+
+
+Hyde2TrackerTrapezoid1::Hyde2TrackerTrapezoid1(map<int, Hyde2TrackerModule*> &Module,
+ THyde2TrackerPhysics* &EventPhysics)
+ : m_ModuleTest(Module),
+ m_EventPhysics(EventPhysics),
+ m_EventData(0),
+ m_PreTreatData(new THyde2TrackerData),
+ m_NumberOfModule(0),
+ m_FirstStageHeight(87.68), // mm
+ m_FirstStageBaseLarge(85.48), // mm
+ m_FirstStageBaseSmall(54.17), // mm
+ m_NumberOfStripsX(214),
+ m_NumberOfStripsY(220)
+{
+ m_StripPitchX = m_FirstStageBaseLarge / (double)m_NumberOfStripsX;
+ m_StripPitchY = m_FirstStageHeight / (double)m_NumberOfStripsY;
+}
+
+
+
+Hyde2TrackerTrapezoid1::~Hyde2TrackerTrapezoid1()
+{
+ delete m_PreTreatData;
+}
+
+
+
+void Hyde2TrackerTrapezoid1::ReadConfiguration(string Path)
+{
+ ifstream ConfigFile;
+ ConfigFile.open(Path.c_str());
+ string LineBuffer;
+ string DataBuffer;
+
+ // A:X1_Y1 --> X:1 Y:1
+ // B:X128_Y1 --> X:128 Y:1
+ // C:X1_Y128 --> X:1 Y:128
+ // D:X128_Y128 --> X:128 Y:128
+
+ double Ax, Bx, Cx, Dx, Ay, By, Cy, Dy, Az, Bz, Cz, Dz;
+ TVector3 A, B, C, D;
+ double Theta = 0, Phi = 0, R = 0, beta_u = 0 , beta_v = 0 , beta_w = 0;
+
+ bool check_A = false;
+ bool check_C = false;
+ bool check_B = false;
+ bool check_D = false;
+
+ bool check_Theta = false;
+ bool check_Phi = false;
+ bool check_R = false;
+ bool check_beta = false;
+
+ bool ReadingStatus = false;
+
+ while (!ConfigFile.eof()) {
+ getline(ConfigFile, LineBuffer);
+
+ // If line is a Hyde2XXX bloc, reading toggle to true
+ // and toggle to true flags indicating which shape is treated.
+ if (LineBuffer.compare(0, 14, "HYD2Trapezoid1") == 0) {
+ cout << "///////////////////////" << endl;
+ cout << "Trapezoid1 module found:" << endl;
+ ReadingStatus = true;
+ }
+
+ // Reading Block
+ while (ReadingStatus) {
+ ConfigFile >> DataBuffer ;
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {
+ ConfigFile.ignore(std::numeric_limits<std::streamsize>::max(), '\n' );
+ }
+ // Finding another telescope (safety), toggle out
+ else if (DataBuffer.compare(0, 14, "HYD2Trapezoid1") == 0) {
+ cout << "WARNING: Another Module is find before standard sequence of Token, Error may occured in Telecope definition" << endl;
+ ReadingStatus = false;
+ }
+
+ // Position method
+ else if (DataBuffer.compare(0, 6, "X1_Y1=") == 0) {
+ check_A = true;
+ ConfigFile >> DataBuffer;
+ Ax = atof(DataBuffer.c_str());
+ Ax = Ax;
+ ConfigFile >> DataBuffer;
+ Ay = atof(DataBuffer.c_str());
+ Ay = Ay;
+ ConfigFile >> DataBuffer;
+ Az = atof(DataBuffer.c_str());
+ Az = Az;
+
+ A = TVector3(Ax, Ay, Az);
+ cout << "X1 Y1 corner position : (" << A.X() << ";" << A.Y() << ";" << A.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X128_Y1=") == 0) {
+ check_B = true;
+ ConfigFile >> DataBuffer;
+ Bx = atof(DataBuffer.c_str());
+ Bx = Bx;
+ ConfigFile >> DataBuffer;
+ By = atof(DataBuffer.c_str());
+ By = By;
+ ConfigFile >> DataBuffer;
+ Bz = atof(DataBuffer.c_str());
+ Bz = Bz;
+
+ B = TVector3(Bx, By, Bz);
+ cout << "X128 Y1 corner position : (" << B.X() << ";" << B.Y() << ";" << B.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X1_Y128=") == 0) {
+ check_C = true;
+ ConfigFile >> DataBuffer;
+ Cx = atof(DataBuffer.c_str());
+ Cx = Cx;
+ ConfigFile >> DataBuffer;
+ Cy = atof(DataBuffer.c_str());
+ Cy = Cy;
+ ConfigFile >> DataBuffer;
+ Cz = atof(DataBuffer.c_str());
+ Cz = Cz;
+
+ C = TVector3(Cx, Cy, Cz);
+ cout << "X1 Y128 corner position : (" << C.X() << ";" << C.Y() << ";" << C.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 10, "X128_Y128=") == 0) {
+ check_D = true;
+ ConfigFile >> DataBuffer;
+ Dx = atof(DataBuffer.c_str());
+ Dx = Dx;
+ ConfigFile >> DataBuffer;
+ Dy = atof(DataBuffer.c_str());
+ Dy = Dy;
+ ConfigFile >> DataBuffer;
+ Dz = atof(DataBuffer.c_str());
+ Dz = Dz;
+
+ D = TVector3(Dx, Dy, Dz);
+ cout << "X128 Y128 corner position : (" << D.X() << ";" << D.Y() << ";" << D.Z() << ")" << endl;
+ } // End Position Method
+
+ // Angle method
+ else if (DataBuffer.compare(0, 6, "THETA=") == 0) {
+ check_Theta = true;
+ ConfigFile >> DataBuffer;
+ Theta = atof(DataBuffer.c_str());
+ Theta = Theta;
+ cout << "Theta: " << Theta << endl;
+ }
+ else if (DataBuffer.compare(0, 4, "PHI=") == 0) {
+ check_Phi = true;
+ ConfigFile >> DataBuffer;
+ Phi = atof(DataBuffer.c_str());
+ Phi = Phi;
+ cout << "Phi: " << Phi << endl;
+ }
+ else if (DataBuffer.compare(0, 2, "R=") == 0) {
+ check_R = true;
+ ConfigFile >> DataBuffer;
+ R = atof(DataBuffer.c_str());
+ R = R;
+ cout << "R: " << R << endl;
+ }
+ else if (DataBuffer.compare(0, 5, "BETA=") == 0) {
+ check_beta = true;
+ ConfigFile >> DataBuffer;
+ beta_u = atof(DataBuffer.c_str());
+ beta_u = beta_u;
+ ConfigFile >> DataBuffer;
+ beta_v = atof(DataBuffer.c_str());
+ beta_v = beta_v;
+ ConfigFile >> DataBuffer;
+ beta_w = atof(DataBuffer.c_str());
+ beta_w = beta_w;
+ cout << "Beta: " << beta_u << " " << beta_v << " " << beta_w << endl;
+ }
+
+ /////////////////////////////////////////////////
+ // If All necessary information there, toggle out
+ if ( (check_A && check_B && check_C && check_D) || (check_Theta && check_Phi && check_R && check_beta) ) {
+ ReadingStatus = false;
+
+ // Add The previously define telescope
+ // With position method
+ if ( check_A && check_B && check_C && check_D ) {
+ AddModule(A, B, C, D);
+ m_ModuleTest[m_index["Trapezoid1"] + m_NumberOfModule] = this;
+ }
+
+ // with angle method
+ else if ( check_Theta && check_Phi && check_R && check_beta ) {
+ AddModule(Theta, Phi, R, beta_u, beta_v, beta_w);
+ m_ModuleTest[m_index["Trapezoid1"] + m_NumberOfModule] = this;
+ }
+
+ // reset boolean flag for point positioning
+ check_A = false;
+ check_B = false;
+ check_C = false;
+ check_D = false;
+ // reset boolean flag for angle positioning
+ check_Theta = false;
+ check_Phi = false;
+ check_R = false;
+ check_beta = false;
+
+ } // end test for adding a module
+ } // end while for reading block
+ } // end while for reading file
+
+ cout << endl << "/////////////////////////////" << endl<<endl;
+}
+
+
+
+void Hyde2TrackerTrapezoid1::PreTreat()
+{
+}
+
+
+
+void Hyde2TrackerTrapezoid1::BuildPhysicalEvent()
+{
+ // Check flags
+// bool Check_FirstStage = false;
+ bool Check_SecondStage = false;
+ bool Check_ThirdStage = false;
+ bool Check_FourthStage = false;
+ bool Check_FifthStage = false;
+ bool Check_SixthStage = false;
+
+ // Thresholds
+/*
+ double FirstStage_Front_E_Threshold = 0; double FirstStage_Front_T_Threshold = 0;
+ double FirstStage_Back_E_Threshold = 0; double FirstStage_Back_T_Threshold = 0;
+ double SecondStage_E_Threshold = 0; double SecondStage_T_Threshold = 0;
+ double ThirdStage_E_Threshold = 0; double ThirdStage_T_Threshold = 0;
+*/
+ // calculate multipicity in the first stage
+ int multXE = m_EventData->GetHYD2TrkFirstStageFrontEMult();
+ int multYE = m_EventData->GetHYD2TrkFirstStageBackEMult();
+ int multXT = m_EventData->GetHYD2TrkFirstStageFrontTMult();
+ int multYT = m_EventData->GetHYD2TrkFirstStageBackTMult();
+ // calculate multiplicity of 2nd and third stages
+ int mult2E = m_EventData->GetHYD2TrkSecondStageEMult();
+ int mult2T = m_EventData->GetHYD2TrkSecondStageTMult();
+ int mult3E = m_EventData->GetHYD2TrkThirdStageEMult();
+ int mult3T = m_EventData->GetHYD2TrkThirdStageTMult();
+ int mult4E = m_EventData->GetHYD2TrkFourthStageEMult();
+ int mult4T = m_EventData->GetHYD2TrkFourthStageTMult();
+ int mult5E = m_EventData->GetHYD2TrkFifthStageEMult();
+ int mult5T = m_EventData->GetHYD2TrkFifthStageTMult();
+ int mult6E = m_EventData->GetHYD2TrkSixthStageEMult();
+ int mult6T = m_EventData->GetHYD2TrkSixthStageTMult();
+
+ // Deal with multiplicity 1 for the first layer
+ if (multXE==1 && multYE==1 && multXT==1 && multYT==1) {
+ // calculate detector number
+ int det_ref = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0);
+ int detecXE = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0) / det_ref;
+ int detecXT = m_EventData->GetHYD2TrkFirstStageFrontTDetectorNbr(0) / det_ref;
+ int detecYE = m_EventData->GetHYD2TrkFirstStageBackEDetectorNbr(0) / det_ref;
+ int detecYT = m_EventData->GetHYD2TrkFirstStageBackTDetectorNbr(0) / det_ref;
+
+ // case of same detector
+ if (detecXE*detecXT*detecYE*detecYT == 1) {
+ // store module number
+ m_EventPhysics->SetModuleNumber(det_ref);
+ // calculate strip number
+ int stripXE = m_EventData->GetHYD2TrkFirstStageFrontEStripNbr(0);
+ int stripXT = m_EventData->GetHYD2TrkFirstStageFrontTStripNbr(0);
+ int stripYE = m_EventData->GetHYD2TrkFirstStageBackEStripNbr(0);
+ int stripYT = m_EventData->GetHYD2TrkFirstStageBackTStripNbr(0);
+
+ // case of same strips on X and Y
+ if (stripXE == stripXT && stripYE == stripYT) { // here we have a good strip event
+ // various
+// Check_FirstStage = true;
+ // store strip ID
+ m_EventPhysics->SetFirstStageFrontPosition(stripXE);
+ m_EventPhysics->SetFirstStageBackPosition(stripYE);
+ // get energy from strips and store it
+ double EnergyStripFront = m_EventData->GetHYD2TrkFirstStageFrontEEnergy(0);
+ m_EventPhysics->SetFirstStageEnergy(EnergyStripFront);
+ double EnergyTot = EnergyStripFront;
+ // get time from strips and store it
+ double TimeStripBack = m_EventData->GetHYD2TrkFirstStageBackEEnergy(0);
+ m_EventPhysics->SetFirstStageTime(TimeStripBack);
+
+ // check if we have a 2nd stage event
+ if (mult2E==1 && mult2T==1) {
+ Check_SecondStage = true;
+ double EnergySecond = m_EventData->GetHYD2TrkSecondStageEEnergy(0);
+ m_EventPhysics->SetSecondStageEnergy(EnergySecond);
+ EnergyTot += EnergySecond;
+ }
+ else if (mult2E>1 || mult2T>1) {
+ cout << "Warning: multiplicity in second stage greater than in firststage" << endl;
+ }
+
+ // check if we have a third stage event
+ if (mult3E==1 && mult3T==1) {
+ Check_ThirdStage = true;
+ double EnergyThird = m_EventData->GetHYD2TrkThirdStageEEnergy(0);
+ m_EventPhysics->SetThirdStageEnergy(EnergyThird);
+ EnergyTot += EnergyThird;
+ }
+ else if (mult3E>1 || mult3T>1) {
+ cout << "Warning: multiplicity in third stage greater than in firststage" << endl;
+ }
+
+ // check if we have a fourth stage event
+ if (mult4E==1 && mult4T==1) {
+ Check_FourthStage = true;
+ double EnergyFourth = m_EventData->GetHYD2TrkFourthStageEEnergy(0);
+ m_EventPhysics->SetFourthStageEnergy(EnergyFourth);
+ EnergyTot += EnergyFourth;
+ }
+ else if (mult4E>1 || mult4T>1) {
+ cout << "Warning: multiplicity in fourth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a fifth stage event
+ if (mult5E==1 && mult5T==1) {
+ Check_FifthStage = true;
+ double EnergyFifth = m_EventData->GetHYD2TrkFifthStageEEnergy(0);
+ m_EventPhysics->SetFifthStageEnergy(EnergyFifth);
+ EnergyTot += EnergyFifth;
+ }
+ else if (mult5E>1 || mult5T>1) {
+ cout << "Warning: multiplicity in fifth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a sixth stage event
+ if (mult6E==1 && mult6T==1) {
+ Check_SixthStage = true;
+ double EnergySixth = m_EventData->GetHYD2TrkSixthStageEEnergy(0);
+ m_EventPhysics->SetSixthStageEnergy(EnergySixth);
+ EnergyTot += EnergySixth;
+ }
+ else if (mult6E>1 || mult6T>1) {
+ cout << "Warning: multiplicity in sixth stage greater than in firststage" << endl;
+ }
+
+ // Fill total energy
+ m_EventPhysics->SetTotalEnergy(EnergyTot);
+
+ // Fill default values for second an third stages
+ if (!Check_SecondStage) {
+ m_EventPhysics->SetSecondStageEnergy(-1000);
+ m_EventPhysics->SetSecondStageTime(-1000);
+ m_EventPhysics->SetSecondStagePosition(-1000);
+ }
+ if (!Check_ThirdStage) {
+ m_EventPhysics->SetThirdStageEnergy(-1000);
+ m_EventPhysics->SetThirdStageTime(-1000);
+ m_EventPhysics->SetThirdStagePosition(-1000);
+ }
+ if (!Check_FourthStage) {
+ m_EventPhysics->SetFourthStageEnergy(-1000);
+ m_EventPhysics->SetFourthStageTime(-1000);
+ m_EventPhysics->SetFourthStagePosition(-1000);
+ }
+ if (!Check_FifthStage) {
+ m_EventPhysics->SetFifthStageEnergy(-1000);
+ m_EventPhysics->SetFifthStageTime(-1000);
+ m_EventPhysics->SetFifthStagePosition(-1000);
+ }
+ if (!Check_SixthStage) {
+ m_EventPhysics->SetSixthStageEnergy(-1000);
+ m_EventPhysics->SetSixthStageTime(-1000);
+ m_EventPhysics->SetSixthStagePosition(-1000);
+ }
+ }
+ else {
+ cout << "Not same strips" << endl;
+ }
+ }
+ else {
+ cout << "Not same detector" << endl;
+ }
+ }
+ else {
+/* cout << "Multiplicity is not one, it is: " << endl;
+ cout << "\tmultXE: " << multXE << endl;
+ cout << "\tmultXT: " << multXT << endl;
+ cout << "\tmultYE: " << multYE << endl;
+ cout << "\tmultYT: " << multYT << endl;*/
+ }
+}
+
+
+
+void Hyde2TrackerTrapezoid1::BuildSimplePhysicalEvent()
+{
+}
+
+
+
+void Hyde2TrackerTrapezoid1::AddModule(TVector3 C_X1_Y1,
+ TVector3 C_X128_Y1,
+ TVector3 C_X1_Y128,
+ TVector3 C_X128_Y128)
+{
+ m_NumberOfModule++;
+
+ // Definition of vectors U and V are *identical* with definition
+ // in NPS.
+ // Vector U parallel to BaseLarge
+ TVector3 U = C_X128_Y1 - C_X1_Y1;
+ U = U.Unit();
+
+ // Vector V parallel to height
+ TVector3 V = 0.5 * (C_X1_Y128 + C_X128_Y128 - C_X1_Y1 - C_X128_Y1);
+ V = V.Unit();
+
+ // Position Vector of Strip Center
+ TVector3 StripCenter = TVector3(0,0,0);
+ // Position Vector of X=1 Y=1 Strip
+ TVector3 Strip_1_1;
+
+ // Buffer object to fill Position Array
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ // Moving StripCenter to 1.1 corner:
+ Strip_1_1 = C_X1_Y1 + m_StripPitchX/2*U + m_StripPitchY/2*V;
+
+ for (int i = 0; i < m_NumberOfStripsX; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < m_NumberOfStripsY; j++) {
+ StripCenter = Strip_1_1 + i*m_StripPitchX*U + j*m_StripPitchY*V;
+
+ lineX.push_back( StripCenter.X() );
+ lineY.push_back( StripCenter.Y() );
+ lineZ.push_back( StripCenter.Z() );
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
+
+
+
+void Hyde2TrackerTrapezoid1::AddModule(double theta,
+ double phi,
+ double distance,
+ double beta_u,
+ double beta_v,
+ double beta_w)
+{
+ m_NumberOfModule++;
+
+ // convert from degree to radian:
+ theta *= M_PI/180;
+ phi *= M_PI/180;
+
+ // Vector U on Module Face (paralelle to Y Strip) (NB: remember that Y strip are allong X axis)
+ TVector3 U ;
+ // Vector V on Module Face (parallele to X Strip)
+ TVector3 V ;
+ // Vector W normal to Module Face (pointing CsI)
+ TVector3 W ;
+ // Vector position of Module Face center
+ TVector3 C ;
+
+ C = TVector3(distance * sin(theta) * cos(phi),
+ distance * sin(theta) * sin(phi),
+ distance * cos(theta));
+
+ TVector3 YperpW = TVector3( cos(theta) * cos(phi),
+ cos(theta) * sin(phi),
+ -sin(theta));
+
+ W = C.Unit();
+ U = W.Cross(YperpW);
+ V = W.Cross(U);
+
+ U = U.Unit();
+ V = V.Unit();
+
+ U.Rotate( beta_u * M_PI/180. , U ) ;
+ V.Rotate( beta_u * M_PI/180. , U ) ;
+
+ U.Rotate( beta_v * M_PI/180. , V ) ;
+ V.Rotate( beta_v * M_PI/180. , V ) ;
+
+ U.Rotate( beta_w * M_PI/180. , W ) ;
+ V.Rotate( beta_w * M_PI/180. , W ) ;
+
+ double Face = 50; // mm
+ double NumberOfStrip = 100;
+ double StripPitch = Face/NumberOfStrip; // mm
+
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ double X, Y, Z;
+
+ // Moving C to the 1.1 corner:
+ C.SetX( C.X() - ( Face/2 - StripPitch/2 ) * ( V.X() + U.X() ) ) ;
+ C.SetY( C.Y() - ( Face/2 - StripPitch/2 ) * ( V.Y() + U.Y() ) ) ;
+ C.SetZ( C.Z() - ( Face/2 - StripPitch/2 ) * ( V.Z() + U.Z() ) ) ;
+
+ for (int i = 0; i < NumberOfStrip; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < NumberOfStrip; j++) {
+ X = C.X() + StripPitch * ( U.X()*i + V.X()*j );
+ Y = C.Y() + StripPitch * ( U.Y()*i + V.Y()*j );
+ Z = C.Z() + StripPitch * ( U.Z()*i + V.Z()*j );
+
+ lineX.push_back(X);
+ lineY.push_back(Y);
+ lineZ.push_back(Z);
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
diff --git a/NPLib/HYDE2/Hyde2TrackerTrapezoid1.h b/NPLib/HYDE2/Hyde2TrackerTrapezoid1.h
new file mode 100644
index 0000000000000000000000000000000000000000..d747be07d436035c67330e14b855abed3da59092
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerTrapezoid1.h
@@ -0,0 +1,102 @@
+#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
diff --git a/NPLib/HYDE2/Hyde2TrackerTrapezoid2.cxx b/NPLib/HYDE2/Hyde2TrackerTrapezoid2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d8e9dbac966e6904b62234b4abf0780c1f34c716
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerTrapezoid2.cxx
@@ -0,0 +1,560 @@
+#include "Hyde2TrackerTrapezoid2.h"
+
+// C++ headers
+#include <limits>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+#include <stdlib.h>
+
+// Hyde2
+#include "THyde2TrackerPhysics.h"
+
+
+Hyde2TrackerTrapezoid2::Hyde2TrackerTrapezoid2(map<int, Hyde2TrackerModule*> &Module,
+ THyde2TrackerPhysics* &EventPhysics)
+ : m_ModuleTest(Module),
+ m_EventPhysics(EventPhysics),
+ m_EventData(0),
+ m_PreTreatData(new THyde2TrackerData),
+ m_NumberOfModule(0),
+ m_FirstStageHeight(50.52), // mm
+ m_FirstStageBaseLarge(51.62), // mm
+ m_FirstStageBaseSmall(20.30), // mm
+ m_NumberOfStripsX(129),
+ m_NumberOfStripsY(126)
+{
+ m_StripPitchX = m_FirstStageBaseLarge / (double)m_NumberOfStripsX;
+ m_StripPitchY = m_FirstStageHeight / (double)m_NumberOfStripsY;
+}
+
+
+
+Hyde2TrackerTrapezoid2::~Hyde2TrackerTrapezoid2()
+{
+ delete m_PreTreatData;
+}
+
+
+
+void Hyde2TrackerTrapezoid2::ReadConfiguration(string Path)
+{
+ ifstream ConfigFile;
+ ConfigFile.open(Path.c_str());
+ string LineBuffer;
+ string DataBuffer;
+
+ // A:X1_Y1 --> X:1 Y:1
+ // B:X128_Y1 --> X:128 Y:1
+ // C:X1_Y128 --> X:1 Y:128
+ // D:X128_Y128 --> X:128 Y:128
+
+ double Ax, Bx, Cx, Dx, Ay, By, Cy, Dy, Az, Bz, Cz, Dz;
+ TVector3 A, B, C, D;
+ double Theta = 0, Phi = 0, R = 0, beta_u = 0 , beta_v = 0 , beta_w = 0;
+
+ bool check_A = false;
+ bool check_C = false;
+ bool check_B = false;
+ bool check_D = false;
+
+ bool check_Theta = false;
+ bool check_Phi = false;
+ bool check_R = false;
+ bool check_beta = false;
+
+ bool ReadingStatus = false;
+
+ while (!ConfigFile.eof()) {
+ getline(ConfigFile, LineBuffer);
+
+ // If line is a Hyde2XXX bloc, reading toggle to true
+ // and toggle to true flags indicating which shape is treated.
+ if (LineBuffer.compare(0, 14, "HYD2Trapezoid2") == 0) {
+ cout << "///////////////////////" << endl;
+ cout << "Trapezoid2 module found:" << endl;
+ ReadingStatus = true;
+ }
+
+ // Reading Block
+ while (ReadingStatus) {
+ ConfigFile >> DataBuffer ;
+ // Comment Line
+ if (DataBuffer.compare(0, 1, "%") == 0) {
+ ConfigFile.ignore(std::numeric_limits<std::streamsize>::max(), '\n' );
+ }
+ // Finding another telescope (safety), toggle out
+ else if (DataBuffer.compare(0, 14, "HYD2Trapezoid2") == 0) {
+ cout << "WARNING: Another Module is find before standard sequence of Token, Error may occured in Telecope definition" << endl;
+ ReadingStatus = false;
+ }
+
+ // Position method
+ else if (DataBuffer.compare(0, 6, "X1_Y1=") == 0) {
+ check_A = true;
+ ConfigFile >> DataBuffer;
+ Ax = atof(DataBuffer.c_str());
+ Ax = Ax;
+ ConfigFile >> DataBuffer;
+ Ay = atof(DataBuffer.c_str());
+ Ay = Ay;
+ ConfigFile >> DataBuffer;
+ Az = atof(DataBuffer.c_str());
+ Az = Az;
+
+ A = TVector3(Ax, Ay, Az);
+ cout << "X1 Y1 corner position : (" << A.X() << ";" << A.Y() << ";" << A.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X128_Y1=") == 0) {
+ check_B = true;
+ ConfigFile >> DataBuffer;
+ Bx = atof(DataBuffer.c_str());
+ Bx = Bx;
+ ConfigFile >> DataBuffer;
+ By = atof(DataBuffer.c_str());
+ By = By;
+ ConfigFile >> DataBuffer;
+ Bz = atof(DataBuffer.c_str());
+ Bz = Bz;
+
+ B = TVector3(Bx, By, Bz);
+ cout << "X128 Y1 corner position : (" << B.X() << ";" << B.Y() << ";" << B.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 8, "X1_Y128=") == 0) {
+ check_C = true;
+ ConfigFile >> DataBuffer;
+ Cx = atof(DataBuffer.c_str());
+ Cx = Cx;
+ ConfigFile >> DataBuffer;
+ Cy = atof(DataBuffer.c_str());
+ Cy = Cy;
+ ConfigFile >> DataBuffer;
+ Cz = atof(DataBuffer.c_str());
+ Cz = Cz;
+
+ C = TVector3(Cx, Cy, Cz);
+ cout << "X1 Y128 corner position : (" << C.X() << ";" << C.Y() << ";" << C.Z() << ")" << endl;
+ }
+ else if (DataBuffer.compare(0, 10, "X128_Y128=") == 0) {
+ check_D = true;
+ ConfigFile >> DataBuffer;
+ Dx = atof(DataBuffer.c_str());
+ Dx = Dx;
+ ConfigFile >> DataBuffer;
+ Dy = atof(DataBuffer.c_str());
+ Dy = Dy;
+ ConfigFile >> DataBuffer;
+ Dz = atof(DataBuffer.c_str());
+ Dz = Dz;
+
+ D = TVector3(Dx, Dy, Dz);
+ cout << "X128 Y128 corner position : (" << D.X() << ";" << D.Y() << ";" << D.Z() << ")" << endl;
+ } // End Position Method
+
+ // Angle method
+ else if (DataBuffer.compare(0, 6, "THETA=") == 0) {
+ check_Theta = true;
+ ConfigFile >> DataBuffer;
+ Theta = atof(DataBuffer.c_str());
+ Theta = Theta;
+ cout << "Theta: " << Theta << endl;
+ }
+ else if (DataBuffer.compare(0, 4, "PHI=") == 0) {
+ check_Phi = true;
+ ConfigFile >> DataBuffer;
+ Phi = atof(DataBuffer.c_str());
+ Phi = Phi;
+ cout << "Phi: " << Phi << endl;
+ }
+ else if (DataBuffer.compare(0, 2, "R=") == 0) {
+ check_R = true;
+ ConfigFile >> DataBuffer;
+ R = atof(DataBuffer.c_str());
+ R = R;
+ cout << "R: " << R << endl;
+ }
+ else if (DataBuffer.compare(0, 5, "BETA=") == 0) {
+ check_beta = true;
+ ConfigFile >> DataBuffer;
+ beta_u = atof(DataBuffer.c_str());
+ beta_u = beta_u;
+ ConfigFile >> DataBuffer;
+ beta_v = atof(DataBuffer.c_str());
+ beta_v = beta_v;
+ ConfigFile >> DataBuffer;
+ beta_w = atof(DataBuffer.c_str());
+ beta_w = beta_w;
+ cout << "Beta: " << beta_u << " " << beta_v << " " << beta_w << endl;
+ }
+
+ /////////////////////////////////////////////////
+ // If All necessary information there, toggle out
+ if ( (check_A && check_B && check_C && check_D) || (check_Theta && check_Phi && check_R && check_beta) ) {
+ ReadingStatus = false;
+
+ // Add The previously define telescope
+ // With position method
+ if ( check_A && check_B && check_C && check_D ) {
+ AddModule(A, B, C, D);
+ m_ModuleTest[m_index["Trapezoid2"] + m_NumberOfModule] = this;
+ }
+
+ // with angle method
+ else if ( check_Theta && check_Phi && check_R && check_beta ) {
+ AddModule(Theta, Phi, R, beta_u, beta_v, beta_w);
+ m_ModuleTest[m_index["Trapezoid2"] + m_NumberOfModule] = this;
+ }
+
+ // reset boolean flag for point positioning
+ check_A = false;
+ check_B = false;
+ check_C = false;
+ check_D = false;
+ // reset boolean flag for angle positioning
+ check_Theta = false;
+ check_Phi = false;
+ check_R = false;
+ check_beta = false;
+
+ } // end test for adding a module
+ } // end while for reading block
+ } // end while for reading file
+
+ cout << endl << "/////////////////////////////" << endl<<endl;
+}
+
+
+
+void Hyde2TrackerTrapezoid2::PreTreat()
+{
+}
+
+
+
+void Hyde2TrackerTrapezoid2::BuildPhysicalEvent()
+{
+ // Check flags
+// bool Check_FirstStage = false;
+ bool Check_SecondStage = false;
+ bool Check_ThirdStage = false;
+ bool Check_FourthStage = false;
+ bool Check_FifthStage = false;
+ bool Check_SixthStage = false;
+
+ // Thresholds
+/*
+ double FirstStage_Front_E_Threshold = 0; double FirstStage_Front_T_Threshold = 0;
+ double FirstStage_Back_E_Threshold = 0; double FirstStage_Back_T_Threshold = 0;
+ double SecondStage_E_Threshold = 0; double SecondStage_T_Threshold = 0;
+ double ThirdStage_E_Threshold = 0; double ThirdStage_T_Threshold = 0;
+*/
+ // calculate multipicity in the first stage
+ int multXE = m_EventData->GetHYD2TrkFirstStageFrontEMult();
+ int multYE = m_EventData->GetHYD2TrkFirstStageBackEMult();
+ int multXT = m_EventData->GetHYD2TrkFirstStageFrontTMult();
+ int multYT = m_EventData->GetHYD2TrkFirstStageBackTMult();
+ // calculate multiplicity of 2nd and third stages
+ int mult2E = m_EventData->GetHYD2TrkSecondStageEMult();
+ int mult2T = m_EventData->GetHYD2TrkSecondStageTMult();
+ int mult3E = m_EventData->GetHYD2TrkThirdStageEMult();
+ int mult3T = m_EventData->GetHYD2TrkThirdStageTMult();
+ int mult4E = m_EventData->GetHYD2TrkFourthStageEMult();
+ int mult4T = m_EventData->GetHYD2TrkFourthStageTMult();
+ int mult5E = m_EventData->GetHYD2TrkFifthStageEMult();
+ int mult5T = m_EventData->GetHYD2TrkFifthStageTMult();
+ int mult6E = m_EventData->GetHYD2TrkSixthStageEMult();
+ int mult6T = m_EventData->GetHYD2TrkSixthStageTMult();
+
+ // Deal with multiplicity 1 for the first layer
+ if (multXE==1 && multYE==1 && multXT==1 && multYT==1) {
+ // calculate detector number
+ int det_ref = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0);
+ int detecXE = m_EventData->GetHYD2TrkFirstStageFrontEDetectorNbr(0) / det_ref;
+ int detecXT = m_EventData->GetHYD2TrkFirstStageFrontTDetectorNbr(0) / det_ref;
+ int detecYE = m_EventData->GetHYD2TrkFirstStageBackEDetectorNbr(0) / det_ref;
+ int detecYT = m_EventData->GetHYD2TrkFirstStageBackTDetectorNbr(0) / det_ref;
+
+ // case of same detector
+ if (detecXE*detecXT*detecYE*detecYT == 1) {
+ // store module number
+ m_EventPhysics->SetModuleNumber(det_ref);
+ // calculate strip number
+ int stripXE = m_EventData->GetHYD2TrkFirstStageFrontEStripNbr(0);
+ int stripXT = m_EventData->GetHYD2TrkFirstStageFrontTStripNbr(0);
+ int stripYE = m_EventData->GetHYD2TrkFirstStageBackEStripNbr(0);
+ int stripYT = m_EventData->GetHYD2TrkFirstStageBackTStripNbr(0);
+
+ // case of same strips on X and Y
+ if (stripXE == stripXT && stripYE == stripYT) { // here we have a good strip event
+ // various
+// Check_FirstStage = true;
+ // store strip ID
+ m_EventPhysics->SetFirstStageFrontPosition(stripXE);
+ m_EventPhysics->SetFirstStageBackPosition(stripYE);
+ // get energy from strips and store it
+ double EnergyStripFront = m_EventData->GetHYD2TrkFirstStageFrontEEnergy(0);
+ m_EventPhysics->SetFirstStageEnergy(EnergyStripFront);
+ double EnergyTot = EnergyStripFront;
+ // get time from strips and store it
+ double TimeStripBack = m_EventData->GetHYD2TrkFirstStageBackEEnergy(0);
+ m_EventPhysics->SetFirstStageTime(TimeStripBack);
+
+ // check if we have a 2nd stage event
+ if (mult2E==1 && mult2T==1) {
+ Check_SecondStage = true;
+ double EnergySecond = m_EventData->GetHYD2TrkSecondStageEEnergy(0);
+ m_EventPhysics->SetSecondStageEnergy(EnergySecond);
+ EnergyTot += EnergySecond;
+ }
+ else if (mult2E>1 || mult2T>1) {
+ cout << "Warning: multiplicity in second stage greater than in firststage" << endl;
+ }
+
+ // check if we have a third stage event
+ if (mult3E==1 && mult3T==1) {
+ Check_ThirdStage = true;
+ double EnergyThird = m_EventData->GetHYD2TrkThirdStageEEnergy(0);
+ m_EventPhysics->SetThirdStageEnergy(EnergyThird);
+ EnergyTot += EnergyThird;
+ }
+ else if (mult3E>1 || mult3T>1) {
+ cout << "Warning: multiplicity in third stage greater than in firststage" << endl;
+ }
+
+ // check if we have a fourth stage event
+ if (mult4E==1 && mult4T==1) {
+ Check_FourthStage = true;
+ double EnergyFourth = m_EventData->GetHYD2TrkFourthStageEEnergy(0);
+ m_EventPhysics->SetFourthStageEnergy(EnergyFourth);
+ EnergyTot += EnergyFourth;
+ }
+ else if (mult4E>1 || mult4T>1) {
+ cout << "Warning: multiplicity in fourth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a fifth stage event
+ if (mult5E==1 && mult5T==1) {
+ Check_FifthStage = true;
+ double EnergyFifth = m_EventData->GetHYD2TrkFifthStageEEnergy(0);
+ m_EventPhysics->SetFifthStageEnergy(EnergyFifth);
+ EnergyTot += EnergyFifth;
+ }
+ else if (mult5E>1 || mult5T>1) {
+ cout << "Warning: multiplicity in fifth stage greater than in firststage" << endl;
+ }
+
+ // check if we have a sixth stage event
+ if (mult6E==1 && mult6T==1) {
+ Check_SixthStage = true;
+ double EnergySixth = m_EventData->GetHYD2TrkSixthStageEEnergy(0);
+ m_EventPhysics->SetSixthStageEnergy(EnergySixth);
+ EnergyTot += EnergySixth;
+ }
+ else if (mult6E>1 || mult6T>1) {
+ cout << "Warning: multiplicity in sixth stage greater than in firststage" << endl;
+ }
+
+ // Fill total energy
+ m_EventPhysics->SetTotalEnergy(EnergyTot);
+
+ // Fill default values for second an third stages
+ if (!Check_SecondStage) {
+ m_EventPhysics->SetSecondStageEnergy(-1000);
+ m_EventPhysics->SetSecondStageTime(-1000);
+ m_EventPhysics->SetSecondStagePosition(-1000);
+ }
+ if (!Check_ThirdStage) {
+ m_EventPhysics->SetThirdStageEnergy(-1000);
+ m_EventPhysics->SetThirdStageTime(-1000);
+ m_EventPhysics->SetThirdStagePosition(-1000);
+ }
+ if (!Check_FourthStage) {
+ m_EventPhysics->SetFourthStageEnergy(-1000);
+ m_EventPhysics->SetFourthStageTime(-1000);
+ m_EventPhysics->SetFourthStagePosition(-1000);
+ }
+ if (!Check_FifthStage) {
+ m_EventPhysics->SetFifthStageEnergy(-1000);
+ m_EventPhysics->SetFifthStageTime(-1000);
+ m_EventPhysics->SetFifthStagePosition(-1000);
+ }
+ if (!Check_SixthStage) {
+ m_EventPhysics->SetSixthStageEnergy(-1000);
+ m_EventPhysics->SetSixthStageTime(-1000);
+ m_EventPhysics->SetSixthStagePosition(-1000);
+ }
+ }
+ else {
+ cout << "Not same strips" << endl;
+ }
+ }
+ else {
+ cout << "Not same detector" << endl;
+ }
+ }
+ else {
+/* cout << "Multiplicity is not one, it is: " << endl;
+ cout << "\tmultXE: " << multXE << endl;
+ cout << "\tmultXT: " << multXT << endl;
+ cout << "\tmultYE: " << multYE << endl;
+ cout << "\tmultYT: " << multYT << endl;*/
+ }
+}
+
+
+
+void Hyde2TrackerTrapezoid2::BuildSimplePhysicalEvent()
+{
+}
+
+
+
+void Hyde2TrackerTrapezoid2::AddModule(TVector3 C_X1_Y1,
+ TVector3 C_X128_Y1,
+ TVector3 C_X1_Y128,
+ TVector3 C_X128_Y128)
+{
+ m_NumberOfModule++;
+
+ // Definition of vectors U and V are *identical* with definition
+ // in NPS.
+ // Vector U parallel to BaseLarge
+ TVector3 U = C_X128_Y1 - C_X1_Y1;
+ U = U.Unit();
+
+ // Vector V parallel to height
+ TVector3 V = 0.5 * (C_X1_Y128 + C_X128_Y128 - C_X1_Y1 - C_X128_Y1);
+ V = V.Unit();
+
+ // Position Vector of Strip Center
+ TVector3 StripCenter = TVector3(0,0,0);
+ // Position Vector of X=1 Y=1 Strip
+ TVector3 Strip_1_1;
+
+ // Buffer object to fill Position Array
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ // Moving StripCenter to 1.1 corner:
+ Strip_1_1 = C_X1_Y1 + m_StripPitchX/2*U + m_StripPitchY/2*V;
+
+ for (int i = 0; i < m_NumberOfStripsX; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < m_NumberOfStripsY; j++) {
+ StripCenter = Strip_1_1 + i*m_StripPitchX*U + j*m_StripPitchY*V;
+
+ lineX.push_back( StripCenter.X() );
+ lineY.push_back( StripCenter.Y() );
+ lineZ.push_back( StripCenter.Z() );
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
+
+
+
+void Hyde2TrackerTrapezoid2::AddModule(double theta,
+ double phi,
+ double distance,
+ double beta_u,
+ double beta_v,
+ double beta_w)
+{
+ m_NumberOfModule++;
+
+ // convert from degree to radian:
+ theta *= M_PI/180;
+ phi *= M_PI/180;
+
+ // Vector U on Module Face (paralelle to Y Strip) (NB: remember that Y strip are allong X axis)
+ TVector3 U ;
+ // Vector V on Module Face (parallele to X Strip)
+ TVector3 V ;
+ // Vector W normal to Module Face (pointing CsI)
+ TVector3 W ;
+ // Vector position of Module Face center
+ TVector3 C ;
+
+ C = TVector3(distance * sin(theta) * cos(phi),
+ distance * sin(theta) * sin(phi),
+ distance * cos(theta));
+
+ TVector3 YperpW = TVector3( cos(theta) * cos(phi),
+ cos(theta) * sin(phi),
+ -sin(theta));
+
+ W = C.Unit();
+ U = W.Cross(YperpW);
+ V = W.Cross(U);
+
+ U = U.Unit();
+ V = V.Unit();
+
+ U.Rotate( beta_u * M_PI/180. , U ) ;
+ V.Rotate( beta_u * M_PI/180. , U ) ;
+
+ U.Rotate( beta_v * M_PI/180. , V ) ;
+ V.Rotate( beta_v * M_PI/180. , V ) ;
+
+ U.Rotate( beta_w * M_PI/180. , W ) ;
+ V.Rotate( beta_w * M_PI/180. , W ) ;
+
+ double Face = 50; // mm
+ double NumberOfStrip = 100;
+ double StripPitch = Face/NumberOfStrip; // mm
+
+ vector<double> lineX;
+ vector<double> lineY;
+ vector<double> lineZ;
+
+ vector< vector< double > > OneModuleStripPositionX;
+ vector< vector< double > > OneModuleStripPositionY;
+ vector< vector< double > > OneModuleStripPositionZ;
+
+ double X, Y, Z;
+
+ // Moving C to the 1.1 corner:
+ C.SetX( C.X() - ( Face/2 - StripPitch/2 ) * ( V.X() + U.X() ) ) ;
+ C.SetY( C.Y() - ( Face/2 - StripPitch/2 ) * ( V.Y() + U.Y() ) ) ;
+ C.SetZ( C.Z() - ( Face/2 - StripPitch/2 ) * ( V.Z() + U.Z() ) ) ;
+
+ for (int i = 0; i < NumberOfStrip; i++) {
+ lineX.clear();
+ lineY.clear();
+ lineZ.clear();
+
+ for (int j = 0; j < NumberOfStrip; j++) {
+ X = C.X() + StripPitch * ( U.X()*i + V.X()*j );
+ Y = C.Y() + StripPitch * ( U.Y()*i + V.Y()*j );
+ Z = C.Z() + StripPitch * ( U.Z()*i + V.Z()*j );
+
+ lineX.push_back(X);
+ lineY.push_back(Y);
+ lineZ.push_back(Z);
+ }
+
+ OneModuleStripPositionX.push_back(lineX);
+ OneModuleStripPositionY.push_back(lineY);
+ OneModuleStripPositionZ.push_back(lineZ);
+ }
+
+ m_StripPositionX.push_back( OneModuleStripPositionX );
+ m_StripPositionY.push_back( OneModuleStripPositionY );
+ m_StripPositionZ.push_back( OneModuleStripPositionZ );
+}
diff --git a/NPLib/HYDE2/Hyde2TrackerTrapezoid2.h b/NPLib/HYDE2/Hyde2TrackerTrapezoid2.h
new file mode 100644
index 0000000000000000000000000000000000000000..7959cbf03b6a817764ac09a7a6974c0784c32350
--- /dev/null
+++ b/NPLib/HYDE2/Hyde2TrackerTrapezoid2.h
@@ -0,0 +1,102 @@
+#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
diff --git a/NPLib/HYDE2/Makefile b/NPLib/HYDE2/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..f4683340f6454ac7214b0fad0405cb6359b6c497
--- /dev/null
+++ b/NPLib/HYDE2/Makefile
@@ -0,0 +1,54 @@
+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 $<
+
+
diff --git a/NPLib/HYDE2/Makefile_longer b/NPLib/HYDE2/Makefile_longer
new file mode 100644
index 0000000000000000000000000000000000000000..f4683340f6454ac7214b0fad0405cb6359b6c497
--- /dev/null
+++ b/NPLib/HYDE2/Makefile_longer
@@ -0,0 +1,54 @@
+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 $<
+
+
diff --git a/NPLib/HYDE2/Makefile_shorter b/NPLib/HYDE2/Makefile_shorter
new file mode 100644
index 0000000000000000000000000000000000000000..da31f47e92eee971ded7ab629e75849ed448ce8b
--- /dev/null
+++ b/NPLib/HYDE2/Makefile_shorter
@@ -0,0 +1,42 @@
+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 $<
+
+
diff --git a/NPLib/HYDE2/README.txt b/NPLib/HYDE2/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..738a7783ee0365fd2ed69f0ce68bec94a5150702
--- /dev/null
+++ b/NPLib/HYDE2/README.txt
@@ -0,0 +1,10 @@
+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)
diff --git a/NPLib/HYDE2/THyde2TrackerData.cxx b/NPLib/HYDE2/THyde2TrackerData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e069e7fbb33c9ec2a1ca8cb8515fe1310f33e4d3
--- /dev/null
+++ b/NPLib/HYDE2/THyde2TrackerData.cxx
@@ -0,0 +1,195 @@
+/*****************************************************************************
+ * 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;
+
+}
diff --git a/NPLib/HYDE2/THyde2TrackerData.h b/NPLib/HYDE2/THyde2TrackerData.h
new file mode 100644
index 0000000000000000000000000000000000000000..6768153a81831a5c9e60145cd8b675b07f03a69e
--- /dev/null
+++ b/NPLib/HYDE2/THyde2TrackerData.h
@@ -0,0 +1,471 @@
+/*****************************************************************************
+ * 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
diff --git a/NPLib/HYDE2/THyde2TrackerPhysics.cxx b/NPLib/HYDE2/THyde2TrackerPhysics.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5320b726750e056e651b6b21f7a9b1b90401f1cd
--- /dev/null
+++ b/NPLib/HYDE2/THyde2TrackerPhysics.cxx
@@ -0,0 +1,70 @@
+/*****************************************************************************
+ * 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();
+}
diff --git a/NPLib/HYDE2/THyde2TrackerPhysics.h b/NPLib/HYDE2/THyde2TrackerPhysics.h
new file mode 100644
index 0000000000000000000000000000000000000000..3da145f5cfac4114a8611fc2ae98bbc8ba2defe1
--- /dev/null
+++ b/NPLib/HYDE2/THyde2TrackerPhysics.h
@@ -0,0 +1,173 @@
+/*****************************************************************************
+ * 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