evgb::EvtTimeFNALBeam Class Reference

configurable FNAL Beam time distribution More...

#include "EvtTimeFNALBeam.h"

Inheritance diagram for evgb::EvtTimeFNALBeam:

Public Member Functions
	EvtTimeFNALBeam (const std::string &config)
virtual	~EvtTimeFNALBeam ()
virtual void	Config (const std::string &config)
virtual double	TimeOffset ()
virtual double	TimeOffset (std::vector< double > bi)
virtual void	PrintConfig (bool verbose=true)
	provide a means of printing the configuration More...
void	SetTimeBetweenBuckets (double val)
	specific methods for this variant More...
double	GetTimeBetweenBuckets () const
void	SetBucketTimeSigma (double val)
double	GetBucketTimeSigma () const
void	SetNBucketsPerBatch (int ival)
int	GetNBucketsPerBatch () const
void	SetNFilledBucketsPerBatch (int ival)
int	GetNFilledBucketsPerBatch () const
void	SetBatchIntensities (std::vector< double > bi)
void	SetDisallowedBatchMask (std::vector< int > disallow)
void	SetGlobalOffset (double val)
double	GetGlobalOffset () const
TRandom *	GetRandomGenerator () const
bool	IsRandomGeneratorOwned () const
bool	IsRandomGeneratorSeeded () const
void	SetRandomGenerator (TRandom *gen, bool isOwned)

Protected Member Functions
std::vector< std::string >	GetConfigTokens (const std::string &config)

Protected Attributes
TRandom *	fRndmGen
bool	fIsOwned
bool	fIsSeeded

Private Member Functions
void	CalculateCPDF (std::vector< double > batchi)

Private Attributes
double	fTimeBetweenBuckets
	time between buckets More...
double	fBucketTimeSigma
	how wide is distribution in bucket More...
int	fNBucketsPerBatch
int	fNFilledBucketsPerBatch
std::vector< double >	fCummulativeBatchPDF
	summed prob for batches More...
std::vector< int >	fDisallowedBatchMask
	disallow individual batches More...
double	fGlobalOffset
	always displaced by this (in ns) More...

Detailed Description

configurable FNAL Beam time distribution

Author

Robert Hatcher <rhatcher fnal.gov> Fermi National Accelerator Laboratory

2015-06-22

Version

Id

EvtTimeFNALBeam.h,v 1.1 2015/06/30 18:01:24 rhatcher Exp

Definition at line 22 of file EvtTimeFNALBeam.h.

Constructor & Destructor Documentation

evgb::EvtTimeFNALBeam::EvtTimeFNALBeam

(

const std::string &

config

)

Definition at line 56 of file EvtTimeFNALBeam.cxx.

References Config(), and SetBatchIntensities().

    : EvtTimeShiftI(config)
    , fTimeBetweenBuckets(1e9/53.103e6)
    , fBucketTimeSigma(0.750)
    , fNBucketsPerBatch(84)        // NOvA-era 81+3, MINOS-era 81+5
    , fNFilledBucketsPerBatch(81)  // 81 for both eras
    , fDisallowedBatchMask(6,0)    // don't disallow any
    , fGlobalOffset(0)
  {
    std::vector<double> bi(6,1.0); // 6 equal batches
    SetBatchIntensities(bi);
    Config(config);
  }

evgb::EvtTimeFNALBeam::~EvtTimeFNALBeam ( )

virtual

Definition at line 71 of file EvtTimeFNALBeam.cxx.

{ ; }

Member Function Documentation

void evgb::EvtTimeFNALBeam::CalculateCPDF ( std::vector< double >  batchi )

private

Definition at line 252 of file EvtTimeFNALBeam.cxx.

References fCummulativeBatchPDF, fDisallowedBatchMask, and sum.

Referenced by GetGlobalOffset(), SetBatchIntensities(), and TimeOffset().

  {
    fCummulativeBatchPDF.clear();
    double sum = 0;
    size_t nbi = bi.size();
    for (size_t i=0; i < nbi; ++i) {
      sum += bi[i];
      fCummulativeBatchPDF.push_back(sum);
    }
    // normalize to unit probability
    for (size_t i=0; i < nbi; ++i) fCummulativeBatchPDF[i] /= sum;
    // make sure the mask vector keeps up (but never make it smaller)
    // allowing all new batches
    if ( nbi > fDisallowedBatchMask.size() )
      fDisallowedBatchMask.resize(nbi,0);

    /*
    for (size_t j=0; j<nbi; ++j) {
      std::cout << " CPDF[" << j << "] " << fCummulativeBatchPDF[j]
                << "  " << ((fDisallowedBatchMask[j])?"dis":"") << "allowed"
                << std::endl;
    }
    */

  }

void evgb::EvtTimeFNALBeam::Config ( const std::string &  config )

virtual

each schema must take a string that configures it it is up to the individual model to parse said string and extract parameters

Implements evgb::EvtTimeShiftI.

Definition at line 73 of file EvtTimeFNALBeam.cxx.

References fBucketTimeSigma, fDisallowedBatchMask, fGlobalOffset, fNBucketsPerBatch, fNFilledBucketsPerBatch, fTimeBetweenBuckets, evgb::EvtTimeShiftI::GetConfigTokens(), ksigma2fwhm, and SetBatchIntensities().

Referenced by EvtTimeFNALBeam().

  {
    // parse config string
    if ( config == "" ) return;
    // GENIEHelper does a PrintConfig() when it gets this object ...

    // not the most sophisticated of parsing ... but FHICL would be overkill

    std::vector<std::string> strs = GetConfigTokens(config);
    // strings have all been tokenized and made lowercase

    size_t nstrs = strs.size();
    for (size_t i=0; i<nstrs; ++i) {
      if ( strs[i] == "numi" ) {
        fTimeBetweenBuckets     = 1e9/53.103e6;
        fBucketTimeSigma        = 0.750;
        fNBucketsPerBatch       = 84;  // NOvA-era 81+3, MINOS-era 81+5
        fNFilledBucketsPerBatch = 81;  // 81 for both eras
        fDisallowedBatchMask    = std::vector<int>(6,0); // don't disallow any
        fGlobalOffset           = 0;
        std::vector<double> bi(6,1.0); // 6 equal batches
        SetBatchIntensities(bi);
      } else
      if ( strs[i] == "booster" ) {
        fTimeBetweenBuckets     = 1e9/53.103e6;
        fBucketTimeSigma        = 2.0;
        fNBucketsPerBatch       = 84;  //
        fNFilledBucketsPerBatch = 81;  //
        fDisallowedBatchMask    = std::vector<int>(1,0); // don't disallow any
        fGlobalOffset           = 0;
        std::vector<double> bi(1,1.0); // 1 batch
        SetBatchIntensities(bi);
      } else
      if ( strs[i].find("intensity") != std::string::npos ) {
        // a list of batch intensities ... sets # of batches
        // eat values up until we see the end, or a word
        std::vector<double> bi;
        // count how many of next tokens are numbers (crude)
        for (size_t jj=i+1; jj<nstrs; ++jj) {
          // very crude check of being a number
          // can be  fooled by strange text
          size_t pos = strs[jj].find_first_not_of("0123456789.-+eE");
          if ( pos != std::string::npos ) break;
          // looks like a numeric value
          double val = atof(strs[jj].c_str());
          if ( val < 0 ) {
            mf::LogError("EvtTime")
              << "EvtTimeFNALBeam 'intensity' value [" << (jj-i-1)
              << "]=" << val << " '" << strs[jj] << "' "
              << "can't be less than zero, setting to zero";
            val = 0;
          }
          bi.push_back(val);
        }
        // ate up some strings ... move loop index
        i += bi.size();
        if ( bi.empty() ) {
          mf::LogError("EvtTime")
            << "EvtTimeFNALBeam error 'intensity' option didn't seem to have values";
        } else {
          SetBatchIntensities(bi);
        }
      } else
      if ( strs[i] == "bdisallowed" ) {
        mf::LogError("EvtTime")
          << "EvtTimeFNALBeam sorry 'bdisallowed' option not yet implemented";
      } else {
        // all the rest take one numeric value
        if ( i+1 >= nstrs ) {
          mf::LogError("EvtTime")
            << "EvtTimeFNALBeam sorry too few values for '" << strs[i] << "'";
          continue;
        }
        const char* arg = strs[i+1].c_str();
        if      ( strs[i] == "sigma"     ) fBucketTimeSigma        = atof(arg);
        else if ( strs[i] == "fwhm"      ) fBucketTimeSigma        = atof(arg)/ksigma2fwhm;
        else if ( strs[i] == "dtbucket"  ) fTimeBetweenBuckets     = atof(arg);
        else if ( strs[i] == "nperbatch" ) fNBucketsPerBatch       = atoi(arg);
        else if ( strs[i] == "nfilled"   ) fNFilledBucketsPerBatch = atoi(arg);
        else if ( strs[i] == "global"    ) fGlobalOffset           = atof(arg);
        else if ( strs[i] == "seed"      ) { ; } // handled in base
        else {
          mf::LogError("EvtTime")
            << "unknown EvtTimeFNALBeam config key '" << strs[i] << "'";
          continue;
        }
        ++i; // used up an argument
      }
    }
    // consistency check
    if ( fNFilledBucketsPerBatch > fNBucketsPerBatch ) {
      mf::LogError("EvtTime")
        << "EvtTimeFNALBeam nfilled " << fNFilledBucketsPerBatch
        << " of " << fNBucketsPerBatch << " buckets per batch,\n"
        << "set nfilled to match buckets per batch";
      fNFilledBucketsPerBatch = fNBucketsPerBatch;
    }

  }

double evgb::EvtTimeFNALBeam::GetBucketTimeSigma ( ) const

inline

Definition at line 51 of file EvtTimeFNALBeam.h.

References fBucketTimeSigma.

{ return fBucketTimeSigma; }

std::vector< std::string > evgb::EvtTimeShiftI::GetConfigTokens ( const std::string &  config )

protectedinherited

Definition at line 69 of file EvtTimeShiftI.cxx.

References x.

Referenced by Config(), evgb::EvtTimeShiftI::EvtTimeShiftI(), and evgb::EvtTimeShiftI::IsRandomGeneratorSeeded().

  {

    std::vector<std::string> strs;
    if ( config == "" ) return strs;

    std::string configLocal = config;

    // blindly reduced UPPER -> lower case above to make this easier
    // convert string to lowercase
    std::transform(configLocal.begin(),configLocal.end(),
                   configLocal.begin(),::tolower);

    // for now make use of GENIE utilities
    strs = genie::utils::str::Split(configLocal,"\t\n ,;=(){}[]");

    // weed out blank ones
    strs.erase(std::remove_if(strs.begin(), strs.end(),
                              [](const std::string& x) {
                                return ( x == "") ; // put your condition here
                              }), strs.end());

    // debugging info
    std::ostringstream msgx;
    msgx << "Config elements:" << std::endl;
    for (size_t j=0; j<strs.size(); ++j) {
      msgx << " [" << std::setw(3) << j << "] -->" << strs[j] << "<--\n";
    }
    // this should end up as LogDebug
    mf::LogDebug("EvtTime") << msgx.str() << std::flush;

    return strs;
  }

double evgb::EvtTimeFNALBeam::GetGlobalOffset ( ) const

inline

Definition at line 61 of file EvtTimeFNALBeam.h.

References CalculateCPDF(), and fGlobalOffset.

{ return fGlobalOffset; }

int evgb::EvtTimeFNALBeam::GetNBucketsPerBatch ( ) const

inline

Definition at line 53 of file EvtTimeFNALBeam.h.

References fNBucketsPerBatch.

{ return fNBucketsPerBatch; }

int evgb::EvtTimeFNALBeam::GetNFilledBucketsPerBatch ( ) const

inline

Definition at line 55 of file EvtTimeFNALBeam.h.

References fNFilledBucketsPerBatch, SetBatchIntensities(), and SetDisallowedBatchMask().

{ return fNFilledBucketsPerBatch; }

TRandom* evgb::EvtTimeShiftI::GetRandomGenerator ( ) const

inlineinherited

Allow users some control over random # sequences An "owned" object is expected to be deleted by the EvtTimeShift obj

Definition at line 61 of file EvtTimeShiftI.h.

References evgb::EvtTimeShiftI::fRndmGen.

Referenced by evgb::GENIEHelper::GENIEHelper().

{ return fRndmGen; }

double evgb::EvtTimeFNALBeam::GetTimeBetweenBuckets ( ) const

inline

Definition at line 49 of file EvtTimeFNALBeam.h.

References fTimeBetweenBuckets.

{ return fTimeBetweenBuckets; }

bool evgb::EvtTimeShiftI::IsRandomGeneratorOwned ( ) const

inlineinherited

Definition at line 62 of file EvtTimeShiftI.h.

References evgb::EvtTimeShiftI::fIsOwned.

{ return fIsOwned; }

bool evgb::EvtTimeShiftI::IsRandomGeneratorSeeded ( ) const

inlineinherited

Definition at line 63 of file EvtTimeShiftI.h.

References evgb::EvtTimeShiftI::fIsSeeded, evgb::EvtTimeShiftI::GetConfigTokens(), and evgb::EvtTimeShiftI::SetRandomGenerator().

Referenced by evgb::GENIEHelper::GENIEHelper().

{ return fIsSeeded; }

void evgb::EvtTimeFNALBeam::PrintConfig ( bool  verbose = true )

virtual

provide a means of printing the configuration

Implements evgb::EvtTimeShiftI.

Definition at line 209 of file EvtTimeFNALBeam.cxx.

References fBucketTimeSigma, fCummulativeBatchPDF, fDisallowedBatchMask, fGlobalOffset, fNBucketsPerBatch, fNFilledBucketsPerBatch, and fTimeBetweenBuckets.

  {

    std::ostringstream msg;
    msg  << "EvtTimeFNALBeam config: \n"
         << "  TimeBetweenBuckets:     " << fTimeBetweenBuckets << " ns\n"
         << "  BucketTimeSigma:        " << fBucketTimeSigma << " ns "
         << "[FWHM " << fBucketTimeSigma*ksigma2fwhm << "]\n"
         << "  NBucketsPerBatch:       " << fNBucketsPerBatch << "\n"
         << "  NFilledBucketsPerBatch: " << fNFilledBucketsPerBatch << "\n"
         << "  Relative Fractions:    ";
    double prev=0;
    for (size_t i=0; i < fCummulativeBatchPDF.size(); ++i) {
      double frac = fCummulativeBatchPDF[i] - prev;
      bool skip = fDisallowedBatchMask[i];
      msg << " ";
      if (skip) msg << "{{";
      msg << frac;
      if (skip) msg << "}}";
      prev = fCummulativeBatchPDF[i];
    }
    msg << "\n"
        << "  GlobalOffset:           " << fGlobalOffset << " ns\n";

    mf::LogInfo("EvtTime") << msg.str();
  }

void evgb::EvtTimeFNALBeam::SetBatchIntensities

(

std::vector< double >

bi

)

Definition at line 237 of file EvtTimeFNALBeam.cxx.

References CalculateCPDF().

Referenced by Config(), EvtTimeFNALBeam(), and GetNFilledBucketsPerBatch().

  {
    CalculateCPDF(bi);
  }

void evgb::EvtTimeFNALBeam::SetBucketTimeSigma ( double  val )

inline

Definition at line 50 of file EvtTimeFNALBeam.h.

References fBucketTimeSigma.

{ fBucketTimeSigma=val; }

void evgb::EvtTimeFNALBeam::SetDisallowedBatchMask

(

std::vector< int >

disallow

)

Definition at line 242 of file EvtTimeFNALBeam.cxx.

References fCummulativeBatchPDF, and fDisallowedBatchMask.

Referenced by GetNFilledBucketsPerBatch().

  {
    size_t ndis = disallow.size();
    size_t nbi  = fCummulativeBatchPDF.size();
    fDisallowedBatchMask = disallow;
    // expand it so it's mirrors # of batch intensities
    // but allow all that haven't been set
    if ( nbi > ndis ) fDisallowedBatchMask.resize(nbi,0);
  }

void evgb::EvtTimeFNALBeam::SetGlobalOffset ( double  val )

inline

Definition at line 60 of file EvtTimeFNALBeam.h.

References fGlobalOffset.

{ fGlobalOffset=val; }

void evgb::EvtTimeFNALBeam::SetNBucketsPerBatch ( int  ival )

inline

Definition at line 52 of file EvtTimeFNALBeam.h.

References fNBucketsPerBatch.

{ fNBucketsPerBatch=ival; }

void evgb::EvtTimeFNALBeam::SetNFilledBucketsPerBatch ( int  ival )

inline

Definition at line 54 of file EvtTimeFNALBeam.h.

References fNFilledBucketsPerBatch.

{ fNFilledBucketsPerBatch=ival; }

void evgb::EvtTimeShiftI::SetRandomGenerator ( TRandom *  gen, bool  isOwned  )

inherited

Definition at line 60 of file EvtTimeShiftI.cxx.

References evgb::EvtTimeShiftI::fIsOwned, and evgb::EvtTimeShiftI::fRndmGen.

Referenced by evgb::EvtTimeShiftI::IsRandomGeneratorSeeded().

  {
    // deal with what we might already have
    if ( fIsOwned ) { delete fRndmGen; fRndmGen = 0; fIsOwned = false; }

    fRndmGen = gen;
    fIsOwned = isOwned;
  }

void evgb::EvtTimeFNALBeam::SetTimeBetweenBuckets ( double  val )

inline

specific methods for this variant

Definition at line 48 of file EvtTimeFNALBeam.h.

References fTimeBetweenBuckets.

{ fTimeBetweenBuckets=val; }

double evgb::EvtTimeFNALBeam::TimeOffset ( )

virtual

return time within a 'record' in nanoseconds version taking array might be used for relative batch fractions that vary on a record-by-record basis

Implements evgb::EvtTimeShiftI.

Definition at line 173 of file EvtTimeFNALBeam.cxx.

References fBucketTimeSigma, fCummulativeBatchPDF, fDisallowedBatchMask, fGlobalOffset, fNBucketsPerBatch, fNFilledBucketsPerBatch, evgb::EvtTimeShiftI::fRndmGen, fTimeBetweenBuckets, and r.

Referenced by TimeOffset().

  {
    // calculate in small to large

    // pick a time within a bucket
    double offset = fRndmGen->Gaus(0.0,fBucketTimeSigma);

    // pick a bucket within a batch
    // assume all ~ buckets constant in batch until we have another model
    offset +=  fTimeBetweenBuckets *
               (double)fRndmGen->Integer(fNFilledBucketsPerBatch);

    // pick a bucket
    bool   disallowed = true;
    size_t ibatch = 0;
    size_t nbatch = fCummulativeBatchPDF.size();
    double r = 2;
    while ( disallowed ) {
      r = fRndmGen->Uniform();
      for (ibatch=0; ibatch<nbatch; ++ibatch) {
        if ( r <= fCummulativeBatchPDF[ibatch] ) break;
      }
      disallowed = ( fDisallowedBatchMask[ibatch] != 0 );
    }
    offset += fTimeBetweenBuckets*(double)fNBucketsPerBatch*(double)ibatch;

    // finally the global offset
    return offset + fGlobalOffset;
  }

double evgb::EvtTimeFNALBeam::TimeOffset ( std::vector< double >  bi )

virtual

Implements evgb::EvtTimeShiftI.

Definition at line 203 of file EvtTimeFNALBeam.cxx.

References CalculateCPDF(), and TimeOffset().

  {
    CalculateCPDF(bi);
    return TimeOffset();
  }

Member Data Documentation

double evgb::EvtTimeFNALBeam::fBucketTimeSigma

private

how wide is distribution in bucket

Definition at line 68 of file EvtTimeFNALBeam.h.

Referenced by Config(), GetBucketTimeSigma(), PrintConfig(), SetBucketTimeSigma(), and TimeOffset().

std::vector<double> evgb::EvtTimeFNALBeam::fCummulativeBatchPDF

private

summed prob for batches

Definition at line 71 of file EvtTimeFNALBeam.h.

Referenced by CalculateCPDF(), PrintConfig(), SetDisallowedBatchMask(), and TimeOffset().

std::vector<int> evgb::EvtTimeFNALBeam::fDisallowedBatchMask

private

disallow individual batches

Definition at line 72 of file EvtTimeFNALBeam.h.

Referenced by CalculateCPDF(), Config(), PrintConfig(), SetDisallowedBatchMask(), and TimeOffset().

double evgb::EvtTimeFNALBeam::fGlobalOffset

private

always displaced by this (in ns)

Definition at line 73 of file EvtTimeFNALBeam.h.

Referenced by Config(), GetGlobalOffset(), PrintConfig(), SetGlobalOffset(), and TimeOffset().

bool evgb::EvtTimeShiftI::fIsOwned

protectedinherited

Definition at line 72 of file EvtTimeShiftI.h.

Referenced by evgb::EvtTimeShiftI::IsRandomGeneratorOwned(), evgb::EvtTimeShiftI::SetRandomGenerator(), and evgb::EvtTimeShiftI::~EvtTimeShiftI().

bool evgb::EvtTimeShiftI::fIsSeeded

protectedinherited

Definition at line 73 of file EvtTimeShiftI.h.

Referenced by evgb::EvtTimeShiftI::EvtTimeShiftI(), and evgb::EvtTimeShiftI::IsRandomGeneratorSeeded().

int evgb::EvtTimeFNALBeam::fNBucketsPerBatch

private

Definition at line 69 of file EvtTimeFNALBeam.h.

Referenced by Config(), GetNBucketsPerBatch(), PrintConfig(), SetNBucketsPerBatch(), and TimeOffset().

int evgb::EvtTimeFNALBeam::fNFilledBucketsPerBatch

private

Definition at line 70 of file EvtTimeFNALBeam.h.

Referenced by Config(), GetNFilledBucketsPerBatch(), PrintConfig(), SetNFilledBucketsPerBatch(), and TimeOffset().

TRandom* evgb::EvtTimeShiftI::fRndmGen

protectedinherited

Definition at line 71 of file EvtTimeShiftI.h.

Referenced by evgb::EvtTimeShiftI::EvtTimeShiftI(), evgb::EvtTimeShiftI::GetRandomGenerator(), evgb::EvtTimeShiftI::SetRandomGenerator(), TimeOffset(), evgb::EvtTimeFlat::TimeOffset(), and evgb::EvtTimeShiftI::~EvtTimeShiftI().

double evgb::EvtTimeFNALBeam::fTimeBetweenBuckets

private

time between buckets

Definition at line 67 of file EvtTimeFNALBeam.h.

Referenced by Config(), GetTimeBetweenBuckets(), PrintConfig(), SetTimeBetweenBuckets(), and TimeOffset().

---

The documentation for this class was generated from the following files:

• nugen/EventGeneratorBase/GENIE/EvtTimeFNALBeam.h
• nugen/EventGeneratorBase/GENIE/EvtTimeFNALBeam.cxx