| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 //
28 #ifndef G4InterpolationManager_h
29 #define G4InterpolationManager_h 1
30
31 #include "G4HadronicException.hh"
32 #include "G4InterpolationScheme.hh"
33 #include "G4ios.hh"
34 #include "globals.hh"
35
36 #include <fstream>
37
38 class G4InterpolationManager
39 {
40 public:
41 friend class G4InterpolationIterator;
42
43 G4InterpolationManager()
44 {
45 nRanges = 1;
46 start = new G4int[1];
47 start[0] = 0;
48 range = new G4int[1];
49 range[0] = 100000;
50 scheme = new G4InterpolationScheme[1];
51 scheme[0] = LINLIN;
52 nEntries = 0;
53 }
54
55 ~G4InterpolationManager()
56 {
57 delete[] start;
58 delete[] range;
59 delete[] scheme;
60 }
61
62 G4InterpolationManager& operator=(const G4InterpolationManager& aManager)
63 {
64 if (this != &aManager) {
65 nRanges = aManager.nRanges;
66 nEntries = aManager.nEntries;
67 delete[] scheme;
68 delete[] start;
69 delete[] range;
70 scheme = new G4InterpolationScheme[nRanges];
71 start = new G4int[nRanges];
72 range = new G4int[nRanges];
73 for (G4int i = 0; i < nRanges; i++) {
74 scheme[i] = aManager.scheme[i];
75 start[i] = aManager.start[i];
76 range[i] = aManager.range[i];
77 }
78 }
79 return *this;
80 }
81
82 inline void Init(G4int aScheme, G4int aRange)
83 {
84 nRanges = 1;
85 start[0] = 0;
86 range[0] = aRange;
87 scheme[0] = MakeScheme(aScheme);
88 nEntries = aRange;
89 }
90 inline void Init(G4InterpolationScheme aScheme, G4int aRange)
91 {
92 nRanges = 1;
93 start[0] = 0;
94 range[0] = aRange;
95 scheme[0] = aScheme;
96 nEntries = aRange;
97 }
98
99 inline void Init(std::istream& aDataFile)
100 {
101 delete[] start;
102 delete[] range;
103 delete[] scheme;
104 aDataFile >> nRanges;
105 start = new G4int[nRanges];
106 range = new G4int[nRanges];
107 scheme = new G4InterpolationScheme[nRanges];
108 start[0] = 0;
109 G4int it;
110 for (G4int i = 0; i < nRanges; i++) {
111 aDataFile >> range[i];
112 //***************************************************************
113 // EMendoza -> there is a bug here.
114 /*
115 if(i!=0) start[i] = start[i-1]+range[i-1];
116 */
117 //***************************************************************
118 if (i != 0) start[i] = range[i - 1];
119 //***************************************************************
120 aDataFile >> it;
121 scheme[i] = MakeScheme(it);
122 }
123 nEntries = start[nRanges - 1] + range[nRanges - 1];
124 }
125
126 G4InterpolationScheme MakeScheme(G4int it);
127
128 inline G4InterpolationScheme GetScheme(G4int index) const
129 {
130 G4int it = 0;
131 for (G4int i = 1; i < nRanges; i++) {
132 if (index < start[i]) break;
133 it = i;
134 }
135 return scheme[it];
136 }
137
138 inline void CleanUp()
139 {
140 nRanges = 0;
141 nEntries = 0;
142 }
143
144 inline G4InterpolationScheme GetInverseScheme(G4int index)
145 {
146 G4InterpolationScheme result = GetScheme(index);
147 if (result == HISTO) {
148 result = RANDOM;
149 }
150 else if (result == LINLOG) {
151 result = LOGLIN;
152 }
153 else if (result == LOGLIN) {
154 result = LINLOG;
155 }
156 else if (result == CHISTO) {
157 result = CRANDOM;
158 }
159 else if (result == CLINLOG) {
160 result = CLOGLIN;
161 }
162 else if (result == CLOGLIN) {
163 result = CLINLOG;
164 }
165 else if (result == UHISTO) {
166 result = URANDOM;
167 }
168 else if (result == ULINLOG) {
169 result = ULOGLIN;
170 }
171 else if (result == ULOGLIN) {
172 result = ULINLOG;
173 }
174 return result;
175 }
176
177 void AppendScheme(G4int aPoint, const G4InterpolationScheme& aScheme);
178
179 private:
180 G4int nRanges;
181 G4InterpolationScheme* scheme;
182 G4int* start;
183 G4int* range;
184 G4int nEntries;
185 };
186 #endif
187