G4P1Messenger Class Reference

#include <G4P1Messenger.hh>

Inheritance diagram for G4P1Messenger:

Collaboration diagram for G4P1Messenger:

Public Member Functions
	G4P1Messenger (G4VAnalysisManager *manager)
virtual	~G4P1Messenger ()
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	CreateP1Cmd ()
void	SetP1Cmd ()

Private Attributes
G4VAnalysisManager *	fManager
	Associated class. More...
std::unique_ptr< G4AnalysisMessengerHelper >	fHelper
std::unique_ptr< G4UIdirectory >	fDirectory
std::unique_ptr< G4UIcommand >	fCreateP1Cmd
std::unique_ptr< G4UIcommand >	fSetP1Cmd
std::unique_ptr< G4UIcommand >	fSetP1XCmd
std::unique_ptr< G4UIcommand >	fSetP1YCmd
std::unique_ptr< G4UIcommand >	fSetP1TitleCmd
std::unique_ptr< G4UIcommand >	fSetP1XAxisCmd
std::unique_ptr< G4UIcommand >	fSetP1YAxisCmd
G4int	fXId
G4AnalysisMessengerHelper::BinData	fXData

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 G4P1Messenger.hh.

Constructor & Destructor Documentation

G4P1Messenger()

G4P1Messenger::G4P1Messenger ( G4VAnalysisManager *  manager )

explicit

Definition at line 43 of file G4P1Messenger.cc.

  : G4UImessenger(),
    fManager(manager),
    fHelper(nullptr),
    fDirectory(nullptr),
    fCreateP1Cmd(nullptr),
    fSetP1Cmd(nullptr),
    fSetP1TitleCmd(nullptr), 
    fSetP1XAxisCmd(nullptr), 
    fSetP1YAxisCmd(nullptr),
    fXData()
{  
  fHelper = G4Analysis::make_unique<G4AnalysisMessengerHelper>("p1");

  fDirectory = fHelper->CreateHnDirectory();

  CreateP1Cmd();

  SetP1Cmd();
  fSetP1XCmd = fHelper->CreateSetBinsCommand("x", this);
  fSetP1YCmd = fHelper->CreateSetValuesCommand("y", this);
   
  fSetP1TitleCmd = fHelper->CreateSetTitleCommand(this);
  fSetP1XAxisCmd = fHelper->CreateSetAxisCommand("x", this);
  fSetP1YAxisCmd = fHelper->CreateSetAxisCommand("y", this);
}

Here is the call graph for this function:

~G4P1Messenger()

G4P1Messenger::~G4P1Messenger ( )

virtual

Definition at line 71 of file G4P1Messenger.cc.

{}

Member Function Documentation

CreateP1Cmd()

void G4P1Messenger::CreateP1Cmd ( )

private

Definition at line 79 of file G4P1Messenger.cc.

{
  auto p1Name = new G4UIparameter("name", 's', false);
  p1Name->SetGuidance("Profile name (label)");
  
  auto p1Title = new G4UIparameter("title", 's', false);
  p1Title->SetGuidance("Profile title");

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

  auto p1xValUnit0 = new G4UIparameter("xvalUnit0", 's', true);
  p1xValUnit0->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
  p1xValUnit0->SetDefaultValue("none");
  
  auto p1xValFcn0 = new G4UIparameter("xvalFcn0", 's', true);
  G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).\n";
  fcnxGuidance += "Note that the unit parameter cannot be omitted in this case,\n";
  fcnxGuidance += "but none value should be used insted.";
  p1xValFcn0->SetGuidance(fcnxGuidance);
  p1xValFcn0->SetParameterCandidates("log log10 exp none");
  p1xValFcn0->SetDefaultValue("none");
    
  auto p1xValBinScheme0 = new G4UIparameter("xvalBinScheme0", 's', true);
  G4String binSchemeGuidance = "The binning scheme (linear, log).\n";
  p1xValBinScheme0->SetParameterCandidates("linear log");
  binSchemeGuidance 
    += "Note that the unit and fcn parameters cannot be omitted in this case,\n";
  binSchemeGuidance += "but none value should be used insted.";
  p1xValBinScheme0->SetGuidance(binSchemeGuidance);
  p1xValBinScheme0->SetDefaultValue("linear");
  
  auto p1yValMin0 = new G4UIparameter("yvalMin0", 'd', true);
  p1yValMin0->SetGuidance("Minimum y-value, expressed in unit (default = 0.)");
  p1yValMin0->SetGuidance("Can be reset with /analysis/p1/set command");
  p1yValMin0->SetDefaultValue(0.);
  
  auto p1yValMax0 = new G4UIparameter("yvalMax0", 'd', true);
  p1yValMax0->SetGuidance("Maximum y-value, expressed in unit (default = 1.)");
  p1yValMax0->SetGuidance("Can be reset with /analysis/p1/set command");
  p1yValMax0->SetDefaultValue(1.);

  auto p1yValUnit0 = new G4UIparameter("yvalUnit0", 's', true);
  p1yValUnit0->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
  p1yValUnit0->SetDefaultValue("none");
  
  auto p1yValFcn0 = new G4UIparameter("yvalFcn0", 's', true);
  G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).\n";
  fcnyGuidance += "Note that the unit parameter cannot be omitted in this case,\n";
  fcnyGuidance += "but none value should be used insted.";
  p1yValFcn0->SetGuidance(fcnyGuidance);
  p1yValFcn0->SetParameterCandidates("log log10 exp none");
  p1yValFcn0->SetDefaultValue("none");
  
  fCreateP1Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/p1/create", this);
  fCreateP1Cmd->SetGuidance("Create 1D profile");
  fCreateP1Cmd->SetParameter(p1Name);
  fCreateP1Cmd->SetParameter(p1Title);
  fCreateP1Cmd->SetParameter(p1xNbins0);
  fCreateP1Cmd->SetParameter(p1xValMin0);
  fCreateP1Cmd->SetParameter(p1xValMax0);
  fCreateP1Cmd->SetParameter(p1xValUnit0);
  fCreateP1Cmd->SetParameter(p1xValFcn0);
  fCreateP1Cmd->SetParameter(p1xValBinScheme0);
  fCreateP1Cmd->SetParameter(p1yValMin0);
  fCreateP1Cmd->SetParameter(p1yValMax0);
  fCreateP1Cmd->SetParameter(p1yValUnit0);
  fCreateP1Cmd->SetParameter(p1yValFcn0);
  fCreateP1Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}  

Here is the caller graph for this function:

SetNewValue()

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

finalvirtual

Reimplemented from G4UImessenger.

Definition at line 241 of file G4P1Messenger.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 == fCreateP1Cmd.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::ValueData ydata;
    fHelper->GetValueData(ydata, parameters, counter);
    auto yunit = GetUnitValue(ydata.fSunit);
    fManager->CreateP1(name, title, 
                       xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit, 
                       ydata.fVmin*yunit, ydata.fVmax*yunit, 
                       xdata.fSunit, ydata.fSunit, 
                       xdata.fSfcn, ydata.fSfcn, 
                       xdata.fSbinScheme);     
  }
  else if ( command == fSetP1Cmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
    G4AnalysisMessengerHelper::BinData xdata;
    fHelper->GetBinData(xdata, parameters, counter);
    auto xunit = GetUnitValue(xdata.fSunit);
    G4AnalysisMessengerHelper::ValueData ydata;
    fHelper->GetValueData(ydata, parameters, counter);
    auto yunit = GetUnitValue(ydata.fSunit);
    fManager->SetP1(id, 
                    xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit, 
                    ydata.fVmin*yunit, ydata.fVmax*yunit, 
                    xdata.fSunit, ydata.fSunit, 
                    xdata.fSfcn, ydata.fSfcn, 
                    xdata.fSbinScheme);     
  }
  else if ( command == fSetP1XCmd.get() ) { 
    // Only save values
    auto counter = 0;
    fXId = G4UIcommand::ConvertToInt(parameters[counter++]);
    fHelper->GetBinData(fXData, parameters, counter);
  }
  else if ( command == fSetP1YCmd.get() ) { 
    // Check if setX command was called
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
    if ( fXId == -1 || fXId != id ) {
      // add exception
      return;
    }
    auto xunit = GetUnitValue(fXData.fSunit);
    G4AnalysisMessengerHelper::ValueData ydata;
    fHelper->GetValueData(ydata, parameters, counter);
    auto yunit = GetUnitValue(ydata.fSunit);
    fManager->SetP1(id, 
                    fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
                    ydata.fVmin*yunit, ydata.fVmax*yunit, 
                    fXData.fSunit, ydata.fSunit, 
                    fXData.fSfcn, ydata.fSfcn, 
                    fXData.fSbinScheme);     
    fXId = -1;                        
  }
  else if ( command == fSetP1TitleCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto title = parameters[counter++];
    fManager->SetP1Title(id, title);     
  }
  else if ( command == fSetP1XAxisCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto xaxis = parameters[counter++];
    fManager->SetP1XAxisTitle(id, xaxis);     
  }
  else if ( command == fSetP1YAxisCmd.get() ) { 
    auto counter = 0;
    auto id = G4UIcommand::ConvertToInt(parameters[counter++]); 
    auto yaxis = parameters[counter++];
    fManager->SetP1YAxisTitle(id, yaxis);     
  }
}  

Here is the call graph for this function:

SetP1Cmd()

void G4P1Messenger::SetP1Cmd ( )

private

Definition at line 164 of file G4P1Messenger.cc.

{
  auto p1Id = new G4UIparameter("id", 'i', false);
  p1Id->SetGuidance("Profile id");
  p1Id->SetParameterRange("id>=0");
  
  auto p1xNbins = new G4UIparameter("xnbins", 'i', false);
  p1xNbins->SetGuidance("Number of x-bins");
  
  auto p1xValMin = new G4UIparameter("xvalMin", 'd', false);
  p1xValMin->SetGuidance("Minimum x-value, expressed in unit");
  
  auto p1xValMax = new G4UIparameter("xvalMax", 'd', false);
  p1xValMax->SetGuidance("Maximum x-value, expressed in unit");
  
  auto p1xValUnit = new G4UIparameter("xvalUnit", 's', false);
  p1xValUnit->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
  p1xValUnit->SetDefaultValue("none");
 
  auto p1xValFcn = new G4UIparameter("xvalFcn", 's', false);
  p1xValFcn->SetParameterCandidates("log log10 exp none");
  G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).\n";
  fcnxGuidance += "Note that the unit parameter cannot be omitted in this case,\n";
  fcnxGuidance += "but none value should be used insted.";
  p1xValFcn->SetGuidance(fcnxGuidance);
  p1xValFcn->SetDefaultValue("none");
 
  auto p1xValBinScheme = new G4UIparameter("xvalBinScheme", 's', true);
  G4String binSchemeGuidance = "The binning scheme (linear, log).\n";
  p1xValBinScheme->SetParameterCandidates("linear log");
  binSchemeGuidance 
    += "Note that the unit and fcn parameters cannot be omitted in this case,\n";
  binSchemeGuidance += "but none value should be used insted.";
  p1xValBinScheme->SetGuidance(binSchemeGuidance);
  p1xValBinScheme->SetDefaultValue("linear");
  
  auto p1yValMin = new G4UIparameter("yvalMin", 'd', false);
  p1yValMin->SetGuidance("Minimum y-value, expressed in unit");
  
  auto p1yValMax = new G4UIparameter("yvalMax", 'd', false);
  p1yValMax->SetGuidance("Maximum y-value, expressed in unit");
  
  auto p1yValUnit = new G4UIparameter("yvalUnit", 's', true);
  p1yValUnit->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
  p1yValUnit->SetDefaultValue("none");
 
  auto p1yValFcn = new G4UIparameter("yvalFcn", 's', false);
  p1yValFcn->SetParameterCandidates("log log10 exp none");
  G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).\n";
  fcnyGuidance += "Note that the unit parameter cannot be omitted in this case,\n";
  fcnyGuidance += "but none value should be used insted.";
  p1yValFcn->SetGuidance(fcnyGuidance);
  p1yValFcn->SetDefaultValue("none");
 
  fSetP1Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/p1/set", this);
  fSetP1Cmd->SetGuidance("Set parameters for the 1D profile of given id:");
  fSetP1Cmd->SetGuidance("  nbins; xvalMin; xvalMax; xunit; xfunction; xbinScheme");
  fSetP1Cmd->SetGuidance("  yvalMin; yvalMax; yunit; yfunction");
  fSetP1Cmd->SetParameter(p1Id);
  fSetP1Cmd->SetParameter(p1xNbins);
  fSetP1Cmd->SetParameter(p1xValMin);
  fSetP1Cmd->SetParameter(p1xValMax);
  fSetP1Cmd->SetParameter(p1xValUnit);
  fSetP1Cmd->SetParameter(p1xValFcn);
  fSetP1Cmd->SetParameter(p1xValBinScheme);
  fSetP1Cmd->SetParameter(p1yValMin);
  fSetP1Cmd->SetParameter(p1yValMax);
  fSetP1Cmd->SetParameter(p1yValUnit);
  fSetP1Cmd->SetParameter(p1yValFcn);
  fSetP1Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}  

Here is the caller graph for this function:

Member Data Documentation

fCreateP1Cmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fCreateP1Cmd

private

Definition at line 63 of file G4P1Messenger.hh.

fDirectory

std::unique_ptr<G4UIdirectory> G4P1Messenger::fDirectory

private

Definition at line 61 of file G4P1Messenger.hh.

fHelper

std::unique_ptr<G4AnalysisMessengerHelper> G4P1Messenger::fHelper

private

Definition at line 60 of file G4P1Messenger.hh.

fManager

G4VAnalysisManager* G4P1Messenger::fManager

private

Associated class.

Definition at line 59 of file G4P1Messenger.hh.

fSetP1Cmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1Cmd

private

Definition at line 64 of file G4P1Messenger.hh.

fSetP1TitleCmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1TitleCmd

private

Definition at line 67 of file G4P1Messenger.hh.

fSetP1XAxisCmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1XAxisCmd

private

Definition at line 68 of file G4P1Messenger.hh.

fSetP1XCmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1XCmd

private

Definition at line 65 of file G4P1Messenger.hh.

fSetP1YAxisCmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1YAxisCmd

private

Definition at line 69 of file G4P1Messenger.hh.

fSetP1YCmd

std::unique_ptr<G4UIcommand> G4P1Messenger::fSetP1YCmd

private

Definition at line 66 of file G4P1Messenger.hh.

fXData

G4AnalysisMessengerHelper::BinData G4P1Messenger::fXData

private

Definition at line 72 of file G4P1Messenger.hh.

fXId

G4int G4P1Messenger::fXId

private

Definition at line 71 of file G4P1Messenger.hh.

---

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

• G4P1Messenger.hh
• G4P1Messenger.cc