source: trunk/examples/advanced/radiation_monitor/analysis/src/RadmonAnalysisLayout.cc @ 1321

Last change on this file since 1321 was 807, checked in by garnier, 16 years ago

update
File size: 17.7 KB
Line 
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// File name:     RadmonDataAnalysisLayout.cc
28// Creation date: Nov 2005
29// Main author:   Riccardo Capra <capra@ge.infn.it>
30//
31// Id:            $Id: RadmonAnalysisLayout.cc,v 1.3 2006/06/29 16:07:37 gunter Exp $
32// Tag:           $Name:  $
33//
34
35// Include files
36#include "RadmonAnalysisLayout.hh"
37#include "RadmonDumpStyle.hh"
38#include "G4UnitsTable.hh"
39
40#include <iomanip>
41
42
43                                                RadmonAnalysisLayout :: RadmonAnalysisLayout()
44{
45}
46 
47 
48 
49                                                RadmonAnalysisLayout :: ~RadmonAnalysisLayout()
50{
51}
52
53
54
55
56
57void                                            RadmonAnalysisLayout :: SetOutputFileName(const G4String & outputFileName)
58{
59 if (fileName==outputFileName)
60  return;
61 
62 fileName=outputFileName;
63 NotifyChange();
64}
65
66
67
68const G4String &                                RadmonAnalysisLayout :: GetOutputFileName(void) const
69{
70 return fileName;
71}
72
73
74
75void                                            RadmonAnalysisLayout :: SetOutputFileFormat(const G4String & outputFileFormat)
76{
77 if (fileFormat==outputFileFormat)
78  return;
79 
80 fileFormat=outputFileFormat;
81 NotifyChange();
82}
83
84
85
86const G4String &                                RadmonAnalysisLayout :: GetOutputFileFormat(void) const
87{
88 return fileFormat;
89}
90
91
92
93
94
95void                                            RadmonAnalysisLayout :: CreateSensitiveDetector(const G4String & sensitiveDetectorLabel, const G4String & sensitiveDetectorType)
96{
97 if (ExistsSensitiveDetector(sensitiveDetectorLabel)) 
98  return;
99 
100 if (!FindSensitiveDetectorType(sensitiveDetectorType))
101  return;
102 
103 sensitiveDetectors.push_back(SensitiveDetector(sensitiveDetectorLabel, sensitiveDetectorType));
104 NotifyChange();
105}
106
107
108
109void                                            RadmonAnalysisLayout :: SetSensitiveDetectorType(const G4String & sensitiveDetectorLabel, const G4String & sensitiveDetectorType)
110{
111 SensitiveDetector * sensitiveDetector(FindSensitiveDetector(sensitiveDetectorLabel));
112 
113 if (!sensitiveDetector)
114  return;
115 
116 if (sensitiveDetectorType==sensitiveDetector->second)
117  return;
118 
119 if (!FindSensitiveDetectorType(sensitiveDetectorType))
120  return;
121 
122 sensitiveDetector->second=sensitiveDetectorType;
123 NotifyChange();
124}
125
126
127
128const G4String &                                RadmonAnalysisLayout :: GetSensitiveDetectorType(const G4String & sensitiveDetectorLabel) const
129{
130 const SensitiveDetector * sensitiveDetector(FindSensitiveDetector(sensitiveDetectorLabel));
131 
132 if (!sensitiveDetector)
133  return GetNullStr();
134 
135 return sensitiveDetector->second;
136}
137
138
139
140void                                            RadmonAnalysisLayout :: RemoveSensitiveDetector(const G4String & sensitiveDetectorLabel)
141{
142 SensitiveDetectors::iterator i(sensitiveDetectors.begin());
143 const SensitiveDetectors::iterator end(sensitiveDetectors.end());
144 
145 while (i<end)
146 {
147  if (i->first==sensitiveDetectorLabel)
148  {
149   sensitiveDetectors.erase(i);
150   return;
151  }
152 
153  i++;
154 } 
155
156 G4cout << "RadmonAnalysisLayout::RemoveSensitiveDetector: Sensitive detector \"" << sensitiveDetectorLabel << "\" does not exist." << G4endl;
157}
158
159
160
161G4int                                           RadmonAnalysisLayout :: GetNSensitiveDetectors(void) const
162{
163 return sensitiveDetectors.size();
164}
165
166
167
168const G4String &                                RadmonAnalysisLayout :: GetSensitiveDetectorLabel(G4int index) const
169{
170 return sensitiveDetectors[index].first;
171}
172
173
174
175
176
177void                                            RadmonAnalysisLayout :: CreateSensitiveDetectorType(const G4String & sensitiveDetectorTypeLabel)
178{
179 if (sensitiveDetectorTypes.ExistsItemByLabel(sensitiveDetectorTypeLabel))
180 {
181  G4cout << "RadmonAnalysisLayout::CreateSensitiveDetectorType: Sensitive detector \"" << sensitiveDetectorTypeLabel << "\" just exists." << G4endl;
182  return;
183 }
184 
185 RadmonAnalysisSensitiveDetectorTypeLayout & sensitiveDetectorType(sensitiveDetectorTypes.AppendItem());
186 sensitiveDetectorType.SetLabel(sensitiveDetectorTypeLabel);
187}
188
189
190
191void                                            RadmonAnalysisLayout :: RemoveSensitiveDetectorType(const G4String & sensitiveDetectorTypeLabel)
192{
193 if (!sensitiveDetectorTypes.ExistsItemByLabel(sensitiveDetectorTypeLabel))
194 {
195  G4cout << "RadmonAnalysisLayout::RemoveSensitiveDetectorType: Sensitive detector \"" << sensitiveDetectorTypeLabel << "\" does not exist." << G4endl;
196  return;
197 }
198 
199 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
200 {
201  G4cout << "RadmonAnalysisLayout::RemoveSensitiveDetectorType: Sensitive detector \"" << sensitiveDetectorTypeLabel << "\" is in use. Cannot be removed." << G4endl;
202  return;
203 }
204
205 sensitiveDetectorTypes.RemoveItemByLabel(sensitiveDetectorTypeLabel);
206}
207
208
209
210
211
212void                                            RadmonAnalysisLayout :: AppendDataAnalysisToSensitiveDetectorType(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel)
213{
214 RadmonAnalysisSensitiveDetectorTypeLayout * sensitiveDetectorType(FindSensitiveDetectorType(sensitiveDetectorTypeLabel));
215 
216 if (! sensitiveDetectorType)
217  return;
218 
219 if (sensitiveDetectorType->ExistsDataAnalysisByLabel(dataAnalysisLabel))
220 {
221  G4cout << "RadmonAnalysisLayout::AppendDataAnalysisToSensitiveDetectorType: Data analysis label \"" << dataAnalysisLabel << "\" just exits in sensitive detector \"" << sensitiveDetectorTypeLabel << "\"." << G4endl;
222  return;
223 }
224 
225 RadmonDataAnalysisLayout & dataAnalysisLayout(sensitiveDetectorType->AppendDataAnalysis());
226 dataAnalysisLayout.SetLabel(dataAnalysisLabel);
227
228 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
229  NotifyChange();
230}
231
232
233
234void                                            RadmonAnalysisLayout :: SetDataAnalysisType(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel, const G4String & dataAnalysisType)
235{
236 RadmonDataAnalysisLayout * dataAnalysis(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
237 
238 if (!dataAnalysis)
239  return;
240 
241 if (dataAnalysis->GetType()==dataAnalysisType)
242  return;
243 
244 dataAnalysis->SetType(dataAnalysisType);
245 
246 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
247  NotifyChange();
248}
249
250
251
252void                                            RadmonAnalysisLayout :: RemoveDataAnalysis(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel)
253{
254 RadmonAnalysisSensitiveDetectorTypeLayout * sensitiveDetectorType(FindSensitiveDetectorType(sensitiveDetectorTypeLabel));
255 
256 if (! sensitiveDetectorType)
257  return;
258 
259 if (!sensitiveDetectorType->ExistsDataAnalysisByLabel(dataAnalysisLabel))
260 {
261  G4cout << "RadmonAnalysisLayout::RemoveDataAnalysis: Data analysis label \"" << dataAnalysisLabel << "\" does not exit in sensitive detector \"" << sensitiveDetectorTypeLabel << "\"." << G4endl;
262  return;
263 }
264 
265 sensitiveDetectorType->RemoveDataAnalysisByLabel(dataAnalysisLabel);
266 
267 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
268  NotifyChange();
269}
270
271
272
273G4int                                           RadmonAnalysisLayout :: GetNDataAnalyses(const G4String & sensitiveDetectorTypeLabel) const
274{
275 const RadmonAnalysisSensitiveDetectorTypeLayout * sensitiveDetectorType(FindSensitiveDetectorType(sensitiveDetectorTypeLabel));
276 
277 if (! sensitiveDetectorType)
278  return 0;
279 
280 return sensitiveDetectorType->GetNDataAnalyses();
281}
282
283
284
285const G4String &                                RadmonAnalysisLayout :: GetDataAnalysisLabel(const G4String & sensitiveDetectorTypeLabel, G4int index) const
286{
287 const RadmonAnalysisSensitiveDetectorTypeLayout * sensitiveDetectorType(FindSensitiveDetectorType(sensitiveDetectorTypeLabel));
288 
289 if (! sensitiveDetectorType)
290  return GetNullStr();
291 
292 return sensitiveDetectorType->GetDataAnalysis(index).GetLabel();
293}
294
295
296
297const G4String &                                RadmonAnalysisLayout :: GetDataAnalysisType(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel) const
298{
299 const RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
300 
301 if (!dataAnalysisType)
302  return GetNullStr();
303 
304 return dataAnalysisType->GetType();
305}
306
307
308
309
310
311void                                            RadmonAnalysisLayout :: SetDataAnalysisAttribute(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel, const G4String & attributeName, const G4String & attributeValue)
312{
313 RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
314 
315 if (!dataAnalysisType)
316  return;
317 
318 dataAnalysisType->SetAttribute(attributeName, attributeValue);
319 
320 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
321  NotifyChange();
322}
323
324
325
326void                                            RadmonAnalysisLayout :: ClearDataAnalysisAttribute(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel, const G4String & attributeName)
327{
328 RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
329 
330 if (!dataAnalysisType)
331  return;
332 
333 if (!dataAnalysisType->ExistsAttribute(attributeName))
334 {
335  G4cout << "RadmonAnalysisLayout::ClearDataAnalysisAttribute: Attribute \"" << attributeName << "\" does not exist in data analysis \"" << dataAnalysisLabel << "\" of sensitive detector \"" << sensitiveDetectorTypeLabel << "\"." << G4endl;
336  return;
337 } 
338 
339 dataAnalysisType->ClearAttribute(attributeName);
340 
341 if (SensitiveDetectorTypeInUse(sensitiveDetectorTypeLabel))
342  NotifyChange();
343}
344
345
346
347G4int                                           RadmonAnalysisLayout :: GetDataAnalysisNAttributes(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel) const
348{
349 const RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
350 
351 if (!dataAnalysisType)
352  return 0;
353 
354 return dataAnalysisType->GetNAttributes();
355}
356
357
358
359G4String                                        RadmonAnalysisLayout :: GetDataAnalysisAttributeName(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel, G4int index) const
360{
361 const RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
362 
363 if (!dataAnalysisType)
364  return GetNullStr();
365 
366 return dataAnalysisType->GetAttributeName(index);
367}
368
369
370
371G4String                                        RadmonAnalysisLayout :: GetDataAnalysisAttribute(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel, const G4String & attributeName, const G4String & defaultAttributeValue) const
372{
373 const RadmonDataAnalysisLayout * dataAnalysisType(FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel));
374 
375 if (!dataAnalysisType)
376  return G4String();
377 
378 return dataAnalysisType->GetAttribute(attributeName, defaultAttributeValue);
379}
380
381
382
383
384
385void                                            RadmonAnalysisLayout :: DumpLayout(std::ostream & out) const
386{
387 const G4String indent("  - ");
388
389 out << "- " << std::setw(RADMONDUMP_INDENT_WIDTH-2); out.setf(std::ostream::left, std::ostream::adjustfield); out << "File name";   out.setf(std::ostream::right, std::ostream::adjustfield); out << " = \"" << fileName << "\"\n"
390        "  " << std::setw(RADMONDUMP_INDENT_WIDTH-2); out.setf(std::ostream::left, std::ostream::adjustfield); out << "File format"; out.setf(std::ostream::right, std::ostream::adjustfield); out << " = \"" << fileFormat << "\"\n"
391        "\n- Sensitive detectors\n";
392
393 G4String indent2(indent);
394 indent2.prepend("  ");
395
396 if (sensitiveDetectors.empty())
397  out << indent << "No sensitive detectors defined.\n";
398 else
399 {
400  const G4int width(RADMONDUMP_INDENT_WIDTH-indent2.length());
401  const G4int n(sensitiveDetectors.size());
402 
403  for (G4int i(0); i<n; i++)
404  {
405   out << indent << "Sensitive Detector # " << i << '\n'
406       << indent2 << std::setw(width); out.setf(std::ostream::left, std::ostream::adjustfield); out << "Label"; out.setf(std::ostream::right, std::ostream::adjustfield); out << " = \"" << sensitiveDetectors[i].first << "\"\n"
407       << indent2 << std::setw(width); out.setf(std::ostream::left, std::ostream::adjustfield); out << "Type"; out.setf(std::ostream::right, std::ostream::adjustfield); out << " = \"" << sensitiveDetectors[i].second << "\"\n";
408  }
409 }
410 
411 out << "\n- Sensitive detector types\n";
412 G4int n(sensitiveDetectorTypes.GetNItems());
413 if (n==0)
414 {
415  out << indent << "No sensitive detector types defined.\n";
416  return;
417 }
418
419 for(G4int i(0); i<n; i++)
420 {
421  out << indent << "Sensitive detector type # " << i << '\n';
422   
423  sensitiveDetectorTypes.GetItem(i).DumpLayout(out, indent2);
424 }
425}
426
427
428
429
430
431G4bool                                          RadmonAnalysisLayout :: Load(std::istream & /* in */)
432{
433 // TO BE DONE
434 G4cout << "RadmonAnalysisLayout::Load(): PLEASE CHECK" << G4endl;
435
436 return false; 
437}
438
439
440
441G4bool                                          RadmonAnalysisLayout :: Save(std::ostream & /* out */) const
442{
443 // TO BE DONE
444 G4cout << "RadmonAnalysisLayout::Save(): PLEASE CHECK" << G4endl;
445
446 return false; 
447}
448
449
450
451
452
453inline G4bool                                   RadmonAnalysisLayout :: SensitiveDetectorTypeInUse(const G4String & sensitiveDetectorType)
454{
455 G4int i(0);
456 G4int n(sensitiveDetectors.size());
457 
458 for (; i<n; i++)
459  if (sensitiveDetectors[i].second==sensitiveDetectorType)
460   return true;
461
462 return false; 
463}
464
465
466
467inline G4bool                                   RadmonAnalysisLayout :: ExistsSensitiveDetector(const G4String & sensitiveDetectorLabel) const
468{
469 G4int i(0);
470 G4int n(sensitiveDetectors.size());
471 
472 for (; i<n; i++)
473  if (sensitiveDetectors[i].first==sensitiveDetectorLabel)
474  {
475   G4cout << "RadmonAnalysisLayout::ExistsSensitiveDetector: Sensitive detector \"" << sensitiveDetectorLabel << "\" just exists." << G4endl;
476   return true;
477  }
478
479 return false; 
480}
481
482
483
484inline RadmonAnalysisLayout::SensitiveDetector * RadmonAnalysisLayout :: FindSensitiveDetector(const G4String & sensitiveDetectorLabel)
485{
486 G4int i(0);
487 G4int n(sensitiveDetectors.size());
488 
489 for (; i<n; i++)
490  if (sensitiveDetectors[i].first==sensitiveDetectorLabel)
491   return &(sensitiveDetectors[i]);
492
493 G4cout << "RadmonAnalysisLayout::FindSensitiveDetector: Sensitive detector \"" << sensitiveDetectorLabel << "\" does not exist." << G4endl;
494 return 0;
495}
496
497
498
499inline const RadmonAnalysisLayout::SensitiveDetector * RadmonAnalysisLayout :: FindSensitiveDetector(const G4String & sensitiveDetectorLabel) const
500{
501 return const_cast<RadmonAnalysisLayout *>(this)->FindSensitiveDetector(sensitiveDetectorLabel);
502}
503
504
505
506inline RadmonAnalysisSensitiveDetectorTypeLayout * RadmonAnalysisLayout :: FindSensitiveDetectorType(const G4String & sensitiveDetectorTypeLabel)
507{
508 if (!sensitiveDetectorTypes.ExistsItemByLabel(sensitiveDetectorTypeLabel))
509 {
510  G4cout << "RadmonAnalysisLayout::FindSensitiveDetectorType: Sensitive detector type \"" << sensitiveDetectorTypeLabel << "\" does not exist." << G4endl;
511  return 0;
512 }
513
514 return & sensitiveDetectorTypes.FindItemByLabel(sensitiveDetectorTypeLabel);
515}
516
517
518
519inline const RadmonAnalysisSensitiveDetectorTypeLayout * RadmonAnalysisLayout :: FindSensitiveDetectorType(const G4String & sensitiveDetectorTypeLabel) const
520{
521 return const_cast<RadmonAnalysisLayout *>(this)->FindSensitiveDetectorType(sensitiveDetectorTypeLabel);
522}
523
524
525
526inline RadmonDataAnalysisLayout *               RadmonAnalysisLayout :: FindDataAnalysis(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel)
527{
528 RadmonAnalysisSensitiveDetectorTypeLayout * sensitiveDetectorType(FindSensitiveDetectorType(sensitiveDetectorTypeLabel));
529 
530 if (sensitiveDetectorType==0)
531  return 0;
532
533 if (!sensitiveDetectorType->ExistsDataAnalysisByLabel(dataAnalysisLabel))
534 {
535  G4cout << "RadmonAnalysisLayout::FindDataAnalysis: Data analysis labelled \"" << dataAnalysisLabel << "\" does not exist in sensitive detector type \"" << sensitiveDetectorTypeLabel << "\"." << G4endl;
536  return 0;
537 }
538
539 return & sensitiveDetectorType->FindDataAnalysisByLabel(dataAnalysisLabel);
540}
541
542
543
544inline const RadmonDataAnalysisLayout *         RadmonAnalysisLayout :: FindDataAnalysis(const G4String & sensitiveDetectorTypeLabel, const G4String & dataAnalysisLabel) const
545{
546 return const_cast<RadmonAnalysisLayout *>(this)->FindDataAnalysis(sensitiveDetectorTypeLabel, dataAnalysisLabel);
547}
548
549
550
551
552
553inline G4String &                               RadmonAnalysisLayout :: GetNullStr() const
554{
555 static G4String *nullStr(0);
556 
557 if (nullStr==0)
558  nullStr=new G4String("");
559 
560 return *nullStr;
561}
Note: See TracBrowser for help on using the repository browser.