LBNEPLacementMessenger.cc
Go to the documentation of this file.
1 //#include <fstream>
2 
3 #include "LBNEDetectorConstruction.hh"
4 
5 #include "G4UIdirectory.hh"
6 #include "G4UIcmdWithAString.hh"
7 #include "G4UIcmdWithABool.hh"
8 #include "G4UIcmdWithAnInteger.hh"
9 #include "G4UIcmdWithADoubleAndUnit.hh"
10 #include "G4UIcmdWithADouble.hh"
11 #include "G4UIcmdWithoutParameter.hh"
12 #include "G4UnitsTable.hh"
13 #include "LBNEPlacementMessenger.hh"
14 
15 LBNEPlacementMessenger* LBNEPlacementMessenger::fInstance = 0;
16 LBNEPlacementMessenger* LBNEPlacementMessenger::Instance() {
17  if (fInstance == 0) fInstance = new LBNEPlacementMessenger();
18  return fInstance;
19 }
20 
21 LBNEPlacementMessenger::~LBNEPlacementMessenger() {
22 
23 }
24 
25 LBNEPlacementMessenger::LBNEPlacementMessenger()
26  {
27 
28 // std::cerr << " LBNEPlacementMessenger::LBNEPlacementMessenger, contructor, starts " << std::endl;
29  LBNEVolumePlacements* volP=LBNEVolumePlacements::Instance();
30  {
31  fDecayPipeLength = new G4UIcmdWithADoubleAndUnit("/LBNE/det/decayPipeLength",this);
32  fDecayPipeLength->SetGuidance("Length of the decay Pipe");
33  fDecayPipeLength->SetParameterName("decayPipeLength",true);
34  double value = volP->GetDecayPipeLength();
35  fDecayPipeLength->SetDefaultValue (value);
36  fDecayPipeLength->SetDefaultUnit ("m");
37  fDecayPipeLength->SetUnitCandidates ("cm m");
38  fDecayPipeLength->AvailableForStates(G4State_PreInit);
39  }
40  {
41  fDecayPipeLongPosition = new G4UIcmdWithADoubleAndUnit("/LBNE/det/decayPipeLongPosition",this);
42  fDecayPipeLongPosition->SetGuidance("Longitudinal Position of the entrance window of the decay pipe with respect to target");
43  fDecayPipeLongPosition->SetParameterName("decayPipeLongPosition",true);
44  double value = volP->GetDecayPipeLongPosition();
45  fDecayPipeLongPosition->SetDefaultValue (value);
46  fDecayPipeLongPosition->SetDefaultUnit ("m");
47  fDecayPipeLongPosition->SetUnitCandidates ("m");
48  fDecayPipeLongPosition->AvailableForStates(G4State_PreInit);
49  }
50  {
51  fDecayPipeRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/decayPipeRadius",this);
52  fDecayPipeRadius->SetGuidance("Radius of the decay Pipe");
53  fDecayPipeRadius->SetParameterName("decayPipeRadius",true);
54  double value = volP->GetDecayPipeRadius();
55  fDecayPipeRadius->SetDefaultValue (value);
56  fDecayPipeRadius->SetDefaultUnit ("m");
57  fDecayPipeRadius->SetUnitCandidates ("cm m");
58  fDecayPipeRadius->AvailableForStates(G4State_PreInit);
59  }
60  {
61  fDecayPipeUpstreamWindowThickness = new G4UIcmdWithADoubleAndUnit("/LBNE/det/decayPipeUsptreamWindowThickness",this);
62  fDecayPipeUpstreamWindowThickness->SetGuidance("Thickness of the upstream window of the decay pipe.");
63  fDecayPipeUpstreamWindowThickness->SetParameterName("decayPipeUpstreamWindowThickness",true);
64  double value = volP->GetDecayPipeUpstrWindowThick();
65  fDecayPipeUpstreamWindowThickness->SetDefaultValue (value);
66  fDecayPipeUpstreamWindowThickness->SetDefaultUnit ("mm");
67  fDecayPipeUpstreamWindowThickness->SetUnitCandidates ("cm");
68  fDecayPipeUpstreamWindowThickness->AvailableForStates(G4State_PreInit);
69  }
70  {
71  fDecayPipeGas = new G4UIcmdWithAString("/LBNE/det/decayPipeGas",this);
72  fDecayPipeGas->SetGuidance("Gas inside of the decay Pipe. Only two options so far, Air or Helium ");
73  fDecayPipeGas->SetParameterName("decayPipeGas",true);
74  fDecayPipeGas->SetDefaultValue (G4String("Helium"));
75  fDecayPipeGas->AvailableForStates(G4State_PreInit);
76  }
77 
78  fWaterLayerThickInHorn = new G4UIcmdWithADoubleAndUnit("/LBNE/det/waterThickInHorn",this);
79  fWaterLayerThickInHorn->SetGuidance("Water Thicknes on the inner conductor of the horn");
80  fWaterLayerThickInHorn->SetParameterName("waterThickInHorn",true);
81  fWaterLayerThickInHorn->SetDefaultValue (0.);
82  fWaterLayerThickInHorn->SetDefaultUnit ("mm");
83  fWaterLayerThickInHorn->SetUnitCandidates ("mm cm m");
84  fWaterLayerThickInHorn->AvailableForStates(G4State_PreInit);
85  {
86  fHorn1Length = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn1Length",this);
87  G4String guidance("Length of Horn1.\n ");
88  guidance += std::string(" The length of the outer conductor, excludes the upstream transition inner/outer, \n");
89  guidance += std::string(" and flanges with bolts. If extended by user, it is assumed that conductor are extended.. " );
90  guidance += std::string(" NUMI Horn1, FNAL Drawing number 8875. 112-ME-363092 " );
91  guidance += std::string(" Obsolete data card, use /LBNE/det/Horn1LongRescale instead ");
92  fHorn1Length->SetGuidance(guidance);
93  fHorn1Length->SetParameterName("Horn1Length",true);
94  double value = volP->GetHorn1Length(); //
95 
96  SetMyUnitsAndConditions(fHorn1Length, value);
97  }
98  {
99  fHorn1InnerCondMat = new G4UIcmdWithAString("/LBNE/det/Horn1InnerConductorMaterial", this);
100  G4String guidance("Material for the inner conductor \n ");
101  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
102  guidance += std::string(" for studying the relevance of the material budget. \n " );
103  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
104  fHorn1InnerCondMat->SetGuidance(guidance);
105  fHorn1InnerCondMat->SetParameterName("Horn1InnerCondMaterial",true);
106  G4String value = volP->GetHorn1InnerConductorMaterial(); //
107  fHorn1InnerCondMat->SetDefaultValue(value);
108  }
109  {
110  fHorn1AllCondMat = new G4UIcmdWithAString("/LBNE/det/Horn1AllConductorMaterial", this);
111  G4String guidance("Material for the All conductors in Horn1 (inner and outer) \n ");
112  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
113  guidance += std::string(" for studying the relevance of the material budget. \n " );
114  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
115  fHorn1AllCondMat->SetGuidance(guidance);
116  fHorn1AllCondMat->SetParameterName("Horn1AllCondMaterial",true);
117  G4String value = volP->GetHorn1AllConductorMaterial(); //
118  fHorn1AllCondMat->SetDefaultValue(value);
119  }
120 
121  {
122  fTargetSLengthGraphite = new G4UIcmdWithADoubleAndUnit("/LBNE/det/GraphiteTargetLength", this);
123  G4String guidance("Length of the Graphite Target.\n ");
124  guidance += std::string(" Note: the length of the indiviudal fins are fixed to 2 cm. So, we will re-adjusted \n");
125  guidance += std::string(" abit to get an integer number of fins. For details, see LBNE-Doc-6100 " );
126  fTargetSLengthGraphite->SetGuidance(guidance);
127  fTargetSLengthGraphite->SetParameterName("GraphiteTargetLength",true);
128  double value = volP->GetTargetSLengthGraphite(); //
129  SetMyUnitsAndConditions(fTargetSLengthGraphite, value);
130  }
131  {
132  fTargetFinWidth = new G4UIcmdWithADoubleAndUnit("/LBNE/det/GraphiteTargetFinWidth", this);
133  G4String guidance("Width of the Graphite Target Fins.\n ");
134  guidance += std::string(" For details, see LBNE-Doc-6100 " );
135  fTargetFinWidth->SetGuidance(guidance);
136  fTargetFinWidth->SetParameterName("GraphiteTargetFinWidth",true);
137  double value = volP->GetTargetFinWidth(); //
138  SetMyUnitsAndConditions(fTargetFinWidth, value);
139  }
140  {
141  fTargetNumFinsWithWings = new G4UIcmdWithAnInteger("/LBNF/det/GraphiteTargetNumWings", this);
142  G4String guidance("Number of upstream fins with wings.\n ");
143  guidance += std::string(" For details, see talk with Jim H., Alberto M., Nikolai M. etc... " );
144  fTargetNumFinsWithWings->SetGuidance(guidance);
145  fTargetNumFinsWithWings->SetParameterName("GraphiteTargetNumWings",true);
146  int value = static_cast<unsigned int>(volP->GetTargetNumFinsWithWings()); //
147  fTargetNumFinsWithWings->SetDefaultValue (value);
148  fTargetNumFinsWithWings->AvailableForStates(G4State_PreInit);
149  }
150  {
151  fTargetMaterial = new G4UIcmdWithAString("/LBNE/det/TargetMaterial", this);
152  G4String guidance("Material for the target \n ");
153  guidance += std::string(" Note: Only Beryllium, Graphite and Aluminum accepted for now.. \n");
154  guidance += std::string(" The physical length of the target is left unchanged upon use of this data card. \n " );
155  guidance += std::string(" Default value: graphite \n " );
156  fTargetMaterial->SetGuidance(guidance);
157  fTargetMaterial->SetParameterName("TargetMaterial",true);
158  G4String value = volP->GetTargetMaterialName(); //
159  fTargetMaterial->SetDefaultValue(value);
160  }
161 
162  {
163  fPlugMaterial = new G4UIcmdWithAString("/LBNE/det/PlugMaterial", this);
164  G4String guidance("Material for the 2n target or plug \n ");
165  guidance += std::string(
166  " Note: If not usual materials (Beryllium, graphite.., please check that the material is defined in LBNEDetectorContruction \n");
167  guidance += std::string(" The physical length of the this target is left unchanged upon use of this data card. \n " );
168  guidance += std::string(" Default value: graphite \n " );
169  fPlugMaterial->SetGuidance(guidance);
170  fPlugMaterial->SetParameterName("PlugMaterial",true);
171  G4String value = volP->GetPlugMaterial(); //
172  fPlugMaterial->SetDefaultValue(value);
173  }
174  {
175  fTargetDensity = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetDensity", this);
176  G4String guidance("Density of the target. Only relevant for the graphite target. \n ");
177  fTargetDensity->SetGuidance(guidance);
178  fTargetDensity->SetParameterName("TargetDensity",true);
179  double value = volP->GetTargetDensity(); //
180  fTargetDensity->SetDefaultValue (value);
181  fTargetDensity->SetDefaultUnit ("g/cm3");
182  fTargetDensity->SetUnitCandidates ("g/cm3");
183  fTargetDensity->AvailableForStates(G4State_PreInit);
184  }
185  {
186  fTargetLengthIntoHorn = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetLengthIntoHorn", this);
187  G4String guidance("Length of the Graphite Target into the horn.\n ");
188  guidance += std::string(" More specifically, the length of graphite from MCZERO to the dowstream tip of graphite. \n");
189  guidance += std::string(" FNAL Drawing number 8875. 112-ME-363092 " );
190  guidance += std::string(" !!! Judged too confusing, discontinued command !!!! " );
191  fTargetLengthIntoHorn->SetGuidance(guidance);
192  fTargetLengthIntoHorn->SetParameterName("TargetLengthIntoHorn",true);
193  double value = volP->GetTargetLengthIntoHorn(); //
194  SetMyUnitsAndConditions(fTargetLengthIntoHorn, value);
195  }
196  {
197  fTargetLengthOutsideHorn = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetLengthOutsideHorn", this);
198  G4String guidance("Length of the Graphite Target outside the horn.\n ");
199  guidance += std::string(" More specifically, the length of graphite from the most upstream point on \n ");
200  guidance += std::string(" the 1rst vertical fin to MCZERO. \n");
201  guidance += std::string(" FNAL Drawing number 8875. 112-ME-363092 " );
202  fTargetLengthOutsideHorn->SetGuidance(guidance);
203  fTargetLengthOutsideHorn->SetParameterName("TargetLengthOutsideHorn",true);
204  double value = volP->GetTargetLengthIntoHorn(); //
205  double valueL = volP->GetTargetSLengthGraphite(); //
206  SetMyUnitsAndConditions(fTargetLengthOutsideHorn, valueL - value);
207  }
208  {
209  fSimpleTargetRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/SimpleTargetRadius", this);
210  G4String guidance("Radius of the simple target.\n ");
211  guidance += std::string(" Should the option UseSimpleCylindicalTarget be selected, \n ");
212  guidance += std::string(" this command sets the radius of the target. \n");
213  guidance += std::string(" No FNAL Drawing number referenced " );
214  fSimpleTargetRadius->SetGuidance(guidance);
215  fSimpleTargetRadius->SetParameterName("SimpleTargetRadius",true);
216  double value = volP->GetSimpleTargetRadius(); //
217  SetMyUnitsAndConditions(fSimpleTargetRadius, value);
218  }
219  {
220  fSimpleTargetLength = new G4UIcmdWithADoubleAndUnit("/LBNE/det/SimpleTargetLength", this);
221  G4String guidance("Length of the simple target.\n ");
222  guidance += std::string(" Should the option UseSimpleCylindicalTarget (or UseSimpleBoxTarget be selected, \n ");
223  guidance += std::string(" this command sets the length of the target. \n");
224  guidance += std::string(" No FNAL Drawing number referenced " );
225  fSimpleTargetLength->SetGuidance(guidance);
226  fSimpleTargetLength->SetParameterName("SimpleTargetLength",true);
227  double value = volP->GetSimpleTargetLength(); //
228  SetMyUnitsAndConditions(fSimpleTargetLength, value);
229  }
230 // August 2014, Quynh added new cards for multi sphere:
231  {
232  fMultiSphereTargetRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/MultiSphereTargetRadius", this);
233  G4String guidance("Radius of the multi sphere target.\n ");
234  guidance += std::string(" Should the option MultiSphereTargetRadius be selected, \n ");
235  guidance += std::string(" this command sets the radius of the target. \n");
236  guidance += std::string(" No FNAL Drawing number referenced " );
237  fMultiSphereTargetRadius->SetGuidance(guidance);
238  fMultiSphereTargetRadius->SetParameterName("MultiSphereTargetRadius",true);
239  double value = volP->GetMultiSphereTargetRadius(); //
240  SetMyUnitsAndConditions(fMultiSphereTargetRadius, value);
241  }
242  {
243  fUseMultiSphereTarget = new G4UIcmdWithABool("/LBNE/det/UseMultiSphereTarget", this);
244  G4String guidance("If true, the NUMI-style target is replaced by a simple spherical. \n ");
245  guidance += std::string(" See MultiSphereTargetLength(Height) for setting it's dimensions, \n ");
246  fUseMultiSphereTarget->SetGuidance(guidance);
247  fUseMultiSphereTarget->SetParameterName("UseMultiSphereTarget",true);
248  bool value = volP->GetUseMultiSphereTarget(); //defined in LBNEVolumePlacements.hh
249  fUseMultiSphereTarget->SetDefaultValue(value);
250  }
251  {
252  fSimpleTargetHeight = new G4UIcmdWithADoubleAndUnit("/LBNE/det/SimpleTargetHeight", this);
253  G4String guidance("Height of the simple box-like target.\n ");
254  guidance += std::string(" Should the option UseSimpleBoxTarget be selected, \n ");
255  guidance += std::string(" this command sets the height of the target. \n");
256  guidance += std::string(" No FNAL Drawing number referenced " );
257  fSimpleTargetHeight->SetGuidance(guidance);
258  fSimpleTargetHeight->SetParameterName("SimpleTargetHeight",true);
259  double value = volP->GetSimpleTargetHeight(); //
260  SetMyUnitsAndConditions(fSimpleTargetHeight, value);
261  }
262  {
263  fSimpleTargetWidth = new G4UIcmdWithADoubleAndUnit("/LBNE/det/SimpleTargetWidth", this);
264  G4String guidance("Width of the simple box-like target.\n ");
265  guidance += std::string(" Should the option UseSimpleBoxTarget be selected, \n ");
266  guidance += std::string(" this command sets the height of the target. \n");
267  guidance += std::string(" No FNAL Drawing number referenced " );
268  fSimpleTargetWidth->SetGuidance(guidance);
269  fSimpleTargetWidth->SetParameterName("SimpleTargetWidth",true);
270  double value = volP->GetSimpleTargetWidth(); //
271  SetMyUnitsAndConditions(fSimpleTargetWidth, value);
272  }
273  {
274  fUseSimpleTargetBox = new G4UIcmdWithABool("/LBNE/det/UseSimpleBoxTarget", this);
275  G4String guidance("If true, the NUMI-style target is replaced by a simple box. \n ");
276  guidance += std::string(" See SimpleTargetLengthWidth (Height) for setting it's dimensions, \n ");
277  fUseSimpleTargetBox->SetGuidance(guidance);
278  fUseSimpleTargetBox->SetParameterName("UseSimpleBoxTarget",true);
279  bool value = volP->GetUseSimpleTargetBox(); //
280  fUseSimpleTargetBox->SetDefaultValue(value);
281  }
282  {
283  fRemoveTargetAlltogether = new G4UIcmdWithABool("/LBNE/det/RemoveTarget", this);
284  G4String guidance("If true, the NUMI-style target is simply gone. \n ");
285  guidance += std::string(" You got 3 pulses of beam to do your experiment, \n");
286  guidance += std::string(" after which you'll have to rebuild the Hadron dump. \n ");
287  fRemoveTargetAlltogether->SetGuidance(guidance);
288  fRemoveTargetAlltogether->SetParameterName("RemoveTarget",true);
289  fRemoveTargetAlltogether->SetDefaultValue(false);
290  }
291  {
292  fConstructPlug = new G4UIcmdWithABool("/LBNE/det/ConstructPlug", this);
293  G4String guidance("If true, a plug (or second target) will be placed either in horn 1, or in horn2, (Optimized design) ");
294  fConstructPlug->SetGuidance(guidance);
295  fConstructPlug->SetParameterName("ConstructPlug",true);
296  bool value = volP->GetConstructPlug(); //
297  fConstructPlug->SetDefaultValue(value);
298  }
299  {
300  fConstructPlugInHorn1 = new G4UIcmdWithABool("/LBNE/det/ConstructPlugInHorn1", this);
301  G4String guidance("If true, a graphite plug will be placed in the beamline downstream of the neck of Horn1, in Horn1.");
302  fConstructPlugInHorn1->SetGuidance(guidance);
303  fConstructPlugInHorn1->SetParameterName("ConstructPlugInHorn1",true);
304  bool value = volP->GetConstructPlugInHorn1(); //
305  fConstructPlugInHorn1->SetDefaultValue(value);
306  }
307  {
308  fPlugLength = new G4UIcmdWithADoubleAndUnit("/LBNE/det/PlugLength", this);
309 
310  G4String guidance("Length of the beam plug.\n ");
311  guidance += std::string(" Should the option ConstructPlug be selected, \n ");
312  fPlugLength->SetGuidance(guidance);
313  fPlugLength->SetParameterName("PlugLength",true);
314  double value = volP->GetPlugLength(); //
315  SetMyUnitsAndConditions(fPlugLength, value);
316  fPlugLength->SetDefaultUnit ("cm");
317  fPlugLength->SetUnitCandidates ("cm m");
318  fPlugLength->AvailableForStates(G4State_PreInit);
319  }
320  {
321  fPlugOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/PlugOuterRadius", this);
322  G4String guidance("Outer radius of the beam plug.\n ");
323  guidance += std::string(" Should the option ConstructPlug be selected, \n");
324  guidance += std::string(" this command sets the outer radius of the plug.\n");
325  guidance += std::string(" It needs to be smaller than the hole in horn2, or Horn1 ");
326  fPlugOuterRadius->SetGuidance(guidance);
327  fPlugOuterRadius->SetParameterName("PlugOuterRadius",true);
328  double value = volP->GetPlugOuterRadius(); //
329  SetMyUnitsAndConditions(fPlugOuterRadius, value);
330  fPlugOuterRadius->SetDefaultUnit ("cm");
331  fPlugOuterRadius->SetUnitCandidates ("cm m");
332  fPlugOuterRadius->AvailableForStates(G4State_PreInit);
333  }
334  {
335  fPlugInnerRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/PlugInnerRadius", this);
336  G4String guidance("Inner radius of the beam plug.\n ");
337  guidance += std::string(" Should the option ConstructPlug be selected, \n");
338  guidance += std::string(" this command sets the inner radius of the plug. \n");
339  guidance += std::string(" In general a solid plus should have this set to zero, the default " );
340  fPlugInnerRadius->SetGuidance(guidance);
341  fPlugInnerRadius->SetParameterName("PlugInnerRadius",true);
342  double value = volP->GetPlugInnerRadius(); //
343  SetMyUnitsAndConditions(fPlugInnerRadius, value);
344  fPlugInnerRadius->SetDefaultUnit ("cm");
345  fPlugInnerRadius->SetUnitCandidates ("cm m");
346  fPlugInnerRadius->AvailableForStates(G4State_PreInit);
347  }
348  {
349  fPlugZPosition = new G4UIcmdWithADoubleAndUnit("/LBNE/det/PlugZPosition", this);
350  G4String guidance("The Z position of the beam plug.\n ");
351  guidance += std::string(" Should the option ConstructPlug be selected, \n");
352  guidance += std::string(" this is the shift upstream relative to the downstream end of horn2, or Horn1 if In Horn1 \n");
353  fPlugZPosition->SetGuidance(guidance);
354  fPlugZPosition->SetParameterName("PlugZPosition",true);
355  double value = volP->GetPlugZPosition(); //
356  SetMyUnitsAndConditions(fPlugZPosition, value);
357  fPlugZPosition->SetDefaultUnit ("cm");
358  fPlugZPosition->SetUnitCandidates ("cm m");
359  fPlugZPosition->AvailableForStates(G4State_PreInit);
360  }
361 
362  {
363  fUseSimpleTargetCylinder = new G4UIcmdWithABool("/LBNE/det/UseSimpleCylindricalTarget", this);
364  G4String guidance("If true, the NUMI-style target is replaced by a simple cylinder. \n ");
365  guidance += std::string(" See SimpleTargetLengthWidth (Height) for setting it's dimensions, \n ");
366  fUseSimpleTargetCylinder->SetGuidance(guidance);
367  fUseSimpleTargetCylinder->SetParameterName("UseSimpleCylindricalTarget",true);
368  bool value = volP->GetUseSimpleTargetBox(); //
369  fUseSimpleTargetCylinder->SetDefaultValue(value);
370  }
371 
372  {
373  fTargetBerylCapThickness = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetBerylliumCapThickness", this);
374  G4String guidance("Thickness of the Beryllium cap, downstream end of the target Helium containment vessel .\n ");
375  guidance += std::string(" Use to study the relevance of adding/removing material in the target \n");
376  fTargetBerylCapThickness->SetGuidance(guidance);
377  fTargetBerylCapThickness->SetParameterName("TargetBerylliumCapThickness",true);
378  double value = volP->GetTargetBerylDownstrWindowThick(); //
379  SetMyUnitsAndConditions(fTargetBerylCapThickness, value);
380  }
381 
382 
383  {
384  fHorn1RadialRescale = new G4UIcmdWithADouble("/LBNE/det/Horn1RadialRescale", this);
385  G4String guidance("A ratio between the actual radii for this run over the nominal values for Horn1 \n ");
386  guidance += std::string(" More specifically, all (excluding target elements in Horn1) will be rescale by \n");
387  guidance += std::string(" that factor. Suggested value for modification: no more than 105 for a start!.. \n");
388  guidance += std::string(" FNAL Drawing number 8875. 112-ME-363096, 363097,... " );
389  fHorn1RadialRescale->SetGuidance(guidance);
390  fHorn1RadialRescale->SetParameterName("Horn1RadialRescale",true);
391  fHorn1RadialRescale->SetDefaultValue(1.0);
392  }
393  {
394  fHorn1LongRescale = new G4UIcmdWithADouble("/LBNE/det/Horn1LongRescale", this);
395  G4String guidance("A ratio between the actual lengths for this run over the nominal values for Horn1 \n ");
396  guidance += std::string(" FNAL Drawing number 8875. 112-ME-363096, 363097,... " );
397  guidance += std::string(" More specifically, all (excluding target elements in Horn1) will be rescale by \n");
398  guidance += std::string(" that factor. Suggested value for modification: no more than a few % change for start!.. \n");
399  fHorn1LongRescale->SetGuidance(guidance);
400  fHorn1LongRescale->SetParameterName("Horn1LongRescale",true);
401  fHorn1LongRescale->SetDefaultValue(1.0);
402  }
403  {
404  fHorn1RadialSafetyMargin = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetAndHorn1RadialSafety", this);
405  G4String guidance(" A back door command to re-adjust the tolerance on the minimum distance \n ");
406  guidance += std::string(" between the tip of the Target Helium tube and the Horn 1 inner conductor. " );
407  guidance += std::string(" To be used exclusively for target misalignment studies. \n");
408  fHorn1RadialSafetyMargin->SetGuidance(guidance);
409  fHorn1RadialSafetyMargin->SetParameterName("TargetAndHorn1RadialSafety",true);
410  const double valDef = volP->GetHorn1RadialSafetyMargin();
411  SetMyUnitsAndConditions(fHorn1RadialSafetyMargin, valDef);
412  }
413  {
414  fHorn1RadiusBigEnough = new G4UIcmdWithABool("/LBNE/det/TargetAndHorn1RadiusBigEnough", this);
415  G4String guidance(" A back door command to re-adjust the inner conductor radius \n ");
416  guidance += std::string(" uspstream of the neck such that the 1 m. long target can be completly inserted . " );
417  guidance += std::string(" in Horn1, to maximize the neutrino flux. \n");
418  guidance += std::string(" The neck is left unchanged, so there is abrupt and unphysical change of ");
419  guidance += std::string(" of the radius entering the neck. ");
420  fHorn1RadiusBigEnough->SetGuidance(guidance);
421  fHorn1RadiusBigEnough->SetParameterName("TargetAndHorn1RadiusBigEnough",true);
422  const bool valDef = volP->IsHorn1RadiusBigEnough();
423  fHorn1RadiusBigEnough->SetDefaultValue(valDef);
424  }
425  {
426  fHorn2RadialRescale = new G4UIcmdWithADouble("/LBNE/det/Horn2RadialRescale", this);
427  G4String guidance("A ratio between the actual radii for this run over the nominal values for Horn2 \n ");
428  guidance += std::string(" More specifically, all (excluding target elements in Horn2) will be rescale by \n");
429  guidance += std::string(" that factor. Suggested value for modification: no more than 105 for a start!.. \n");
430  guidance += std::string(" FNAL Drawing number 8875.112 MD-363383 " );
431  fHorn2RadialRescale->SetGuidance(guidance);
432  fHorn2RadialRescale->SetParameterName("Horn2RadialRescale",true);
433  fHorn2RadialRescale->SetDefaultValue(1.0);
434  }
435  {
436  fHorn2RadialRescaleCst = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn2RadialRescaleCst", this);
437  G4String guidance("The new radial coordinates will now be = radialRescale*r_old + RadialRescaleCst \n ");
438  guidance += std::string(" More specifically, all (excluding target elements in Horn2) will be rescale by \n");
439  guidance += std::string(" that linear function. \n");
440  guidance += std::string(" Note: For this parameter to be effective, you must invoke Horn2RadialRescale \n");
441  guidance += std::string(" FNAL Drawing number 8875.112 MD-363383 " );
442  fHorn2RadialRescaleCst->SetGuidance(guidance);
443  fHorn2RadialRescaleCst->SetParameterName("Horn2RadialRescaleCst",true);
444  fHorn2RadialRescaleCst->SetDefaultUnit ("mm");
445  fHorn2RadialRescaleCst->SetUnitCandidates ("cm mm m");
446  fHorn2RadialRescaleCst->SetDefaultValue(0.0); // Identity relation, by default.
447  }
448  {
449  fHorn2LongRescale = new G4UIcmdWithADouble("/LBNE/det/Horn2LongRescale", this);
450  G4String guidance("A ratio between the actual lengths for this run over the nominal values for Horn2 \n ");
451  guidance += std::string(" More specifically, all (excluding target elements in Horn2) will be rescale by \n");
452  guidance += std::string(" that factor. Suggested value for modification: no more than 105 for a start!.. \n");
453  guidance += std::string(" FNAL Drawing number 8875.112 MD-363383 " );
454  fHorn2LongRescale->SetGuidance(guidance);
455  fHorn2LongRescale->SetParameterName("Horn2LongRescale",true);
456  fHorn2LongRescale->SetDefaultValue(1.0);
457  }
458  {
459  fHorn2LongPosition = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn2LongPosition", this);
460  G4String guidance("The Z position of Horn2 with respect to the entrance of Horn1 (a.k.a MCZero) \n ");
461  fHorn2LongPosition->SetGuidance(guidance);
462  fHorn2LongPosition->SetParameterName("Horn2LongPosition",true);
463  double value = volP->GetHorn2LongPosition(); //
464 
465  SetMyUnitsAndConditions(fHorn2LongPosition, value);
466  }
467  {
468  fHorn2InnerCondMat = new G4UIcmdWithAString("/LBNE/det/Horn2InnerConductorMaterial", this);
469  G4String guidance("Material for the inner conductor \n ");
470  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
471  guidance += std::string(" for studying the relevance of the material budget. \n " );
472  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
473  fHorn2InnerCondMat->SetGuidance(guidance);
474  fHorn2InnerCondMat->SetParameterName("Horn2InnerCondMaterial",true);
475  G4String value = volP->GetHorn2InnerConductorMaterial(); //
476  fHorn2InnerCondMat->SetDefaultValue(value);
477  }
478  {
479  fHorn2AllCondMat = new G4UIcmdWithAString("/LBNE/det/Horn2AllConductorMaterial", this);
480  G4String guidance("Material for all conductors, inner, outer, I/O transition, etc.. \n ");
481  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
482  guidance += std::string(" for studying the relevance of the material budget. \n " );
483  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
484  fHorn2AllCondMat->SetGuidance(guidance);
485  fHorn2AllCondMat->SetParameterName("Horn2AllCondMaterial",true);
486  G4String value = volP->GetHorn2AllConductorMaterial(); //
487  fHorn2AllCondMat->SetDefaultValue(value);
488  }
489  {
490  fHorn3InnerCondMat = new G4UIcmdWithAString("/LBNE/det/Horn3InnerConductorMaterial", this);
491  G4String guidance("Material for the inner conductor \n ");
492  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
493  guidance += std::string(" for studying the relevance of the material budget. \n " );
494  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
495  fHorn3InnerCondMat->SetGuidance(guidance);
496  fHorn3InnerCondMat->SetParameterName("Horn3InnerCondMaterial",true);
497  G4String value = volP->GetHorn2InnerConductorMaterial(); //
498  fHorn3InnerCondMat->SetDefaultValue(value);
499  }
500  {
501  fHorn3AllCondMat = new G4UIcmdWithAString("/LBNE/det/Horn3AllConductorMaterial", this);
502  G4String guidance("Material for all conductors, inner, outer, I/O transition, etc.. \n ");
503  guidance += std::string(" Aluminum is the base line and default. This option should only be used \n");
504  guidance += std::string(" for studying the relevance of the material budget. \n " );
505  guidance += std::string(" That is, run with a fictious Horn with air or vacuum as material carrying 200kA \n " );
506  fHorn3AllCondMat->SetGuidance(guidance);
507  fHorn3AllCondMat->SetParameterName("Horn3AllCondMaterial",true);
508  G4String value = volP->GetHorn3AllConductorMaterial(); //
509  fHorn3AllCondMat->SetDefaultValue(value);
510  }
511 
512  {
513  fUseMarsTargetHorns = new G4UIcmdWithABool("/LBNE/det/UseMarsTargetHorns", this);
514  G4String guidance("If true (default is false) use GDML geometry exported from MARS rather than standard G4LBNE target/horns \n ");
515  fUseMarsTargetHorns->SetGuidance(guidance);
516  fUseMarsTargetHorns->SetParameterName("UseMarsTargetHorns",true);
517  bool value = volP->GetUseMarsTargetHorns(); //
518  fUseMarsTargetHorns->SetDefaultValue(value);
519  }
520 
521  {
522  fMarsTargetHornsGDMLFilename = new G4UIcmdWithAString("/LBNE/det/GDMLMarsTargetHornsFilename", this);
523  G4String guidance("File name generated by MARS/ROOT describing the target/horns. \n ");
524  guidance += std::string(" Path name can be relative, if the executable runs from the correct directory \n");
525  guidance += std::string(" Typically .../g4lbne \n " );
526  guidance += std::string(" Or, absolute i.e, /scratch/.../g4blne/gdml/lbne_absorber_112912.gdml \n " );
527  guidance += std::string(" The translation of an (eventual) Unix environment variable is currently not implemented \n " );
528  fMarsTargetHornsGDMLFilename->SetGuidance(guidance);
529  fMarsTargetHornsGDMLFilename->SetParameterName("GDMLMarsTargetHornsFilename",true);
530  G4String value = volP->GetMarsTargetHornsGDMLFilename(); //
531  fMarsTargetHornsGDMLFilename->SetDefaultValue(value);
532  }
533 
534  {
535  fAbsorberGDMLFilename = new G4UIcmdWithAString("/LBNE/det/GDMLAbsorberFilename", this);
536  G4String guidance("File name generated by MARS/ROOT describing the Hadron absorber at the end of the beam line. \n ");
537  guidance += std::string(" Path name can be relative, if the executable runs from the correct directory \n");
538  guidance += std::string(" Typically .../g4lbne \n " );
539  guidance += std::string(" Or, absolute i.e, /scratch/.../g4blne/gdml/lbne_absorber_112912.gdml \n " );
540  guidance += std::string(" The translation of an (eventual) Unix environment variable is currently not implement \n " );
541  fAbsorberGDMLFilename->SetGuidance(guidance);
542  fAbsorberGDMLFilename->SetParameterName("GDMLAbsorberFilename",true);
543  G4String value = volP->GetAbsorberGDMLFilename(); //
544  fAbsorberGDMLFilename->SetDefaultValue(value);
545  }
546  {
547  fInstallShield = new G4UIcmdWithABool("/LBNE/det/InstallShield", this);
548  G4String guidance("If true (default) install beamline rotated rectangular chunck of steel surrounding the horns \n ");
549  fInstallShield->SetGuidance(guidance);
550  fInstallShield->SetParameterName("InstallShieldAroundHorns",true);
551  bool value = volP->GetDoInstallShield(); //
552  fInstallShield->SetDefaultValue(value);
553  }
554  {
555  fLengthOfRockDownstr = new G4UIcmdWithADoubleAndUnit("/LBNE/det/LengthOfRockDownstr", this);
556  G4String guidance(" The length of rock downstream of the muon alcove. \n ");
557  fLengthOfRockDownstr->SetGuidance(guidance);
558  fLengthOfRockDownstr->SetParameterName("LengthOfRockDownstr",true);
559  const double valDef = volP->GetLengthOfRockDownstreamAlcove();
560  SetMyUnitsAndConditions(fLengthOfRockDownstr, valDef);
561  }
562  //
563  // 1.2 MW option We keep the above data card as define above, but will have a "modal" flag when we work with the 1.2 MW option.
564  //
565  {
566  fUse1p2MW = new G4UIcmdWithABool("/LBNE/det/Use1p2MW", this);
567  G4String guidance("If true, the NUMI-style target will be adapted for 1.2 MW operation, prelimnary design. \n ");
568  guidance += std::string(" See DocDB note 8639-v1 by J. Hylen \n ");
569  fUse1p2MW->SetGuidance(guidance);
570  fUse1p2MW->SetParameterName("Use1p2MW",true);
571  bool value = volP->GetUse1p2MW(); //
572  fUse1p2MW->SetDefaultValue(value);
573  }
574  {
575  fUse1p2MWSmallTgt = new G4UIcmdWithABool("/LBNE/det/Use1p2MWSmallTgt", this);
576  G4String guidance("If true, the NUMI-style target will be adapted for 1.2 MW operation, prelimnary design. \n ");
577  guidance += std::string(" \n ");
578  fUse1p2MWSmallTgt->SetGuidance(guidance);
579  fUse1p2MWSmallTgt->SetParameterName("Use1p2MWSmallTgT",true);
580  fUse1p2MWSmallTgt->SetDefaultValue(false);
581  }
582 
583  {
584  fUseRALTGTv1 = new G4UIcmdWithABool("/LBNE/det/UseRALTGTv1", this);
585  G4String guidance("If true, the Rutherford accelerator lab target will be adapted for 1.2 MW operation, preliminary design. \n ");
586  guidance += std::string(" \n ");
587  fUseRALTGTv1->SetGuidance(guidance);
588  fUseRALTGTv1->SetParameterName("UseRALTGTv1",true);
589  fUseRALTGTv1->SetDefaultValue(false);
590  }
591 
592  {
593  fUseRoundedTargetFins = new G4UIcmdWithABool("/LBNE/det/UseRoundedTargetFins", this);
594  G4String guidance("If true, the vertical fins will rounded. Only implemented for 1.2 MW option. Default is true. \n ");
595  guidance += std::string(" See IHEP target documentation, serial number 3, received on March 26 from J. Hylen \n ");
596  fUseRoundedTargetFins->SetGuidance(guidance);
597  fUseRoundedTargetFins->SetParameterName("UseRoundedTargetFins",true);
598  bool value = volP->GetUseRoundedTargetFins(); //
599  fUseRoundedTargetFins->SetDefaultValue(value);
600  }
601  //
602  // September 2014: adding the arbitrary shaped Horn1 (G4Polycone type )
603  //
604  {
605  fUseHorn1Polycone = new G4UIcmdWithABool("/LBNE/det/UseHorn1Polycone", this);
606  G4String guidance("If true, Horn1 Inner conductor is a simple Polycone. See documentation on the g4lbne wiki for usage. \n ");
607  fUseHorn1Polycone->SetGuidance(guidance);
608  fUseHorn1Polycone->SetParameterName("UseHorn1Polycone",true);
609  bool value = volP->GetUseHorn1Polycone(); //
610  fUseHorn1Polycone->SetDefaultValue(value);
611  }
612  {
613  fUseHorn1PolyNumInnerPts = new G4UIcmdWithAnInteger("/LBNE/det/NumInnerPtsHorn1Polycone", this);
614  G4String guidance("Number of inner points defining the Inner conductor. See documentation on the g4lbne wiki for usage. \n ");
615  fUseHorn1PolyNumInnerPts->SetGuidance(guidance);
616  fUseHorn1PolyNumInnerPts->SetParameterName("NumInnerPtsHorn1Polycone",true);
617  fUseHorn1PolyNumInnerPts->SetDefaultValue(10);
618  }
619  {
620  const size_t numCmdsHorn1PolyPts = 20;
621  fHorn1PolyListRinThickZVects.resize(numCmdsHorn1PolyPts);
622  G4String guidance("Inner Conductor pts, rInner, thicknes,, Zlocation See documentation on the g4lbne wiki for usage. \n ");
623  for (size_t k=0; k !=numCmdsHorn1PolyPts; k++) {
624  std::ostringstream tmpStrStr;
625  tmpStrStr << "/LBNE/det/Horn1PolyPt" << k << "RinThickZ";
626  G4String tmpStr(tmpStrStr.str());
627  fHorn1PolyListRinThickZVects[k] = new G4UIcmdWith3VectorAndUnit(tmpStr.c_str(), this);
628  fHorn1PolyListRinThickZVects[k]->SetGuidance(guidance);
629  fHorn1PolyListRinThickZVects[k]->SetParameterName("Horn1PolyPtxxxRin", "Horn1PolyPtxxxThick", "Horn1PolyPtxxxZCoord", true);
630  fHorn1PolyListRinThickZVects[k]->SetDefaultUnit ("mm");
631  fHorn1PolyListRinThickZVects[k]->SetUnitCandidates ("mm cm m");
632  }
633  }
634  {
635  fHorn1PolyOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn1PolyOuterRadius", this);
636  G4String guidance("Horn1 Polycone Outer Radius conductor. See documentation on the g4lbne wiki for usage. \n ");
637  fHorn1PolyOuterRadius->SetGuidance(guidance);
638  fHorn1PolyOuterRadius->SetParameterName("Horn1PolyOuterRadius", true);
639  bool value = volP->GetHorn1PolyOuterRadius(); //
640  fHorn1PolyOuterRadius->SetDefaultValue(value);
641  fHorn1PolyOuterRadius->SetDefaultUnit ("mm");
642  fHorn1PolyOuterRadius->SetUnitCandidates ("mm cm m");
643  }
644  //
645  // August 2015: We add an arbitrary number of G4PolyCones, up to 5 of them..
646  //
647  {
648  fUseNumberOfHornsPoly = new G4UIcmdWithAnInteger("/LBNE/det/NumberOfHornsPolycone", this);
649  G4String guidance("Number of simplified Horns, type Polycones. See documentation on the g4lbne wiki for usage. \n ");
650  guidance += std::string(".. Also used in defining the number of realistic horns, Conceptual Design, Dec. 2016 \n");
651  fUseNumberOfHornsPoly->SetGuidance(guidance);
652  fUseNumberOfHornsPoly->SetParameterName("NumberOfHornsPolycone",true);
653  fUseNumberOfHornsPoly->SetDefaultValue(0);
654  }
655  //
656  // October/November 2015, John LoSecco, P. L., adding the possibility of parabolic
657  // horns.
658  //
659  {
660  fSetPolyconeHornParabolic = new G4UIcmdWithAnInteger("/LBNE/det/SetPolyconeHornParabolic", this);
661  G4String guidance("Set the Polycone horn's hape to parabolic. Technically, still a G4Polycone shape \n");
662  guidance += std::string(" but, linear segment radial increment of one mm, following a parabola, linear within 1 mm. \n ");
663  guidance += std::string(" Valid Argument, integer, between 1 and 5 \n ");
664  fSetPolyconeHornParabolic->SetGuidance(guidance);
665  fSetPolyconeHornParabolic->SetParameterName("SetPolyconeHornParabolic",true);
666  fSetPolyconeHornParabolic->SetDefaultValue(0);
667 
668  }
669  // Brute force.. Embarrasingly lengthy, horns by horns, 2 to 5, inclusive.
670  // Horn2
671  {
672  fUseHorn2PolyNumInnerPts = new G4UIcmdWithAnInteger("/LBNE/det/NumInnerPtsHorn2Polycone", this);
673  G4String guidance("Number of inner points defining the Inner conductor, for Horn2. \n ");
674  fUseHorn2PolyNumInnerPts->SetGuidance(guidance);
675  fUseHorn2PolyNumInnerPts->SetParameterName("NumInnerPtsHorn2Polycone",true);
676  fUseHorn2PolyNumInnerPts->SetDefaultValue(10);
677  }
678  {
679  const size_t numCmdsHorn2PolyPts = 20;
680  fHorn2PolyListRinThickZVects.resize(numCmdsHorn2PolyPts);
681  G4String guidance("Inner Conductor pts, rInner, thicknes,, for Horn2 \n ");
682  for (size_t k=0; k !=numCmdsHorn2PolyPts; k++) {
683  std::ostringstream tmpStrStr;
684  tmpStrStr << "/LBNE/det/Horn2PolyPt" << k << "RinThickZ";
685  G4String tmpStr(tmpStrStr.str());
686  fHorn2PolyListRinThickZVects[k] = new G4UIcmdWith3VectorAndUnit(tmpStr.c_str(), this);
687  fHorn2PolyListRinThickZVects[k]->SetGuidance(guidance);
688  fHorn2PolyListRinThickZVects[k]->SetParameterName("Horn2PolyPtxxxRin", "Horn2PolyPtxxxThick", "Horn2PolyPtxxxZCoord", true);
689  fHorn2PolyListRinThickZVects[k]->SetDefaultUnit ("mm");
690  fHorn2PolyListRinThickZVects[k]->SetUnitCandidates ("mm cm m");
691  }
692  }
693  {
694  fHorn2PolyOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn2PolyOuterRadius", this);
695  G4String guidance("Horn2 Polycone Outer Radius conductor, for Horn2 \n ");
696  fHorn2PolyOuterRadius->SetGuidance(guidance);
697  fHorn2PolyOuterRadius->SetParameterName("Horn2PolyOuterRadius", true);
698  bool value = 0.; //
699  fHorn2PolyOuterRadius->SetDefaultValue(value);
700  fHorn2PolyOuterRadius->SetDefaultUnit ("mm");
701  fHorn2PolyOuterRadius->SetUnitCandidates ("mm cm m");
702  }
703  {
704  fHorn2PolyZStartPos = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn2PolyZStartPos", this);
705  G4String guidance("Horn2 Polycone Starting Position (Z of the first inner coord, in G4 world syst., for Horn2 \n ");
706  fHorn2PolyZStartPos->SetGuidance(guidance);
707  fHorn2PolyZStartPos->SetParameterName("Horn2PolyZStartPos", true);
708  bool value = -5.0e3*CLHEP::m; //
709  fHorn2PolyZStartPos->SetDefaultValue(value);
710  fHorn2PolyZStartPos->SetDefaultUnit ("mm");
711  fHorn2PolyZStartPos->SetUnitCandidates ("mm cm m");
712  }
713  //
714  // Horn3
715  //
716  {
717  fUseHorn3PolyNumInnerPts = new G4UIcmdWithAnInteger("/LBNE/det/NumInnerPtsHorn3Polycone", this);
718  G4String guidance("Number of inner points defining the Inner conductor, for Horn3. \n ");
719  fUseHorn3PolyNumInnerPts->SetGuidance(guidance);
720  fUseHorn3PolyNumInnerPts->SetParameterName("NumInnerPtsHorn3Polycone",true);
721  fUseHorn3PolyNumInnerPts->SetDefaultValue(10);
722  }
723  {
724  const size_t numCmdsHorn3PolyPts = 20;
725  fHorn3PolyListRinThickZVects.resize(numCmdsHorn3PolyPts);
726  G4String guidance("Inner Conductor pts, rInner, thicknes,, for Horn3 \n ");
727  for (size_t k=0; k !=numCmdsHorn3PolyPts; k++) {
728  std::ostringstream tmpStrStr;
729  tmpStrStr << "/LBNE/det/Horn3PolyPt" << k << "RinThickZ";
730  G4String tmpStr(tmpStrStr.str());
731  fHorn3PolyListRinThickZVects[k] = new G4UIcmdWith3VectorAndUnit(tmpStr.c_str(), this);
732  fHorn3PolyListRinThickZVects[k]->SetGuidance(guidance);
733  fHorn3PolyListRinThickZVects[k]->SetParameterName("Horn3PolyPtxxxRin", "Horn3PolyPtxxxThick", "Horn3PolyPtxxxZCoord", true);
734  fHorn3PolyListRinThickZVects[k]->SetDefaultUnit ("mm");
735  fHorn3PolyListRinThickZVects[k]->SetUnitCandidates ("mm cm m");
736  }
737  }
738  {
739  fHorn3PolyOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn3PolyOuterRadius", this);
740  G4String guidance("Horn3 Polycone Outer Radius conductor, for Horn3 \n ");
741  fHorn3PolyOuterRadius->SetGuidance(guidance);
742  fHorn3PolyOuterRadius->SetParameterName("Horn3PolyOuterRadius", true);
743  fHorn3PolyOuterRadius->SetDefaultValue(75.0*CLHEP::cm);
744  fHorn3PolyOuterRadius->SetDefaultUnit ("mm");
745  fHorn3PolyOuterRadius->SetUnitCandidates ("mm cm m");
746  }
747  {
748  fHorn3PolyZStartPos = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn3PolyZStartPos", this);
749  G4String guidance("Horn3 Polycone Starting Position (Z of the first inner coord, in G4 world syst., for Horn3 \n ");
750  fHorn3PolyZStartPos->SetGuidance(guidance);
751  fHorn3PolyZStartPos->SetParameterName("Horn3PolyZStartPos", true);
752  bool value = -5.0e3*CLHEP::m; //
753  fHorn3PolyZStartPos->SetDefaultValue(value);
754  fHorn3PolyZStartPos->SetDefaultUnit ("mm");
755  fHorn3PolyZStartPos->SetUnitCandidates ("mm cm m");
756  }
757  //
758  // Horn4
759  //
760  {
761  fUseHorn4PolyNumInnerPts = new G4UIcmdWithAnInteger("/LBNE/det/NumInnerPtsHorn4Polycone", this);
762  G4String guidance("Number of inner points defining the Inner conductor, for Horn4. \n ");
763  fUseHorn4PolyNumInnerPts->SetGuidance(guidance);
764  fUseHorn4PolyNumInnerPts->SetParameterName("NumInnerPtsHorn4Polycone",true);
765  fUseHorn4PolyNumInnerPts->SetDefaultValue(10);
766  }
767  {
768  const size_t numCmdsHorn4PolyPts = 20;
769  fHorn4PolyListRinThickZVects.resize(numCmdsHorn4PolyPts);
770  G4String guidance("Inner Conductor pts, rInner, thicknes,, for Horn4 \n ");
771  for (size_t k=0; k !=numCmdsHorn4PolyPts; k++) {
772  std::ostringstream tmpStrStr;
773  tmpStrStr << "/LBNE/det/Horn4PolyPt" << k << "RinThickZ";
774  G4String tmpStr(tmpStrStr.str());
775  fHorn4PolyListRinThickZVects[k] = new G4UIcmdWith3VectorAndUnit(tmpStr.c_str(), this);
776  fHorn4PolyListRinThickZVects[k]->SetGuidance(guidance);
777  fHorn4PolyListRinThickZVects[k]->SetParameterName("Horn4PolyPtxxxRin", "Horn4PolyPtxxxThick", "Horn4PolyPtxxxZCoord", true);
778  fHorn4PolyListRinThickZVects[k]->SetDefaultUnit ("mm");
779  fHorn4PolyListRinThickZVects[k]->SetUnitCandidates ("mm cm m");
780  }
781  }
782  {
783  fHorn4PolyOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn4PolyOuterRadius", this);
784  G4String guidance("Horn4 Polycone Outer Radius conductor, for Horn4 \n ");
785  fHorn4PolyOuterRadius->SetGuidance(guidance);
786  fHorn4PolyOuterRadius->SetParameterName("Horn4PolyOuterRadius", true);
787  fHorn4PolyOuterRadius->SetDefaultValue(75.0*CLHEP::cm);
788  fHorn4PolyOuterRadius->SetDefaultUnit ("mm");
789  fHorn4PolyOuterRadius->SetUnitCandidates ("mm cm m");
790  }
791  {
792  fHorn4PolyZStartPos = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn4PolyZStartPos", this);
793  G4String guidance("Horn4 Polycone Starting Position (Z of the first inner coord, in G4 world syst., for Horn4 \n ");
794  fHorn4PolyZStartPos->SetGuidance(guidance);
795  fHorn4PolyZStartPos->SetParameterName("Horn4PolyZStartPos", true);
796  bool value = -5.0e3*CLHEP::m; //
797  fHorn4PolyZStartPos->SetDefaultValue(value);
798  fHorn4PolyZStartPos->SetDefaultUnit ("mm");
799  fHorn4PolyZStartPos->SetUnitCandidates ("mm cm m");
800  }
801  //
802  // Horn5
803  //
804  {
805  fUseHorn5PolyNumInnerPts = new G4UIcmdWithAnInteger("/LBNE/det/NumInnerPtsHorn5Polycone", this);
806  G4String guidance("Number of inner points defining the Inner conductor, for Horn5. \n ");
807  fUseHorn5PolyNumInnerPts->SetGuidance(guidance);
808  fUseHorn5PolyNumInnerPts->SetParameterName("NumInnerPtsHorn5Polycone",true);
809  fUseHorn5PolyNumInnerPts->SetDefaultValue(10);
810  }
811  {
812  const size_t numCmdsHorn5PolyPts = 20;
813  fHorn5PolyListRinThickZVects.resize(numCmdsHorn5PolyPts);
814  G4String guidance("Inner Conductor pts, rInner, thicknes,, for Horn5 \n ");
815  for (size_t k=0; k !=numCmdsHorn5PolyPts; k++) {
816  std::ostringstream tmpStrStr;
817  tmpStrStr << "/LBNE/det/Horn5PolyPt" << k << "RinThickZ";
818  G4String tmpStr(tmpStrStr.str());
819  fHorn5PolyListRinThickZVects[k] = new G4UIcmdWith3VectorAndUnit(tmpStr.c_str(), this);
820  fHorn5PolyListRinThickZVects[k]->SetGuidance(guidance);
821  fHorn5PolyListRinThickZVects[k]->SetParameterName("Horn5PolyPtxxxRin", "Horn5PolyPtxxxThick", "Horn5PolyPtxxxZCoord", true);
822  fHorn5PolyListRinThickZVects[k]->SetDefaultUnit ("mm");
823  fHorn5PolyListRinThickZVects[k]->SetUnitCandidates ("mm cm m");
824  }
825  }
826  {
827  fHorn5PolyOuterRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn5PolyOuterRadius", this);
828  G4String guidance("Horn5 Polycone Outer Radius conductor, for Horn5 \n ");
829  fHorn5PolyOuterRadius->SetGuidance(guidance);
830  fHorn5PolyOuterRadius->SetParameterName("Horn5PolyOuterRadius", true);
831  fHorn5PolyOuterRadius->SetDefaultValue(75.0*CLHEP::cm);
832  fHorn5PolyOuterRadius->SetDefaultUnit ("mm");
833  fHorn5PolyOuterRadius->SetUnitCandidates ("mm cm m");
834  }
835  {
836  fHorn5PolyZStartPos = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Horn5PolyZStartPos", this);
837  G4String guidance("Horn5 Polycone Starting Position (Z of the first inner coord, in G4 world syst., for Horn5 \n ");
838  fHorn5PolyZStartPos->SetGuidance(guidance);
839  fHorn5PolyZStartPos->SetParameterName("Horn5PolyZStartPos", true);
840  bool value = -5.0e3*CLHEP::m; //
841  fHorn5PolyZStartPos->SetDefaultValue(value);
842  fHorn5PolyZStartPos->SetDefaultUnit ("mm");
843  fHorn5PolyZStartPos->SetUnitCandidates ("mm cm m");
844  }
845 
846 
847  //
848  // October 2014: Adding the option of removing the decay pipe snout to leave more room for extend horns
849  //
850  {
851  fRemoveDecayPipeSnout = new G4UIcmdWithABool("/LBNE/det/RemoveDecayPipeSnout", this);
852  G4String guidance("If true, We will not place the decay pipe snout in fron of the entrance of decay pipe \n ");
853  fRemoveDecayPipeSnout->SetGuidance(guidance);
854  fRemoveDecayPipeSnout->SetParameterName("RemoveDecayPipeSnout",true);
855  bool value = volP->GetRemoveDecayPipeSnout(); //
856  fRemoveDecayPipeSnout->SetDefaultValue(value);
857  }
858  //
859  // March 2015: Adding a wire all the way down the beam pipe.
860  //
861  {
862  fRadiusMilindWire = new G4UIcmdWithADoubleAndUnit("/LBNE/det/MillindWireRadius", this);
863  G4String guidance("Set the radius of the write that runs down the beam pipe. \n ");
864  fRadiusMilindWire->SetGuidance(guidance);
865  fRadiusMilindWire->SetParameterName("MillindWireRadius", true);
866  bool value = volP->GetRadiusMilindWire(); //
867  fRadiusMilindWire->SetDefaultValue(value);
868  fRadiusMilindWire->SetDefaultUnit ("mm");
869  fRadiusMilindWire->SetUnitCandidates ("mm cm");
870  }
871  {
872  fCurrentMilindWire = new G4UIcmdWithADoubleAndUnit("/LBNE/det/MillindWireCurrent", this);
873  G4String guidance("Set the Current of the write that runs down the beam pipe. \n ");
874  fCurrentMilindWire->SetGuidance(guidance);
875  fCurrentMilindWire->SetParameterName("MillindWireCurrent", true);
876  bool value = volP->GetCurrentMilindWire(); //
877  fCurrentMilindWire->SetDefaultValue(value);
878  fCurrentMilindWire->SetDefaultUnit ("A");
879  fCurrentMilindWire->SetUnitCandidates ("A");
880  }
881  // January 2016: Make writing out a gdml file easier:
882  {
883  fWriteGDMLFile = new G4UIcmdWithABool("/LBNE/det/WriteGDMLFile", this);
884  G4String guidance("Write a GDML file containing the entire tunnel geometry \n ");
885  fWriteGDMLFile->SetGuidance(guidance);
886  fWriteGDMLFile->SetParameterName("WriteGDMLFile",true);
887  fWriteGDMLFile->SetDefaultValue(false);
888  }
889 
890 
891  // John Back, March 2016: target module (e.g. SAT) options
892  {
893  fUseTargetModule = new G4UIcmdWithABool("/LBNE/det/UseTargetModule", this);
894  G4String guidance("If true, the NuMI target is replaced by the Target Module\n");
895  fUseTargetModule->SetGuidance(guidance);
896  fUseTargetModule->SetParameterName("UseTargetModule", true);
897  bool value = volP->GetUseTargetModule(); //defined in LBNEVolumePlacements.hh
898  fUseTargetModule->SetDefaultValue(value);
899  }
900  {
901  fUseTarget2Module = new G4UIcmdWithABool("/LBNE/det/UseTarget2Module", this);
902  G4String guidance("If true, the NuMI target is replaced by a 2nd Target Module\n");
903  fUseTarget2Module->SetGuidance(guidance);
904  fUseTarget2Module->SetParameterName("UseTarget2Module", true);
905  bool value = volP->GetUseTarget2Module(); //defined in LBNEVolumePlacements.hh
906  fUseTarget2Module->SetDefaultValue(value);
907  }
908  {
909  fTargetModuleType = new G4UIcmdWithAnInteger("/LBNE/det/TargetModuleType", this);
910  G4String guidance("Set the type for the first target module: SAT = 0, Cylinder = 1\n");
911  fTargetModuleType->SetGuidance(guidance);
912  fTargetModuleType->SetParameterName("TargetModuleType", true);
913  fTargetModuleType->SetDefaultValue(0);
914  }
915  {
916  fTarget2ModuleType = new G4UIcmdWithAnInteger("/LBNE/det/Target2ModuleType", this);
917  G4String guidance("Set the type for the 2nd target module: SAT = 0, Cylinder = 1\n");
918  fTarget2ModuleType->SetGuidance(guidance);
919  fTarget2ModuleType->SetParameterName("Target2ModuleType", true);
920  fTarget2ModuleType->SetDefaultValue(0);
921  }
922  {
923  fTarget2Material = new G4UIcmdWithAString("/LBNE/det/Target2Material", this);
924  G4String guidance("Material for the 2nd target \n ");
925  //guidance += std::string(" Note: Only Beryllium, Graphite and Aluminum accepted for now.. \n");
926  guidance += std::string(" The physical length of the target is left unchanged upon use of this data card. \n " );
927  guidance += std::string(" Default value: graphite \n " );
928  fTarget2Material->SetGuidance(guidance);
929  fTarget2Material->SetParameterName("Target2Material",true);
930  G4String value = volP->GetTargetMaterialName(); //
931  fTarget2Material->SetDefaultValue(value);
932  }
933  {
934  fTargetRadius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetRadius", this);
935  G4String guidance("Target object radius\n ");
936  guidance += std::string(" Should the option TargetRadius be selected (UseTargetModule=true), \n ");
937  guidance += std::string(" this command sets the radius of each target object. \n");
938  guidance += std::string(" No FNAL Drawing number referenced " );
939  fTargetRadius->SetGuidance(guidance);
940  fTargetRadius->SetParameterName("TargetRadius",true);
941  double value = volP->GetTargetRadius(); //
942  SetMyUnitsAndConditions(fTargetRadius, value);
943  }
944  {
945  fTarget2Radius = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Target2Radius", this);
946  G4String guidance("Target 2 object radius\n ");
947  guidance += std::string(" Should the option Target2Radius be selected (UseTarget2Module=true), \n ");
948  guidance += std::string(" this command sets the radius of each target object. \n");
949  guidance += std::string(" No FNAL Drawing number referenced " );
950  fTarget2Radius->SetGuidance(guidance);
951  fTarget2Radius->SetParameterName("Target2Radius",true);
952  double value = volP->GetTarget2Radius(); //
953  SetMyUnitsAndConditions(fTarget2Radius, value);
954  }
955  {
956  fTargetLength = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetLength", this);
957  G4String guidance("The length of the target object\n ");
958  guidance += std::string(" Should the option TargetLength be selected (UseTargetModule=true), \n ");
959  guidance += std::string(" this command sets the length of the target object.\n");
960  guidance += std::string(" No FNAL Drawing number referenced " );
961  fTargetLength->SetGuidance(guidance);
962  fTargetLength->SetParameterName("TargetLength",true);
963  double value = volP->GetTargetLength(); //
964  SetMyUnitsAndConditions(fTargetLength, value);
965  }
966  {
967  fTarget2Length = new G4UIcmdWithADoubleAndUnit("/LBNE/det/Target2Length", this);
968  G4String guidance("The length of the target 2 object\n ");
969  guidance += std::string(" Should the option TargetLength be selected (UseTarget2Module=true), \n ");
970  guidance += std::string(" this command sets the length of the target object.\n");
971  guidance += std::string(" No FNAL Drawing number referenced " );
972  fTarget2Length->SetGuidance(guidance);
973  fTarget2Length->SetParameterName("Target2Length",true);
974  double value = volP->GetTarget2Length(); //
975  SetMyUnitsAndConditions(fTarget2Length, value);
976  }
977  {
978  fTargetNLambda = new G4UIcmdWithADouble("/LBNE/det/TargetNLambda", this);
979  G4String guidance("Specify the target object length using nuclear interaction length lambda\n ");
980  guidance += std::string(" Should the option TargetNLambda be selected (UseTargetModule=true), \n ");
981  guidance += std::string(" this command sets the length of the target object.\n");
982  guidance += std::string(" No FNAL Drawing number referenced " );
983  fTargetNLambda->SetGuidance(guidance);
984  fTargetNLambda->SetParameterName("TargetNLambda",true);
985  double value = volP->GetTargetNLambda();
986  fTargetNLambda->SetDefaultValue(value);
987  }
988  {
989  fTarget2NLambda = new G4UIcmdWithADouble("/LBNE/det/Target2NLambda", this);
990  G4String guidance("Specify the target 2 object length using nuclear interaction length lambda\n ");
991  guidance += std::string(" Should the option Target2NLambda be selected (UseTarget2Module=true), \n ");
992  guidance += std::string(" this command sets the length of the target object.\n");
993  guidance += std::string(" No FNAL Drawing number referenced " );
994  fTarget2NLambda->SetGuidance(guidance);
995  fTarget2NLambda->SetParameterName("Target2NLambda",true);
996  double value = volP->GetTarget2NLambda();
997  fTarget2NLambda->SetDefaultValue(value);
998  }
999  {
1000  fTargetFracOutHornL = new G4UIcmdWithADouble("/LBNE/det/TargetFracOutHornL", this);
1001  G4String guidance("The fractional length of the target outside Horn1 \n ");
1002  guidance += std::string(" Should the option TargetFracOutHornL be selected (UseTargetModule=true) , \n ");
1003  guidance += std::string(" this command will update the length of the target outside Horn1.\n");
1004  guidance += std::string(" No FNAL Drawing number referenced " );
1005  fTargetFracOutHornL->SetGuidance(guidance);
1006  fTargetFracOutHornL->SetParameterName("TargetFracOutHornL",true);
1007  double value = volP->GetTargetFracOutHornL();
1008  fTargetFracOutHornL->SetDefaultValue(value);
1009  }
1010  {
1011  fTargetLengthOutsideExtra = new G4UIcmdWithADoubleAndUnit("/LBNE/det/TargetLengthOutsideExtra", this);
1012  G4String guidance("Set TargetLengthOutsideExtra to align the target if required\n ");
1013  fTargetLengthOutsideExtra->SetGuidance(guidance);
1014  fTargetLengthOutsideExtra->SetParameterName("TargetLengthOutsideExtra",true);
1015  double value = volP->GetTargetLengthOutsideExtra(); //
1016  SetMyUnitsAndConditions(fTargetLengthOutsideExtra, value);
1017  }
1018  //
1019  // June 2016: Implementing LBNF Optimize Conecptual Design horns. Logical flag onlu, all data hardcoded.
1020  // for now.
1021  {
1022  fUseLBNFOptimConceptDesignHornA = new G4UIcmdWithABool("/LBNE/det/LBNFOptimConceptDesignHornA", this);
1023  G4String guidance("If true, we will be using the Horn A LBNF Optimized, Conceptual Design, F.Y. 2016/2017 \n ");
1024  fUseLBNFOptimConceptDesignHornA->SetGuidance(guidance);
1025  fUseLBNFOptimConceptDesignHornA->SetParameterName("LBNFOptimConceptDesignHorn1",true);
1026  bool value = volP->GetUseLBNFOptimConceptDesignHornA(); //defined in LBNEVolumePlacements.hh
1027  fUseLBNFOptimConceptDesignHornA->SetDefaultValue(value);
1028  }
1029  {
1030  fUseLBNFOptimConceptDesignHornB = new G4UIcmdWithABool("/LBNE/det/LBNFOptimConceptDesignHornB", this);
1031  G4String guidance("If true, we will be using the Horn B LBNF Optimized, Conceptual Design, F.Y. 2016/2017 \n ");
1032  fUseLBNFOptimConceptDesignHornB->SetGuidance(guidance);
1033  fUseLBNFOptimConceptDesignHornB->SetParameterName("LBNFOptimConceptDesignHorn2",true);
1034  bool value = volP->GetUseLBNFOptimConceptDesignHornB(); //defined in LBNEVolumePlacements.hh
1035  fUseLBNFOptimConceptDesignHornB->SetDefaultValue(value);
1036  }
1037  {
1038  fUseLBNFOptimConceptDesignHornC = new G4UIcmdWithABool("/LBNE/det/LBNFOptimConceptDesignHornC", this);
1039  G4String guidance("If true, we will be using the Horn C LBNF Optimized, Conceptual Design, F.Y. 2016/2017 \n ");
1040  fUseLBNFOptimConceptDesignHornC->SetGuidance(guidance);
1041  fUseLBNFOptimConceptDesignHornC->SetParameterName("LBNFOptimConceptDesignHorn3",true);
1042  bool value = volP->GetUseLBNFOptimConceptDesignHornC(); //defined in LBNEVolumePlacements.hh
1043  fUseLBNFOptimConceptDesignHornC->SetDefaultValue(value);
1044  }
1045  //
1046  // August 2 2016: Remove the baffle..
1047  {
1048  fInstallBaffle = new G4UIcmdWithABool("/LBNE/det/InstallBaffle", this);
1049  G4String guidance("If true (default) install the baffle that protect the horn and target agains excessive beam deflections. \n ");
1050  fInstallBaffle->SetGuidance(guidance);
1051  fInstallBaffle->SetParameterName("InstallBaffleUsptream of target ",true);
1052  bool value = volP->GetInstallBaffle(); //
1053  fInstallBaffle->SetDefaultValue(value);
1054  }
1055  {
1056  fInstallRALShortTarget = new G4UIcmdWithABool("/LBNE/det/InstallRALShortTarget", this);
1057  G4String guidance("If true (default) install the short target (1.5m) that does not need a downstream support. \n ");
1058  fInstallRALShortTarget->SetGuidance(guidance);
1059  fInstallRALShortTarget->SetParameterName("InstallRALShortTarget (Downstream support option C from the RAL review) ",true);
1060  bool value = volP->GetInstallRALShortTarget(); //
1061  fInstallRALShortTarget->SetDefaultValue(value);
1062  }
1063  {
1064  fRALSimpleTargetLength = new G4UIcmdWithADoubleAndUnit("/LBNE/det/RALSimpleTargetLength",this);
1065  fRALSimpleTargetLength->SetGuidance("Length of Rutherford Target");
1066  fRALSimpleTargetLength->SetParameterName("RALSimpleTargetLength",true);
1067  double value = volP->GetRALSimpleTargetLength();
1068  fRALSimpleTargetLength->SetDefaultValue (value);
1069  fRALSimpleTargetLength->SetDefaultUnit ("mm");
1070  fRALSimpleTargetLength->SetUnitCandidates ("m mm");
1071  fRALSimpleTargetLength->AvailableForStates(G4State_PreInit);
1072  }
1073  {
1074  fRemoveRALBafflet = new G4UIcmdWithABool("/LBNE/det/RemoveRALBafflet", this);
1075  G4String guidance("If true (default) remove the RAL bafflet that protect the horn and target agains excessive beam deflections. \n ");
1076  fRemoveRALBafflet->SetGuidance(guidance);
1077  fRemoveRALBafflet->SetParameterName("InstallBaffleUsptream of target ", true);
1078  bool value = volP->GetRemoveRALBafflet(); //
1079  fRemoveRALBafflet->SetDefaultValue(value);
1080  }
1081  {
1082  fInstallUpstreamHorizontalTarget = new G4UIcmdWithABool("/LBNE/det/InstallUpstreamHorizontalTarget", this);
1083  G4String guidance(
1084  "If true (default) install the UpstreamHorizontalTarget that protect the horn and target agains excessive beam deflections. \n ");
1085  fInstallUpstreamHorizontalTarget->SetGuidance(guidance);
1086  fInstallUpstreamHorizontalTarget->SetParameterName("InstallUpstreamHorizontalTarget",true);
1087  bool value = volP->GetInstallUpstreamHorizontalTarget(); //
1088  fInstallUpstreamHorizontalTarget->SetDefaultValue(value);
1089  }
1090  //
1091  // December 12 2016: allow for the removal of the downstream target support, to gauge the cost.
1092  //
1093  {
1094  fInstallDownstTargetSupport = new G4UIcmdWithABool("/LBNE/det/InstallDownstTargetSupport", this);
1095  G4String guidance(
1096  "If true (default) install the downstream target support, to leviate the cantilever problem for the 2m long target. \n ");
1097  fInstallDownstTargetSupport->SetGuidance(guidance);
1098  fInstallDownstTargetSupport->SetParameterName("InstallUpstreamHorizontalTarget",true);
1099  bool value = volP->GetInstallUpstreamHorizontalTarget(); //
1100  fInstallDownstTargetSupport->SetDefaultValue(value);
1101  }
1102  //
1103  // January 2017: Define one data card that defines the Optimized Horns, engineered (or "realistic")
1104  // CD - rev2, This is a summary card.
1105  //
1106  {
1107  fUseConceptDesignOptimEngineered = new G4UIcmdWithABool("/LBNE/det/UseConceptDesignOptimEngineered", this);
1108  G4String guidance(
1109  "If true, we will be using the 3-horn system, optimized, engineered, Rev 2 \n ");
1110  fUseConceptDesignOptimEngineered->SetGuidance(guidance);
1111  fUseConceptDesignOptimEngineered->SetParameterName("UseConceptualDesignOptimizeEngineeredRev2",true);
1112  fUseConceptDesignOptimEngineered->SetDefaultValue(false);
1113  }
1114  //
1115  // February 2017: Define one data card that defines the CDR Opyimized horns, which had only one
1116  // Polycorn horn and Horn2, rescale.
1117  //
1118  {
1119  fUseCDR2015Optimized = new G4UIcmdWithABool("/LBNE/det/UseCDR2015Optimized", this);
1120  G4String guidance(
1121  "If true, we will be using the CDR 2015 optimized configuration (only 2 horns) \n ");
1122  fUseCDR2015Optimized->SetGuidance(guidance);
1123  fUseCDR2015Optimized->SetParameterName("UseConceptualDesignOptimizeEngineeredRev2",true);
1124  fUseCDR2015Optimized->SetDefaultValue(false);
1125  }
1126 
1127 }
1128 // Just to avoid code bloat..
1129 
1130 void LBNEPlacementMessenger::SetMyUnitsAndConditions(G4UIcmdWithADoubleAndUnit *cmd, double value) {
1131 
1132  cmd->SetDefaultValue (value);
1133  cmd->SetDefaultUnit ("m");
1134  cmd->SetUnitCandidates ("cm m");
1135  cmd->AvailableForStates(G4State_PreInit);
1136 }
1137 void LBNEPlacementMessenger::SetNewValue(G4UIcommand* command, G4String newValue) {
1138  LBNEVolumePlacements* volP=LBNEVolumePlacements::Instance();
1139  if (command == fWaterLayerThickInHorn) {
1140  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1141  volP->SetWaterLayerThickInHorns(cmdWD->GetNewDoubleValue(newValue));
1142 // std::cerr << " Changed WaterLayerThickInHorns , o.k. " << std::endl; // exit(2);
1143  }
1144  if (command == fDecayPipeLength) {
1145  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1146  volP->SetDecayPipeLength(cmdWD->GetNewDoubleValue(newValue));
1147  }
1148  if (command == fDecayPipeRadius) {
1149  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1150  volP->SetDecayPipeRadius(cmdWD->GetNewDoubleValue(newValue));
1151  }
1152  if (command == fDecayPipeLongPosition) {
1153  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1154  volP->SetDecayPipeLongPosition(cmdWD->GetNewDoubleValue(newValue));
1155  }
1156  if (command == fDecayPipeUpstreamWindowThickness) {
1157  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1158  volP->SetDecayPipeUpstrWindowThick(cmdWD->GetNewDoubleValue(newValue));
1159  }
1160  if (command == fDecayPipeGas) {
1161  volP->SetDecayPipeGas(newValue);
1162  }
1163  if (command == fHorn1Length) {
1164  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1165  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument,
1166  " Obsolete data card, use Horn1LongRescale instead ");
1167  volP->SetHorn1Length(cmdWD->GetNewDoubleValue(newValue));
1168  }
1169 
1170  if (command == fTargetSLengthGraphite) {
1171  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1172  std::cerr << " Extending the target to L = " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1173  volP->SetTargetSLengthGraphite(cmdWD->GetNewDoubleValue(newValue));
1174  volP->SetSimpleTargetLength(cmdWD->GetNewDoubleValue(newValue)); // Used only if Simple target used.
1175  volP->SetMultiSphereTargetLength(cmdWD->GetNewDoubleValue(newValue));//Quynh. real target.(4). should i delete the above line?
1176  if (fUse1p2MWSmallTgt) volP->SegmentTargetSmallTgt();
1177  else volP->SegmentTarget();
1178  }
1179  if (command == fTargetFinWidth) {
1180  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1181  volP->SetTargetFinWidth(cmdWD->GetNewDoubleValue(newValue));
1182  volP->SegmentTarget();
1183  }
1184  if (command == fTargetNumFinsWithWings) {
1185  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1186  volP->SetTargetNumFinsWithWings(static_cast<unsigned int>(cmdWD->GetNewIntValue(newValue)));
1187  }
1188  if (command == fTargetDensity) {
1189  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1190  volP->SetTargetDensity(cmdWD->GetNewDoubleValue(newValue));
1191  }
1192  if (command == fTargetBerylCapThickness) {
1193  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1194  std::cout << " !!! You have chosen a unusual thickness for the target He tube cap "
1195  << newValue << " \n .... Please check that the volume don't overlap in the listing.. " << std::endl;
1196  volP->SetTargetBerylDownstrWindowThick(cmdWD->GetNewDoubleValue(newValue));
1197  }
1198  if (command == fTargetMaterial) {
1199  std::cout << " !!! You have chosen to use " << newValue << " as target material " << std::endl;
1200  volP->SetTargetMaterialName(newValue);
1201  }
1202  if (command == fPlugMaterial) {
1203  std::cout << " !!! You have chosen to use " << newValue << " as 2n target (or plug) material " << std::endl;
1204  volP->SetPlugMaterial(newValue);
1205  }
1206  if (command == fTargetLengthIntoHorn) {
1207  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1208  std::cout << " !!! You have chosen the seemingly confusing way to define the length of the target which \n "
1209  << " the horn. This command should be deprecated. Please use TargetLengthOutsideHorn " << std::endl;
1210  volP->SetTargetLengthIntoHorn(cmdWD->GetNewDoubleValue(newValue));
1211  volP->SegmentTarget();
1212  }
1213  if (command == fTargetLengthOutsideHorn) {
1214  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1215  volP->SetTargetLengthOutsideHorn(cmdWD->GetNewDoubleValue(newValue) );
1216  /*
1217  ** Obsolete, August - Sept 2014. Assume from now on
1218  double valueL = volP->GetTargetSLengthGraphite(); //
1219  const double lengthReturnFlow = 25.3*CLHEP::mm; // empirically set.. Needs improvement. Must use variable in VolumePlacements.
1220  volP->SetTargetLengthOutsideHorn(cmdWD->GetNewDoubleValue(newValue) );
1221  double valIH = valueL - cmdWD->GetNewDoubleValue(newValue) + lengthReturnFlow;
1222  // Not sure what to do for the multiSphere target. Need more info about the extra space for return
1223  // flow of Helium. Also, study precedence of data cards!!!! P.L., August 2014.
1224  if (valIH < -2*CLHEP::mm) {
1225  if (!volP->GetUse1p2MW()) {
1226  std::ostringstream mStrStr;
1227  mStrStr << " The target is completely retracted from Horn1. We assume a \"Nova-like\" configuration. \n "
1228  << " However, the 700 kW target is selected. Unsupported for now.... Fatal ";
1229  G4String mStr(mStrStr.str());
1230  G4Exception("LBNEVolumePlacements::Create", " ", FatalErrorInArgument, mStr.c_str());
1231 
1232  } else {
1233  if (volP->GetHorn1MotherIsPolycone()) { // Hopefully obsolete.
1234  std::cout << " The target is completely retracted from Horn1. We assume a \"Nova-like\" configuration. \n "
1235  << " ........ valIH " << valIH << " target Length " << valueL << std::endl;
1236  volP->SetTargetLengthOutsideHorn(cmdWD->GetNewDoubleValue(newValue) );
1237  volP->SetUsePseudoNova(true);
1238  } else {
1239  volP->SetUsePseudoNova(false); // We no longer use this option, it stays false
1240  }
1241  }
1242  }
1243  else if ((!volP->GetHorn1MotherIsPolycone()) && (valIH < (lengthReturnFlow + 5.0*CLHEP::mm)) && ( valIH > -2.0*CLHEP::mm)) {
1244  std::ostringstream mStrStr;
1245  mStrStr << " The target is almost completely retracted from Horn1. " <<
1246  " The Upstream/Downstream arbitrary split cuts into the target end. "
1247  << " Unsupported for now.... Fatal ";
1248  G4String mStr(mStrStr.str());
1249  G4Exception("LBNEVolumePlacements::Create", " ", FatalErrorInArgument, mStr.c_str());
1250  }
1251 // volP->SetTargetLengthIntoHorn(valIH);
1252  // to have the first fin target at coord 0.3mm, to follow the convention.
1253 // volP->SegmentTarget();
1254 */
1255  }
1256 //Quynh, August 2014.
1257  if (command == fUseMultiSphereTarget) {
1258  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1259  volP->SetUseMultiSphereTarget(cmdB->GetNewBoolValue(newValue.c_str()));
1260  G4String aNameM("Beryllium");
1261  volP->SetTargetMaterialName(aNameM);
1262  volP->AdaptForMultiSphereTarget();
1263  }
1264  if (command == fUseSimpleTargetBox) {
1265  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1266  volP->SetUseSimpleTargetBox(cmdB->GetNewBoolValue(newValue.c_str()));
1267  volP->SegmentTarget(); // To update the much simplified target...
1268  }
1269  if (command == fRemoveTargetAlltogether) {
1270  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1271  volP->SetRemoveTargetAlltogether(cmdB->GetNewBoolValue(newValue.c_str()));
1272  }
1273 
1274 
1275  if (command == fUseSimpleTargetCylinder) {
1276  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1277  volP->SetUseSimpleTargetCylinder(cmdB->GetNewBoolValue(newValue.c_str()));
1278  volP->SegmentTarget(); // To update the much simplified target...
1279  }
1280  if (command == fSimpleTargetRadius) {
1281  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1282  if (!volP->GetUseSimpleTargetCylinder()) {
1283  std::cout << " !!! You are channging the radius of the simple cylindrical target, \n, but the " <<
1284  " NUMI-style target is still installed. Consider using first the GUI command UseSimpleCylindricalTarget \n";
1285  } else {
1286  std::cerr << " Setting new target radius to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1287  }
1288  volP->SetSimpleTargetRadius(cmdWD->GetNewDoubleValue(newValue));
1289  volP->SegmentTarget(); // To update the much simplified target...
1290  }
1291  if (command == fSimpleTargetLength) {
1292  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1293  if (!volP->GetUseSimpleTargetCylinder()) {
1294  std::cout << " !!! You are channging the length of the simple cylindrical target, \n, but the " <<
1295  " NUMI-style target is still installed. Consider using first the GUI command UseSimpleCylindricalTarget \n";
1296  } else {
1297  std::cerr << " Setting new targetlength to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1298  }
1299  volP->SetSimpleTargetLength(cmdWD->GetNewDoubleValue(newValue));
1300  volP->SegmentTarget(); // To update the much simplified target...
1301  }
1302  if (command == fMultiSphereTargetRadius) {
1303  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1304  if (!volP->GetUseMultiSphereTarget()) {
1305  std::cout << " !!! You are channging the radius of the multi sphere target, \n, but the " <<
1306  " NUMI-style target is still installed. Consider using first the GUI command UseMultiSphereTarget \n";
1307  } else {
1308  std::cerr << " Setting new target sphere radii to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1309  }
1310  volP->SetMultiSphereTargetRadius(cmdWD->GetNewDoubleValue(newValue));
1311  volP->AdaptForMultiSphereTarget();
1312  }
1313  if (command == fSimpleTargetWidth) {
1314  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1315  if (!volP->GetUseSimpleTargetBox()) {
1316  std::cout << " !!! You are channging the width of the simple box-like target, \n, but the " <<
1317  " NUMI-style target is still installed. Consider using first the GUI command UseSimpleBoxTarget \n";
1318  }
1319  volP->SetSimpleTargetWidth(cmdWD->GetNewDoubleValue(newValue));
1320  volP->SegmentTarget(); // To update the much simplified target...
1321  }
1322  if (command == fSimpleTargetHeight) {
1323  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1324  if (!volP->GetUseSimpleTargetBox()) {
1325  std::cout << " !!! You are channging the height of the simple box-like target, \n, but the " <<
1326  " NUMI-style target is still installed. Consider using first the GUI command UseSimpleBoxTarget \n";
1327  }
1328  volP->SetSimpleTargetHeight(cmdWD->GetNewDoubleValue(newValue));
1329  volP->SegmentTarget(); // To update the much simplified target...
1330  }
1331 
1332  if (command == fHorn1InnerCondMat) {
1333  std::cout << " You are now using non-standard material " << newValue
1334  << " for the Horn1 Inner Conductor material " << std::endl;
1335  volP->SetHorn1InnerConductorMaterial(newValue);
1336  }
1337  if (command == fHorn1AllCondMat) {
1338  std::cout << " You are now using non-standard material " << newValue
1339  << " for all of the Horn1 Conductors (inner, outer, I/O transition.. " << std::endl;
1340  volP->SetHorn1InnerConductorMaterial(newValue);
1341  volP->SetHorn1AllConductorMaterial(newValue);
1342  }
1343  if (command == fHorn1RadialSafetyMargin ) {
1344  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1345  const double val = cmdWD->GetNewDoubleValue(newValue);
1346  std::cout << " You are changing the safety margin in the minimum distance between \n";
1347  std::cout << " the downstream tip of the target and Horn1 inner conductor, from \n";
1348  std::cout << " the default of 2.5 mm down to " << val << std::endl;
1349  if (val < 0.) {
1350  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument,
1351  " The value the Horn radial safet margin can not be nergative ");
1352  }
1353  volP->SetHorn1RadialSafetyMargin(val);
1354  }
1355  if (command == fHorn1RadiusBigEnough ) {
1356  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1357  const bool val = cmdWD->GetNewBoolValue(newValue);
1358  std::cout << " The inner conductor radius will be set large enough to accomodate \n";
1359  std::cout << " the Helium filled Target container vessel, up the ! 1 m. into the horn1. \n";
1360  std::cout << " The default is false " << val << std::endl;
1361  volP->SetHorn1RadiusBigEnough(val);
1362  }
1363 
1364  if (command == fHorn1RadialRescale) {
1365  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1366  volP->SetHorn1RadialRescale(cmdWD->GetNewDoubleValue(newValue));
1367  volP->RescaleHorn1Radially();
1368  }
1369  if (command == fHorn1LongRescale) {
1370  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1371  volP->SetHorn1LongRescale(cmdWD->GetNewDoubleValue(newValue));
1372  volP->RescaleHorn1Lengthwise();
1373  }
1374  if (command == fHorn2RadialRescale) {
1375  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1376  volP->SetHorn2RadialRescale(cmdWD->GetNewDoubleValue(newValue));
1377  volP->RescaleHorn2Radially();
1378  }
1379  if (command == fHorn2RadialRescaleCst) {
1380  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1381  volP->SetHorn2RadialRescaleCst(cmdWD->GetNewDoubleValue(newValue));
1382  volP->ShiftHorn2Radially();
1383  }
1384  if (command == fHorn2LongRescale) {
1385  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1386  volP->SetHorn2LongRescale(cmdWD->GetNewDoubleValue(newValue));
1387  volP->RescaleHorn2Lengthwise();
1388  }
1389  if (command == fHorn2InnerCondMat) {
1390  std::cout << " You are now using non-standard material " << newValue
1391  << " for the Horn2 Inner Conductor material " << std::endl;
1392  volP->SetHorn2InnerConductorMaterial(newValue);
1393  }
1394  if (command == fHorn2AllCondMat) {
1395  std::cout << " You are now using non-standard material " << newValue
1396  << " for all of the Horn2 Conductor material " << std::endl;
1397  volP->SetHorn2InnerConductorMaterial(newValue);
1398  volP->SetHorn2AllConductorMaterial(newValue);
1399  }
1400  if (command == fHorn2LongPosition) {
1401  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1402  volP->SetHorn2LongPosition(cmdWD->GetNewDoubleValue(newValue));
1403  }
1404  if (command == fUseMarsTargetHorns) {
1405  volP->SetUseMarsTargetHorns(newValue);
1406  }
1407 
1408  if (command == fMarsTargetHornsGDMLFilename) {
1409  volP->SetMarsTargetHornsGDMLFilename(newValue);
1410  }
1411  if (command == fAbsorberGDMLFilename) {
1412  volP->SetAbsorberGDMLFilename(newValue);
1413  }
1414  if (command == fLengthOfRockDownstr) {
1415  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1416  volP->SetLengthOfRockDownstreamAlcove(cmdWD->GetNewDoubleValue(newValue));
1417  }
1418  if (command == fInstallShield) {
1419  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1420  volP->SetDoInstallShield(cmdB->GetNewBoolValue(newValue.c_str()));
1421  }
1422  if (command == fConstructPlug) {
1423  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1424  volP->SetConstructPlug(cmdB->GetNewBoolValue(newValue.c_str()));
1425  }
1426  if (command == fConstructPlugInHorn1) {
1427  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1428  volP->SetConstructPlugInHorn1(cmdB->GetNewBoolValue(newValue.c_str()));
1429  }
1430  if (command == fPlugLength) {
1431  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1432  volP->SetPlugLength(cmdWD->GetNewDoubleValue(newValue));
1433  }
1434  // 1.2 MW options.
1435  if (command == fUse1p2MW) {
1436  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1437  volP->SetUse1p2MW(cmdB->GetNewBoolValue(newValue.c_str()));
1438  std::cout << " You are now using the 1.2 MW design, new version, Nov. 2016 " << std::endl;
1439  std::cout << " Adapted from J. Hylen by Cory Crowley, Nov. 2016. " << std::endl;
1440  std::cout << " See also option Use1p2MWSmallTgt, circa Feb 2014 " << std::endl;
1441  if (volP->GetUse1p2MW()) {
1442  volP->adaptTargetFor1p2MW();
1443  volP->SegmentTarget();
1444  }
1445  }
1446 
1447  if (command == fUseRALTGTv1) {
1448  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1449  volP->SetUseRALTGTv1(cmdB->GetNewBoolValue(newValue.c_str()));
1450  std::cout << " You are now using the Rutherford accelerator laboratory design, first version, circa May 2017 " << std::endl;
1451  if (volP->GetUseRALTGTv1()) {
1452  volP->adaptRALTGTv1();
1453 // volP->SegmentRALTGTv1();
1454  }
1455  }
1456 
1457 
1458 
1459  if (command == fUse1p2MWSmallTgt) {
1460  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1461  volP->SetUse1p2MWSmallTgt(cmdB->GetNewBoolValue(newValue.c_str()));
1462  std::cout << " You are now using the 1.2 MW design, first version, circa Feb 2014 " << std::endl;
1463  if (volP->GetUse1p2MWSmallTgt()) {
1464  volP->adaptTargetFor1p2MWSmallTgt();
1465  volP->SegmentTargetSmallTgt();
1466  }
1467  }
1468  if (command == fUseRoundedTargetFins) {
1469  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1470  volP->SetUseRoundedTargetFins(cmdB->GetNewBoolValue(newValue.c_str()));
1471  if (cmdB->GetNewBoolValue(newValue.c_str()))
1472  std::cout << " You are now using the Rounded fins target, at it should be " << std::endl;
1473  else std::cout << " You are now using thestraight edge fins for the target, " << std::endl <<
1474  " .... you should probably reduce the fins width a few % (1p2MW default thickness) " << std::endl;
1475  }
1476  if (command == fPlugOuterRadius) {
1477  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1478  volP->SetPlugOuterRadius(cmdWD->GetNewDoubleValue(newValue));
1479  }
1480  if (command == fPlugInnerRadius) {
1481  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1482  volP->SetPlugInnerRadius(cmdWD->GetNewDoubleValue(newValue));
1483  }
1484  if (command == fPlugZPosition) {
1485  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1486  volP->SetPlugZPosition(cmdWD->GetNewDoubleValue(newValue));
1487  }
1488  //
1489  // September 2014: Install the custom Horn1 Polycone.
1490  //
1491  if (command == fUseHorn1Polycone) {
1492  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1493  volP->SetUseHorn1Polycone(cmdWD->GetNewBoolValue(newValue));
1494  }
1495  if (command == fUseHorn1PolyNumInnerPts) {
1496  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1497  volP->SetUseHorn1PolyNumInnerPts(cmdWD->GetNewIntValue(newValue));
1498  // August 2015: Also update the new set of paramters...
1499  volP->SetUseHornsPolyNumInnerPts(1, cmdWD->GetNewIntValue(newValue));
1500  }
1501  if (command == fHorn1PolyOuterRadius) {
1502  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1503  volP->SetHorn1PolyOuterRadius(cmdWD->GetNewDoubleValue(newValue));
1504  volP->SetHornsPolyOuterRadius(1, cmdWD->GetNewDoubleValue(newValue));
1505  }
1506  for (size_t kCmd=0; kCmd != fHorn1PolyListRinThickZVects.size(); kCmd++) {
1507  if (command == fHorn1PolyListRinThickZVects[kCmd]) {
1508  G4UIcmdWith3VectorAndUnit* cmdWD = dynamic_cast<G4UIcmdWith3VectorAndUnit*> (command);
1509  G4ThreeVector v = cmdWD->GetNew3VectorValue(newValue);
1510  volP->SetHorn1PolyInnerThreeVect(kCmd, v);
1511  volP->SetHornsPolyInnerThreeVect(1, kCmd, v);
1512  break;
1513  }
1514  }
1515  //
1516  // August 2015..
1517  //
1518  if (command == fUseNumberOfHornsPoly) {
1519  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1520  const int nn = cmdWD->GetNewIntValue(newValue);
1521  std::cout << " You are now using the optimized horns. Number of them requested " << nn << std::endl;
1522  volP->SetTargetLengthOutsideHorn(0.);
1523  volP->SetNumberOfHornsPolycone(nn); // Backward compatibility with Optimization effort, during 2016
1524  volP->SetUse1p2MW(true);
1525  volP->SetUse1p2MWSmallTgt(false);
1526  volP->adaptTargetFor1p2MW();
1527  volP->SegmentTarget();
1528  if (nn > 0) volP->SetHornsPolyZStartPos(1, 0.*CLHEP::mm);
1529  volP->SetTargetLengthOutsideHorn(0.);
1530  }
1531  //
1532  // October 2015.. John LoSecco, P.L.
1533  //
1534  if (command == fSetPolyconeHornParabolic) {
1535  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1536  const int nn = cmdWD->GetNewIntValue(newValue);
1537  if ((nn < 1) || (nn > 5)) {
1538  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument,
1539  " SetPolyconeHornParabolic, valid argument between 1 and 5 ");
1540  }
1541  volP->SetPolyconeHornParabolic(static_cast<size_t>(nn), true);
1542  if (nn == 1) volP->SetPolyconeHorn1Parabolic(true);
1543  }
1544  if (command == fUseHorn2PolyNumInnerPts) {
1545  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1546  volP->SetUseHornsPolyNumInnerPts(2, cmdWD->GetNewIntValue(newValue));
1547  }
1548  if (command == fHorn2PolyOuterRadius) {
1549  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1550  volP->SetHornsPolyOuterRadius(2, cmdWD->GetNewDoubleValue(newValue));
1551  }
1552  for (size_t kCmd=0; kCmd != fHorn2PolyListRinThickZVects.size(); kCmd++) {
1553  if (command == fHorn2PolyListRinThickZVects[kCmd]) {
1554  G4UIcmdWith3VectorAndUnit* cmdWD = dynamic_cast<G4UIcmdWith3VectorAndUnit*> (command);
1555  G4ThreeVector v = cmdWD->GetNew3VectorValue(newValue);
1556  volP->SetHornsPolyInnerThreeVect(2, kCmd, v);
1557  break;
1558  }
1559  }
1560  if (command == fHorn2PolyZStartPos) {
1561  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1562  volP->SetHornsPolyZStartPos(2, cmdWD->GetNewDoubleValue(newValue));
1563  }
1564  //
1565  // Repeat for Horns 3, 4, 5.
1566  //
1567  if (command == fUseHorn3PolyNumInnerPts) {
1568  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1569  volP->SetUseHornsPolyNumInnerPts(3, cmdWD->GetNewIntValue(newValue));
1570  }
1571  if (command == fHorn3PolyOuterRadius) {
1572  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1573  volP->SetHornsPolyOuterRadius(3, cmdWD->GetNewDoubleValue(newValue));
1574  }
1575  for (size_t kCmd=0; kCmd != fHorn3PolyListRinThickZVects.size(); kCmd++) {
1576  if (command == fHorn3PolyListRinThickZVects[kCmd]) {
1577  G4UIcmdWith3VectorAndUnit* cmdWD = dynamic_cast<G4UIcmdWith3VectorAndUnit*> (command);
1578  G4ThreeVector v = cmdWD->GetNew3VectorValue(newValue);
1579  volP->SetHornsPolyInnerThreeVect(3, kCmd, v);
1580  break;
1581  }
1582  }
1583  if (command == fHorn3PolyZStartPos) {
1584  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1585  volP->SetHornsPolyZStartPos(3, cmdWD->GetNewDoubleValue(newValue));
1586  }
1587  if (command == fUseHorn4PolyNumInnerPts) {
1588  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1589  volP->SetUseHornsPolyNumInnerPts(4, cmdWD->GetNewIntValue(newValue));
1590  }
1591  if (command == fHorn4PolyOuterRadius) {
1592  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1593  volP->SetHornsPolyOuterRadius(4, cmdWD->GetNewDoubleValue(newValue));
1594  }
1595  for (size_t kCmd=0; kCmd != fHorn4PolyListRinThickZVects.size(); kCmd++) {
1596  if (command == fHorn4PolyListRinThickZVects[kCmd]) {
1597  G4UIcmdWith3VectorAndUnit* cmdWD = dynamic_cast<G4UIcmdWith3VectorAndUnit*> (command);
1598  G4ThreeVector v = cmdWD->GetNew3VectorValue(newValue);
1599  volP->SetHornsPolyInnerThreeVect(4, kCmd, v);
1600  break;
1601  }
1602  }
1603  if (command == fHorn4PolyZStartPos) {
1604  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1605  volP->SetHornsPolyZStartPos(4, cmdWD->GetNewDoubleValue(newValue));
1606  }
1607  if (command == fUseHorn5PolyNumInnerPts) {
1608  G4UIcmdWithAnInteger* cmdWD = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1609  volP->SetUseHornsPolyNumInnerPts(5, cmdWD->GetNewIntValue(newValue));
1610  }
1611  if (command == fHorn5PolyOuterRadius) {
1612  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1613  volP->SetHornsPolyOuterRadius(5, cmdWD->GetNewDoubleValue(newValue));
1614  }
1615  for (size_t kCmd=0; kCmd != fHorn5PolyListRinThickZVects.size(); kCmd++) {
1616  if (command == fHorn5PolyListRinThickZVects[kCmd]) {
1617  G4UIcmdWith3VectorAndUnit* cmdWD = dynamic_cast<G4UIcmdWith3VectorAndUnit*> (command);
1618  G4ThreeVector v = cmdWD->GetNew3VectorValue(newValue);
1619  volP->SetHornsPolyInnerThreeVect(5, kCmd, v);
1620  break;
1621  }
1622  }
1623  if (command == fHorn5PolyZStartPos) {
1624  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1625  volP->SetHornsPolyZStartPos(5, cmdWD->GetNewDoubleValue(newValue));
1626  }
1627  //
1628  // With a caveat: we may not have the room for decay pipe snout, so we remove it..
1629  //
1630  if (command == fRemoveDecayPipeSnout) {
1631  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1632  volP->SetRemoveDecayPipeSnout(cmdWD->GetNewBoolValue(newValue));
1633  }
1634  //
1635  // Milind Wire in the decay pipe..
1636  if (command == fRadiusMilindWire) {
1637  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1638  volP->SetRadiusMilindWire(cmdWD->GetNewDoubleValue(newValue));
1639  }
1640  if (command == fCurrentMilindWire) {
1641  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1642  volP->SetCurrentMilindWire(cmdWD->GetNewDoubleValue(newValue));
1643  }
1644 
1645  if (command == fWriteGDMLFile) {
1646  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1647  volP->SetWriteGDMLFile(cmdWD->GetNewBoolValue(newValue));
1648  }
1649 
1650  // John Back, March 2016: target module (e.g. SAT) options
1651  if (command == fUseTargetModule) {
1652  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1653  volP->SetUseTargetModule(cmdB->GetNewBoolValue(newValue.c_str()));
1654  // Also initialise the fTargetLengthOutsideExtra to zero for now to ensure
1655  // no overlapping volumes for any Horn arrangement
1656  volP->SetTargetLengthOutsideExtra(0.0);
1657  }
1658 
1659  if (command == fUseTarget2Module) {
1660  G4UIcmdWithABool* cmdB = dynamic_cast<G4UIcmdWithABool*> (command);
1661  volP->SetUseTarget2Module(cmdB->GetNewBoolValue(newValue.c_str()));
1662  }
1663 
1664  if (command == fTargetModuleType) {
1665  G4UIcmdWithAnInteger* cmdB = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1666  volP->SetTargetModuleType(cmdB->GetNewIntValue(newValue.c_str()));
1667  }
1668 
1669  if (command == fTarget2ModuleType) {
1670  G4UIcmdWithAnInteger* cmdB = dynamic_cast<G4UIcmdWithAnInteger*> (command);
1671  volP->SetTarget2ModuleType(cmdB->GetNewIntValue(newValue.c_str()));
1672  }
1673 
1674  if (command == fTarget2Material) {
1675  std::cout << " !!! You have chosen to use " << newValue << " as the 2nd target material " << std::endl;
1676  volP->SetTarget2MaterialName(newValue);
1677  }
1678 
1679  if (command == fTargetRadius) {
1680  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1681  if (!volP->GetUseTargetModule()) {
1682  std::cerr << " !!! You are changing target object radius for the target module, \n, but the " <<
1683  " NUMI-style target is still installed. Consider using first the GUI command UseTargetModule. \n";
1684  } else {
1685  std::cout << " Setting new target module object radius to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1686  }
1687  volP->SetTargetRadius(cmdWD->GetNewDoubleValue(newValue));
1688 
1689  }
1690 
1691  if (command == fTarget2Radius) {
1692  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1693  if (!volP->GetUseTarget2Module()) {
1694  std::cerr << " !!! You are changing target object radius for the 2nd target module, \n, but the " <<
1695  " NUMI-style target is still installed. Consider using first the GUI command UseTarget2Module. \n";
1696  } else {
1697  std::cout << " Setting new 2nd target module object radius to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1698  }
1699  volP->SetTarget2Radius(cmdWD->GetNewDoubleValue(newValue));
1700 
1701  }
1702 
1703  if (command == fTargetLength) {
1704  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1705  if (!volP->GetUseTargetModule()) {
1706  std::cerr << " !!! You are changing the total length of the target module (object), \n, but the " <<
1707  " NUMI-style target is still installed. Consider using first the GUI command UseTargetModule. \n";
1708  } else {
1709  std::cout << " Setting new target module object length to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1710  }
1711  volP->SetTargetLength(cmdWD->GetNewDoubleValue(newValue));
1712 
1713  }
1714 
1715  if (command == fTarget2Length) {
1716  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1717  if (!volP->GetUseTarget2Module()) {
1718  std::cerr << " !!! You are changing the total length of the 2nd target module (object), \n, but the " <<
1719  " NUMI-style target is still installed. Consider using first the GUI command UseTarget2Module. \n";
1720  } else {
1721  std::cout << " Setting new 2nd target module object length to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1722  }
1723  volP->SetTarget2Length(cmdWD->GetNewDoubleValue(newValue));
1724 
1725  }
1726 
1727  if (command == fTargetNLambda) {
1728  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1729  if (!volP->GetUseTargetModule()) {
1730  std::cerr << " !!! You are specifying the number of interaction lengths for the target module (object), \n, but the " <<
1731  " NUMI-style target is still installed. Consider using first the GUI command UseTargetModule. \n";
1732  } else {
1733  std::cout << " Setting number of interaction lengths to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1734  }
1735  volP->SetTargetNLambda(cmdWD->GetNewDoubleValue(newValue));
1736 
1737  }
1738 
1739  if (command == fTarget2NLambda) {
1740  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1741  if (!volP->GetUseTarget2Module()) {
1742  std::cerr << " !!! You are specifying the number of interaction lengths for the 2nd target module (object), \n, but the " <<
1743  " NUMI-style target is still installed. Consider using first the GUI command UseTarget2Module. \n";
1744  } else {
1745  std::cout << " Setting number of interaction lengths for 2nd module to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1746  }
1747  volP->SetTarget2NLambda(cmdWD->GetNewDoubleValue(newValue));
1748 
1749  }
1750 
1751  if (command == fTargetFracOutHornL) {
1752  G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
1753  if (!volP->GetUseTargetModule()) {
1754  std::cerr << " !!! You are specifying the length fraction of the target module outside Horn1, \n, but the " <<
1755  " NUMI-style target is still installed. Consider using first the GUI command UseTargetModule. \n";
1756  } else {
1757  std::cout << " Setting new length fraction of target module outside Horn1 to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1758  }
1759  volP->SetTargetFracOutHornL(cmdWD->GetNewDoubleValue(newValue));
1760 
1761  }
1762 
1763  if (command == fTargetLengthOutsideExtra) {
1764  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1765  std::cout << " Setting new TargetLengthOutsideExtra shift to " << cmdWD->GetNewDoubleValue(newValue) << std::endl;
1766  volP->SetTargetLengthOutsideExtra(cmdWD->GetNewDoubleValue(newValue));
1767 
1768  }
1769 
1770  if (command == fHorn3InnerCondMat) {
1771  std::cout << " You are now using non-standard material " << newValue
1772  << " for the Horn3 (HornC) Inner Conductor material " << std::endl;
1773  volP->SetHorn3InnerConductorMaterial(newValue);
1774  }
1775  if (command == fHorn3AllCondMat) {
1776  std::cout << " You are now using non-standard material " << newValue
1777  << " for all of the Horn3 Conductor material " << std::endl;
1778  volP->SetHorn3InnerConductorMaterial(newValue);
1779  volP->SetHorn3AllConductorMaterial(newValue);
1780  }
1781  if (command == fUseLBNFOptimConceptDesignHornA ) {
1782  if (volP->GetNumberOfHornsPolycone() < 1) {
1783  std::string msg0(
1784  " You haven't defined the number of Polycone Horns. \n");
1785  msg0 += std::string(
1786  " Please use the infamous data card /LBNE/det/NumberOfHornsPolycone prior to set the horn style \n");
1787  std::cerr << msg0 << std::endl;
1788  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument, msg0.c_str());
1789  }
1790  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1791  const bool val = cmdWD->GetNewBoolValue(newValue);
1792  if (val) std::cout << " We are using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn A \n";
1793  if (!val) {
1794  std::cout << " We are NOT using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn A \n";
1795  std::cout << " Other data cards must be used to defined Horn1 \n";
1796  return;
1797  }
1798 
1799 // volP->adaptTargetFor1p2MW();
1800 // volP->configureTargetForConceptHornARev2(); Now called from the above.
1801 // volP->SegmentTarget();
1802 // The above is already done while defining the number of Polycone horns..
1803 //
1804  volP->SetUseLBNFOptimConceptDesignHornA(val);
1805  volP->PreparePolyconForConceptHornA();
1806 
1807 
1808 // This is now alsways called, but we allow for an eventual re-definition of the target fin width.
1809 //
1810 
1811  }
1812 
1813  if (command == fUseLBNFOptimConceptDesignHornB ) {
1814  if (volP->GetNumberOfHornsPolycone() < 2) {
1815  std::string msg0(
1816  " The number of Polycone Horns is less than 2.. I am confused.... \n");
1817  msg0 += std::string(
1818  " Please use the infamous data card /LBNE/det/NumberOfHornsPolycone prior to set the horn style \n");
1819  std::cerr << msg0 << std::endl;
1820  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument, msg0.c_str());
1821  }
1822  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1823  const bool val = cmdWD->GetNewBoolValue(newValue);
1824  if (val) std::cout << " We are using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn B \n";
1825  if (!val) {
1826  std::cout << " We are NOT using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn B \n";
1827  std::cout << " Other data cards must be used to defined Horn2 \n";
1828  return;
1829  }
1830  // Version Rev 2, November 22 2016. Drawing NX9 F10071359
1831  volP->SetUseLBNFOptimConceptDesignHornB(val);
1832  volP->PreparePolyconForConceptHornB();
1833 
1834  }
1835  if (command == fUseLBNFOptimConceptDesignHornC ) {
1836  if (volP->GetNumberOfHornsPolycone() < 3) {
1837  std::string msg0(
1838  " The number of Polycone Horns is less than 3.. I am confused.... \n");
1839  msg0 += std::string(
1840  " Please use the infamous data card /LBNE/det/NumberOfHornsPolycone prior to set the horn style \n");
1841  std::cerr << msg0 << std::endl;
1842  G4Exception("LBNEPlacementMessenger::SetNewValue ", " ", FatalErrorInArgument, msg0.c_str());
1843  }
1844  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1845  const bool val = cmdWD->GetNewBoolValue(newValue);
1846  if (val) std::cout << " We are using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn C \n";
1847  if (!val) {
1848  std::cout << " We are NOT using the LBNF, optimized, Conceptual Design F.Y. 2016, for Horn C \n";
1849  std::cout << " Other data cards must be used to defined Horn3 \n";
1850  return;
1851  }
1852  // Define with some level of detail, as this is used in computing the magnetic field.
1853  // Node one for Horn B, but we will get back to it at some point...
1854  //
1855  volP->SetUseLBNFOptimConceptDesignHornC(val);
1856  volP->PreparePolyconForConceptHornC();
1857  }
1858  if (command == fInstallBaffle ) {
1859  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1860  const bool val = cmdWD->GetNewBoolValue(newValue);
1861  volP->SetInstallBaffle(val);
1862  }
1863  if (command == fRemoveRALBafflet ) {
1864  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1865  const bool val = cmdWD->GetNewBoolValue(newValue);
1866  volP->SetRemoveRALBafflet(val);
1867  }
1868  if (command == fRALSimpleTargetLength) {
1869  G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
1870  volP->SetRALSimpleTargetLength(cmdWD->GetNewDoubleValue(newValue));
1871  }
1872  if (command == fInstallRALShortTarget ) {
1873  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1874  const bool val = cmdWD->GetNewBoolValue(newValue);
1875  volP->SetInstallRALShortTarget(val);
1876  }
1877  if (command == fInstallUpstreamHorizontalTarget ) {
1878  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1879  const bool val = cmdWD->GetNewBoolValue(newValue);
1880  volP->SetInstallUpstreamHorizontalTarget(val);
1881  }
1882  if (command == fInstallDownstTargetSupport ) {
1883  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1884  const bool val = cmdWD->GetNewBoolValue(newValue);
1885  volP->SetInstallDownstTargetSupport(val);
1886  }
1887 
1888  if (command == fUseConceptDesignOptimEngineered ) {
1889  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1890  const bool val = cmdWD->GetNewBoolValue(newValue);
1891  if (val) {
1892  volP->SetUse1p2MW(true);
1893  volP->SetUse1p2MWSmallTgt(false);
1894  volP->SetNumberOfHornsPolycone(3);
1895  volP->adaptTargetFor1p2MW();
1896 // volP->configureTargetForConceptHornARev2(); Now called from the above.
1897  volP->SegmentTarget();
1898  volP->SetHornsPolyZStartPos(1, 0.*CLHEP::mm);
1899  volP->SetHornsPolyZStartPos(2, 2956.51*CLHEP::mm);
1900  volP->SetHornsPolyZStartPos(3, 17806.949*CLHEP::mm);
1901  volP->SetUseLBNFOptimConceptDesignHornA(true);
1902  volP->PreparePolyconForConceptHornA();
1903  volP->SetUseLBNFOptimConceptDesignHornB(true);
1904  volP->PreparePolyconForConceptHornB();
1905  volP->SetUseLBNFOptimConceptDesignHornC(true);
1906  volP->PreparePolyconForConceptHornC();
1907  volP->SetTargetLengthOutsideHorn(0.);
1908  }
1909  }
1910  if (command == fUseCDR2015Optimized ) {
1911  G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
1912  const bool val = cmdWD->GetNewBoolValue(newValue);
1913  volP->SetUseCDR2015Optimized(val);
1914  volP->SetUse1p2MWSmallTgt(true);
1915  volP->adaptTargetFor1p2MWSmallTgt();
1916  }
1917 
1918 
1919 }
LBNEVolumePlacements::GetCurrentMilindWire
double GetCurrentMilindWire() const
Definition: LBNEVolumePlacements.hh:1245
LBNEPlacementMessenger::fInstallRALShortTarget
G4UIcmdWithABool * fInstallRALShortTarget
Definition: LBNEPlacementMessenger.hh:199
LBNEVolumePlacements::GetLengthOfRockDownstreamAlcove
double GetLengthOfRockDownstreamAlcove() const
Definition: LBNEVolumePlacements.hh:198
LBNEVolumePlacements::SetMultiSphereTargetLength
void SetMultiSphereTargetLength(double r)
Definition: LBNEVolumePlacements.hh:1233
LBNEPlacementMessenger::fHorn1RadiusBigEnough
G4UIcmdWithABool * fHorn1RadiusBigEnough
Definition: LBNEPlacementMessenger.hh:80
LBNEPlacementMessenger::fHorn4PolyZStartPos
G4UIcmdWithADoubleAndUnit * fHorn4PolyZStartPos
Definition: LBNEPlacementMessenger.hh:158
LBNEVolumePlacements::SetSimpleTargetWidth
void SetSimpleTargetWidth(double r)
Definition: LBNEVolumePlacements.hh:235
LBNEPlacementMessenger::fTargetNumFinsWithWings
G4UIcmdWithAnInteger * fTargetNumFinsWithWings
Definition: LBNEPlacementMessenger.hh:56
LBNEVolumePlacements::SetTargetNumFinsWithWings
void SetTargetNumFinsWithWings(unsigned int n)
Definition: LBNEVolumePlacements.hh:273
LBNEVolumePlacements::GetSimpleTargetHeight
double GetSimpleTargetHeight() const
Definition: LBNEVolumePlacements.hh:245
LBNEPlacementMessenger::fUseSimpleTargetCylinder
G4UIcmdWithABool * fUseSimpleTargetCylinder
Definition: LBNEPlacementMessenger.hh:61
LBNEPlacementMessenger::fTarget2NLambda
G4UIcmdWithADouble * fTarget2NLambda
Definition: LBNEPlacementMessenger.hh:182
LBNEVolumePlacements::SetDecayPipeUpstrWindowThick
void SetDecayPipeUpstrWindowThick(double l)
Definition: LBNEVolumePlacements.hh:208
LBNEVolumePlacements::GetTargetDensity
double GetTargetDensity() const
Definition: LBNEVolumePlacements.hh:274
LBNEPlacementMessenger::fInstallDownstTargetSupport
G4UIcmdWithABool * fInstallDownstTargetSupport
Definition: LBNEPlacementMessenger.hh:204
LBNEPlacementMessenger::fTarget2ModuleType
G4UIcmdWithAnInteger * fTarget2ModuleType
Definition: LBNEPlacementMessenger.hh:179
LBNEPlacementMessenger::fInstallShield
G4UIcmdWithABool * fInstallShield
Definition: LBNEPlacementMessenger.hh:114
LBNEVolumePlacements::SetTargetFracOutHornL
void SetTargetFracOutHornL(double l)
Definition: LBNEVolumePlacements.hh:1357
LBNEPlacementMessenger::fSimpleTargetHeight
G4UIcmdWithADoubleAndUnit * fSimpleTargetHeight
Definition: LBNEPlacementMessenger.hh:64
LBNEVolumePlacements::GetDecayPipeUpstrWindowThick
double GetDecayPipeUpstrWindowThick() const
Definition: LBNEVolumePlacements.hh:167
LBNEPlacementMessenger::fRALSimpleTargetLength
G4UIcmdWithADoubleAndUnit * fRALSimpleTargetLength
Definition: LBNEPlacementMessenger.hh:200
LBNEVolumePlacements::GetUseMultiSphereTarget
bool GetUseMultiSphereTarget() const
Definition: LBNEVolumePlacements.hh:1235
LBNEVolumePlacements::GetMultiSphereTargetRadius
double GetMultiSphereTargetRadius() const
Definition: LBNEVolumePlacements.hh:1236
LBNEVolumePlacements::SetPlugMaterial
void SetPlugMaterial(std::string name)
Definition: LBNEVolumePlacements.hh:225
LBNEPlacementMessenger::fHorn3AllCondMat
G4UIcmdWithAString * fHorn3AllCondMat
Definition: LBNEPlacementMessenger.hh:90
LBNEVolumePlacements::GetUseLBNFOptimConceptDesignHornB
bool GetUseLBNFOptimConceptDesignHornB() const
Definition: LBNEVolumePlacements.hh:1400
LBNEVolumePlacements::SetMarsTargetHornsGDMLFilename
void SetMarsTargetHornsGDMLFilename(G4String &name)
Definition: LBNEVolumePlacements.hh:310
LBNEPlacementMessenger::fHorn1PolyListRinThickZVects
std::vector< G4UIcmdWith3VectorAndUnit * > fHorn1PolyListRinThickZVects
Definition: LBNEPlacementMessenger.hh:129
LBNEPlacementMessenger::SetNewValue
void SetNewValue(G4UIcommand *command, G4String cmd)
Definition: LBNEPLacementMessenger.cc:1137
string
std::string string
Definition: nybbler.cc:12
LBNEPlacementMessenger::fTargetLengthIntoHorn
G4UIcmdWithADoubleAndUnit * fTargetLengthIntoHorn
Definition: LBNEPlacementMessenger.hh:49
LBNEVolumePlacements::GetPlugZPosition
double GetPlugZPosition() const
Definition: LBNEVolumePlacements.hh:185
LBNEVolumePlacements::GetDecayPipeLongPosition
double GetDecayPipeLongPosition() const
Definition: LBNEVolumePlacements.hh:168
LBNEVolumePlacements::Instance
static LBNEVolumePlacements * Instance()
Definition: LBNEVolumePlacements.cc:57
LBNEPlacementMessenger::fTargetBerylCapThickness
G4UIcmdWithADoubleAndUnit * fTargetBerylCapThickness
Definition: LBNEPlacementMessenger.hh:51
LBNEVolumePlacements::GetInstallUpstreamHorizontalTarget
bool GetInstallUpstreamHorizontalTarget() const
Definition: LBNEVolumePlacements.hh:1421
command
int command
Definition: tclscanner.cpp:1124
LBNEPlacementMessenger::fUseLBNFOptimConceptDesignHornA
G4UIcmdWithABool * fUseLBNFOptimConceptDesignHornA
Definition: LBNEPlacementMessenger.hh:187
LBNEVolumePlacements::GetTarget2Length
double GetTarget2Length() const
Definition: LBNEVolumePlacements.hh:1309
LBNEVolumePlacements::SetRALSimpleTargetLength
void SetRALSimpleTargetLength(double l)
Definition: LBNEVolumePlacements.hh:1434
LBNEVolumePlacements::GetMarsTargetHornsGDMLFilename
G4String GetMarsTargetHornsGDMLFilename() const
Definition: LBNEVolumePlacements.hh:309
LBNEPlacementMessenger::fDecayPipeLongPosition
G4UIcmdWithADoubleAndUnit * fDecayPipeLongPosition
Definition: LBNEPlacementMessenger.hh:94
LBNEVolumePlacements::SetHorn3AllConductorMaterial
void SetHorn3AllConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:215
LBNEVolumePlacements::SetUseLBNFOptimConceptDesignHornB
void SetUseLBNFOptimConceptDesignHornB(bool f)
Definition: LBNEVolumePlacements.hh:1406
LBNEVolumePlacements::GetUseLBNFOptimConceptDesignHornC
bool GetUseLBNFOptimConceptDesignHornC() const
Definition: LBNEVolumePlacements.hh:1401
LBNEPlacementMessenger::fHorn2LongRescale
G4UIcmdWithADouble * fHorn2LongRescale
Definition: LBNEPlacementMessenger.hh:85
LBNEVolumePlacements::SetTargetFinWidth
void SetTargetFinWidth(double l)
Definition: LBNEVolumePlacements.hh:258
LBNEPlacementMessenger::fTargetLengthOutsideExtra
G4UIcmdWithADoubleAndUnit * fTargetLengthOutsideExtra
Definition: LBNEPlacementMessenger.hh:176
LBNEPlacementMessenger::fHorn2InnerCondMat
G4UIcmdWithAString * fHorn2InnerCondMat
Definition: LBNEPlacementMessenger.hh:87
LBNEPlacementMessenger::fTargetDensity
G4UIcmdWithADoubleAndUnit * fTargetDensity
Definition: LBNEPlacementMessenger.hh:54
LBNEVolumePlacements::GetHorn1PolyOuterRadius
double GetHorn1PolyOuterRadius() const
Definition: LBNEVolumePlacements.hh:475
LBNEVolumePlacements::SetHorn2RadialRescaleCst
void SetHorn2RadialRescaleCst(double r)
Definition: LBNEVolumePlacements.hh:302
LBNEPlacementMessenger::fHorn3PolyOuterRadius
G4UIcmdWithADoubleAndUnit * fHorn3PolyOuterRadius
Definition: LBNEPlacementMessenger.hh:152
LBNEPlacementMessenger::fMultiSphereTargetRadius
G4UIcmdWithADoubleAndUnit * fMultiSphereTargetRadius
Definition: LBNEPlacementMessenger.hh:70
LBNEPlacementMessenger::fHorn1LongRescale
G4UIcmdWithADouble * fHorn1LongRescale
Definition: LBNEPlacementMessenger.hh:74
LBNEVolumePlacements::GetTargetSLengthGraphite
double GetTargetSLengthGraphite() const
Definition: LBNEVolumePlacements.hh:255
LBNEPlacementMessenger::fHorn2PolyZStartPos
G4UIcmdWithADoubleAndUnit * fHorn2PolyZStartPos
Definition: LBNEPlacementMessenger.hh:148
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:45
LBNEVolumePlacements::GetSimpleTargetWidth
double GetSimpleTargetWidth() const
Definition: LBNEVolumePlacements.hh:244
LBNEVolumePlacements::SetMultiSphereTargetRadius
void SetMultiSphereTargetRadius(double r)
Definition: LBNEVolumePlacements.hh:1234
LBNEPlacementMessenger::fConstructPlugInHorn1
G4UIcmdWithABool * fConstructPlugInHorn1
Definition: LBNEPlacementMessenger.hh:45
LBNEPlacementMessenger::fUseNumberOfHornsPoly
G4UIcmdWithAnInteger * fUseNumberOfHornsPoly
Definition: LBNEPlacementMessenger.hh:142
LBNEVolumePlacements::GetAbsorberGDMLFilename
G4String GetAbsorberGDMLFilename() const
Definition: LBNEVolumePlacements.hh:312
LBNEPlacementMessenger::fUse1p2MWSmallTgt
G4UIcmdWithABool * fUse1p2MWSmallTgt
Definition: LBNEPlacementMessenger.hh:119
LBNEVolumePlacements::SetTargetLengthOutsideExtra
void SetTargetLengthOutsideExtra(double l)
Definition: LBNEVolumePlacements.hh:1370
LBNEVolumePlacements::SetConstructPlugInHorn1
void SetConstructPlugInHorn1(bool t)
Definition: LBNEVolumePlacements.hh:228
LBNEPlacementMessenger::fUseLBNFOptimConceptDesignHornB
G4UIcmdWithABool * fUseLBNFOptimConceptDesignHornB
Definition: LBNEPlacementMessenger.hh:188
LBNEPlacementMessenger::fUseHorn5PolyNumInnerPts
G4UIcmdWithAnInteger * fUseHorn5PolyNumInnerPts
Definition: LBNEPlacementMessenger.hh:160
LBNEPlacementMessenger::fDecayPipeLength
G4UIcmdWithADoubleAndUnit * fDecayPipeLength
Definition: LBNEPlacementMessenger.hh:92
LBNEVolumePlacements::SetTargetMaterialName
void SetTargetMaterialName(G4String &aName)
Definition: LBNEVolumePlacements.hh:281
LBNEVolumePlacements::GetTarget2Radius
double GetTarget2Radius() const
Definition: LBNEVolumePlacements.hh:1301
LBNEVolumePlacements::GetUseLBNFOptimConceptDesignHornA
bool GetUseLBNFOptimConceptDesignHornA() const
Definition: LBNEVolumePlacements.hh:1399
LBNEVolumePlacements::GetDecayPipeLength
double GetDecayPipeLength() const
Definition: LBNEVolumePlacements.hh:165
LBNEPlacementMessenger::fDecayPipeRadius
G4UIcmdWithADoubleAndUnit * fDecayPipeRadius
Definition: LBNEPlacementMessenger.hh:93
LBNEPlacementMessenger::fHorn5PolyZStartPos
G4UIcmdWithADoubleAndUnit * fHorn5PolyZStartPos
Definition: LBNEPlacementMessenger.hh:163
LBNEPlacementMessenger::fUseLBNFOptimConceptDesignHornC
G4UIcmdWithABool * fUseLBNFOptimConceptDesignHornC
Definition: LBNEPlacementMessenger.hh:189
LBNEVolumePlacements::GetUseSimpleTargetBox
bool GetUseSimpleTargetBox() const
Definition: LBNEVolumePlacements.hh:239
LBNEPlacementMessenger::fRadiusMilindWire
G4UIcmdWithADoubleAndUnit * fRadiusMilindWire
Definition: LBNEPlacementMessenger.hh:101
LBNEPlacementMessenger::fPlugLength
G4UIcmdWithADoubleAndUnit * fPlugLength
Definition: LBNEPlacementMessenger.hh:40
LBNEVolumePlacements::GetTarget2NLambda
G4double GetTarget2NLambda() const
Definition: LBNEVolumePlacements.hh:1366
LBNEVolumePlacements::SetHorn1RadialRescale
void SetHorn1RadialRescale(double r)
Definition: LBNEVolumePlacements.hh:297
LBNEPlacementMessenger::fHorn1AllCondMat
G4UIcmdWithAString * fHorn1AllCondMat
Definition: LBNEPlacementMessenger.hh:76
LBNEVolumePlacements::SetHornsPolyZStartPos
void SetHornsPolyZStartPos(size_t hornNumber, double z)
Definition: LBNEVolumePlacements.hh:669
LBNEVolumePlacements::GetTargetNumFinsWithWings
unsigned int GetTargetNumFinsWithWings() const
Definition: LBNEVolumePlacements.hh:272
LBNEPlacementMessenger::fRemoveTargetAlltogether
G4UIcmdWithABool * fRemoveTargetAlltogether
Definition: LBNEPlacementMessenger.hh:138
LBNEPlacementMessenger::fSimpleTargetLength
G4UIcmdWithADoubleAndUnit * fSimpleTargetLength
Definition: LBNEPlacementMessenger.hh:66
LBNEVolumePlacements::SetHorn2LongPosition
void SetHorn2LongPosition(double l)
Definition: LBNEVolumePlacements.hh:304
LBNEPlacementMessenger::fInstallBaffle
G4UIcmdWithABool * fInstallBaffle
Definition: LBNEPlacementMessenger.hh:196
LBNEPlacementMessenger::fUseHorn2PolyNumInnerPts
G4UIcmdWithAnInteger * fUseHorn2PolyNumInnerPts
Definition: LBNEPlacementMessenger.hh:145
LBNEPlacementMessenger::fCurrentMilindWire
G4UIcmdWithADoubleAndUnit * fCurrentMilindWire
Definition: LBNEPlacementMessenger.hh:102
LBNEPlacementMessenger::fRemoveRALBafflet
G4UIcmdWithABool * fRemoveRALBafflet
Definition: LBNEPlacementMessenger.hh:197
LBNEPlacementMessenger::fUseTarget2Module
G4UIcmdWithABool * fUseTarget2Module
Definition: LBNEPlacementMessenger.hh:178
LBNEPlacementMessenger::fLengthOfRockDownstr
G4UIcmdWithADoubleAndUnit * fLengthOfRockDownstr
Definition: LBNEPlacementMessenger.hh:104
LBNEVolumePlacements::GetSimpleTargetRadius
double GetSimpleTargetRadius() const
Definition: LBNEVolumePlacements.hh:243
LBNEPlacementMessenger::fHorn1RadialSafetyMargin
G4UIcmdWithADoubleAndUnit * fHorn1RadialSafetyMargin
Definition: LBNEPlacementMessenger.hh:79
LBNEVolumePlacements::GetUseMarsTargetHorns
bool GetUseMarsTargetHorns() const
Definition: LBNEVolumePlacements.hh:306
LBNEPlacementMessenger::fHorn2RadialRescaleCst
G4UIcmdWithADoubleAndUnit * fHorn2RadialRescaleCst
Definition: LBNEPlacementMessenger.hh:84
LBNEVolumePlacements::GetTargetFinWidth
double GetTargetFinWidth() const
Definition: LBNEVolumePlacements.hh:257
LBNEVolumePlacements::SetDecayPipeRadius
void SetDecayPipeRadius(double l)
Definition: LBNEVolumePlacements.hh:206
LBNEVolumePlacements::SetPolyconeHorn1Parabolic
void SetPolyconeHorn1Parabolic(bool t)
Definition: LBNEVolumePlacements.hh:637
LBNEPlacementMessenger::fUseRoundedTargetFins
G4UIcmdWithABool * fUseRoundedTargetFins
Definition: LBNEPlacementMessenger.hh:123
LBNEVolumePlacements::SetHorn2AllConductorMaterial
void SetHorn2AllConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:214
LBNEPlacementMessenger::fHorn4PolyOuterRadius
G4UIcmdWithADoubleAndUnit * fHorn4PolyOuterRadius
Definition: LBNEPlacementMessenger.hh:157
LBNEPlacementMessenger::fSimpleTargetWidth
G4UIcmdWithADoubleAndUnit * fSimpleTargetWidth
Definition: LBNEPlacementMessenger.hh:65
LBNEPlacementMessenger::fDecayPipeGas
G4UIcmdWithAString * fDecayPipeGas
Definition: LBNEPlacementMessenger.hh:96
LBNEVolumePlacements::SetHorn3InnerConductorMaterial
void SetHorn3InnerConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:212
LBNEPlacementMessenger::fTarget2Material
G4UIcmdWithAString * fTarget2Material
Definition: LBNEPlacementMessenger.hh:183
LBNEPlacementMessenger::fPlugInnerRadius
G4UIcmdWithADoubleAndUnit * fPlugInnerRadius
Definition: LBNEPlacementMessenger.hh:41
LBNEPlacementMessenger::fHorn2PolyOuterRadius
G4UIcmdWithADoubleAndUnit * fHorn2PolyOuterRadius
Definition: LBNEPlacementMessenger.hh:147
LBNEVolumePlacements::SetSimpleTargetHeight
void SetSimpleTargetHeight(double r)
Definition: LBNEVolumePlacements.hh:236
LBNEVolumePlacements::GetTargetMaterialName
G4String GetTargetMaterialName() const
Definition: LBNEVolumePlacements.hh:280
LBNEVolumePlacements::SetDecayPipeGas
void SetDecayPipeGas(G4String &name)
Definition: LBNEVolumePlacements.hh:209
LBNEVolumePlacements::SetHorn1PolyOuterRadius
void SetHorn1PolyOuterRadius(double r)
Definition: LBNEVolumePlacements.hh:514
LBNEVolumePlacements::GetHorn2InnerConductorMaterial
G4String GetHorn2InnerConductorMaterial() const
Definition: LBNEVolumePlacements.hh:171
LBNEVolumePlacements::SetCurrentMilindWire
void SetCurrentMilindWire(double r)
Definition: LBNEVolumePlacements.hh:1246
LBNEVolumePlacements::GetHorn2AllConductorMaterial
G4String GetHorn2AllConductorMaterial() const
Definition: LBNEVolumePlacements.hh:174
LBNEVolumePlacements::SetPlugInnerRadius
void SetPlugInnerRadius(double r)
Definition: LBNEVolumePlacements.hh:223
LBNEVolumePlacements::GetHorn1RadialSafetyMargin
double GetHorn1RadialSafetyMargin() const
Definition: LBNEVolumePlacements.hh:288
LBNEVolumePlacements::SetUseHorn1PolyNumInnerPts
void SetUseHorn1PolyNumInnerPts(int n)
Definition: LBNEVolumePlacements.hh:499
LBNEVolumePlacements::SetHorn2InnerConductorMaterial
void SetHorn2InnerConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:211
LBNEVolumePlacements::GetDecayPipeRadius
double GetDecayPipeRadius() const
Definition: LBNEVolumePlacements.hh:166
LBNEPlacementMessenger::fTargetSLengthGraphite
G4UIcmdWithADoubleAndUnit * fTargetSLengthGraphite
Definition: LBNEPlacementMessenger.hh:47
LBNEPlacementMessenger::fHorn2RadialRescale
G4UIcmdWithADouble * fHorn2RadialRescale
Definition: LBNEPlacementMessenger.hh:82
LBNEPlacementMessenger::fHorn1InnerCondMat
G4UIcmdWithAString * fHorn1InnerCondMat
Definition: LBNEPlacementMessenger.hh:75
LBNEVolumePlacements::GetTargetBerylDownstrWindowThick
double GetTargetBerylDownstrWindowThick() const
Definition: LBNEVolumePlacements.hh:285
LBNEPlacementMessenger::fDecayPipeUpstreamWindowThickness
G4UIcmdWithADoubleAndUnit * fDecayPipeUpstreamWindowThickness
Definition: LBNEPlacementMessenger.hh:95
LBNEVolumePlacements::SetTargetLengthIntoHorn
void SetTargetLengthIntoHorn(double l)
Definition: LBNEVolumePlacements.hh:283
LBNEPlacementMessenger::fHorn3PolyZStartPos
G4UIcmdWithADoubleAndUnit * fHorn3PolyZStartPos
Definition: LBNEPlacementMessenger.hh:153
LBNEPlacementMessenger::fUseHorn3PolyNumInnerPts
G4UIcmdWithAnInteger * fUseHorn3PolyNumInnerPts
Definition: LBNEPlacementMessenger.hh:150
LBNEVolumePlacements::GetTargetNLambda
G4double GetTargetNLambda() const
Definition: LBNEVolumePlacements.hh:1363
LBNEVolumePlacements::SetSimpleTargetLength
void SetSimpleTargetLength(double l)
Definition: LBNEVolumePlacements.hh:237
LBNEVolumePlacements::SetUseLBNFOptimConceptDesignHornA
void SetUseLBNFOptimConceptDesignHornA(bool f)
Definition: LBNEVolumePlacements.hh:1405
LBNEPlacementMessenger::fSimpleTargetRadius
G4UIcmdWithADoubleAndUnit * fSimpleTargetRadius
Definition: LBNEPlacementMessenger.hh:63
LBNEPlacementMessenger::fMarsTargetHornsGDMLFilename
G4UIcmdWithAString * fMarsTargetHornsGDMLFilename
Definition: LBNEPlacementMessenger.hh:108
LBNEPlacementMessenger::fHorn5PolyListRinThickZVects
std::vector< G4UIcmdWith3VectorAndUnit * > fHorn5PolyListRinThickZVects
Definition: LBNEPlacementMessenger.hh:161
LBNEPlacementMessenger::fHorn1PolyOuterRadius
G4UIcmdWithADoubleAndUnit * fHorn1PolyOuterRadius
Definition: LBNEPlacementMessenger.hh:130
LBNEPlacementMessenger::fTargetLengthOutsideHorn
G4UIcmdWithADoubleAndUnit * fTargetLengthOutsideHorn
Definition: LBNEPlacementMessenger.hh:50
LBNEPlacementMessenger::SetMyUnitsAndConditions
void SetMyUnitsAndConditions(G4UIcmdWithADoubleAndUnit *cmd, double value)
Definition: LBNEPLacementMessenger.cc:1130
LBNEVolumePlacements::GetRemoveDecayPipeSnout
bool GetRemoveDecayPipeSnout() const
Definition: LBNEVolumePlacements.hh:1240
LBNEPlacementMessenger::fWriteGDMLFile
G4UIcmdWithABool * fWriteGDMLFile
Definition: LBNEPlacementMessenger.hh:112
LBNEVolumePlacements::SetHorn1InnerConductorMaterial
void SetHorn1InnerConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:210
LBNEVolumePlacements::SetUseLBNFOptimConceptDesignHornC
void SetUseLBNFOptimConceptDesignHornC(bool f)
Definition: LBNEVolumePlacements.hh:1407
LBNEVolumePlacements::GetPlugMaterial
std::string GetPlugMaterial() const
Definition: LBNEVolumePlacements.hh:186
LBNEVolumePlacements::SetHorn2LongRescale
void SetHorn2LongRescale(double r)
Definition: LBNEVolumePlacements.hh:299
LBNEPlacementMessenger::fHorn1Length
G4UIcmdWithADoubleAndUnit * fHorn1Length
Definition: LBNEPlacementMessenger.hh:36
LBNEPlacementMessenger::fTarget2Length
G4UIcmdWithADoubleAndUnit * fTarget2Length
Definition: LBNEPlacementMessenger.hh:181
LBNEPlacementMessenger::fHorn3InnerCondMat
G4UIcmdWithAString * fHorn3InnerCondMat
Definition: LBNEPlacementMessenger.hh:89
LBNEVolumePlacements::SetDecayPipeLongPosition
void SetDecayPipeLongPosition(double l)
Definition: LBNEVolumePlacements.hh:207
LBNEPlacementMessenger::fPlugOuterRadius
G4UIcmdWithADoubleAndUnit * fPlugOuterRadius
Definition: LBNEPlacementMessenger.hh:42
LBNEPlacementMessenger::fPlugZPosition
G4UIcmdWithADoubleAndUnit * fPlugZPosition
Definition: LBNEPlacementMessenger.hh:43
LBNEVolumePlacements::SetInstallDownstTargetSupport
void SetInstallDownstTargetSupport(bool t)
Definition: LBNEVolumePlacements.hh:1425
LBNEPlacementMessenger::fTargetLength
G4UIcmdWithADoubleAndUnit * fTargetLength
Definition: LBNEPlacementMessenger.hh:173
LBNEVolumePlacements::SetPolyconeHornParabolic
void SetPolyconeHornParabolic(size_t hornNumber, bool t)
Definition: LBNEVolumePlacements.hh:627
LBNEVolumePlacements::GetHorn3AllConductorMaterial
G4String GetHorn3AllConductorMaterial() const
Definition: LBNEVolumePlacements.hh:175
LBNEVolumePlacements::SetHorn1RadiusBigEnough
void SetHorn1RadiusBigEnough(bool t)
Definition: LBNEVolumePlacements.hh:289
LBNEVolumePlacements::SetPlugOuterRadius
void SetPlugOuterRadius(double r)
Definition: LBNEVolumePlacements.hh:224
value
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1225
LBNEVolumePlacements::SetTarget2MaterialName
void SetTarget2MaterialName(G4String &aName)
Definition: LBNEVolumePlacements.hh:1389
LBNEVolumePlacements::SetRemoveTargetAlltogether
void SetRemoveTargetAlltogether(bool t)
Definition: LBNEVolumePlacements.hh:250
LBNEVolumePlacements::GetHorn1Length
double GetHorn1Length() const
Definition: LBNEVolumePlacements.hh:177
LBNEPlacementMessenger::fUseHorn1Polycone
G4UIcmdWithABool * fUseHorn1Polycone
Definition: LBNEPlacementMessenger.hh:127
LBNEVolumePlacements::GetRALSimpleTargetLength
double GetRALSimpleTargetLength() const
Definition: LBNEVolumePlacements.hh:1432
LBNEPlacementMessenger::fUseCDR2015Optimized
G4UIcmdWithABool * fUseCDR2015Optimized
Definition: LBNEPlacementMessenger.hh:215
LBNEPlacementMessenger::fSetPolyconeHornParabolic
G4UIcmdWithAnInteger * fSetPolyconeHornParabolic
Definition: LBNEPlacementMessenger.hh:165
LBNEVolumePlacements::GetRadiusMilindWire
double GetRadiusMilindWire() const
Definition: LBNEVolumePlacements.hh:1243
LBNEVolumePlacements::GetTargetLengthIntoHorn
double GetTargetLengthIntoHorn() const
Definition: LBNEVolumePlacements.hh:282
LBNEPlacementMessenger::fInstallUpstreamHorizontalTarget
G4UIcmdWithABool * fInstallUpstreamHorizontalTarget
Definition: LBNEPlacementMessenger.hh:198
LBNEPlacementMessenger::fHorn2PolyListRinThickZVects
std::vector< G4UIcmdWith3VectorAndUnit * > fHorn2PolyListRinThickZVects
Definition: LBNEPlacementMessenger.hh:146
LBNEPlacementMessenger::fTargetFinWidth
G4UIcmdWithADoubleAndUnit * fTargetFinWidth
Definition: LBNEPlacementMessenger.hh:48
LBNEVolumePlacements::GetTargetLengthOutsideExtra
G4double GetTargetLengthOutsideExtra() const
Definition: LBNEVolumePlacements.hh:1371
LBNEPlacementMessenger::fTargetFracOutHornL
G4UIcmdWithADouble * fTargetFracOutHornL
Definition: LBNEPlacementMessenger.hh:175
LBNEVolumePlacements::SetTargetSLengthGraphite
void SetTargetSLengthGraphite(double l)
Definition: LBNEVolumePlacements.hh:256
LBNEVolumePlacements::GetHorn1AllConductorMaterial
G4String GetHorn1AllConductorMaterial() const
Definition: LBNEVolumePlacements.hh:173
run_cnn_1class.m
m
Definition: run_cnn_1class.py:75
LBNEPlacementMessenger::fHorn3PolyListRinThickZVects
std::vector< G4UIcmdWith3VectorAndUnit * > fHorn3PolyListRinThickZVects
Definition: LBNEPlacementMessenger.hh:151
LBNEVolumePlacements::SetHornsPolyOuterRadius
void SetHornsPolyOuterRadius(size_t hornNumber, double r)
Definition: LBNEVolumePlacements.hh:663
LBNEPlacementMessenger::fUseMultiSphereTarget
G4UIcmdWithABool * fUseMultiSphereTarget
Definition: LBNEPlacementMessenger.hh:69
LBNEVolumePlacements::SetLengthOfRockDownstreamAlcove
void SetLengthOfRockDownstreamAlcove(double l)
Definition: LBNEVolumePlacements.hh:192
LBNEPlacementMessenger::fTargetNLambda
G4UIcmdWithADouble * fTargetNLambda
Definition: LBNEPlacementMessenger.hh:174
LBNEVolumePlacements::GetConstructPlugInHorn1
bool GetConstructPlugInHorn1() const
Definition: LBNEVolumePlacements.hh:242
LBNEVolumePlacements::SetSimpleTargetRadius
void SetSimpleTargetRadius(double r)
Definition: LBNEVolumePlacements.hh:234
LBNEPlacementMessenger::fTarget2Radius
G4UIcmdWithADoubleAndUnit * fTarget2Radius
Definition: LBNEPlacementMessenger.hh:180
LBNEVolumePlacements::GetUseSimpleTargetCylinder
bool GetUseSimpleTargetCylinder() const
Definition: LBNEVolumePlacements.hh:240
LBNEVolumePlacements::SetUseHornsPolyNumInnerPts
void SetUseHornsPolyNumInnerPts(size_t hornNumber, size_t nElem)
Definition: LBNEVolumePlacements.hh:640
LBNEVolumePlacements::SetDecayPipeLength
void SetDecayPipeLength(double l)
Definition: LBNEVolumePlacements.hh:202
LBNEVolumePlacements::SetHorn2RadialRescale
void SetHorn2RadialRescale(double r)
Definition: LBNEVolumePlacements.hh:301
LBNEVolumePlacements::GetSimpleTargetLength
double GetSimpleTargetLength() const
Definition: LBNEVolumePlacements.hh:246
LBNEPlacementMessenger::fUseMarsTargetHorns
G4UIcmdWithABool * fUseMarsTargetHorns
Definition: LBNEPlacementMessenger.hh:106
LBNEPlacementMessenger::fInstance
static LBNEPlacementMessenger * fInstance
Definition: LBNEPlacementMessenger.hh:30
LBNEVolumePlacements::SetHorn1LongRescale
void SetHorn1LongRescale(double r)
Definition: LBNEVolumePlacements.hh:295
LBNEPlacementMessenger::fUseConceptDesignOptimEngineered
G4UIcmdWithABool * fUseConceptDesignOptimEngineered
Definition: LBNEPlacementMessenger.hh:209
LBNEVolumePlacements::SetHornsPolyInnerThreeVect
void SetHornsPolyInnerThreeVect(size_t hornNumber, size_t iP, G4ThreeVector vVal)
Definition: LBNEVolumePlacements.hh:649
LBNEVolumePlacements::SetRadiusMilindWire
void SetRadiusMilindWire(double r)
Definition: LBNEVolumePlacements.hh:1244
LBNEPlacementMessenger::fUseTargetModule
G4UIcmdWithABool * fUseTargetModule
Definition: LBNEPlacementMessenger.hh:170
LBNEPlacementMessenger::fHorn5PolyOuterRadius
G4UIcmdWithADoubleAndUnit * fHorn5PolyOuterRadius
Definition: LBNEPlacementMessenger.hh:162
LBNEPlacementMessenger::fPlugMaterial
G4UIcmdWithAString * fPlugMaterial
Definition: LBNEPlacementMessenger.hh:53
LBNEPlacementMessenger::fUseHorn4PolyNumInnerPts
G4UIcmdWithAnInteger * fUseHorn4PolyNumInnerPts
Definition: LBNEPlacementMessenger.hh:155
LBNEVolumePlacements::GetHorn1InnerConductorMaterial
G4String GetHorn1InnerConductorMaterial() const
Definition: LBNEVolumePlacements.hh:170
LBNEVolumePlacements::SetTargetBerylDownstrWindowThick
void SetTargetBerylDownstrWindowThick(double t)
Definition: LBNEVolumePlacements.hh:286
getreco.cmd
list cmd
Definition: getreco.py:22
LBNEPlacementMessenger::fUseHorn1PolyNumInnerPts
G4UIcmdWithAnInteger * fUseHorn1PolyNumInnerPts
Definition: LBNEPlacementMessenger.hh:128
LBNEVolumePlacements::GetUseRoundedTargetFins
bool GetUseRoundedTargetFins() const
Definition: LBNEVolumePlacements.hh:423
LBNEPlacementMessenger::fConstructPlug
G4UIcmdWithABool * fConstructPlug
Definition: LBNEPlacementMessenger.hh:44
LBNEPlacementMessenger::fRemoveDecayPipeSnout
G4UIcmdWithABool * fRemoveDecayPipeSnout
Definition: LBNEPlacementMessenger.hh:134
LBNEPlacementMessenger::fHorn1RadialRescale
G4UIcmdWithADouble * fHorn1RadialRescale
Definition: LBNEPlacementMessenger.hh:73
LBNEPlacementMessenger::fHorn2AllCondMat
G4UIcmdWithAString * fHorn2AllCondMat
Definition: LBNEPlacementMessenger.hh:88
LBNEVolumePlacements::GetPlugInnerRadius
double GetPlugInnerRadius() const
Definition: LBNEVolumePlacements.hh:183
LBNEVolumePlacements::GetNumberOfHornsPolycone
int GetNumberOfHornsPolycone() const
Definition: LBNEVolumePlacements.hh:518
LBNEPlacementMessenger::fHorn4PolyListRinThickZVects
std::vector< G4UIcmdWith3VectorAndUnit * > fHorn4PolyListRinThickZVects
Definition: LBNEPlacementMessenger.hh:156
LBNEVolumePlacements::SetAbsorberGDMLFilename
void SetAbsorberGDMLFilename(G4String &name)
Definition: LBNEVolumePlacements.hh:313
LBNEVolumePlacements::SetHorn1PolyInnerThreeVect
void SetHorn1PolyInnerThreeVect(size_t iP, G4ThreeVector vVal)
Definition: LBNEVolumePlacements.hh:503
LBNEVolumePlacements::GetPlugOuterRadius
double GetPlugOuterRadius() const
Definition: LBNEVolumePlacements.hh:184
LBNEPlacementMessenger::fTargetMaterial
G4UIcmdWithAString * fTargetMaterial
Definition: LBNEPlacementMessenger.hh:52
LBNEVolumePlacements::GetTargetFracOutHornL
G4double GetTargetFracOutHornL() const
Definition: LBNEVolumePlacements.hh:1358
LBNEPlacementMessenger::fUseSimpleTargetBox
G4UIcmdWithABool * fUseSimpleTargetBox
Definition: LBNEPlacementMessenger.hh:60
LBNEVolumePlacements::GetInstallRALShortTarget
bool GetInstallRALShortTarget() const
Definition: LBNEVolumePlacements.hh:1429
LBNEVolumePlacements::SetHorn1RadialSafetyMargin
void SetHorn1RadialSafetyMargin(double t)
Definition: LBNEVolumePlacements.hh:287
LBNEPlacementMessenger::fHorn2LongPosition
G4UIcmdWithADoubleAndUnit * fHorn2LongPosition
Definition: LBNEPlacementMessenger.hh:86
LBNEVolumePlacements::GetHorn2LongPosition
double GetHorn2LongPosition() const
Definition: LBNEVolumePlacements.hh:303
LBNEPlacementMessenger::fTargetModuleType
G4UIcmdWithAnInteger * fTargetModuleType
Definition: LBNEPlacementMessenger.hh:171
LBNEPlacementMessenger::fTargetRadius
G4UIcmdWithADoubleAndUnit * fTargetRadius
Definition: LBNEPlacementMessenger.hh:172
LBNEVolumePlacements::SetUseSimpleTargetCylinder
void SetUseSimpleTargetCylinder(bool t)
Definition: LBNEVolumePlacements.hh:233
endl
QTextStream & endl(QTextStream &s)
Definition: qtextstream.cpp:2030
LBNEVolumePlacements::SetUseRoundedTargetFins
void SetUseRoundedTargetFins(bool t)
Definition: LBNEVolumePlacements.hh:424
LBNEVolumePlacements::IsHorn1RadiusBigEnough
bool IsHorn1RadiusBigEnough() const
Definition: LBNEVolumePlacements.hh:290
LBNEVolumePlacements::SetHorn1AllConductorMaterial
void SetHorn1AllConductorMaterial(G4String &name)
Definition: LBNEVolumePlacements.hh:213
LBNEVolumePlacements::SetWaterLayerThickInHorns
void SetWaterLayerThickInHorns(double l)
Definition: LBNEVolumePlacements.hh:217
LBNEPlacementMessenger::Instance
static LBNEPlacementMessenger * Instance()
Definition: LBNEPLacementMessenger.cc:16
LBNEPlacementMessenger::fAbsorberGDMLFilename
G4UIcmdWithAString * fAbsorberGDMLFilename
Definition: LBNEPlacementMessenger.hh:110
LBNEVolumePlacements::SetTargetLengthOutsideHorn
void SetTargetLengthOutsideHorn(double l)
Definition: LBNEVolumePlacements.hh:284
LBNEVolumePlacements::SetInstallUpstreamHorizontalTarget
void SetInstallUpstreamHorizontalTarget(bool f)
Definition: LBNEVolumePlacements.hh:1423
LBNEPlacementMessenger::fWaterLayerThickInHorn
G4UIcmdWithADoubleAndUnit * fWaterLayerThickInHorn
Definition: LBNEPlacementMessenger.hh:35
Generated by   doxygen 1.8.11