// // ******************************************************************** // * 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. * // ******************************************************************** // // // $Id: G4ParticleTable.hh 73711 2013-09-09 09:57:29Z gcosmo $ // // // ------------------------------------------------------------ // GEANT 4 class header file // // History: first implementation, based on object model of // 27 June 1996, H.Kurashige // ------------------------------------------------------------ // added fParticleMessenger 14 Nov., 97 H.Kurashige // added Create/DeleteMessenger 06 Jul., 98 H.Kurashige // modified FindIon 02 Aug., 98 H.Kurashige // added dictionary for encoding 24 Sep., 98 H.Kurashige // added RemoveAllParticles() 8 Nov., 98 H.Kurashige // -------------------------------- // fixed some improper codings 08 Apr., 99 H.Kurashige // modified FindIon/GetIon methods 17 AUg., 99 H.Kurashige // implement new version for using STL map instaed of RW PtrHashedDictionary // 28 ct., 99 H.Kurashige // modified implementation of Remove 21 Mar.,08 H.Kurashige // remove G4ShortLivedTable 25 July, 13 H.Kurashige // #ifndef G4ParticleTable_h #define G4ParticleTable_h 1 #include #include "G4ios.hh" #include "globals.hh" #include "G4Threading.hh" #include "G4ParticleDefinition.hh" #include "G4ParticleTableIterator.hh" class G4UImessenger; class G4ParticleMessenger; class G4IonTable; class G4ParticleTable { // Class Description // G4ParticleTable is the table of pointer to G4ParticleDefinition // G4ParticleTable is a "singleton" (only one and staic object) // In G4ParticleTable, each G4ParticleDefinition pointer is stored // with its name as a key to itself. So, each G4ParticleDefinition // object must have unique name for itself. // public: typedef G4ParticleTableIterator::Map G4PTblDictionary; typedef G4ParticleTableIterator G4PTblDicIterator; typedef G4ParticleTableIterator::Map G4PTblEncodingDictionary; typedef G4ParticleTableIterator G4PTblEncodingDicIterator; protected: // default constructor G4ParticleTable(); // Copy constructor and assignment operator G4ParticleTable(const G4ParticleTable &right); G4ParticleTable & operator=(const G4ParticleTable &); public: void SlaveG4ParticleTable(); void WorkerG4ParticleTable(); // This method is similar to the constructor. It is used by each worker // thread to achieve the partial effect as that of the master thread. virtual ~G4ParticleTable(); // Do we need DestroySlaveG4ParticleTable()? public: // With Description static G4ParticleTable* GetParticleTable(); // return the pointer to G4ParticleTable object // G4ParticleTable is a "singleton" and can get its pointer by this function // At the first time of calling this function, the G4ParticleTable object // is instantiated G4bool contains(const G4ParticleDefinition *particle) const; G4bool contains(const G4String &particle_name) const; // returns TRUE if the ParticleTable contains G4int entries() const; G4int size() const; // returns the number of Particles in the ParticleTable G4ParticleDefinition* GetParticle(G4int index) const; // returns a pointer to i-th particles in the ParticleTable // 0<= index < entries() const G4String& GetParticleName(G4int index) const; // returns name of i-th particles in the ParticleTable G4ParticleDefinition* FindParticle(G4int PDGEncoding ); G4ParticleDefinition* FindParticle(const G4String &particle_name); G4ParticleDefinition* FindParticle(const G4ParticleDefinition *particle); // returns a pointer to the particle (0 if not contained) G4ParticleDefinition* FindAntiParticle(G4int PDGEncoding ); G4ParticleDefinition* FindAntiParticle(const G4String &particle_name); G4ParticleDefinition* FindAntiParticle(const G4ParticleDefinition *particle); // returns a pointer to its anti-particle (0 if not contained) G4PTblDicIterator* GetIterator() const; // return the pointer of Iterator (RW compatible) void DumpTable(const G4String &particle_name = "ALL"); // dump information of particles specified by name public: //With Description G4IonTable* GetIonTable() const; // return the pointer to G4IonTable object /////////////////////////////////////////////////////////////////////// // NOTE :: // Following FindIon/GetIon methods will be removed in future relases // Use FindIon/GetIon methods of G4IonTable instead // G4ParticleDefinition* FindIon( G4int atomicNumber, G4int atomicMass, G4double excitationEnergy ); G4ParticleDefinition* FindIon( G4int atomicNumber, G4int atomicMass, G4int numberOfLambda, G4double excitationEnergy ); // return the pointer to an ion (returns 0 if the ion does not exist) // the ion has excitation energy nearest to given excitationEnergy (0: ground state) G4ParticleDefinition* GetIon( G4int atomicNumber, G4int atomicMass, G4double excitationEnergy); G4ParticleDefinition* GetIon( G4int atomicNumber, G4int atomicMass, G4int numberOfLambda, G4double excitationEnergy); G4ParticleDefinition* GetIon(G4int atomicNumber, G4int atomicMass, G4int level); // return the pointer to an ion ( create ion if the ion does not exist) // It has excitation energy nearest to given excitationEnergy (0: ground state) G4ParticleDefinition* FindIon( G4int atomicNumber, G4int atomicMass, G4int dummy1, G4int dummy2 ); // return the pointer to an ion // !! This routine behaves same as GetIon( atomicNumber, atomicMass, 0) // !! The third and fourth arguments are meaningless // !! This routine is provided for compatibility to old version /////////////////////////////////////////////////////////////////////////////////////// public: // With Description G4ParticleDefinition* Insert(G4ParticleDefinition *particle); // insert the particle into ParticleTable // return value is same as particle if successfully inserted // or pointer to another G4ParticleDefinition object // which has same name of particle // or 0 if fail to insert by another reason G4ParticleDefinition* Remove(G4ParticleDefinition *particle); // Remove the particle from the table (not delete) void RemoveAllParticles(); // remove all particles from G4ParticleTable void DeleteAllParticles(); // remove and delete all particles from G4ParticleTable public: G4UImessenger* CreateMessenger(); void DeleteMessenger(); // create/delete messenger for the particle table // these methods are supposed to be invoked by G4RunManager only protected: const G4PTblDictionary* GetDictionary() const; const G4String& GetKey(const G4ParticleDefinition *particle) const; // return key value of the particle (i.e. particle name) const G4PTblEncodingDictionary* GetEncodingDictionary() const; // return the pointer to EncodingDictionary private: G4int verboseLevel; // controle flag for output message // 0: Silent // 1: Warning message // 2: More public: void SetVerboseLevel(G4int value); G4int GetVerboseLevel() const; static G4ThreadLocal G4ParticleMessenger* fParticleMessenger; static G4ThreadLocal G4PTblDictionary* fDictionary; static G4ThreadLocal G4PTblDicIterator* fIterator; static G4ThreadLocal G4PTblEncodingDictionary* fEncodingDictionary; // These fields should be thread local or thread private. For a singleton // class, we can change any member field as static without any problem // because there is only one instance. Then we are allowed to add // "G4ThreadLocal". //01.25.2009 Xin Dong: Phase II change for Geant4 multi-threading. //Phase I changes this member to be thread local while each thread holds //its own copy of particles. //Phase II changes this member back in order to share particles. static G4ParticleTable* fgParticleTable; static G4IonTable* fIonTable; // This field should be thread private. However, we have to keep one copy // of the ion table pointer. So we change all important fields of G4IonTable // to the thread local variable. // These shadow pointers are used by each worker thread to copy the content // from the master thread. static G4ParticleMessenger* fParticleMessengerShadow; static G4PTblDictionary* fDictionaryShadow; static G4PTblDicIterator* fIteratorShadow; static G4PTblEncodingDictionary* fEncodingDictionaryShadow; private: const G4String noName; G4bool readyToUse; G4ParticleDefinition* genericIon; public: void SetReadiness(G4bool val=true); G4bool GetReadiness() const; G4ParticleDefinition* GetGenericIon() const; void SetGenericIon(G4ParticleDefinition*); private: void CheckReadiness() const; #ifdef G4MULTITHREADED public: //Andrea Dotti January 16. Shared instance of a mutex static G4Mutex particleTableMutex; static G4int lockCount; #endif }; #include "G4ParticleTable.icc" #endif