G4Molecule.hh

Go to the documentation of this file.

//
// ********************************************************************
// * 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.
//
// ---------------------------------------------------------------------
//      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;
class G4MolecularConfiguration;
class G4MoleculeDefinition;
class G4MolecularDecayChannel;
class G4DynamicParticle;

G4Molecule* GetMolecule(const G4Track& track) ;
G4Molecule* GetMolecule(const G4Track* track) ;

class G4Molecule : public G4IT
{

public: // With Description

    ITDef(G4Molecule)

    //From G4VUserTrackInformation
    void Print() const;

    //  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 *aVUserTrackInformation);

    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;

private :
    bool CompareElectronOccupancy (const G4ElectronOccupancy* /*elecOccupancy2*/,
                                   const G4int& /*totalOcc1*/, const G4int& /*totalOcc2*/) const;

public:
    //------ Constructors --------------------------
    G4Molecule(G4MoleculeDefinition * molecule);

    G4Molecule(G4MoleculeDefinition * molecule, G4int, G4int);

    G4Molecule(G4MoleculeDefinition * molecule, G4int, G4bool);

    virtual ~G4Molecule();

    //-------- Methods -------------------------------
    //Get from static definition
    const G4String& GetName() const;

    G4int GetAtomsNumber() const;

    void SetElectronOccupancy(const G4ElectronOccupancy*);

    void ExciteMolecule(G4int);

    void IonizeMolecule(G4int);

    void AddElectron(G4int orbit, G4int n =1);

    void RemoveElectron(G4int,G4int number=1);

    void MoveOneElectron(G4int /*orbit*/,G4int /*orbit*/);

    G4double GetNbElectrons() const; //This method can be used to check if the electron s number is physical

    void PrintState() const;

    G4Track * BuildTrack(G4double globalTime, const G4ThreeVector& Position);

    G4double GetKineticEnergy() const;

    G4double GetDiffusionVelocity() const;

    const std::vector <const G4MolecularDecayChannel*>* GetDecayChannel() const;

    G4int GetMoleculeID() const;

    //-------------Inline functions ---------------------
    const G4MoleculeDefinition* GetDefinition() const;

    //methods to set/get changing parameters


    void SetDiffusionCoefficient(G4double);

    G4double GetDiffusionCoefficient() const;

    void SetDecayTime(G4double);

    G4double GetDecayTime() const;

    void SetVanDerVaalsRadius(G4double);
    G4double GetVanDerVaalsRadius() const ;

    const G4ElectronOccupancy* GetElectronOccupancy() const;

    G4int GetCharge() const;

    void SetMass(G4double);

    G4double GetMass() const;

    inline G4MolecularConfiguration* GetMolecularConfiguration() ;

    inline static void SetGlobalTemperature(double);
    inline static double GetGlobalTemperature();

private:
    G4Molecule();

    void Init();
    G4DynamicParticle* fDynamicParticle;

    G4MolecularConfiguration* fMolecularConfiguration;

    static double fgTemperature;
};


#if defined G4EM_ALLOC_EXPORT
extern G4DLLEXPORT G4Allocator<G4Molecule> aMoleculeAllocator;
#else
extern G4DLLIMPORT G4Allocator<G4Molecule> aMoleculeAllocator;
#endif


inline void * G4Molecule::operator new(size_t)
{
    void * aMolecule;
    aMolecule = (void *) aMoleculeAllocator.MallocSingle();
    return aMolecule;
}

inline void G4Molecule::operator delete(void * aMolecule)
{
    // DEBUG
    // G4cout<<"G4Molecule::operator delete(void * aMolecule) called"<<G4endl;
    aMoleculeAllocator.FreeSingle((G4Molecule *) aMolecule);
}

inline G4MolecularConfiguration* G4Molecule::GetMolecularConfiguration()
{
    return fMolecularConfiguration ;
}

inline void G4Molecule::SetGlobalTemperature(double temperature)
{
    fgTemperature = temperature;
}

inline double G4Molecule::GetGlobalTemperature()
{
    return fgTemperature;
}

#endif

---