| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // G4ElectronOccupancy << 8 // $Id: G4ElectronOccupancy.hh,v 1.4 1999/12/15 14:51:10 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 // 10 //
28 // Class description: << 11 //
>> 12 // ------------------------------------------------------------
>> 13 // GEANT 4 class header file
29 // 14 //
30 // This class has information of occupation of << 15 // For information related to this code contact:
31 // GetOccupancy(N) gives the number of electro << 16 // CERN, CN Division, ASD group
32 // For example : Carbon atom should be << 17 // History: first implementation, based on object model of
>> 18 // Hisaya Kurashige, 17 Aug 1999
>> 19 // ----------------------------------------------------------------
>> 20 // Class Description
>> 21 // This class has information of occupation of electrons
>> 22 // in atomic orbits
>> 23 // -
>> 24 // GetOccupancy(N) gives the number of electron
>> 25 // in N-th orbit
>> 26 // For example : Carbon atom should be
33 // GetOccupancy(0) --> 2 27 // GetOccupancy(0) --> 2
34 // GetOccupancy(1) --> 4 28 // GetOccupancy(1) --> 4
35 // GetOccupancy(2..7) --> 0 29 // GetOccupancy(2..7) --> 0
>> 30 // -
>> 31 // GetTotalOccupancy() gives the total number of electrons
36 // 32 //
37 // GetTotalOccupancy() gives the total number << 33 // ---------------------------------------------------------------
38 34
39 // Author: Hisaya Kurashige, 17 Aug 1999 <<
40 // ------------------------------------------- <<
41 #ifndef G4ElectronOccupancy_hh <<
42 #define G4ElectronOccupancy_hh 1 <<
43 35
>> 36
>> 37 #ifndef G4ElectronOccupancy_h
>> 38 #define G4ElectronOccupancy_h 1
>> 39
>> 40 #include "globals.hh"
44 #include "G4Allocator.hh" 41 #include "G4Allocator.hh"
45 #include "G4ios.hh" 42 #include "G4ios.hh"
46 #include "globals.hh" <<
47 43
48 #include "pwdefs.hh" << 44 class G4ElectronOccupancy
49 <<
50 class G4ElectronOccupancy <<
51 { 45 {
52 public: << 46 public:
53 enum << 47 enum { MaxSizeOfOrbit = 7};
54 { <<
55 MaxSizeOfOrbit = 20 <<
56 }; <<
57 <<
58 G4ElectronOccupancy(G4int sizeOrbit = MaxS <<
59 G4ElectronOccupancy(const G4ElectronOccupa <<
60 <<
61 virtual ~G4ElectronOccupancy(); <<
62 48
63 // new/delete operators are overloaded to << 49 public: // With Description
64 inline void* operator new(size_t); << 50 G4ElectronOccupancy( G4int sizeOrbit = MaxSizeOfOrbit );
65 inline void operator delete(void* aElectro << 51 G4ElectronOccupancy( const G4ElectronOccupancy& right );
>> 52
>> 53 public:
>> 54 virtual ~G4ElectronOccupancy();
>> 55
>> 56 // new/delete operators are oberloded to use G4Allocator
>> 57 inline void *operator new(size_t);
>> 58 inline void operator delete(void *aElectronOccupancy);
>> 59
>> 60
>> 61 //- operators
>> 62 G4ElectronOccupancy & operator=(const G4ElectronOccupancy &right);
>> 63 G4int operator==(const G4ElectronOccupancy &right) const;
>> 64 G4int operator!=(const G4ElectronOccupancy &right) const;
>> 65
>> 66 public: // With Description
>> 67 // The following methods returns
>> 68 // 0: if the orbit(atom) is vacant
>> 69 // >0: number of electrons in orbit
>> 70 G4int GetTotalOccupancy() const;
>> 71 G4int GetOccupancy(G4int orbit) const;
>> 72
>> 73 //
>> 74 G4int AddElectron(G4int orbit, G4int number = 1);
>> 75 G4int RemoveElectron(G4int orbit, G4int number = 1);
>> 76
>> 77 G4int GetSizeOfOrbit() const;
>> 78 void DumpInfo() const;
>> 79
>> 80 private:
>> 81 G4int theSizeOfOrbit;
>> 82 G4int theTotalOccupancy;
>> 83 G4int* theOccupancies;
66 84
67 G4ElectronOccupancy& operator=(const G4Ele <<
68 G4bool operator==(const G4ElectronOccupanc <<
69 G4bool operator!=(const G4ElectronOccupanc <<
70 <<
71 inline G4int GetTotalOccupancy() const; <<
72 inline G4int GetOccupancy(G4int orbit) con <<
73 // The following methods returns <<
74 // 0: if the orbit(atom) is vacant <<
75 // >0: number of electrons in orbit <<
76 <<
77 G4int AddElectron(G4int orbit, G4int numbe <<
78 G4int RemoveElectron(G4int orbit, G4int nu <<
79 <<
80 inline G4int GetSizeOfOrbit() const; <<
81 void DumpInfo() const; <<
82 <<
83 private: <<
84 G4int theSizeOfOrbit = 0; <<
85 G4int theTotalOccupancy = 0; <<
86 G4int* theOccupancies = nullptr; <<
87 }; 85 };
88 86
89 extern G4PART_DLL G4Allocator<G4ElectronOccupa << 87 extern G4Allocator<G4ElectronOccupancy> aElectronOccupancyAllocator;
90 88
91 // ------------------------ 89 // ------------------------
92 // Inline methods << 90 // Inlined operators
93 // ------------------------ 91 // ------------------------
94 92
95 inline void* G4ElectronOccupancy::operator new << 93 inline void * G4ElectronOccupancy::operator new(size_t)
96 { 94 {
97 if (aElectronOccupancyAllocator() == nullptr << 95 void * aElectronOccupancy;
98 aElectronOccupancyAllocator() = new G4Allo << 96 aElectronOccupancy = (void *) aElectronOccupancyAllocator.MallocSingle();
99 } << 97 return aElectronOccupancy;
100 return (void*)aElectronOccupancyAllocator()- <<
101 } 98 }
102 99
103 inline void G4ElectronOccupancy::operator dele << 100 inline void G4ElectronOccupancy::operator delete(void * aElectronOccupancy)
104 { 101 {
105 aElectronOccupancyAllocator()->FreeSingle((G << 102 aElectronOccupancyAllocator.FreeSingle((G4ElectronOccupancy *) aElectronOccupancy);
106 } 103 }
107 104
108 inline G4int G4ElectronOccupancy::GetSizeOfOrb << 105 inline
>> 106 G4int G4ElectronOccupancy::GetSizeOfOrbit() const
109 { 107 {
110 return theSizeOfOrbit; << 108 return theSizeOfOrbit;
111 } 109 }
112 110
113 inline G4int G4ElectronOccupancy::GetTotalOccu << 111 inline
>> 112 G4int G4ElectronOccupancy::GetTotalOccupancy() const
114 { 113 {
115 return theTotalOccupancy; << 114 return theTotalOccupancy;
116 } 115 }
117 116
118 inline G4int G4ElectronOccupancy::GetOccupancy << 117 inline
>> 118 G4int G4ElectronOccupancy::GetOccupancy(G4int orbit) const
119 { 119 {
120 G4int value = 0; 120 G4int value = 0;
121 if ((orbit >= 0) && (orbit < theSizeOfOrbit) << 121 if ((orbit >=0)&&(orbit<theSizeOfOrbit)){
122 value = theOccupancies[orbit]; 122 value = theOccupancies[orbit];
123 } 123 }
>> 124 return value;
>> 125 }
>> 126
>> 127 inline
>> 128 G4int G4ElectronOccupancy::AddElectron(G4int orbit, G4int number)
>> 129 {
>> 130 G4int value =0;
>> 131 if ((orbit >=0)&&(orbit<theSizeOfOrbit)){
>> 132 theOccupancies[orbit] += number;
>> 133 theTotalOccupancy += number;
>> 134 value = number;
>> 135 }
124 return value; 136 return value;
125 } 137 }
126 138
>> 139 inline
>> 140 G4int G4ElectronOccupancy::RemoveElectron(G4int orbit, G4int number)
>> 141 {
>> 142 G4int value =0;
>> 143 if ((orbit >=0)&&(orbit<theSizeOfOrbit) ){
>> 144 if ( theOccupancies[orbit] < number ) number = theOccupancies[orbit];
>> 145 theOccupancies[orbit] -= number;
>> 146 theTotalOccupancy -= number;
>> 147 value = number;
>> 148 }
>> 149 return value;
>> 150 }
127 #endif 151 #endif
>> 152
>> 153
>> 154
>> 155
>> 156
>> 157
128 158