Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 << 25 // >> 26 // $Id: G4ElementData.hh 72057 2013-07-04 13:07:29Z gcosmo $ >> 27 // 26 //-------------------------------------------- 28 //--------------------------------------------------------------------------- 27 // 29 // 28 // GEANT4 Class file 30 // GEANT4 Class file 29 // 31 // 30 // Description: Data structure for cross secti 32 // Description: Data structure for cross sections, shell cross sections, 31 // isotope cross sections. Data a << 33 // isotope cross sections. Control of vector size should be 32 // Z (atomic number in majority o << 34 // performed in user code, no protection in this class 33 // be in the interval 0 <= Z < le << 34 // data a second parameter idx or << 35 // In most cases ID = A - atomic << 36 // There are run time const metho << 37 // assuming responsibility of con << 38 // check input and may throwgh a << 39 // 35 // 40 // Author: V.Ivanchenko 10.03.2011 36 // Author: V.Ivanchenko 10.03.2011 41 // 37 // 42 // Modifications: 30.09.2023 Extended function << 38 // Modifications: 43 // 39 // 44 //-------------------------------------------- 40 //---------------------------------------------------------------------------- 45 // 41 // 46 42 47 #ifndef G4ElementData_h << 43 #ifndef ElementData_h 48 #define G4ElementData_h 1 << 44 #define ElementData_h 1 49 45 50 #include "G4Physics2DVector.hh" << 46 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 51 #include "G4PhysicsVector.hh" << 52 #include "globals.hh" << 53 47 >> 48 #include "globals.hh" >> 49 #include "G4NistElementBuilder.hh" >> 50 #include "G4PhysicsVector.hh" >> 51 #include "G4Physics2DVector.hh" 54 #include <vector> 52 #include <vector> 55 53 56 class G4ElementData << 54 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 55 >> 56 class G4ElementData 57 { 57 { 58 public: << 58 public: 59 explicit G4ElementData(G4int length = 99); << 60 59 61 ~G4ElementData(); << 60 G4ElementData(); 62 61 63 // Assignment operator and copy constructor << 62 ~G4ElementData(); 64 G4ElementData& operator=(const G4ElementData << 65 G4ElementData(const G4ElementData&) = delete << 66 63 67 // add cross section for the element 64 // add cross section for the element 68 void InitialiseForElement(G4int Z, G4Physics 65 void InitialiseForElement(G4int Z, G4PhysicsVector* v); 69 66 70 // add 2D cross section for the element 67 // add 2D cross section for the element 71 void InitialiseForElement(G4int Z, G4Physics 68 void InitialiseForElement(G4int Z, G4Physics2DVector* v); 72 69 73 // reserve vector of components 70 // reserve vector of components 74 void InitialiseForComponent(G4int Z, G4int n << 71 void InitialiseForComponent(G4int Z, G4int nComponents=0); 75 << 76 // reserve vector of 2D components << 77 void InitialiseFor2DComponent(G4int Z, G4int << 78 72 79 // prepare vector of components 73 // prepare vector of components 80 void AddComponent(G4int Z, G4int id, G4Physi 74 void AddComponent(G4int Z, G4int id, G4PhysicsVector* v); 81 75 82 // prepare vector of 2D components << 76 // set name of the dataset 83 void Add2DComponent(G4int Z, G4int id, G4Phy << 77 void SetName(const G4String& nam); 84 78 85 // set name of the dataset (optional) << 79 // get vector for the element 86 inline void SetName(const G4String& nam); << 80 inline G4PhysicsVector* GetElementData(G4int Z); 87 81 88 //------------------------------------------ << 82 // get 2-D vector for the element 89 // run time const methods - no check on vali << 83 inline G4Physics2DVector* GetElement2DData(G4int Z); 90 // it is a responsibility of the consume cod << 91 //------------------------------------------ << 92 84 93 // get name of the dataset << 85 // get number of components for the element 94 inline const G4String& GetName() const; << 86 inline size_t GetNumberOfComponents(G4int Z); 95 87 96 // get vector for the element << 88 // get component ID which may be number of nucleons, 97 inline G4PhysicsVector* GetElementData(G4int << 98 << 99 // get 2-D vector for the element << 100 inline G4Physics2DVector* GetElement2DData(G << 101 << 102 // get vector per shell or per isotope << 103 inline G4PhysicsVector* GetComponentDataByID << 104 << 105 // get vector per shell or per isotope << 106 inline G4Physics2DVector* Get2DComponentData << 107 << 108 // return cross section per element << 109 inline G4double GetValueForElement(G4int Z, << 110 << 111 //------------------------------------------ << 112 // run time const methods with input paramet << 113 //------------------------------------------ << 114 << 115 // get number of components for the element << 116 inline std::size_t GetNumberOfComponents(G4i << 117 << 118 // get number of 2D components for the eleme << 119 inline std::size_t GetNumberOf2DComponents(G << 120 << 121 // get component ID which may be number of n << 122 // or shell number, or any other integer 89 // or shell number, or any other integer 123 inline G4int GetComponentID(G4int Z, std::si << 90 inline G4int GetComponentID(G4int Z, size_t idx); 124 91 125 // get vector per shell or per isotope 92 // get vector per shell or per isotope 126 inline G4PhysicsVector* << 93 inline G4PhysicsVector* GetComponentDataByIndex(G4int Z, size_t idx); 127 GetComponentDataByIndex(G4int Z, std::size_t << 128 94 129 // get vector per shell or per isotope 95 // get vector per shell or per isotope 130 inline G4Physics2DVector* << 96 inline G4PhysicsVector* GetComponentDataByID(G4int Z, G4int id); 131 Get2DComponentDataByIndex(G4int Z, std::size << 132 97 133 // return cross section per element << 98 // return cross section per element 134 // if not available return zero 99 // if not available return zero 135 inline G4double << 100 inline G4double GetValueForElement(G4int Z, G4double kinEnergy); 136 GetValueForComponent(G4int Z, std::size_t id << 137 101 138 private: << 102 // return cross section per element 139 << 103 // if not available return zero 140 void DataError(G4int Z, const G4String&); << 104 inline G4double GetValueForComponent(G4int Z, size_t idx, G4double kinEnergy); 141 105 142 const G4int maxNumElm; << 106 private: 143 107 144 std::vector<G4PhysicsVector*> elmData; << 108 // Assignment operator and copy constructor 145 std::vector<G4Physics2DVector*> elm2Data; << 109 G4ElementData & operator=(const G4ElementData &right); 146 std::vector<std::vector<std::pair<G4int, G4P << 110 G4ElementData(const G4ElementData&); 147 std::vector<std::vector<std::pair<G4int, G4P << 148 111 149 G4String name{""}; << 112 G4PhysicsVector* elmData[maxNumElements]; >> 113 G4Physics2DVector* elm2Data[maxNumElements]; >> 114 std::vector<G4PhysicsVector*> compData[maxNumElements]; >> 115 std::vector<G4int> compID[maxNumElements]; >> 116 size_t compLength[maxNumElements]; >> 117 G4String name; 150 }; 118 }; 151 119 152 //-------------------------------------------- << 153 // run time const methods without check on val << 154 //-------------------------------------------- << 155 << 156 inline void G4ElementData::SetName(const G4Str 120 inline void G4ElementData::SetName(const G4String& nam) 157 { 121 { 158 name = nam; 122 name = nam; 159 } 123 } 160 124 161 inline const G4String& G4ElementData::GetName( << 125 inline 162 { << 126 G4PhysicsVector* G4ElementData::GetElementData(G4int Z) 163 return name; << 164 } << 165 << 166 inline G4PhysicsVector* G4ElementData::GetElem << 167 { 127 { 168 return elmData[Z]; 128 return elmData[Z]; 169 } 129 } 170 130 171 inline G4Physics2DVector* G4ElementData::GetEl << 131 inline >> 132 G4Physics2DVector* G4ElementData::GetElement2DData(G4int Z) 172 { 133 { 173 return elm2Data[Z]; 134 return elm2Data[Z]; 174 } 135 } 175 136 176 inline G4PhysicsVector* << 137 inline 177 G4ElementData::GetComponentDataByID(G4int Z, G << 138 size_t G4ElementData::GetNumberOfComponents(G4int Z) 178 { 139 { 179 G4PhysicsVector* v = nullptr; << 140 return compLength[Z]; 180 for (auto const & p : *(compData[Z])) { << 181 if (id == p.first) { << 182 v = p.second; << 183 break; << 184 } << 185 } << 186 return v; << 187 } 141 } 188 142 189 inline G4Physics2DVector* << 143 inline G4int G4ElementData::GetComponentID(G4int Z, size_t idx) 190 G4ElementData::Get2DComponentDataByID(G4int Z, << 191 { 144 { 192 G4Physics2DVector* v = nullptr; << 145 return (compID[Z])[idx]; 193 for (auto const & p : *(comp2D[Z])) { << 194 if (id == p.first) { << 195 v = p.second; << 196 break; << 197 } << 198 } << 199 return v; << 200 } 146 } 201 147 202 inline G4double << 148 inline 203 G4ElementData::GetValueForElement(G4int Z, G4d << 149 G4PhysicsVector* G4ElementData::GetComponentDataByIndex(G4int Z, size_t idx) 204 { 150 { 205 return elmData[Z]->Value(kinEnergy); << 151 return (compData[Z])[idx]; 206 } 152 } 207 153 208 //-------------------------------------------- << 154 inline 209 // run time const methods with check on validi << 155 G4PhysicsVector* G4ElementData::GetComponentDataByID(G4int Z, G4int id) 210 //-------------------------------------------- << 211 << 212 inline std::size_t G4ElementData::GetNumberOfC << 213 { 156 { 214 return (nullptr != compData[Z]) ? compData[Z << 157 G4PhysicsVector* v = 0; 215 } << 158 for(size_t i=0; i<compLength[Z]; ++i) { 216 << 159 if(id == (compID[Z])[i]) { 217 inline std::size_t G4ElementData::GetNumberOf2 << 160 v = (compData[Z])[i]; 218 { << 161 break; 219 return (nullptr != comp2D[Z]) ? comp2D[Z]->s << 162 } 220 } << 163 } 221 << 164 return v; 222 inline G4int G4ElementData::GetComponentID(G4i << 223 { << 224 return (idx < GetNumberOfComponents(Z)) ? (* << 225 } 165 } 226 166 227 inline G4PhysicsVector* << 167 inline 228 G4ElementData::GetComponentDataByIndex(G4int Z << 168 G4double G4ElementData::GetValueForElement(G4int Z, G4double kinEnergy) 229 { 169 { 230 return << 170 return elmData[Z]->Value(kinEnergy); 231 (idx < GetNumberOfComponents(Z)) ? (*(comp << 232 } 171 } 233 172 234 inline G4Physics2DVector* << 173 inline G4double 235 G4ElementData::Get2DComponentDataByIndex(G4int << 174 G4ElementData::GetValueForComponent(G4int Z, size_t idx, G4double kinEnergy) 236 { 175 { 237 return << 176 return ((compData[Z])[idx])->Value(kinEnergy); 238 (idx < GetNumberOf2DComponents(Z)) ? (*(co << 239 } 177 } 240 178 241 inline G4double << 179 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 242 G4ElementData::GetValueForComponent(G4int Z, s << 243 { << 244 return (idx < GetNumberOfComponents(Z)) ? << 245 (*(compData[Z]))[idx].second->Value(e) : 0 << 246 } << 247 180 248 #endif 181 #endif >> 182 249 183