1 | // this : |
---|
2 | #include <G4Lab/PhysicsTableAccessor.h> |
---|
3 | |
---|
4 | // Inventor : |
---|
5 | #include <Inventor/SbString.h> |
---|
6 | #include <Inventor/SbName.h> |
---|
7 | #include <Inventor/nodes/SoSeparator.h> |
---|
8 | |
---|
9 | #ifdef WIN32 |
---|
10 | #undef pascal // Clash between windef.h and Geant4/SystemOfUnits.hh |
---|
11 | #endif |
---|
12 | |
---|
13 | // Geant4 : |
---|
14 | #include <G4ParticleTable.hh> |
---|
15 | #include <G4PhysicsTable.hh> |
---|
16 | #include <G4ParticleDefinition.hh> |
---|
17 | #include <G4Element.hh> |
---|
18 | #include <G4VProcess.hh> |
---|
19 | #include <G4ProcessVector.hh> |
---|
20 | #include <G4ProcessManager.hh> |
---|
21 | |
---|
22 | // Lib : |
---|
23 | #include <Slash/Core/ISession.h> |
---|
24 | #include <Slash/Data/IIterator.h> |
---|
25 | #include <Lib/Out.h> |
---|
26 | #include <Lib/Value.h> |
---|
27 | #include <Lib/smanip.h> |
---|
28 | #include <Lib/fmanip.h> |
---|
29 | #include <Lib/dirmanip.h> |
---|
30 | #include <Lib/Debug.h> |
---|
31 | |
---|
32 | // AIDA : |
---|
33 | #include <AIDA/IAnalysisFactory.h> |
---|
34 | #include <AIDA/ITreeFactory.h> |
---|
35 | #include <AIDA/ITree.h> |
---|
36 | #include <AIDA/IPlotterFactory.h> |
---|
37 | #include <AIDA/IPlotter.h> |
---|
38 | #include <AIDA/IPlotterRegion.h> |
---|
39 | #include <AIDA/IFunctionFactory.h> |
---|
40 | #include <AIDA/IFunction.h> |
---|
41 | |
---|
42 | namespace G4Lab { |
---|
43 | class PhysicsTable { |
---|
44 | public: |
---|
45 | PhysicsTable(const std::string& aTableName, |
---|
46 | const std::string& aProcessName, |
---|
47 | const std::string& aParticleName, |
---|
48 | G4PhysicsTable* aTable, |
---|
49 | G4VProcess* aProcess, |
---|
50 | G4ParticleDefinition* aParticle) |
---|
51 | :fTableName(aTableName) |
---|
52 | ,fProcessName(aProcessName) |
---|
53 | ,fParticleName(aParticleName) |
---|
54 | ,fTable(aTable) |
---|
55 | ,fProcess(aProcess) |
---|
56 | ,fParticle(aParticle){} |
---|
57 | virtual ~PhysicsTable() { |
---|
58 | delete fTable; |
---|
59 | } |
---|
60 | public: |
---|
61 | std::string fTableName; |
---|
62 | std::string fProcessName; |
---|
63 | std::string fParticleName; |
---|
64 | G4PhysicsTable* fTable; |
---|
65 | G4VProcess* fProcess; |
---|
66 | G4ParticleDefinition* fParticle; |
---|
67 | Lib::Debug fDebug; |
---|
68 | }; |
---|
69 | } |
---|
70 | |
---|
71 | ////////////////////////////////////////////////////////////////////////////// |
---|
72 | G4Lab::PhysicsTableAccessor::PhysicsTableAccessor( |
---|
73 | Slash::Core::ISession& aSession |
---|
74 | ,AIDA::IAnalysisFactory* aAIDA |
---|
75 | ) |
---|
76 | :Lib::BaseAccessor(aSession.printer()) |
---|
77 | ,fSession(aSession) |
---|
78 | ,fType("PhysicsTable") |
---|
79 | ,fAIDA(aAIDA) |
---|
80 | ////////////////////////////////////////////////////////////////////////////// |
---|
81 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
82 | { |
---|
83 | addProperty("table",Lib::Property::STRING); |
---|
84 | addProperty("process",Lib::Property::STRING); |
---|
85 | addProperty("particle",Lib::Property::STRING); |
---|
86 | addProperty("number",Lib::Property::INTEGER); |
---|
87 | addProperty("name",Lib::Property::STRING); |
---|
88 | } |
---|
89 | ////////////////////////////////////////////////////////////////////////////// |
---|
90 | G4Lab::PhysicsTableAccessor::~PhysicsTableAccessor( |
---|
91 | ) |
---|
92 | ////////////////////////////////////////////////////////////////////////////// |
---|
93 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
94 | { |
---|
95 | for(unsigned int index=0;index<fTables.size();index++) delete fTables[index]; |
---|
96 | } |
---|
97 | ////////////////////////////////////////////////////////////////////////////// |
---|
98 | std::string G4Lab::PhysicsTableAccessor::name( |
---|
99 | ) const |
---|
100 | ////////////////////////////////////////////////////////////////////////////// |
---|
101 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
102 | { |
---|
103 | return fType; |
---|
104 | } |
---|
105 | namespace G4Lab { |
---|
106 | class PhysicsTableIterator : public virtual Slash::Data::IIterator { |
---|
107 | public: //Slash::Data::IIterator |
---|
108 | virtual Slash::Data::IAccessor::Data object() { |
---|
109 | if(fIterator==fVector.end()) return 0; |
---|
110 | return *fIterator; |
---|
111 | } |
---|
112 | virtual void next() { ++fIterator; } |
---|
113 | virtual void* tag() { return 0;} |
---|
114 | public: |
---|
115 | PhysicsTableIterator(std::vector<G4Lab::PhysicsTable*>& aVector) |
---|
116 | :fVector(aVector) { |
---|
117 | fIterator = fVector.begin(); |
---|
118 | } |
---|
119 | virtual ~PhysicsTableIterator() {} |
---|
120 | private: |
---|
121 | std::vector<G4Lab::PhysicsTable*>& fVector; |
---|
122 | std::vector<G4Lab::PhysicsTable*>::iterator fIterator; |
---|
123 | }; |
---|
124 | } |
---|
125 | ////////////////////////////////////////////////////////////////////////////// |
---|
126 | Slash::Data::IIterator* G4Lab::PhysicsTableAccessor::iterator( |
---|
127 | ) |
---|
128 | ////////////////////////////////////////////////////////////////////////////// |
---|
129 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
130 | { |
---|
131 | if(!fTables.size() ) { |
---|
132 | G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable(); |
---|
133 | if(particleTable) { |
---|
134 | G4ParticleTable::G4PTblDicIterator* particleTableIterator = |
---|
135 | particleTable->GetIterator(); |
---|
136 | if(particleTableIterator) { |
---|
137 | particleTableIterator->reset(); |
---|
138 | while( (*particleTableIterator)() ){ |
---|
139 | G4ParticleDefinition* particle = particleTableIterator->value(); |
---|
140 | if(particle) { |
---|
141 | G4String particleName = particle->GetParticleName(); |
---|
142 | //Lib::Out out(fSession.printer()); |
---|
143 | //out << "debug : Particle : " << particleName << Lib::endl; |
---|
144 | // Processes for this particle : |
---|
145 | G4ProcessManager* processManager = particle->GetProcessManager(); |
---|
146 | if(processManager) { |
---|
147 | G4ProcessVector* processList = processManager->GetProcessList(); |
---|
148 | if(processList) { |
---|
149 | int number = processList->entries(); |
---|
150 | for (int index=0;index<number;index++){ |
---|
151 | G4VProcess* process = (*processList)(index); |
---|
152 | std::vector<std::string> names; |
---|
153 | std::vector<G4PhysicsTable*> tables; |
---|
154 | if(findProcessTables(particle, |
---|
155 | process, |
---|
156 | names, |
---|
157 | tables)) { |
---|
158 | for(unsigned int i=0;i<tables.size();i++) { |
---|
159 | std::vector<std::string> words; |
---|
160 | Lib::smanip::words(names[i],".",words); |
---|
161 | if(words.size()==3) { |
---|
162 | fTables.push_back(new PhysicsTable(words[0], |
---|
163 | words[1], |
---|
164 | words[2], |
---|
165 | tables[i], |
---|
166 | process, |
---|
167 | particle)); |
---|
168 | } |
---|
169 | } |
---|
170 | } |
---|
171 | } |
---|
172 | } |
---|
173 | } |
---|
174 | } |
---|
175 | } |
---|
176 | } |
---|
177 | } |
---|
178 | } |
---|
179 | |
---|
180 | return new PhysicsTableIterator(fTables); |
---|
181 | } |
---|
182 | ////////////////////////////////////////////////////////////////////////////// |
---|
183 | Slash::Core::IValue* G4Lab::PhysicsTableAccessor::findValue( |
---|
184 | Slash::Data::IAccessor::Data aData |
---|
185 | ,const std::string& aName |
---|
186 | ,void* |
---|
187 | ) |
---|
188 | ////////////////////////////////////////////////////////////////////////////// |
---|
189 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
190 | { |
---|
191 | PhysicsTable* obj = (PhysicsTable*)aData; |
---|
192 | if(aName=="table") { |
---|
193 | return new Lib::Value(obj->fTableName); |
---|
194 | } else if(aName=="process") { |
---|
195 | return new Lib::Value(obj->fProcessName); |
---|
196 | } else if(aName=="particle") { |
---|
197 | return new Lib::Value(obj->fParticleName); |
---|
198 | } else if(aName=="number") { |
---|
199 | return new Lib::Value((int)obj->fTable->size()); |
---|
200 | } else if(aName=="name") { |
---|
201 | std::string name = |
---|
202 | obj->fTableName + "." + obj->fProcessName + "." + obj->fParticleName; |
---|
203 | return new Lib::Value(name); |
---|
204 | } else { |
---|
205 | return new Lib::Value(); |
---|
206 | } |
---|
207 | } |
---|
208 | ////////////////////////////////////////////////////////////////////////////// |
---|
209 | void G4Lab::PhysicsTableAccessor::beginVisualize( |
---|
210 | ) |
---|
211 | ////////////////////////////////////////////////////////////////////////////// |
---|
212 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
213 | { |
---|
214 | if(!fAIDA) { |
---|
215 | Lib::Out out(fSession.printer()); |
---|
216 | out << "G4Lab::PhysicsTableAccessor::beginVisualize :" |
---|
217 | << " AIDA not found. Can't then find an AIDA plotter." |
---|
218 | << Lib::endl; |
---|
219 | } |
---|
220 | } |
---|
221 | ////////////////////////////////////////////////////////////////////////////// |
---|
222 | void G4Lab::PhysicsTableAccessor::visualize( |
---|
223 | Slash::Data::IAccessor::Data aData |
---|
224 | ,void* |
---|
225 | ) |
---|
226 | ////////////////////////////////////////////////////////////////////////////// |
---|
227 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
228 | { |
---|
229 | PhysicsTable* obj = (PhysicsTable*)aData; |
---|
230 | |
---|
231 | std::string value; |
---|
232 | |
---|
233 | bool superpose = true; |
---|
234 | if(fSession.parameterValue("modeling.superpose",value)) |
---|
235 | if(!Lib::smanip::tobool(value,superpose)) superpose = true; |
---|
236 | |
---|
237 | if(!fAIDA) return; |
---|
238 | |
---|
239 | AIDA::ITreeFactory* tf = fAIDA->createTreeFactory(); |
---|
240 | if(!tf) return; |
---|
241 | AIDA::ITree* memoryTree = tf->create(); |
---|
242 | delete tf; |
---|
243 | if(!memoryTree) return; |
---|
244 | |
---|
245 | AIDA::IFunctionFactory* functionFactory = |
---|
246 | fAIDA->createFunctionFactory(*memoryTree); |
---|
247 | if(!functionFactory) { |
---|
248 | Lib::Out out(fSession.printer()); |
---|
249 | out << "Can't create an function factory." << Lib::endl; |
---|
250 | return; |
---|
251 | } |
---|
252 | |
---|
253 | AIDA::IPlotterFactory* plotterFactory = fAIDA->createPlotterFactory(); |
---|
254 | if(!plotterFactory) { |
---|
255 | Lib::Out out(fSession.printer()); |
---|
256 | out << "Can't create a plotter factory." << Lib::endl; |
---|
257 | delete functionFactory; |
---|
258 | return; |
---|
259 | } |
---|
260 | |
---|
261 | AIDA::IPlotter* plotter = plotterFactory->create(); |
---|
262 | if(!plotter) { |
---|
263 | Lib::Out out(fSession.printer()); |
---|
264 | out << "Can't create a plotter factory." << Lib::endl; |
---|
265 | delete functionFactory; |
---|
266 | delete plotterFactory; |
---|
267 | return; |
---|
268 | } |
---|
269 | |
---|
270 | int number = obj->fTable->entries(); |
---|
271 | if(!superpose) { |
---|
272 | if(number>0) plotter->createRegions(1,number,0); |
---|
273 | else plotter->createRegions(1,1,0); |
---|
274 | } |
---|
275 | |
---|
276 | for (int count=0;count<number;count++){ |
---|
277 | G4PhysicsVector* physicsVector = (*(obj->fTable))[count]; |
---|
278 | size_t n = physicsVector->GetVectorLength(); |
---|
279 | if(n>=2) { |
---|
280 | std::string name; |
---|
281 | Lib::smanip::printf(name,1024,"%s.%s.%s.%d", |
---|
282 | obj->fTableName.c_str(), |
---|
283 | obj->fProcessName.c_str(), |
---|
284 | obj->fParticleName.c_str(), |
---|
285 | count); |
---|
286 | std::vector<double> params; |
---|
287 | params.push_back(1); // Dimension of the grid (here one). |
---|
288 | params.push_back(n); // Number of entries for first grid axis. |
---|
289 | size_t i; |
---|
290 | for (i=0;i<n;i++) params.push_back(i); // Xs. |
---|
291 | for (i=0;i<n;i++) params.push_back((*physicsVector)[i]); //Values. |
---|
292 | AIDA::IFunction* function = |
---|
293 | functionFactory->createFunctionByName(name,"Grid1D"); |
---|
294 | if(!function) { |
---|
295 | Lib::Out out(fSession.printer()); |
---|
296 | out << "Can't create \"" << name << "\" function." << Lib::endl; |
---|
297 | break; |
---|
298 | } |
---|
299 | function->setParameters(params); |
---|
300 | |
---|
301 | AIDA::IPlotterRegion& region = plotter->currentRegion(); |
---|
302 | |
---|
303 | region.plot(*function); |
---|
304 | region.setParameter("plotter.xAxisAutomated","FALSE"); |
---|
305 | std::string value1; |
---|
306 | Lib::smanip::printf(value1,32,"%g",0.); |
---|
307 | region.setParameter("plotter.xAxisMinimum",value1); |
---|
308 | std::string value2; |
---|
309 | Lib::smanip::printf(value2,32,"%g",(double)(n-1)); |
---|
310 | region.setParameter("plotter.xAxisMaximum",value2); |
---|
311 | std::string value3; |
---|
312 | Lib::smanip::printf(value3,32,"%d",4 * n); |
---|
313 | region.setParameter("plotter.xNumberOfPoints",value3); |
---|
314 | /* |
---|
315 | fSession.out().println("debug : min : %s, max : %s, steps : %s\n.", |
---|
316 | value1.c_str(),value2.c_str(),value3.c_str()); |
---|
317 | */ |
---|
318 | |
---|
319 | if(!superpose) plotter->next(); |
---|
320 | |
---|
321 | } |
---|
322 | } |
---|
323 | |
---|
324 | delete plotter; |
---|
325 | delete functionFactory; |
---|
326 | delete plotterFactory; |
---|
327 | |
---|
328 | } |
---|
329 | ////////////////////////////////////////////////////////////////////////////// |
---|
330 | void G4Lab::PhysicsTableAccessor::endVisualize( |
---|
331 | ) |
---|
332 | ////////////////////////////////////////////////////////////////////////////// |
---|
333 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
334 | { |
---|
335 | } |
---|
336 | ////////////////////////////////////////////////////////////////////////////// |
---|
337 | bool G4Lab::PhysicsTableAccessor::findProcessTables( |
---|
338 | G4ParticleDefinition* aParticle |
---|
339 | ,G4VProcess* aProcess |
---|
340 | ,std::vector<std::string>& aTables |
---|
341 | ,std::vector<G4PhysicsTable*>& aPhysicsTables |
---|
342 | ) |
---|
343 | ////////////////////////////////////////////////////////////////////////////// |
---|
344 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
345 | { |
---|
346 | aTables.clear(); |
---|
347 | aPhysicsTables.clear(); |
---|
348 | |
---|
349 | std::string tmpName; |
---|
350 | if(!Lib::fmanip::tmpname(tmpName,".","G4Lab_tmp","")) { |
---|
351 | Lib::Out out(fSession.printer()); |
---|
352 | out << "Can't build a temporary directory name." << Lib::endl; |
---|
353 | return false; |
---|
354 | } |
---|
355 | |
---|
356 | if(!Lib::dirmanip::create(tmpName)) { |
---|
357 | Lib::Out out(fSession.printer()); |
---|
358 | out << "Can't create \"" << tmpName << "\" directory." << Lib::endl; |
---|
359 | return false; |
---|
360 | } |
---|
361 | |
---|
362 | #ifdef WIN32 //binary mode out on Windows. |
---|
363 | G4bool ascii = true; |
---|
364 | #else |
---|
365 | G4bool ascii = false; |
---|
366 | #endif |
---|
367 | aProcess->StorePhysicsTable(aParticle,tmpName,ascii); |
---|
368 | |
---|
369 | // Analyse the content of the directory : |
---|
370 | std::vector<std::string> files; |
---|
371 | if(!Lib::dirmanip::entries(tmpName,files,false)) { |
---|
372 | Lib::Out out(fSession.printer()); |
---|
373 | out << "Can't get files in \"" << tmpName << "\" directory." << Lib::endl; |
---|
374 | } else { |
---|
375 | // Analyse files : |
---|
376 | Lib::smanip::remove(files,"."); |
---|
377 | Lib::smanip::remove(files,".."); |
---|
378 | for(unsigned int index=0;index<files.size();index++) { |
---|
379 | std::vector<std::string> words; |
---|
380 | Lib::smanip::words(files[index],".",words); |
---|
381 | //Lib::Out out(fSession.printer()); |
---|
382 | //out << "debug : Analyse \"" << files[index] << "\" ." << Lib::endl; |
---|
383 | if(words.size()==4) { |
---|
384 | std::string table = words[0]; |
---|
385 | std::string process = words[1]; |
---|
386 | std::string particle = words[2]; |
---|
387 | //Lib::smanip::replace(aTables[i],".dat",""); |
---|
388 | std::string filename = |
---|
389 | aProcess->GetPhysicsTableFileName(aParticle, |
---|
390 | tmpName, |
---|
391 | table, |
---|
392 | ascii); |
---|
393 | G4PhysicsTable* physicsTable = |
---|
394 | new G4PhysicsTable(G4Element::GetNumberOfElements()); |
---|
395 | if(physicsTable) { |
---|
396 | G4bool status = physicsTable->RetrievePhysicsTable(filename,ascii); |
---|
397 | if(!status){ |
---|
398 | Lib::Out out(fSession.printer()); |
---|
399 | out << "Unable to read \"" << filename << "\" file." << Lib::endl; |
---|
400 | delete physicsTable; |
---|
401 | physicsTable = 0; |
---|
402 | } |
---|
403 | } |
---|
404 | if(physicsTable) { |
---|
405 | aTables.push_back(table+"."+process+"."+particle); |
---|
406 | aPhysicsTables.push_back(physicsTable); |
---|
407 | } |
---|
408 | } |
---|
409 | } |
---|
410 | } |
---|
411 | |
---|
412 | // Remove the temporary directory : |
---|
413 | if(!Lib::dirmanip::remove(tmpName)) { |
---|
414 | Lib::Out out(fSession.printer()); |
---|
415 | out << "Can't remove \"" << tmpName << "\" directory." << Lib::endl; |
---|
416 | aTables.clear(); |
---|
417 | aPhysicsTables.clear(); |
---|
418 | return false; |
---|
419 | } |
---|
420 | |
---|
421 | return true; |
---|
422 | } |
---|