G4ModelCommandsT.hh

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
//
// 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, 
                const G4String& cmdName="set")
    :G4ModelCmdApplyStringColour<M>(model, placement, cmdName) {}
  
  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, 
                 const G4String& cmdName="setDefault")
    :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
  
  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,
              const G4String& cmdName="add")
    :G4ModelCmdApplyString<M>(model, placement, cmdName) 
  {
    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,
           const G4String& cmdName="add")
  :G4ModelCmdApplyInteger<M>(model, placement, cmdName)
  {
    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,
           const G4String& cmdName="invert")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
           const G4String& cmdName="active")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
            const G4String& cmdName="verbose")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
                const G4String& cmdName="reset") 
    :G4ModelCmdApplyNull<M>(model, placement, cmdName)
  {
    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,
                const G4String& cmdName="setAuxPtsColour") 
    :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
 
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,
                 const G4String& cmdName="setStepPtsColour")
    :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
 
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,
            const G4String& cmdName="setDrawLine")    
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
               const G4String& cmdName="setLineVisible") 
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
              const G4String& cmdName="setDrawAuxPts")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
                 const G4String& cmdName="setAuxPtsVisible")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
               const G4String& cmdName="setDrawStepPts")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    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,
                  const G4String& cmdName="setStepPtsVisible")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set step points visible command");
  }
  
protected:
 
   void Apply(const G4bool& myBool) {
     G4VModelCommand<M>::Model()->SetStepPtsVisible(myBool);
  }
  
};
 
// Set auxiliary points size command
template <typename M>
class G4ModelCmdSetAuxPtsSize : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetAuxPtsSize(M* model, const G4String& placement,
               const G4String& cmdName="setAuxPtsSize")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    G4ModelCmdApplyString<M>::Command()->SetGuidance("Set auxiliary points size command");
  }
  
protected:
 
   void Apply(const G4String& sizeString) {
     std::istringstream iss(sizeString);
     G4double size;
     G4String unit;
     iss >> size >> unit;
     if (G4VModelCommand<M>::Model()->GetAuxPtsSizeType() == G4VMarker::world)
       {
     G4double myDouble = G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(sizeString);
     G4VModelCommand<M>::Model()->SetAuxPtsSize(myDouble);
       }
     else  // none or screen
       {
     G4VModelCommand<M>::Model()->SetAuxPtsSize(size);
       }
   }
  
};
 
// Set step points size command
template <typename M>
class G4ModelCmdSetStepPtsSize : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetStepPtsSize(M* model, const G4String& placement,
               const G4String& cmdName="setStepPtsSize")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    G4ModelCmdApplyString<M>::Command()->SetGuidance("Set step points size command");
  }
  
protected:
 
   void Apply(const G4String& sizeString) {
     std::istringstream iss(sizeString);
     G4double size;
     G4String unit;
     iss >> size >> unit;
     if (G4VModelCommand<M>::Model()->GetStepPtsSizeType() == G4VMarker::world)
       {
     G4double myDouble = G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(sizeString);
     G4VModelCommand<M>::Model()->SetStepPtsSize(myDouble);
       }
     else  // none or screen
       {
     G4VModelCommand<M>::Model()->SetStepPtsSize(size);
       }
   }
  
};
 
// Set step points type command
template <typename M>
class G4ModelCmdSetStepPtsType : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetStepPtsType(M* model, const G4String& placement,
               const G4String& cmdName="setStepPtsType")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    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 {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetStepPtsType::Apply",
     "modeling0109", JustWarning, ed);
      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,
              const G4String& cmdName="setAuxPtsType")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    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 {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetAuxPtsType::Apply",
     "modeling0110", JustWarning, ed);
      return;
    }
    
    G4VModelCommand<M>::Model()->SetAuxPtsType(myType);
  }
  
};
 
// Set step points size type command
template <typename M>
class G4ModelCmdSetStepPtsSizeType : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetStepPtsSizeType(M* model, const G4String& placement,
                const G4String& cmdName="setStepPtsSizeType")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
    cmd->SetGuidance("Set step size type.");
    cmd->SetCandidates("none world screen");
  }
  
protected:
 
  void Apply(const G4String& type) {
    G4VMarker::SizeType mySizeType;
    
    if (type == "none") {mySizeType = G4VMarker::none;}
    else if (type == "world") {mySizeType = G4VMarker::world;}
    else if (type == "screen") {mySizeType = G4VMarker::screen;}
    else {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetStepPtsSizeType::Apply",
     "modeling0111", JustWarning, ed);
      return;
    }
    G4VModelCommand<M>::Model()->SetStepPtsSizeType(mySizeType);
  }
  
};
 
// Set auxiliary points size type command
template <typename M>
class G4ModelCmdSetAuxPtsSizeType : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetAuxPtsSizeType(M* model, const G4String& placement,
                   const G4String& cmdName="setAuxPtsSizeType")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
    cmd->SetGuidance("Set auxiliary size type.");
    cmd->SetCandidates("none world screen");
  }
  
protected:
 
  void Apply(const G4String& type) {
    G4VMarker::SizeType mySizeType;
    
    if (type == "none") {mySizeType = G4VMarker::none;}
    else if (type == "world") {mySizeType = G4VMarker::world;}
    else if (type == "screen") {mySizeType = G4VMarker::screen;}
    else {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetAuxPtsSizeType::Apply",
     "modeling0112", JustWarning, ed);
      return;
    }
    G4VModelCommand<M>::Model()->SetAuxPtsSizeType(mySizeType);
  }
  
};
 
// Set step points fill style command
template <typename M>
class G4ModelCmdSetStepPtsFillStyle : public G4ModelCmdApplyString<M> {
  
public:
 
  G4ModelCmdSetStepPtsFillStyle(M* model, const G4String& placement,
                const G4String& cmdName="setStepPtsFillStyle")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    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 {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetStepPtsFillStyle::Apply",
     "modeling0113", JustWarning, ed);
      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,
                   const G4String& cmdName="setAuxPtsFillStyle")
    :G4ModelCmdApplyString<M>(model, placement, cmdName)
  {
    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 {
      G4ExceptionDescription ed;
      ed << "Invalid argument. See command guidance for options.";
      G4Exception
    ("G4ModelCmdSetAuxPtsFillStyle::Apply",
     "modeling0114", JustWarning, ed);
      return;
    }
    G4VModelCommand<M>::Model()->SetAuxPtsFillStyle(myFillStyle);
  }
  
};
 
// SetLineWidth command
template <typename M>
class G4ModelCmdSetLineWidth : public G4ModelCmdApplyDouble<M> {
 
public:
 
  G4ModelCmdSetLineWidth(M* model, const G4String& placement,
                         const G4String& cmdName="""setLineWidth")
  :G4ModelCmdApplyDouble<M>(model, placement, cmdName){}
 
protected:
 
  void Apply(const G4double& width) {
    G4VModelCommand<M>::Model()->SetLineWidth(width);
  }
 
};
 
// SetLineColour command
template <typename M>
class G4ModelCmdSetLineColour : public G4ModelCmdApplyColour<M> {
 
public:
 
  G4ModelCmdSetLineColour(M* model, const G4String& placement,
                          const G4String& cmdName="""setLineColour")
  :G4ModelCmdApplyColour<M>(model, placement, cmdName){}
 
protected:
 
  void Apply(const G4Colour& colour) {
    G4VModelCommand<M>::Model()->SetLineColour(colour);
  }
 
};
 
// Set time slice interval command
template <typename M>
class G4ModelCmdSetTimeSliceInterval : public G4ModelCmdApplyDoubleAndUnit<M> {
 
public:
 
  G4ModelCmdSetTimeSliceInterval(M* model, const G4String& placement,
                 const G4String& cmdName = "setTimeSliceInterval")
    :G4ModelCmdApplyDoubleAndUnit<M>(model, placement, cmdName)
  {
    G4UIcmdWithADoubleAndUnit* cmd = G4ModelCmdApplyDoubleAndUnit<M>::Command();
    cmd->SetGuidance
      ("Set time slice interval.  Give unit, e.g., \"0.1 ns\"");
    cmd->SetUnitCategory("Time");
  }
 
protected:
 
   void Apply(const G4double& myDouble) {
     G4VModelCommand<M>::Model()->SetTimeSliceInterval(myDouble);
  }
 
};
 
// 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;
  
};
 
// Draw command
template <typename M>
class G4ModelCmdDraw : public G4ModelCmdApplyBool<M> {
 
public: // With description
 
  G4ModelCmdDraw(M* model, const G4String& placement,
         const G4String& cmdName="draw")
    :G4ModelCmdApplyBool<M>(model, placement, cmdName)
  {
    G4ModelCmdApplyBool<M>::Command()->SetGuidance("Draw command");
  }
 
  virtual ~G4ModelCmdDraw() {}
 
protected:
 
  virtual void Apply(const G4bool& newValue) {
    if (newValue) G4VModelCommand<M>::Model()->Draw();
  }
 
};
 
// Set interval
template <typename M>
class G4ModelCmdAddInterval : public G4ModelCmdApplyString<M> {
 
public: // With description
 
  G4ModelCmdAddInterval(M* model, const G4String& placement, 
            const G4String& cmdName="addInterval")
    :G4ModelCmdApplyString<M>(model, placement, cmdName) 
  {
    G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
    cmd->SetGuidance("Set interval.");
  }
  
  virtual ~G4ModelCmdAddInterval() {}
 
protected:
 
  virtual void Apply(const G4String& param) {
    G4VModelCommand<M>::Model()->AddInterval(param);
 
  }
};
 
// Set value
template <typename M>
class G4ModelCmdAddValue : public G4ModelCmdApplyString<M> {
 
public: // With description
 
  G4ModelCmdAddValue(M* model, const G4String& placement, 
             const G4String& cmdName="addValue")
    :G4ModelCmdApplyString<M>(model, placement, cmdName) 
  {
    G4UIcmdWithAString* cmd = G4ModelCmdApplyString<M>::Command();
    cmd->SetGuidance("Set value.");
  }
  
  virtual ~G4ModelCmdAddValue() {}
protected:
 
  virtual void Apply(const G4String& param) {
    G4VModelCommand<M>::Model()->AddValue(param);
  }
};
 
// Set string command
template <typename M>
class G4ModelCmdSetString : public G4ModelCmdApplyString<M> {
 
public: // With description
 
  G4ModelCmdSetString(M* model, const G4String& placement, 
              const G4String& cmdName="set")
    :G4ModelCmdApplyString<M>(model, placement, cmdName) 
  {
    G4ModelCmdApplyString<M>::Command()->SetGuidance("Set command");
  }
 
  virtual ~G4ModelCmdSetString() {}
 
protected:
  
  virtual void Apply(const G4String& newValue) {
    G4VModelCommand<M>::Model()->Set(newValue);
  }
  
};
 
#endif