Gabriele Cosmo
351 lines
16 KiB
C++
351 lines
16 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Class Name: G4AdjointCrossSurfChecker
|
|
// Author: L. Desorgher
|
|
// Organisation: SpaceIT GmbH
|
|
// Contract: ESA contract 21435/08/NL/AT
|
|
// Customer: ESA/ESTEC
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <sstream>
|
|
|
|
#include "G4AdjointSimMessenger.hh"
|
|
#include "G4RunManager.hh"
|
|
#include "G4AdjointSimManager.hh"
|
|
#include "G4UIdirectory.hh"
|
|
#include "G4UIcmdWithABool.hh"
|
|
#include "G4UIcmdWithAnInteger.hh"
|
|
#include "G4UIcmdWithADoubleAndUnit.hh"
|
|
#include "G4UIcmdWithADouble.hh"
|
|
#include "G4UIcmdWithoutParameter.hh"
|
|
#include "G4UIcmdWithAString.hh"
|
|
#include "G4UnitsTable.hh"
|
|
#include "G4UIcmdWith3VectorAndUnit.hh"
|
|
/*
|
|
#ifdef G4MULTITHREADED
|
|
#include "G4MTAdjointSimManager.hh"
|
|
#endif
|
|
*/
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
G4AdjointSimMessenger::G4AdjointSimMessenger(G4AdjointSimManager* pAdjointRunManager)
|
|
: theAdjointRunManager(pAdjointRunManager)
|
|
/*
|
|
#ifdef G4MULTITHREADED
|
|
,theMTAdjointRunManager(0),beamOnCmd(0)
|
|
#endif
|
|
*/
|
|
|
|
{
|
|
AdjointSimDir = new G4UIdirectory("/adjoint/");
|
|
AdjointSimDir->SetGuidance("Control of the adjoint or reverse monte carlo simulation");
|
|
|
|
|
|
//Start and adjoint Run
|
|
//---------------------
|
|
//if (G4RunManager::GetRunManager()->GetRunManagerType() == G4RunManager::sequentialRM){
|
|
beamOnCmd = new G4UIcommand("/adjoint/start_run",this);
|
|
beamOnCmd->SetGuidance("Start an adjoint Run.");
|
|
beamOnCmd->SetGuidance("Default number of events to be processed is 1.");
|
|
beamOnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
G4UIparameter* p1 = new G4UIparameter("numberOfEvent",'i',true);
|
|
p1->SetDefaultValue(1);
|
|
p1->SetParameterRange("numberOfEvent >= 0");
|
|
beamOnCmd->SetParameter(p1);
|
|
//}
|
|
|
|
//Commands to define parameters relative to the external source
|
|
//------------------------------------------------------------
|
|
|
|
G4UIparameter* pos_x_par = new G4UIparameter("X",'d',true);
|
|
|
|
G4UIparameter* pos_y_par = new G4UIparameter("Y",'d',true);
|
|
|
|
G4UIparameter* pos_z_par = new G4UIparameter("Z",'d',true);
|
|
|
|
G4UIparameter* radius_par = new G4UIparameter("R",'d',true);
|
|
|
|
radius_par->SetParameterRange("R >= 0");
|
|
|
|
G4UIparameter* unit_par = new G4UIparameter("unit",'s',true);
|
|
|
|
DefineSpherExtSourceCmd = new G4UIcommand("/adjoint/DefineSphericalExtSource",this);
|
|
DefineSpherExtSourceCmd->SetGuidance("Define a spherical external source.");
|
|
DefineSpherExtSourceCmd->SetParameter(pos_x_par);
|
|
DefineSpherExtSourceCmd->SetParameter(pos_y_par);
|
|
DefineSpherExtSourceCmd->SetParameter(pos_z_par);
|
|
DefineSpherExtSourceCmd->SetParameter(radius_par);
|
|
DefineSpherExtSourceCmd->SetParameter(unit_par);
|
|
|
|
G4UIparameter* phys_vol_name_par = new G4UIparameter("phys_vol_name",'s',true);
|
|
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd= new G4UIcommand("/adjoint/DefineSphericalExtSourceCenteredOnAVolume",this);
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd->SetGuidance("Define a spherical external source with the center located at the center of a physical volume");
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(phys_vol_name_par);
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(radius_par);
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(unit_par);
|
|
|
|
DefineExtSourceOnAVolumeExtSurfaceCmd= new G4UIcmdWithAString("/adjoint/DefineExtSourceOnExtSurfaceOfAVolume",this);
|
|
DefineExtSourceOnAVolumeExtSurfaceCmd->SetGuidance("Set the external source on the external surface of a physical volume");
|
|
DefineExtSourceOnAVolumeExtSurfaceCmd->SetParameterName("phys_vol_name",false);
|
|
|
|
setExtSourceEMaxCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetExtSourceEmax",this);
|
|
setExtSourceEMaxCmd->SetGuidance("Set the maximum energy of the external source");
|
|
setExtSourceEMaxCmd->SetParameterName("Emax",false);
|
|
setExtSourceEMaxCmd->SetUnitCategory("Energy");
|
|
setExtSourceEMaxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
//Commands to define the adjoint source
|
|
//------------------------------------------------------------
|
|
|
|
DefineSpherAdjSourceCmd = new G4UIcommand("/adjoint/DefineSphericalAdjSource",this);
|
|
DefineSpherAdjSourceCmd->SetGuidance("Define a spherical adjoint source.");
|
|
DefineSpherAdjSourceCmd->SetParameter(pos_x_par);
|
|
DefineSpherAdjSourceCmd->SetParameter(pos_y_par);
|
|
DefineSpherAdjSourceCmd->SetParameter(pos_z_par);
|
|
DefineSpherAdjSourceCmd->SetParameter(radius_par);
|
|
DefineSpherAdjSourceCmd->SetParameter(unit_par);
|
|
|
|
DefineSpherAdjSourceCenteredOnAVolumeCmd= new G4UIcommand("/adjoint/DefineSphericalAdjSourceCenteredOnAVolume",this);
|
|
DefineSpherAdjSourceCenteredOnAVolumeCmd->SetGuidance("Define a spherical adjoint source with the center located at the center of a physical volume");
|
|
DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(phys_vol_name_par);
|
|
DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(radius_par);
|
|
DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(unit_par);
|
|
|
|
DefineAdjSourceOnAVolumeExtSurfaceCmd= new G4UIcmdWithAString("/adjoint/DefineAdjSourceOnExtSurfaceOfAVolume",this);
|
|
DefineAdjSourceOnAVolumeExtSurfaceCmd->SetGuidance("Set the adjoint source on the external surface of physical volume");
|
|
DefineAdjSourceOnAVolumeExtSurfaceCmd->SetParameterName("phys_vol_name",false);
|
|
|
|
setAdjSourceEminCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetAdjSourceEmin",this);
|
|
setAdjSourceEminCmd->SetGuidance("Set the minimum energy of the adjoint source");
|
|
setAdjSourceEminCmd->SetParameterName("Emin",false);
|
|
setAdjSourceEminCmd->SetUnitCategory("Energy");
|
|
setAdjSourceEminCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
setAdjSourceEmaxCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetAdjSourceEmax",this);
|
|
setAdjSourceEmaxCmd->SetGuidance("Set the maximum energy of the adjoint source");
|
|
setAdjSourceEmaxCmd->SetParameterName("Emax",false);
|
|
setAdjSourceEmaxCmd->SetUnitCategory("Energy");
|
|
setAdjSourceEmaxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
ConsiderParticleAsPrimaryCmd = new G4UIcmdWithAString("/adjoint/ConsiderAsPrimary",this);
|
|
ConsiderParticleAsPrimaryCmd->SetGuidance("Set the selected particle as primary");
|
|
ConsiderParticleAsPrimaryCmd->SetParameterName("particle",false);
|
|
ConsiderParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
|
|
|
|
NeglectParticleAsPrimaryCmd= new G4UIcmdWithAString("/adjoint/NeglectAsPrimary",this);
|
|
NeglectParticleAsPrimaryCmd->SetGuidance("Remove the selected particle from the list of primaries");
|
|
NeglectParticleAsPrimaryCmd->SetParameterName("particle",false);
|
|
NeglectParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
|
|
|
|
|
|
setNbOfPrimaryFwdGammasPerEventCmd =
|
|
new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryFwdGammasPerEvent",this);
|
|
setNbOfPrimaryFwdGammasPerEventCmd->SetGuidance("Set the nb of primary fwd gamm generated on the adjoint source");
|
|
setNbOfPrimaryFwdGammasPerEventCmd->SetParameterName("Nb_gammas",false);
|
|
setNbOfPrimaryFwdGammasPerEventCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
setNbOfPrimaryAdjGammasPerEventCmd =
|
|
new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryAdjGammasPerEvent",this);
|
|
setNbOfPrimaryAdjGammasPerEventCmd->SetGuidance("Set the nb of primary fwd gamm generated on the adjoint source");
|
|
setNbOfPrimaryAdjGammasPerEventCmd->SetParameterName("Nb_gammas",false);
|
|
setNbOfPrimaryAdjGammasPerEventCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
setNbOfPrimaryAdjElectronsPerEventCmd =
|
|
new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryAdjElectronsPerEvent",this);
|
|
setNbOfPrimaryAdjElectronsPerEventCmd->SetGuidance("Set the nb of primary fwd gamm generated on the adjoint source");
|
|
setNbOfPrimaryAdjElectronsPerEventCmd->SetParameterName("Nb_gammas",false);
|
|
setNbOfPrimaryAdjElectronsPerEventCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
|
|
|
|
|
|
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/*
|
|
#ifdef G4MULTITHREADED
|
|
G4AdjointSimMessenger::G4AdjointSimMessenger(G4MTAdjointSimManager* pAdjointRunManager)
|
|
: theAdjointRunManager(0),theMTAdjointRunManager(pAdjointRunManager),DefineSpherExtSourceCmd(0),
|
|
DefineSpherExtSourceCenteredOnAVolumeCmd(0), DefineExtSourceOnAVolumeExtSurfaceCmd(0),
|
|
setExtSourceEMaxCmd(0),DefineSpherAdjSourceCmd(0),DefineSpherAdjSourceCenteredOnAVolumeCmd(0),
|
|
DefineAdjSourceOnAVolumeExtSurfaceCmd(0),setAdjSourceEminCmd(0),setAdjSourceEmaxCmd(0),
|
|
ConsiderParticleAsPrimaryCmd(0),NeglectParticleAsPrimaryCmd(0)
|
|
{
|
|
AdjointSimDir = new G4UIdirectory("/adjoint/");
|
|
AdjointSimDir->SetGuidance("Control of the adjoint or reverse monte carlo simulation");
|
|
|
|
|
|
//Start and adjoint Run
|
|
//---------------------
|
|
beamOnCmd = new G4UIcommand("/adjoint/start_run",this);
|
|
beamOnCmd->SetGuidance("Start an adjoint Run.");
|
|
beamOnCmd->SetGuidance("Default number of events to be processed is 1.");
|
|
beamOnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
|
|
G4UIparameter* p1 = new G4UIparameter("numberOfEvent",'i',true);
|
|
p1->SetDefaultValue(1);
|
|
p1->SetParameterRange("numberOfEvent >= 0");
|
|
beamOnCmd->SetParameter(p1);
|
|
|
|
|
|
ConsiderParticleAsPrimaryCmd = new G4UIcmdWithAString("/adjoint/ConsiderAsPrimary",this);
|
|
ConsiderParticleAsPrimaryCmd->SetGuidance("Set the selected particle as primary");
|
|
ConsiderParticleAsPrimaryCmd->SetParameterName("particle",false);
|
|
ConsiderParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
|
|
|
|
NeglectParticleAsPrimaryCmd= new G4UIcmdWithAString("/adjoint/NeglectAsPrimary",this);
|
|
NeglectParticleAsPrimaryCmd->SetGuidance("Remove the selected particle from the lits of primaries");
|
|
NeglectParticleAsPrimaryCmd->SetParameterName("particle",false);
|
|
NeglectParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
|
|
|
|
|
|
}
|
|
#endif
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
|
|
G4AdjointSimMessenger::~G4AdjointSimMessenger()
|
|
{
|
|
if (beamOnCmd) delete beamOnCmd;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
|
|
void G4AdjointSimMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
|
|
{
|
|
if (!command) return;
|
|
if( command==beamOnCmd )
|
|
{
|
|
G4int nev;
|
|
const char* nv = (const char*)newValue;
|
|
std::istringstream is(nv);
|
|
is >> nev ;
|
|
if (G4RunManager::GetRunManager()->GetRunManagerType() == G4RunManager::sequentialRM) theAdjointRunManager->RunAdjointSimulation(nev);
|
|
/*
|
|
#ifdef G4MULTITHREADED
|
|
else if (theMTAdjointRunManager) theMTAdjointRunManager->RunAdjointSimulation(nev);
|
|
else if (theAdjointRunManager) theAdjointRunManager->SwitchToAdjointSimulationMode();
|
|
#endif
|
|
*/
|
|
//G4cout<<"G4AdjointSimMessenger::SetNewValue BeamOnCmd out"<<std::endl;
|
|
}
|
|
else if ( command==ConsiderParticleAsPrimaryCmd){
|
|
theAdjointRunManager->ConsiderParticleAsPrimary(newValue);
|
|
}
|
|
else if ( command==NeglectParticleAsPrimaryCmd){
|
|
theAdjointRunManager->NeglectParticleAsPrimary(newValue);
|
|
}
|
|
/*
|
|
#ifdef G4MULTITHREADED
|
|
if (G4RunManager::GetRunManager()->GetRunManagerType() == G4RunManager::masterRM) return;
|
|
#endif
|
|
*/
|
|
if ( command==DefineSpherExtSourceCmd){
|
|
|
|
G4double x,y,z,r;
|
|
G4String unit;
|
|
const char* nv = (const char*)newValue;
|
|
std::istringstream is(nv);
|
|
is >> x>>y>>z>>r>>unit;
|
|
|
|
x*=G4UnitDefinition::GetValueOf(unit);
|
|
y*=G4UnitDefinition::GetValueOf(unit);
|
|
z*=G4UnitDefinition::GetValueOf(unit);
|
|
r*=G4UnitDefinition::GetValueOf(unit);
|
|
theAdjointRunManager->DefineSphericalExtSource(r,G4ThreeVector(x,y,z));
|
|
}
|
|
else if ( command==DefineSpherExtSourceCenteredOnAVolumeCmd){
|
|
|
|
G4double r;
|
|
G4String vol_name, unit;
|
|
const char* nv = (const char*)newValue;
|
|
std::istringstream is(nv);
|
|
is >>vol_name>>r>>unit;
|
|
r*=G4UnitDefinition::GetValueOf(unit);
|
|
theAdjointRunManager->DefineSphericalExtSourceWithCentreAtTheCentreOfAVolume(r,vol_name);
|
|
}
|
|
else if ( command==DefineExtSourceOnAVolumeExtSurfaceCmd){
|
|
theAdjointRunManager->DefineExtSourceOnTheExtSurfaceOfAVolume(newValue);
|
|
}
|
|
else if ( command== setExtSourceEMaxCmd){
|
|
|
|
theAdjointRunManager->SetExtSourceEmax(setExtSourceEMaxCmd->GetNewDoubleValue(newValue));
|
|
}
|
|
else if ( command==DefineSpherAdjSourceCmd){
|
|
|
|
G4double x,y,z,r;
|
|
G4String unit;
|
|
const char* nv = (const char*)newValue;
|
|
std::istringstream is(nv);
|
|
is >> x>>y>>z>>r>>unit;
|
|
|
|
x*=G4UnitDefinition::GetValueOf(unit);
|
|
y*=G4UnitDefinition::GetValueOf(unit);
|
|
z*=G4UnitDefinition::GetValueOf(unit);
|
|
r*=G4UnitDefinition::GetValueOf(unit);
|
|
theAdjointRunManager->DefineSphericalAdjointSource(r,G4ThreeVector(x,y,z));
|
|
}
|
|
else if ( command==DefineSpherAdjSourceCenteredOnAVolumeCmd){
|
|
|
|
G4double r;
|
|
G4String vol_name, unit;
|
|
const char* nv = (const char*)newValue;
|
|
std::istringstream is(nv);
|
|
is >>vol_name>>r>>unit;
|
|
r*=G4UnitDefinition::GetValueOf(unit);
|
|
theAdjointRunManager->DefineSphericalAdjointSourceWithCentreAtTheCentreOfAVolume(r,vol_name);
|
|
}
|
|
else if ( command==DefineAdjSourceOnAVolumeExtSurfaceCmd){
|
|
|
|
theAdjointRunManager->DefineAdjointSourceOnTheExtSurfaceOfAVolume(newValue);
|
|
}
|
|
else if ( command== setAdjSourceEminCmd){
|
|
|
|
theAdjointRunManager->SetAdjointSourceEmin(setAdjSourceEminCmd->GetNewDoubleValue(newValue));
|
|
}
|
|
else if ( command== setAdjSourceEmaxCmd){
|
|
|
|
theAdjointRunManager->SetAdjointSourceEmax(setAdjSourceEmaxCmd->GetNewDoubleValue(newValue));
|
|
}
|
|
else if ( command== setNbOfPrimaryFwdGammasPerEventCmd){
|
|
theAdjointRunManager->SetNbOfPrimaryFwdGammasPerEvent(setNbOfPrimaryFwdGammasPerEventCmd->GetNewIntValue(newValue));
|
|
}
|
|
else if ( command== setNbOfPrimaryAdjGammasPerEventCmd){
|
|
theAdjointRunManager->SetNbAdjointPrimaryGammasPerEvent(setNbOfPrimaryAdjGammasPerEventCmd->GetNewIntValue(newValue));
|
|
}
|
|
else if ( command== setNbOfPrimaryAdjElectronsPerEventCmd){
|
|
theAdjointRunManager->SetNbAdjointPrimaryElectronsPerEvent(setNbOfPrimaryAdjElectronsPerEventCmd->GetNewIntValue(newValue));
|
|
}
|
|
|
|
|
|
}
|
|
|