G4ScoreQuantityMessenger Class Reference

#include <G4ScoreQuantityMessenger.hh>

Inheritance diagram for G4ScoreQuantityMessenger:

Collaboration 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, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () 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, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

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

Detailed Description

Definition at line 59 of file G4ScoreQuantityMessenger.hh.

Constructor & Destructor Documentation

G4ScoreQuantityMessenger::G4ScoreQuantityMessenger

(

G4ScoringManager *

SManager

)

Definition at line 91 of file G4ScoreQuantityMessenger.cc.

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

G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger

(

)

Definition at line 174 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

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

protected

Definition at line 539 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;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 501 of file G4ScoreQuantityMessenger.cc.

                                                                                {

    G4Tokenizer next(newValues);
    G4String val;
    while ( !(val = next()).isNull() ) { // Loop checking 12.18.2015 M.Asai
        token.push_back(val);
    }
}

Here is the caller graph for this function:

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

protected

Definition at line 511 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));
}    

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 526 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4String G4ScoreQuantityMessenger::GetCurrentValue ( G4UIcommand *  )

virtual

Reimplemented from G4UImessenger.

Definition at line 494 of file G4ScoreQuantityMessenger.cc.

{
  G4String val;

  return val;
}

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

virtual

Reimplemented from G4UImessenger.

Definition at line 215 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]);
              ps->SetBoundaryFlag(StoB(token[1]));
              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]));
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qPassTrackLengthCmd){
          if( CheckMeshPS(mesh,token[0]) ) {
              G4PSPassageTrackLength* ps = new G4PSPassageTrackLength3D(token[0]);
              ps->Weighted(StoB(token[1]));
              ps->SetUnit(token[2]);
              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])); 
              ps->Weighted(StoB(token[2]));
              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]);
              G4double unitVal = G4UnitDefinition::GetValueOf(token[3]);
              mesh->SetFilter(new G4SDKineticEnergyFilter(name,elow*unitVal,ehigh*unitVal));
            } 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;
            }
      }
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p02/source/digits_hits/utils/include/G4ScoreQuantityMessenger.hh
• source/geant4.10.03.p02/source/digits_hits/utils/src/G4ScoreQuantityMessenger.cc
• source/geant4.10.03.p02/source/digits_hits/utils/src/G4ScoreQuantityMessengerQCmd.cc