Support for user defined sensitive detectors; new TVirtualMC::NIELEdep(); clean-up:

Details:
- Added support for user defined sensitive detectors
  o TVirtualMCSensitiveDetector: the interface class for a user sensitive detector
  o New functions in TVirtualMC:
     void SetSensitiveDetector(const TString &volName, TVirtualMCSensitiveDetector *sd);
     TVirtualMCSensitiveDetector *GetSensitiveDetector(const TString &volName) const;
     void SetExclusiveSDScoring(Bool_t exclusiveSDScoring);
  o New function in TVirtualMCApplication:
     void ConstructSensitiveDetectors();
- Added new TVirtualMC::NIELEdep() function
- Removed default implementation for  TVirtualMC::TrackPosition/Momentum with Float_t arguments

Author: ihrivnac

montecarlo/vmc/inc/LinkDef.h

@@ -14,16 +14,12 @@
 #pragma link C++ enum EMCOpSurfaceType;
 #pragma link C++ enum EMCOpSurfaceFinish;
 
-#pragma link C++ class  TVirtualMC+;
-#pragma link C++ class  TVirtualMCGeometry+;
-#pragma link C++ class  TVirtualMCApplication+;
-#pragma link C++ class  TVirtualMCStack+;
-#pragma link C++ class  TMCVerbose+;
-#pragma link C++ class  TGeoMCGeometry+;
+#pragma link C++ class TVirtualMC + ;
+#pragma link C++ class TVirtualMCGeometry + ;
+#pragma link C++ class TVirtualMCApplication + ;
+#pragma link C++ class TVirtualMCSensitiveDetector + ;
+#pragma link C++ class TVirtualMCStack + ;
+#pragma link C++ class TMCVerbose + ;
+#pragma link C++ class TGeoMCGeometry + ;
 
 #endif
-
-
-
-
-

montecarlo/vmc/inc/TVirtualMC.h

@@ -37,6 +37,7 @@ class TLorentzVector;
 class TGeoHMatrix;
 class TArrayI;
 class TArrayD;
+class TVirtualMCSensitiveDetector;
 
 class TVirtualMC : public TNamed {
 
@@ -435,6 +436,26 @@ class TVirtualMC : public TNamed {
    /// Return the copyNo of i-th daughter of the volume specified by volName
    virtual Int_t        VolDaughterCopyNo(const char* volName, Int_t i) const = 0;
 
+   //
+   // ------------------------------------------------
+   // methods for sensitive detectors
+   // ------------------------------------------------
+   //
+
+   /// Set a sensitive detector to a volume
+   /// - volName - the volume name
+   /// - sd - the user sensitive detector
+   virtual void SetSensitiveDetector(const TString &volName, TVirtualMCSensitiveDetector *sd);
+
+   /// Get a sensitive detector of a volume
+   /// - volName - the volume name
+   virtual TVirtualMCSensitiveDetector *GetSensitiveDetector(const TString &volName) const;
+
+   /// The scoring option:
+   /// if true, scoring is performed only via user defined sensitive detectors and
+   /// MCApplication::Stepping is not called
+   virtual void SetExclusiveSDScoring(Bool_t exclusiveSDScoring);
+
    //
    // ------------------------------------------------
    // methods for physics management
@@ -695,7 +716,7 @@ class TVirtualMC : public TNamed {
 
    /// Return the current position in the master reference frame of the
    /// track being transported (as float)
-   virtual void TrackPosition(Float_t &x, Float_t &y, Float_t &z) const;
+   virtual void TrackPosition(Float_t &x, Float_t &y, Float_t &z) const =0;
 
    /// Return the direction and the momentum (GeV/c) of the track
    /// currently being transported
@@ -707,7 +728,7 @@ class TVirtualMC : public TNamed {
 
    /// Return the direction and the momentum (GeV/c) of the track
    /// currently being transported (as float)
-   virtual void TrackMomentum(Float_t &px, Float_t &py, Float_t &pz, Float_t &etot) const;
+   virtual void TrackMomentum(Float_t &px, Float_t &py, Float_t &pz, Float_t &etot) const =0;
 
    /// Return the length in centimeters of the current step (in cm)
    virtual Double_t TrackStep() const =0;
@@ -721,6 +742,9 @@ class TVirtualMC : public TNamed {
    /// Return the energy lost in the current step
    virtual Double_t Edep() const =0;
 
+   /// Return the non-ionising energy lost (NIEL) in the current step
+   virtual Double_t NIELEdep() const;
+
    //
    // get methods
    // tracking particle
@@ -888,18 +912,41 @@ class TVirtualMC : public TNamed {
 
 // inline functions (with temorary implementation)
 
-inline void TVirtualMC::TrackPosition(Float_t & /*x*/, Float_t & /*y*/, Float_t & /*z*/) const
+inline void TVirtualMC::SetSensitiveDetector(const TString &/*volName*/, TVirtualMCSensitiveDetector */*sd*/)
 {
-   /// Return the current position in the master reference frame of the
-   /// track being transported (as float)
-   Warning("TrackPosition(Float_t& ...)", "New function - not yet implemented.");
+   /// Set a sensitive detector to a volume
+   /// - volName - the volume name
+   /// - sd - the user sensitive detector
+
+   Warning("SetSensitiveDetector(...)", "New function - not yet implemented.");
 }
 
-inline void TVirtualMC::TrackMomentum(Float_t & /*px*/, Float_t & /*py*/, Float_t & /*pz*/, Float_t & /*etot*/) const
+inline TVirtualMCSensitiveDetector *TVirtualMC::GetSensitiveDetector(const TString &/*volName*/) const
 {
-   /// Return the direction and the momentum (GeV/c) of the track
-   /// currently being transported (as float)
-   Warning("TrackPosition(Float_t& ...)", "New function - not yet implemented.");
+   /// Get a sensitive detector of a volume
+   /// - volName - the volume name
+
+   Warning("GetSensitiveDetector()", "New function - not yet implemented.");
+
+   return 0;
+}
+
+inline void TVirtualMC::SetExclusiveSDScoring(Bool_t /*exclusiveSDScoring*/)
+{
+   /// The scoring option:
+   /// if true, scoring is performed only via user defined sensitive detectors and
+   /// MCApplication::Stepping is not called
+
+   Warning("SetExclusiveSDScoring(...)", "New function - not yet implemented.");
+}
+
+inline Double_t TVirtualMC::NIELEdep() const
+{
+   /// Return the non-ionising energy lost (NIEL) in the current step
+
+   Warning("NIELEdep()", "New function - not yet implemented.");
+
+   return 0.;
 }
 
 #define gMC (TVirtualMC::GetMC())

montecarlo/vmc/inc/TVirtualMCApplication.h

@@ -51,6 +51,9 @@ class TVirtualMCApplication : public TNamed {
    /// Define parameters for optical processes (optional)
    virtual void ConstructOpGeometry() {}
 
+   /// Define sensitive detectors (optional)
+   virtual void ConstructSensitiveDetectors() {}
+
    /// Initialize geometry
    /// (Usually used to define sensitive volumes IDs)
    virtual void InitGeometry() = 0;

montecarlo/vmc/inc/TVirtualMCSensitiveDetector.h

@@ -0,0 +1,58 @@
+// @(#)root/vmc:$Id$
+// Authors: Ivana Hrivnacova 19/04/2018
+
+/*************************************************************************
+ * Copyright (C) 2006, Rene Brun and Fons Rademakers.                    *
+ * Copyright (C) 2018 ALICE Experiment at CERN.                          *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#ifndef ROOT_TVirtualMCSensitiveDetector
+#define ROOT_TVirtualMCSensitiveDetector
+
+// Class TVirtualMCSensitiveDetector
+// ---------------------------------
+// Interface to a user defined particles stack.
+//
+
+#include "TNamed.h"
+
+class TParticle;
+
+class TVirtualMCSensitiveDetector : public TNamed {
+
+public:
+   // Constructor
+   TVirtualMCSensitiveDetector(const char *name, const char *title = "");
+   TVirtualMCSensitiveDetector(const TString &name, const TString &title = "");
+
+   // Destructor
+   virtual ~TVirtualMCSensitiveDetector();
+
+   /// Initialize detector.
+   /// Called at initialization of geometry before MCApplication::InitGeometry().
+   virtual void Initialize() = 0;
+
+   /// Process hits.
+   /// Called at each step when track pass through the associated volume
+   virtual void ProcessHits() = 0;
+
+   /// End of event.
+   /// Called at end of event before MCApplication::FinishEvent().
+   virtual void EndOfEvent() = 0;
+
+protected:
+   // Default constructor
+   TVirtualMCSensitiveDetector();
+   // Copy constructor
+   TVirtualMCSensitiveDetector(const TVirtualMCSensitiveDetector &rhs);
+   // Assignment constructor
+   TVirtualMCSensitiveDetector &operator=(const TVirtualMCSensitiveDetector &rhs);
+
+   ClassDef(TVirtualMCSensitiveDetector, 1) // Interface to a user sensitive detector
+};
+
+#endif // ROOT_TVirtualMCSensitiveDetector

montecarlo/vmc/src/TVirtualMCSensitiveDetector.cxx

@@ -0,0 +1,69 @@
+// @(#)root/vmc:$Id$
+// Authors: Ivana Hrivnacova 19/04/2018
+
+/*************************************************************************
+ * Copyright (C) 2006, Rene Brun and Fons Rademakers.                    *
+ * Copyright (C) 2018, ALICE Experiment at CERN.                         *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#include "TVirtualMCSensitiveDetector.h"
+
+/** \class TVirtualMCSensitiveDetector
+    \ingroup vmc
+
+Interface to a user defined sensitive detector.
+*/
+
+ClassImp(TVirtualMCSensitiveDetector);
+
+////////////////////////////////////////////////////////////////////////////////
+/// Standard constructor
+
+TVirtualMCSensitiveDetector::TVirtualMCSensitiveDetector(const char *name, const char *title) : TNamed(name, title) {}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Standard constructor
+
+TVirtualMCSensitiveDetector::TVirtualMCSensitiveDetector(const TString &name, const TString &title)
+   : TNamed(name, title)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Default constructor
+
+TVirtualMCSensitiveDetector::TVirtualMCSensitiveDetector() : TNamed() {}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Copy constructor
+
+TVirtualMCSensitiveDetector::TVirtualMCSensitiveDetector(const TVirtualMCSensitiveDetector &rhs) : TNamed(rhs)
+{
+   /// Copy constructor
+
+   *this = rhs;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Destructor
+
+TVirtualMCSensitiveDetector::~TVirtualMCSensitiveDetector() {}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Assignment operator
+
+TVirtualMCSensitiveDetector &TVirtualMCSensitiveDetector::operator=(const TVirtualMCSensitiveDetector &rhs)
+{
+   // check assignment to self
+   if (this == &rhs)
+      return *this;
+
+   // base class assignment
+   TNamed::operator=(rhs);
+
+   return *this;
+}