#include <G4DNAWaterDissociationDisplacer.hh>

Inheritance diagram for G4DNAWaterDissociationDisplacer:

Collaboration diagram for G4DNAWaterDissociationDisplacer:

Public Member Functions
	G4DNAWaterDissociationDisplacer ()

virtual	~G4DNAWaterDissociationDisplacer ()

virtual std::vector< G4ThreeVector >	GetProductsDisplacement (const G4MolecularDissociationChannel *) const

virtual G4ThreeVector	GetMotherMoleculeDisplacement (const G4MolecularDissociationChannel *) const

G4ThreeVector	radialDistributionOfElectron () const

G4ThreeVector	radialDistributionOfProducts (G4double r_rms) const

Public Member Functions inherited from G4VMolecularDecayDisplacer
void	SetVerbose (G4int)

virtual	~G4VMolecularDecayDisplacer ()

Static Public Member Functions
static G4double	ElectronProbaDistribution (G4double r)

Static Public Attributes
static G4DLLIMPORT const DisplacementType	Ionisation_DissociationDecay

static G4DLLIMPORT const DisplacementType	A1B1_DissociationDecay

static G4DLLIMPORT const DisplacementType	B1A1_DissociationDecay

static G4DLLIMPORT const DisplacementType	AutoIonisation

static G4DLLIMPORT const DisplacementType	DissociativeAttachment

Static Public Attributes inherited from G4VMolecularDecayDisplacer
static G4DLLIMPORT const DisplacementType	NoDisplacement

Private Attributes
std::function< G4double(G4double)>	fProba1DFunction

std::vector< G4double >	fElectronThermalization

G4DNARevertProbability	fFastElectronDistrib

Additional Inherited Members
Protected Member Functions inherited from G4VMolecularDecayDisplacer
	G4VMolecularDecayDisplacer ()

Static Protected Member Functions inherited from G4VMolecularDecayDisplacer
static DisplacementType	AddDisplacement ()

Protected Attributes inherited from G4VMolecularDecayDisplacer
G4int	fVerbose

Static Protected Attributes inherited from G4VMolecularDecayDisplacer
static DisplacementType *	Last = 0

Detailed Description

Definition at line 54 of file G4DNAWaterDissociationDisplacer.hh.

Constructor & Destructor Documentation

◆ G4DNAWaterDissociationDisplacer()

G4DNAWaterDissociationDisplacer::G4DNAWaterDissociationDisplacer ( )

Definition at line 76 of file G4DNAWaterDissociationDisplacer.cc.

                                                                  :
     G4VMolecularDecayDisplacer(),
     fFastElectronDistrib(0, 10, 0.001)
 {
   fProba1DFunction =
       std::bind((G4double(*)(G4double))
                 &G4DNAWaterDissociationDisplacer::ElectronProbaDistribution,
                 std::placeholders::_1);
 
   size_t nBins = 100;
 
   fElectronThermalization.reserve(nBins);
 
   double eps = 1./((int)nBins);
 
   // G4cout << "eps = " << eps << G4endl;
 
   double proba = eps;
 
   fElectronThermalization.push_back(0.);
 
   for(size_t i = 1 ; i < nBins ; ++i)
   {
     double r = fFastElectronDistrib.Revert(proba, fProba1DFunction);
     fElectronThermalization.push_back(r);
     proba+=eps;
   }
 }

Here is the call graph for this function:

◆ ~G4DNAWaterDissociationDisplacer()

G4DNAWaterDissociationDisplacer::~G4DNAWaterDissociationDisplacer ( )

virtual

Definition at line 107 of file G4DNAWaterDissociationDisplacer.cc.

 {
   ;
 }

Here is the call graph for this function:

Member Function Documentation

◆ ElectronProbaDistribution()

G4double G4DNAWaterDissociationDisplacer::ElectronProbaDistribution ( G4double r )

static

Definition at line 69 of file G4DNAWaterDissociationDisplacer.cc.

 {
   return (2*r+1)*exp(-2*r);
 }

Here is the caller graph for this function:

◆ GetMotherMoleculeDisplacement()

G4ThreeVector G4DNAWaterDissociationDisplacer::GetMotherMoleculeDisplacement ( const G4MolecularDissociationChannel * theDecayChannel ) const

virtual

Implements G4VMolecularDecayDisplacer.

Definition at line 116 of file G4DNAWaterDissociationDisplacer.cc.

 {
   G4int decayType = theDecayChannel->GetDisplacementType();
 
   G4double RMSMotherMoleculeDisplacement = 0;
 
   if (decayType == Ionisation_DissociationDecay)
   {
     RMSMotherMoleculeDisplacement = 2.0 * nanometer;
   }
   else if (decayType == A1B1_DissociationDecay)
   {
     RMSMotherMoleculeDisplacement = 0. * nanometer;
   }
   else if (decayType == B1A1_DissociationDecay)
   {
     RMSMotherMoleculeDisplacement = 0. * nanometer;
   }
   else if (decayType == AutoIonisation)
   {
     RMSMotherMoleculeDisplacement = 2.0 * nanometer;
   }
   else if (decayType == DissociativeAttachment)
   {
     RMSMotherMoleculeDisplacement = 0. * nanometer;
   }
 
   if (RMSMotherMoleculeDisplacement == 0)
   {
     return G4ThreeVector(0, 0, 0);
   }
   auto RandDirection = radialDistributionOfProducts(
       RMSMotherMoleculeDisplacement);
 
   return RandDirection;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetProductsDisplacement()

vector< G4ThreeVector > G4DNAWaterDissociationDisplacer::GetProductsDisplacement ( const G4MolecularDissociationChannel * theDecayChannel ) const

virtual

Implements G4VMolecularDecayDisplacer.

Definition at line 157 of file G4DNAWaterDissociationDisplacer.cc.

 {
   G4int nbProducts = theDecayChannel->GetNbProducts();
   vector<G4ThreeVector> theProductDisplacementVector(nbProducts);
 
   typedef map<const G4MoleculeDefinition*, G4double> RMSmap;
   RMSmap theRMSmap;
 
   G4int decayType = theDecayChannel->GetDisplacementType();
 
   if (decayType == Ionisation_DissociationDecay)
   {
     if (fVerbose) G4cout << "Ionisation_DissociationDecay" << G4endl;
     G4double RdmValue = G4UniformRand();
 
     if(RdmValue< 0.5)
     {
       // H3O
       theRMSmap[G4H3O::Definition()] = 0.* nanometer;
       // OH
       theRMSmap[G4OH::Definition()] = 0.8* nanometer;
     }
     else
     {
       // H3O
       theRMSmap[G4H3O::Definition()] = 0.8* nanometer;
       // OH
       theRMSmap[G4OH::Definition()] = 0.* nanometer;
     }
 
     for(int i = 0; i < nbProducts; i++)
     {
       G4double theRMSDisplacement;
       G4MolecularConfiguration* product = theDecayChannel->GetProduct(i);
       theRMSDisplacement = theRMSmap[product->GetDefinition()];
 
       if(theRMSDisplacement==0)
       {
         theProductDisplacementVector[i] = G4ThreeVector();
       }
       else
       {
         auto RandDirection = radialDistributionOfProducts(theRMSDisplacement);
         theProductDisplacementVector[i] = RandDirection;
       }
     }
   }
   else if(decayType == A1B1_DissociationDecay)
   {
     if(fVerbose)
       G4cout<<"A1B1_DissociationDecay"<<G4endl;
     G4double theRMSDisplacement = 2.4 * nanometer;
     auto RandDirection =
         radialDistributionOfProducts(theRMSDisplacement);
 
     for(G4int i =0; i < nbProducts; i++)
     {
       G4MolecularConfiguration* product = theDecayChannel->GetProduct(i);
 
       if(product->GetDefinition()== G4OH::Definition())
       {
         theProductDisplacementVector[i] = -1./18.*RandDirection;
       }
       else if(product->GetDefinition() == G4Hydrogen::Definition())
       {
         theProductDisplacementVector[i] = +17./18.*RandDirection;
       }
     }
   }
   else if(decayType == B1A1_DissociationDecay)
   {
     if(fVerbose)
       G4cout<<"B1A1_DissociationDecay"<<G4endl;
     G4double theRMSDisplacement = 0.8 * nanometer;
     auto RandDirection =
         radialDistributionOfProducts(theRMSDisplacement);
 
     G4int NbOfOH = 0;
     for(G4int i =0; i < nbProducts; i++)
     {
       G4MolecularConfiguration* product = theDecayChannel->GetProduct(i);
       if(product->GetDefinition() == G4H2::Definition())
       {
         theProductDisplacementVector[i] = -2./18.*RandDirection;
       }
       else if(product->GetDefinition() == G4OH::Definition())
       {
         G4ThreeVector OxygenDisplacement = +16./18.*RandDirection;
         G4double OHRMSDisplacement = 1.1 * nanometer;
 
         auto OHDisplacement =
             radialDistributionOfProducts(OHRMSDisplacement);
 
         if(NbOfOH==0)
         {
           OHDisplacement = 1./2.*OHDisplacement;
         }
         else
         {
           OHDisplacement = -1./2.*OHDisplacement;
         }
 
         theProductDisplacementVector[i] =
             OHDisplacement + OxygenDisplacement;
 
         NbOfOH ++;
       }
     }
   }
   else if(decayType == AutoIonisation)
   {
     if(fVerbose)
     G4cout<<"AutoIonisation"<<G4endl;
     G4double RdmValue = G4UniformRand();
 
     if(RdmValue< 0.5)
     {
       // H3O
       theRMSmap[G4H3O::Definition()] = 0.* nanometer;
       // OH
       theRMSmap[G4OH::Definition()] = 0.8* nanometer;
     }
     else
     {
       // H3O
       theRMSmap[G4H3O::Definition()] = 0.8* nanometer;
       // OH
       theRMSmap[G4OH::Definition()] = 0.* nanometer;
     }
 
     for(G4int i =0; i < nbProducts; i++)
     {
       G4MolecularConfiguration* product = theDecayChannel->GetProduct(i);
       auto theRMSDisplacement = theRMSmap[product->GetDefinition()];
 
       if(theRMSDisplacement==0)
       {
         theProductDisplacementVector[i] = G4ThreeVector();
       }
       else
       {
         auto RandDirection =
             radialDistributionOfProducts(theRMSDisplacement);
         theProductDisplacementVector[i] = RandDirection;
       }
       if(product->GetDefinition() == G4Electron_aq::Definition())
       {
         theProductDisplacementVector[i]=radialDistributionOfElectron();
       }
     }
   }
   else if(decayType == DissociativeAttachment)
   {
     if(fVerbose)
     G4cout<<"DissociativeAttachment"<<G4endl;
     G4double theRMSDisplacement = 0.8 * nanometer;
     auto RandDirection =
         radialDistributionOfProducts(theRMSDisplacement);
 
     G4int NbOfOH = 0;
     for(G4int i =0; i < nbProducts; i++)
     {
       G4MolecularConfiguration* product = theDecayChannel->GetProduct(i);
       if(product->GetDefinition() == G4H2::Definition())
       {
         theProductDisplacementVector[i] = -2./18.*RandDirection;
       }
       else if(product->GetDefinition() == G4OH::Definition())
       {
         G4ThreeVector OxygenDisplacement = +16./18.*RandDirection;
         G4double OHRMSDisplacement = 1.1 * nanometer;
 
         auto OHDisplacement =
             radialDistributionOfProducts(OHRMSDisplacement);
 
         if(NbOfOH==0)
         {
           OHDisplacement = 1./2.*OHDisplacement;
         }
         else
         {
           OHDisplacement = -1./2.*OHDisplacement;
         }
 
         theProductDisplacementVector[i] = OHDisplacement + OxygenDisplacement;
 
         NbOfOH ++;
       }
     }
   }
 
   return theProductDisplacementVector;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ radialDistributionOfElectron()

G4ThreeVector G4DNAWaterDissociationDisplacer::radialDistributionOfElectron ( ) const

Definition at line 368 of file G4DNAWaterDissociationDisplacer.cc.

 {
   G4double rand_value = G4UniformRand();
   size_t nBins = fElectronThermalization.size();
   size_t bin = size_t(rand_value*nBins);
   return fElectronThermalization[bin]*G4RandomDirection();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ radialDistributionOfProducts()

G4ThreeVector G4DNAWaterDissociationDisplacer::radialDistributionOfProducts ( G4double r_rms ) const

Definition at line 355 of file G4DNAWaterDissociationDisplacer.cc.

 {
   static const double inverse_sqrt_3 = 1./sqrt(3.);
   double sigma = Rrms*inverse_sqrt_3;
   double x = G4RandGauss::shoot(0.,sigma);
   double y = G4RandGauss::shoot(0.,sigma);
   double z = G4RandGauss::shoot(0.,sigma);
   return G4ThreeVector(x,y,z);
 }