G4DNAMoleculeEncounterStepper Class Reference

#include <G4DNAMoleculeEncounterStepper.hh>

Inheritance diagram for G4DNAMoleculeEncounterStepper:

Public Member Functions
	G4DNAMoleculeEncounterStepper ()
virtual	~G4DNAMoleculeEncounterStepper ()
	G4DNAMoleculeEncounterStepper (const G4DNAMoleculeEncounterStepper &)
virtual void	Prepare ()
virtual G4double	CalculateStep (const G4Track &, const G4double &)
void	SetReactionModel (G4VDNAReactionModel *)
G4VDNAReactionModel *	GetReactionModel ()
void	SetVerbose (int)
Public Member Functions inherited from G4VITTimeStepper
	G4VITTimeStepper ()
virtual	~G4VITTimeStepper ()
	G4VITTimeStepper (const G4VITTimeStepper &)
G4VITTimeStepper &	operator= (const G4VITTimeStepper &other)
virtual void	Initialize ()
virtual void	Prepare ()
virtual G4double	CalculateStep (const G4Track &, const G4double &)=0
G4TrackVectorHandle	GetReactants ()
virtual void	ResetReactants ()
G4double	GetSampledMinTimeStep ()
void	SetReactionTable (const G4ITReactionTable *)
const G4ITReactionTable *	GetReactionTable ()

Additional Inherited Members
Static Public Member Functions inherited from G4VITTimeStepper
static void	SetTimes (const G4double &, const G4double &)
Protected Attributes inherited from G4VITTimeStepper
G4double	fSampledMinTimeStep
G4TrackVectorHandle	fReactants
const G4ITReactionTable *	fpReactionTable
Static Protected Attributes inherited from G4VITTimeStepper
static G4double	fCurrentGlobalTime = -1
static G4double	fUserMinTimeStep = -1

Detailed Description

Given a molecule G4DNAMoleculeEncounterStepper will calculate for its possible reactants what will be the minimum encounter time and the associated molecules.*

This model includes dynamical time steps as explained in "Computer-Aided Stochastic Modeling of the Radiolysis of Liquid Water", V. Michalik, M. Begusová, E. A. Bigildeev, Radiation Research, Vol. 149, No. 3 (Mar., 1998), pp. 224-236

Definition at line 61 of file G4DNAMoleculeEncounterStepper.hh.

Constructor & Destructor Documentation

G4DNAMoleculeEncounterStepper() [1/2]

G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper

(

)

Definition at line 47 of file G4DNAMoleculeEncounterStepper.cc.

                                                             :
    G4VITTimeStepper(),
    fMolecularReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable)),
    fReactionModel(0)
{
    fVerbose = 0;
    fHasAlreadyReachedNullTime = false;
}

~G4DNAMoleculeEncounterStepper()

G4DNAMoleculeEncounterStepper::~G4DNAMoleculeEncounterStepper ( )

virtual

Definition at line 66 of file G4DNAMoleculeEncounterStepper.cc.

{}

G4DNAMoleculeEncounterStepper() [2/2]

G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper

(

const G4DNAMoleculeEncounterStepper &

right

)

Definition at line 69 of file G4DNAMoleculeEncounterStepper.cc.

                                                                                                       :
    G4VITTimeStepper(right),
    fMolecularReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
{
    fVerbose                    = right.fVerbose ;
    fMolecularReactionTable     = right.fMolecularReactionTable;
    fReactionModel              = 0;
    fHasAlreadyReachedNullTime  = false;
}

Member Function Documentation

CalculateStep()

G4double G4DNAMoleculeEncounterStepper::CalculateStep ( const G4Track &  trackA, const G4double &  userMinTimeStep  )

virtual

Implements G4VITTimeStepper.

Definition at line 87 of file G4DNAMoleculeEncounterStepper.cc.

{
    // DEBUG
    //    G4cout << "G4MoleculeEncounterStepper::CalculateStep, time :" << G4ITTrackHolder::Instance()->GetGlobalTime()  << G4endl;
 
    G4Molecule* moleculeA = GetMolecule(trackA);
 
 
#ifdef G4VERBOSE
    if(fVerbose)
    {
        G4cout << "_______________________________________________________________________" << G4endl;
        G4cout << "G4DNAMoleculeEncounterStepper::CalculateStep" << G4endl;
        G4cout << "Incident molecule : " << moleculeA->GetName()
               << " (" << trackA.GetTrackID() << ") "
               << G4endl;
    }
#endif
 
    //__________________________________________________________________
    // Retrieve general informations for making reactions
    const vector<const G4Molecule*>* reactivesVector =
            fMolecularReactionTable -> CanReactWith(moleculeA);
 
    if(!reactivesVector)
    {
#ifdef G4VERBOSE
        //    DEBUG
        if(fVerbose > 1)
        {
            G4cout << "!!!!!!!!!!!!!!!!!!!!"<<G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4MoleculeEncounterStepper::CalculateStep will return infinity for the reaction because the molecule "
                   << moleculeA->GetName()
                   << " does not have any reactants given in the reaction table."
                   << G4endl;
            G4cout << "!!!!!!!!!!!!!!!!!!!!"<<G4endl;
        }
#endif
        return DBL_MAX;
    }
 
    G4int nbReactives = reactivesVector->size();
 
    if(nbReactives == 0)
    {
#ifdef G4VERBOSE
        //    DEBUG
        if(fVerbose)
        {
            G4cout << "!!!!!!!!!!!!!!!!!!!!"<<G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4MoleculeEncounterStepper::CalculateStep will return infinity for the reaction because the molecule "
                   << moleculeA->GetName()
                   << " does not have any reactants given in the reaction table."
                   << "This message can also result from a wrong implementation of the reaction table."
                   << G4endl;
            G4cout << "!!!!!!!!!!!!!!!!!!!!"<<G4endl;
        }
#endif
        return DBL_MAX;
    }
    // DEBUG
    //    else
    //    {
    //        G4cout << "nb reactants : " << nbReactives << " pour mol "<< moleculeA -> GetName () << G4endl;
    //        for(int k=0 ; k < nbReactives ; k++)
    //        {
    //            G4cout << (*reactivesVector)[k]->GetName() << G4endl;
    //        }
    //    }
 
    fUserMinTimeStep = userMinTimeStep ;
    if(fReactants) fReactants = 0 ;
    fReactants = new vector<G4Track*>();
 
    fSampledMinTimeStep = DBL_MAX;
    fHasAlreadyReachedNullTime = false;
 
    fReactionModel -> Initialise(moleculeA, trackA) ;
 
    //__________________________________________________________________
    // Start looping on possible reactants
    for (G4int i=0 ; i<nbReactives ; i++)
    {
        const G4Molecule* moleculeB = (*reactivesVector)[i];
 
        //______________________________________________________________
        // Retrieve reaction range
        G4double R = -1 ; // reaction Range
        R = fReactionModel -> GetReactionRadius(i);
 
        //______________________________________________________________
        // Use KdTree algorithm to find closest reactants
        G4KDTreeResultHandle results (G4ITManager<G4Molecule>::Instance()
                                      -> FindNearest(moleculeA, moleculeB));
 
        RetrieveResults(trackA,moleculeA,moleculeB,R,results, true);
    }
 
#ifdef G4VERBOSE
    //    DEBUG
    if(fVerbose)
    {
        G4cout << "G4MoleculeEncounterStepper::CalculateStep will finally return :"
               << G4BestUnit(fSampledMinTimeStep, "Time")<< G4endl;
 
        if(fVerbose > 1)
        {
            G4cout << "TrackA: " << moleculeA->GetName() << " (" << trackA.GetTrackID() << ") can react with: ";
 
            vector<G4Track*>::iterator it;
            for(it = fReactants->begin() ; it != fReactants->end() ; it++)
            {
                G4Track* trackB = *it;
                G4cout << GetMolecule(trackB)->GetName() << " ("
                       << trackB->GetTrackID() << ") \t ";
            }
            G4cout << G4endl;
        }
    }
#endif
    return fSampledMinTimeStep ;
}

GetReactionModel()

G4VDNAReactionModel * G4DNAMoleculeEncounterStepper::GetReactionModel ( )

inline

Definition at line 98 of file G4DNAMoleculeEncounterStepper.hh.

{
    return fReactionModel;
}

Prepare()

void G4DNAMoleculeEncounterStepper::Prepare ( )

virtual

Reimplemented from G4VITTimeStepper.

Definition at line 79 of file G4DNAMoleculeEncounterStepper.cc.

{
    // DEBUG
    //    G4cout << "G4DNAMoleculeEncounterStepper::PrepareForAllProcessors" << G4endl;
    G4VITTimeStepper::Prepare();
    G4ITManager<G4Molecule>::Instance()->UpdatePositionMap();
}

SetReactionModel()

void G4DNAMoleculeEncounterStepper::SetReactionModel ( G4VDNAReactionModel *  reactionModel )

inline

Definition at line 93 of file G4DNAMoleculeEncounterStepper.hh.

{
    fReactionModel = reactionModel ;
}

SetVerbose()

void G4DNAMoleculeEncounterStepper::SetVerbose ( int  flag )

inline

Definition at line 103 of file G4DNAMoleculeEncounterStepper.hh.

{
    fVerbose = flag;
}

---

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

• G4DNAMoleculeEncounterStepper.hh
• G4DNAMoleculeEncounterStepper.cc