// // ******************************************************************** // * 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 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(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(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(mesh)) { G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox" << G4endl; nSegment[0] = Ni; nSegment[1] = Nj; nSegment[2] = Nk; } else if(dynamic_cast(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(prim); if(pp == nullptr) { G4ExceptionDescription ed; ed << "Primitive scorer <" << primName << "> does not support direct histogram filling."; cmd->CommandFailed(ed); return; } pp->Plot(copyNo, histID); }