G4ScoreQuantityMessenger Class Reference

#include <G4ScoreQuantityMessenger.hh>

Inheritance diagram for G4ScoreQuantityMessenger:

Public Member Functions
	G4ScoreQuantityMessenger (G4ScoringManager *SManager)
	~G4ScoreQuantityMessenger ()
void	SetNewValue (G4UIcommand *command, G4String newValues)
G4String	GetCurrentValue (G4UIcommand *)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const

Protected Member Functions
void	FillTokenVec (G4String newValues, G4TokenVec &token)
void	FParticleCommand (G4VScoringMesh *mesh, G4TokenVec &token)
void	FParticleWithEnergyCommand (G4VScoringMesh *mesh, G4TokenVec &token)
G4bool	CheckMeshPS (G4VScoringMesh *mesh, G4String &psname)
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)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

Additional Inherited Members
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir
G4String	baseDirName

Detailed Description

Definition at line 59 of file G4ScoreQuantityMessenger.hh.

Constructor & Destructor Documentation

G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::G4ScoreQuantityMessenger

(

G4ScoringManager *

SManager

)

Definition at line 88 of file G4ScoreQuantityMessenger.cc.

:fSMan(SManager)
{
  QuantityCommands();
  FilterCommands();
}

~G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger

(

)

Definition at line 171 of file G4ScoreQuantityMessenger.cc.

{
    delete         quantityDir;
    delete         qTouchCmd;
    delete         qGetUnitCmd;
    delete         qSetUnitCmd;
 
    //
    delete    qCellChgCmd;
    delete    qCellFluxCmd;
    delete    qPassCellFluxCmd;
    delete    qeDepCmd;
    delete    qdoseDepCmd;
    delete    qnOfStepCmd;
    delete    qnOfSecondaryCmd;
    //
    delete          qTrackLengthCmd;
    delete          qPassCellCurrCmd;
    delete          qPassTrackLengthCmd;
    delete          qFlatSurfCurrCmd;
    delete          qFlatSurfFluxCmd;
//    delete          qSphereSurfCurrCmd;
//    delete          qSphereSurfFluxCmd;
//    delete          qCylSurfCurrCmd;
//    delete          qCylSurfFluxCmd;
    delete          qNofCollisionCmd;
    delete          qPopulationCmd;
    delete          qTrackCountCmd;
    delete          qTerminationCmd;
    delete          qMinKinEAtGeneCmd;
    //
    delete          qStepCheckerCmd;
    //
    delete   filterDir;
    delete   fchargedCmd;
    delete   fneutralCmd;
    delete   fkinECmd;
    delete   fparticleCmd;
    delete   fparticleKinECmd;
}

Member Function Documentation

CheckMeshPS()

G4bool G4ScoreQuantityMessenger::CheckMeshPS ( G4VScoringMesh *  mesh, G4String &  psname  )

protected

Definition at line 533 of file G4ScoreQuantityMessenger.cc.

                                                                                  {
    if(!mesh->FindPrimitiveScorer(psname)) {
    return true;
    } else {
    G4cout << "WARNING[" << qTouchCmd->GetCommandPath()
           << "] : Quantity name, \"" << psname << "\", is already existing." << G4endl;
    mesh->SetNullToCurrentPrimitiveScorer();
    return false;
    }
}

Referenced by SetNewValue().

FillTokenVec()

void G4ScoreQuantityMessenger::FillTokenVec ( G4String  newValues, G4TokenVec &  token  )

protected

Definition at line 495 of file G4ScoreQuantityMessenger.cc.

                                                                                {
 
    G4Tokenizer next(newValues);
    G4String val;
    while ( !(val = next()).isNull() ) {
    token.push_back(val);
    }
}

Referenced by SetNewValue().

FParticleCommand()

void G4ScoreQuantityMessenger::FParticleCommand ( G4VScoringMesh *  mesh, G4TokenVec &  token  )

protected

Definition at line 505 of file G4ScoreQuantityMessenger.cc.

                                                                                      {
    //
    // Filter name
    G4String name = token[0];
    //
    // particle list
    std::vector<G4String> pnames;
    for ( G4int i = 1; i<(G4int)token.size(); i++){
    pnames.push_back(token[i]);
    }
    //
    // Attach Filter
    mesh->SetFilter(new G4SDParticleFilter(name,pnames));
}    

Referenced by SetNewValue().

FParticleWithEnergyCommand()

void G4ScoreQuantityMessenger::FParticleWithEnergyCommand ( G4VScoringMesh *  mesh, G4TokenVec &  token  )

protected

Definition at line 520 of file G4ScoreQuantityMessenger.cc.

                                                                                               {
    G4String& name = token[0];
    G4double  elow = StoD(token[1]);
    G4double  ehigh= StoD(token[2]);
    G4double  unitVal = G4UnitDefinition::GetValueOf(token[3]);
    G4SDParticleWithEnergyFilter* filter = 
    new G4SDParticleWithEnergyFilter(name,elow*unitVal,ehigh*unitVal);
    for ( G4int i = 4; i < (G4int)token.size(); i++){
    filter->add(token[i]);
    }
    mesh->SetFilter(filter);
}

Referenced by SetNewValue().

GetCurrentValue()

G4String G4ScoreQuantityMessenger::GetCurrentValue ( G4UIcommand *  )

virtual

Reimplemented from G4UImessenger.

Definition at line 488 of file G4ScoreQuantityMessenger.cc.

{
  G4String val;
 
  return val;
}

SetNewValue()

void G4ScoreQuantityMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValues  )

virtual

Reimplemented from G4UImessenger.

Definition at line 212 of file G4ScoreQuantityMessenger.cc.

{
      //
      // Get Current Mesh
      //
      G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
      if(!mesh)
      {
        G4cerr << "ERROR : No mesh is currently open. Open/create a mesh first. Command ignored." << G4endl;
        return;
      }
      // Tokens
      G4TokenVec token;
      FillTokenVec(newVal,token);
      //
      // Commands for Current Mesh
      if(command==qTouchCmd) {
              mesh->SetCurrentPrimitiveScorer(newVal);
      } else if(command == qGetUnitCmd ){
      G4cout << "Unit:  "<< mesh->GetCurrentPSUnit() <<G4endl;
      } else if(command == qSetUnitCmd ){
      mesh->SetCurrentPSUnit(newVal);
      } else if(command== qCellChgCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
          G4PSCellCharge3D* ps = new G4PSCellCharge3D(token[0]);
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qCellFluxCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
          G4PSCellFlux3D* ps = new G4PSCellFlux3D(token[0]);
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSCellFluxForCylinder3D* ps = 
        new G4PSCellFluxForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
          G4ThreeVector msize = mesh->GetSize(); // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
          mesh->SetPrimitiveScorer(ps);
            }
      }
      } else if(command== qPassCellFluxCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
          G4PSPassageCellFlux3D* ps = new G4PSPassageCellFlux3D(token[0]);
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSPassageCellFluxForCylinder3D* ps = 
        new G4PSPassageCellFluxForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
          G4ThreeVector msize = mesh->GetSize();  // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
          mesh->SetPrimitiveScorer(ps);
            }
      }
      } else if(command==qeDepCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
          G4PSEnergyDeposit3D* ps =new G4PSEnergyDeposit3D(token[0]);
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qdoseDepCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
          G4PSDoseDeposit3D* ps = new G4PSDoseDeposit3D(token[0]);
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSDoseDepositForCylinder3D* ps = 
        new G4PSDoseDepositForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
          G4ThreeVector msize = mesh->GetSize(); // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
          mesh->SetPrimitiveScorer(ps);
            }
      }
      } else if(command== qnOfStepCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
          G4PSNofStep3D* ps = new G4PSNofStep3D(token[0]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qnOfSecondaryCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
          G4PSNofSecondary3D* ps =new G4PSNofSecondary3D(token[0]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qTrackLengthCmd) {
      if ( CheckMeshPS(mesh,token[0]) ){
          G4PSTrackLength3D* ps = new G4PSTrackLength3D(token[0]);
          ps->Weighted(StoB(token[1]));
          ps->MultiplyKineticEnergy(StoB(token[2]));
          ps->DivideByVelocity(StoB(token[3]));
          ps->SetUnit(token[4]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qPassCellCurrCmd){
      if( CheckMeshPS(mesh,token[0]) ) {
          G4PSPassageCellCurrent* ps = new G4PSPassageCellCurrent3D(token[0]);
          ps->Weighted(StoB(token[1]));
          //ps->SetUnit(token[2]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qPassTrackLengthCmd){
      if( CheckMeshPS(mesh,token[0]) ) {
          G4PSPassageTrackLength* ps = new G4PSPassageTrackLength3D(token[0]);
          ps->Weighted(StoB(token[1]));
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qFlatSurfCurrCmd){
      if( CheckMeshPS(mesh,token[0])) {
          G4PSFlatSurfaceCurrent3D* ps = 
        new G4PSFlatSurfaceCurrent3D(token[0],StoI(token[1]));
          ps->Weighted(StoB(token[2]));
          ps->DivideByArea(StoB(token[3]));
          if ( StoB(token[3]) ){
        ps->SetUnit(token[4]);
          }else{
        ps->SetUnit("");
          }
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qFlatSurfFluxCmd){
      if( CheckMeshPS(mesh, token[0] )) {
          G4PSFlatSurfaceFlux3D* ps = new G4PSFlatSurfaceFlux3D(token[0],StoI(token[1]));
          ps->Weighted(StoB(token[2]));
          ps->DivideByArea(StoB(token[3]));
          if ( StoB(token[3]) ){
        ps->SetUnit(token[4]);
          }else{
        ps->SetUnit("");
          }
          mesh->SetPrimitiveScorer(ps);
      }
//    } else if(command== qSphereSurfCurrCmd){
//    if( CheckMeshPS(mesh, token[0] )) {
//        G4PSSphereSurfaceCurrent3D* ps = 
//      new G4PSSphereSurfaceCurrent3D(token[0],StoI(token[1]));
//        ps->Weighted(StoB(token[2]));
//        ps->DivideByArea(StoB(token[3]));
//        if ( StoB(token[3]) ){
//      ps->SetUnit(token[4]);
//        }else{
//      ps->SetUnit("");
//        }
//        mesh->SetPrimitiveScorer(ps);
//    }
//   } else if(command== qSphereSurfFluxCmd){
//    if( CheckMeshPS(mesh,token[0])) {
//            G4PSSphereSurfaceFlux3D* ps = new G4PSSphereSurfaceFlux3D(token[0], StoI(token[1]));
//        ps->Weighted(StoB(token[2]));
//        ps->DivideByArea(StoB(token[3]));
//        if ( StoB(token[3]) ){
//      ps->SetUnit(token[4]);
//        }else{
//      ps->SetUnit("");
//        }
//        mesh->SetPrimitiveScorer(ps);
//    }
//   } else if(command== qCylSurfCurrCmd){
//    if( CheckMeshPS(mesh, token[0] ) ) {
//        G4PSCylinderSurfaceCurrent3D* ps = 
//      new G4PSCylinderSurfaceCurrent3D(token[0],StoI(token[1]));
//        ps->Weighted(StoB(token[2]));
//        ps->DivideByArea(StoB(token[3]));
//        if ( StoB(token[3]) ){
//      ps->SetUnit(token[4]);
//        }else{
//      ps->SetUnit("");
//        }
//        ps->SetUnit(token[4]);
//        mesh->SetPrimitiveScorer(ps);
//    }
//   } else if(command== qCylSurfFluxCmd){
//    if( CheckMeshPS(mesh, token[0] ) {
//            G4PSCylinerSurfaceFlux3D* ps =new G4PSCylinderSurfaceFlux3D(token[0], StoI(token[1]));
//        ps->Weighted(StoB(token[2]));
//        ps->DivideByArea(StoB(token[3]));
//        if ( StoB(token[3]) ){
//      ps->SetUnit(token[4]);
//        }else{
//      ps->SetUnit("");
//        }
//        mesh->SetPrimitiveScorer(ps);
//    }
      } else if(command== qNofCollisionCmd){
      if( CheckMeshPS(mesh,token[0])) {
          G4PSNofCollision3D* ps =new G4PSNofCollision3D(token[0]); 
          ps->Weighted(StoB(token[1]));
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qPopulationCmd){
      if( CheckMeshPS(mesh,token[0]) ) {
          G4PSPopulation3D* ps =new G4PSPopulation3D(token[0]); 
          ps->Weighted(StoB(token[1]));
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qTrackCountCmd){
      if( CheckMeshPS(mesh,token[0])) {
          G4PSTrackCounter3D* ps =new G4PSTrackCounter3D(token[0],StoI(token[1])); 
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qTerminationCmd){
      if( CheckMeshPS(mesh,token[0])) {
          G4PSTermination3D* ps =new G4PSTermination3D(token[0]); 
          ps->Weighted(StoB(token[1]));
          mesh->SetPrimitiveScorer(ps);
      }
 
      } else if(command== qMinKinEAtGeneCmd){
      if( CheckMeshPS(mesh,token[0]) ){
          G4PSMinKinEAtGeneration3D* ps =new G4PSMinKinEAtGeneration3D(token[0]); 
          ps->SetUnit(token[1]);
          mesh->SetPrimitiveScorer(ps);
      }
      } else if(command== qStepCheckerCmd){
      if( CheckMeshPS(mesh,token[0]) ){
          G4PSStepChecker3D* ps =new G4PSStepChecker3D(token[0]); 
          mesh->SetPrimitiveScorer(ps);
      }
 
        //
        // Filters 
        // 
      }else if(command== fchargedCmd){
        if(!mesh->IsCurrentPrimitiveScorerNull()) {
          mesh->SetFilter(new G4SDChargedFilter(token[0])); 
        } else {
          G4cout << "WARNING[" << fchargedCmd->GetCommandPath()
             << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
        }
      }else if(command== fneutralCmd){
        if(!mesh->IsCurrentPrimitiveScorerNull()) {
          mesh->SetFilter(new G4SDNeutralFilter(token[0])); 
        } else {
          G4cout << "WARNING[" << fneutralCmd->GetCommandPath()
             << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
        }
      }else if(command== fkinECmd){
        if(!mesh->IsCurrentPrimitiveScorerNull()) {
          G4String& name = token[0];
          G4double elow  = StoD(token[1]);
          G4double ehigh = StoD(token[2]);
          mesh->SetFilter(new G4SDKineticEnergyFilter(name,elow,ehigh));
        } else {
          G4cout << "WARNING[" << fkinECmd->GetCommandPath()
             << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
        }
      }else if(command== fparticleKinECmd){
        if(!mesh->IsCurrentPrimitiveScorerNull()) {
          FParticleWithEnergyCommand(mesh,token); 
        } else {
          G4cout << "WARNING[" << fparticleKinECmd->GetCommandPath()
             << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
        }
      } else if(command==fparticleCmd) {
        if(!mesh->IsCurrentPrimitiveScorerNull()) {
          FParticleCommand(mesh,token);
        } else {
          G4cout << "WARNING[" << fparticleCmd->GetCommandPath()
             << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
        }
      }
}

---

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

• G4ScoreQuantityMessenger.hh
• G4ScoreQuantityMessenger.cc
• G4ScoreQuantityMessengerQCmd.cc