#include <G4DNAMolecularReaction.hh>

Inheritance diagram for G4DNAMolecularReaction:

Public Member Functions
	G4DNAMolecularReaction ()

virtual	~G4DNAMolecularReaction ()

	G4DNAMolecularReaction (const G4DNAMolecularReaction &other)

G4DNAMolecularReaction &	operator= (const G4DNAMolecularReaction &other)

virtual G4bool	TestReactibility (const G4Track &, const G4Track &, const double currentStepTime, const double previousStepTime, bool userStepTimeLimit)

virtual G4ITReactionChange *	MakeReaction (const G4Track &, const G4Track &)

void	SetReactionModel (G4VDNAReactionModel *)

void	SetReactionTable (const G4DNAMolecularReactionTable *)

void	SetVerbose (int)

Public Member Functions inherited from G4VITReactionProcess
	G4VITReactionProcess ()

virtual	~G4VITReactionProcess ()

	G4VITReactionProcess (const G4VITReactionProcess &other)

G4VITReactionProcess &	operator= (const G4VITReactionProcess &other)

virtual void	Initialize ()

virtual G4bool	IsApplicable (G4ITType, G4ITType) const

virtual G4bool	TestReactibility (const G4Track &, const G4Track &, const double, const double, bool)=0

virtual G4ITReactionChange *	MakeReaction (const G4Track &, const G4Track &)=0

void	SetReactionTable (const G4ITReactionTable *)

void	ResetChanges ()

Protected Attributes
const G4DNAMolecularReactionTable *&	fMolReactionTable

G4VDNAReactionModel *	fReactionModel

G4int	fVerbose

G4double	fReactionRadius

G4double	fDistance

Protected Attributes inherited from G4VITReactionProcess
const G4ITReactionTable *	fpReactionTable

G4ITReactionChange *	fpChanges

G4String	fName

Detailed Description

G4DNAMolecularReaction is the reaction process used in G4DNAMolecularStepByStepModel between two molecules. After the global track steps, it test whether the molecules can react. If so, the reaction is made.

Definition at line 55 of file G4DNAMolecularReaction.hh.

Constructor & Destructor Documentation

◆ G4DNAMolecularReaction() [1/2]

G4DNAMolecularReaction::G4DNAMolecularReaction ( )

Default constructor

Definition at line 47 of file G4DNAMolecularReaction.cc.

                                              :G4VITReactionProcess(),
    fMolReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
{
    //ctor
    fVerbose        = 0;
    fReactionModel  = 0;
    fReactionRadius = -1;
    fDistance       = -1;
}

◆ ~G4DNAMolecularReaction()

G4DNAMolecularReaction::~G4DNAMolecularReaction ( )

virtual

Default destructor

Definition at line 57 of file G4DNAMolecularReaction.cc.

{
    //dtor
    if(fpChanges) delete fpChanges;
}

◆ G4DNAMolecularReaction() [2/2]

G4DNAMolecularReaction::G4DNAMolecularReaction ( const G4DNAMolecularReaction & other )

Copy constructor

Parameters

other Object to copy from

Definition at line 63 of file G4DNAMolecularReaction.cc.

                                                                                 :G4VITReactionProcess(other),
    fMolReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
{
    //copy ctor
    fVerbose            = other.fVerbose ;
    fMolReactionTable   = other.fMolReactionTable;
    fReactionModel      = 0;
    fReactionRadius     = -1;
    fDistance           = -1;
}

Member Function Documentation

◆ MakeReaction()

G4ITReactionChange * G4DNAMolecularReaction::MakeReaction	(	const G4Track &	trackA,
		const G4Track &	trackB
	)

virtual

Will generate the products of the two given tracks

Implements G4VITReactionProcess.

Definition at line 149 of file G4DNAMolecularReaction.cc.

{
    fpChanges = new G4ITReactionChange();
    fpChanges->Initialize(trackA, trackB);
 
    G4Molecule* moleculeA = GetMolecule(trackA);
    G4Molecule* moleculeB = GetMolecule(trackB);
 
#ifdef G4VERBOSE
    // DEBUG
    if(fVerbose)
    {
        G4cout << "G4DNAMolecularReaction::MakeReaction" << G4endl;
        G4cout<<"TrackA n°"                     << trackA.GetTrackID()
             <<"\t | Track B n°"                << trackB.GetTrackID() << G4endl;
 
        G4cout<<"Track A : Position : "         << G4BestUnit(trackA.GetPosition(),"Length")
             <<"\t Global Time : "              << G4BestUnit(trackA.GetGlobalTime(), "Time")<< G4endl;
 
        G4cout<<"Track B : Position : "         << G4BestUnit(trackB.GetPosition() ,"Length")
             <<"\t Global Time : "              << G4BestUnit(trackB.GetGlobalTime(), "Time")<< G4endl;
 
        G4cout<<"Reaction range : "             << G4BestUnit(fReactionRadius,"Length")
             << " \t Separation distance : "    << G4BestUnit(fDistance,"Length")<< G4endl;
        G4cout << "--------------------------------------------" << G4endl;
    }
#endif
 
    const G4DNAMolecularReactionData* reactionData =  fMolReactionTable->GetReactionData(moleculeA, moleculeB);
 
    G4int nbProducts = reactionData->GetNbProducts();
 
    if (nbProducts)
    {
        G4double D1 = moleculeA->GetDiffusionCoefficient();
        G4double D2 = moleculeB->GetDiffusionCoefficient();
        G4double sqrD1 = sqrt(D1);
        G4double sqrD2 = sqrt(D2);
        G4double numerator = sqrD1 + sqrD2;
        G4ThreeVector reactionSite = sqrD1/numerator * trackA.GetPosition()
                                   + sqrD2/numerator * trackB.GetPosition()  ;
 
        for (G4int j=0 ; j < nbProducts; j++)
        {
            G4Molecule* product = new G4Molecule(*reactionData->GetProduct(j));
            G4Track* productTrack = product->BuildTrack(trackA.GetGlobalTime(),
                                                        reactionSite);
 
            productTrack->SetTrackStatus(fAlive);
 
            fpChanges->AddSecondary(productTrack);
            G4ITManager<G4Molecule>::Instance()->Push(productTrack);
        }
    }
 
    fpChanges->KillParents(true);
 
    return fpChanges;
}

◆ operator=()

G4DNAMolecularReaction & G4DNAMolecularReaction::operator= ( const G4DNAMolecularReaction & other )

Assignment operator

Parameters

other Object to assign from

Returns: A reference to this

Definition at line 74 of file G4DNAMolecularReaction.cc.

{
    if (this == &rhs) return *this; // handle self assignment
 
    fVerbose            = rhs.fVerbose ;
    fMolReactionTable   = rhs.fMolReactionTable;
    fReactionRadius     = -1;
    fDistance           = -1;
 
    //assignment operator
    return *this;
}

◆ SetReactionModel()

void G4DNAMolecularReaction::SetReactionModel ( G4VDNAReactionModel * model )

inline

Definition at line 102 of file G4DNAMolecularReaction.hh.

{
    fReactionModel = model;
}

◆ SetReactionTable()

void G4DNAMolecularReaction::SetReactionTable ( const G4DNAMolecularReactionTable * )

inline

◆ SetVerbose()

void G4DNAMolecularReaction::SetVerbose ( int verb )

inline

Definition at line 107 of file G4DNAMolecularReaction.hh.

{
    fVerbose = verb;
}

◆ TestReactibility()

G4bool G4DNAMolecularReaction::TestReactibility	(	const G4Track &	trackA,
		const G4Track &	trackB,
		const double	currentStepTime,
		const double	previousStepTime,
		bool	userStepTimeLimit
	)

virtual

Given two tracks, it tells you whether they can react

Implements G4VITReactionProcess.

Definition at line 87 of file G4DNAMolecularReaction.cc.

{
    G4Molecule* moleculeA = GetMolecule(trackA);
    G4Molecule* moleculeB = GetMolecule(trackB);
 
    if(!fReactionModel)
    {
        G4ExceptionDescription exceptionDescription ("You have to give a reaction model to the molecular reaction process");
        G4Exception("G4DNAMolecularReaction::TestReactibility","MolecularReaction001",
                    FatalErrorInArgument,exceptionDescription);
        return false; // makes coverity happy
    }
    if(fMolReactionTable==0)
    {
        G4ExceptionDescription exceptionDescription ("You have to give a reaction table to the molecular reaction process");
        G4Exception("G4DNAMolecularReaction::TestReactibility","MolecularReaction002",
                    FatalErrorInArgument,exceptionDescription);
        return false; // makes coverity happy
    }
 
    // Retrieve reaction range
    fReactionRadius = -1 ; // reaction Range
    fReactionRadius = fReactionModel -> GetReactionRadius(moleculeA, moleculeB);
 
    fDistance = -1 ; // separation distance
 
    if(currentStepTime == 0.)
    {
        userStepTimeLimit = false;
    }
 
    G4bool output = fReactionModel->FindReaction(trackA, trackB, fReactionRadius,fDistance, userStepTimeLimit);
 
#ifdef G4VERBOSE
    //    DEBUG
    if(fVerbose > 1)
    {
        G4cout << "\033[1;39;36m" << "G4MolecularReaction "<< G4endl;
        G4cout << "FindReaction returned : " << G4BestUnit(output,"Length") << G4endl;
        G4cout << " reaction radius : " << G4BestUnit(fReactionRadius,"Length")
               << " real distance : " << G4BestUnit((trackA.GetPosition() - trackB.GetPosition()).mag(), "Length")
               << " calculated distance by model (= -1 if real distance > reaction radius and the user limitation step is not reached) : "
               << G4BestUnit(fDistance,"Length")
               << G4endl;
 
        G4cout << "TrackID A : " << trackA.GetTrackID()
               << ", TrackID B : " << trackB.GetTrackID()
               << " | MolA " << moleculeA->GetName()
               << ", MolB " << moleculeB->GetName()
               <<"\033[0m\n"
               << G4endl;
        G4cout << "--------------------------------------------" << G4endl;
    }
#endif
    return output ;
}

Member Data Documentation

◆ fDistance

G4double G4DNAMolecularReaction::fDistance

protected

Definition at line 98 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), MakeReaction(), operator=(), and TestReactibility().

◆ fMolReactionTable

const G4DNAMolecularReactionTable*& G4DNAMolecularReaction::fMolReactionTable

protected

Definition at line 94 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), MakeReaction(), operator=(), and TestReactibility().

◆ fReactionModel

G4VDNAReactionModel* G4DNAMolecularReaction::fReactionModel

protected

Definition at line 95 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), SetReactionModel(), and TestReactibility().

◆ fReactionRadius

G4double G4DNAMolecularReaction::fReactionRadius

protected

Definition at line 97 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), MakeReaction(), operator=(), and TestReactibility().

◆ fVerbose

G4int G4DNAMolecularReaction::fVerbose

protected

Definition at line 96 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), MakeReaction(), operator=(), SetVerbose(), and TestReactibility().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4DNAMolecularReaction() [1/2]

◆ ~G4DNAMolecularReaction()

◆ G4DNAMolecularReaction() [2/2]

Member Function Documentation

◆ MakeReaction()

◆ operator=()

◆ SetReactionModel()

◆ SetReactionTable()

◆ SetVerbose()

◆ TestReactibility()

Member Data Documentation

◆ fDistance

◆ fMolReactionTable

◆ fReactionModel

◆ fReactionRadius

◆ fVerbose