Gabriele Cosmo
320 lines
10 KiB
C++
320 lines
10 KiB
C++
//
|
||
// ********************************************************************
|
||
// * License and Disclaimer *
|
||
// * *
|
||
// * The Geant4 software is copyright of the Copyright Holders of *
|
||
// * the Geant4 Collaboration. It is provided under the terms and *
|
||
// * conditions of the Geant4 Software License, included in the file *
|
||
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
||
// * include a list of copyright holders. *
|
||
// * *
|
||
// * Neither the authors of this software system, nor their employing *
|
||
// * institutes,nor the agencies providing financial support for this *
|
||
// * work make any representation or warranty, express or implied, *
|
||
// * regarding this software system or assume any liability for its *
|
||
// * use. Please see the license in the file LICENSE and URL above *
|
||
// * for the full disclaimer and the limitation of liability. *
|
||
// * *
|
||
// * This code implementation is the result of the scientific and *
|
||
// * technical work of the GEANT4 collaboration. *
|
||
// * By using, copying, modifying or distributing the software (or *
|
||
// * any work based on the software) you agree to acknowledge its *
|
||
// * use in resulting scientific publications, and indicate your *
|
||
// * acceptance of all terms of the Geant4 Software license. *
|
||
// ********************************************************************
|
||
//
|
||
// Contact: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
|
||
//
|
||
// WARNING : This class is released as a prototype.
|
||
// It might strongly evolve or even disapear in the next releases.
|
||
//
|
||
// The code is developed in the framework of the ESA AO7146
|
||
//
|
||
// We would be very happy hearing from you, send us your feedback! :)
|
||
//
|
||
// In order for Geant4-DNA to be maintained and still open-source,
|
||
// article citations are crucial.
|
||
// If you use Geant4-DNA chemistry and you publish papers about your software,
|
||
// in addition to the general paper on Geant4-DNA:
|
||
//
|
||
// Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
|
||
//
|
||
// we would be very happy if you could please also cite the following
|
||
// reference papers on chemistry:
|
||
//
|
||
// J. Comput. Phys. 274 (2014) 841-882
|
||
// Prog. Nucl. Sci. Tec. 2 (2011) 503-508
|
||
//
|
||
// ---------------------------------------------------------------------
|
||
// GEANT 4 class header file
|
||
//
|
||
// History: first implementation, based on G4DynamicParticle
|
||
// New dependency : G4VUserTrackInformation
|
||
//
|
||
// ---------------- G4Molecule ----------------
|
||
// first design&implementation by Alfonso Mantero, 7 Apr 2009
|
||
// New developments Alfonso Mantero & Mathieu Karamitros
|
||
// Oct/Nov 2009 Class Name changed to G4Molecule
|
||
// Removed dependency from G4DynamicParticle
|
||
// New constructors :
|
||
// copy constructor
|
||
// direct ionized/excited molecule
|
||
// New methods :
|
||
// Get : name,atoms' number,nb electrons,decayChannel
|
||
// PrintState //To get the electronic level and the
|
||
// corresponding name of the excitation
|
||
// Kinematic :
|
||
// BuildTrack,GetKineticEnergy,GetDiffusionVelocity
|
||
// Change the way dynCharge and eNb is calculated
|
||
// ---------------------------------------------------------------------
|
||
|
||
#ifndef G4Molecule_h
|
||
#define G4Molecule_h 1
|
||
|
||
#include "G4IT.hh"
|
||
#include "G4Allocator.hh"
|
||
#include "G4MoleculeDefinition.hh"
|
||
|
||
class G4Molecule;
|
||
template<>
|
||
G4KDNode<G4Molecule>::~G4KDNode();
|
||
|
||
class G4Molecule;
|
||
class G4MolecularConfiguration;
|
||
class G4MoleculeDefinition;
|
||
class G4MolecularDissociationChannel;
|
||
class G4DynamicParticle;
|
||
class G4Material;
|
||
|
||
G4Molecule* GetMolecule(const G4Track& track);
|
||
G4Molecule* GetMolecule(const G4Track* track);
|
||
|
||
/** Class Description
|
||
* The dynamic molecule holds all the data that change for a molecule
|
||
* It has a pointer to G4MoleculeDefinition object, which holds
|
||
* all the "ground level" information.
|
||
*/
|
||
|
||
class G4Molecule : public G4IT
|
||
{
|
||
|
||
public:
|
||
// With Description
|
||
|
||
ITDef(G4Molecule) // NOLINT because it's a macro
|
||
|
||
//From G4VUserTrackInformation
|
||
void Print() const override;
|
||
|
||
// new/delete operators are overloded to use G4Allocator
|
||
inline void *operator new(size_t);
|
||
#ifdef __IBMCPP__
|
||
inline void *operator new(size_t sz, void* p)
|
||
{
|
||
return p;
|
||
}
|
||
#endif
|
||
inline void operator delete(void*);
|
||
|
||
G4Molecule(const G4Molecule&);
|
||
G4Molecule & operator=(const G4Molecule &right);
|
||
G4bool operator==(const G4Molecule &right) const;
|
||
G4bool operator!=(const G4Molecule &right) const;
|
||
G4bool operator<(const G4Molecule &right) const;
|
||
|
||
operator int() const
|
||
{
|
||
return GetMoleculeID();
|
||
}
|
||
|
||
G4ITType GetITSubType() const override
|
||
{
|
||
return GetMoleculeID();
|
||
}
|
||
|
||
public:
|
||
//------ Constructors --------------------------
|
||
/** To build a molecule at ground state according to a given
|
||
* G4MoleculeDefinition that can be obtained from G4GenericMoleculeManager
|
||
*/
|
||
G4Molecule(G4MoleculeDefinition* pMoleculeDefinition);
|
||
|
||
G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, int charge);
|
||
|
||
/** To build a molecule at a specific excitation/ionisation state according
|
||
* to a ground state that can be obtained from G4GenericMoleculeManager
|
||
*/
|
||
G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, G4int, G4int);
|
||
|
||
/** Specific builder for water molecules to be used in Geant4-DNA,
|
||
* the last option Excitation is true if the molecule is excited, is
|
||
* false is the molecule is ionized.
|
||
*/
|
||
G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, G4int, G4bool);
|
||
|
||
G4Molecule(const G4MolecularConfiguration*);
|
||
|
||
~G4Molecule() override;
|
||
|
||
//-------- Methods -------------------------------
|
||
//Get from static definition
|
||
/** Returns the name of the molecule
|
||
*/
|
||
const G4String& GetName() const override;
|
||
|
||
/** Returns the formated name of the molecule
|
||
*/
|
||
const G4String& GetFormatedName() const;
|
||
|
||
/** Returns the nomber of atoms compouning the molecule
|
||
*/
|
||
G4int GetAtomsNumber() const;
|
||
|
||
/** Will set up the correct molecularConfiguration given
|
||
* an electron configuration
|
||
*/
|
||
void SetElectronOccupancy(const G4ElectronOccupancy*);
|
||
|
||
/** Method used in Geant4-DNA to excite water molecules
|
||
*/
|
||
void ExciteMolecule(G4int);
|
||
|
||
/** Method used in Geant4-DNA to ionize water molecules
|
||
*/
|
||
void IonizeMolecule(G4int);
|
||
|
||
/** Add n electrons to a given orbit.
|
||
* Note : You can add as many electrons to a given orbit, the result
|
||
* may be unrealist.
|
||
*/
|
||
void AddElectron(G4int orbit, G4int n = 1);
|
||
|
||
/** Remove n electrons to a given orbit.
|
||
*/
|
||
void RemoveElectron(G4int, G4int number = 1);
|
||
|
||
/** Move one electron from an orbit to another.
|
||
*/
|
||
void MoveOneElectron(G4int /*orbit*/, G4int /*orbit*/);
|
||
|
||
/** Returns the number of electron.
|
||
*/
|
||
G4double GetNbElectrons() const; //This method can be used to check if the electron s number is physical
|
||
|
||
/** Show the electronic state of the molecule.
|
||
*/
|
||
void PrintState() const;
|
||
|
||
G4Track* BuildTrack(G4double globalTime, const G4ThreeVector &Position, const G4Track * = nullptr);
|
||
|
||
G4double GetKineticEnergy() const;
|
||
|
||
G4double GetDiffusionVelocity() const;
|
||
|
||
const std::vector<const G4MolecularDissociationChannel*>* GetDissociationChannels() const;
|
||
|
||
G4int GetFakeParticleID() const;
|
||
G4int GetMoleculeID() const;
|
||
|
||
//-------------Inline functions ---------------------
|
||
/** Get molecule definition. This G4MoleculeDefinition has the ground
|
||
* electronic state of the molecule.
|
||
*/
|
||
const G4MoleculeDefinition* GetDefinition() const;
|
||
|
||
//methods to set/get changing parameters
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
/** Sets the diffusion coefficient D of the molecule used in diffusion
|
||
* processes to calculate the mean square jump distance between two
|
||
* changes of direction. In three dimension : <x^2> = 6 D t where t is
|
||
* the mean jump time between two changes of direction.
|
||
*/
|
||
void SetDiffusionCoefficient(G4double);
|
||
|
||
/** Returns the diffusion coefficient D.
|
||
*/
|
||
G4double GetDiffusionCoefficient() const;
|
||
|
||
/** Returns the diffusion coefficient D.
|
||
*/
|
||
G4double GetDiffusionCoefficient(const G4Material*,
|
||
double temperature) const;
|
||
|
||
/** Set the decay time of the molecule.
|
||
*/
|
||
void SetDecayTime(G4double);
|
||
|
||
/** Returns the decay time of the molecule.
|
||
*/
|
||
G4double GetDecayTime() const;
|
||
|
||
/** The Van Der Valls Radius of the molecule
|
||
*/
|
||
void SetVanDerVaalsRadius(G4double);
|
||
G4double GetVanDerVaalsRadius() const;
|
||
|
||
/** Returns the object ElectronOccupancy describing the electronic
|
||
* configuration of the molecule.
|
||
*/
|
||
const G4ElectronOccupancy* GetElectronOccupancy() const;
|
||
|
||
/** Returns the charge of molecule.
|
||
*/
|
||
G4int GetCharge() const;
|
||
|
||
/** Set the total mass of the molecule.
|
||
*/
|
||
void SetMass(G4double);
|
||
|
||
/** Returns the total mass of the molecule.
|
||
*/
|
||
G4double GetMass() const;
|
||
|
||
/** Returns the label of the molecule configuration
|
||
*/
|
||
const G4String& GetLabel() const;
|
||
|
||
void SetLabel(const G4String& label);
|
||
|
||
void ChangeConfigurationToLabel(const G4String& label);
|
||
|
||
////////////////////////////////////////////////////////////////////////
|
||
|
||
const G4MolecularConfiguration* GetMolecularConfiguration() const;
|
||
|
||
static G4Molecule* GetMolecule(const G4Track*);
|
||
|
||
private:
|
||
/** Default molecule builder
|
||
*/
|
||
G4Molecule();
|
||
const G4MolecularConfiguration* fpMolecularConfiguration;
|
||
};
|
||
|
||
#if defined G4EM_ALLOC_EXPORT
|
||
extern G4DLLEXPORT G4Allocator<G4Molecule>*& aMoleculeAllocator();
|
||
#else
|
||
extern G4DLLIMPORT G4Allocator<G4Molecule>*& aMoleculeAllocator();
|
||
#endif
|
||
|
||
//////////////////////////
|
||
inline void * G4Molecule::operator new(size_t)
|
||
//////////////////////////
|
||
{
|
||
if (aMoleculeAllocator() == nullptr)
|
||
{
|
||
aMoleculeAllocator() = new G4Allocator<G4Molecule>;
|
||
}
|
||
return (void *)aMoleculeAllocator()->MallocSingle();
|
||
}
|
||
|
||
//////////////////////////
|
||
inline void G4Molecule::operator delete(void * aMolecule)
|
||
//////////////////////////
|
||
{
|
||
aMoleculeAllocator()->FreeSingle((G4Molecule *)aMolecule);
|
||
}
|
||
|
||
#endif
|