ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CexmcEnergyDepositDigitizerMessenger.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CexmcEnergyDepositDigitizerMessenger.cc
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