lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.6.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-12-06 15:12:28 +01:00
parent b2a62ae692
commit 5baee230e9
2997 changed files with 141580 additions and 98673 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/event/include/G4SmartTrackStack.hh
+46 -52
View File
@@ -23,72 +23,66 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
//
// Last Modification : 04/Oct/12 S. Kamperis
//
#ifndef G4SmartTrackStack_h
#define G4SmartTrackStack_h 1
#include "G4StackedTrack.hh"
#include "G4TrackStack.hh"
#include "globals.hh"
// class description:
//
// This is a 'smart' stack class used by G4StackManager. This class object
// stores G4StackedTrack class objects in various dedicated stacks
// Author: S.Kamperis - 04/Oct/12
// --------------------------------------------------------------------
#ifndef G4SmartTrackStack_hh
#define G4SmartTrackStack_hh 1
#include "G4StackedTrack.hh"
#include "G4TrackStack.hh"
#include "globals.hh"
class G4SmartTrackStack
{
public:
G4SmartTrackStack();
~G4SmartTrackStack();
G4SmartTrackStack();
~G4SmartTrackStack();
G4SmartTrackStack & operator=(const G4SmartTrackStack&) = delete;
G4bool operator==(const G4SmartTrackStack&) const = delete;
G4bool operator!=(const G4SmartTrackStack&) const = delete;
void PushToStack(const G4StackedTrack& aStackedTrack);
G4StackedTrack PopFromStack();
void clear();
void clearAndDestroy();
void TransferTo(G4TrackStack* aStack);
G4double getEnergyOfStack(G4TrackStack* aTrackStack);
void dumpStatistics();
inline G4int GetNTrack() const { return nTracks; }
inline G4int GetMaxNTrack() const { return maxNTracks; }
private:
const G4SmartTrackStack & operator=
(const G4SmartTrackStack &right);
G4bool operator==(const G4SmartTrackStack &right) const;
G4bool operator!=(const G4SmartTrackStack &right) const;
public:
void PushToStack(const G4StackedTrack& aStackedTrack);
G4StackedTrack PopFromStack();
void clear();
void clearAndDestroy();
void TransferTo(G4TrackStack* aStack);
G4double getEnergyOfStack(G4TrackStack* aTrackStack);
void dumpStatistics();
inline G4int n_stackedTrack() const
{
return G4int(stacks[0]->GetNTrack() +
stacks[1]->GetNTrack() +
stacks[2]->GetNTrack() +
stacks[3]->GetNTrack() +
stacks[4]->GetNTrack());
}
private:
G4int fTurn;
G4int nTurn; // should be 5
G4double energies[5];
G4TrackStack* stacks[5];
// = 0 : all primaries and secondaries except followings
// = 1 : secondary neutrons
// = 2 : secondary electrons
// = 3 : secondary gammas
// = 4 : secondary positrons
G4int maxNTracks;
G4int nTracks;
public:
G4int GetNTrack() const { return nTracks; }
G4int GetMaxNTrack() const { return maxNTracks; }
private:
inline G4int n_stackedTrack() const
{
return stacks[0]->GetNTrack() +
stacks[1]->GetNTrack() +
stacks[2]->GetNTrack() +
stacks[3]->GetNTrack() +
stacks[4]->GetNTrack();
}
G4int fTurn;
G4int nTurn; // should be 5
G4double energies[5];
G4TrackStack* stacks[5];
// = 0 : all primaries and secondaries except followings
// = 1 : secondary neutrons
// = 2 : secondary electrons
// = 3 : secondary gammas
// = 4 : secondary positrons
G4int maxNTracks;
G4int nTracks;
};
#endif
source/event/include/G4StackedTrack.hh
+22 -25
View File
@@ -23,38 +23,35 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
//
// Last Modification : 02/Feb/96 M.Asai
//
#ifndef G4StackedTrack_h
#define G4StackedTrack_h 1
class G4VTrajectory;
class G4Track;
// class description:
//
// This class is exclusively used by G4StackManager and G4TrackStack
// classes for storing a G4Track object.
//
// Author: Makoto Asai (SLAC) - 02/Feb/96
// --------------------------------------------------------------------
#ifndef G4StackedTrack_hh
#define G4StackedTrack_hh 1
class G4VTrajectory;
class G4Track;
class G4StackedTrack
{
public:
G4StackedTrack() : track(0), trajectory(0) {}
G4StackedTrack(G4Track* aTrack, G4VTrajectory* aTraj = 0) : track(aTrack), trajectory(aTraj) {}
~G4StackedTrack() {}
private:
G4Track* track;
G4VTrajectory* trajectory;
public:
G4Track* GetTrack() const { return track; }
G4VTrajectory* GetTrajectory() const { return trajectory; }
public:
G4StackedTrack() : track(nullptr), trajectory(nullptr) {}
G4StackedTrack(G4Track* aTrack, G4VTrajectory* aTraj = nullptr)
: track(aTrack), trajectory(aTraj) {}
~G4StackedTrack() {}
G4Track* GetTrack() const { return track; }
G4VTrajectory* GetTrajectory() const { return trajectory; }
private:
G4Track* track;
G4VTrajectory* trajectory;
};
#endif
source/event/include/G4TrackStack.hh
+43 -43
View File
@@ -23,62 +23,62 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
//
// Last Modification : 09/Dec/96 M.Asai
//
#ifndef G4TrackStack_h
#define G4TrackStack_h 1
#include "G4StackedTrack.hh"
#include "G4Types.hh"
#include <vector>
class G4SmartTrackStack;
// class description:
//
// This is a stack class used by G4StackManager. This class object
// stores G4StackedTrack class objects in the form of bi-directional
// linked list.
// Author: Makoto Asai (SLAC) - 09/Dec/96
// --------------------------------------------------------------------
#ifndef G4TrackStack_hh
#define G4TrackStack_hh 1
#include <vector>
#include "G4StackedTrack.hh"
#include "G4Types.hh"
class G4SmartTrackStack;
class G4TrackStack : public std::vector<G4StackedTrack>
{
public:
G4TrackStack() : safetyValve1(0), safetyValve2(0), nstick(0) {}
G4TrackStack(size_t n) : safetyValve1(4*n/5), safetyValve2(4*n/5-100), nstick(100) { reserve(n);}
~G4TrackStack();
public:
G4TrackStack()
: safetyValue1(0), safetyValue2(0), nstick(0) {}
G4TrackStack(size_t n)
: safetyValue1(G4int(4*n/5)),
safetyValue2(G4int(4*n/5-100)), nstick(100) { reserve(n); }
~G4TrackStack();
private:
const G4TrackStack & operator=(const G4TrackStack &right);
G4bool operator==(const G4TrackStack &right) const;
G4bool operator!=(const G4TrackStack &right) const;
G4TrackStack& operator=(const G4TrackStack&) = delete;
G4bool operator==(const G4TrackStack&) const = delete;
G4bool operator!=(const G4TrackStack&) const = delete;
public:
void PushToStack(const G4StackedTrack& aStackedTrack) { push_back(aStackedTrack); }
G4StackedTrack PopFromStack() { G4StackedTrack st = back(); pop_back(); return st; }
void TransferTo(G4TrackStack* aStack);
void TransferTo(G4SmartTrackStack* aStack);
void PushToStack(const G4StackedTrack& aStackedTrack)
{ push_back(aStackedTrack); }
G4StackedTrack PopFromStack()
{ G4StackedTrack st = back(); pop_back(); return st; }
void TransferTo(G4TrackStack* aStack);
void TransferTo(G4SmartTrackStack* aStack);
void clearAndDestroy();
private:
G4int safetyValve1;
G4int safetyValve2;
G4int nstick;
void clearAndDestroy();
size_t GetNTrack() const { return size(); }
size_t GetMaxNTrack() const { return max_size(); }
inline G4int GetSafetyValue1() const { return safetyValue1; }
inline G4int GetSafetyValue2() const { return safetyValue2; }
inline G4int GetNStick() const { return nstick; }
public:
G4int GetNTrack() const { return size(); }
G4int GetMaxNTrack() const { return max_size(); }
inline G4int GetSafetyValve1() const { return safetyValve1; }
inline G4int GetSafetyValve2() const { return safetyValve2; }
inline G4int GetNStick() const { return nstick; }
G4double getTotalEnergy(void) const;
void SetSafetyValve2(int x) { safetyValve2 = x < 0 ? 0 : x; }
G4double getTotalEnergy(void) const;
void SetSafetyValue2(G4int x) { safetyValue2 = x < 0 ? 0 : x; }
private:
G4int safetyValue1;
G4int safetyValue2;
G4int nstick;
};
#endif
source/event/include/G4TrajectoryContainer.hh
+14 -16
View File
@@ -23,20 +23,17 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
//
// G4TrajectoryContainer
//
// Class description:
//
// This is a container of G4VTrajectory objects and the object of this
// container will be associated to G4Event object.
//
// ********************************************************************
#ifndef G4TrajectoryContainer_h
#define G4TrajectoryContainer_h 1
// Author: Makoto Asai (SLAC)
// --------------------------------------------------------------------
#ifndef G4TrajectoryContainer_hh
#define G4TrajectoryContainer_hh 1
#include <vector>
@@ -50,38 +47,38 @@ typedef std::vector<G4VTrajectory*> TrajectoryVector;
class G4TrajectoryContainer
{
public:
G4TrajectoryContainer();
~G4TrajectoryContainer();
private:
G4TrajectoryContainer(const G4TrajectoryContainer&);
G4TrajectoryContainer& operator=(const G4TrajectoryContainer&);
G4TrajectoryContainer(const G4TrajectoryContainer&) = delete;
G4TrajectoryContainer& operator=(const G4TrajectoryContainer&) = delete;
public:
inline void *operator new(size_t);
inline void operator delete(void* anEvent);
G4bool operator==(const G4TrajectoryContainer& right) const;
G4bool operator!=(const G4TrajectoryContainer& right) const;
public:
inline size_t size() const { return vect->size(); }
inline void push_back(G4VTrajectory* p) { vect->push_back(p); }
inline G4int entries() const { return size(); }
inline size_t entries() const { return size(); }
inline G4bool insert(G4VTrajectory* p) { push_back(p); return true; }
inline void clearAndDestroy()
{
for(size_t i=0;i<size();i++) delete (*vect)[i];
for(std::size_t i=0; i<size(); ++i) delete (*vect)[i];
vect->clear();
}
inline G4VTrajectory* operator[](size_t n) { return (*vect)[n]; }
inline TrajectoryVector* GetVector() const { return vect; }
private:
TrajectoryVector* vect;
};
extern G4EVENT_DLL G4Allocator<G4TrajectoryContainer>*& aTrajectoryContainerAllocator();
extern G4EVENT_DLL
G4Allocator<G4TrajectoryContainer>*& aTrajectoryContainerAllocator();
inline void* G4TrajectoryContainer::operator new(size_t)
{
@@ -92,7 +89,8 @@ inline void* G4TrajectoryContainer::operator new(size_t)
inline void G4TrajectoryContainer::operator delete(void* aTrajectoryContainer)
{
aTrajectoryContainerAllocator()->FreeSingle((G4TrajectoryContainer*)aTrajectoryContainer);
aTrajectoryContainerAllocator()
->FreeSingle((G4TrajectoryContainer*)aTrajectoryContainer);
}
#endif