LBNEDetectorMessenger Class Reference

#include <LBNEDetectorMessenger.hh>

Inheritance diagram for LBNEDetectorMessenger:

Public Member Functions
	LBNEDetectorMessenger (LBNEDetectorConstruction *)
	~LBNEDetectorMessenger ()
void	SetNewValue (G4UIcommand *, G4String)

Private Attributes
LBNEDetectorConstruction *	LBNEDetector
G4UIdirectory *	LBNEDir
G4UIdirectory *	detDir
G4UIcmdWithABool *	ConstructTarget
G4UIcmdWithoutParameter *	UpdateCmd
G4UIcmdWithoutParameter *	ConstructCmd
G4UIcmdWithADoubleAndUnit *	WaterLayerThickInHorn
G4UIcmdWithADoubleAndUnit *	SetBeamlineAngle
G4UIcmdWithADoubleAndUnit *	SetHornCurrent
G4UIcmdWithADoubleAndUnit *	SetSkinDepthInnerRad
std::vector< G4UIcmdWithADoubleAndUnit * >	SetHornsDeltaEccentricityIO
std::vector< G4UIcmdWithADoubleAndUnit * >	SetHornsDeltaEllipticityI
std::vector< G4UIcmdWithADoubleAndUnit * >	SetHornsCurrentEqualizerLongAbsLength
std::vector< G4UIcmdWithAString * >	SetFileNameFieldMapForCE
std::vector< G4UIcmdWithADouble * >	SetHornsCurrentEqualizerQuadAmpl
std::vector< G4UIcmdWithADouble * >	SetHornsCurrentEqualizerOctAmpl
std::vector< G4UIcmdWithADouble * >	SetHornsCurrentMultiplier
G4UIcmdWithABool *	ConstructSimpAbsorber
G4UIcmdWithABool *	ConstructSculptedAbsorber
G4UIcmdWithABool *	DisableSpoiler
G4UIcmdWithABool *	DisableSculptedLayers
G4UIcmdWithABool *	DisableMask
G4UIcmdWithABool *	ExpandAlLayers
G4UIcmdWithAnInteger *	RemoveLayers
G4UIcmdWithADoubleAndUnit *	DwStrAbsSteelWidth
G4UIcmdWithADoubleAndUnit *	DwStrAbsConcreteWidth
G4UIcmdWithADoubleAndUnit *	ZCoordForPerfectFocusing

Detailed Description

Definition at line 16 of file LBNEDetectorMessenger.hh.

Constructor & Destructor Documentation

LBNEDetectorMessenger::LBNEDetectorMessenger

(

LBNEDetectorConstruction *

LBNEDet

)

Definition at line 2029 of file LBNEDetectorConstruction.cc.

                                                                              :LBNEDetector(LBNEDet)
{
   LBNEDir = new G4UIdirectory("/LBNE/");
   LBNEDir->SetGuidance("UI commands for detector geometry");
   
   detDir = new G4UIdirectory("/LBNE/det/");
   detDir->SetGuidance("detector control");
   
   
   ConstructTarget = new G4UIcmdWithABool("/LBNE/det/constructTarget",this); 
   ConstructTarget->SetParameterName("constructTarget", false);
   ConstructTarget->SetGuidance("Target construction on/off"); 
   ConstructTarget->SetParameterName("constructTarget",true); 
   ConstructTarget->AvailableForStates(G4State_PreInit,G4State_Idle);
   
   SetBeamlineAngle = new
   G4UIcmdWithADoubleAndUnit("/LBNE/det/setBeamlineAngle",this);
   SetBeamlineAngle->SetParameterName("angle", false);
   SetBeamlineAngle->SetGuidance("Set the angle of the beamline");
   
   UpdateCmd = new G4UIcmdWithoutParameter("/LBNE/det/update",this);
   UpdateCmd->SetGuidance("Update or Construct LBNE geometry. Same difference ");
   UpdateCmd->SetGuidance("This command MUST be applied before \"beamOn\" ");
   UpdateCmd->SetGuidance("if you changed geometrical value(s).");
   UpdateCmd->AvailableForStates(G4State_PreInit);
   
   ConstructCmd = new G4UIcmdWithoutParameter("/LBNE/det/construct",this);
   ConstructCmd->SetGuidance("Construct LBNE geometry. Should be one and only time ");
   ConstructCmd->SetGuidance("This command MUST be applied before \"beamOn\" ");
   ConstructCmd->SetGuidance("if you changed geometrical value(s).");
   ConstructCmd->AvailableForStates(G4State_PreInit);
  
    //Messenger for simple geometry of absorber
    ConstructSimpAbsorber = new G4UIcmdWithABool("/LBNE/det/ConstructSimpAbsorber",this);
    ConstructSimpAbsorber->SetParameterName("Simple Absorber",true);
    ConstructSimpAbsorber->SetGuidance("Set geometry of Hadron Absorber. If true simulate simple version of absorber");
    ConstructSimpAbsorber->SetDefaultValue(false);
    ConstructSimpAbsorber->AvailableForStates(G4State_PreInit,G4State_Idle);

    ConstructSculptedAbsorber = new G4UIcmdWithABool("/LBNE/det/ConstructSculptedAbsorber",this);
    ConstructSculptedAbsorber->SetParameterName("Aluminum, Sculpted Absorber",true);
    ConstructSculptedAbsorber->SetGuidance("Set geometry of Hadron Absorber. If true simulate the 2015 Sculpted absorber");
    ConstructSculptedAbsorber->SetDefaultValue(false);
    ConstructSculptedAbsorber->AvailableForStates(G4State_PreInit,G4State_Idle);

    DisableSpoiler = new G4UIcmdWithABool("/LBNE/det/DisableSpoiler",this);
    DisableSpoiler->SetParameterName("Remove spoiler",true);
    DisableSpoiler->SetGuidance("If true simulate the 2015 Sculpted absorber without the spoiler");
    DisableSpoiler->SetDefaultValue(false);
    DisableSpoiler->AvailableForStates(G4State_PreInit,G4State_Idle);

    DisableSculptedLayers = new G4UIcmdWithABool("/LBNE/det/DisableSculptedLayers",this);
    DisableSculptedLayers->SetParameterName("Remove sculpting",true);
    DisableSculptedLayers->SetGuidance("If true simulate the 2015 Sculpted absorber without the sculpting on the aluminum layers");
    DisableSculptedLayers->SetDefaultValue(false);
    DisableSculptedLayers->AvailableForStates(G4State_PreInit,G4State_Idle);

    DisableMask = new G4UIcmdWithABool("/LBNE/det/DisableMask",this);
    DisableMask->SetParameterName("Remove sculpting",true);
    DisableMask->SetGuidance("If true simulate the 2015 Sculpted absorber without the mask layers between the spoiler and core part of the absorber");
    DisableMask->SetDefaultValue(false);
    DisableMask->AvailableForStates(G4State_PreInit,G4State_Idle);

    ExpandAlLayers = new G4UIcmdWithABool("/LBNE/det/ExpandAlLayers",this);
    ExpandAlLayers->SetParameterName("Expand Sculpted Absorber Al layers to 2.8x2.8 m",true);
    ExpandAlLayers->SetGuidance("If true simulate the 2015 Sculpted absorber with a core region to the size of the decay pipe");
    ExpandAlLayers->SetDefaultValue(false);
    ExpandAlLayers->AvailableForStates(G4State_PreInit,G4State_Idle);

    RemoveLayers = new G4UIcmdWithAnInteger("/LBNE/det/RemoveLayers",this);
    RemoveLayers->SetParameterName("Number of layers to remove from the downstream end of the absorber",true);
    RemoveLayers->SetGuidance("Simulate the 2015 Sculpted absorber with fewer layers");
    RemoveLayers->SetDefaultValue(0);
    RemoveLayers->AvailableForStates(G4State_PreInit,G4State_Idle);

    DwStrAbsSteelWidth = new G4UIcmdWithADoubleAndUnit("/LBNE/det/DwStrAbsSteelWidth",this);
    DwStrAbsSteelWidth->SetParameterName("Steel Downstr Width",true);
    DwStrAbsSteelWidth->SetGuidance("Define the downstream width (m) of the steel volume in the simple geometry of absorber. Default value is ...");
    LBNEDetector->SetDwStrAbsSteelWidth(1.865*CLHEP::m);
    DwStrAbsSteelWidth->SetDefaultUnit("m");
    DwStrAbsSteelWidth->AvailableForStates(G4State_PreInit);

    DwStrAbsConcreteWidth = new G4UIcmdWithADoubleAndUnit("/LBNE/det/DwStrAbsConcreteWidth",this);
    DwStrAbsConcreteWidth->SetParameterName("Concrete Downstr Width",true);
    DwStrAbsConcreteWidth->SetGuidance("Define the downstream width (m) of the concrete volume in the simple geometry of absorber. Default value is ...");
    LBNEDetector->SetDwStrAbsConcreteWidth(1.33*CLHEP::m);
    DwStrAbsConcreteWidth ->SetDefaultUnit("m");
    DwStrAbsConcreteWidth->AvailableForStates(G4State_PreInit);

   new G4UnitDefinition("kiloampere" , "kA", "Electric current", 1000.*CLHEP::ampere);   
   SetHornCurrent = new
     G4UIcmdWithADoubleAndUnit("/LBNE/det/seHornCurrent",this);
   SetHornCurrent->SetParameterName("Horn Current", false);
   SetHornCurrent->SetGuidance(" The current for the horn system. (Horn1 and Horn2 are in series.");
   SetHornCurrent ->SetDefaultValue(200.0); // CDR, March 2012
   SetHornCurrent->SetDefaultUnit("kA");
   SetHornCurrent->SetUnitCandidates("kA");
   SetHornCurrent->AvailableForStates(G4State_PreInit);
   {
   SetSkinDepthInnerRad  = new G4UIcmdWithADoubleAndUnit("/LBNE/det/SetSkinDepthInnerRad",this);
   std::string aGuidance("The skin depth for the inner conductor. \n ");
   aGuidance += std::string(" The default assumes infinite.  Using Zarko' thesis model, \n"); 
   aGuidance += std::string("  MINOS Document 5694-v1, section 5.2.4, p150 - 156 \n");
   SetSkinDepthInnerRad->SetGuidance(aGuidance.c_str());
   SetSkinDepthInnerRad->SetParameterName("SetSkinDepthInnerRad",true);
   SetSkinDepthInnerRad->SetDefaultValue (1.0e10*CLHEP::mm);
   SetSkinDepthInnerRad->AvailableForStates(G4State_PreInit);
   }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "DeltaEccentricityIO"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADoubleAndUnit* aGUICmd  = new G4UIcmdWithADoubleAndUnit(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The Eccentricity between Inner/Outer conductors for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxDeltaEccentricityIO",true);
       aGUICmd->SetDefaultValue (0.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsDeltaEccentricityIO.push_back(aGUICmd);
     }
    }
    {
     //
     
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "DeltaEllipticityI"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADoubleAndUnit* aGUICmd  = new G4UIcmdWithADoubleAndUnit(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The Ellipticity of the  Inner conductor for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxDeltaEllipticityI",true);
       aGUICmd->SetDefaultValue (0.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsDeltaEllipticityI.push_back(aGUICmd);
     }
   }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; 
       aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "CurrentMultipiler"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADouble* aGUICmd  = new G4UIcmdWithADouble(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "A magic current amplifier to increase/decrease the current for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxCurrentMultiplier",true);
       aGUICmd->SetDefaultValue (1.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsCurrentMultiplier.push_back(aGUICmd);
     }
    }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; 
       aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "CurrentEqualizerLongAbsLength"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADoubleAndUnit* aGUICmd  = new G4UIcmdWithADoubleAndUnit(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The charact. length of the decrease of the azimuthal anisotropy \n " 
         << " due imperfect current equal. section  for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxCurrentEqualizerLongAbsLength",true);
       aGUICmd->SetDefaultValue (100.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsCurrentEqualizerLongAbsLength.push_back(aGUICmd);
     }
    }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; 
       aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "CurrentEqualizerQuadAmpl"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADouble* aGUICmd  = new G4UIcmdWithADouble(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The amplitude of the azimuthal, quadrupolar, anisotropy \n "  
         << " due imperfect current equal. section  for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxCurrentEqualizerQuadAmpl",true);
       aGUICmd->SetDefaultValue (0.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsCurrentEqualizerQuadAmpl.push_back(aGUICmd);
     }
    }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; 
       aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "CurrentEqualizerOctAmpl"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithADouble* aGUICmd  = new G4UIcmdWithADouble(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The amplitude of the azimuthal, quadrupolar, anisotropy \n "  
         << " due imperfect current equal. section  for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxCurrentEqualizerOctAmpl",true);
       aGUICmd->SetDefaultValue (0.);
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetHornsCurrentEqualizerOctAmpl.push_back(aGUICmd);
     }
    }
   {
     for (size_t kH=0; kH != 3; kH++) { // We will work with only 3 horns. Per executive decision of Laura F.
       std::ostringstream aNStrStr; 
       aNStrStr << "/LBNE/det/SetHorn" << (kH+1) << "CurrentEqualizerMapFileName"; 
       std::string aNStr(aNStrStr.str());
       G4UIcmdWithAString* aGUICmd  = new G4UIcmdWithAString(aNStr.c_str(),this);
       std::ostringstream aNGStrStr; aNGStrStr 
         << "The file name for the field map created from a priot run, \n "  
         << " related to imperfect current equal. section  for Horn number " << (kH+1) << "\n."; 
       std::string aNGStr(aNGStrStr.str()); 
       aGUICmd->SetGuidance(aNGStr.c_str());
       aGUICmd->SetParameterName("SetHornxCurrentEqualizerFileName",true);
       aGUICmd->SetDefaultValue("?");
       aGUICmd->AvailableForStates(G4State_PreInit);
       SetFileNameFieldMapForCE.push_back(aGUICmd);
     }
    }
   {
   ZCoordForPerfectFocusing  = new G4UIcmdWithADoubleAndUnit("/LBNE/det/ZCoordForPerfectFocusing",this);
   std::string aGuidance("The Z-location at which the perfect focusing process set the track polar angle to zero \n ");
   aGuidance += std::string(" If this Z  is > 0. , we trigger the instantaneous foucing at this Z  \n");
   aGuidance += std::string(" else, Z < 0., we trigger the instantaneous foucing at the radius of Target Canister  \n");
   aGuidance += std::string(" which, for the LBNE 1.2 MW option is 17.6 mm  \n");
   ZCoordForPerfectFocusing->SetGuidance(aGuidance.c_str());
   ZCoordForPerfectFocusing->SetParameterName("ZCoordForPerfectFocusing", true);
   ZCoordForPerfectFocusing->SetDefaultUnit ("m");
   ZCoordForPerfectFocusing->SetUnitCandidates ("mm cm m");
   ZCoordForPerfectFocusing->SetDefaultValue (1.0e103);
   ZCoordForPerfectFocusing->AvailableForStates(G4State_PreInit);
   }
   /*   
   {
   ConstructLBNFNano = new G4UIcmdWithABool("/LBNF/det/ConstructLBNFNano",this); 
   ConstructLBNFNano->SetParameterName("ConstructLBNFNano", false);
   ConstructLBNFNano->SetGuidance("Neutrino Progenitor Spectrometer construction on/off"); 
   ConstructLBNFNano->SetParameterName("ConstructLBNFNano",true); 
   ConstructLBNFNano->AvailableForStates(G4State_PreInit,G4State_Idle);
   }
   */
}

LBNEDetectorMessenger::~LBNEDetectorMessenger

(

)

Definition at line 2277 of file LBNEDetectorConstruction.cc.

{

   delete detDir;
   delete LBNEDir;
   delete ConstructSimpAbsorber;
   delete ConstructSculptedAbsorber;
   delete DwStrAbsConcreteWidth;
   delete DwStrAbsSteelWidth;
   delete ConstructTarget;
   delete SetBeamlineAngle;
   delete UpdateCmd;
   delete ConstructCmd;
   delete SetHornCurrent;
   delete SetSkinDepthInnerRad;
   for (size_t kH=0; kH != 3; kH++) {
     delete SetHornsDeltaEccentricityIO[kH];
     delete SetHornsDeltaEllipticityI[kH];
     delete SetHornsCurrentEqualizerLongAbsLength[kH];
     delete SetHornsCurrentEqualizerQuadAmpl[kH];
     delete SetFileNameFieldMapForCE[kH];
     delete SetHornsCurrentEqualizerOctAmpl[kH];
     delete SetHornsCurrentMultiplier[kH];
   }
   delete ZCoordForPerfectFocusing;
   delete DisableSpoiler;
   delete DisableSculptedLayers;
   delete DisableMask;
   delete ExpandAlLayers;
   delete RemoveLayers;
}

Member Function Documentation

void LBNEDetectorMessenger::SetNewValue	(	G4UIcommand *	command,
		G4String	newValue
	)

Definition at line 2310 of file LBNEDetectorConstruction.cc.

{

   //Turn on and off simple geometry
   //Note: ConstructSimpAbsorber defined in LBNEDetectorMessemger.hh
   //      SetConstructSimpAbsorber and fConstructSimpAbsorber defined in LBNEDetectorConstruction.hh
   if ( command == ConstructSimpAbsorber ) 
     {
       LBNEDetector->SetConstructSimpAbsorber(ConstructSimpAbsorber->GetNewBoolValue(newValue));
     }
   
   if ( command == ConstructSculptedAbsorber ) 
     {
       LBNEDetector->SetConstructSculptedAbsorber(ConstructSculptedAbsorber->GetNewBoolValue(newValue));
     }

   if ( command == DisableSpoiler ) 
     {
       LBNEDetector->SetDisableSpoiler(DisableSpoiler->GetNewBoolValue(newValue));
     }
  
   if ( command == DisableSculptedLayers ) 
     {
       LBNEDetector->SetDisableSculptedLayers(DisableSculptedLayers->GetNewBoolValue(newValue));
     }

   if ( command == DisableMask )
     {
       LBNEDetector->SetDisableMask(DisableMask->GetNewBoolValue(newValue));  
     }   

   if ( command == ExpandAlLayers )
     {
       LBNEDetector->SetExpandAlLayers(ExpandAlLayers->GetNewBoolValue(newValue));
     }

   if ( command == RemoveLayers )
     {
       LBNEDetector->SetRemoveLayers(RemoveLayers->GetNewIntValue(newValue));
     }

   if ( command == DwStrAbsSteelWidth )
     {
       G4UIcmdWithADoubleAndUnit* cmdSteelDwStr = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
       LBNEDetector->SetDwStrAbsSteelWidth(cmdSteelDwStr->GetNewDoubleValue(newValue));  
       //G4double SteelWidth = LBNEDetector->GetDwStrAbsSteelWidth();
     }
 

    if ( command == DwStrAbsConcreteWidth)
     {
       G4UIcmdWithADoubleAndUnit* cmdConcreteDwStr = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
       LBNEDetector->SetDwStrAbsConcreteWidth(cmdConcreteDwStr->GetNewDoubleValue(newValue));
       // G4double ConcWidth = LBNEDetector->GetDwStrAbsConcreteWidth();
     }

  if ( command == UpdateCmd ) 
   {
      LBNEDetector->Construct();
      return;
   }
  if ( command == ConstructCmd ) 
   {
      LBNEDetector->Construct();
      return;
   }
   if (command == SetHornCurrent) {
     G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
     LBNEDetector->SetHornCurrent(cmdWD->GetNewDoubleValue(newValue));
   }
   if (command == SetSkinDepthInnerRad) {
     G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
     LBNEDetector->SetSkinDepthInnerRad(cmdWD->GetNewDoubleValue(newValue));
   }
   for (size_t kH=0; kH != 3; kH++) {
     if (command == SetHornsDeltaEccentricityIO[kH]) {
       G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
       LBNEDetector->SetDeltaEccentricityIO(kH, cmdWD->GetNewDoubleValue(newValue));
     }
     if (command == SetHornsDeltaEllipticityI[kH]) {
       G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
       LBNEDetector->SetDeltaEllipticityI(kH, cmdWD->GetNewDoubleValue(newValue));
     }
     if (command == SetHornsCurrentEqualizerLongAbsLength[kH]) {
       G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
       LBNEDetector->SetCurrentEqualizerLongAbsLength(kH, cmdWD->GetNewDoubleValue(newValue));
     }
     if (command == SetHornsCurrentEqualizerQuadAmpl[kH]) {
       G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
       LBNEDetector->SetCurrentEqualizerQuadAmpl(kH, cmdWD->GetNewDoubleValue(newValue));
     }
     if (command == SetFileNameFieldMapForCE[kH]) {
       LBNEDetector->SetFileNameFieldMapForCE(kH, newValue);
     }
     if (command == SetHornsCurrentEqualizerOctAmpl[kH]) {
       G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
       LBNEDetector->SetCurrentEqualizerOctAmpl(kH, cmdWD->GetNewDoubleValue(newValue));
     }
     if (command == SetHornsCurrentMultiplier[kH]) {
       G4UIcmdWithADouble* cmdWD = dynamic_cast<G4UIcmdWithADouble*> (command);
       LBNEDetector->SetCurrentMultipiler(kH, cmdWD->GetNewDoubleValue(newValue));
     }
   }
   if (command == ZCoordForPerfectFocusing) {
     G4UIcmdWithADoubleAndUnit* cmdWD = dynamic_cast<G4UIcmdWithADoubleAndUnit*> (command);
     double val = cmdWD->GetNewDoubleValue(newValue);
     LBNEDetector->SetZCoordForPerfectFocusing(val);
     if (val < 0.) {
       std::cout << " You have chosen a near perfect focus exiting the target Helium containment vessel " << std::endl;
       std::cout << " This only make sens if the real horn current is vanishlingly small.. " << std::endl;
       LBNEDetector->SetHornCurrent(2.0e-11);
       std::cout << " ...Done.. Also, Horn's conductors are made of air " << std::endl;
       LBNEVolumePlacements* volP=LBNEVolumePlacements::Instance();
       G4String matAir("Air");
       volP->SetHorn1InnerConductorMaterial(matAir);
       volP->SetHorn1AllConductorMaterial(matAir);
       volP->SetHorn2InnerConductorMaterial(matAir);
       volP->SetHorn2AllConductorMaterial(matAir);
     } else if (val > 22499.*CLHEP::mm) {
       std::cout << " You have chosen a near perfect focus entering the decay channel at Z =  " << val << std::endl;
     }
   }
   /*
   ** not yet deployed.. 
   **
   if (command == ConstructLBNFNano) {
      G4UIcmdWithABool* cmdWD = dynamic_cast<G4UIcmdWithABool*> (command);
       LBNEDetector->SetConstructLBNFNano(cmdWD->GetNewBoolValue(newValue));
   }
   */
}

Member Data Documentation

G4UIcmdWithoutParameter* LBNEDetectorMessenger::ConstructCmd

private

Definition at line 35 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::ConstructSculptedAbsorber

private

Definition at line 52 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::ConstructSimpAbsorber

private

Definition at line 51 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::ConstructTarget

private

Definition at line 31 of file LBNEDetectorMessenger.hh.

G4UIdirectory* LBNEDetectorMessenger::detDir

private

Definition at line 28 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::DisableMask

private

Definition at line 55 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::DisableSculptedLayers

private

Definition at line 54 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::DisableSpoiler

private

Definition at line 53 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::DwStrAbsConcreteWidth

private

Definition at line 60 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::DwStrAbsSteelWidth

private

Definition at line 59 of file LBNEDetectorMessenger.hh.

G4UIcmdWithABool* LBNEDetectorMessenger::ExpandAlLayers

private

Definition at line 56 of file LBNEDetectorMessenger.hh.

LBNEDetectorConstruction* LBNEDetectorMessenger::LBNEDetector

private

Definition at line 25 of file LBNEDetectorMessenger.hh.

G4UIdirectory* LBNEDetectorMessenger::LBNEDir

private

Definition at line 27 of file LBNEDetectorMessenger.hh.

G4UIcmdWithAnInteger* LBNEDetectorMessenger::RemoveLayers

private

Definition at line 57 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::SetBeamlineAngle

private

Definition at line 40 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithAString*> LBNEDetectorMessenger::SetFileNameFieldMapForCE

private

Definition at line 46 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::SetHornCurrent

private

Definition at line 41 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADoubleAndUnit*> LBNEDetectorMessenger::SetHornsCurrentEqualizerLongAbsLength

private

Definition at line 45 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADouble*> LBNEDetectorMessenger::SetHornsCurrentEqualizerOctAmpl

private

Definition at line 48 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADouble*> LBNEDetectorMessenger::SetHornsCurrentEqualizerQuadAmpl

private

Definition at line 47 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADouble*> LBNEDetectorMessenger::SetHornsCurrentMultiplier

private

Definition at line 49 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADoubleAndUnit*> LBNEDetectorMessenger::SetHornsDeltaEccentricityIO

private

Definition at line 43 of file LBNEDetectorMessenger.hh.

std::vector<G4UIcmdWithADoubleAndUnit*> LBNEDetectorMessenger::SetHornsDeltaEllipticityI

private

Definition at line 44 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::SetSkinDepthInnerRad

private

Definition at line 42 of file LBNEDetectorMessenger.hh.

G4UIcmdWithoutParameter* LBNEDetectorMessenger::UpdateCmd

private

Definition at line 34 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::WaterLayerThickInHorn

private

Definition at line 37 of file LBNEDetectorMessenger.hh.

G4UIcmdWithADoubleAndUnit* LBNEDetectorMessenger::ZCoordForPerfectFocusing

private

Definition at line 63 of file LBNEDetectorMessenger.hh.

---

The documentation for this class was generated from the following files:

• g4lbne/include/LBNEDetectorMessenger.hh
• g4lbne/src/LBNEDetectorConstruction.cc