Import Geant4 10.0.0 source tree

source/tracking/CMakeLists.txt

@@ -7,7 +7,7 @@
 #
 # Generated on : 24/9/2010
 #
-# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:11:07 bmorgan Exp $
+# $Id: CMakeLists.txt 66821 2013-01-12 16:22:43Z gcosmo $
 #
 #------------------------------------------------------------------------------
 

source/tracking/GNUmakefile

@@ -1,4 +1,4 @@
-# $Id: GNUmakefile,v 1.7 2010-10-27 07:57:21 gcosmo Exp $
+# $Id: GNUmakefile 77241 2013-11-22 09:55:47Z gcosmo $
 # ----------------------------------------------------------
 # GNUmakefile for tracking library.  Katsuya Amako, 5/9/95.
 # ----------------------------------------------------------
@@ -23,6 +23,7 @@ CPPFLAGS += -I$(G4BASE)/global/management/include \
             -I$(G4BASE)/geometry/management/include \
             -I$(G4BASE)/geometry/volumes/include \
             -I$(G4BASE)/geometry/navigation/include \
+            -I$(G4BASE)/geometry/magneticfield/include \
             -I$(G4BASE)/geometry/solids/CSG/include \
             -I$(G4BASE)/track/include \
             -I$(G4BASE)/materials/include \

source/tracking/History

@@ -1,5 +1,4 @@
-$Id: History,v 1.147 2010-11-18 17:24:22 allison Exp $
-$Name: not supported by cvs2svn $ 
+$Id: History 78003 2013-12-02 08:26:54Z gcosmo $
 -------------------------------------------------------------------
 
      =========================================================
@@ -18,6 +17,53 @@ committal in the CVS repository !
      * Reverse chronological order (last date on top), please *
      ----------------------------------------------------------
 
+29th November2013 M.Asai (tracking-V09-06-10)
+- G4VTrajectory::ShowTrajectory() : add missing \\n.
+
+28th November2013 M.Asai (tracking-V09-06-09)
+- G4SteppingManager::fTouchableHistory data member is cleared in the
+  destructor to avoid double-deletion in MT mode.
+
+21st November2013 J.Perl (tracking-V09-06-08)
+- G4TrackingManager : Add handling for StoreTrajectory new case 4
+
+21st November2013 M.Asai (tracking-V09-06-07)
+- G4TrackingMessenger : Move invokation with G4TransportationManager 
+  in G4VisCommandsSceneAdd.cc to this G4TrakingMessenger. 
+  Since G4TransportationManager is thread-local,
+  G4VisCommandsSceneAdd.cc cannot access to G4TransportationManager.
+
+3rd November2013 L.Desorgher (tracking-V09-06-06)
+-G4AdjointTrackingAction. Change order of initialization in constructor to 
+  avoid compilation warning.
+
+31th October2013 L.Desorgher (tracking-V09-06-05)
+-Create G4AdjointTrackingAction and modify G4AdjointSteppingAction in order to 
+treat the reverse tracking of an adjoint particle and tracking of its 
+equivalent forward particle in the same event.This is requested for the 
+migration of the ReverseMC to the MT mode.  
+
+29th August 2013 M.Asai (tracking-V09-06-04)
+- Add protection against null pointer for the process manager of
+  secondaries in case secondaries are generated at zero kinetic energy.
+
+11th April 2013 G.Cosmo (tracking-V09-06-03)
+- Cleanup of automatic changes for MT in classes: G4RichTrajectory,
+  G4RichTrajectoryPoint, G4SmoothTrajectory, G4SmoothTrajectoryPoint,
+  G4Trajectory, G4TrajectoryPoint.
+
+5th February 2013 Takashi Sasaki (tracking-V09-06-02)
+- Fix for the problem report #1397. More than two AtRest
+  processes are allowed. Needs checks for the results.
+
+11th January 2013  Gabriele Cosmo (tracking-V09-06-01)
+- Replace plain printout to cerr with G4Exception warning in
+  G4SteppingManager::InvokeAtRestDoItProcs().
+  Addressing problem report #1421.
+
+3rd December 2012  John Allison (tracking-V09-06-00)
+- Removed DrawTrajectory(G4int i_mode).
+
 26 October 2012 Laurent Desorgher (tracking-V09-05-04)
 - G4AdointSteppingAction.cc. Add test for adjoint particle reaching "out_of_the_world".
  

source/tracking/include/G4AdjointCrossSurfChecker.hh

@@ -23,7 +23,7 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
-// $Id$
+// $Id: G4AdjointCrossSurfChecker.hh 66872 2013-01-15 01:25:57Z japost $
 //
 /////////////////////////////////////////////////////////////////////////////////
 //      Class Name:	G4AdjointCrossSurfChecker
@@ -91,7 +91,7 @@ class G4AdjointCrossSurfChecker
    G4int FindRegisteredSurface(const G4String& name);
    
  private: 
-   static G4AdjointCrossSurfChecker* instance;
+   static G4ThreadLocal G4AdjointCrossSurfChecker* instance;
   
    std::vector<G4String> ListOfSurfaceName;
    std::vector<G4String> ListOfSurfaceType;

source/tracking/include/G4AdjointSteppingAction.hh

@@ -23,7 +23,7 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
-// $Id$
+// $Id: G4AdjointSteppingAction.hh 75570 2013-11-04 11:41:10Z gcosmo $
 //
 /////////////////////////////////////////////////////////////////////////////////
 //      Class Name:	G4AdjointSteppingAction
@@ -83,8 +83,11 @@ class G4AdjointSteppingAction : public G4UserSteppingAction
     inline G4double GetLastWeight(){return last_weight;}
     inline void SetPrimWeight(G4double weight){prim_weight=weight;} 
     inline G4ParticleDefinition* GetLastPartDef(){return last_part_def;}
-    inline void SetUserAdjointSteppingAction( G4UserSteppingAction* anAction) {theUserAdjointSteppingAction = anAction;}
-     
+    inline void SetUserAdjointSteppingAction( G4UserSteppingAction* anAction) {
+    	                               theUserAdjointSteppingAction = anAction;}
+    inline void SetUserForwardSteppingAction( G4UserSteppingAction* anAction) {
+    	                                  theUserFwdSteppingAction = anAction;}
+    inline void SetAdjointTrackingMode(G4bool aBool){is_adjoint_tracking_mode =aBool;}
   private:
 
     G4double ext_sourceEMax;
@@ -98,6 +101,8 @@ class G4AdjointSteppingAction : public G4UserSteppingAction
     G4double prim_weight ;
     G4ParticleDefinition* last_part_def;
     G4UserSteppingAction* theUserAdjointSteppingAction;
+    G4UserSteppingAction* theUserFwdSteppingAction;
+    G4bool is_adjoint_tracking_mode;
 
 };
 #endif

source/tracking/include/G4AdjointTrackingAction.hh

@@ -0,0 +1,102 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+// $Id: G4AdjointTrackingAction.hh 75409 2013-11-01 00:31:00Z ldesorgh$
+//
+//
+//---------------------------------------------------------------
+//
+// G4AdjointTrackingAction.hh
+//
+// class description:
+//   This class represents actions taken place at the
+//   the start/end point of processing one track during an adjoint simulation
+//
+//---------------------------------------------------------------
+
+
+
+#ifndef G4AdjointTrackingAction_h
+#define G4AdjointTrackingAction_h 1
+#include "globals.hh"
+#include "G4UserTrackingAction.hh"
+#include "G4ThreeVector.hh"
+class G4AdjointSteppingAction;
+class G4Track;
+///////////////////////////
+class G4AdjointTrackingAction : public G4UserTrackingAction
+///////////////////////////
+{
+
+//--------
+public: // with description
+//--------
+
+// Constructor & Destructor
+   G4AdjointTrackingAction(G4AdjointSteppingAction* anAction);
+   virtual ~G4AdjointTrackingAction();
+
+// Member functions
+   virtual void PreUserTrackingAction(const G4Track*);
+   virtual void PostUserTrackingAction(const G4Track*);
+   void RegisterAtEndOfAdjointTrack();
+
+//inline methods
+   inline void SetUserForwardTrackingAction(G4UserTrackingAction* anAction){
+	   	   	               theUserFwdTrackingAction = anAction;}
+   inline G4ThreeVector GetPositionAtEndOfLastAdjointTrack(){ return last_pos;}
+   inline G4ThreeVector GetDirectionAtEndOfLastAdjointTrack(){ return last_direction;}
+   inline G4double GetEkinAtEndOfLastAdjointTrack(){ return last_ekin;}
+   inline G4double GetEkinNucAtEndOfLastAdjointTrack(){ return last_ekin_nuc;}
+   inline G4double GetWeightAtEndOfLastAdjointTrack(){return last_weight;}
+   inline G4double GetCosthAtEndOfLastAdjointTrack(){return last_cos_th;}
+   inline const G4String& GetFwdParticleNameAtEndOfLastAdjointTrack(){return last_fwd_part_name;}
+   inline G4int GetFwdParticlePDGEncodingAtEndOfLastAdjointTrack(){return last_fwd_part_PDGEncoding;}
+
+
+private:
+   G4AdjointSteppingAction* theAdjointSteppingAction;
+   G4UserTrackingAction* theUserFwdTrackingAction;
+   G4bool is_adjoint_tracking_mode;
+
+
+   //adjoint particle information on the external surface
+   //-----------------------------
+   G4ThreeVector last_pos;
+   G4ThreeVector last_direction;
+   G4double last_ekin,last_ekin_nuc; //last_ekin_nuc=last_ekin/nuc, nuc is 1 if not a nucleus
+   G4double last_cos_th;
+   G4String last_fwd_part_name;
+   G4int  last_fwd_part_PDGEncoding;
+   G4double last_weight;
+   G4int ID_of_last_particle_that_reach_the_ext_source;
+
+
+};
+
+#endif
+
+

source/tracking/include/G4RichTrajectory.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4RichTrajectory.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -56,8 +56,8 @@
 #ifndef G4RICHTRAJECTORY_HH
 #define G4RICHTRAJECTORY_HH
 
+#include "trkgdefs.hh"
 #include "G4Trajectory.hh"
-
 #include "G4TouchableHandle.hh"
 
 typedef std::vector<G4VTrajectoryPoint*>  RichTrajectoryPointsContainer;
@@ -83,6 +83,8 @@ public:
   {return (this==&right);} 
   
   // Other (virtual) member functions
+  void ShowTrajectory(std::ostream& os=G4cout) const;
+  void DrawTrajectory() const;
   void AppendStep(const G4Step* aStep);
   void MergeTrajectory(G4VTrajectory* secondTrajectory);
   int GetPointEntries() const { return fpRichPointsContainer->size(); }
@@ -107,25 +109,19 @@ private:
 
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-extern G4DLLEXPORT G4Allocator<G4RichTrajectory>
-aRichTrajectoryAllocator;
-#else
-extern G4DLLIMPORT G4Allocator<G4RichTrajectory>
-aRichTrajectoryAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4RichTrajectory> *aRichTrajectoryAllocator;
 
 inline void* G4RichTrajectory::operator new(size_t)
 {
-  void* aRichTrajectory;
-  aRichTrajectory = (void*)aRichTrajectoryAllocator.MallocSingle();
-  return aRichTrajectory;
+  if (!aRichTrajectoryAllocator)
+  { aRichTrajectoryAllocator = new G4Allocator<G4RichTrajectory>; }
+  return (void*)aRichTrajectoryAllocator->MallocSingle();
 }
 
 inline void G4RichTrajectory::operator delete(void* aRichTrajectory)
 {
-  aRichTrajectoryAllocator.FreeSingle
-    ((G4RichTrajectory*)aRichTrajectory);
+  aRichTrajectoryAllocator->FreeSingle((G4RichTrajectory*)aRichTrajectory);
 }
 
 #endif

source/tracking/include/G4RichTrajectoryPoint.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4RichTrajectoryPoint.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -57,12 +57,13 @@
 #ifndef G4RICHTRAJECTORYPOINT_HH
 #define G4RICHTRAJECTORYPOINT_HH
 
-#include "G4TrajectoryPoint.hh"
+#include <vector>
 
+#include "trkgdefs.hh"
+#include "G4TrajectoryPoint.hh"
 #include "G4TouchableHandle.hh"
 #include "G4ThreeVector.hh"
 #include "G4StepStatus.hh"
-#include <vector>
 
 class G4Track;
 class G4Step;
@@ -116,28 +117,20 @@ private:
   G4double fPostStepPointWeight;
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-extern G4DLLEXPORT G4Allocator<G4RichTrajectoryPoint>
-aRichTrajectoryPointAllocator;
-#else
-extern G4DLLIMPORT G4Allocator<G4RichTrajectoryPoint>
-aRichTrajectoryPointAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4RichTrajectoryPoint> *aRichTrajectoryPointAllocator;
 
 inline void* G4RichTrajectoryPoint::operator new(size_t)
 {
-  void *aRichTrajectoryPoint;
-  aRichTrajectoryPoint =
-    (void *) aRichTrajectoryPointAllocator.MallocSingle();
-  return aRichTrajectoryPoint;
+  if (!aRichTrajectoryPointAllocator)
+  { aRichTrajectoryPointAllocator = new G4Allocator<G4RichTrajectoryPoint>; }
+  return (void *) aRichTrajectoryPointAllocator->MallocSingle();
 }
 
-inline void G4RichTrajectoryPoint::operator delete
-(void *aRichTrajectoryPoint)
+inline void G4RichTrajectoryPoint::operator delete(void *aRichTrajectoryPoint)
 {
-  aRichTrajectoryPointAllocator.FreeSingle
+  aRichTrajectoryPointAllocator->FreeSingle
     ((G4RichTrajectoryPoint *) aRichTrajectoryPoint);
 }
 
 #endif
-

source/tracking/include/G4SmoothTrajectory.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SmoothTrajectory.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -47,20 +47,23 @@ class G4SmoothTrajectory;
 #ifndef G4SmoothTrajectory_h
 #define G4SmoothTrajectory_h 1
 
+#include <stdlib.h>                   // Include from 'system'
+#include <vector>
+
+#include "trkgdefs.hh"
 #include "G4VTrajectory.hh"
 #include "G4Allocator.hh"
-#include <stdlib.h>                 // Include from 'system'
-#include "G4ios.hh"               // Include from 'system'
-#include <vector>            // G4RWTValOrderedVector
-#include "globals.hh"               // Include from 'global'
-#include "G4ParticleDefinition.hh"  // Include from 'particle+matter'
-#include "G4SmoothTrajectoryPoint.hh"     // Include from 'tracking'
+#include "G4ios.hh"                   // Include from 'system'
+#include "globals.hh"                 // Include from 'global'
+#include "G4ParticleDefinition.hh"    // Include from 'particle+matter'
+#include "G4SmoothTrajectoryPoint.hh" // Include from 'tracking'
 #include "G4Track.hh"
 #include "G4Step.hh"
 
-class G4Polyline;                   // Forward declaration.
+class G4Polyline;                     // Forward declaration
 
 typedef std::vector<G4VTrajectoryPoint*>  TrajectoryPointContainer;
+
 class G4SmoothTrajectory : public G4VTrajectory
 {
 
@@ -104,8 +107,7 @@ public:
 
 // Other member functions
    virtual void ShowTrajectory(std::ostream& os=G4cout) const;
-   //virtual void DrawTrajectory() const;
-   virtual void DrawTrajectory(G4int i_mode = 0) const;
+   virtual void DrawTrajectory() const;
    virtual void AppendStep(const G4Step* aStep);
    virtual int GetPointEntries() const { return positionRecord->size(); }
    virtual G4VTrajectoryPoint* GetPoint(G4int i) const 
@@ -133,22 +135,19 @@ public:
 
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-  extern G4DLLEXPORT G4Allocator<G4SmoothTrajectory> aSmoothTrajectoryAllocator;
-#else
-  extern G4DLLIMPORT G4Allocator<G4SmoothTrajectory> aSmoothTrajectoryAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4SmoothTrajectory> *aSmoothTrajectoryAllocator;
 
 inline void* G4SmoothTrajectory::operator new(size_t)
 {
-  void* aTrajectory;
-  aTrajectory = (void*)aSmoothTrajectoryAllocator.MallocSingle();
-  return aTrajectory;
+  if (!aSmoothTrajectoryAllocator)
+  { aSmoothTrajectoryAllocator = new G4Allocator<G4SmoothTrajectory>; }
+  return (void*)aSmoothTrajectoryAllocator->MallocSingle();
 }
 
 inline void G4SmoothTrajectory::operator delete(void* aTrajectory)
 {
-  aSmoothTrajectoryAllocator.FreeSingle((G4SmoothTrajectory*)aTrajectory);
+  aSmoothTrajectoryAllocator->FreeSingle((G4SmoothTrajectory*)aTrajectory);
 }
 
 #endif

source/tracking/include/G4SmoothTrajectoryPoint.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SmoothTrajectoryPoint.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -38,6 +38,7 @@
 #ifndef G4SmoothTrajectoryPoint_h
 #define G4SmoothTrajectoryPoint_h 1
 
+#include "trkgdefs.hh"
 #include "G4VTrajectoryPoint.hh"
 #include "globals.hh"                // Include from 'global'
 #include "G4ThreeVector.hh"          // Include from 'geometry'
@@ -54,7 +55,7 @@ public: // without description
 // Constructor/Destructor
    G4SmoothTrajectoryPoint();
    // No auxiliary points setter, so must set the points in the
-   // constructor already (jacek 31/10/2002)
+   // constructor already
    G4SmoothTrajectoryPoint(G4ThreeVector pos,
 			   std::vector<G4ThreeVector>* auxiliaryPoints);
    G4SmoothTrajectoryPoint(G4ThreeVector pos);
@@ -91,23 +92,19 @@ public:
    std::vector<G4ThreeVector>* fAuxiliaryPointVector;
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-  extern G4DLLEXPORT G4Allocator<G4SmoothTrajectoryPoint> aSmoothTrajectoryPointAllocator;
-#else
-  extern G4DLLIMPORT G4Allocator<G4SmoothTrajectoryPoint> aSmoothTrajectoryPointAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4SmoothTrajectoryPoint> *aSmoothTrajectoryPointAllocator;
 
 inline void* G4SmoothTrajectoryPoint::operator new(size_t)
 {
-   void *aTrajectoryPoint;
-   aTrajectoryPoint = (void *) aSmoothTrajectoryPointAllocator.MallocSingle();
-   return aTrajectoryPoint;
+  if (!aSmoothTrajectoryPointAllocator)
+  { aSmoothTrajectoryPointAllocator= new G4Allocator<G4SmoothTrajectoryPoint>; }
+  return (void *) aSmoothTrajectoryPointAllocator->MallocSingle();
 }
 
 inline void G4SmoothTrajectoryPoint::operator delete(void *aTrajectoryPoint)
 {
-   aSmoothTrajectoryPointAllocator.FreeSingle((G4SmoothTrajectoryPoint *) aTrajectoryPoint);
+  aSmoothTrajectoryPointAllocator->FreeSingle((G4SmoothTrajectoryPoint *) aTrajectoryPoint);
 }
 
 #endif
-

source/tracking/include/G4SteppingManager.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SteppingManager.hh 66241 2012-12-13 18:34:42Z gunter $
 // 
 //---------------------------------------------------------------
 //

source/tracking/include/G4SteppingVerbose.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SteppingVerbose.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/include/G4TrackingManager.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrackingManager.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/include/G4TrackingMessenger.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrackingMessenger.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/include/G4Trajectory.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4Trajectory.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -51,20 +51,23 @@ class G4Trajectory;
 #ifndef G4Trajectory_h
 #define G4Trajectory_h 1
 
+#include <stdlib.h>                 // Include from 'system'
+#include <vector>
+
+#include "trkgdefs.hh"
 #include "G4VTrajectory.hh"
 #include "G4Allocator.hh"
-#include <stdlib.h>                 // Include from 'system'
-#include "G4ios.hh"               // Include from 'system'
-#include <vector>            // G4RWTValOrderedVector
+#include "G4ios.hh"                 // Include from 'system'
 #include "globals.hh"               // Include from 'global'
 #include "G4ParticleDefinition.hh"  // Include from 'particle+matter'
 #include "G4TrajectoryPoint.hh"     // Include from 'tracking'
 #include "G4Track.hh"
 #include "G4Step.hh"
 
-class G4Polyline;                   // Forward declaration.
+class G4Polyline;                   // Forward declaration
 
 typedef std::vector<G4VTrajectoryPoint*>  TrajectoryPointContainer;
+
 ///////////////////
 class G4Trajectory : public G4VTrajectory
 ///////////////////
@@ -106,8 +109,7 @@ public: // with description
 
 // Other member functions
    virtual void ShowTrajectory(std::ostream& os=G4cout) const;
-   //virtual void DrawTrajectory() const;
-   virtual void DrawTrajectory(G4int i_mode = 0) const;
+   virtual void DrawTrajectory() const;
    virtual void AppendStep(const G4Step* aStep);
    virtual int GetPointEntries() const { return positionRecord->size(); }
    virtual G4VTrajectoryPoint* GetPoint(G4int i) const 
@@ -134,32 +136,19 @@ public: // with description
 
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-  extern G4DLLEXPORT G4Allocator<G4Trajectory> aTrajectoryAllocator;
-#else
-  extern G4DLLIMPORT G4Allocator<G4Trajectory> aTrajectoryAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4Trajectory> *aTrajectoryAllocator;
 
 inline void* G4Trajectory::operator new(size_t)
 {
-  void* aTrajectory;
-  aTrajectory = (void*)aTrajectoryAllocator.MallocSingle();
-  return aTrajectory;
+  if (!aTrajectoryAllocator)
+  { aTrajectoryAllocator = new G4Allocator<G4Trajectory>; }
+  return (void*)aTrajectoryAllocator->MallocSingle();
 }
 
 inline void G4Trajectory::operator delete(void* aTrajectory)
 {
-  aTrajectoryAllocator.FreeSingle((G4Trajectory*)aTrajectory);
+  aTrajectoryAllocator->FreeSingle((G4Trajectory*)aTrajectory);
 }
 
 #endif
-
-
-
-
-
-
-
-
-
-

source/tracking/include/G4TrajectoryPoint.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrajectoryPoint.hh 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -49,6 +49,7 @@
 #ifndef G4TrajectoryPoint_h
 #define G4TrajectoryPoint_h 1
 
+#include "trkgdefs.hh"
 #include "G4VTrajectoryPoint.hh"
 #include "globals.hh"                // Include from 'global'
 #include "G4ThreeVector.hh"          // Include from 'geometry'
@@ -93,23 +94,19 @@ public: // without description
 
 };
 
-#if defined G4TRACKING_ALLOC_EXPORT
-  extern G4DLLEXPORT G4Allocator<G4TrajectoryPoint> aTrajectoryPointAllocator;
-#else
-  extern G4DLLIMPORT G4Allocator<G4TrajectoryPoint> aTrajectoryPointAllocator;
-#endif
+extern G4TRACKING_DLL G4ThreadLocal
+G4Allocator<G4TrajectoryPoint> *aTrajectoryPointAllocator;
 
 inline void* G4TrajectoryPoint::operator new(size_t)
 {
-   void *aTrajectoryPoint;
-   aTrajectoryPoint = (void *) aTrajectoryPointAllocator.MallocSingle();
-   return aTrajectoryPoint;
+  if (!aTrajectoryPointAllocator)
+  { aTrajectoryPointAllocator = new G4Allocator<G4TrajectoryPoint>; }
+  return (void *) aTrajectoryPointAllocator->MallocSingle();
 }
 
 inline void G4TrajectoryPoint::operator delete(void *aTrajectoryPoint)
 {
-   aTrajectoryPointAllocator.FreeSingle((G4TrajectoryPoint *) aTrajectoryPoint);
+  aTrajectoryPointAllocator->FreeSingle((G4TrajectoryPoint *) aTrajectoryPoint);
 }
 
 #endif
-

source/tracking/include/G4UserSteppingAction.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4UserSteppingAction.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/include/G4UserTrackingAction.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4UserTrackingAction.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //
 //---------------------------------------------------------------

source/tracking/include/G4VSteppingVerbose.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VSteppingVerbose.hh 66872 2013-01-15 01:25:57Z japost $
 //
 //---------------------------------------------------------------
 //
@@ -76,9 +76,9 @@ public:
   virtual ~G4VSteppingVerbose();
   //
 protected:  
-  static G4VSteppingVerbose* fInstance;// pointer to the instance 
-  static G4int Silent; //flag for verbosity
-  static G4int SilentStepInfo; //another flag for verbosity
+  static G4ThreadLocal G4VSteppingVerbose* fInstance;// pointer to the instance 
+  static G4ThreadLocal G4int Silent; //flag for verbosity
+  static G4ThreadLocal G4int SilentStepInfo; //another flag for verbosity
 public:   // with description
 // static methods to set/get the object's pointer 
   static void SetInstance(G4VSteppingVerbose* Instance);

source/tracking/include/G4VTrajectory.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VTrajectory.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //
@@ -88,9 +88,7 @@ class G4VTrajectory
    // may be used or may be overridden in the concrete class.  Note:
    // the user needs to follow with new-line or end-of-string,
    // depending on the nature of os.
-   virtual void DrawTrajectory(G4int i_mode =0) const;
-   //virtual void DrawTrajectory() const;
-   //virtual void DrawTrajectory(G4int i_mode) const;
+   virtual void DrawTrajectory() const;
    // Draw the trajectory.  A default implementation in this base
    // class may be used or may be overridden in the concrete class.
    virtual const std::map<G4String,G4AttDef>* GetAttDefs() const

source/tracking/include/G4VTrajectoryPoint.hh

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VTrajectoryPoint.hh 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/include/trkgdefs.hh

@@ -0,0 +1,51 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+// $Id: $
+//
+//
+// Defines for Windows DLLs import/export
+//
+
+#ifndef TRKGDEFS_HH
+#define TRKGDEFS_HH
+
+#include "G4Types.hh"
+
+#ifdef WIN32
+  //
+  // Unique identifier for global module
+  //
+  #if defined G4TRACKING_ALLOC_EXPORT
+    #define G4TRACKING_DLL G4DLLEXPORT
+  #else
+    #define G4TRACKING_DLL G4DLLIMPORT
+  #endif
+#else
+  #define G4TRACKING_DLL
+#endif
+
+#endif /* G4TRKGDEFS_HH */

source/tracking/sources.cmake

@@ -11,7 +11,7 @@
 #
 # Generated on : 24/9/2010
 #
-# $Id: sources.cmake,v 1.1 2010-09-29 19:11:16 bmorgan Exp $
+# $Id: sources.cmake 77241 2013-11-22 09:55:47Z gcosmo $
 #
 #------------------------------------------------------------------------------
 
@@ -23,6 +23,7 @@ include_directories(${CMAKE_SOURCE_DIR}/source/digits_hits/detector/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/digits_hits/hits/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/geometry/navigation/include)
+include_directories(${CMAKE_SOURCE_DIR}/source/geometry/magneticfield/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/geometry/solids/CSG/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/geometry/volumes/include)
 include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
@@ -45,6 +46,7 @@ GEANT4_DEFINE_MODULE(NAME G4tracking
     HEADERS
         G4AdjointCrossSurfChecker.hh
         G4AdjointSteppingAction.hh
+        G4AdjointTrackingAction.hh
         G4RichTrajectory.hh
         G4RichTrajectoryPoint.hh
         G4SmoothTrajectory.hh
@@ -60,9 +62,11 @@ GEANT4_DEFINE_MODULE(NAME G4tracking
         G4VSteppingVerbose.hh
         G4VTrajectory.hh
         G4VTrajectoryPoint.hh
+        trkgdefs.hh
     SOURCES
         G4AdjointCrossSurfChecker.cc
         G4AdjointSteppingAction.cc
+        G4AdjointTrackingAction.cc
         G4RichTrajectory.cc
         G4RichTrajectoryPoint.cc
         G4SmoothTrajectory.cc

source/tracking/src/G4AdjointCrossSurfChecker.cc

@@ -23,7 +23,7 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
-// $Id$
+// $Id: G4AdjointCrossSurfChecker.cc 66872 2013-01-15 01:25:57Z japost $
 //
 /////////////////////////////////////////////////////////////////////////////
 //      Class Name:	G4AdjointCrossSurfChecker
@@ -44,7 +44,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 // 
-G4AdjointCrossSurfChecker* G4AdjointCrossSurfChecker::instance = 0;
+G4ThreadLocal G4AdjointCrossSurfChecker* G4AdjointCrossSurfChecker::instance = 0;
 
 //////////////////////////////////////////////////////////////////////////////
 //

source/tracking/src/G4AdjointSteppingAction.cc

@@ -23,7 +23,7 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
-// $Id$
+// $Id: G4AdjointSteppingAction.cc 75570 2013-11-04 11:41:10Z gcosmo $
 //
 /////////////////////////////////////////////////////////////////////////////
 //      Class Name:	G4AdjointSteppingAction
@@ -40,10 +40,12 @@
 #include "G4AdjointCrossSurfChecker.hh"
 ////////////////////////////////////////////////////////////////////////////////////////////////
 //
+
 G4AdjointSteppingAction::G4AdjointSteppingAction()
   : ext_sourceEMax(0.), start_event(false),
     did_adj_part_reach_ext_source(false), last_ekin(0.), last_weight(0.),
-    prim_weight(0.), last_part_def(0), theUserAdjointSteppingAction(0)
+    prim_weight(0.), last_part_def(0), theUserAdjointSteppingAction(0),
+    theUserFwdSteppingAction(0)
 { 
   theG4AdjointCrossSurfChecker = G4AdjointCrossSurfChecker::GetInstance();
 }
@@ -56,11 +58,25 @@ G4AdjointSteppingAction::~G4AdjointSteppingAction()
 //
 void G4AdjointSteppingAction::UserSteppingAction(const G4Step* aStep)
 {
+  G4Track* aTrack =aStep->GetTrack();
+  //forward tracking mode
+   if(!is_adjoint_tracking_mode){
+     //check if last adjoint did reach the external source
+     if (!did_adj_part_reach_ext_source) {
+        aTrack->SetTrackStatus(fStopAndKill);
+        return;
+     }
+     if(theUserFwdSteppingAction)
+       theUserFwdSteppingAction->UserSteppingAction(aStep);
+     return;
+   }
+
+
   //Apply first the user adjoint stepping action
   //---------------------------
   if (theUserAdjointSteppingAction) theUserAdjointSteppingAction->UserSteppingAction(aStep);
 
-  G4Track* aTrack =aStep->GetTrack();
+
   G4double nb_nuc=1.;
   G4ParticleDefinition* thePartDef = aTrack->GetDefinition();
  
@@ -76,7 +92,6 @@ void G4AdjointSteppingAction::UserSteppingAction(const G4Step* aStep)
   }
 
   G4double weight_factor = aTrack->GetWeight()/prim_weight;
-
   if ( (weight_factor>0 && weight_factor<=0) || weight_factor<= 1e-290 || weight_factor>1.e200)
   {
 	//std::cout<<"Weight_factor problem! Value = "<<weight_factor<<std::endl;
@@ -96,7 +111,6 @@ void G4AdjointSteppingAction::UserSteppingAction(const G4Step* aStep)
   if (theG4AdjointCrossSurfChecker->CrossingOneOfTheRegisteredSurface(aStep, surface_name, crossing_pos, cos_to_surface, GoingIn) ){
   	
 	//G4cout<<"Test_step11"<<std::endl;
-	//G4cout<<surface_name<<std::endl;
 	if (surface_name == "ExternalSource") {
 		//Registering still needed
 		did_adj_part_reach_ext_source=true;

source/tracking/src/G4AdjointTrackingAction.cc

@@ -0,0 +1,92 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+//
+// $Id: G4AdjointTrackingAction.cc 75409 2013-11-01 00:31:00Z ldesorgh$
+//
+// ---------------------------------------------------------------
+//
+//
+//
+// ---------------------------------------------------------------
+
+#include "G4AdjointTrackingAction.hh"
+#include "G4ParticleTable.hh"
+#include "G4Track.hh"
+#include "G4AdjointSteppingAction.hh"
+
+
+
+/////////////////////////////////////////////////////////
+G4AdjointTrackingAction::G4AdjointTrackingAction(
+                                         G4AdjointSteppingAction* anAction)
+ :theAdjointSteppingAction(anAction),theUserFwdTrackingAction(0)
+{;}
+/////////////////////////////////////////////////////////
+G4AdjointTrackingAction::~G4AdjointTrackingAction()
+/////////////////////////////////////////////////////////
+{;}
+/////////////////////////////////////////////////////////
+void G4AdjointTrackingAction::PreUserTrackingAction(const G4Track* aTrack)
+{ G4String partType = aTrack->GetParticleDefinition()->GetParticleType();
+  if (aTrack->GetDynamicParticle()->GetPrimaryParticle() &&
+              partType.contains(G4String("adjoint"))){
+   is_adjoint_tracking_mode =true;
+   theAdjointSteppingAction->SetPrimWeight(aTrack->GetWeight());
+  }
+  else {
+   is_adjoint_tracking_mode =false;
+   if (theUserFwdTrackingAction)
+        theUserFwdTrackingAction->PreUserTrackingAction(aTrack);
+  }
+  theAdjointSteppingAction->SetAdjointTrackingMode(is_adjoint_tracking_mode);
+}
+/////////////////////////////////////////////////////////
+ void G4AdjointTrackingAction::PostUserTrackingAction(const G4Track* aTrack)
+{ if(!is_adjoint_tracking_mode){
+	if (theUserFwdTrackingAction)
+		theUserFwdTrackingAction->PostUserTrackingAction(aTrack);
+  }
+  else if (theAdjointSteppingAction->GetDidAdjParticleReachTheExtSource()){
+    last_pos = theAdjointSteppingAction->GetLastPosition();
+    last_direction = theAdjointSteppingAction->GetLastMomentum();
+    last_direction /=last_direction.mag();
+    last_cos_th =  last_direction.z();
+    G4ParticleDefinition* aPartDef= theAdjointSteppingAction->GetLastPartDef();
+    last_fwd_part_name= aPartDef->GetParticleName();
+    last_fwd_part_name.remove(0,4);
+    last_fwd_part_PDGEncoding=G4ParticleTable::GetParticleTable()
+                         ->FindParticle(last_fwd_part_name)->GetPDGEncoding();
+    last_ekin = theAdjointSteppingAction->GetLastEkin();
+    last_ekin_nuc = last_ekin;
+    if (aPartDef->GetParticleType() == "adjoint_nucleus") {
+      G4double  nb_nuc=double(aPartDef->GetBaryonNumber());
+      last_ekin_nuc /=nb_nuc;
+    }
+    last_weight = theAdjointSteppingAction->GetLastWeight(); ;
+  }
+}
+
+

source/tracking/src/G4RichTrajectory.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4RichTrajectory.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 // ---------------------------------------------------------------
 //
@@ -57,14 +57,15 @@
 
 #include <sstream>
 
-G4Allocator<G4RichTrajectory> aRichTrajectoryAllocator;
+G4ThreadLocal G4Allocator<G4RichTrajectory> *aRichTrajectoryAllocator = 0;
 
 G4RichTrajectory::G4RichTrajectory():
   fpRichPointsContainer(0),
   fpCreatorProcess(0),
   fpEndingProcess(0),
   fFinalKineticEnergy(0.)
-{}
+{
+}
 
 G4RichTrajectory::G4RichTrajectory(const G4Track* aTrack):
   G4Trajectory(aTrack)  // Note: this initialises the base class data
@@ -154,6 +155,20 @@ void G4RichTrajectory::MergeTrajectory(G4VTrajectory* secondTrajectory)
   seco->fpRichPointsContainer->clear();
 }
 
+void G4RichTrajectory::ShowTrajectory(std::ostream& os) const
+{
+  // Invoke the default implementation in G4VTrajectory...
+  G4VTrajectory::ShowTrajectory(os);
+  // ... or override with your own code here.
+}
+
+void G4RichTrajectory::DrawTrajectory() const
+{
+  // Invoke the default implementation in G4VTrajectory...
+  G4VTrajectory::DrawTrajectory();
+  // ... or override with your own code here.
+}
+
 const std::map<G4String,G4AttDef>* G4RichTrajectory::GetAttDefs() const
 {
   G4bool isNew;

source/tracking/src/G4RichTrajectoryPoint.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4RichTrajectoryPoint.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //
 // ---------------------------------------------------------------
@@ -61,7 +61,7 @@
 
 #include <sstream>
 
-G4Allocator<G4RichTrajectoryPoint> aRichTrajectoryPointAllocator;
+G4ThreadLocal G4Allocator<G4RichTrajectoryPoint> *aRichTrajectoryPointAllocator = 0;
 
 G4RichTrajectoryPoint::G4RichTrajectoryPoint():
   fpAuxiliaryPointVector(0),
@@ -113,33 +113,6 @@ G4RichTrajectoryPoint::G4RichTrajectoryPoint(const G4Step* aStep):
   fpPostStepPointVolume = postStepPoint->GetTouchableHandle();
   fPreStepPointWeight = preStepPoint->GetWeight();
   fPostStepPointWeight = postStepPoint->GetWeight();
-
-  /*
-  G4cout << "fpAuxiliaryPointVector "
-	 << (void*) fpAuxiliaryPointVector;
-  G4cout << ": ";
-  if (fpAuxiliaryPointVector) {
-    G4cout << "size: " << fpAuxiliaryPointVector->size();
-    for (size_t i = 0; i < fpAuxiliaryPointVector->size(); ++i)
-      G4cout << "\n  " << (*fpAuxiliaryPointVector)[i];
-  } else {
-    G4cout << "non-existent";
-  }
-  G4cout << G4endl;
-
-  static const G4Step* lastStep = 0;
-  if (aStep && aStep == lastStep) {
-    G4cout << "********* aStep is same as last" << G4endl;
-  }
-  lastStep = aStep;
-
-  static std::vector<G4ThreeVector>*  lastAuxiliaryPointVector = 0;
-  if (fpAuxiliaryPointVector &&
-      fpAuxiliaryPointVector == lastAuxiliaryPointVector) {
-    G4cout << "********* fpAuxiliaryPointVector is same as last" << G4endl;
-  }
-  lastAuxiliaryPointVector = fpAuxiliaryPointVector;
-  */
 }
 
 G4RichTrajectoryPoint::G4RichTrajectoryPoint

source/tracking/src/G4SmoothTrajectory.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SmoothTrajectory.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //
 // ---------------------------------------------------------------
@@ -53,7 +53,7 @@
 #include "G4AttCheck.hh"
 #endif
 
-G4Allocator<G4SmoothTrajectory> aSmoothTrajectoryAllocator;
+G4ThreadLocal G4Allocator<G4SmoothTrajectory> *aSmoothTrajectoryAllocator = 0;
 
 G4SmoothTrajectory::G4SmoothTrajectory()
 :  positionRecord(0), fTrackID(0), fParentID(0),
@@ -76,7 +76,7 @@ G4SmoothTrajectory::G4SmoothTrajectory(const G4Track* aTrack)
    positionRecord->push_back(new G4SmoothTrajectoryPoint(aTrack->GetPosition()));
 
    // The first point has no auxiliary points, so set the auxiliary
-   // points vector to NULL (jacek 31/10/2002)
+   // points vector to NULL
    positionRecord->push_back(new G4SmoothTrajectoryPoint(aTrack->GetPosition(), 0));
 }
 
@@ -100,10 +100,11 @@ G4SmoothTrajectory::G4SmoothTrajectory(G4SmoothTrajectory & right):G4VTrajectory
 
 G4SmoothTrajectory::~G4SmoothTrajectory()
 {
-  if (positionRecord) {
-    //  positionRecord->clearAndDestroy();
+  if (positionRecord)
+  {
     size_t i;
-    for(i=0;i<positionRecord->size();i++){
+    for(i=0;i<positionRecord->size();i++)
+    {
       delete  (*positionRecord)[i];
     }
     positionRecord->clear();
@@ -118,21 +119,12 @@ void G4SmoothTrajectory::ShowTrajectory(std::ostream& os) const
   // ... or override with your own code here.
 }
 
-/***
 void G4SmoothTrajectory::DrawTrajectory() const
 {
   // Invoke the default implementation in G4VTrajectory...
   G4VTrajectory::DrawTrajectory();
   // ... or override with your own code here.
 }
-***/
-
-void G4SmoothTrajectory::DrawTrajectory(G4int i_mode) const
-{
-  // Invoke the default implementation in G4VTrajectory...
-  G4VTrajectory::DrawTrajectory(i_mode);
-  // ... or override with your own code here.
-}
 
 const std::map<G4String,G4AttDef>* G4SmoothTrajectory::GetAttDefs() const
 {
@@ -217,7 +209,6 @@ std::vector<G4AttValue>* G4SmoothTrajectory::CreateAttValues() const
 
 void G4SmoothTrajectory::AppendStep(const G4Step* aStep)
 {
-  // (jacek 30/10/2002)
   positionRecord->push_back(
       new G4SmoothTrajectoryPoint(aStep->GetPostStepPoint()->GetPosition(),
 				  aStep->GetPointerToVectorOfAuxiliaryPoints()));
@@ -237,10 +228,7 @@ void G4SmoothTrajectory::MergeTrajectory(G4VTrajectory* secondTrajectory)
   for(G4int i=1;i<ent;i++) // initial point of the second trajectory should not be merged
   { 
     positionRecord->push_back((*(seco->positionRecord))[i]);
-    //    positionRecord->push_back(seco->positionRecord->removeAt(1));
   }
   delete (*seco->positionRecord)[0];
   seco->positionRecord->clear();
 }
-
-

source/tracking/src/G4SmoothTrajectoryPoint.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SmoothTrajectoryPoint.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 //
 // ---------------------------------------------------------------
@@ -45,7 +45,7 @@
 #include "G4AttCheck.hh"
 #endif
 
-G4Allocator<G4SmoothTrajectoryPoint> aSmoothTrajectoryPointAllocator;
+G4ThreadLocal G4Allocator<G4SmoothTrajectoryPoint> *aSmoothTrajectoryPointAllocator = 0;
 
 G4SmoothTrajectoryPoint::G4SmoothTrajectoryPoint()
 : fAuxiliaryPointVector(0)

source/tracking/src/G4SteppingManager.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SteppingManager.cc 77790 2013-11-28 09:52:16Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -97,7 +97,7 @@ G4SteppingManager::G4SteppingManager()
 G4SteppingManager::~G4SteppingManager()
 ///////////////////////////////////////
 {
-
+   fTouchableHandle = 0;
 // Destruct simple 'has-a' objects
    fStep->DeleteSecondaryVector();
 ///////////////////////////   delete fSecondary;

source/tracking/src/G4SteppingManager2.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SteppingManager2.cc 73605 2013-09-02 09:34:55Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -50,6 +50,7 @@
 #include "G4TransportationManager.hh"
 #include "G4SteppingManager.hh"
 #include "G4LossTableManager.hh"
+#include "G4ParticleTable.hh"
 
 /////////////////////////////////////////////////
 void G4SteppingManager::GetProcessNumber()
@@ -301,6 +302,8 @@ void G4SteppingManager::InvokeAtRestDoItProcs()
      lifeTime =
        fCurrentProcess->AtRestGPIL( *fTrack, &fCondition );
 
+     
+
      if(fCondition==Forced && fCurrentProcess){
        (*fSelectedAtRestDoItVector)[ri] = Forced;
      }
@@ -309,18 +312,17 @@ void G4SteppingManager::InvokeAtRestDoItProcs()
        if(lifeTime < shortestLifeTime ){
           shortestLifeTime = lifeTime;
           fAtRestDoItProcTriggered =  G4int(ri);
-          (*fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
        }
      }
    }
 
+  (*fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
+
 // at least one process is necessary to destroy the particle  
 // exit with warning 
    if(NofInactiveProc==MAXofAtRestLoops){ 
-     G4cerr << "ERROR - G4SteppingManager::InvokeAtRestDoItProcs()" << G4endl
-            << "        No AtRestDoIt process is active!" << G4endl;
-     // G4Exception("G4SteppingManager::InvokeAtRestDoItProcs", "Tracking0013",
-     //             FatalException, "No AtRestDoIt process is active." );
+     G4Exception("G4SteppingManager::InvokeAtRestDoItProcs()", "Tracking0013",
+                 JustWarning, "No AtRestDoIt process is active!" );
    }
 
    fStep->SetStepLength( 0. );  //the particle has stopped
@@ -367,6 +369,8 @@ void G4SteppingManager::InvokeAtRestDoItProcs()
 	 // it invokes a rest process at the beginning of the tracking
 	 if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
 	   G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
+           if(!pm && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
+           { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
 	   if (pm->GetAtRestProcessVector()->entries()>0){
 	     tempSecondaryTrack->SetTrackStatus( fStopButAlive );
 	     fSecondary->push_back( tempSecondaryTrack );
@@ -441,6 +445,8 @@ void G4SteppingManager::InvokeAlongStepDoItProcs()
 	 // it invokes a rest process at the beginning of the tracking
 	 if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
 	   G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
+           if(!pm && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
+           { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
 	   if (pm->GetAtRestProcessVector()->entries()>0){
 	     tempSecondaryTrack->SetTrackStatus( fStopButAlive );
 	     fSecondary->push_back( tempSecondaryTrack );
@@ -557,6 +563,8 @@ void G4SteppingManager::InvokePSDIP(size_t np)
             // it invokes a rest process at the beginning of the tracking
 	    if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN){
 	      G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
+              if(!pm && tempSecondaryTrack->GetDefinition()->IsGeneralIon())
+              { pm = G4ParticleTable::GetParticleTable()->GetGenericIon()->GetProcessManager(); }
 	      if (pm->GetAtRestProcessVector()->entries()>0){
 		tempSecondaryTrack->SetTrackStatus( fStopButAlive );
 		fSecondary->push_back( tempSecondaryTrack );

source/tracking/src/G4SteppingVerbose.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4SteppingVerbose.cc 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //

source/tracking/src/G4TrackingManager.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrackingManager.cc 77241 2013-11-22 09:55:47Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -102,6 +102,7 @@ void G4TrackingManager::ProcessOneTrack(G4Track* apValueG4Track)
     case 1: fpTrajectory = new G4Trajectory(fpTrack); break;
     case 2: fpTrajectory = new G4SmoothTrajectory(fpTrack); break;
     case 3: fpTrajectory = new G4RichTrajectory(fpTrack); break;
+    case 4: fpTrajectory = new G4RichTrajectory(fpTrack); break;
     }
   }
 #endif

source/tracking/src/G4TrackingMessenger.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrackingMessenger.cc 77241 2013-11-22 09:55:47Z gcosmo $
 //
 //---------------------------------------------------------------
 //
@@ -52,6 +52,9 @@
 #include "G4SteppingManager.hh"
 #include "G4TrackStatus.hh"
 #include "G4ios.hh"
+#include "G4TransportationManager.hh"
+#include "G4PropagatorInField.hh"
+#include "G4IdentityTrajectoryFilter.hh"
 
 ///////////////////////////////////////////////////////////////////
 G4TrackingMessenger::G4TrackingMessenger(G4TrackingManager * trMan)
@@ -77,9 +80,10 @@ G4TrackingMessenger::G4TrackingMessenger(G4TrackingManager * trMan)
   StoreTrajectoryCmd->SetGuidance(" 1 : Choose G4Trajectory as default.");
   StoreTrajectoryCmd->SetGuidance(" 2 : Choose G4SmoothTrajectory as default.");
   StoreTrajectoryCmd->SetGuidance(" 3 : Choose G4RichTrajectory as default.");
+  StoreTrajectoryCmd->SetGuidance(" 4 : Choose G4RichTrajectory with auxiliary points as default.");
   StoreTrajectoryCmd->SetParameterName("Store",true);
   StoreTrajectoryCmd->SetDefaultValue(0);
-  StoreTrajectoryCmd->SetRange("Store >=0 && Store <= 3"); 
+  StoreTrajectoryCmd->SetRange("Store >=0 && Store <= 4"); 
 
 
   VerboseCmd = new G4UIcmdWithAnInteger("/tracking/verbose",this);
@@ -131,8 +135,21 @@ void G4TrackingMessenger::SetNewValue(G4UIcommand * command,G4String newValues)
         G4UImanager::GetUIpointer()->ApplyCommand("/control/exit");
   }
 
+  static G4ThreadLocal G4IdentityTrajectoryFilter* auxiliaryPointsFilter = 0;
+  if(!auxiliaryPointsFilter) auxiliaryPointsFilter = new G4IdentityTrajectoryFilter;
   if( command == StoreTrajectoryCmd ){
-    trackingManager->SetStoreTrajectory(StoreTrajectoryCmd->ConvertToInt(newValues));
+    G4int trajType = StoreTrajectoryCmd->ConvertToInt(newValues);
+    if(trajType==2||trajType==4)
+    {
+      G4TransportationManager::GetTransportationManager()
+        ->GetPropagatorInField()->SetTrajectoryFilter(auxiliaryPointsFilter);
+    }
+    else
+    {
+      G4TransportationManager::GetTransportationManager()
+        ->GetPropagatorInField()->SetTrajectoryFilter(0);
+    }
+    trackingManager->SetStoreTrajectory(trajType);
   }
 }
 

source/tracking/src/G4Trajectory.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4Trajectory.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 // ---------------------------------------------------------------
 //
@@ -52,7 +52,7 @@
 #include "G4AttCheck.hh"
 #endif
 
-G4Allocator<G4Trajectory> aTrajectoryAllocator;
+G4ThreadLocal G4Allocator<G4Trajectory> *aTrajectoryAllocator = 0;
 
 G4Trajectory::G4Trajectory()
 :  positionRecord(0), fTrackID(0), fParentID(0),
@@ -96,7 +96,6 @@ G4Trajectory::G4Trajectory(G4Trajectory & right):G4VTrajectory()
 G4Trajectory::~G4Trajectory()
 {
   if (positionRecord) {
-    //  positionRecord->clearAndDestroy();
     size_t i;
     for(i=0;i<positionRecord->size();i++){
       delete  (*positionRecord)[i];
@@ -113,21 +112,12 @@ void G4Trajectory::ShowTrajectory(std::ostream& os) const
   // ... or override with your own code here.
 }
 
-/***
 void G4Trajectory::DrawTrajectory() const
 {
   // Invoke the default implementation in G4VTrajectory...
   G4VTrajectory::DrawTrajectory();
   // ... or override with your own code here.
 }
-***/
-
-void G4Trajectory::DrawTrajectory(G4int i_mode) const
-{
-  // Invoke the default implementation in G4VTrajectory...
-  G4VTrajectory::DrawTrajectory(i_mode);
-  // ... or override with your own code here.
-}
 
 const std::map<G4String,G4AttDef>* G4Trajectory::GetAttDefs() const
 {
@@ -229,10 +219,7 @@ void G4Trajectory::MergeTrajectory(G4VTrajectory* secondTrajectory)
   for(G4int i=1;i<ent;i++) // initial point of the second trajectory should not be merged
   { 
     positionRecord->push_back((*(seco->positionRecord))[i]);
-    //    positionRecord->push_back(seco->positionRecord->removeAt(1));
   }
   delete (*seco->positionRecord)[0];
   seco->positionRecord->clear();
 }
-
-

source/tracking/src/G4TrajectoryPoint.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4TrajectoryPoint.cc 69003 2013-04-15 09:25:23Z gcosmo $
 //
 // ---------------------------------------------------------------
 //
@@ -44,7 +44,7 @@
 #include "G4AttCheck.hh"
 #endif
 
-G4Allocator<G4TrajectoryPoint> aTrajectoryPointAllocator;
+G4ThreadLocal G4Allocator<G4TrajectoryPoint> *aTrajectoryPointAllocator = 0;
 
 G4TrajectoryPoint::G4TrajectoryPoint()
 {

source/tracking/src/G4UserSteppingAction.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4UserSteppingAction.cc 66241 2012-12-13 18:34:42Z gunter $
 //
 // ---------------------------------------------------------------
 //

source/tracking/src/G4UserTrackingAction.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4UserTrackingAction.cc 66241 2012-12-13 18:34:42Z gunter $
 //
 // ---------------------------------------------------------------
 //

source/tracking/src/G4VSteppingVerbose.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VSteppingVerbose.cc 66872 2013-01-15 01:25:57Z japost $
 //
 //---------------------------------------------------------------
 //
@@ -46,9 +46,9 @@
 #include "G4Track.hh"
 #include "G4ParticleDefinition.hh"
 
-G4VSteppingVerbose* G4VSteppingVerbose::fInstance = 0;
-G4int G4VSteppingVerbose::Silent = 0;
-G4int G4VSteppingVerbose::SilentStepInfo = 0;
+G4ThreadLocal G4VSteppingVerbose* G4VSteppingVerbose::fInstance = 0;
+G4ThreadLocal G4int G4VSteppingVerbose::Silent = 0;
+G4ThreadLocal G4int G4VSteppingVerbose::SilentStepInfo = 0;
 
 G4VSteppingVerbose::G4VSteppingVerbose()
   : fManager(0), fUserSteppingAction(0), 

source/tracking/src/G4VTrajectory.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VTrajectory.cc 78003 2013-12-02 08:26:54Z gcosmo $
 //
 // ---------------------------------------------------------------
 //
@@ -109,9 +109,9 @@ void G4VTrajectory::ShowTrajectory(std::ostream& os) const
 
     delete attValues;  // AttValues must be deleted after use.
   }
+  os << "\n";
 }
 
-/***
 void G4VTrajectory::DrawTrajectory() const
 {
   G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
@@ -120,23 +120,3 @@ void G4VTrajectory::DrawTrajectory() const
     pVVisManager->DispatchToModel(*this);
   }
 }
-***/
-
-void G4VTrajectory::DrawTrajectory(G4int i_mode) const
-{
-  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
-
-  static G4bool warnedAboutIMode = false;
-  if (!warnedAboutIMode && i_mode != 0) {
-    G4Exception
-        ("G4VTrajectory::DrawTrajectory()",
-         "Tracking0100", JustWarning,
-         "DEPRECATED! The use of i_mode argument in DrawTrajectory()"
-         "\n  is deprecated and will be removed at the next major release.");
-    warnedAboutIMode = true;
-  }
-
-  if (0 != pVVisManager) {
-    pVVisManager->DispatchToModel(*this, i_mode);
-  }
-}

source/tracking/src/G4VTrajectoryPoint.cc

@@ -24,7 +24,7 @@
 // ********************************************************************
 //
 //
-// $Id$
+// $Id: G4VTrajectoryPoint.cc 66241 2012-12-13 18:34:42Z gunter $
 //
 //---------------------------------------------------------------
 //