Gabriele Cosmo
612 lines
17 KiB
C++
612 lines
17 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
// $Id: G4ModelCommandsT.hh,v 1.7 2006/06/29 21:30:24 gunter Exp $
|
|
// GEANT4 tag $Name: geant4-08-01 $
|
|
//
|
|
// Generic model messenges.
|
|
//
|
|
// Jane Tinslay March 2006
|
|
//
|
|
#ifndef G4MODELCOMMANDST_HH
|
|
#define G4MODELCOMMANDST_HH
|
|
|
|
#include "G4ModelApplyCommandsT.hh"
|
|
#include "G4Polymarker.hh"
|
|
#include "G4UIdirectory.hh"
|
|
#include <sstream>
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set parameter colour
|
|
template <typename M>
|
|
class G4ModelCmdSetStringColour : public G4ModelCmdApplyStringColour<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdSetStringColour(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyStringColour<M>(model, placement, "set") {}
|
|
|
|
virtual ~G4ModelCmdSetStringColour() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4String& param, const G4Colour& colour) {
|
|
G4VModelCommand<M>::Model()->Set(param, colour);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set default colour
|
|
template <typename M>
|
|
class G4ModelCmdSetDefaultColour : public G4ModelCmdApplyColour<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdSetDefaultColour(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyColour<M>(model, placement, "setDefault") {}
|
|
|
|
virtual ~G4ModelCmdSetDefaultColour() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4Colour& colour) {
|
|
G4VModelCommand<M>::Model()->SetDefault(colour);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Add string command
|
|
template <typename M>
|
|
class G4ModelCmdAddString : public G4ModelCmdApplyString<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdAddString(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyString<M>(model, placement, "add")
|
|
{
|
|
G4ModelCmdApplyString<M>::Command()->SetGuidance("Add command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdAddString() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4String& newValue) {
|
|
G4VModelCommand<M>::Model()->Add(newValue);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//Add integer command
|
|
template <typename M>
|
|
class G4ModelCmdAddInt : public G4ModelCmdApplyInteger<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdAddInt(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyInteger<M>(model, placement, "add")
|
|
{
|
|
G4ModelCmdApplyInteger<M>::Command()->SetGuidance("Add command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdAddInt() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4int& newValue) {
|
|
G4VModelCommand<M>::Model()->Add(newValue);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Invert command
|
|
template <typename M>
|
|
class G4ModelCmdInvert : public G4ModelCmdApplyBool<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdInvert(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "invert")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Invert command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdInvert() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4bool& newValue) {
|
|
G4VModelCommand<M>::Model()->SetInvert(newValue);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Active command
|
|
template <typename M>
|
|
class G4ModelCmdActive : public G4ModelCmdApplyBool<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdActive(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "active")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Active command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdActive() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4bool& newValue) {
|
|
G4VModelCommand<M>::Model()->SetActive(newValue);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Verbose command
|
|
template <typename M>
|
|
class G4ModelCmdVerbose : public G4ModelCmdApplyBool<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdVerbose(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "verbose")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Verbose command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdVerbose() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply(const G4bool& newValue) {
|
|
G4VModelCommand<M>::Model()->SetVerbose(newValue);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Reset command
|
|
template <typename M>
|
|
class G4ModelCmdReset : public G4ModelCmdApplyNull<M> {
|
|
|
|
public: // With description
|
|
|
|
G4ModelCmdReset(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyNull<M>(model, placement, "reset")
|
|
{
|
|
G4ModelCmdApplyNull<M>::Command()->SetGuidance("Reset command");
|
|
}
|
|
|
|
virtual ~G4ModelCmdReset() {}
|
|
|
|
protected:
|
|
|
|
virtual void Apply() {
|
|
G4VModelCommand<M>::Model()->Reset();
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set auxiliary points colour command
|
|
template <typename M>
|
|
class G4ModelCmdSetAuxPtsColour : public G4ModelCmdApplyColour<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetAuxPtsColour(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyColour<M>(model, placement, "setAuxPtsColour") {}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4Colour& colour) {
|
|
G4VModelCommand<M>::Model()->SetAuxPtsColour(colour);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set set points colour command
|
|
template <typename M>
|
|
class G4ModelCmdSetStepPtsColour : public G4ModelCmdApplyColour<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetStepPtsColour(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyColour<M>(model, placement, "setStepPtsColour") {}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4Colour& colour) {
|
|
G4VModelCommand<M>::Model()->SetStepPtsColour(colour);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set draw line command
|
|
template <typename M>
|
|
class G4ModelCmdSetDrawLine : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetDrawLine(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setDrawLine")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw line command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetDrawLine(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set line visibility command
|
|
template <typename M>
|
|
class G4ModelCmdSetLineVisible : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetLineVisible(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setLineVisible")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set line visibility command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetLineVisible(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set draw auxiliary points command
|
|
template <typename M>
|
|
class G4ModelCmdSetDrawAuxPts : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetDrawAuxPts(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setDrawAuxPts")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw auxiliary points command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetDrawAuxPts(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set auxiliary points visibility
|
|
template <typename M>
|
|
class G4ModelCmdSetAuxPtsVisible : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetAuxPtsVisible(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setAuxPtsVisible")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set auxiliary points visibility command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetAuxPtsVisible(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set draw step points command
|
|
template <typename M>
|
|
class G4ModelCmdSetDrawStepPts : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetDrawStepPts(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setDrawStepPts")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw step points command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetDrawStepPts(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set step points visible command
|
|
template <typename M>
|
|
class G4ModelCmdSetStepPtsVisible : public G4ModelCmdApplyBool<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetStepPtsVisible(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyBool<M>(model, placement, "setStepPtsVisible")
|
|
{
|
|
G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set step points colour command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4bool& myBool) {
|
|
G4VModelCommand<M>::Model()->SetStepPtsVisible(myBool);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set auxiliary points size command
|
|
template <typename M>
|
|
class G4ModelCmdSetAuxPtsSize : public G4ModelCmdApplyDouble<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetAuxPtsSize(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyDouble<M>(model, placement, "setAuxPtsSize")
|
|
{
|
|
G4ModelCmdApplyDouble<M>::Command()->SetGuidance("Set auxiliary points size command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4double& myDouble) {
|
|
G4VModelCommand<M>::Model()->SetAuxPtsSize(myDouble);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set step points size command
|
|
template <typename M>
|
|
class G4ModelCmdSetStepPtsSize : public G4ModelCmdApplyDouble<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetStepPtsSize(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyDouble<M>(model, placement, "setStepPtsSize")
|
|
{
|
|
G4ModelCmdApplyDouble<M>::Command()->SetGuidance("Set step points colour command");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4double& myDouble) {
|
|
G4VModelCommand<M>::Model()->SetStepPtsSize(myDouble);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set step points type command
|
|
template <typename M>
|
|
class G4ModelCmdSetStepPtsType : public G4ModelCmdApplyString<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetStepPtsType(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyString<M>(model, placement, "setStepPtsType")
|
|
{
|
|
G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
|
|
cmd->SetGuidance("Set step points type.");
|
|
cmd->SetCandidates("dots circles squares");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4String& type) {
|
|
G4Polymarker::MarkerType myType;
|
|
|
|
if (type == "dots") {myType = G4Polymarker::dots;}
|
|
else if (type == "circles") {myType = G4Polymarker::circles;}
|
|
else if (type == "squares") {myType = G4Polymarker::squares;}
|
|
else {
|
|
std::ostringstream o;
|
|
o << "Invalid argument. See command guidance for options.";
|
|
G4Exception
|
|
("G4ModelCmdSetStepPtsType::Apply",
|
|
"InvalidArgument", JustWarning, o.str().c_str());
|
|
return;
|
|
}
|
|
G4VModelCommand<M>::Model()->SetStepPtsType(myType);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set auxiliary points type command
|
|
template <typename M>
|
|
class G4ModelCmdSetAuxPtsType : public G4ModelCmdApplyString<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetAuxPtsType(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyString<M>(model, placement, "setAuxPtsType")
|
|
{
|
|
G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
|
|
|
|
cmd->SetGuidance("Set auxiliary points type.");
|
|
cmd->SetCandidates("dots circles squares");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4String& type) {
|
|
G4Polymarker::MarkerType myType;
|
|
|
|
if (type == "dots") {myType = G4Polymarker::dots;}
|
|
else if (type == "circles") {myType = G4Polymarker::circles;}
|
|
else if (type == "squares") {myType = G4Polymarker::squares;}
|
|
else {
|
|
std::ostringstream o;
|
|
o << "Invalid argument. See command guidance for options.";
|
|
G4Exception
|
|
("G4ModelCmdSetAuxPtsType::Apply",
|
|
"InvalidArgument", JustWarning, o.str().c_str());
|
|
return;
|
|
}
|
|
|
|
G4VModelCommand<M>::Model()->SetAuxPtsType(myType);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set step points fill style command
|
|
template <typename M>
|
|
class G4ModelCmdSetStepPtsFillStyle : public G4ModelCmdApplyString<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetStepPtsFillStyle(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyString<M>(model, placement, "setStepPtsFillStyle")
|
|
{
|
|
G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
|
|
cmd->SetGuidance("Set step fill style type.");
|
|
cmd->SetCandidates("noFill hashed filled");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4String& type) {
|
|
G4VMarker::FillStyle myFillStyle;
|
|
|
|
if (type == "noFill") {myFillStyle = G4VMarker::noFill;}
|
|
else if (type == "hashed") {myFillStyle = G4VMarker::hashed;}
|
|
else if (type == "filled") {myFillStyle = G4VMarker::filled;}
|
|
else {
|
|
std::ostringstream o;
|
|
o << "Invalid argument. See command guidance for options.";
|
|
G4Exception
|
|
("G4ModelCmdSetStepPtsFillStyle::Apply",
|
|
"InvalidArgument", JustWarning, o.str().c_str());
|
|
return;
|
|
}
|
|
G4VModelCommand<M>::Model()->SetStepPtsFillStyle(myFillStyle);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Set auxiliary points fill style command
|
|
template <typename M>
|
|
class G4ModelCmdSetAuxPtsFillStyle : public G4ModelCmdApplyString<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetAuxPtsFillStyle(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyString<M>(model, placement, "setAuxPtsFillStyle")
|
|
{
|
|
G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
|
|
cmd->SetGuidance("Set auxiliary fill style.");
|
|
cmd->SetCandidates("noFill hashed filled");
|
|
}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4String& type) {
|
|
G4VMarker::FillStyle myFillStyle;
|
|
|
|
if (type == "noFill") {myFillStyle = G4VMarker::noFill;}
|
|
else if (type == "hashed") {myFillStyle = G4VMarker::hashed;}
|
|
else if (type == "filled") {myFillStyle = G4VMarker::filled;}
|
|
else {
|
|
std::ostringstream o;
|
|
o << "Invalid argument. See command guidance for options.";
|
|
G4Exception
|
|
("G4ModelCmdSetAuxPtsFillStyle::Apply",
|
|
"InvalidArgument", JustWarning, o.str().c_str());
|
|
return;
|
|
}
|
|
G4VModelCommand<M>::Model()->SetAuxPtsFillStyle(myFillStyle);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// SetLineColour command
|
|
template <typename M>
|
|
class G4ModelCmdSetLineColour : public G4ModelCmdApplyColour<M> {
|
|
|
|
public:
|
|
|
|
G4ModelCmdSetLineColour(M* model, const G4String& placement)
|
|
:G4ModelCmdApplyColour<M>(model, placement, "setLineColour") {}
|
|
|
|
protected:
|
|
|
|
void Apply(const G4Colour& colour) {
|
|
G4VModelCommand<M>::Model()->SetLineColour(colour);
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Create context directory command
|
|
template <typename M>
|
|
class G4ModelCmdCreateContextDir : public G4UImessenger {
|
|
|
|
public:
|
|
|
|
G4ModelCmdCreateContextDir(M* model, const G4String& placement) {
|
|
G4String title = placement+"/"+model->Name()+"/";
|
|
cmd = new G4UIdirectory(title);
|
|
|
|
cmd->SetGuidance("Commands for default configuration");
|
|
}
|
|
|
|
virtual ~G4ModelCmdCreateContextDir() {
|
|
delete cmd;
|
|
}
|
|
|
|
protected:
|
|
|
|
G4UIdirectory* cmd;
|
|
|
|
};
|
|
#endif
|
|
|