G4DNAElectronHoleRecombination Class Reference

#include <G4DNAElectronHoleRecombination.hh>

Inheritance diagram for G4DNAElectronHoleRecombination:

Collaboration diagram for G4DNAElectronHoleRecombination:

Classes
struct	ReactionProfile
struct	State

Public Member Functions
	G4DNAElectronHoleRecombination ()
virtual	~G4DNAElectronHoleRecombination ()
void	Create ()
void	StartTracking (G4Track *)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)
virtual G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *condition)

Private Member Functions
G4bool	FindReactant (const G4Track &track)
void	MakeReaction (const G4Track &track)

Private Attributes
const std::vector< double > *	fpMoleculeDensity
G4ParticleChange	fParticleChange
G4bool	fIsInitialized
std::map< int, std::pair< double, double > >	fOnsagerRadiusPerMaterial

Detailed Description

Definition at line 38 of file G4DNAElectronHoleRecombination.hh.

Constructor & Destructor Documentation

G4DNAElectronHoleRecombination()

G4DNAElectronHoleRecombination::G4DNAElectronHoleRecombination

(

)

Definition at line 105 of file G4DNAElectronHoleRecombination.cc.

                                                               :
    G4VITRestDiscreteProcess("G4DNAElectronHoleRecombination", fElectromagnetic)
{
  Create();
//  G4cout << epsilon(1.0095, 298.) << G4endl;
//  G4cout << epsilon(1., 293.15) << G4endl;
//  G4cout << epsilon(0.9277, 423.) << G4endl;
//  G4cout << epsilon(0.816, 523.) << G4endl;
//  G4cout << epsilon(0.6, 623) << G4endl;
}

Here is the call graph for this function:

~G4DNAElectronHoleRecombination()

G4DNAElectronHoleRecombination::~G4DNAElectronHoleRecombination ( )

virtual

Definition at line 116 of file G4DNAElectronHoleRecombination.cc.

{
}

Member Function Documentation

AtRestDoIt()

G4VParticleChange * G4DNAElectronHoleRecombination::AtRestDoIt ( const G4Track &  track, const G4Step &    )

virtual

Definition at line 143 of file G4DNAElectronHoleRecombination.cc.

{
  fParticleChange.Initialize(track);
  ClearInteractionTimeLeft();
  ClearNumberOfInteractionLengthLeft();
  MakeReaction(track);
  return &fParticleChange;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildPhysicsTable()

virtual void G4DNAElectronHoleRecombination::BuildPhysicsTable ( const G4ParticleDefinition &  )

inlinevirtual

Definition at line 49 of file G4DNAElectronHoleRecombination.hh.

{}

Here is the call graph for this function:

Create()

void G4DNAElectronHoleRecombination::Create

(

)

Definition at line 120 of file G4DNAElectronHoleRecombination.cc.

{
  pParticleChange = &fParticleChange;
  enableAtRestDoIt = true;
  enableAlongStepDoIt = false;
  enablePostStepDoIt = true;

  SetProcessSubType(60);

  G4VITProcess::SetInstantiateProcessState(false);
  // ie G4DNAElectronHoleRecombination uses a state class
  // inheriting from G4ProcessState

  fIsInitialized = false;
  fProposesTimeStep = true;
  fpMoleculeDensity = 0;

  verboseLevel = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindReactant()

G4bool G4DNAElectronHoleRecombination::FindReactant ( const G4Track &  track )

private

Definition at line 218 of file G4DNAElectronHoleRecombination.cc.

{
  if(GetMolecule(track)->GetCharge() <= 0)
  {
    // G4cout << "La charge est negative ou nulle !! " << G4endl;
    return false;
  }

  const std::vector<double>* densityTable =
      G4DNAMolecularMaterial::Instance()->GetDensityTableFor(track.GetMaterial());

  double temperature = track.GetMaterial()->GetTemperature();
  double density = (*densityTable)[track.GetMaterial()->GetIndex()] /
                    ( g/(1e-2*m*1e-2*m*1e-2*m) );
  double eps = epsilon(density, temperature);

  // G4cout << " temperature = " << temperature << G4endl;
  // G4cout << " density = " << density << G4endl;
  // G4cout << " eps = " << eps << G4endl;

  double onsager_radius = onsager_constant * 1. / (temperature * eps);

  G4Molecule e_aq(G4Electron_aq::Definition());

  G4KDTreeResultHandle results = G4MoleculeFinder::Instance()
      ->FindNearestInRange(track.GetPosition(),
                           e_aq.GetMoleculeID(),
                           10. * onsager_radius);

  // double distance = -1.;
  // double probability = -1.;

  if(results == 0 || results->GetSize() == 0)
  {
    //    G4cout << "rien trouve a moins de 10 rc" << G4endl;
    return false;
  }

  results->Sort();

  State* state = fpState->GetState<State>();
  std::vector<ReactionProfile>& reactants = state->fReactants;
  state->fSampleProba = G4UniformRand();

  reactants.resize(results->GetSize());

  for(size_t i = 0; results->End() == false; results->Next(), ++i)
  {
    reactants[i].fElectron = results->GetItem<G4IT>()->GetTrack();
    reactants[i].fDistance = std::sqrt(results->GetDistanceSqr());

    if(reactants[i].fDistance != 0)
    {
      reactants[i].fProbability = 1.
          - std::exp(-onsager_radius / reactants[i].fDistance);
    }
    else
    {
      reactants[i].fProbability = 1.;
    }

    //  G4cout << "dis = "
    //         << reactants[i].fDistance << " prob = " << reactants[i].fProbability << G4endl;
  }

  if(results->GetSize() != 0 && reactants.empty())
  {
    G4cout << "Size is = " << results->GetSize() << G4endl;
    abort();
  }

  if(reactants.empty()) return false;

  //  G4cout << " reactants[0].fDistance =" << reactants[0].fDistance
  //        << " onsager_radius = " << onsager_radius << "\t";
  //
  //  G4cout << " reactants[0].fProbability =" << reactants[0].fProbability
  //        << "state->fSampleProba = " << state->fSampleProba << "\t";

  if(reactants[0].fProbability > state->fSampleProba) return true;
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMeanFreePath()

G4double G4DNAElectronHoleRecombination::GetMeanFreePath ( const G4Track &  aTrack, G4double  previousStepSize, G4ForceCondition *  condition  )

virtual

Definition at line 383 of file G4DNAElectronHoleRecombination.cc.

{
  //  G4cout << "track ID = " << track.GetTrackID()
  //      <<  " G4DNAElectronHoleRecombination --> ";
    if(FindReactant(track))
    {
  //    G4cout << " SELECTED " ;
  //    G4cout << G4endl;
      return 0;
    }

  //  G4cout << " NOT SELECTED " << G4endl;
    return DBL_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMeanLifeTime()

G4double G4DNAElectronHoleRecombination::GetMeanLifeTime ( const G4Track &  aTrack, G4ForceCondition *  condition  )

virtual

Definition at line 402 of file G4DNAElectronHoleRecombination.cc.

{
//  G4cout << "track ID = " << track.GetTrackID()
//      <<  " G4DNAElectronHoleRecombination --> ";
  if(FindReactant(track))
  {
//    G4cout << " SELECTED " ;
//    G4cout << G4endl;
    return 0;
  }

//  G4cout << " NOT SELECTED " << G4endl;
  return DBL_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsApplicable()

G4bool G4DNAElectronHoleRecombination::IsApplicable ( const G4ParticleDefinition &  particle )

virtual

Definition at line 305 of file G4DNAElectronHoleRecombination.cc.

{
  if(G4Threading::IsMasterThread())
  {
    G4MoleculeDefinition* H2O = G4MoleculeTable::Instance()
        ->GetMoleculeDefinition("H2O", false);

    if(H2O) // if this condition does not hold => process cannot be applied
    {
      G4MolecularConfiguration* vib =
          G4H2O::Definition()->NewConfiguration("H2Ovib");

      assert(vib != 0);

      G4MolecularConfiguration* H2 = G4MoleculeTable::Instance()
          ->GetConfiguration("H2", false);
      G4MolecularConfiguration* OH = G4MoleculeTable::Instance()
          ->GetConfiguration("OH", false);
      G4MolecularConfiguration* H = G4MoleculeTable::Instance()
          ->GetConfiguration("H", false);

      double probaRemaining = 1.;

      if(OH || H2)
      {
        G4MolecularDissociationChannel* diss2 =
                  new G4MolecularDissociationChannel("H2Ovib_DissociativeDecay1");
        if(H2)
        {
          diss2->AddProduct(H2);
        }
        if(OH)
        {
          diss2->AddProduct(OH);
          diss2->AddProduct(OH);
        }

        double proba = 0.15;
        diss2->SetProbability(proba);
        probaRemaining -= proba;
        diss2->SetDisplacementType(G4DNAWaterDissociationDisplacer::
                                   B1A1_DissociationDecay);
        G4H2O::Definition()->AddDecayChannel(vib, diss2);
      }

      if(OH || H)
      {
        G4MolecularDissociationChannel* diss3 =
            new G4MolecularDissociationChannel("H2Ovib_DissociativeDecay2");
        if(OH)
        {
          diss3->AddProduct(OH);
        }
        if(H)
        {
          diss3->AddProduct(H);
        }
        double proba = 0.55;
        diss3->SetProbability(proba);
        probaRemaining -= proba;
        diss3->SetDisplacementType(G4DNAWaterDissociationDisplacer::
                                   A1B1_DissociationDecay);
        G4H2O::Definition()->AddDecayChannel(vib, diss3);
      }

      G4MolecularDissociationChannel* channel1 =
          new G4MolecularDissociationChannel("H2Ovib_NonDissociative");
      channel1->SetProbability(probaRemaining);
      G4H2O::Definition()->AddDecayChannel(vib, channel1);
    }
  }

  if(particle.GetParticleName() == "H2O") return true;
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeReaction()

void G4DNAElectronHoleRecombination::MakeReaction ( const G4Track &  track )

private

Definition at line 164 of file G4DNAElectronHoleRecombination.cc.

{
  fParticleChange.Initialize(track);
  State* state = fpState->GetState<State>();
  double random = state->fSampleProba;
  std::vector<ReactionProfile>& reactants = state->fReactants;

  G4Track* selected_reactant = 0;

  for(size_t i = 0; i < reactants.size(); ++i)
  {
    if(reactants[i].fElectron->GetTrackStatus() != fAlive) continue;
    if(reactants[i].fProbability > random)
    {
      selected_reactant = reactants[i].fElectron;
    }
    break;
  }

  //  G4cout << "MakeReaction with charge ="
  //       << GetMolecule(track)->GetCharge() << G4endl;

  if(selected_reactant)
  {
    //    G4cout << " Will react with TID = " << selected_reactant->GetTrackID()
    //           << G4endl;

    if(G4MoleculeCounter::InUse())
      G4MoleculeCounter::Instance()->
        RemoveAMoleculeAtTime(GetMolecule(track)->GetMolecularConfiguration(),
                              track.GetGlobalTime());
    GetMolecule(track)->ChangeConfigurationToLabel("H2Ovib");

    if(G4MoleculeCounter::InUse())
      G4MoleculeCounter::Instance()->
        AddAMoleculeAtTime(GetMolecule(track)->GetMolecularConfiguration(),
                           track.GetGlobalTime());

    //  fParticleChange.ProposeTrackStatus(fStopAndKill);
    fParticleChange.ProposeTrackStatus(fStopButAlive);

    selected_reactant->SetTrackStatus(fStopAndKill);
    //  G4TrackList::Pop(selected_reactant);
    //  G4ITTrackHolder::Instance()->PushToKill(selected_reactant);

  }
  else
  {
    fParticleChange.ProposeTrackStatus(fStopButAlive);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PostStepDoIt()

G4VParticleChange * G4DNAElectronHoleRecombination::PostStepDoIt ( const G4Track &  track, const G4Step &  step  )

virtual

Definition at line 418 of file G4DNAElectronHoleRecombination.cc.

{
  return AtRestDoIt(track, step);
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartTracking()

void G4DNAElectronHoleRecombination::StartTracking

(

G4Track *

track

)

Definition at line 155 of file G4DNAElectronHoleRecombination.cc.

{
  G4VProcess::StartTracking(track);
  G4VITProcess::fpState.reset(new State());
  G4VITProcess::StartTracking(track);
}

Here is the call graph for this function:

Member Data Documentation

fIsInitialized

G4bool G4DNAElectronHoleRecombination::fIsInitialized

private

Definition at line 107 of file G4DNAElectronHoleRecombination.hh.

fOnsagerRadiusPerMaterial

std::map<int, std::pair<double, double> > G4DNAElectronHoleRecombination::fOnsagerRadiusPerMaterial

private

Definition at line 108 of file G4DNAElectronHoleRecombination.hh.

fParticleChange

G4ParticleChange G4DNAElectronHoleRecombination::fParticleChange

private

Definition at line 106 of file G4DNAElectronHoleRecombination.hh.

fpMoleculeDensity

const std::vector<double>* G4DNAElectronHoleRecombination::fpMoleculeDensity

private

Definition at line 105 of file G4DNAElectronHoleRecombination.hh.

---

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

• G4DNAElectronHoleRecombination.hh
• G4DNAElectronHoleRecombination.cc