New root dicts

CMakeLists.txt

@@ -11,7 +11,7 @@ project(uLib)
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 4)
+set(PROJECT_VERSION_MINOR 5)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -79,8 +79,31 @@ include(${EIGEN3_USE_FILE})
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
-find_package(VTK CONFIG REQUIRED)
+option(CENTOS_SUPPORT "VTK definitions for CentOS" OFF)
-include(${VTK_USE_FILE})
+if(CENTOS_SUPPORT)
+    find_package(VTK CONFIG REQUIRED)
+    include(${VTK_USE_FILE})
+else()
+    find_package(VTK REQUIRED
+                     COMPONENTS CommonColor
+                                CommonCore
+                                FiltersCore
+                                FiltersModeling
+                                FiltersSources
+                                IOLegacy
+                                IOXML
+                                IOXMLParser
+                                ImagingCore
+                                InteractionStyle
+                                InteractionWidgets
+                                RenderingAnnotation
+                                RenderingContextOpenGL2
+                                RenderingCore
+                                RenderingFreeType
+                                RenderingGL2PSOpenGL2
+                                RenderingOpenGL2
+                                RenderingVolumeOpenGL2)
+endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
 set(CMAKE_REQUIRED_LIBRARIES CMAKE_REQUIRED_LIBRARIES m)

src/Math/VoxRaytracer.cpp

@@ -25,11 +25,12 @@
 
 
 #include <iostream>
-#include <unordered_map>
 
 #include "VoxRaytracer.h"
 #include "Utils.h"
 
+#define unlikely(expr) __builtin_expect(!!(expr), 0)
+
 inline float fast_sign(float f) { return 1 - 2 * (f < 0); }
 
 namespace uLib {
@@ -48,17 +49,16 @@ void VoxRaytracer::RayData::AddElement(Id_t id, float L)
 
 void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
 {
-    if (!in.m_Data.size())
+    if (unlikely(!in.m_Data.size())) {
-    {
         std::cout << "Warinig: PoCA on exit border!\n";
+        return;
     }
-    else if (!m_Data.size())
+    else if (unlikely(!m_Data.size())) {
-    {
         m_Data = in.m_Data;
         std::cout << "Warinig: PoCA on entrance border!\n";
+        return;
     }
-    else
+    else {
-    {
         // Opzione 1) un voxel in piu' //
         m_Data.reserve(m_Data.size() + in.m_Data.size());
         m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
@@ -82,22 +82,16 @@ void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
 void VoxRaytracer::RayData::PrintSelf(std::ostream &o)
 {
     o << "Ray: total lenght " << m_TotalLength << "\n";
-    for(std::vector<Element>::iterator it = m_Data.begin(); it < m_Data.end(); ++it)
+    std::vector<Element>::iterator it;
-    {
+    for(it = m_Data.begin(); it < m_Data.end(); ++it)
         o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
-    }
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
 //// RAY TRACER ////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-VoxRaytracer::VoxRaytracer(StructuredGrid &image) : m_Image(&image)
-{
-    m_scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
-               (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
-               (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
-}
 
 bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt)
 {
@@ -156,7 +150,9 @@ bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt)
 }
 
 
-VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in, const HPoint3f &out) const
+VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
+                                                       const HPoint3f &out)
+const
 {
     RayData ray;
     Vector4f pt1 = m_Image->GetLocalPoint(in);
@@ -166,33 +162,39 @@ VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in, const
     float l = s.head(3).norm();
     Vector3f L(l/s(0), l/s(1), l/s(2));
 
+    // Vector3f scale; // FIXXX
+    // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+    //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+    //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+
     Vector3f offset;
-    for(int i=0;i<3;++i)
+    for(int i=0;i<3;++i) offset(i) = (s(i)>=0) - (pt1(i)-floor(pt1(i))) ;
-    {
-        offset(i) = (s(i)>=0) - (pt1(i)-floor(pt1(i)));
-    }
     offset = offset.cwiseProduct(L).cwiseAbs();
     L = L.cwiseAbs();
 
     //---- Check if the ray only crosses one voxel
     Vector3i vid = m_Image->Find(in);
-    if (vid == m_Image->Find(out))
+    if(vid == m_Image->Find(out)){
-    {
       ray.AddElement(m_Image->Map(vid),s.norm());
       return ray;
     }
 
     //---- Otherwise, loop until ray is finished
     int id; float d;
-    while (l>0)
+    while(l>0){
-    {
+
       d = offset.minCoeff(&id);
 
-        if (m_Image->IsInsideGrid(vid))
+      if(m_Image->IsInsideGrid(vid)){
-        {
+	ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
-            ray.AddElement(m_Image->Map(vid), d * m_scale(id));
       }
 
+      // nan check //
+      //        if(unlikely(!isFinite(d * scale(id)))) {
+      //            std:: cout << "NAN in raytracer\n";
+      //            exit(1);
+      //        }
+
       vid(id) += (int)fast_sign(s(id));
 
       l -= d;
@@ -202,102 +204,11 @@ VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in, const
     return ray;
 }
 
-static int encode_v(Vector3i in)
-{
-    return ((in[0] + 1) << 4) + ((in[1] + 1) << 2) + in[2] + 1;
-}
-
-static Vector3i decode_v(int in)
-{
-    Vector3i result {
-     ((in & 48) >> 4) - 1,
-     ((in & 12) >> 2) - 1,
-     (in & 3) - 1
-    };
-    return result;
-}
-
-VoxRaytracer::RayData VoxRaytracer::BeamBetweenPoints(const HPoint3f &in, const HPoint3f &out, Vector3i thickness) const
-{
-    if (thickness[0] < 0) thickness[0] = 0;
-    if (thickness[1] < 0) thickness[1] = 0;
-    if (thickness[2] < 0) thickness[2] = 0;
-
-    Vector3i zero_v { 0, 0, 0 };
-
-    RayData ray = TraceBetweenPoints(in, out);
-    if (thickness == zero_v || ray.Data().size() == 0) return ray;
-
-    /*
-     * Calculate the forbidden relocations
-     */
-
-    std::unordered_map<int, int> ban_points(26);
-
-    Vector3i prevPos = m_Image->UnMap(ray.Data()[0].vox_id);
-    Vector3i currDir = zero_v;
-    int currLen = 1;
-
-    for (int k = 1; k < ray.Data().size(); k++)
-    {
-        Vector3i currPos = m_Image->UnMap(ray.Data()[k].vox_id);
-        Vector3i offset = currPos - prevPos;
-        prevPos = currPos;
-
-        if (k == 1) currDir = offset;
-
-        if (offset == currDir)
-        {
-            currLen++;
-            continue;
-        }
-
-        int enc_v = encode_v(currDir);
-        if (ban_points.find(enc_v) == ban_points.end())
-        {
-            ban_points.emplace(enc_v, currLen);
-        }
-        else if (currLen > ban_points[enc_v])
-        {
-            ban_points[enc_v] = currLen;
-        }
-
-        currDir = offset;
-        currLen = 2;
-    }
-
-    /*
-     * Calculate the beam section
-     */
-    std::vector<Vector3i> relocs;
-    relocs.push_back(zero_v);
-
-    /*
-     * Compose the beam
-     */
-    RayData beam;
-    for (auto iter : ray.Data())
-    {
-        Vector3i rPos = m_Image->UnMap(iter.vox_id);
-
-        for (Vector3i reloc : relocs)
-        {
-            Vector3i cPos = rPos + reloc;
-            if (!m_Image->IsInsideGrid(cPos)) continue;
-
-            beam.AddElement(m_Image->Map(cPos), iter.L);
-        }
-    }
-
-    return beam;
-}
-
-
-
 // 20150528 SV for absorbed muons
 VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
 {
     RayData ray;
+
     Vector4f pt = m_Image->GetLocalPoint(line.origin);
     Vector4f s = m_Image->GetLocalPoint(line.direction);
 
@@ -339,4 +250,4 @@ VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
     return ray;
 }
 
-} //end of namespace uLib
+}

src/Math/VoxRaytracer.h

@@ -38,8 +38,7 @@ namespace uLib {
 class VoxRaytracer {
 
 public:
-    class RayData
+    class RayData {
-    {
     public:
         RayData() : m_TotalLength(0) {}
 
@@ -63,8 +62,14 @@ public:
         Scalarf              m_TotalLength;
     };
 
-public:
+
-    VoxRaytracer(StructuredGrid &image);
+ public:
+ VoxRaytracer(StructuredGrid &image) : m_Image(&image) {
+      m_scale <<
+	(m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+	(m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+	(m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+    }
 
     bool GetEntryPoint(const HLine3f &line, HPoint3f &pt);
 
@@ -72,8 +77,6 @@ public:
 
     RayData TraceBetweenPoints(const HPoint3f &in, const HPoint3f &out) const;
 
-    RayData BeamBetweenPoints(const HPoint3f &in, const HPoint3f &out, Vector3i thickness) const;
-
     RayData TraceLine(const HLine3f &line) const;
 
     inline StructuredGrid* GetImage() const { return this->m_Image; }

src/Root/CMakeLists.txt

@@ -1,12 +1,49 @@
 set(HEADERS RootMathDense.h
             RootMuonScatter.h
-            RootHitRaw.h)
+            RootHitRaw.h
+            muCastorMCTrack.h
+            muCastorHit.h
+            muCastorInfo.h
+            muCastorSkinHit.h
+            muCastorPrimaryVertex.h
+            muCastorMuDetDIGI.h
+            SkinDetectorWriter.h)
 
-set(SOURCES ${HEADERS} RootMuonScatter.cpp)
+set(SOURCES ${HEADERS} RootMuonScatter.cpp
+                       muCastorMCTrack.cpp
+                       muCastorHit.cpp
+                       muCastorInfo.cpp
+                       muCastorSkinHit.cpp
+                       muCastorPrimaryVertex.cpp
+                       muCastorMuDetDIGI.cpp
+                       SkinDetectorWriter.cpp)
+
+set(DICTIONARY_HEADERS muCastorMCTrack.h
+                       muCastorHit.h
+                       muCastorInfo.h
+                       muCastorSkinHit.h
+                       muCastorPrimaryVertex.h
+                       muCastorMuDetDIGI.h
+                       SkinDetectorWriter.h)
 
 set(LIBRARIES ${ROOT_LIBRARIES}
               ${PACKAGE_LIBPREFIX}Math)
 
+set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
+root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}
+                         LINKDEF Linkdef.h)
+set_source_files_properties(${rDictName}.cxx
+                            PROPERTIES GENERATED TRUE)
+set_source_files_properties(${rDictName}.h
+                            PROPERTIES GENERATED TRUE)
+list(APPEND SOURCES ${rDictName}.cxx)
+
+# TODO use a custom target linked to root_generate_dictionary
+set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
+                ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
+install(FILES ${R_ARTIFACTS}
+        DESTINATION ${PACKAGE_INSTALL_LIB_DIR})
+
 set(libname ${PACKAGE_LIBPREFIX}Root)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
 set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)

src/Root/Linkdef.h

@@ -74,11 +74,13 @@ using namespace ROOT::Mutom;
 #pragma link C++ function HitRaw::Tdc() const;
 #pragma link C++ function HitRaw::Ch() const;
 
-#pragma link C++ class  muBlastMCTrack+;
-#pragma link C++ class  muBlastHit+;
 #pragma link C++ class  muCastorMCTrack+;
 #pragma link C++ class  muCastorHit+;
 #pragma link C++ class  muCastorInfo+;
+#pragma link C++ class  muCastorSkinHit+;
+#pragma link C++ class  muCastorPrimaryVertex+;
+#pragma link C++ class  muCastorMuDetDIGI+;
+#pragma link C++ class  SkinDetectorWriter+;
 
 #endif // __CINT__
 

src/Root/SkinDetectorWriter.cpp

@@ -0,0 +1,47 @@
+#include "SkinDetectorWriter.h"
+#include "muCastorSkinHit.h"
+#include "TVector3.h"
+
+SkinDetectorWriter::SkinDetectorWriter(string filename) :
+    t_file(nullptr),
+    t_tree(nullptr),
+    t_buffer(nullptr),
+    i_status(0)
+{
+    t_file = new TFile(filename.c_str(), "RECREATE");
+    t_tree = new TTree("muCastorMC", "muCastorMC");
+    t_buffer = new TClonesArray("muCastorSkinHit");
+
+    t_tree->Branch("CastorSkinHits", "TClonesArray", t_buffer, 32000, 99);
+
+    if (t_file->IsZombie()) i_status = 1;
+}
+
+SkinDetectorWriter::~SkinDetectorWriter()
+{}
+
+void SkinDetectorWriter::add(int detID, float p_x, float p_y, float p_z,
+                             float m_x, float m_y, float m_z)
+{
+    TClonesArray& ref = *t_buffer;
+    int size = ref.GetEntriesFast();
+
+    muCastorSkinHit* new_hit = new(ref[size]) muCastorSkinHit();
+    new_hit->SetDetID(detID);
+    new_hit->SetPdgCode(13);
+    new_hit->SetMotherID(-1);
+    new_hit->SetPos (TVector3(p_x, p_y, p_z));
+    new_hit->SetMom (TVector3(m_x, m_y, m_z));
+}
+
+void SkinDetectorWriter::write()
+{
+    if (t_tree->Fill() < 0) i_status = 2;
+    t_buffer->Delete();   // or t_buffer->Clear() ??
+}
+
+void SkinDetectorWriter::close()
+{
+    if (t_tree->Write() == 0) i_status = 3;
+    t_file->Close();
+}

src/Root/SkinDetectorWriter.h

@@ -0,0 +1,32 @@
+#ifndef SkinDetectorWriter_h
+#define SkinDetectorWriter_h
+
+#include <string>
+
+#include "TFile.h"
+#include "TTree.h"
+#include "TClonesArray.h"
+
+using std::string;
+
+class SkinDetectorWriter
+{
+public:
+    SkinDetectorWriter(string filename);
+    virtual ~SkinDetectorWriter();
+
+    void add(int detID, float p_x, float p_y, float p_z, float m_x, float m_y, float m_z);
+    int status() { return i_status; }
+    void write();
+    void close();
+
+private:
+    TFile* t_file;
+    TTree* t_tree;
+    TClonesArray* t_buffer;
+    int i_status;
+};
+
+
+
+#endif //SkinDetectorWriter_h

src/Root/muCastorMuDetDIGI.cpp

@@ -0,0 +1,41 @@
+/// \file muCastorMuDetDIGI.cxx 
+/// \brief Implementation of the muCastorMuDetDIGI class 
+//  This class build the DIGI for the scintillator detectors 
+/// \author G. Bonomi, M. Subieta - INFN
+
+#include <iostream>
+
+#include "muCastorMuDetDIGI.h"
+
+/// \cond CLASSIMP
+ClassImp(muCastorMuDetDIGI)
+/// \endcond
+
+using namespace std;
+
+//_____________________________________________________________________________
+muCastorMuDetDIGI::muCastorMuDetDIGI() :
+    fDetID(-1),
+    fLayID(-1),
+    fTubID(-1),
+    fDistMC(0.),
+    fDriftMC(0.),
+    fDist(0.),
+    fDrift(0.),
+    fEnergy(0.)
+{}
+
+//_____________________________________________________________________________
+muCastorMuDetDIGI::~muCastorMuDetDIGI() 
+{}
+
+//_____________________________________________________________________________
+void muCastorMuDetDIGI::Print(const Option_t* /*opt*/) const
+{
+    cout << "  DetID: " << fDetID
+         << "  LayID: " << fLayID
+         << "  TubID: " << fTubID
+         << "  energy deposit (keV): " << fEnergy
+         << endl;
+}
+

src/Root/muCastorMuDetDIGI.h

@@ -0,0 +1,75 @@
+#ifndef muCastor_MuDetDIGI_H
+#define muCastor_MuDetDIGI_H
+
+/// \file muCastorMuDetDIGI.h
+/// \brief Definition of the muCastorMuDetDIGI class 
+///
+/// \authors G. Bonomi, M. Subieta - INFN
+
+#include <TObject.h>
+
+class muCastorMuDetDIGI : public TObject
+{
+public:
+    muCastorMuDetDIGI();
+    virtual ~muCastorMuDetDIGI();
+
+    // -------> PUBLIC FUNCTIONS
+    virtual void Print(const Option_t* option = "") const;
+
+    // -------> SET METHODS
+
+    /// Set Det ID (Detector module)
+    void SetDetID(Int_t id)  { fDetID = id; };  
+
+    /// Set Layer ID (Layer [0,5])
+    void SetLayID(Int_t id)  { fLayID = id; };  
+
+    /// Set Tube ID (Tube inside each layer)
+    void SetTubID(Int_t id)  { fTubID = id; };  
+
+    void SetDistMC      (Double_t v)  { fDistMC = v; };
+    void SetDriftMC     (Double_t v)  { fDriftMC= v; };
+    void SetDist        (Double_t v)  { fDist   = v; };
+    void SetDrift       (Double_t v)  { fDrift  = v; };
+
+    // Set energy 
+    void SetEnergy(Double_t e)  { fEnergy = e; };
+
+    // -------> GET METHODS
+
+    /// \return The Module number
+    Int_t GetDetID() { return fDetID; };
+
+    /// \return The Layer number
+    Int_t GetLayID() { return fLayID; };
+
+    /// \return The Tube number
+    Int_t GetTubID() { return fTubID; };
+
+    Double_t GetDistMC()    { return fDistMC;   };
+    Double_t GetDriftMC()   { return fDriftMC;  };
+    Double_t GetDist()      { return fDist;     };
+    Double_t GetDrift()     { return fDrift;    };
+
+    /// \return Get energy
+    Double_t GetEnergy()   { return fEnergy; };
+
+
+    // -------> PRIVATE VARIABLES
+private:
+    Int_t      fDetID;      // Detector module ID 
+    Int_t      fLayID;      // Detector layer ID
+    Int_t      fTubID;      // Layer tube ID
+    Double_t   fDistMC;     // Minimum distance of particle tracks to the wire
+    Double_t   fDriftMC;    // Minimum drift time to the wire
+    Double_t   fDist;       // Minimum distance of particle tracks to the wire (with smearing)
+    Double_t   fDrift;      // Minimum drift time to the wire (with smearing)
+    Double_t   fEnergy;     // Energy released in the element
+
+    ClassDef(muCastorMuDetDIGI,1) //muCastorMuDetDIGI  
+};
+
+#endif //muCastorMuDetDIGI_H
+
+

src/Root/muCastorPrimaryVertex.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <limits>
+
+#include "muCastorPrimaryVertex.h"
+
+/// \cond CLASSIMP
+ClassImp(muCastorPrimaryVertex)
+/// \endcond
+
+using namespace std;
+
+//_____________________________________________________________________________
+muCastorPrimaryVertex::muCastorPrimaryVertex() {
+/// Default constructor
+    Reset();
+}
+
+//_____________________________________________________________________________
+muCastorPrimaryVertex::~muCastorPrimaryVertex()
+{
+/// Destructor
+}
+
+//_____________________________________________________________________________
+void muCastorPrimaryVertex::Reset()
+{
+    fPdgCode    = 0;
+    fVx         = std::numeric_limits<double>::quiet_NaN();
+    fVy         = std::numeric_limits<double>::quiet_NaN();
+    fVz         = std::numeric_limits<double>::quiet_NaN();
+    fPx         = std::numeric_limits<double>::quiet_NaN();
+    fPy         = std::numeric_limits<double>::quiet_NaN();
+    fPz         = std::numeric_limits<double>::quiet_NaN();
+    fE          = std::numeric_limits<double>::quiet_NaN();
+}
+
+//_____________________________________________________________________________
+void muCastorPrimaryVertex::Print(const Option_t* /*opt*/) const
+{
+/// Printing
+
+  	cout << "  Primary particle PDG Code " << fPdgCode << endl; 
+	cout << "  Vertex: (" << fVx << ", " << fVy << ", " << fVz << ") cm" << endl;
+	cout << "  Mom: (" << fPx << ", " << fPy << ", " << fPz << ")  MeV/c" << endl;
+
+}
+

src/Root/muCastorPrimaryVertex.h

@@ -0,0 +1,53 @@
+#ifndef muCastor_PVTX_H
+#define muCastor_PVTX_H
+
+/// \brief Definition of the muCastorPrimaryVertex class 
+///
+/// \authors G. Bonomi (04/02/2020)
+
+#include <TObject.h>
+
+class muCastorPrimaryVertex : public TObject
+{
+    public:
+        muCastorPrimaryVertex();
+        virtual ~muCastorPrimaryVertex();
+
+        // -------> PUBLIC FUNCTIONS
+        virtual void Print(const Option_t* option = "") const;
+
+        // -------> SET METHODS
+
+		void SetPdgCode(Int_t code) { fPdgCode = code; };
+
+        void SetVx(Double_t Vx)   { fVx = Vx; };  
+        void SetVy(Double_t Vy)   { fVy = Vy; };  
+        void SetVz(Double_t Vz)   { fVz = Vz; };  
+
+        void SetPx(Double_t Px)   { fPx = Px; };  
+        void SetPy(Double_t Py)   { fPy = Py; };  
+        void SetPz(Double_t Pz)   { fPz = Pz; };  
+
+        void SetE(Double_t E)  { fE = E; };
+
+        void Reset();
+    private:
+        // -------> PRIVATE VARIABLES
+		Int_t          fPdgCode;              // PDG code of the particle
+
+  		Double_t       fVx;                   // x of production vertex
+  		Double_t       fVy;                   // y of production vertex
+  		Double_t       fVz;                   // z of production vertex
+
+ 		Double_t       fPx;                   // x component of momentum
+  		Double_t       fPy;                   // y component of momentum
+  		Double_t       fPz;                   // z component of momentum
+  		Double_t       fE;                    // Energy
+
+
+        ClassDef(muCastorPrimaryVertex,1) //muCastorPrimaryVertex  
+};
+
+#endif //muCastor_PVTX_H
+
+

src/Root/muCastorSkinHit.cpp

@@ -0,0 +1,43 @@
+//----------------------------------------------------------
+// Class : CastorSkinHit 
+// Date: October 2020
+// Author: Germano Bonomi   germano.bonomi@unibs.it
+//----------------------------------------------------------
+
+#include <iostream>
+
+#include "muCastorSkinHit.h"
+
+/// \cond CLASSIMP
+ClassImp(muCastorSkinHit)
+/// \endcond
+
+using namespace std;
+
+//_____________________________________________________________________________
+muCastorSkinHit::muCastorSkinHit() :
+    fDetID(-1),
+    fPdgCode(-1),
+    fMotherID(-1),
+    fMomX(0.),
+    fMomY(0.),
+    fMomZ(0.),
+    fPosX(0.),
+    fPosY(0.),
+    fPosZ(0.)
+{}
+
+//_____________________________________________________________________________
+muCastorSkinHit::~muCastorSkinHit() 
+{}
+//_____________________________________________________________________________
+void muCastorSkinHit::Print(const Option_t* /*opt*/) const
+{
+    cout << "  detID: " << fDetID 
+         << "  position (cm): (" 
+         << fPosX << ", " << fPosY << ", " << fPosZ << ")"
+         << "  momentum (MeV/c): (" 
+         << fMomX << ", " << fMomY << ", " << fMomZ << ")"
+         << endl;
+}
+

src/Root/muCastorSkinHit.h

@@ -0,0 +1,52 @@
+//----------------------------------------------------------
+// Class : CastorSkinHit 
+// Date: October 2020
+// Author: Germano Bonomi   germano.bonomi@unibs.it
+//----------------------------------------------------------
+
+#ifndef muCastor_SKINHIT_H
+#define muCastor_SKINHIT_H
+
+
+#include <TObject.h>
+#include <TVector3.h>
+
+class muCastorSkinHit : public TObject
+{
+public:
+    muCastorSkinHit();
+    virtual ~muCastorSkinHit();
+
+    // methods
+    virtual void Print(const Option_t* option = "") const;
+
+    // set methods
+    void SetDetID(Int_t id)         { fDetID = id; };  
+    void SetPdgCode(Int_t pdg)      { fPdgCode = pdg; };
+    void SetMotherID(Int_t mid)     { fMotherID = mid; };
+    void SetMom(TVector3 xyz)       { fMomX = xyz.X(); fMomY = xyz.Y(); fMomZ = xyz.Z(); };
+    void SetPos(TVector3 xyz)       { fPosX = xyz.X(); fPosY = xyz.Y(); fPosZ = xyz.Z(); };
+
+    Int_t GetDetID()    { return fDetID; }
+    Int_t GetPdgCode()  { return fPdgCode; }
+    Int_t GetMotherID() { return fMotherID; }
+    TVector3 GetMom()   { return TVector3(fMomX, fMomY, fMomZ); }
+    TVector3 GetPos()   { return TVector3(fPosX, fPosY, fPosZ); }
+      
+private:
+    Int_t      fDetID;      // Detector module ID 
+    Int_t      fPdgCode;    // Particle PDG Code
+    Int_t      fMotherID;   // Particle mother ID (-1 = primary, 0 = secondary, etc..)
+    Double_t   fMomX;       // Track momentum when releasing the hit (X)
+    Double_t   fMomY;       // Track momentum when releasing the hit (Y)
+    Double_t   fMomZ;       // Track momentum when releasing the hit (Z)
+    Double_t   fPosX;       // Hit coordinates (at the entrance of the detector) (X)
+    Double_t   fPosY;       // Hit coordinates (at the entrance of the detector) (Y)
+    Double_t   fPosZ;       // Hit coordinates (at the entrance of the detector) (Z)
+    
+    ClassDef(muCastorSkinHit,1) //muCastorSkinHit  
+};
+
+#endif //muCastort_SKINHIT_H
+
+