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
Public Member Functions inherited from evgb::EvtTimeShiftI
	EvtTimeShiftI (const std::string &config)
virtual	~EvtTimeShiftI ()
TRandom *	GetRandomGenerator () const
bool	IsRandomGeneratorOwned () const
void	SetRandomGenerator (TRandom *gen, bool isOwned)

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...

Additional Inherited Members
Protected Attributes inherited from evgb::EvtTimeShiftI
TRandom *	fRndmGen
bool	fIsOwned

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.

    : 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 271 of file EvtTimeFNALBeam.cxx.

  {
    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.

  {
    // 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::string configLocal = config;
    // convert string to lowercase
    std::transform(configLocal.begin(),configLocal.end(),configLocal.begin(),::tolower);

    // for now make use of GENIE utilities
    std::vector<std::string> 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;

    // blindly reduced UPPER -> lower case above to make this easier
    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 {
          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.

{ return fBucketTimeSigma; }

double evgb::EvtTimeFNALBeam::GetGlobalOffset ( ) const

inline

Definition at line 61 of file EvtTimeFNALBeam.h.

{ return fGlobalOffset; }

int evgb::EvtTimeFNALBeam::GetNBucketsPerBatch ( ) const

inline

Definition at line 53 of file EvtTimeFNALBeam.h.

{ return fNBucketsPerBatch; }

int evgb::EvtTimeFNALBeam::GetNFilledBucketsPerBatch ( ) const

inline

Definition at line 55 of file EvtTimeFNALBeam.h.

{ return fNFilledBucketsPerBatch; }

double evgb::EvtTimeFNALBeam::GetTimeBetweenBuckets ( ) const

inline

Definition at line 49 of file EvtTimeFNALBeam.h.

{ return fTimeBetweenBuckets; }

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

virtual

provide a means of printing the configuration

Implements evgb::EvtTimeShiftI.

Definition at line 228 of file EvtTimeFNALBeam.cxx.

  {

    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 256 of file EvtTimeFNALBeam.cxx.

  {
    CalculateCPDF(bi);
  }

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

inline

Definition at line 50 of file EvtTimeFNALBeam.h.

{ fBucketTimeSigma=val; }

void evgb::EvtTimeFNALBeam::SetDisallowedBatchMask

(

std::vector< int >

disallow

)

Definition at line 261 of file EvtTimeFNALBeam.cxx.

  {
    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.

{ fGlobalOffset=val; }

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

inline

Definition at line 52 of file EvtTimeFNALBeam.h.

{ fNBucketsPerBatch=ival; }

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

inline

Definition at line 54 of file EvtTimeFNALBeam.h.

{ fNFilledBucketsPerBatch=ival; }

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

inline

specific methods for this variant

Definition at line 48 of file EvtTimeFNALBeam.h.

{ 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 192 of file EvtTimeFNALBeam.cxx.

  {
    // 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 222 of file EvtTimeFNALBeam.cxx.

  {
    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.

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

private

summed prob for batches

Definition at line 71 of file EvtTimeFNALBeam.h.

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

private

disallow individual batches

Definition at line 72 of file EvtTimeFNALBeam.h.

double evgb::EvtTimeFNALBeam::fGlobalOffset

private

always displaced by this (in ns)

Definition at line 73 of file EvtTimeFNALBeam.h.

int evgb::EvtTimeFNALBeam::fNBucketsPerBatch

private

Definition at line 69 of file EvtTimeFNALBeam.h.

int evgb::EvtTimeFNALBeam::fNFilledBucketsPerBatch

private

Definition at line 70 of file EvtTimeFNALBeam.h.

double evgb::EvtTimeFNALBeam::fTimeBetweenBuckets

private

time between buckets

Definition at line 67 of file EvtTimeFNALBeam.h.

---

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

• nutools/old/EventGeneratorBase/GENIE/EvtTimeFNALBeam.h
• nutools/old/EventGeneratorBase/GENIE/EvtTimeFNALBeam.cxx