G4H3Messenger Class Reference

#include <G4H3Messenger.hh>

Inheritance diagram for G4H3Messenger:

Collaboration diagram for G4H3Messenger:

Public Member Functions
	G4H3Messenger (G4VAnalysisManager *manager)
virtual	~G4H3Messenger ()
virtual void	SetNewValue (G4UIcommand *command, G4String value) final
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Private Member Functions
void	CreateH3Cmd ()
void	SetH3Cmd ()

Private Attributes
G4VAnalysisManager *	fManager
	Associated class. More...
std::unique_ptr< G4AnalysisMessengerHelper >	fHelper
std::unique_ptr< G4UIdirectory >	fDirectory
std::unique_ptr< G4UIcommand >	fCreateH3Cmd
std::unique_ptr< G4UIcommand >	fSetH3Cmd
std::unique_ptr< G4UIcommand >	fSetH3XCmd
std::unique_ptr< G4UIcommand >	fSetH3YCmd
std::unique_ptr< G4UIcommand >	fSetH3ZCmd
std::unique_ptr< G4UIcommand >	fSetH3TitleCmd
std::unique_ptr< G4UIcommand >	fSetH3XAxisCmd
std::unique_ptr< G4UIcommand >	fSetH3YAxisCmd
std::unique_ptr< G4UIcommand >	fSetH3ZAxisCmd
G4int	fXId
G4int	fYId
G4AnalysisMessengerHelper::BinData	fXData
G4AnalysisMessengerHelper::BinData	fYData

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (G4String s)
G4double	StoD (G4String s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir
G4String	baseDirName
G4bool	commandsShouldBeInMaster

Detailed Description

Definition at line 46 of file G4H3Messenger.hh.

Constructor & Destructor Documentation

G4H3Messenger()

G4H3Messenger::G4H3Messenger ( G4VAnalysisManager *  manager )

explicit

Definition at line 43 of file G4H3Messenger.cc.

  : G4UImessenger(),
    fManager(manager),
    fHelper(nullptr),
    fDirectory(nullptr),
    fCreateH3Cmd(nullptr),
    fSetH3Cmd(nullptr),
    fSetH3XCmd(nullptr),
    fSetH3YCmd(nullptr),
    fSetH3ZCmd(nullptr),
    fSetH3TitleCmd(nullptr), 
    fSetH3XAxisCmd(nullptr), 
    fSetH3YAxisCmd(nullptr), 
    fSetH3ZAxisCmd(nullptr), 
    fXId(-1),
    fYId(-1),
    fXData(),
    fYData()
{  
  fHelper = G4Analysis::make_unique<G4AnalysisMessengerHelper>("h3");

  fDirectory = fHelper->CreateHnDirectory();

  CreateH3Cmd();

  SetH3Cmd();
  fSetH3XCmd = fHelper->CreateSetBinsCommand("x", this);
  fSetH3YCmd = fHelper->CreateSetBinsCommand("y", this);
  
  fSetH3TitleCmd = fHelper->CreateSetTitleCommand(this);
  fSetH3XAxisCmd = fHelper->CreateSetAxisCommand("x", this);
  fSetH3YAxisCmd = fHelper->CreateSetAxisCommand("y", this);
  fSetH3ZAxisCmd = fHelper->CreateSetAxisCommand("z", this);
}

Here is the call graph for this function:

~G4H3Messenger()

G4H3Messenger::~G4H3Messenger ( )

virtual

Definition at line 79 of file G4H3Messenger.cc.

{}

Member Function Documentation

CreateH3Cmd()

void G4H3Messenger::CreateH3Cmd ( )

private

Definition at line 87 of file G4H3Messenger.cc.

{
  auto h3Name = new G4UIparameter("name", 's', false);
  h3Name->SetGuidance("Histogram name (label)");
  
  auto h3Title = new G4UIparameter("title", 's', false);
  h3Title->SetGuidance("Histogram title");

  auto h3xNbins0 = new G4UIparameter("xnbins0", 'i', true);
  h3xNbins0->SetGuidance("Number of x-bins (default = 100)");
  h3xNbins0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3xNbins0->SetDefaultValue(100);
  
  auto h3xValMin0 = new G4UIparameter("xvalMin0", 'd', true);
  h3xValMin0->SetGuidance("Minimum x-value, expressed in unit (default = 0.)");
  h3xValMin0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3xValMin0->SetDefaultValue(0.);
  
  auto h3xValMax0 = new G4UIparameter("xvalMax0", 'd', true);
  h3xValMax0->SetGuidance("Maximum x-value, expressed in unit (default = 1.)");
  h3xValMax0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3xValMax0->SetDefaultValue(1.);

  auto h3xValUnit0 = new G4UIparameter("xvalUnit0", 's', true);
  h3xValUnit0->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
  h3xValUnit0->SetDefaultValue("none");
  
  auto h3xValFcn0 = new G4UIparameter("xvalFcn0", 's', true);
  G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
  h3xValFcn0->SetGuidance(fcnxGuidance);
  h3xValFcn0->SetParameterCandidates("log log10 exp none");
  h3xValFcn0->SetDefaultValue("none");
  
  auto h3xValBinScheme0 = new G4UIparameter("xvalBinScheme0", 's', true);
  G4String xbinSchemeGuidance = "The binning scheme (linear, log).";
  h3xValBinScheme0->SetParameterCandidates("linear log");
  h3xValBinScheme0->SetGuidance(xbinSchemeGuidance);
  h3xValBinScheme0->SetDefaultValue("linear");
  
  auto h3yNbins0 = new G4UIparameter("ynbins0", 'i', true);
  h3yNbins0->SetGuidance("Number of y-bins (default = 100)");
  h3yNbins0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3yNbins0->SetDefaultValue(100);
  
  auto h3yValMin0 = new G4UIparameter("yvalMin0", 'd', true);
  h3yValMin0->SetGuidance("Minimum y-value, expressed in unit (default = 0.)");
  h3yValMin0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3yValMin0->SetDefaultValue(0.);
  
  auto h3yValMax0 = new G4UIparameter("yvalMax0", 'd', true);
  h3yValMax0->SetGuidance("Maximum y-value, expressed in unit (default = 1.)");
  h3yValMax0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3yValMax0->SetDefaultValue(1.);

  auto h3yValUnit0 = new G4UIparameter("yvalUnit0", 's', true);
  h3yValUnit0->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
  h3yValUnit0->SetDefaultValue("none");
  
  auto h3yValFcn0 = new G4UIparameter("yvalFcn0", 's', true);
  G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
  h3yValFcn0->SetGuidance(fcnyGuidance);
  h3yValFcn0->SetParameterCandidates("log log10 exp none");
  h3yValFcn0->SetDefaultValue("none");

  auto h3yValBinScheme0 = new G4UIparameter("yvalBinScheme0", 's', true);
  G4String ybinSchemeGuidance = "The binning scheme (linear, log).";
  h3yValBinScheme0->SetParameterCandidates("linear log");
  h3yValBinScheme0->SetGuidance(ybinSchemeGuidance);
  h3yValBinScheme0->SetDefaultValue("linear");
  
  auto h3zNbins0 = new G4UIparameter("znbins0", 'i', true);
  h3zNbins0->SetGuidance("Number of z-bins (default = 100)");
  h3zNbins0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3zNbins0->SetDefaultValue(100);
  
  auto h3zValMin0 = new G4UIparameter("zvalMin0", 'd', true);
  h3zValMin0->SetGuidance("Minimum z-value, expressed in unit (default = 0.)");
  h3zValMin0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3zValMin0->SetDefaultValue(0.);
  
  auto h3zValMax0 = new G4UIparameter("zvalMax0", 'd', true);
  h3zValMax0->SetGuidance("Maximum z-value, expressed in unit (default = 1.)");
  h3zValMax0->SetGuidance("Can be reset with /analysis/h3/set command");
  h3zValMax0->SetDefaultValue(1.);

  auto h3zValUnit0 = new G4UIparameter("zvalUnit0", 's', true);
  h3zValUnit0->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
  h3zValUnit0->SetDefaultValue("none");
  
  auto h3zValFcn0 = new G4UIparameter("zvalFcn0", 's', true);
  G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
  h3zValFcn0->SetGuidance(fcnzGuidance);
  h3zValFcn0->SetParameterCandidates("log log10 exp none");
  h3zValFcn0->SetDefaultValue("none");

  auto h3zValBinScheme0 = new G4UIparameter("zvalBinScheme0", 's', true);
  G4String zbinSchemeGuidance = "The binning scheme (linear, log).";
  h3zValBinScheme0->SetParameterCandidates("linear log");
  h3zValBinScheme0->SetGuidance(zbinSchemeGuidance);
  h3zValBinScheme0->SetDefaultValue("linear");
  
  fCreateH3Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/h3/create", this);
  fCreateH3Cmd->SetGuidance("Create 3D histogram");
  fCreateH3Cmd->SetParameter(h3Name);
  fCreateH3Cmd->SetParameter(h3Title);
  fCreateH3Cmd->SetParameter(h3xNbins0);
  fCreateH3Cmd->SetParameter(h3xValMin0);
  fCreateH3Cmd->SetParameter(h3xValMax0);
  fCreateH3Cmd->SetParameter(h3xValUnit0);
  fCreateH3Cmd->SetParameter(h3xValFcn0);
  fCreateH3Cmd->SetParameter(h3xValBinScheme0);
  fCreateH3Cmd->SetParameter(h3yNbins0);
  fCreateH3Cmd->SetParameter(h3yValMin0);
  fCreateH3Cmd->SetParameter(h3yValMax0);
  fCreateH3Cmd->SetParameter(h3yValUnit0);
  fCreateH3Cmd->SetParameter(h3yValFcn0);
  fCreateH3Cmd->SetParameter(h3yValBinScheme0);
  fCreateH3Cmd->SetParameter(h3zNbins0);
  fCreateH3Cmd->SetParameter(h3zValMin0);
  fCreateH3Cmd->SetParameter(h3zValMax0);
  fCreateH3Cmd->SetParameter(h3zValUnit0);
  fCreateH3Cmd->SetParameter(h3zValFcn0);
  fCreateH3Cmd->SetParameter(h3zValBinScheme0);
  fCreateH3Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}  

Here is the caller graph for this function:

SetH3Cmd()

void G4H3Messenger::SetH3Cmd ( )

private

Definition at line 215 of file G4H3Messenger.cc.

{
  auto h3Id = new G4UIparameter("id", 'i', false);
  h3Id->SetGuidance("Histogram id");
  h3Id->SetParameterRange("id>=0");
  
  auto h3xNbins = new G4UIparameter("xnbins", 'i', false);
  h3xNbins->SetGuidance("Number of x-bins");
  
  auto h3xValMin = new G4UIparameter("xvalMin", 'd', false);
  h3xValMin->SetGuidance("Minimum x-value, expressed in unit");
  
  auto h3xValMax = new G4UIparameter("xvalMax", 'd', false);
  h3xValMax->SetGuidance("Maximum x-value, expressed in unit");
  
  auto h3xValUnit = new G4UIparameter("xvalUnit", 's', false);
  h3xValUnit->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
  h3xValUnit->SetDefaultValue("none");
 
  auto h3xValFcn = new G4UIparameter("xvalFcn", 's', false);
  h3xValFcn->SetParameterCandidates("log log10 exp none");
  G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
  h3xValFcn->SetGuidance(fcnxGuidance);
  h3xValFcn->SetDefaultValue("none");
 
  auto h3xValBinScheme = new G4UIparameter("xvalBinScheme", 's', true);
  G4String xbinSchemeGuidance = "The binning scheme (linear, log).";
  h3xValBinScheme->SetParameterCandidates("linear log");
  h3xValBinScheme->SetGuidance(xbinSchemeGuidance);
  h3xValBinScheme->SetDefaultValue("linear");
  
  auto h3yNbins = new G4UIparameter("nybins", 'i', false);
  h3yNbins->SetGuidance("Number of y-bins");
  
  auto h3yValMin = new G4UIparameter("yvalMin", 'd', false);
  h3yValMin->SetGuidance("Minimum y-value, expressed in unit");
  
  auto h3yValMax = new G4UIparameter("yvalMax", 'd', false);
  h3yValMax->SetGuidance("Maximum y-value, expressed in unit");
  
  auto h3yValUnit = new G4UIparameter("yvalUnit", 's', true);
  h3yValUnit->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
  h3yValUnit->SetDefaultValue("none");
 
  auto h3yValFcn = new G4UIparameter("yvalFcn", 's', false);
  h3yValFcn->SetParameterCandidates("log log10 exp none");
  G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
  h3yValFcn->SetGuidance(fcnyGuidance);
  h3yValFcn->SetDefaultValue("none");
 
  auto h3yValBinScheme = new G4UIparameter("yvalBinScheme", 's', true);
  G4String ybinSchemeGuidance = "The binning scheme (linear, log).";
  h3yValBinScheme->SetParameterCandidates("linear log");
  h3yValBinScheme->SetGuidance(ybinSchemeGuidance);
  h3yValBinScheme->SetDefaultValue("linear");
 
  auto h3zNbins = new G4UIparameter("nzbins", 'i', false);
  h3zNbins->SetGuidance("Number of z-bins");
  
  auto h3zValMin = new G4UIparameter("zvalMin", 'd', false);
  h3zValMin->SetGuidance("Minimum z-value, expressed in unit");
  
  auto h3zValMax = new G4UIparameter("zvalMax", 'd', false);
  h3zValMax->SetGuidance("Maximum z-value, expressed in unit");
  
  auto h3zValUnit = new G4UIparameter("zvalUnit", 's', true);
  h3zValUnit->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
  h3zValUnit->SetDefaultValue("none");
 
  auto h3zValFcn = new G4UIparameter("zvalFcn", 's', false);
  h3zValFcn->SetParameterCandidates("log log10 exp none");
  G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
  h3zValFcn->SetGuidance(fcnzGuidance);
  h3zValFcn->SetDefaultValue("none");
 
  auto h3zValBinScheme = new G4UIparameter("zvalBinScheme", 's', true);
  G4String zbinSchemeGuidance = "The binning scheme (linear, log).";
  h3zValBinScheme->SetParameterCandidates("linear log");
  h3zValBinScheme->SetGuidance(zbinSchemeGuidance);
  h3zValBinScheme->SetDefaultValue("linear");
 
  fSetH3Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/h3/set", this);
  fSetH3Cmd->SetGuidance("Set parameters for the 3D histogram of given id:");
  fSetH3Cmd->SetGuidance("  nxbins; xvalMin; xvalMax; xunit; xfunction; xbinScheme");
  fSetH3Cmd->SetGuidance("  nybins; yvalMin; yvalMax; yunit; yfunction; ybinScheme");
  fSetH3Cmd->SetGuidance("  nzbins; zvalMin; zvalMax; zunit; zfunction; zbinScheme");
  fSetH3Cmd->SetParameter(h3Id);
  fSetH3Cmd->SetParameter(h3xNbins);
  fSetH3Cmd->SetParameter(h3xValMin);
  fSetH3Cmd->SetParameter(h3xValMax);
  fSetH3Cmd->SetParameter(h3xValUnit);
  fSetH3Cmd->SetParameter(h3xValFcn);
  fSetH3Cmd->SetParameter(h3xValBinScheme);
  fSetH3Cmd->SetParameter(h3yNbins);
  fSetH3Cmd->SetParameter(h3yValMin);
  fSetH3Cmd->SetParameter(h3yValMax);
  fSetH3Cmd->SetParameter(h3yValUnit);
  fSetH3Cmd->SetParameter(h3yValFcn);
  fSetH3Cmd->SetParameter(h3yValBinScheme);
  fSetH3Cmd->SetParameter(h3zNbins);
  fSetH3Cmd->SetParameter(h3zValMin);
  fSetH3Cmd->SetParameter(h3zValMax);
  fSetH3Cmd->SetParameter(h3zValUnit);
  fSetH3Cmd->SetParameter(h3zValFcn);
  fSetH3Cmd->SetParameter(h3zValBinScheme);
  fSetH3Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}  

Here is the caller graph for this function:

SetNewValue()

void G4H3Messenger::SetNewValue ( G4UIcommand *  command, G4String  value  )

finalvirtual

Reimplemented from G4UImessenger.

Definition at line 329 of file G4H3Messenger.cc.

{
  // tokenize parameters in a vector
  std::vector<G4String> parameters;
  G4Analysis::Tokenize(newValues, parameters);
  // check consistency
  if ( G4int(parameters.size()) != command->GetParameterEntries() ) {
    // Should never happen but let's check anyway for consistency
    fHelper->WarnAboutParameters(command, parameters.size());
    return;
  }  

  if ( command == fCreateH3Cmd.get() ) {  
    auto counter = 0;
    auto name = parameters[counter++];
    auto title = parameters[counter++];
    G4AnalysisMessengerHelper::BinData xdata;
    fHelper->GetBinData(xdata, parameters, counter);
    auto xunit = GetUnitValue(xdata.fSunit);
    G4AnalysisMessengerHelper::BinData ydata;
    fHelper->GetBinData(ydata, parameters, counter);
    auto yunit = GetUnitValue(ydata.fSunit);
    G4AnalysisMessengerHelper::BinData zdata;
    fHelper->GetBinData(zdata, parameters, counter);
    auto zunit = GetUnitValue(zdata.fSunit);
    fManager->CreateH3(name, title, 
                       xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit, 
                       ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit, 
                       zdata.fNbins, zdata.fVmin*zunit, zdata.fVmax*zunit, 
                       xdata.fSunit, ydata.fSunit, zdata.fSunit,
                       xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
                       xdata.fSbinScheme, ydata.fSbinScheme, zdata.fSbinScheme);     
  }
  else if ( command == fSetH3Cmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
    G4AnalysisMessengerHelper::BinData xdata;
    fHelper->GetBinData(xdata, parameters, counter);
    auto xunit = GetUnitValue(xdata.fSunit);
    G4AnalysisMessengerHelper::BinData ydata;
    fHelper->GetBinData(ydata, parameters, counter);
    auto yunit = GetUnitValue(ydata.fSunit);
    G4AnalysisMessengerHelper::BinData zdata;
    fHelper->GetBinData(zdata, parameters, counter);
    auto zunit = GetUnitValue(zdata.fSunit);
    fManager->SetH3(id, 
                    xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit, 
                    ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit, 
                    zdata.fNbins, zdata.fVmin*zunit, zdata.fVmax*zunit, 
                    xdata.fSunit, ydata.fSunit, zdata.fSunit,
                    xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
                    xdata.fSbinScheme, ydata.fSbinScheme, zdata.fSbinScheme);     
  }
  else if ( command == fSetH3XCmd.get() ) { 
    // Only save values
    auto counter = 0;
    fXId = G4UIcommand::ConvertToInt(parameters[counter++]);
    fHelper->GetBinData(fXData, parameters, counter);
  }
  else if ( command == fSetH3YCmd.get() ) { 
    // Only save values
    auto counter = 0;
    fYId = G4UIcommand::ConvertToInt(parameters[counter++]);
    fHelper->GetBinData(fYData, parameters, counter);
  }
  else if ( command == fSetH3ZCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
    // Check if setX and setY command was called
    if ( fXId == -1 || fXId != id || 
         fYId == -1 || fYId != id ) {
      fHelper->WarnAboutSetCommands();
      return;
    }
    auto xunit = GetUnitValue(fXData.fSunit);
    auto yunit = GetUnitValue(fYData.fSunit);
    G4AnalysisMessengerHelper::BinData zdata;
    fHelper->GetBinData(zdata, parameters, counter);
    auto zunit = GetUnitValue(zdata.fSunit);
    fManager->SetH3(id, 
                    fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
                    fYData.fNbins, fYData.fVmin*yunit, fYData.fVmax*yunit,
                    zdata.fNbins, zdata.fVmin*zunit, zdata.fVmax*zunit, 
                    fXData.fSunit, fYData.fSunit, zdata.fSunit, 
                    fXData.fSfcn, fYData.fSfcn, zdata.fSfcn,
                    fXData.fSbinScheme, fYData.fSbinScheme, zdata.fSbinScheme);     
    fXId = -1;                        
    fYId = -1;                        
  }
  else if ( command == fSetH3TitleCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto title = parameters[counter++];
    fManager->SetH3Title(id, title);     
  }
  else if ( command == fSetH3XAxisCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto xaxis = parameters[counter++];
    fManager->SetH3XAxisTitle(id, xaxis);     
  }
  else if ( command == fSetH3YAxisCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto yaxis = parameters[counter++];
    fManager->SetH3YAxisTitle(id, yaxis);     
  }
  else if ( command == fSetH3ZAxisCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto zaxis = parameters[counter++];
    fManager->SetH3ZAxisTitle(id, zaxis);     
  }
}  

Here is the call graph for this function:

Member Data Documentation

fCreateH3Cmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fCreateH3Cmd

private

Definition at line 63 of file G4H3Messenger.hh.

fDirectory

std::unique_ptr<G4UIdirectory> G4H3Messenger::fDirectory

private

Definition at line 61 of file G4H3Messenger.hh.

fHelper

std::unique_ptr<G4AnalysisMessengerHelper> G4H3Messenger::fHelper

private

Definition at line 60 of file G4H3Messenger.hh.

fManager

G4VAnalysisManager* G4H3Messenger::fManager

private

Associated class.

Definition at line 59 of file G4H3Messenger.hh.

fSetH3Cmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3Cmd

private

Definition at line 64 of file G4H3Messenger.hh.

fSetH3TitleCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3TitleCmd

private

Definition at line 68 of file G4H3Messenger.hh.

fSetH3XAxisCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3XAxisCmd

private

Definition at line 69 of file G4H3Messenger.hh.

fSetH3XCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3XCmd

private

Definition at line 65 of file G4H3Messenger.hh.

fSetH3YAxisCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3YAxisCmd

private

Definition at line 70 of file G4H3Messenger.hh.

fSetH3YCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3YCmd

private

Definition at line 66 of file G4H3Messenger.hh.

fSetH3ZAxisCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3ZAxisCmd

private

Definition at line 71 of file G4H3Messenger.hh.

fSetH3ZCmd

std::unique_ptr<G4UIcommand> G4H3Messenger::fSetH3ZCmd

private

Definition at line 67 of file G4H3Messenger.hh.

fXData

G4AnalysisMessengerHelper::BinData G4H3Messenger::fXData

private

Definition at line 75 of file G4H3Messenger.hh.

fXId

G4int G4H3Messenger::fXId

private

Definition at line 73 of file G4H3Messenger.hh.

fYData

G4AnalysisMessengerHelper::BinData G4H3Messenger::fYData

private

Definition at line 76 of file G4H3Messenger.hh.

fYId

G4int G4H3Messenger::fYId

private

Definition at line 74 of file G4H3Messenger.hh.

---

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

• G4H3Messenger.hh
• G4H3Messenger.cc