ML2MainMessenger.cc

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
// The code was written by :
//  ^Claudio Andenna  claudio.andenna@ispesl.it, claudio.andenna@iss.infn.it
//      *Barbara Caccia barbara.caccia@iss.it
//      with the support of Pablo Cirrone (LNS, INFN Catania Italy)
//  with the contribute of Alessandro Occhigrossi*
//
// ^INAIL DIPIA - ex ISPESL and INFN Roma, gruppo collegato Sanità, Italy
// *Istituto Superiore di Sanità and INFN Roma, gruppo collegato Sanità, Italy
//  Viale Regina Elena 299, 00161 Roma (Italy)
//  tel (39) 06 49902246
//  fax (39) 06 49387075
//
// more information:
// http://g4advancedexamples.lngs.infn.it/Examples/medical-linac
//
//*******************************************************//

#include "ML2MainMessenger.hh"
#include "G4SystemOfUnits.hh"

CML2MainMessenger::CML2MainMessenger(CML2CInputData *InData)  
{

    CInputData=InData;
    phaseSpaceCentre=new G4UIcmdWith3VectorAndUnit("/general/centrePhaseSpace", this);
    phaseSpaceCentre->SetDefaultUnit("mm");
    phaseSpaceCentre->SetDefaultValue(G4ThreeVector(0.,0.,164.));
    phaseSpaceCentre->SetGuidance("position of the centre of the plane phase space");
    CInputData->setPhaseSpaceCentre(G4ThreeVector(0.*mm,0.*mm,164.*mm));

    phaseSpaceHalfSize=new G4UIcmdWith3VectorAndUnit("/general/halfSizePhaseSpace", this);
    phaseSpaceHalfSize->SetDefaultUnit("mm");
    phaseSpaceHalfSize->SetDefaultValue(G4ThreeVector(100.,100.,1.));
    phaseSpaceHalfSize->SetGuidance("half size of the plane phase space");
    CInputData->setPhaseSpaceHalfSize(G4ThreeVector(100.*mm,100.*mm,1.*mm));

    bSavePhaseSpace=new G4UIcmdWithABool("/general/bSavePhaseSpace",this);
    bSavePhaseSpace->SetDefaultValue(false);
    bSavePhaseSpace->SetGuidance("true if to save the phase space");
    CInputData->setbSavePhaseSPace(false);

    bForcePhaseSpaceBeforeJaws=new G4UIcmdWithABool("/general/bForcePhaseSpaceBeforeJaws",this);
    bForcePhaseSpaceBeforeJaws->SetDefaultValue(false);
    bForcePhaseSpaceBeforeJaws->SetGuidance("to automatically put the phase plane before the jaws");
    CInputData->setbForcePhaseSpaceBeforeJaws(false);

    bStopAtPhaseSpace=new G4UIcmdWithABool("/general/bStopAtPhaseSpace",this);
    bStopAtPhaseSpace->SetDefaultValue(false);
    bStopAtPhaseSpace->SetGuidance("true if to kill the particle at the phase space");
    CInputData->setbStopAtPhaseSpace(false);

    bSaveROG=new G4UIcmdWithABool("/general/bSaveROG",this);
    bSaveROG->SetDefaultValue(true);
    bSaveROG->SetGuidance("true if save the ROG volume");
    CInputData->setbSaveROG(true);

    bOnlyVisio=new G4UIcmdWithABool("/OnlyVisio",this);
    bOnlyVisio->SetDefaultValue(false);
    bOnlyVisio->SetGuidance("switch the visualization mode");
    CInputData->setbOnlyVisio(false);

    ROGOutFile=new G4UIcmdWithAString("/general/ROGOutFile",this);
    ROGOutFile->SetDefaultValue("");
    ROGOutFile->SetGuidance("full path of the ROG file name");
    CInputData->setROGOutFile("defaultROGFile.txt");

    phaseSPaceOutFile=new G4UIcmdWithAString("/general/PhaseSpaceOutFile",this);
    phaseSPaceOutFile->SetDefaultValue("");
    phaseSPaceOutFile->SetGuidance("full file name of the phase space");
    CInputData->setPhaseSpaceOutFile("");

    maxNumberOfEvents=new G4UIcmdWithAnInteger("/convergence/maxNumberOfEvents", this);
    maxNumberOfEvents->SetDefaultValue(10);
    maxNumberOfEvents->SetGuidance(" maximum number of events at least in one experimental voxel");
    CInputData->setMaxNumberOfEvents(10);

    nMaxLoop=new G4UIcmdWithAnInteger("/convergence/nMaxLoop", this);
    nMaxLoop->SetDefaultValue(1);
    nMaxLoop->SetGuidance("it is used if /convergence/bCompareExp is false");
    CInputData->setNmaxLoop(1);

    bCompareExp=new G4UIcmdWithABool("/convergence/bCompareExp",this);
    bCompareExp->SetDefaultValue(false);
    bCompareExp->SetGuidance("to compare the data with an experimental  file data");
    CInputData->setBCompareExp(false);

    fileExperimentalData=new G4UIcmdWithAString("/convergence/fileExperimentalData",this);
    fileExperimentalData->SetDefaultValue("");
    fileExperimentalData->SetGuidance("full path and name of the experimental file results");
    CInputData->setFileExperimentalData("");

    fileExperimentalDataOut=new G4UIcmdWithAString("/convergence/fileExperimentalDataOut",this);
    fileExperimentalDataOut->SetDefaultValue("");
    fileExperimentalDataOut->SetGuidance("full path and name of the experimental file results");
    CInputData->setFileExperimentalDataOut("");

    nBeam=new G4UIcmdWithAnInteger("/general/nBeam",this);
    nBeam->SetDefaultValue(100);
    nBeam->SetGuidance("number of events to run");
    CInputData->setNBeams(100);

    nMaxParticlesInRamPlanePhaseSpace=new G4UIcmdWithAnInteger("/general/nMaxParticlesInRamPlanePhaseSpace",this);
    nMaxParticlesInRamPlanePhaseSpace->SetDefaultValue(10000);
    nMaxParticlesInRamPlanePhaseSpace->SetGuidance("maximum particle number stored in RAM before saving - for phase space");
    CInputData->setNMaxParticlesInRamPlanePhaseSpace(10000);

    saving_in_Selected_Voxels_every_events=new G4UIcmdWithAnInteger("/general/saving_in_Selected_Voxels_every_events",this);
    saving_in_Selected_Voxels_every_events->SetDefaultValue(10000);
    saving_in_Selected_Voxels_every_events->SetGuidance("maximum particle number stored before saving - for experiemntal data comparison");
    CInputData->setSaving_in_Selected_Voxels_every_events(10000);

    saving_in_ROG_Voxels_every_events=new G4UIcmdWithAnInteger("/general/saving_in_ROG_Voxels_every_events",this);
    saving_in_ROG_Voxels_every_events->SetDefaultValue(1000);
    saving_in_ROG_Voxels_every_events->SetGuidance("maximum particle number stored before saving - for ROG");
    CInputData->setSaving_in_ROG_Voxels_every_events(1000);

    max_N_particles_in_PhSp_File=new G4UIcmdWithAnInteger("/general/max_N_particles_in_PhSp_File",this);
    max_N_particles_in_PhSp_File->SetDefaultValue(1000);
    max_N_particles_in_PhSp_File->SetGuidance("maximum particle number stored in the phase space file");
    CInputData->setMax_N_particles_in_PhSp_File(1000);
}

CML2MainMessenger::~CML2MainMessenger(void)
{
    delete saving_in_Selected_Voxels_every_events; 
    delete saving_in_ROG_Voxels_every_events;
    delete max_N_particles_in_PhSp_File;
    delete phaseSpaceCentre; 
    delete phaseSpaceHalfSize;
    delete phaseSPaceOutFile;
    delete ROGOutFile;
    delete bSavePhaseSpace;
    delete bForcePhaseSpaceBeforeJaws;
    delete bStopAtPhaseSpace;
    delete bSaveROG;

    delete nBeam;
    delete nMaxParticlesInRamPlanePhaseSpace;

    delete maxNumberOfEvents;
    delete bCompareExp;
    delete bOnlyVisio;
    delete fileExperimentalData;
    delete fileExperimentalDataOut;
    delete nMaxLoop;
}

void CML2MainMessenger::SetNewValue(G4UIcommand* cmd, G4String newValue)
{
    if (cmd==nBeam)
    {CInputData->setNBeams(nBeam->GetNewIntValue(newValue));}

    if (cmd==nMaxParticlesInRamPlanePhaseSpace)
    {CInputData->setNMaxParticlesInRamPlanePhaseSpace(nMaxParticlesInRamPlanePhaseSpace->GetNewIntValue(newValue));}

    if (cmd==saving_in_Selected_Voxels_every_events)
    {CInputData->setSaving_in_Selected_Voxels_every_events(saving_in_Selected_Voxels_every_events->GetNewIntValue(newValue));}

    if (cmd==saving_in_ROG_Voxels_every_events)
    {CInputData->setSaving_in_ROG_Voxels_every_events(saving_in_ROG_Voxels_every_events->GetNewIntValue(newValue));}

    if (cmd==max_N_particles_in_PhSp_File)
    {CInputData->setMax_N_particles_in_PhSp_File(max_N_particles_in_PhSp_File->GetNewIntValue(newValue));}

    if (cmd==phaseSpaceCentre)
    {CInputData->setPhaseSpaceCentre(phaseSpaceCentre->GetNew3VectorRawValue(newValue));}

    if (cmd==phaseSpaceHalfSize)
    {
        CInputData->setPhaseSpaceHalfSize(phaseSpaceHalfSize->GetNew3VectorRawValue(newValue));
    }

    if (cmd==bOnlyVisio)
    {CInputData->setbOnlyVisio(bOnlyVisio->GetNewBoolValue(newValue));}

    if (cmd==bForcePhaseSpaceBeforeJaws)
    {CInputData->setbForcePhaseSpaceBeforeJaws(bForcePhaseSpaceBeforeJaws->GetNewBoolValue(newValue));}

    if (cmd==bSavePhaseSpace)
    {CInputData->setbSavePhaseSPace(bSavePhaseSpace->GetNewBoolValue(newValue));}

    if (cmd==bSaveROG)
    {CInputData->setbSaveROG(bSaveROG->GetNewBoolValue(newValue));}

    if (cmd==bStopAtPhaseSpace)
    {CInputData->setbStopAtPhaseSpace(bStopAtPhaseSpace->GetNewBoolValue(newValue));}

    if (cmd==phaseSPaceOutFile)
    {CInputData->setPhaseSpaceOutFile(newValue);}

    if (cmd==ROGOutFile)
    {CInputData->setROGOutFile(newValue);}

    if (cmd==maxNumberOfEvents)
    {CInputData->setMaxNumberOfEvents(maxNumberOfEvents->GetNewIntValue(newValue));}

    if (cmd==nMaxLoop)
    {CInputData->setNmaxLoop(nMaxLoop->GetNewIntValue(newValue));}

    if (cmd==bCompareExp)
    {CInputData->setBCompareExp(bCompareExp->GetNewBoolValue(newValue));}

    if (cmd==fileExperimentalData)
    {CInputData->setFileExperimentalData(newValue);}

    if (cmd==fileExperimentalDataOut)
    {CInputData->setFileExperimentalDataOut(newValue);}
}