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

Import Geant4 10.6.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-06-28 11:59:04 +02:00
parent 28a70706e0
commit d0f911957d
1056 changed files with 95168 additions and 78160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/dna/management/include/G4ITModelProcessor.hh
+48 -139
View File
@@ -43,14 +43,13 @@
// J. Comput. Phys. 274 (2014) 841-882
// Prog. Nucl. Sci. Tec. 2 (2011) 503-508
#ifndef G4ITMODELPROCESSOR_H
#define G4ITMODELPROCESSOR_H
#pragma once
#include <vector>
#include "G4ITReactionChange.hh"
#include "G4ITType.hh"
#include "G4ITModelHandler.hh"
#include "G4ITStepStatus.hh"
#include <vector>
class G4VITTimeStepComputer;
class G4VITReactionProcess;
@@ -60,17 +59,6 @@ class G4UserTimeStepAction;
class G4ITTrackingManager;
class G4ITTrackHolder;
//#ifndef compTrackPerID__
//#define compTrackPerID__
// struct compTrackPerID
// {
// bool operator()(G4Track* rhs, G4Track* lhs) const
// {
// return rhs->GetTrackID() < lhs->GetTrackID();
// }
// };
//#endif
/**
* The G4ITModelProcessor will call the two processes defined in G4VITModel.
* This processes act at the beginning and end of each step.
@@ -78,155 +66,76 @@ class G4ITTrackHolder;
* the track and eventually it can return some tracks that can likely react
* at the end of the step.
* The second one, the ReactionProcess will make the tracks reacting.
* \deprecated This class will be removed
*/
class G4ITModelProcessor
{
public:
G4ITModelProcessor();
virtual ~G4ITModelProcessor();
G4ITModelProcessor();
G4ITModelProcessor(const G4ITModelProcessor& other) = delete;
G4ITModelProcessor& operator=(const G4ITModelProcessor& other) = delete;
virtual ~G4ITModelProcessor();
inline void SetModelHandler(G4ITModelHandler*);
void Initialize();
//void Initialize(G4MIWorkspace* /*workspace*/);
void SetModelHandler(G4ITModelHandler*);
void SetTrackingManager(G4ITTrackingManager* trackingManager);
void RegisterModel(double time, G4VITStepModel*);
void Initialize();
/**
* Restore original state of the modelProcessor.
* This method should be call only by the G4Scheduler
*/
inline void CleanProcessor();
void RegisterModel(double time, G4VITStepModel*);
G4double CalculateMinTimeStep(G4double currentGlobalTime,
G4double definedMinTimeStep);
/** Restore the original state. This method should be called only by G4Scheduler */
void CleanProcessor();
void ComputeTrackReaction(G4ITStepStatus fITStepStatus,
G4double fGlobalTime,
G4double currentTimeStep,
G4double previousTimeStep,
G4bool reachedUserTimeLimit,
G4double fTimeTolerance,
G4UserTimeStepAction* fpUserTimeStepAction,
G4int fVerbose);
G4double CalculateMinTimeStep(G4double currentGlobalTime,
G4double definedMinTimeStep);
//____________________________________________________________
// Time stepper part
void InitializeStepper(G4double currentGlobalTime,
G4double userMinTime);
void ComputeTrackReaction(G4ITStepStatus fITStepStatus,
G4double fGlobalTime,
G4double currentTimeStep,
G4double previousTimeStep,
G4bool reachedUserTimeLimit,
G4double fTimeTolerance,
G4UserTimeStepAction* fpUserTimeStepAction,
G4int fVerbose);
bool GetComputeTimeStep()
{
return fComputeTimeStep;
}
void InitializeStepper(G4double currentGlobalTime,
G4double userMinTime);
protected:
inline void SetTrack(const G4Track*);
bool GetComputeTimeStep() const;
public:
void CalculateTimeStep(const G4Track*, const G4double);
void DoCalculateStep();
void CalculateTimeStep(const G4Track*, G4double userMinTimeStep);
//____________________________________________________________
// Reaction process part
void FindReaction(G4ITReactionSet* reactionSet,
const double currentStepTime,
const double previousStepTime,
const bool reachedUserStepTimeLimit);
void DoCalculateStep();
//____________________________________________________________
// Get results
inline const std::vector<std::vector<G4VITStepModel*> >* GetCurrentModel();
void FindReaction(G4ITReactionSet* pReactionSet,
double currentStepTime,
double previousStepTime,
bool reachedUserStepTimeLimit);
inline std::vector<G4ITReactionChange*>* GetReactionInfo()
{
return &fReactionInfo;
}
const G4Track* GetTrack() const
{
return fpTrack;
}
void SetTrackingManager(G4ITTrackingManager* trackingManager)
{
fpTrackingManager = trackingManager;
}
const G4Track* GetTrack() const;
protected:
void ExtractTimeStepperData();
void SetTrack(const G4Track*);
void ExtractTimeStepperData();
/** Copy constructor
* \param other Object to copy from
*/
G4ITModelProcessor(const G4ITModelProcessor& other);
/** Assignment operator
* \param other Object to assign from
* \return A reference to this
*/
G4ITModelProcessor& operator=(const G4ITModelProcessor& other);
G4double fTSTimeStep;
G4ITReactionSet* fReactionSet;
G4ITTrackingManager* fpTrackingManager;
G4ITTrackHolder* fpTrackContainer;
//_____________________________
// Members
G4bool fInitialized;
G4ITModelHandler* fpModelHandler;
G4double fTSTimeStep;
G4ITReactionSet* fReactionSet;
G4ITTrackingManager* fpTrackingManager;
G4ITTrackHolder* fpTrackContainer;
const G4Track* fpTrack;
G4double fUserMinTimeStep;
G4bool fInitialized;
G4ITModelHandler* fpModelHandler;
std::vector<G4VITStepModel*> fActiveModels;
G4VITStepModel* fpActiveModelWithMinTimeStep;
const G4Track* fpTrack;
G4double fUserMinTimeStep;
std::vector<std::unique_ptr<G4ITReactionChange>> fReactionInfo;
// Interactions between different IT types
// eg : electron/proton
std::vector<std::vector<G4VITStepModel*> > fCurrentModel;
// Interactions between ITs of the same type
// eg : molecule/molecule or electron/electron
G4VITStepModel* fpModel;
G4ITModelManager* fpModelManager;
G4ITType fCurrentType1;
G4ITType fCurrentType2;
std::vector<G4ITReactionChange*> fReactionInfo;
bool fComputeTimeStep;
bool fComputeReaction;
bool fComputeTimeStep;
bool fComputeReaction;
};
///
// Inline methods
///
inline void G4ITModelProcessor::SetTrack(const G4Track* track)
{
fpTrack = track;
}
inline const std::vector<std::vector<G4VITStepModel*> >* G4ITModelProcessor::GetCurrentModel()
{
return &fCurrentModel;
}
inline void G4ITModelProcessor::SetModelHandler(G4ITModelHandler* modelHandler)
{
if (fInitialized == 1)
{
G4ExceptionDescription exceptionDescription;
exceptionDescription
<< "You are trying to set a new model while the model processor has alreaday be initialized";
G4Exception("G4ITModelProcessor::SetModelHandler", "ITModelProcessor001",
FatalErrorInArgument, exceptionDescription);
}
fpModelHandler = modelHandler;
}
inline void G4ITModelProcessor::CleanProcessor()
{
fpTrack = 0;
}
#endif // G4ITMODELPROCESSOR_H