#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

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::G4DNAMolecularReaction ( )

Default constructor

Definition at line 47 of file G4DNAMolecularReaction.cc.

References fDistance, fReactionModel, fReactionRadius, and fVerbose.

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

G4DNAMolecularReaction::~G4DNAMolecularReaction ( )

virtual

Default destructor

Definition at line 57 of file G4DNAMolecularReaction.cc.

References G4VITReactionProcess::fpChanges.

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

G4DNAMolecularReaction::G4DNAMolecularReaction ( const G4DNAMolecularReaction & other )

Copy constructor

Parameters

other Object to copy from

Definition at line 63 of file G4DNAMolecularReaction.cc.

References fDistance, fMolReactionTable, fReactionModel, fReactionRadius, and fVerbose.

                                                                                  :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

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.

References G4ITReactionChange::AddSecondary(), G4Molecule::BuildTrack(), fAlive, fDistance, fMolReactionTable, G4VITReactionProcess::fpChanges, fReactionRadius, fVerbose, G4BestUnit, G4cout, G4endl, G4Molecule::GetDiffusionCoefficient(), G4Track::GetGlobalTime(), GetMolecule(), G4DNAMolecularReactionData::GetNbProducts(), G4Track::GetPosition(), G4DNAMolecularReactionData::GetProduct(), G4DNAMolecularReactionTable::GetReactionData(), G4Track::GetTrackID(), G4ITReactionChange::Initialize(), G4ITManager< T >::Instance(), G4ITReactionChange::KillParents(), and G4Track::SetTrackStatus().

 {
     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;
 }

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.

References fDistance, fMolReactionTable, fReactionRadius, and fVerbose.

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

void G4DNAMolecularReaction::SetReactionModel ( G4VDNAReactionModel * model )

inline

Definition at line 102 of file G4DNAMolecularReaction.hh.

References fReactionModel.

 {
     fReactionModel = model;
 }

void G4DNAMolecularReaction::SetReactionTable ( const G4DNAMolecularReactionTable * )

inline

void G4DNAMolecularReaction::SetVerbose ( int verb )

inline

Definition at line 107 of file G4DNAMolecularReaction.hh.

References fVerbose.

 {
     fVerbose = verb;
 }

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.

References FatalErrorInArgument, fDistance, G4VDNAReactionModel::FindReaction(), fMolReactionTable, fReactionModel, fReactionRadius, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), GetMolecule(), G4Molecule::GetName(), G4Track::GetPosition(), and G4Track::GetTrackID().

 {
     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 ;
 }