| 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 *
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>
45 #include <G4UIcmdWithADoubleAndUnit.hh>
46 #include <G4UIcmdWithAString.hh>
47 #include <G4UIcmdWithABool.hh>
48 #include <G4UIcmdWith3Vector.hh>
49 #include <G4UIcmdWithoutParameter.hh>
50 #include "CexmcEnergyDepositDigitizer.hh"
51 #include "CexmcEnergyDepositDigitizerMessenger.hh"
52 #include "CexmcMessenger.hh"
53 #include "CexmcCommon.hh"
54
55
56 CexmcEnergyDepositDigitizerMessenger::CexmcEnergyDepositDigitizerMessenger(
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(
154 ( CexmcMessenger::detectorDirName +
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(
171 ( CexmcMessenger::detectorDirName +
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(
188 ( CexmcMessenger::detectorDirName +
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(
202 ( CexmcMessenger::detectorDirName +
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(
213 ( CexmcMessenger::detectorDirName +
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(
228 ( CexmcMessenger::detectorDirName +
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
238 CexmcEnergyDepositDigitizerMessenger::~CexmcEnergyDepositDigitizerMessenger()
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
256 void CexmcEnergyDepositDigitizerMessenger::SetNewValue( G4UIcommand * cmd,
257 G4String value )
258 {
259 do
260 {
261 if ( cmd == setMonitorThreshold )
262 {
263 energyDepositDigitizer->SetMonitorThreshold(
264 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
265 break;
266 }
267 if ( cmd == setVetoCountersThreshold )
268 {
269 energyDepositDigitizer->SetVetoCountersThreshold(
270 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
271 break;
272 }
273 if ( cmd == setLeftVetoCounterThreshold )
274 {
275 energyDepositDigitizer->SetVetoCounterLeftThreshold(
276 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
277 break;
278 }
279 if ( cmd == setRightVetoCounterThreshold )
280 {
281 energyDepositDigitizer->SetVetoCounterRightThreshold(
282 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
283 break;
284 }
285 if ( cmd == setCalorimetersThreshold )
286 {
287 energyDepositDigitizer->SetCalorimetersThreshold(
288 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
289 break;
290 }
291 if ( cmd == setLeftCalorimeterThreshold )
292 {
293 energyDepositDigitizer->SetCalorimeterLeftThreshold(
294 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
295 break;
296 }
297 if ( cmd == setRightCalorimeterThreshold )
298 {
299 energyDepositDigitizer->SetCalorimeterRightThreshold(
300 G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
301 break;
302 }
303 if ( cmd == setCalorimeterTriggerAlgorithm )
304 {
305 CexmcCalorimeterTriggerAlgorithm calorimeterTriggerAlgorithm(
306 CexmcAllCrystalsMakeEDTriggerThreshold );
307 do
308 {
309 if ( value == "inner" )
310 {
311 calorimeterTriggerAlgorithm =
312 CexmcInnerCrystalsMakeEDTriggerThreshold;
313 break;
314 }
315 } while ( false );
316 energyDepositDigitizer->SetCalorimeterTriggerAlgorithm(
317 calorimeterTriggerAlgorithm );
318 break;
319 }
320 if ( cmd == setOuterCrystalsVetoAlgorithm )
321 {
322 CexmcOuterCrystalsVetoAlgorithm outerCrystalsVetoAlgorithm(
323 CexmcNoOuterCrystalsVeto );
324 do
325 {
326 if ( value == "max" )
327 {
328 outerCrystalsVetoAlgorithm =
329 CexmcMaximumEDInASingleOuterCrystalVeto;
330 break;
331 }
332 if ( value == "fraction" )
333 {
334 outerCrystalsVetoAlgorithm =
335 CexmcFractionOfEDInOuterCrystalsVeto;
336 break;
337 }
338 } while ( false );
339 energyDepositDigitizer->SetOuterCrystalsVetoAlgorithm(
340 outerCrystalsVetoAlgorithm );
341 break;
342 }
343 if ( cmd == setOuterCrystalsVetoFraction )
344 {
345 energyDepositDigitizer->SetOuterCrystalsVetoFraction(
346 G4UIcmdWithADouble::GetNewDoubleValue( value ) );
347 break;
348 }
349 if ( cmd == applyFiniteCrystalResolution )
350 {
351 energyDepositDigitizer->ApplyFiniteCrystalResolution(
352 G4UIcmdWithABool::GetNewBoolValue( value ) );
353 break;
354 }
355 if ( cmd == addCrystalResolutionRange )
356 {
357 G4ThreeVector vec( G4UIcmdWith3Vector::GetNew3VectorValue(
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
373