EDepSimSpillTimeFactory.cc

Go to the documentation of this file.

#include <sstream>

#include <globals.hh>

#include <EDepSimLog.hh>

#include "kinem/EDepSimVTimeFactory.hh"
#include "kinem/EDepSimSpillTimeFactory.hh"
#include "kinem/EDepSimSpillTimeGenerator.hh"

EDepSim::SpillTimeFactory::SpillTimeFactory(
    EDepSim::UserPrimaryGeneratorMessenger* parent) 
    : EDepSim::VTimeFactory("spill",parent),
      fSpillTime(100*ns), 
      fBunchSeparation(582*ns),
      fBunchLength(12.4*ns) {
    
    fSpillTimeCMD = new G4UIcmdWithADoubleAndUnit(CommandName("start"),this);
    fSpillTimeCMD->SetGuidance("Set the start time of the spill.");
    fSpillTimeCMD->SetParameterName("time",false);
    fSpillTimeCMD->SetUnitCategory("Time");

    fBunchSepCMD = new G4UIcmdWithADoubleAndUnit(CommandName("bunchSep"),this);
    fBunchSepCMD->SetGuidance("Set the time between bunch starts.");
    fBunchSepCMD->SetParameterName("time",false);
    fBunchSepCMD->SetUnitCategory("Time");

    fBunchLengthCMD = new G4UIcmdWithADoubleAndUnit(CommandName("bunchLength"),
                                                    this);
    fBunchLengthCMD->SetGuidance("Set the length of a bunch.");
    fBunchLengthCMD->SetParameterName("time",false);
    fBunchLengthCMD->SetUnitCategory("Time");

    fBunchCountCMD = new G4UIcmdWithAnInteger(CommandName("bunchCount"),
                                              this);
    fBunchCountCMD->SetGuidance("Set the number of bunchs in a spill.  "
                                "Reset bunch power to default.");
    fBunchCountCMD->SetParameterName("count",false);

    fBunchPowerCMD = new G4UIcommand(CommandName("bunchPower"),this);
    fBunchPowerCMD->SetGuidance("Set the power in a bunch "
                                "(bunchs are numbered from ONE)");
    G4UIparameter* bunchPar = new G4UIparameter('i');
    bunchPar->SetParameterName("bunch");
    fBunchPowerCMD->SetParameter(bunchPar);
    G4UIparameter* powerPar = new G4UIparameter('d');
    powerPar->SetParameterName("power");
    fBunchPowerCMD->SetParameter(powerPar);
    
    //Initialize the bunchs
    SetBunchCount(6);

}

EDepSim::SpillTimeFactory::~SpillTimeFactory() {
    delete fSpillTimeCMD;
    delete fBunchSepCMD;
    delete fBunchLengthCMD;
    delete fBunchCountCMD;
    delete fBunchPowerCMD;
}

void EDepSim::SpillTimeFactory::SetNewValue(G4UIcommand* command,
                                           G4String newValue) {
    if (command == fSpillTimeCMD) {
        SetSpillTime(fSpillTimeCMD->GetNewDoubleValue(newValue));
    }
    else if (command == fBunchSepCMD) {
        SetBunchSeparation(fBunchSepCMD->GetNewDoubleValue(newValue));
    }
    else if (command == fBunchLengthCMD) {
        SetBunchLength(fBunchLengthCMD->GetNewDoubleValue(newValue));
    }
    else if (command == fBunchCountCMD) {
        SetBunchCount(fBunchCountCMD->GetNewIntValue(newValue));
    }
    else if (command == fBunchPowerCMD) {
        std::istringstream input((char*)newValue.c_str());
        int bunch;
        double power;
        input >> bunch >> power;
        SetBunchPower(bunch,power);
    }
}

EDepSim::VTimeGenerator* EDepSim::SpillTimeFactory::GetGenerator() {
    EDepSim::VTimeGenerator* time = new EDepSim::SpillTimeGenerator(
        GetName(),fSpillTime,fBunchSeparation,fBunchLength,fBunchPower);
    return time;
}

void EDepSim::SpillTimeFactory::SetBunchCount(int bunchs) {
    fBunchPower.resize(bunchs);
    for (std::vector<double>::iterator b = fBunchPower.begin();
         b != fBunchPower.end();
         ++b) {
        *b = 1.0;
    }
}

void EDepSim::SpillTimeFactory::SetBunchPower(int bunch, double power) {
    if (bunch<1 || (unsigned) bunch > fBunchPower.size()) {
        EDepSimError("Illegal bunch number: " << bunch);
        EDepSimError("Invalid bunch structure");
    }
    fBunchPower[bunch-1] = power;
}