lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6399a014b611a4aa09ecba225418222dac261ca1
geant4/source/digits_hits/utils/src/G4ScoringMessenger.cc
T
Gabriele Cosmo 6399a014b6 Import Geant4 11.0.0.beta source tree
2021-06-25 16:12:29 +02:00

1093 lines
37 KiB
C++
Raw Blame History

//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// ---------------------------------------------------------------------
#include "G4ScoringMessenger.hh"
#include "G4ScoringManager.hh"
#include "G4VScoringMesh.hh"
#include "G4ScoringBox.hh"
#include "G4ScoringCylinder.hh"
#include "G4ScoringRealWorld.hh"
#include "G4ScoringProbe.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithoutParameter.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWith3VectorAndUnit.hh"
#include "G4UIcommand.hh"
#include "G4UIparameter.hh"
#include "G4Tokenizer.hh"
#include "G4UnitsTable.hh"
#include "G4VScoreColorMap.hh"
G4ScoringMessenger::G4ScoringMessenger(G4ScoringManager* SManager)
: fSMan(SManager)
{
G4UIparameter* param = nullptr;
scoreDir = new G4UIdirectory("/score/");
scoreDir->SetGuidance("Interactive scoring commands.");
listCmd = new G4UIcmdWithoutParameter("/score/list", this);
listCmd->SetGuidance("List scoring worlds.");
dumpCmd = new G4UIcmdWithoutParameter("/score/dump", this);
dumpCmd->SetGuidance("Dump results of scorers.");
verboseCmd = new G4UIcmdWithAnInteger("/score/verbose", this);
verboseCmd->SetGuidance("Verbosity.");
verboseCmd->SetGuidance(" 0) errors or warnings,");
verboseCmd->SetGuidance(" 1) information with 0)");
meshCreateDir = new G4UIdirectory("/score/create/");
meshCreateDir->SetGuidance(" Mesh creation commands.");
//
// Mesh commands
meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh", this);
meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
meshBoxCreateCmd->SetParameterName("MeshName", false);
//
meshCylinderCreateCmd =
new G4UIcmdWithAString("/score/create/cylinderMesh", this);
meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
meshCylinderCreateCmd->SetParameterName("MeshName", false);
//
// meshSphereCreateCmd = new
// G4UIcmdWithAString("/score/create/sphereMesh",this);
// meshSphereCreateCmd->SetGuidance("Create scoring mesh.");
// meshSphereCreateCmd->SetParameterName("MeshName",false);
//
meshRWLogVolCreateCmd =
new G4UIcommand("/score/create/realWorldLogVol", this);
meshRWLogVolCreateCmd->SetGuidance(
"Define scorers to a logical volume defined in the real world.");
meshRWLogVolCreateCmd->SetGuidance(
" - Name of the specified logical volume is used as the mesh name.");
meshRWLogVolCreateCmd->SetGuidance(
" - /score/mesh commands do not affect for this mesh.");
meshRWLogVolCreateCmd->SetGuidance(
" - If copyNumberLevel is set, the copy number of that-level higher");
meshRWLogVolCreateCmd->SetGuidance(
" in the geometrical hierarchy is used as the index.");
param = new G4UIparameter("logVol", 's', false);
meshRWLogVolCreateCmd->SetParameter(param);
param = new G4UIparameter("copyNumberLevel", 'i', true);
param->SetParameterRange("copyNumberLevel>=0");
param->SetDefaultValue(0);
meshRWLogVolCreateCmd->SetParameter(param);
//
probeCreateCmd = new G4UIcommand("/score/create/probe", this);
probeCreateCmd->SetGuidance("Define scoring probe.");
probeCreateCmd->SetGuidance(
" halfSize defines the half-width of the probing cube.");
param = new G4UIparameter("pname", 's', false);
probeCreateCmd->SetParameter(param);
param = new G4UIparameter("halfSize", 'd', false);
probeCreateCmd->SetParameter(param);
param = new G4UIparameter("unit", 's', true);
param->SetDefaultUnit("mm");
probeCreateCmd->SetParameter(param);
param = new G4UIparameter("checkOverlap", 'b', true);
param->SetDefaultValue(false);
probeCreateCmd->SetParameter(param);
//
meshOpnCmd = new G4UIcmdWithAString("/score/open", this);
meshOpnCmd->SetGuidance("Open scoring mesh.");
meshOpnCmd->SetParameterName("MeshName", false);
//
meshClsCmd = new G4UIcmdWithoutParameter("/score/close", this);
meshClsCmd->SetGuidance("Close scoring mesh.");
//
// meshActCmd = new G4UIcmdWithABool("/score/mesh/activate",this);
// meshActCmd->SetGuidance("Activate scoring mesh.");
// meshActCmd->SetParameterName("MeshName",false);
//
meshDir = new G4UIdirectory("/score/mesh/");
meshDir->SetGuidance(" Mesh processing commands.");
//
mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize", this);
mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
mBoxSizeCmd->SetGuidance("Dx Dy Dz unit");
mBoxSizeCmd->SetParameterName("Di", "Dj", "Dk", false, false);
mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
mBoxSizeCmd->SetDefaultUnit("mm");
//
mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize", this);
mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
mCylinderSizeCmd->SetGuidance("R Dz unit");
param = new G4UIparameter("R", 'd', false);
param->SetParameterRange("R>0");
mCylinderSizeCmd->SetParameter(param);
param = new G4UIparameter("Dz", 'd', false);
param->SetParameterRange("Dz>0");
mCylinderSizeCmd->SetParameter(param);
param = new G4UIparameter("unit", 's', true);
param->SetDefaultUnit("mm");
mCylinderSizeCmd->SetParameter(param);
//
mCylinderRMinCmd =
new G4UIcmdWithADoubleAndUnit("/score/mesh/cylinderRMin", this);
mCylinderRMinCmd->SetGuidance("Define the inner radius of the tube mesh.");
mCylinderRMinCmd->SetGuidance("This command is not needed for cylinder mesh");
mCylinderRMinCmd->SetParameterName("RMin", false, false);
mCylinderRMinCmd->SetRange("RMin>=0.");
mCylinderRMinCmd->SetDefaultUnit("mm");
//
mCylinderAngleCmd = new G4UIcommand("/score/mesh/cylinderAngles", this);
mCylinderAngleCmd->SetGuidance(
"Define starting angle and span for tube segment mesh.");
mCylinderAngleCmd->SetGuidance(
"This command is not needed for cylinder mesh");
param = new G4UIparameter("startPhi", 'd', false);
mCylinderAngleCmd->SetParameter(param);
param = new G4UIparameter("deltaPhi", 'd', false);
param->SetParameterRange("deltaPhi>0.");
mCylinderAngleCmd->SetParameter(param);
param = new G4UIparameter("unit", 's', true);
param->SetDefaultUnit("deg");
mCylinderAngleCmd->SetParameter(param);
//
// Division command
mBinCmd = new G4UIcommand("/score/mesh/nBin", this);
mBinCmd->SetGuidance("Define segments of the scoring mesh.");
mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
mBinCmd->SetGuidance(" Ni :(int) Number of bins i (in x-axis) ");
mBinCmd->SetGuidance(" Nj :(int) Number of bins j (in y-axis) ");
mBinCmd->SetGuidance(" Nk :(int) Number of bins k (in z-axis) ");
mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
mBinCmd->SetGuidance(" Nr :(int) Number of bins in radial axis ");
mBinCmd->SetGuidance(" Nz :(int) Number of bins in z axis ");
mBinCmd->SetGuidance(" Nphi:(int) Number of bins in phi axis ");
// mBinCmd->SetGuidance(" Axis:(int) Axis of division ");
// mBinCmd->SetGuidance(" P1..Pn-1 :(double) \"paramter from P1 to Pn-1 for
// division.\"");
param = new G4UIparameter("Ni", 'i', false);
param->SetDefaultValue("1");
param->SetParameterRange("Ni>0");
mBinCmd->SetParameter(param);
param = new G4UIparameter("Nj", 'i', false);
param->SetDefaultValue("1");
param->SetParameterRange("Nj>0");
mBinCmd->SetParameter(param);
param = new G4UIparameter("Nk", 'i', false);
param->SetDefaultValue("1");
mBinCmd->SetParameter(param);
param->SetParameterRange("Nk>0");
// param = new G4UIparameter("Axis",'i',true);
// param->SetDefaultValue("3");
// mBinCmd->SetParameter(param);
//
// Placement command
mTransDir = new G4UIdirectory("/score/mesh/translate/");
mTransDir->SetGuidance("Mesh translation commands.");
//
mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset", this);
mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
//
mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz", this);
mTXyzCmd->SetGuidance("Translate the scoring mesh.");
mTXyzCmd->SetParameterName("X", "Y", "Z", false, false);
mTXyzCmd->SetDefaultUnit("mm");
//
mRotDir = new G4UIdirectory("/score/mesh/rotate/");
mRotDir->SetGuidance("Mesh rotation commands.");
//
// mRResetCmd = new G4UIcmdWithoutParameter("/score/mesh/rotate/reset",this);
// mRResetCmd->SetGuidance("Reset rotation angles of the scoring mesh.");
//
mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX", this);
mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
mRotXCmd->SetParameterName("Rx", false);
mRotXCmd->SetDefaultUnit("deg");
//
mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY", this);
mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
mRotYCmd->SetParameterName("Ry", false);
mRotYCmd->SetDefaultUnit("deg");
//
mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ", this);
mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
mRotZCmd->SetParameterName("Rz", false);
mRotZCmd->SetDefaultUnit("deg");
//
probeDir = new G4UIdirectory("/score/probe/");
probeDir->SetGuidance("Probe commands");
probeMatCmd = new G4UIcmdWithAString("/score/probe/material", this);
probeMatCmd->SetGuidance("Specify a material to the probe cube.");
probeMatCmd->SetGuidance("Material name has to be taken from G4NistManager.");
probeMatCmd->SetGuidance("Once this command is used, the specified material "
"overlays the material in the mass geometry");
probeMatCmd->SetGuidance("with \"Layered Mass Geometry\" mechanism so that "
"physics quantities such as energy deposition");
probeMatCmd->SetGuidance("or dose will be calculated with this material.");
probeMatCmd->SetGuidance("To switch-off this overlaying, use \"none\".");
probeMatCmd->SetParameterName("matName", true);
probeMatCmd->SetDefaultValue("none");
probeMatCmd->SetToBeBroadcasted(false);
probeLocateCmd = new G4UIcmdWith3VectorAndUnit("/score/probe/locate", this);
probeLocateCmd->SetGuidance(
"Locate a probe in the global coordinate system.");
probeLocateCmd->SetParameterName("x", "y", "z", false);
probeLocateCmd->SetDefaultUnit("mm");
probeLocateCmd->SetToBeBroadcasted(false);
// Draw Scoring result
drawCmd = new G4UIcommand("/score/drawProjection", this);
drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
drawCmd->SetGuidance(
"Parameter <proj> specified which projection(s) to be drawn.");
drawCmd->SetGuidance(
" 100 : xy-plane, 010 : yz-plane, 001 : zx-plane -- default 111");
drawCmd->SetGuidance(
" 100 : N/A, 010 : z_phi-plane, 001 : r_phi-plane -- default 111");
param = new G4UIparameter("meshName", 's', false);
drawCmd->SetParameter(param);
param = new G4UIparameter("psName", 's', false);
drawCmd->SetParameter(param);
param = new G4UIparameter("colorMapName", 's', true);
param->SetDefaultValue("defaultLinearColorMap");
drawCmd->SetParameter(param);
param = new G4UIparameter("proj", 'i', true);
param->SetDefaultValue(111);
drawCmd->SetParameter(param);
drawCmd->SetToBeBroadcasted(false);
// Draw column
drawColumnCmd = new G4UIcommand("/score/drawColumn", this);
drawColumnCmd->SetGuidance("Draw a cell column.");
drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x for box mesh");
drawColumnCmd->SetGuidance(
" 0 : z-phi, 1: r-phi, 2: r-z for cylinder mesh");
param = new G4UIparameter("meshName", 's', false);
drawColumnCmd->SetParameter(param);
param = new G4UIparameter("psName", 's', false);
drawColumnCmd->SetParameter(param);
param = new G4UIparameter("plane", 'i', false);
param->SetParameterRange("plane>=0 && plane<=2");
drawColumnCmd->SetParameter(param);
param = new G4UIparameter("column", 'i', false);
drawColumnCmd->SetParameter(param);
param = new G4UIparameter("colorMapName", 's', true);
param->SetDefaultValue("defaultLinearColorMap");
drawColumnCmd->SetParameter(param);
drawColumnCmd->SetToBeBroadcasted(false);
colorMapDir = new G4UIdirectory("/score/colorMap/");
colorMapDir->SetGuidance("Color map commands.");
listColorMapCmd =
new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps", this);
listColorMapCmd->SetGuidance("List registered score color maps.");
listColorMapCmd->SetToBeBroadcasted(false);
floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax", this);
floatMinMaxCmd->SetGuidance(
"Min/Max of the color map is calculated according to the actual scores.");
floatMinMaxCmd->SetParameterName("colorMapName", true, false);
floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
floatMinMaxCmd->SetToBeBroadcasted(false);
colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax", this);
colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
param = new G4UIparameter("colorMapMame", 's', true);
param->SetDefaultValue("defaultLinearColorMap");
colorMapMinMaxCmd->SetParameter(param);
param = new G4UIparameter("minValue", 'd', false);
colorMapMinMaxCmd->SetParameter(param);
param = new G4UIparameter("maxValue", 'd', false);
colorMapMinMaxCmd->SetParameter(param);
colorMapMinMaxCmd->SetToBeBroadcasted(false);
/*
chartCmd = new G4UIcommand("/score/drawChart",this);
chartCmd->SetGuidance("Draw color chart on the screen.");
chartCmd->SetGuidance("[usage] /score/drawChart");
chartCmd->SetGuidance(" mesh :(String) Mesh name.");
chartCmd->SetGuidance(" psname :(String) PS name.");
chartCmd->SetGuidance(" On/Off :(boolean) On or Off the color chart.");
chartCmd->SetGuidance(" scale :(String) default=linear, or log ");
param = new G4UIparameter("meshName",'s',false);
chartCmd->SetParameter(param);
param = new G4UIparameter("psName",'s',false);
chartCmd->SetParameter(param);
param = new G4UIparameter("On",'s',true);
param->SetDefaultValue("true");
chartCmd->SetParameter(param);
param = new G4UIparameter("scale",'s',true);
param->SetDefaultValue("linear");
chartCmd->SetParameter(param);
*/
// Dump a scored quantity
dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
param = new G4UIparameter("meshName", 's', false);
dumpQtyToFileCmd->SetParameter(param);
param = new G4UIparameter("psName", 's', false);
dumpQtyToFileCmd->SetParameter(param);
param = new G4UIparameter("fileName", 's', false);
dumpQtyToFileCmd->SetParameter(param);
param = new G4UIparameter("option", 's', true);
dumpQtyToFileCmd->SetParameter(param);
dumpQtyToFileCmd->SetToBeBroadcasted(false);
dumpQtyWithFactorCmd = new G4UIcommand("/score/dumpQuantityWithFactor", this);
dumpQtyWithFactorCmd->SetGuidance("Dump one scored quantity to file.");
dumpQtyWithFactorCmd->SetGuidance(
"Each value is multiplied by the specified factor.");
param = new G4UIparameter("meshName", 's', false);
dumpQtyWithFactorCmd->SetParameter(param);
param = new G4UIparameter("psName", 's', false);
dumpQtyWithFactorCmd->SetParameter(param);
param = new G4UIparameter("fileName", 's', false);
dumpQtyWithFactorCmd->SetParameter(param);
param = new G4UIparameter("factor", 'd', false);
param->SetParameterRange("factor>0.");
dumpQtyWithFactorCmd->SetParameter(param);
param = new G4UIparameter("option", 's', true);
dumpQtyWithFactorCmd->SetParameter(param);
dumpQtyWithFactorCmd->SetToBeBroadcasted(false);
// Dump all scored quantities
dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
param = new G4UIparameter("meshName", 's', false);
dumpAllQtsToFileCmd->SetParameter(param);
param = new G4UIparameter("fileName", 's', false);
dumpAllQtsToFileCmd->SetParameter(param);
param = new G4UIparameter("option", 's', true);
dumpAllQtsToFileCmd->SetParameter(param);
dumpAllQtsToFileCmd->SetToBeBroadcasted(false);
dumpAllQtsWithFactorCmd =
new G4UIcommand("/score/dumpAllQuantitiesWithFactor", this);
dumpAllQtsWithFactorCmd->SetGuidance(
"Dump all quantities of the mesh to file.");
dumpAllQtsWithFactorCmd->SetGuidance(
"Each value is multiplied by the specified factor.");
param = new G4UIparameter("meshName", 's', false);
dumpAllQtsWithFactorCmd->SetParameter(param);
param = new G4UIparameter("fileName", 's', false);
dumpAllQtsWithFactorCmd->SetParameter(param);
param = new G4UIparameter("factor", 'd', false);
param->SetParameterRange("factor>0.");
dumpAllQtsWithFactorCmd->SetParameter(param);
param = new G4UIparameter("option", 's', true);
dumpAllQtsWithFactorCmd->SetParameter(param);
dumpAllQtsWithFactorCmd->SetToBeBroadcasted(false);
fill1DCmd = new G4UIcommand("/score/fill1D", this);
fill1DCmd->SetGuidance("Let a primitive scorer fill 1-D histogram");
fill1DCmd->SetGuidance("Before using this command, primitive scorer must be "
"defined and assigned.");
fill1DCmd->SetGuidance("Also before using this command, a histogram has to "
"be defined by /analysis/h1/create command.");
fill1DCmd->SetGuidance(
"This command is available only for real-world volume or probe.");
fill1DCmd->SetGuidance("Please note that this command has to be applied to "
"each copy number of the scoring volume.");
fill1DCmd->SetGuidance("If same histogram ID is used more than once, more "
"than one scorers fill that histogram.");
param = new G4UIparameter("histID", 'i', false);
fill1DCmd->SetParameter(param);
param = new G4UIparameter("meshName", 's', false);
fill1DCmd->SetParameter(param);
param = new G4UIparameter("scorerName", 's', false);
fill1DCmd->SetParameter(param);
param = new G4UIparameter("copyNo", 'i', true);
param->SetDefaultValue(0);
fill1DCmd->SetParameter(param);
}
G4ScoringMessenger::~G4ScoringMessenger()
{
delete listCmd;
delete verboseCmd;
//
delete meshBoxCreateCmd;
delete meshCylinderCreateCmd;
delete meshRWLogVolCreateCmd;
delete probeCreateCmd;
delete meshCreateDir;
// delete meshSphereCreateCmd;
//
delete meshOpnCmd;
//
delete meshClsCmd;
// delete meshActCmd;
delete meshDir;
//
delete mBoxSizeCmd;
delete mCylinderSizeCmd;
delete mCylinderRMinCmd;
delete mCylinderAngleCmd;
// delete mSphereSizeCmd;
//
delete mBinCmd;
//
delete mTResetCmd;
delete mTXyzCmd;
delete mTransDir;
// delete mRResetCmd;
delete mRotXCmd;
delete mRotYCmd;
delete mRotZCmd;
delete mRotDir;
//
delete probeLocateCmd;
delete probeMatCmd;
delete probeDir;
//
// delete chartCmd;
delete dumpCmd;
delete drawCmd;
delete drawColumnCmd;
delete listColorMapCmd;
delete floatMinMaxCmd;
delete colorMapMinMaxCmd;
delete colorMapDir;
delete dumpQtyToFileCmd;
delete dumpQtyWithFactorCmd;
delete dumpAllQtsToFileCmd;
delete dumpAllQtsWithFactorCmd;
delete fill1DCmd;
//
delete scoreDir;
}
void G4ScoringMessenger::SetNewValue(G4UIcommand* command, G4String newVal)
{
using MeshShape = G4VScoringMesh::MeshShape;
if(command == listCmd)
{
fSMan->List();
}
else if(command == dumpCmd)
{
fSMan->Dump();
}
else if(command == drawCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String psName = next();
G4String colorMapName = next();
G4int axflg = StoI(next());
fSMan->DrawMesh(meshName, psName, colorMapName, axflg);
}
else if(command == drawColumnCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String psName = next();
G4int iPlane = StoI(next());
G4int iColumn = StoI(next());
G4String colorMapName = next();
fSMan->DrawMesh(meshName, psName, iPlane, iColumn, colorMapName);
// } else if(command==chartCmd ){
// G4Tokenizer next(newVal);
// G4String meshName = next();
// G4String psName = next();
// //G4bool onFlag = StoB(next());
// G4String scaleOption = next();
// fSMan->DrawChart(meshName,psName,onFlag,scaleOption);
}
else if(command == dumpQtyToFileCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String psName = next();
G4String fileName = next();
G4String option = next("\n");
auto mesh = fSMan->FindMesh(meshName);
if(!mesh)
{
G4ExceptionDescription ed;
ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
command->CommandFailed(ed);
return;
}
fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
}
else if(command == dumpQtyWithFactorCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String psName = next();
G4String fileName = next();
G4double fac = StoD(next());
G4String option = next("\n");
auto mesh = fSMan->FindMesh(meshName);
if(!mesh)
{
G4ExceptionDescription ed;
ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
command->CommandFailed(ed);
return;
}
fSMan->SetFactor(fac);
fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
fSMan->SetFactor(1.0);
}
else if(command == dumpAllQtsToFileCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String fileName = next();
G4String option = next("\n");
auto mesh = fSMan->FindMesh(meshName);
if(!mesh)
{
G4ExceptionDescription ed;
ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
command->CommandFailed(ed);
return;
}
fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
}
else if(command == dumpAllQtsWithFactorCmd)
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4String fileName = next();
G4double fac = StoD(next());
G4String option = next("\n");
auto mesh = fSMan->FindMesh(meshName);
if(!mesh)
{
G4ExceptionDescription ed;
ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
command->CommandFailed(ed);
return;
}
fSMan->SetFactor(fac);
fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
fSMan->SetFactor(1.0);
}
else if(command == fill1DCmd)
{
Fill1D(command, newVal);
}
else if(command == verboseCmd)
{
fSMan->SetVerboseLevel(verboseCmd->GetNewIntValue(newVal));
}
else if(command == meshBoxCreateCmd)
{
G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
if(currentmesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath() << "] : Mesh <"
<< currentmesh->GetWorldName()
<< "> is still open. Close it first. Command ignored.";
command->CommandFailed(ed);
}
else
{
G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
if(!mesh)
{
mesh = new G4ScoringBox(newVal);
fSMan->RegisterScoringMesh(mesh);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
<< "] : Scoring mesh <" << newVal
<< "> already exists. Command ignored.";
command->CommandFailed(ed);
}
}
}
else if(command == meshCylinderCreateCmd)
{
G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
if(currentmesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath() << "] : Mesh <"
<< currentmesh->GetWorldName()
<< "> is still open. Close it first. Command ignored.";
command->CommandFailed(ed);
}
else
{
G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
if(!mesh)
{
mesh = new G4ScoringCylinder(newVal);
fSMan->RegisterScoringMesh(mesh);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
<< "] : Scoring mesh <" << newVal
<< "> already exists. Command ignored.";
command->CommandFailed(ed);
}
}
}
else if(command == meshRWLogVolCreateCmd)
{
auto mesh = fSMan->GetCurrentMesh();
if(mesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath() << "] : Mesh <"
<< mesh->GetWorldName()
<< "> is still open. Close it first. Command ignored.";
command->CommandFailed(ed);
}
else
{
G4Tokenizer next(newVal);
G4String meshName = next();
G4int idx = StoI(next());
mesh = fSMan->FindMesh(meshName);
if(!mesh)
{
mesh = new G4ScoringRealWorld(meshName);
mesh->SetCopyNumberLevel(idx);
fSMan->RegisterScoringMesh(mesh);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
<< "] : Scoring mesh <" << meshName
<< "> already exists. Command ignored.";
command->CommandFailed(ed);
}
}
}
else if(command == probeCreateCmd)
{
auto mesh = fSMan->GetCurrentMesh();
if(mesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath() << "] : Mesh <"
<< mesh->GetWorldName()
<< "> is still open. Close it first. Command ignored.";
command->CommandFailed(ed);
}
else
{
G4Tokenizer next(newVal);
G4String qname = next();
G4double halfSize = StoD(next());
halfSize *= G4UIcommand::ValueOf(next());
G4bool checkOverlap = StoB(next());
mesh = fSMan->FindMesh(qname);
if(!mesh)
{
mesh = new G4ScoringProbe(qname, halfSize, checkOverlap);
fSMan->RegisterScoringMesh(mesh);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << probeCreateCmd->GetCommandPath() << "] : Mesh name <"
<< qname << "> already exists. Use another name.";
command->CommandFailed(ed);
}
}
}
else if(command == probeMatCmd || command == probeLocateCmd)
{
auto mesh = fSMan->GetCurrentMesh();
if(!mesh)
{
G4ExceptionDescription ed;
ed << "ERROR : No mesh is currently open. Open/create a mesh first. "
"Command ignored.";
command->CommandFailed(ed);
return;
}
if(mesh->GetShape() != MeshShape::probe)
{
G4ExceptionDescription ed;
ed << "ERROR : Inconsistent mesh type. Close current mesh and open "
"Scoring Probe.";
command->CommandFailed(ed);
return;
}
if(command == probeMatCmd)
{
G4bool succ = static_cast<G4ScoringProbe*>(mesh)->SetMaterial(newVal);
if(!succ)
{
G4ExceptionDescription ed;
ed << "Material <" << newVal
<< "> is not defind in G4NistManager. Command is ignored.\n"
<< "Use /material/nist/listMaterials command to see the available "
"materials.";
command->CommandFailed(ed);
return;
}
}
else if(command == probeLocateCmd)
{
G4ThreeVector loc = probeLocateCmd->GetNew3VectorValue(newVal);
static_cast<G4ScoringProbe*>(mesh)->LocateProbe(loc);
}
}
else if(command == listColorMapCmd)
{
fSMan->ListScoreColorMaps();
}
else if(command == floatMinMaxCmd)
{
G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
if(colorMap)
{
colorMap->SetFloatingMinMax(true);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << floatMinMaxCmd->GetCommandPath() << "] : color map <"
<< newVal << "> is not defined. Command ignored.";
command->CommandFailed(ed);
}
}
else if(command == colorMapMinMaxCmd)
{
G4Tokenizer next(newVal);
G4String mapName = next();
G4double minVal = StoD(next());
G4double maxVal = StoD(next());
G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
if(colorMap)
{
colorMap->SetFloatingMinMax(false);
colorMap->SetMinMax(minVal, maxVal);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << colorMapMinMaxCmd->GetCommandPath() << "] : color map <"
<< newVal << "> is not defined. Command ignored." << G4endl;
command->CommandFailed(ed);
}
}
else if(command == meshOpnCmd)
{
G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
if(currentmesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Mesh <"
<< currentmesh->GetWorldName()
<< "> is still open. Close it first. Command ignored.";
command->CommandFailed(ed);
}
else
{
G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
if(!mesh)
{
G4ExceptionDescription ed;
ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Scoring mesh <"
<< newVal << "> does not exist. Command ignored.";
command->CommandFailed(ed);
}
else
{
fSMan->SetCurrentMesh(mesh);
}
}
}
else if(command == meshClsCmd)
{
fSMan->CloseCurrentMesh();
}
else
{
//
// Get Current Mesh
//
G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
//
// Commands for Current Mesh
if(mesh)
{
MeshShape shape = mesh->GetShape();
if(shape == MeshShape::realWorldLogVol)
{
G4ExceptionDescription ed;
ed << "ERROR[" << mBinCmd->GetCommandPath()
<< "] : Number of mesh command cannot be set for this type of mesh. "
"Command ignored.";
command->CommandFailed(ed);
}
else
{
// Tokens
G4TokenVec token;
FillTokenVec(newVal, token);
//
// Mesh Geometry
//
// if(command==meshActCmd) {
// mesh->Activate(meshActCmd->GetNewBoolValue(newVal));
// } else
if(command == mBoxSizeCmd)
{
if(shape == MeshShape::box)
{
G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
G4double vsize[3];
vsize[0] = size.x();
vsize[1] = size.y();
vsize[2] = size.z();
mesh->SetSize(vsize);
}
else
{
G4ExceptionDescription ed;
ed << "ERROR[" << mBoxSizeCmd->GetCommandPath()
<< "] : This mesh is not Box. Command ignored.";
command->CommandFailed(ed);
}
}
else if(command == mCylinderSizeCmd || command == mCylinderRMinCmd ||
command == mCylinderAngleCmd)
{
if(shape != MeshShape::cylinder)
{
G4ExceptionDescription ed;
ed << "ERROR[" << command->GetCommandPath()
<< "] : This mesh is not Cylinder. Command ignored.";
command->CommandFailed(ed);
}
else
{
if(command == mCylinderSizeCmd)
{
G4double vsize[3];
vsize[0] = (mesh->GetSize()).x();
vsize[1] = StoD(token[0]);
vsize[2] = StoD(token[1]);
G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
vsize[1] *= unt;
vsize[2] *= unt;
mesh->SetSize(vsize);
}
else if(command == mCylinderRMinCmd)
{
G4double vsize[3];
vsize[0] = mCylinderRMinCmd->GetNewDoubleValue(newVal);
vsize[1] = (mesh->GetSize()).y();
vsize[2] = (mesh->GetSize()).z();
mesh->SetSize(vsize);
}
else if(command == mCylinderAngleCmd)
{
G4double stphi = StoD(token[0]);
G4double spphi = StoD(token[1]);
G4double unt = mCylinderAngleCmd->ValueOf(token[2]);
mesh->SetAngles(stphi * unt, spphi * unt);
}
}
}
else if(command == mBinCmd)
{
MeshBinCommand(mesh, token);
}
else if(command == mTResetCmd)
{
G4double centerPosition[3] = { 0., 0., 0. };
mesh->SetCenterPosition(centerPosition);
}
else if(command == mTXyzCmd)
{
G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
G4double centerPosition[3];
centerPosition[0] = xyz.x();
centerPosition[1] = xyz.y();
centerPosition[2] = xyz.z();
mesh->SetCenterPosition(centerPosition);
// } else if(command==mRResetCmd) {
}
else if(command == mRotXCmd)
{
G4double value = mRotXCmd->GetNewDoubleValue(newVal);
mesh->RotateX(value);
}
else if(command == mRotYCmd)
{
G4double value = mRotYCmd->GetNewDoubleValue(newVal);
mesh->RotateY(value);
}
else if(command == mRotZCmd)
{
G4double value = mRotZCmd->GetNewDoubleValue(newVal);
mesh->RotateZ(value);
}
}
}
else
{
G4ExceptionDescription ed;
ed << "ERROR: No mesh is currently open. Open/create a mesh first. "
"Command ignored.";
command->CommandFailed(ed);
}
}
}
G4String G4ScoringMessenger::GetCurrentValue(G4UIcommand* command)
{
G4String val;
if(command == verboseCmd)
{
val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel());
}
return val;
}
void G4ScoringMessenger::FillTokenVec(G4String newValues, G4TokenVec& token)
{
G4Tokenizer next(newValues);
G4String val;
while(!(val = next()).isNull())
{ // Loop checking 12.18.2015 M.Asai
token.push_back(val);
}
}
void G4ScoringMessenger::MeshBinCommand(G4VScoringMesh* mesh, G4TokenVec& token)
{
G4int Ni = StoI(token[0]);
G4int Nj = StoI(token[1]);
G4int Nk = StoI(token[2]);
G4int nSegment[3];
if(dynamic_cast<G4ScoringBox*>(mesh))
{
G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox"
<< G4endl;
nSegment[0] = Ni;
nSegment[1] = Nj;
nSegment[2] = Nk;
}
else if(dynamic_cast<G4ScoringCylinder*>(mesh))
{
G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder"
<< G4endl;
nSegment[0] = Nj;
nSegment[1] = Nk;
nSegment[2] = Ni;
}
else
{
G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException,
"invalid mesh type");
return;
}
//
mesh->SetNumberOfSegments(nSegment);
}
#include "G4VPrimitivePlotter.hh"
#include "G4VScoreHistFiller.hh"
void G4ScoringMessenger::Fill1D(G4UIcommand* cmd, G4String newVal)
{
using MeshShape = G4VScoringMesh::MeshShape;
G4Tokenizer next(newVal);
G4int histID = StoI(next());
G4String meshName = next();
G4String primName = next();
G4int copyNo = StoI(next());
auto filler = G4VScoreHistFiller::Instance();
if(!filler)
{
G4ExceptionDescription ed;
ed << "G4TScoreHistFiller is not instantiated in this application.";
cmd->CommandFailed(ed);
return;
}
//
// To do : check the validity of histID
//
auto sm = G4ScoringManager::GetScoringManagerIfExist();
auto mesh = sm->FindMesh(meshName);
if(mesh == nullptr)
{
G4ExceptionDescription ed;
ed << "Mesh name <" << meshName << "> is not found.";
cmd->CommandFailed(ed);
return;
}
auto shape = mesh->GetShape();
if(shape != MeshShape::realWorldLogVol && shape != MeshShape::probe)
{
G4ExceptionDescription ed;
ed << "Mesh <" << meshName
<< "> is not real-world logical volume or probe.";
cmd->CommandFailed(ed);
return;
}
auto prim = mesh->GetPrimitiveScorer(primName);
if(prim == nullptr)
{
G4ExceptionDescription ed;
ed << "Primitive scorer name <" << primName << "> is not found.";
cmd->CommandFailed(ed);
return;
}
auto pp = dynamic_cast<G4VPrimitivePlotter*>(prim);
if(pp == nullptr)
{
G4ExceptionDescription ed;
ed << "Primitive scorer <" << primName
<< "> does not support direct histogram filling.";
cmd->CommandFailed(ed);
return;
}
pp->Plot(copyNo, histID);
}
Reference in New Issue View Git Blame Copy Permalink