JSUPERNOVA::JL0BackgroundSimulator Class Reference

Class to emulate L0 background for an arbitrarily sized detector. More...

#include <JL0BackgroundSimulator.hh>

Public Member Functions
	JL0BackgroundSimulator (TFile *in, bool twoDim=false)
	Default constructor. More...
	~JL0BackgroundSimulator ()
	Destructor. More...
void	configureTimeWindow (const int T_ms)
	Configure the duration of an output sample. More...
void	setSeed (const UInt_t uSeed=0)
	Set TRandom seed. More...
void	configureRatio (const int inputNumberOfLines, const int outputNumberOfLines)
	Configure generation ratio. More...
bg_type	generate ()
	Generate sample of L0 background L0 data are randomly sampled from a single L0 dataset. More...
bg_type	generate_poisson (const int domRate_Hz=500)
	Generate pure poissionian background. More...
bg_type	generate_shuffled (bool randomizeRun=false)
	Generate sample of L0 background The sampling of the L0 data is not sequential but random within the L0 dataset. More...
h2d_t *	build_H2D (const int k, const int start)
	Generate 2D histogram. More...
vector< double >	build_NC (const int k, const int start)
	Build NC sequence. More...
h2d_t *	generate_H2D (int rb=1)
	Generate 2D sample. More...
bg_type	generate_fitted (int rb=1)
	Generate fitted L1 sample. More...

Static Public Member Functions
static vector< double >	rebin (const vector< double > &in, const int rb)
	Rebin vector. More...
static bg_type	fit_H2D (h2d_t *in)
	Fit 2D sample. More...

Private Attributes
vector< vector< double > >	rt
vector< vector< double > >	nc
vector< h2d_t * >	rt2d
int	TWindow_ms
int	genRatio
int	outputSize
double	genScale
TRandom *	rnd

Detailed Description

Class to emulate L0 background for an arbitrarily sized detector.

Definition at line 57 of file JL0BackgroundSimulator.hh.

Constructor & Destructor Documentation

JSUPERNOVA::JL0BackgroundSimulator::JL0BackgroundSimulator ( TFile *  in, bool  twoDim = false  )

inline

Default constructor.

The input file contains a sequence of histograms with sampled L0 data; Each histogram is loaded as a vector, which will be considered as an individual L0 dataset.

Parameters

in	input file from JRipple
twoDim	make 2D histogram with distribution of hit time differences vs time

Definition at line 83 of file JL0BackgroundSimulator.hh.

                                                           {

      TWindow_ms = 100;
      genRatio   = 115;
      genScale   = 1;

      TString rt_tag = ".RT_DET_SUM";
      TString nc_tag = ".NC_DET_SUM";
      TString rt2d_tag = ".RT2D_DET";

      rnd = new TRandom();

      TIter iter(in->GetListOfKeys());

      for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {

        const TString tag(key->GetName());

        // match 
        if (tag.EndsWith(rt_tag)) {

          TString rt_hist_tag = tag;
          TString run_tag = TString(tag, tag.Length() - rt_tag.Length());
          
          TString nc_hist_tag = run_tag + nc_tag;

          TH1D* RT = (TH1D*) in->Get(rt_hist_tag);
          TH1D* NC = (TH1D*) in->Get(nc_hist_tag);

          vector<double> rt_buf = loadHistogram(RT);
          vector<double> nc_buf = loadHistogram(NC);

          int n = nc_buf.size();

          rt.push_back( vector<double>() );
          nc.push_back( vector<double>() );

          // build parallel vectors 
          // 1 NC bin <=> 100 RT bins
          for (int i = 0; i < n; i++) {
            // empty slices are discarded
            if (nc_buf[i] > 0) {
              nc.back().push_back( nc_buf[i] );
              for (int j = 100 * i; j < 100 * (i + 1); j++) {
                rt.back().push_back( rt_buf[j] );
              }
            }
          }
        
          if (twoDim) {
            TString rt2d_hist_tag = run_tag + rt2d_tag;
            h2d_t* RT2D = (h2d_t*) in->Get(rt2d_hist_tag);

            if (RT2D != NULL) {
              RT2D->SetDirectory(0);
              rt2d.push_back(RT2D);
            }
          }

        }

      }

    }

JSUPERNOVA::JL0BackgroundSimulator::~JL0BackgroundSimulator ( )

inline

Destructor.

Definition at line 151 of file JL0BackgroundSimulator.hh.

                              {
      delete rnd;
    }

Member Function Documentation

void JSUPERNOVA::JL0BackgroundSimulator::configureTimeWindow ( const int  T_ms )

inline

Configure the duration of an output sample.

Parameters

T_ms	sample duration in ms

Definition at line 160 of file JL0BackgroundSimulator.hh.

                                             {
      TWindow_ms = T_ms;
    }

void JSUPERNOVA::JL0BackgroundSimulator::setSeed ( const UInt_t  uSeed = 0 )

inline

Set TRandom seed.

Parameters

uSeed

seed

Definition at line 169 of file JL0BackgroundSimulator.hh.

                                         {
      rnd->SetSeed(uSeed);
    } 

void JSUPERNOVA::JL0BackgroundSimulator::configureRatio ( const int  inputNumberOfLines, const int  outputNumberOfLines  )

inline

Configure generation ratio.

Parameters

inputNumberOfLines	number of lines of input detector
outputNumberOfLines	number of lines of output detector

Definition at line 179 of file JL0BackgroundSimulator.hh.

                                                                                     {
      outputSize   = inputNumberOfLines;
      // ratio is integer by design
      genRatio     = outputNumberOfLines / inputNumberOfLines;
      // scaling factor to compensate the ratio remainder
      genScale     = outputNumberOfLines / (1.0 * inputNumberOfLines * genRatio);
    }

bg_type JSUPERNOVA::JL0BackgroundSimulator::generate ( )

inline

Generate sample of L0 background L0 data are randomly sampled from a single L0 dataset.

Returns

2D vector with hit count and number of active channels as a function of time

Definition at line 194 of file JL0BackgroundSimulator.hh.

                       {

      bg_type out(2, vector<double>(TWindow_ms));

      int k = rnd->Integer(rt.size());

      int limit = rt[k].size() - (genRatio * TWindow_ms);

      int start = rnd->Integer(limit);

      for (int i = 0; i < genRatio; i++) {

        for (int j = 0; j < TWindow_ms; j++) {

          int bin = start + (i * TWindow_ms) +  j;

          out[0][j] += genScale * rt[k].at(bin      );
          out[1][j] += genScale * nc[k].at(bin / 100);

        }

      }

      return out;
    }

bg_type JSUPERNOVA::JL0BackgroundSimulator::generate_poisson ( const int  domRate_Hz = 500 )

inline

Generate pure poissionian background.

Definition at line 223 of file JL0BackgroundSimulator.hh.

                                                         {

      bg_type out(2, vector<double>(TWindow_ms));

      double mu = outputSize * 18 * domRate_Hz * 1.0e-3; 

      for (unsigned i = 0; i < out[0].size(); i++) {

        double count  = rnd->Poisson(mu);
        
        out[0][i] = count;
        out[1][i] = outputSize * 18 * 31;
        
      } 

      return out;

    }

bg_type JSUPERNOVA::JL0BackgroundSimulator::generate_shuffled ( bool  randomizeRun = false )

inline

Generate sample of L0 background The sampling of the L0 data is not sequential but random within the L0 dataset.

Returns

2D vector with hit count and number of active channels as a function of time

Definition at line 248 of file JL0BackgroundSimulator.hh.

                                                         {

      bg_type out(2, vector<double>(TWindow_ms));

      int nRuns = rt.size();

      int k = rnd->Integer(nRuns);

      // a series n = 'genRatio' elements is sampled randomly within the dataset
      // all the elements start with the same offset to the timeslice beginning

      int offset = rnd->Integer(100);

      for (int i = 0; i < genRatio; i++) {

        int start = 100 * rnd->Integer(nc[k].size() - ceil(TWindow_ms / 100.0)) + offset;

        for (int j = 0; j < TWindow_ms; j++) {

          int bin = start + j;

          out[0][j] += genScale * rt[k].at(bin      );
          out[1][j] += genScale * nc[k].at(bin / 100);
                  
        }

        if (randomizeRun) {
          k = rnd->Integer(nRuns);
        }

      }

      return out;
    }    

h2d_t* JSUPERNOVA::JL0BackgroundSimulator::build_H2D ( const int  k, const int  start  )

inline

Generate 2D histogram.

Definition at line 287 of file JL0BackgroundSimulator.hh.

                                                    {

      h2d_t* proto = rt2d[k];

      int ny   = proto->GetNbinsY();
      int ymin = proto->GetYaxis()->GetXmin(); 
      int ymax = proto->GetYaxis()->GetXmax();

      h2d_t* out = new h2d_t("sample", NULL, TWindow_ms, 0, TWindow_ms, ny, ymin, ymax);        
      
      for (int i = 0; i < genRatio; i++) {

        for (int j = 0; j < TWindow_ms; j++) {

          int xbin = 1 + start + (i * TWindow_ms) +  j;

          for (int ybin = 1; ybin <= rt2d[k]->GetNbinsY(); ybin++) {
              
            double val = rt2d[k]->GetBinContent(xbin, ybin);    

            double bcx = ((TAxis*)out->GetXaxis())->GetBinCenter(j + 1);
            double bcy = ((TAxis*)out->GetYaxis())->GetBinCenter(ybin);
              
            out->Fill(bcx, bcy, val);

          }

        }

      }

      return out;

    }

vector<double> JSUPERNOVA::JL0BackgroundSimulator::build_NC ( const int  k, const int  start  )

inline

Build NC sequence.

Definition at line 326 of file JL0BackgroundSimulator.hh.

                                                           {
      
      vector<double> out(TWindow_ms);

      for (int i = 0; i < genRatio; i++) {

        for (int j = 0; j < TWindow_ms; j++) {

          int bin = start + (i * TWindow_ms) +  j;

          out[j] += genScale * nc[k].at(bin / 100);

        }

      }

      return out;
    }

static vector<double> JSUPERNOVA::JL0BackgroundSimulator::rebin ( const vector< double > &  in, const int  rb  )

inlinestatic

Rebin vector.

Definition at line 348 of file JL0BackgroundSimulator.hh.

                                                                        {

      const int n = in.size();

      vector<double> out(n/rb);
     
      for (int i = 0; i < n; i++) {
        out[i/rb] += in[i];
      }

      return out;

    }

h2d_t* JSUPERNOVA::JL0BackgroundSimulator::generate_H2D ( int  rb = 1 )

inline

Generate 2D sample.

Definition at line 365 of file JL0BackgroundSimulator.hh.

                                    {

      h2d_t* out = NULL;
      
      if (rt2d.size() > 0) {

        int k = rnd->Integer(rt2d.size());

        int limit = rt2d[k]->GetNbinsX() - (genRatio * TWindow_ms);

        int start = rnd->Integer(limit);

        out = build_H2D(k, start);

      }

      if (rb != 1) { out->RebinX(rb); }

      return out;
    
    }

static bg_type JSUPERNOVA::JL0BackgroundSimulator::fit_H2D ( h2d_t *  in )

inlinestatic

Fit 2D sample.

Definition at line 391 of file JL0BackgroundSimulator.hh.

                                      {

      int n = in->GetNbinsX();

      // 0 -> signal
      // 1 -> fitted background
      // 2 -> background fit error

      bg_type out(3, vector<double>(n));

      for (int bin = 1; bin <= n; bin++) {

        double sg = 0, bg = 0, er = 0;

        TH1D* h = in->ProjectionY("timeBin", bin, bin);

        if (h->GetEntries() > 0) {
          
          TF1 f("f", "[0]*exp(-0.5*(x-[1])*(x-[1])/([2]*[2]))/(TMath::Sqrt(2*TMath::Pi())*[2]) + [3]");

          f.SetParameter(0, h->GetMaximum());
          f.SetParameter(1, h->GetMean());
          f.SetParameter(2, h->GetRMS() * 0.25);
          f.SetParameter(3, h->GetMinimum());
          
          h->Fit(&f, "Q", "same");

          bg = f.GetParameter(3) * h->GetNbinsX();
          sg = h->GetSumOfWeights() - bg;
          er = f.GetParError(3) * h->GetNbinsX();

        }

        int i = bin - 1;
      
        out[0][i] = sg;
        out[1][i] = bg;
        out[2][i] = er;

        delete h;

      }
      
      return out;

    }

bg_type JSUPERNOVA::JL0BackgroundSimulator::generate_fitted ( int  rb = 1 )

inline

Generate fitted L1 sample.

Definition at line 443 of file JL0BackgroundSimulator.hh.

                                        {

      bg_type out;

      int k = rnd->Integer(rt.size());

      int limit = rt[k].size() - (genRatio * TWindow_ms);

      int start = rnd->Integer(limit);

      h2d_t* sample = build_H2D(k, start);
      
      if (rb != 1) { sample->RebinX(rb); }

      bg_type fit = fit_H2D(sample);
      
      out.push_back(fit[0]);

      delete sample;
      
      if (rb == 1) {
        out.push_back(build_NC(k, start));
      } else {
        out.push_back(rebin(build_NC(k, start), rb));
      }

      out.push_back(fit[1]);
      out.push_back(fit[2]);

      return out;      
    
    }   

Member Data Documentation

vector<vector<double> > JSUPERNOVA::JL0BackgroundSimulator::rt

private

Definition at line 59 of file JL0BackgroundSimulator.hh.

vector<vector<double> > JSUPERNOVA::JL0BackgroundSimulator::nc

private

Definition at line 60 of file JL0BackgroundSimulator.hh.

vector<h2d_t*> JSUPERNOVA::JL0BackgroundSimulator::rt2d

private

Definition at line 62 of file JL0BackgroundSimulator.hh.

int JSUPERNOVA::JL0BackgroundSimulator::TWindow_ms

private

Definition at line 64 of file JL0BackgroundSimulator.hh.

int JSUPERNOVA::JL0BackgroundSimulator::genRatio

private

Definition at line 65 of file JL0BackgroundSimulator.hh.

int JSUPERNOVA::JL0BackgroundSimulator::outputSize

private

Definition at line 66 of file JL0BackgroundSimulator.hh.

double JSUPERNOVA::JL0BackgroundSimulator::genScale

private

Definition at line 68 of file JL0BackgroundSimulator.hh.

TRandom* JSUPERNOVA::JL0BackgroundSimulator::rnd

private

Definition at line 70 of file JL0BackgroundSimulator.hh.

---

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

• JL0BackgroundSimulator.hh