Geant4_10
CexmcEnergyDepositDigitizerMessenger.cc
Go to the documentation of this file.
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  *
29  * Filename: CexmcEnergyDepositDigitizerMessenger.cc
30  *
31  * Description: energy deposit digitizer messenger
32  *
33  * Version: 1.0
34  * Created: 29.11.2009 19:07:05
35  * Revision: none
36  * Compiler: gcc
37  *
38  * Author: Alexey Radkov (),
39  * Company: PNPI
40  *
41  * ============================================================================
42  */
43 
44 #include <G4UIcmdWithADouble.hh>
46 #include <G4UIcmdWithAString.hh>
47 #include <G4UIcmdWithABool.hh>
48 #include <G4UIcmdWith3Vector.hh>
52 #include "CexmcMessenger.hh"
53 #include "CexmcCommon.hh"
54 
55 
57  CexmcEnergyDepositDigitizer * energyDepositDigitizer ) :
58  energyDepositDigitizer( energyDepositDigitizer ),
59  setMonitorThreshold( NULL ), setVetoCountersThreshold( NULL ),
60  setLeftVetoCounterThreshold( NULL ), setRightVetoCounterThreshold( NULL ),
61  setCalorimetersThreshold( NULL ), setLeftCalorimeterThreshold( NULL ),
62  setRightCalorimeterThreshold( NULL ),
63  setCalorimeterTriggerAlgorithm( NULL ),
64  setOuterCrystalsVetoAlgorithm( NULL ), setOuterCrystalsVetoFraction( NULL ),
65  applyFiniteCrystalResolution( NULL ), addCrystalResolutionRange( NULL ),
66  clearCrystalResolutionData( NULL )
67 {
68  setMonitorThreshold = new G4UIcmdWithADoubleAndUnit(
69  ( CexmcMessenger::monitorEDDirName + "threshold" ).c_str(), this );
70  setMonitorThreshold->SetGuidance( "Monitor trigger threshold" );
71  setMonitorThreshold->SetParameterName( "MonitorThreshold", false );
72  setMonitorThreshold->SetDefaultValue( 0 );
73  setMonitorThreshold->SetUnitCandidates( "ev keV MeV GeV" );
74  setMonitorThreshold->SetDefaultUnit( "MeV" );
75  setMonitorThreshold->AvailableForStates( G4State_PreInit, G4State_Idle );
76 
77  setVetoCountersThreshold = new G4UIcmdWithADoubleAndUnit(
78  ( CexmcMessenger::vetoCounterEDDirName + "threshold" ).c_str(),
79  this );
80  setVetoCountersThreshold->SetGuidance( "Veto counters trigger threshold" );
81  setVetoCountersThreshold->SetParameterName( "VetoCountersThreshold",
82  false );
83  setVetoCountersThreshold->SetDefaultValue( 0 );
84  setVetoCountersThreshold->SetUnitCandidates( "ev keV MeV GeV" );
85  setVetoCountersThreshold->SetDefaultUnit( "MeV" );
86  setVetoCountersThreshold->AvailableForStates( G4State_PreInit,
87  G4State_Idle );
88 
89  setLeftVetoCounterThreshold = new G4UIcmdWithADoubleAndUnit(
90  ( CexmcMessenger::vetoCounterLeftEDDirName + "threshold" ).c_str(),
91  this );
92  setLeftVetoCounterThreshold->SetGuidance(
93  "Left veto counter trigger threshold" );
94  setLeftVetoCounterThreshold->SetParameterName( "LeftVetoCounterThreshold",
95  false );
96  setLeftVetoCounterThreshold->SetDefaultValue( 0 );
97  setLeftVetoCounterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
98  setLeftVetoCounterThreshold->SetDefaultUnit( "MeV" );
99  setLeftVetoCounterThreshold->AvailableForStates( G4State_PreInit,
100  G4State_Idle );
101 
102  setRightVetoCounterThreshold = new G4UIcmdWithADoubleAndUnit(
103  ( CexmcMessenger::vetoCounterRightEDDirName + "threshold" ).c_str(),
104  this );
105  setRightVetoCounterThreshold->SetGuidance(
106  "Right veto counter trigger threshold" );
107  setRightVetoCounterThreshold->SetParameterName( "RightVetoCounterThreshold",
108  false );
109  setRightVetoCounterThreshold->SetDefaultValue( 0 );
110  setRightVetoCounterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
111  setRightVetoCounterThreshold->SetDefaultUnit( "MeV" );
112  setRightVetoCounterThreshold->AvailableForStates( G4State_PreInit,
113  G4State_Idle );
114 
115  setCalorimetersThreshold = new G4UIcmdWithADoubleAndUnit(
116  ( CexmcMessenger::calorimeterEDDirName + "threshold" ).c_str(),
117  this );
118  setCalorimetersThreshold->SetGuidance( "Calorimeters trigger threshold" );
119  setCalorimetersThreshold->SetParameterName( "CalorimetersThreshold",
120  false );
121  setCalorimetersThreshold->SetDefaultValue( 0 );
122  setCalorimetersThreshold->SetUnitCandidates( "ev keV MeV GeV" );
123  setCalorimetersThreshold->SetDefaultUnit( "MeV" );
124  setCalorimetersThreshold->AvailableForStates( G4State_PreInit,
125  G4State_Idle );
126 
127  setLeftCalorimeterThreshold = new G4UIcmdWithADoubleAndUnit(
128  ( CexmcMessenger::calorimeterLeftEDDirName + "threshold" ).c_str(),
129  this );
130  setLeftCalorimeterThreshold->SetGuidance(
131  "Left calorimeter trigger threshold" );
132  setLeftCalorimeterThreshold->SetParameterName( "LeftCalorimeterThreshold",
133  false );
134  setLeftCalorimeterThreshold->SetDefaultValue( 0 );
135  setLeftCalorimeterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
136  setLeftCalorimeterThreshold->SetDefaultUnit( "MeV" );
137  setLeftCalorimeterThreshold->AvailableForStates( G4State_PreInit,
138  G4State_Idle );
139 
140  setRightCalorimeterThreshold = new G4UIcmdWithADoubleAndUnit(
141  ( CexmcMessenger::calorimeterRightEDDirName + "threshold" ).c_str(),
142  this );
143  setRightCalorimeterThreshold->SetGuidance(
144  "Right calorimeter trigger threshold" );
145  setRightCalorimeterThreshold->SetParameterName( "RightCalorimeterThreshold",
146  false );
147  setRightCalorimeterThreshold->SetDefaultValue( 0 );
148  setRightCalorimeterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
149  setRightCalorimeterThreshold->SetDefaultUnit( "MeV" );
150  setRightCalorimeterThreshold->AvailableForStates( G4State_PreInit,
151  G4State_Idle );
152 
153  setCalorimeterTriggerAlgorithm = new G4UIcmdWithAString(
155  "calorimeterTriggerAlgorithm" ).c_str(), this );
156  setCalorimeterTriggerAlgorithm->SetGuidance( "\n"
157  " all - energy deposit in all crystals in a calorimeter\n"
158  " will be checked against calorimeter threshold "
159  "value,\n"
160  " inner - energy deposit in only inner crystals\n"
161  " will be checked against calorimeter threshold "
162  "value" );
163  setCalorimeterTriggerAlgorithm->SetParameterName(
164  "CalorimeterTriggerAlgorithm", false );
165  setCalorimeterTriggerAlgorithm->SetCandidates( "all inner" );
166  setCalorimeterTriggerAlgorithm->SetDefaultValue( "inner" );
167  setCalorimeterTriggerAlgorithm->AvailableForStates( G4State_PreInit,
168  G4State_Idle );
169 
170  setOuterCrystalsVetoAlgorithm = new G4UIcmdWithAString(
172  "outerCrystalsVetoAlgorithm" ).c_str(), this );
173  setOuterCrystalsVetoAlgorithm->SetGuidance( "\n"
174  " none - events will not be rejected by any algorithm,\n"
175  " max - reject event trigger if crystal with maximum energy "
176  "\n deposit is one of outer crystals,\n"
177  " fraction - reject event trigger if energy deposit "
178  "fraction in\n outer crystals is more than "
179  "value of\n 'outerCrystalsVetoFraction'" );
180  setOuterCrystalsVetoAlgorithm->SetParameterName(
181  "OuterCrystalsVetoAlgorithm", false );
182  setOuterCrystalsVetoAlgorithm->SetCandidates( "none max fraction" );
183  setOuterCrystalsVetoAlgorithm->SetDefaultValue( "none" );
184  setOuterCrystalsVetoAlgorithm->AvailableForStates( G4State_PreInit,
185  G4State_Idle );
186 
187  setOuterCrystalsVetoFraction = new G4UIcmdWithADouble(
189  "outerCrystalsVetoFraction" ).c_str(), this );
190  setOuterCrystalsVetoFraction->SetGuidance( "\n Fraction of whole energy "
191  "deposit in one calorimeter\n that belongs to outer crystals.\n"
192  " If 'outerCrystalsVetoAlgorithm' is 'fraction' and\n"
193  " the outer crystals energy deposit fraction exceeds "
194  "this\n value then event won't trigger" );
195  setOuterCrystalsVetoFraction->SetParameterName(
196  "OuterCrystalsVetoFraction", false );
197  setOuterCrystalsVetoFraction->SetDefaultValue( 0 );
198  setOuterCrystalsVetoFraction->AvailableForStates( G4State_PreInit,
199  G4State_Idle );
200 
201  applyFiniteCrystalResolution = new G4UIcmdWithABool(
203  "applyFiniteCrystalResolution" ).c_str(), this );
204  applyFiniteCrystalResolution->SetGuidance( "\n Specify if finite "
205  "energy resolution of the crystals\n will be accounted" );
206  applyFiniteCrystalResolution->SetParameterName(
207  "ApplyFiniteCrystalResolution", true );
208  applyFiniteCrystalResolution->SetDefaultValue( true );
209  applyFiniteCrystalResolution->AvailableForStates( G4State_PreInit,
210  G4State_Idle );
211 
212  addCrystalResolutionRange = new G4UIcmdWith3Vector(
214  "addCrystalResolutionRange" ).c_str(), this );
215  addCrystalResolutionRange->SetGuidance( "\n Add new energy range "
216  "(in GeV!) with fwhm percentage\n value of crystal resolution "
217  "in this range" );
218  addCrystalResolutionRange->SetParameterName(
219  "CrystalResolutionRangeBottom", "CrystalResolutionRangeTop",
220  "CrystalResolutionRangeValue", false );
221  addCrystalResolutionRange->SetRange( "CrystalResolutionRangeBottom >= 0. "
222  "&& CrystalResolutionRangeTop >= 0. && "
223  "CrystalResolutionRangeValue >= 0." );
224  addCrystalResolutionRange->AvailableForStates( G4State_PreInit,
225  G4State_Idle );
226 
227  clearCrystalResolutionData = new G4UIcmdWithoutParameter(
229  "clearCrystalResolutionData" ).c_str(), this );
230  clearCrystalResolutionData->SetGuidance( "\n Clear all crystal "
231  "resolution ranges.\n Can be used to redefine crystal "
232  "resolution data" );
233  clearCrystalResolutionData->AvailableForStates( G4State_PreInit,
234  G4State_Idle );
235 }
236 
237 
239 {
240  delete setMonitorThreshold;
241  delete setVetoCountersThreshold;
242  delete setLeftVetoCounterThreshold;
243  delete setRightVetoCounterThreshold;
244  delete setCalorimetersThreshold;
245  delete setLeftCalorimeterThreshold;
246  delete setRightCalorimeterThreshold;
247  delete setCalorimeterTriggerAlgorithm;
248  delete setOuterCrystalsVetoAlgorithm;
249  delete setOuterCrystalsVetoFraction;
250  delete applyFiniteCrystalResolution;
251  delete addCrystalResolutionRange;
252  delete clearCrystalResolutionData;
253 }
254 
255 
257  G4String value )
258 {
259  do
260  {
261  if ( cmd == setMonitorThreshold )
262  {
263  energyDepositDigitizer->SetMonitorThreshold(
265  break;
266  }
267  if ( cmd == setVetoCountersThreshold )
268  {
269  energyDepositDigitizer->SetVetoCountersThreshold(
271  break;
272  }
273  if ( cmd == setLeftVetoCounterThreshold )
274  {
275  energyDepositDigitizer->SetVetoCounterLeftThreshold(
277  break;
278  }
279  if ( cmd == setRightVetoCounterThreshold )
280  {
281  energyDepositDigitizer->SetVetoCounterRightThreshold(
283  break;
284  }
285  if ( cmd == setCalorimetersThreshold )
286  {
287  energyDepositDigitizer->SetCalorimetersThreshold(
289  break;
290  }
291  if ( cmd == setLeftCalorimeterThreshold )
292  {
293  energyDepositDigitizer->SetCalorimeterLeftThreshold(
295  break;
296  }
297  if ( cmd == setRightCalorimeterThreshold )
298  {
299  energyDepositDigitizer->SetCalorimeterRightThreshold(
301  break;
302  }
303  if ( cmd == setCalorimeterTriggerAlgorithm )
304  {
305  CexmcCalorimeterTriggerAlgorithm calorimeterTriggerAlgorithm(
307  do
308  {
309  if ( value == "inner" )
310  {
311  calorimeterTriggerAlgorithm =
313  break;
314  }
315  } while ( false );
316  energyDepositDigitizer->SetCalorimeterTriggerAlgorithm(
317  calorimeterTriggerAlgorithm );
318  break;
319  }
320  if ( cmd == setOuterCrystalsVetoAlgorithm )
321  {
322  CexmcOuterCrystalsVetoAlgorithm outerCrystalsVetoAlgorithm(
324  do
325  {
326  if ( value == "max" )
327  {
328  outerCrystalsVetoAlgorithm =
330  break;
331  }
332  if ( value == "fraction" )
333  {
334  outerCrystalsVetoAlgorithm =
336  break;
337  }
338  } while ( false );
339  energyDepositDigitizer->SetOuterCrystalsVetoAlgorithm(
340  outerCrystalsVetoAlgorithm );
341  break;
342  }
343  if ( cmd == setOuterCrystalsVetoFraction )
344  {
345  energyDepositDigitizer->SetOuterCrystalsVetoFraction(
347  break;
348  }
349  if ( cmd == applyFiniteCrystalResolution )
350  {
351  energyDepositDigitizer->ApplyFiniteCrystalResolution(
353  break;
354  }
355  if ( cmd == addCrystalResolutionRange )
356  {
358  value ) );
359  G4double bottom( std::min( vec.x(), vec.y() ) );
360  G4double top( std::max( vec.x(), vec.y() ) );
361  energyDepositDigitizer->AddCrystalResolutionRange( bottom, top,
362  vec.z() );
363  break;
364  }
365  if ( cmd == clearCrystalResolutionData )
366  {
367  energyDepositDigitizer->ClearCrystalResolutionData();
368  break;
369  }
370  } while ( false );
371 }
372 
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
void SetOuterCrystalsVetoFraction(G4double value, G4bool fromMessenger=true)
char cmd[1024]
Definition: tracer.cxx:25
double x() const
void SetCalorimeterLeftThreshold(G4double value, G4bool fromMessenger=true)
static G4String vetoCounterEDDirName
void SetParameterName(const char *theNameX, const char *theNameY, const char *theNameZ, G4bool omittable, G4bool currentAsDefault=false)
static G4String monitorEDDirName
void SetOuterCrystalsVetoAlgorithm(CexmcOuterCrystalsVetoAlgorithm value, G4bool fromMessenger=true)
static G4String detectorDirName
void ClearCrystalResolutionData(G4bool fromMessenger=true)
void SetCalorimeterRightThreshold(G4double value, G4bool fromMessenger=true)
void SetVetoCounterRightThreshold(G4double value, G4bool fromMessenger=true)
static G4double GetNewDoubleValue(const char *paramString)
static G4bool GetNewBoolValue(const char *paramString)
double z() const
static G4String calorimeterEDDirName
void SetDefaultValue(G4bool defVal)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
static G4String calorimeterRightEDDirName
static G4ThreeVector GetNew3VectorValue(const char *paramString)
void AddCrystalResolutionRange(G4double bottom, G4double top, G4double value, G4bool fromMessenger=true)
static G4double GetNewDoubleValue(const char *paramString)
void SetRange(const char *rs)
Definition: G4UIcommand.hh:125
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
void AvailableForStates(G4ApplicationState s1)
Definition: G4UIcommand.cc:225
static G4String calorimeterLeftEDDirName
void SetNewValue(G4UIcommand *cmd, G4String value)
void SetDefaultValue(const char *defVal)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
T max(const T t1, const T t2)
brief Return the largest of the two arguments
void SetDefaultUnit(const char *defUnit)
double y() const
void SetDefaultValue(G4double defVal)
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
void ApplyFiniteCrystalResolution(G4bool value, G4bool fromMessenger=true)
CexmcOuterCrystalsVetoAlgorithm
Definition: CexmcCommon.hh:138
const XML_Char int const XML_Char * value
Definition: expat.h:331
void SetCalorimeterTriggerAlgorithm(CexmcCalorimeterTriggerAlgorithm value, G4bool fromMessenger=true)
void SetVetoCounterLeftThreshold(G4double value, G4bool fromMessenger=true)
void SetCandidates(const char *candidateList)
CexmcEnergyDepositDigitizerMessenger(CexmcEnergyDepositDigitizer *energyDepositDigitiser)
double G4double
Definition: G4Types.hh:76
void SetMonitorThreshold(G4double value, G4bool fromMessenger=true)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
static G4String vetoCounterRightEDDirName
CexmcCalorimeterTriggerAlgorithm
Definition: CexmcCommon.hh:146
void SetUnitCandidates(const char *candidateList)
static G4String vetoCounterLeftEDDirName