Geant4 LXR

Cross-Referencing   Geant4
Geant4/examples/advanced/fastAerosol/src/FADetectorConstructionMessenger.cc

   //
   // ********************************************************************
   // * License and Disclaimer                                           *
   // *                                                                  *
   // * The  Geant4 software  is  copyright of the Copyright Holders  of *
   // * the Geant4 Collaboration.  It is provided  under  the terms  and *
   // * conditions of the Geant4 Software License,  included in the file *
   // * LICENSE and available at  http://cern.ch/geant4/license .  These *
   // * include a list of copyright holders.                             *
  // *                                                                  *
  // * Neither the authors of this software system, nor their employing *
  // * institutes,nor the agencies providing financial support for this *
  // * work  make  any representation or  warranty, express or implied, *
  // * regarding  this  software system or assume any liability for its *
  // * use.  Please see the license in the file  LICENSE  and URL above *
  // * for the full disclaimer and the limitation of liability.         *
  // *                                                                  *
  // * This  code  implementation is the result of  the  scientific and *
  // * technical work of the GEANT4 collaboration.                      *
  // * By using,  copying,  modifying or  distributing the software (or *
  // * any work based  on the software)  you  agree  to acknowledge its *
  // * use  in  resulting  scientific  publications,  and indicate your *
  // * acceptance of all terms of the Geant4 Software license.          *
  // ********************************************************************
  //
  
  // (adapted from B2aDetectorMessenger)
  // Author: A.Knaian (ara@nklabs.com), N.MacFadden (natemacfadden@gmail.com)
  
  #include "FADetectorConstructionMessenger.hh"
  #include "FADetectorConstruction.hh"
  
  #include "G4UIcmdWithAnInteger.hh"
  #include "G4UIcmdWithADoubleAndUnit.hh"
  #include "G4UIcmdWithADouble.hh"
  #include "G4UIcmdWithABool.hh"
  #include "G4UIcmdWithAString.hh"
  
  DetectorConstructionMessenger::DetectorConstructionMessenger(DetectorConstruction* detectorIn)
   : G4UImessenger()
  {
    fDetector = detectorIn;
  
    // Directory
    //
    // /geometry
    fGeometryDirectory = new G4UIdirectory("/geometry/");
    fGeometryDirectory->SetGuidance("Geometry setup.");
  
    // Physics
    //
    // /geometry/stepLim
    fStepLimCmd = new G4UIcmdWithADoubleAndUnit("/geometry/stepLim",this);
    fStepLimCmd->SetGuidance("Maximum step length.");
    fStepLimCmd->SetParameterName("stepLim",false);
    fStepLimCmd->SetRange("stepLim>=0.");
    fStepLimCmd->SetDefaultValue(DBL_MAX);
    fStepLimCmd->SetDefaultUnit("mm");
    fStepLimCmd->AvailableForStates(G4State_PreInit);
  
    // Cloud droplet settings
    // /geometry/dropletR
    fDropletRCmd = new G4UIcmdWithADoubleAndUnit("/geometry/dropletR",this);
    fDropletRCmd->SetGuidance("Minimal bounding radius of droplet.");
    fDropletRCmd->SetParameterName("dropletR",false);
    fDropletRCmd->SetRange("dropletR>0.");
    fDropletRCmd->SetDefaultValue(1.0);
    fDropletRCmd->SetDefaultUnit("mm");
    fDropletRCmd->AvailableForStates(G4State_PreInit);
  
    // /geometry/dropletNumDens     
    fDropletNumDensCmd = new G4UIcmdWithADouble("/geometry/dropletNumDens", this);
    fDropletNumDensCmd->SetGuidance("Number of droplets per mm^3.");        // would be nice to have official number density units
    fDropletNumDensCmd->SetParameterName("dropletCOunt",false);
    fDropletNumDensCmd->SetDefaultValue(0);
    fDropletNumDensCmd->AvailableForStates(G4State_PreInit);
  
    // Cloud build type
    //
    // /geometry/fastAerosol
    fFastAerosolCloudCmd = new G4UIcmdWithABool("/geometry/fastAerosolCloud",this);
    fFastAerosolCloudCmd->SetGuidance("Whether or not to build the fastAerosol cloud.");
    fFastAerosolCloudCmd->SetParameterName("fastAerosol",false);
    fFastAerosolCloudCmd->SetDefaultValue(false);
    fFastAerosolCloudCmd->AvailableForStates(G4State_PreInit);
  
    // /geometry/parameterisedCloud
    fParameterisedCloudCmd = new G4UIcmdWithABool("/geometry/parameterisedCloud",this);
    fParameterisedCloudCmd->SetGuidance("Whether or not to build the parameterised cloud.");
    fParameterisedCloudCmd->SetParameterName("parameterisedCloud",false);
    fParameterisedCloudCmd->SetDefaultValue(false);
    fParameterisedCloudCmd->AvailableForStates(G4State_PreInit);
  
    // /geometry/smoothCloud
    fSmoothCloudCmd = new G4UIcmdWithABool("/geometry/smoothCloud",this);
    fSmoothCloudCmd->SetGuidance("Whether or not to build the smooth cloud.");
    fSmoothCloudCmd->SetParameterName("smoothCloud",false);
    fSmoothCloudCmd->SetDefaultValue(false);
    fSmoothCloudCmd->AvailableForStates(G4State_PreInit);
 
   // fastAerosol cloud details
   //
   // /geometry/cloudShape
   fCloudShapeCmd = new G4UIcmdWithAString("/geometry/cloudShape",this);
   fCloudShapeCmd->SetGuidance("Cloud bulk shape");
   fCloudShapeCmd->SetParameterName("cloudShapeStr",false);
   fCloudShapeCmd->AvailableForStates(G4State_PreInit);
 
   // /geometry/dropletShape
   fDropletShapeCmd = new G4UIcmdWithAString("/geometry/dropletShape",this);
   fDropletShapeCmd->SetGuidance("Cloud droplet shape");
   fDropletShapeCmd->SetParameterName("dropletShapeStr",false);
   fDropletShapeCmd->AvailableForStates(G4State_PreInit);
 
   // /geometry/prePopulate
   fPrePopulateCmd = new G4UIcmdWithABool("/geometry/prePopulate",this);
   fPrePopulateCmd->SetGuidance("Whether or not to populate the cloud at the beginning.");
   fPrePopulateCmd->SetParameterName("prePopulate",false);
   fPrePopulateCmd->SetDefaultValue(false);
   fPrePopulateCmd->AvailableForStates(G4State_PreInit);
 
   // /geometry/minSpacing
   fMinSpacingCmd = new G4UIcmdWithADoubleAndUnit("/geometry/minSpacing",this);
   fMinSpacingCmd->SetGuidance("Minimum spacing between surfaces of spheres when generating random cloud of spheres.");
   fMinSpacingCmd->SetParameterName("minSpacing",false);
   fMinSpacingCmd->SetRange("minSpacing>0.");
   fMinSpacingCmd->SetDefaultValue(10.);
   fMinSpacingCmd->SetDefaultUnit("micrometer");
   fMinSpacingCmd->AvailableForStates(G4State_PreInit);
 
   // /geometry/setSmartless
   fSmartlessCmd = new G4UIcmdWithADouble("/geometry/smartless", this);
   fSmartlessCmd->SetGuidance("Set the 'smartless' parameter for the parameterised cloud.");
   fSmartlessCmd->SetParameterName("smartless",false);
   fSmartlessCmd->SetRange("smartless>0.");
   fSmartlessCmd->SetDefaultValue(2.0);
   fSmartlessCmd->AvailableForStates(G4State_PreInit);
 
   // /geometry/cloudSeed
   fCloudSeedCmd = new G4UIcmdWithAnInteger("/geometry/cloudSeed", this);
   fCloudSeedCmd->SetGuidance("Base of the random seed for the cloud sphere positions.");
   fCloudSeedCmd->SetParameterName("cloudSeed",false);
   fCloudSeedCmd->SetDefaultValue(0);
   fCloudSeedCmd->AvailableForStates(G4State_PreInit);
 }
 
 DetectorConstructionMessenger::~DetectorConstructionMessenger()
 {
   delete fGeometryDirectory;
 
   delete fStepLimCmd;
 
   delete fDropletRCmd;
   delete fDropletNumDensCmd;
 
   delete fFastAerosolCloudCmd;
   delete fParameterisedCloudCmd;
   delete fSmoothCloudCmd;
 
   delete fCloudShapeCmd;
   delete fDropletShapeCmd;
   delete fPrePopulateCmd;
   delete fMinSpacingCmd;
   //delete fGridPitchCmd;
 
   delete fSmartlessCmd;
 
   delete fCloudSeedCmd;
 }
 
 void DetectorConstructionMessenger::SetNewValue( G4UIcommand* command, G4String newValue)
 {
   // Geometry Commands
 
   if( command == fFastAerosolCloudCmd ) {
     fDetector->fFastAerosolCloud = (fFastAerosolCloudCmd->GetNewBoolValue(newValue));
   }
 
   if( command == fStepLimCmd ) {
     fDetector->fStepLim = (fStepLimCmd->GetNewDoubleValue(newValue));
   }
 
   if( command == fDropletRCmd ) {
     fDetector->fDropletR = (fDropletRCmd->GetNewDoubleValue(newValue));
   }
   if( command == fDropletNumDensCmd ) {
     fDetector->fDropletNumDens = (fDropletNumDensCmd->GetNewDoubleValue(newValue));
   }
 
   if( command == fParameterisedCloudCmd ) {
     fDetector->fParameterisedCloud = (fParameterisedCloudCmd->GetNewBoolValue(newValue));
   }
   if( command == fSmoothCloudCmd ) {
     fDetector->fSmoothCloud = (fSmoothCloudCmd->GetNewBoolValue(newValue));
   }
   if( command == fPrePopulateCmd ) {
     fDetector->fPrePopulate = (fPrePopulateCmd->GetNewBoolValue(newValue));
   }
 
   if( command == fCloudShapeCmd ) {
     fDetector->fCloudShapeStr = newValue;
   }
   if( command == fDropletShapeCmd ) {
     fDetector->fDropletShapeStr = newValue;
   }
   if( command == fMinSpacingCmd ) {
     fDetector->fMinSpacing = (fMinSpacingCmd->GetNewDoubleValue(newValue));
   }
   if( command == fSmartlessCmd ) {
     fDetector->fSmartless = (fSmartlessCmd->GetNewDoubleValue(newValue));
   }
   if( command == fCloudSeedCmd ) {
     fDetector->fCloudSeed = (fCloudSeedCmd->GetNewIntValue(newValue));
   }
 }