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

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/dna/models/include/G4DNADingfelderChargeDecreaseModel.hh
+7
View File
@@ -114,6 +114,13 @@ private:
G4DNADingfelderChargeDecreaseModel & operator=(const G4DNADingfelderChargeDecreaseModel &right);
G4DNADingfelderChargeDecreaseModel(const G4DNADingfelderChargeDecreaseModel&);
// Reusable particle definitions
G4ParticleDefinition* protonDef;
G4ParticleDefinition* alphaPlusPlusDef;
G4ParticleDefinition* alphaPlusDef;
G4ParticleDefinition* hydrogenDef;
G4ParticleDefinition* heliumDef;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/dna/models/include/G4DNADingfelderChargeIncreaseModel.hh
+6
View File
@@ -115,6 +115,12 @@ private:
G4DNADingfelderChargeIncreaseModel & operator=(const G4DNADingfelderChargeIncreaseModel &right);
G4DNADingfelderChargeIncreaseModel(const G4DNADingfelderChargeIncreaseModel&);
// Reusable particle definitions
G4ParticleDefinition* hydrogenDef;
G4ParticleDefinition* alphaPlusPlusDef;
G4ParticleDefinition* alphaPlusDef;
G4ParticleDefinition* heliumDef;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/dna/models/include/G4DNAEventScheduler.hh
+23 -19
View File
@@ -39,6 +39,8 @@
#include "G4ITReaction.hh"
#include "G4DNAEventSet.hh"
#include "G4DNAUpdateSystemModel.hh"
#include "G4H2O2.hh"
#include <CLHEP/Units/SystemOfUnits.h>
class G4VITStepModel;
class G4DNAGillespieDirectMethod;
class G4UserMeshAction;
@@ -66,8 +68,8 @@ class G4DNAEventScheduler : public IEventScheduler
void SetEndTime(const G4double&);
G4double GetStartTime() const;
G4double GetEndTime() const;
[[maybe_unused]] G4double GetTimeStep() const;
[[maybe_unused]] void SetStartTime(G4double time);
G4double GetTimeStep() const;
void SetStartTime(G4double time);
inline void SetVerbose(G4int verbose) { fVerbose = verbose; }
inline G4int GetVerbose() const;
@@ -79,13 +81,13 @@ class G4DNAEventScheduler : public IEventScheduler
void RunInMesh();
void Run();
[[maybe_unused]] void AddTimeToRecord(const G4double& time);
void AddTimeToRecord(const G4double& time);
void RecordTime();
void ClearAndReChargeCounter();
void PrintRecordTime();
void Stop();
[[maybe_unused]] void SetMaxNbSteps(G4int);
void SetMaxNbSteps(G4int);
std::map<G4double /*time*/, MapCounter> GetCounterMap() const;
G4DNAMesh* GetMesh() const;
G4int GetPixels() const;
@@ -93,22 +95,25 @@ class G4DNAEventScheduler : public IEventScheduler
static G4bool CheckingReactionRadius(G4double resolution);
private:
G4int fVerbose;
G4bool fInitialized;
G4double fStartTime;
G4double fEndTime;
G4int fStepNumber;
G4int fMaxStep;
G4bool fRunning;
G4double fTimeStep;
G4double fGlobalTime;
G4double fJumpingNumber;
G4double fReactionNumber;
G4int fVerbose = 0;
G4bool fInitialized = false;
G4double fStartTime = 1 * CLHEP::picosecond;
G4double fEndTime = 10000 * CLHEP::second;
G4int fStepNumber = 0;
G4int fMaxStep = INT_MAX;
G4bool fRunning = true;
G4double fTimeStep = DBL_MAX;
G4double fGlobalTime = 1 * CLHEP::picosecond;
G4double fJumpingNumber = 0;
G4double fReactionNumber = 0;
G4int fPixel;
G4bool fIsChangeMesh;
G4bool fSetChangeMesh;
G4int fStepNumberInMesh;
G4bool fIsChangeMesh = false;
G4bool fSetChangeMesh = true;
G4int fStepNumberInMesh = 0;
G4double fInitialPixels;
G4double fTransferTime = 0.;
const G4double C = 20;
const G4double D = G4H2O2::Definition()->GetDiffusionCoefficient(); // this is the biggest D
std::unique_ptr<G4DNAMesh> fpMesh;
std::unique_ptr<G4DNAGillespieDirectMethod> fpGillespieReaction;
@@ -116,7 +121,6 @@ class G4DNAEventScheduler : public IEventScheduler
std::unique_ptr<G4DNAUpdateSystemModel> fpUpdateSystem;
std::unique_ptr<G4UserMeshAction> fpUserMeshAction;
// an aternative Counter
std::map<G4double /*time*/, MapCounter> fCounterMap;
std::set<G4double> fTimeToRecord;
std::set<G4double>::iterator fLastRecoredTime;
source/processes/electromagnetic/dna/models/include/G4DNAGillespieDirectMethod.hh
+15 -16
View File
@@ -34,43 +34,42 @@
#include "G4MoleculeTable.hh"
#include "G4ITTrackHolder.hh"
#include "G4DNAEventSet.hh"
class G4DNAMolecularReactionTable;
class G4DNAMolecularReactionData;
class G4DNAScavengerMaterial;
class G4MolecularConfiguration;
class G4DNAGillespieDirectMethod
{
public:
G4DNAGillespieDirectMethod();
~G4DNAGillespieDirectMethod();
using MolType = const G4MolecularConfiguration*;
using Key = unsigned int;
using Index = G4Voxel::Index;
using Index = G4VDNAMesh::Index;
using Voxel = G4DNAMesh::Voxel;
using JumpingData = std::pair<MolType, Index>;
using ReactionData = const G4DNAMolecularReactionData;
using EventIt = G4DNAEventSet::EventSet::iterator;
G4double PropensityFunction(const Index& index, ReactionData* data);
G4double PropensityFunction(const Index& index, MolType moleType);
G4double PropensityFunction(const Voxel& voxel, ReactionData* data);
G4double PropensityFunction(const Voxel& voxel, MolType moleType);
inline void SetVoxelMesh(G4DNAMesh& mesh) { fpMesh = &mesh; }
void SetTimeStep(const G4double& stepTime);
G4double Reaction(const Index& index);
G4double DiffusiveJumping(const Index& index);
G4double ComputeNumberInNode(const Index& index, MolType type);
G4double VolumeOfNode(const Index& index);
void Initialize();
void CreateEvent(unsigned int key);
void CreateEvent(const Index& index);
void SetEventSet(G4DNAEventSet*);
private:
G4double Reaction(const Voxel& voxel);
G4double DiffusiveJumping(const Voxel& voxel);
G4double ComputeNumberInNode(const Voxel& voxel, MolType type);
G4double VolumeOfNode(const Voxel& voxel);
G4DNAMolecularReactionTable* fMolecularReactions;
G4DNAMesh* fpMesh;
G4DNAMesh* fpMesh = nullptr;
G4double fTimeStep;
G4DNAEventSet* fpEventSet;
G4double fVerbose;
G4DNAEventSet* fpEventSet = nullptr;
G4double fVerbose = 0;
std::map<G4double /*Propensity*/, ReactionData*> fReactionDataMap;
std::map<G4double /*Propensity*/, JumpingData> fJumpingDataMap;
G4bool FindScavenging(const Index& index, MolType, G4double&);
G4DNAScavengerMaterial* fpScavengerMaterial;
G4bool FindScavenging(const Voxel& voxel, MolType, G4double&);
G4DNAScavengerMaterial* fpScavengerMaterial = nullptr;
};
#endif
source/processes/electromagnetic/dna/models/include/G4DNAIRT_geometries.hh
-118
View File
@@ -1,118 +0,0 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
/*
* G4DNAIRT_geometries.hh
*
* Created on: Jul 23, 2019
* Author: W. G. Shin
* J. Ramos-Mendez and B. Faddegon
*/
#ifndef G4DNAIRT_geometries_HH_
#define G4DNAIRT_geometries_HH_
#include "globals.hh"
#include "G4ThreeVector.hh"
#include "G4DNAMolecularReaction.hh"
#include "G4DNAMolecularReactionTable.hh"
#include "G4MoleculeTable.hh"
#include "G4VDNAReactionModel.hh"
#include "G4VITReactionProcess.hh"
#include "G4ITReactionTable.hh"
#include "G4ITTrackHolder.hh"
#include "G4ITReaction.hh"
#include "G4Molecule.hh"
#include "G4VITReactionProcess.hh"
#include "G4ParticleChange.hh"
#include "G4VDNAMolecularGeometry.hh"
#include "AddClone_def.hh"
#include <vector>
#include <map>
class G4DNAMolecularReactionTable;
class G4VDNAReactionModel;
class G4ErrorFunction;
class G4DNAIRT_geometries : public G4VITReactionProcess
{
public:
G4DNAIRT_geometries();
explicit G4DNAIRT_geometries(G4VDNAReactionModel*);
~G4DNAIRT_geometries() override;
G4DNAIRT_geometries(const G4DNAIRT_geometries& other) = delete;
G4DNAIRT_geometries& operator=(const G4DNAIRT_geometries& other) = delete;
G4bool TestReactibility(const G4Track&,
const G4Track&,
G4double ,
G4bool ) override;
std::vector<std::unique_ptr<G4ITReactionChange>> FindReaction(G4ITReactionSet*, const G4double, const G4double, const G4bool) override;
std::unique_ptr<G4ITReactionChange> MakeReaction(const G4Track&, const G4Track&) override;
void SetReactionModel(G4VDNAReactionModel*);
void Initialize() override;
void SpaceBinning();
void IRTSampling();
void Sampling(G4Track*);
G4double GetIndependentReactionTime(const G4MolecularConfiguration*, const G4MolecularConfiguration*, G4double);
G4int FindBin(G4int, G4double, G4double, G4double);
G4double SamplePDC(G4double , G4double );
protected:
const G4DNAMolecularReactionTable*& fMolReactionTable;
G4VDNAReactionModel* fpReactionModel;
private:
G4ITTrackHolder* fTrackHolder;
G4ITReactionSet* fReactionSet;
G4ErrorFunction* erfc;
std::map<G4int,std::map<G4int,std::map<G4int,std::vector<G4Track*>>>> spaceBinned;
std::vector<std::pair<G4ThreeVector,G4Track*>> positionMap;
G4double fRCutOff;
G4double timeMin;
G4double timeMax;
G4double fXMin, fYMin, fZMin;
G4double fXMax, fYMax, fZMax;
G4int fNx, fNy, fNz;
G4int xiniIndex, yiniIndex, ziniIndex;
G4int xendIndex, yendIndex, zendIndex;
G4VDNAMolecularGeometry* fGeometry;
};
#endif /* G4DNAIRT_geometries_HH_ */
source/processes/electromagnetic/dna/models/include/G4DNAIndependentReactionTimeModel.hh
+19 -24
View File
@@ -30,34 +30,29 @@
#define G4DNAIndependentReactionTimeModel_hh 1
#include "G4String.hh"
#include "G4VITStepModel.hh"
#include <G4ReferenceCast.hh>
class G4DNAMolecularReactionTable;
class G4VDNAReactionModel;
class G4VReactionTypeManager;
class G4DNAIndependentReactionTimeModel
: public G4VITStepModel
class G4DNAIndependentReactionTimeModel : public G4VITStepModel
{
public:
explicit G4DNAIndependentReactionTimeModel(const G4String& name = "DNAIndependentReactionTimeModel");
G4DNAIndependentReactionTimeModel(const G4String& name,
std::unique_ptr<G4VITTimeStepComputer> pTimeStepper,
std::unique_ptr<G4VITReactionProcess> pReactionProcess);
G4DNAIndependentReactionTimeModel(const G4DNAIndependentReactionTimeModel&) = delete;
~G4DNAIndependentReactionTimeModel() override;
public:
explicit G4DNAIndependentReactionTimeModel(
const G4String& name = "DNAIndependentReactionTimeModel");
G4DNAIndependentReactionTimeModel(
const G4String& name, std::unique_ptr<G4VITTimeStepComputer> pTimeStepper,
std::unique_ptr<G4VITReactionProcess> pReactionProcess);
G4DNAIndependentReactionTimeModel(const G4DNAIndependentReactionTimeModel&) =
delete;
~G4DNAIndependentReactionTimeModel() override;
void PrintInfo() override;
void Initialize() override;
void SetReactionModel(G4VDNAReactionModel*);
G4VDNAReactionModel* GetReactionModel();
void PrintInfo() override;
void Initialize() override;
void SetReactionModel(G4VDNAReactionModel*);
G4VDNAReactionModel* GetReactionModel();
void SetReactionTypeManager(G4VReactionTypeManager* pReactionProcessManager);
protected:
const G4DNAMolecularReactionTable*& fMolecularReactionTable;
std::unique_ptr<G4VDNAReactionModel> fpReactionModel;
std::unique_ptr<G4VReactionTypeManager> fReactionTypeManager;
protected:
const G4DNAMolecularReactionTable*& fMolecularReactionTable =
reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable);
std::unique_ptr<G4VDNAReactionModel> fpReactionModel;
};
#endif
source/processes/electromagnetic/dna/models/include/G4DNAIndependentReactionTimeStepper.hh
+47 -52
View File
@@ -33,15 +33,15 @@
#include "G4VITTimeStepComputer.hh"
#include "G4KDTreeResult.hh"
#include "G4IRTUtils.hh"
#include "G4VReactionType.hh"
#include <memory>
#include <set>
#include "G4ITTrackHolder.hh"
#include "G4ITReaction.hh"
#include "G4ReferenceCast.hh"
class G4VReactionTypeManager;
class G4VDNAReactionModel;
class G4DNAMolecularReactionTable;
class G4MolecularConfiguration;
class G4DNAReactionTypeManager;
class G4Molecule;
class G4ITReactionSet;
class G4ITReactionChange;
@@ -50,61 +50,56 @@ class G4ITTrackHolder;
class G4DNAIndependentReactionTimeStepper : public G4VITTimeStepComputer
{
public:
G4DNAIndependentReactionTimeStepper();
~G4DNAIndependentReactionTimeStepper() override = default;
G4DNAIndependentReactionTimeStepper(const G4DNAIndependentReactionTimeStepper&) = delete;
G4DNAIndependentReactionTimeStepper& operator=(const G4DNAIndependentReactionTimeStepper&) = delete;
public:
G4DNAIndependentReactionTimeStepper();
~G4DNAIndependentReactionTimeStepper() override = default;
G4DNAIndependentReactionTimeStepper(
const G4DNAIndependentReactionTimeStepper&) = delete;
G4DNAIndependentReactionTimeStepper& operator =(
const G4DNAIndependentReactionTimeStepper&) = delete;
void Prepare() override;
G4double CalculateStep(const G4Track&, const G4double&) override;
G4double CalculateMinTimeStep(G4double, G4double) override;
void Prepare() override;
G4double CalculateStep(const G4Track&, const G4double&) override;
G4double CalculateMinTimeStep(G4double, G4double) override;
void SetReactionModel(G4VDNAReactionModel*);
G4VDNAReactionModel* GetReactionModel();
void SetReactionModel(G4VDNAReactionModel*);
G4VDNAReactionModel* GetReactionModel();
std::unique_ptr<G4ITReactionChange>
FindReaction(G4ITReactionSet* pReactionSet,
const G4double& currentStepTime = 0,
const G4double& previousStepTime = 0,
const G4bool& reachedUserStepTimeLimit = false);
std::unique_ptr<G4ITReactionChange> FindReaction(
G4ITReactionSet* pReactionSet, const G4double& currentStepTime = 0,
const G4double& previousStepTime = 0,
const G4bool& reachedUserStepTimeLimit = false);
void SetReactionProcess(G4VITReactionProcess* pReactionProcess);
void SetVerbose(G4int);
void SetReactionProcess(G4VITReactionProcess* pReactionProcess);
private:
void InitializeForNewTrack();
class Utils;
void CheckAndRecordResults(const Utils& utils);
void SetReactionTypeManager(G4VReactionTypeManager* typeManager);
void SetVerbose(G4int);
private:
void InitializeForNewTrack();
ReactionType GetReactionType(const G4Track& trackA, const G4Track& trackB);
G4double GetTimeToEncounter(const G4Track& trackA, const G4Track& trackB);
class Utils;
G4bool fHasAlreadyReachedNullTime = false;
const G4DNAMolecularReactionTable*& fMolecularReactionTable =
reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable);
G4VDNAReactionModel* fReactionModel = nullptr;
G4ITTrackHolder* fpTrackContainer = G4ITTrackHolder::Instance();
G4ITReactionSet* fReactionSet = G4ITReactionSet::Instance();
G4int fVerbose = 0;
G4double fRCutOff = G4IRTUtils::GetRCutOff();
G4VITReactionProcess* fpReactionProcess = nullptr;
std::map<G4int, G4ThreeVector> fSampledPositions;
std::set<G4int> fCheckedTracks;
void CheckAndRecordResults(const Utils& utils);
G4double GetTimeToEncounter(const G4Track& trackA,
const G4Track& trackB);
G4bool fHasAlreadyReachedNullTime;
const G4DNAMolecularReactionTable*& fMolecularReactionTable;
G4VDNAReactionModel* fReactionModel;
G4ITTrackHolder* fpTrackContainer;
G4ITReactionSet* fReactionSet;
G4int fVerbose;
G4double fRCutOff;
G4DNAReactionTypeManager* fReactionTypeManager;
G4VITReactionProcess* fpReactionProcess;
std::map<G4int,G4ThreeVector> fSampledPositions;
class Utils
{
public:
Utils(const G4Track& tA, const G4Track& tB);
~Utils() = default;
const G4Track& fTrackA;
const G4Track& fTrackB;
const G4Molecule* fpMoleculeA;
const G4Molecule* fpMoleculeB;
};
class Utils
{
public:
Utils(const G4Track& tA, const G4Track& tB);
~Utils() = default;
const G4Track& fTrackA;
const G4Track& fTrackB;
const G4Molecule* fpMoleculeA;
const G4Molecule* fpMoleculeB;
};
};
#endif
source/processes/electromagnetic/dna/models/include/G4DNAMillerGreenExcitationModel.hh
+7
View File
@@ -131,6 +131,13 @@ private:
G4DNAMillerGreenExcitationModel & operator=(const G4DNAMillerGreenExcitationModel &right);
G4DNAMillerGreenExcitationModel(const G4DNAMillerGreenExcitationModel&);
// Reusable particle definitions
G4ParticleDefinition* protonDef;
G4ParticleDefinition* hydrogenDef;
G4ParticleDefinition* alphaPlusPlusDef;
G4ParticleDefinition* alphaPlusDef;
G4ParticleDefinition* heliumDef;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/dna/models/include/G4DNARPWBAExcitationModel.hh
+105
View File
@@ -0,0 +1,105 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// Created on 2022/03/03
//
// Authors: A.D. Dominguez-Munoz, M.I. Gallardo, M.C. Bordage,
// Z. Francis, S. Incerti, M.A. Cortes-Giraldo
//
// Contact: M.A. Cortes-Giraldo (miancortes -at- us.es)
//
//
#ifndef G4DNARPWBAExcitationModel_h
#define G4DNARPWBAExcitationModel_h 1
#include "G4VEmModel.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4ProductionCutsTable.hh"
#include "G4DNACrossSectionDataSet.hh"
#include "G4LogLogInterpolation.hh"
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4DNAWaterExcitationStructure.hh"
#include "G4NistManager.hh"
class G4DNARPWBAExcitationModel : public G4VEmModel
{
public:
explicit G4DNARPWBAExcitationModel(
const G4ParticleDefinition* p = nullptr,
const G4String& nam = "DNARPWBAExcitationModel");
~G4DNARPWBAExcitationModel() override;
G4DNARPWBAExcitationModel& operator=(const G4DNARPWBAExcitationModel& right) =
delete;
G4DNARPWBAExcitationModel(const G4DNARPWBAExcitationModel&) = delete;
void Initialise(const G4ParticleDefinition*,
const G4DataVector& = *(new G4DataVector())) override;
G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p, G4double ekin,
G4double emin, G4double emax) override;
G4double GetPartialCrossSection(const G4Material*, G4int level,
const G4ParticleDefinition*,
G4double kineticEnergy) override;
void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*, const G4DynamicParticle*,
G4double tmin, G4double maxEnergy) override;
inline void SelectStationary(const G4bool& input);
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma = nullptr;
private:
// Partial cross section
G4int RandomSelect(G4double energy);
G4DNAWaterExcitationStructure waterStructure;
G4bool statCode = false;
// Water density table
const std::vector<G4double>* fpMolWaterDensity = nullptr;
G4bool isInitialised = false;
G4int verboseLevel = 0;
const G4ParticleDefinition* fParticleDefinition = G4Proton::ProtonDefinition();
G4double fLowEnergy = 0;
G4double fHighEnergy = 0;
G4String fTableFile;
std::unique_ptr<G4DNACrossSectionDataSet> fTableData;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline void G4DNARPWBAExcitationModel::SelectStationary(const G4bool& input)
{
statCode = input;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/dna/models/include/G4DNARPWBAIonisationModel.hh
+151
View File
@@ -0,0 +1,151 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// Created on 2022/03/03
//
// Authors: A.D. Dominguez-Munoz, M.I. Gallardo, M.C. Bordage,
// Z. Francis, S. Incerti, M.A. Cortes-Giraldo
//
// Contact: M.A. Cortes-Giraldo (miancortes -at- us.es)
//
//
#ifndef G4DNARPWBAIonisationModel_h
#define G4DNARPWBAIonisationModel_h 1
#include "G4VEmModel.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4ProductionCutsTable.hh"
#include "G4DNACrossSectionDataSet.hh"
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4DNAGenericIonsManager.hh"
#include "G4LogLogInterpolation.hh"
#include "G4DNAWaterIonisationStructure.hh"
#include "G4VAtomDeexcitation.hh"
#include "G4NistManager.hh"
class G4DNARPWBAIonisationModel : public G4VEmModel
{
public:
G4DNARPWBAIonisationModel(const G4ParticleDefinition* p = nullptr,
const G4String& nam = "DNARPWBAIonisationModel");
~G4DNARPWBAIonisationModel() override;
G4DNARPWBAIonisationModel& operator=(const G4DNARPWBAIonisationModel& right) =
delete;
G4DNARPWBAIonisationModel(const G4DNARPWBAIonisationModel&) = delete;
void Initialise(const G4ParticleDefinition*,
const G4DataVector& = *(new G4DataVector())) override;
G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p, G4double ekin,
G4double emin, G4double emax) override;
void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*, const G4DynamicParticle*,
G4double tmin, G4double maxEnergy) override;
G4double GetPartialCrossSection(const G4Material*, G4int /*level*/,
const G4ParticleDefinition*,
G4double /*kineticEnergy*/) override;
G4double DifferentialCrossSection(const G4double& k, const G4double& energyTransfer,
const G4int& shell);
G4double TransferedEnergy(G4double incomingParticleEnergy, G4int shell,
const G4double& random);
inline void SelectFasterComputation(const G4bool& input);
inline void SelectStationary(const G4bool& input);
inline void SelectSPScaling(const G4bool& input);
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma = nullptr;
private:
using MapData = std::map<G4String, std::unique_ptr<G4DNACrossSectionDataSet>,
std::less<G4String>>;
using TriDimensionMap = std::map<G4double, std::map<G4double, G4double>>;
using VecMap = std::map<G4double, std::vector<G4double>>;
// methods
G4double RandomizeEjectedElectronEnergy(const G4double&, const G4int& );
G4double RandomizeEjectedElectronEnergyFromCumulatedDcs(const G4double& incomingParticleEnergy,
const G4int& shell);
G4double Interpolate(const G4double& e1, const G4double& e2, const G4double& e, const G4double& xs1,
const G4double& xs2);
G4double QuadInterpolator(const G4double& e11, const G4double& e12, const G4double& e21,
const G4double& e22, const G4double& x11, const G4double& x12,
const G4double& x21, const G4double& x22, const G4double& t1,
const G4double& t2, const G4double& t, const G4double& e);
//shoud change to array ?
G4int RandomSelect(G4double energy);
void InitialiseForProton(const G4ParticleDefinition*);
G4bool InEnergyLimit(const G4double&);
//members
G4bool fasterCode = false;
G4bool statCode = false;
G4bool spScaling = true;
// Water density table
const std::vector<G4double>* fpMolWaterDensity = nullptr;
// Deexcitation manager to produce fluo photons and e-
G4VAtomDeexcitation* fAtomDeexcitation = nullptr;
G4double lowEnergyLimit = 0;
G4double highEnergyLimit = 0;
G4bool isInitialised = false;
G4int verboseLevel = 0;
// Cross section
std::unique_ptr<G4DNACrossSectionDataSet> fpTotalCrossSection;
// Final state
G4DNAWaterIonisationStructure waterStructure;
TriDimensionMap eDiffCrossSectionData[6];
TriDimensionMap eNrjTransfData[6]; // for cumulated dcs
TriDimensionMap pDiffCrossSectionData[6];
TriDimensionMap pNrjTransfData[6]; // for cumulated dcs
std::vector<G4double> eTdummyVec;
std::vector<G4double> pTdummyVec;
VecMap eVecm;
VecMap pVecm;
VecMap eProbaShellMap[6]; // for cumulated dcs
VecMap pProbaShellMap[6]; // for cumulated dcs
const G4ParticleDefinition* fProtonDef = G4Proton::ProtonDefinition();
};
inline void G4DNARPWBAIonisationModel::SelectFasterComputation(
const G4bool& input)
{
fasterCode = input;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline void G4DNARPWBAIonisationModel::SelectStationary(const G4bool& input)
{
statCode = input;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline void G4DNARPWBAIonisationModel::SelectSPScaling(const G4bool& input)
{
spScaling = input;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/dna/models/include/G4DNARuddIonisationExtendedModel.hh
+18
View File
@@ -158,12 +158,30 @@ private:
G4double Sum(G4double energy, const G4String& particle);
G4int RandomSelect(G4double energy,const G4String& particle );
G4ParticleDefinition* GetDNAIonParticleDefinition(const G4ParticleDefinition* particleDefinition);
//
G4DNARuddIonisationExtendedModel & operator=(const G4DNARuddIonisationExtendedModel &right);
G4DNARuddIonisationExtendedModel(const G4DNARuddIonisationExtendedModel&);
// Reusable particle definitions
G4ParticleDefinition* protonDef;
G4ParticleDefinition* hydrogenDef;
G4ParticleDefinition* alphaPlusPlusDef;
G4ParticleDefinition* alphaPlusDef;
G4ParticleDefinition* heliumDef;
//G4ParticleDefinition* lithiumDef;
//G4ParticleDefinition* berylliumDef;
//G4ParticleDefinition* boronDef;
G4ParticleDefinition* carbonDef;
G4ParticleDefinition* nitrogenDef;
G4ParticleDefinition* oxygenDef;
G4ParticleDefinition* siliconDef;
G4ParticleDefinition* ironDef;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/dna/models/include/G4DNARuddIonisationModel.hh
+7
View File
@@ -155,6 +155,13 @@ private:
G4DNARuddIonisationModel & operator=(const G4DNARuddIonisationModel &right);
G4DNARuddIonisationModel(const G4DNARuddIonisationModel&);
// Reusable particle definitions
G4ParticleDefinition* protonDef;
G4ParticleDefinition* hydrogenDef;
G4ParticleDefinition* alphaPlusPlusDef;
G4ParticleDefinition* alphaPlusDef;
G4ParticleDefinition* heliumDef;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/dna/models/include/G4DNASmoluchowskiReactionModel.hh
+1 -1
View File
@@ -73,7 +73,7 @@ public :
virtual void InitialiseToPrint(const G4MolecularConfiguration*) ;
virtual G4double GetReactionRadius(const G4MolecularConfiguration*,
const G4MolecularConfiguration*);
virtual G4double GetReactionRadius(const G4int);
virtual G4double GetReactionRadius(const G4int&);
virtual G4bool FindReaction(const G4Track&,
const G4Track&,
source/processes/electromagnetic/dna/models/include/G4DNATotallyDiffusionControlled.hh
-58
View File
@@ -1,58 +0,0 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// 20/2/2019
// Author : HoangTRAN
#ifndef G4DNATotallyDiffusionControlled_h
#define G4DNATotallyDiffusionControlled_h 1
#include "G4DNAReactionTypeManager.hh"
#include "G4VReactionType.hh"
class G4MolecularConfiguration;
class G4DNAMolecularReactionTable;
class G4VDNAReactionModel;
class G4DNATotallyDiffusionControlled
: public G4VReactionType
{
public:
G4DNATotallyDiffusionControlled();
~G4DNATotallyDiffusionControlled() override;
G4DNATotallyDiffusionControlled(const G4DNATotallyDiffusionControlled& other) = delete;
G4DNATotallyDiffusionControlled& operator=(const G4DNATotallyDiffusionControlled& other) = delete;
G4double GetTimeToEncounter(const G4Track& trackA,
const G4Track& trackB) override;
G4bool GeminateRecombinationProbability(const G4MolecularConfiguration* pConfMolA,
const G4MolecularConfiguration* pConfMolB) override;
private:
G4double GetDiffusionCoefficient(const G4MolecularConfiguration* pMA,
const G4MolecularConfiguration* pMB);
};
#endif
source/processes/electromagnetic/dna/models/include/G4DNAUpdateSystemModel.hh
+8 -11
View File
@@ -36,7 +36,7 @@ class G4DNAMolecularReactionData;
class G4DNAUpdateSystemModel : public G4VUpdateSystemModel
{
public:
using Index = G4Voxel::Index;
using Index = G4VDNAMesh::Index;
using MolType = const G4MolecularConfiguration*;
using JumpingData = std::pair<MolType, Index>;
using ReactionData = const G4DNAMolecularReactionData;
@@ -45,21 +45,18 @@ class G4DNAUpdateSystemModel : public G4VUpdateSystemModel
~G4DNAUpdateSystemModel() override = default;
void UpdateSystem(const Index& index, const ReactionData& data);
void UpdateSystem(const Index& index, const JumpingData& data);
void KillMolecule(const Index& index, MolType type);
void CreateMolecule(const Index& index, MolType);
void JumpTo(const Index& index, MolType type);
void JumpIn(const Index& index, MolType);
void SetMesh(G4DNAMesh*);
void SetGlobalTime(const G4double& globalTime) { fGlobalTime = globalTime; }
void SetVerbose(G4int verbose) { fVerbose = verbose; }
private:
G4DNAMesh* fpMesh;
G4int fVerbose;
G4double fGlobalTime;
void KillMolecule(const Index& index, MolType type);
void CreateMolecule(const Index& index, MolType);
void JumpTo(const Index& index, MolType type);
void JumpIn(const Index& index, MolType);
G4DNAMesh* fpMesh = nullptr;
G4int fVerbose = 0;
G4double fGlobalTime = DBL_MAX;
};
#endif // G4DNAUPDATESYSTEMMODEL_HH
source/processes/electromagnetic/dna/models/include/G4DiffusionControlledReactionModel.hh
+23 -24
View File
@@ -32,35 +32,34 @@
#include "G4VDNAReactionModel.hh"
#include <vector>
class G4DNAMolecularReactionData;
class G4VReactionTypeManager;
class G4DNAReactionTypeManager;
class G4DiffusionControlledReactionModel : public G4VDNAReactionModel
{
public :
G4DiffusionControlledReactionModel();
~G4DiffusionControlledReactionModel() override;
public:
G4DiffusionControlledReactionModel();
~G4DiffusionControlledReactionModel() override;
G4DiffusionControlledReactionModel(const G4DiffusionControlledReactionModel&) = delete;
G4DiffusionControlledReactionModel& operator=(const G4DiffusionControlledReactionModel&) = delete;
G4DiffusionControlledReactionModel(
const G4DiffusionControlledReactionModel&) = delete;
G4DiffusionControlledReactionModel& operator =(
const G4DiffusionControlledReactionModel&) = delete;
void Initialise(const G4MolecularConfiguration*, const G4Track&) override;
void InitialiseToPrint(const G4MolecularConfiguration*) override;
G4double GetReactionRadius(const G4MolecularConfiguration*,
const G4MolecularConfiguration*) override;
G4double GetReactionRadius(G4int) override;
void Initialise(const G4MolecularConfiguration*, const G4Track&) override;
void InitialiseToPrint(const G4MolecularConfiguration*) override;
G4double GetReactionRadius(const G4MolecularConfiguration*,
const G4MolecularConfiguration*) override;
G4double GetReactionRadius(const G4int&) override;
G4bool FindReaction(const G4Track&,
const G4Track&,
G4double /*reactionRadius*/,
G4double& /*separationDistance*/,
G4bool /*alongStepInteraction*/) override
{return true;}
void SetReactionTypeManager(G4VReactionTypeManager* typeManager);
private :
const std::vector<const G4DNAMolecularReactionData*>* fpReactionData ;
G4DNAReactionTypeManager* fReactionTypeManager;
G4bool FindReaction(const G4Track&, const G4Track&,
G4double /*reactionRadius*/,
G4double& /*separationDistance*/,
G4bool /*alongStepInteraction*/) override
{
return true;
}
G4double GetTimeToEncounter(const G4Track& trackA, const G4Track& trackB);
private:
const std::vector<const G4DNAMolecularReactionData*>* fpReactionData =
nullptr;
};
#endif
source/processes/electromagnetic/dna/models/include/G4DNAPartiallyDiffusionControlled.hh → source/processes/electromagnetic/dna/models/include/G4VDNAHitModel.hh
+24 -26
View File
@@ -23,34 +23,32 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// 20/2/2019
// Author : HoangTRAN
#ifndef G4VDNAHitModel_hh
#define G4VDNAHitModel_hh
#include "globals.hh"
#include <vector>
#include <variant>
class G4DNAComponentNode;
class G4VPhysicalVolume;
class G4Track;
#ifndef G4DNAPartiallyDiffusionControlled_h
#define G4DNAPartiallyDiffusionControlled_h 1
#include "G4DNAReactionTypeManager.hh"
#include "G4VReactionType.hh"
class G4MolecularConfiguration;
class G4DNAPartiallyDiffusionControlled
: public G4VReactionType
class G4VDNAHitModel
{
public:
G4DNAPartiallyDiffusionControlled();
~G4DNAPartiallyDiffusionControlled() override;
G4DNAPartiallyDiffusionControlled(const G4DNAPartiallyDiffusionControlled& other) = delete;
G4DNAPartiallyDiffusionControlled& operator=(const G4DNAPartiallyDiffusionControlled& other) = delete;
using DNANode =
std::variant<const G4DNAComponentNode*, /*for dnadamage chain*/
const G4VPhysicalVolume* /*for molecularDNA chain*/>;
G4double GetTimeToEncounter(const G4Track& trackA,
const G4Track& trackB) override;
public:
explicit G4VDNAHitModel(const G4String& name);
virtual ~G4VDNAHitModel() = default;
// delete assignment operator
G4VDNAHitModel& operator=(const G4VDNAHitModel& right) = delete;
G4VDNAHitModel(const G4VDNAHitModel&) = delete;
virtual G4double CalculateReactionTime(const G4Track& trackA, DNANode&) = 0;
virtual G4bool DoReaction(const G4Track& track, const G4double&,
const DNANode&) = 0;
G4bool GeminateRecombinationProbability(const G4MolecularConfiguration*,
const G4MolecularConfiguration*) override;
private:
G4double GetDiffusionCoefficient(const G4MolecularConfiguration*,
const G4MolecularConfiguration*);
private:
const G4String fName;
};
#endif
#endif