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