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

#include <JLightCurveBackgroundGenerator.hh>

Public Member Functions
	JLightCurveBackgroundGenerator (TFile *in, bool twoDim=false)
	Default constructor.

	~JLightCurveBackgroundGenerator ()
	Destructor.

void	configureTimeWindow (const int T_ms)
	Configure the duration of an output sample.

void	setSeed (const UInt_t uSeed=0)
	Set TRandom seed.

void	configureRatio (const int inputNumberOfLines, const int outputNumberOfLines)
	Configure generation ratio.

bg_type	generate ()
	Generate sample of L0 background L0 data are randomly sampled from a single L0 dataset.

bg_type	generate_poisson (const int domRate_Hz=500)
	Generate pure poissionian background.

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.

h2d_t *	build_H2D (const int k, const int start)
	Generate 2D histogram.

vector< double >	build_NC (const int k, const int start)
	Build NC sequence.

h2d_t *	generate_H2D (int rb=1)
	Generate 2D sample.

bg_type	generate_fitted (int rb=1)
	Generate fitted L1 sample.

Static Public Member Functions
static vector< double >	rebin (const vector< double > &in, const int rb)
	Rebin vector.

static bg_type	fit_H2D (h2d_t *in)
	Fit 2D sample.

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 59 of file JLightCurveBackgroundGenerator.hh.

Constructor & Destructor Documentation

◆ JLightCurveBackgroundGenerator()

JSUPERNOVA::JLightCurveBackgroundGenerator::JLightCurveBackgroundGenerator	(	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 85 of file JLightCurveBackgroundGenerator.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);
            }
          }
 
        }
 
      }
 
    }

◆ ~JLightCurveBackgroundGenerator()

JSUPERNOVA::JLightCurveBackgroundGenerator::~JLightCurveBackgroundGenerator ( )

inline

Destructor.

Definition at line 153 of file JLightCurveBackgroundGenerator.hh.

                                      {
      delete rnd;
    }

Member Function Documentation

◆ configureTimeWindow()

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

inline

Configure the duration of an output sample.

Parameters

T_ms	sample duration in ms

Definition at line 162 of file JLightCurveBackgroundGenerator.hh.

                                             {
      TWindow_ms = T_ms;
    }

◆ setSeed()

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

inline

Set TRandom seed.

Parameters

uSeed seed

Definition at line 171 of file JLightCurveBackgroundGenerator.hh.

                                         {
      rnd->SetSeed(uSeed);
    } 

◆ configureRatio()

void JSUPERNOVA::JLightCurveBackgroundGenerator::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 181 of file JLightCurveBackgroundGenerator.hh.

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

◆ generate()

bg_type JSUPERNOVA::JLightCurveBackgroundGenerator::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 196 of file JLightCurveBackgroundGenerator.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;
    }

◆ generate_poisson()

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

inline

Generate pure poissionian background.

Definition at line 225 of file JLightCurveBackgroundGenerator.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;
 
    }

◆ generate_shuffled()

bg_type JSUPERNOVA::JLightCurveBackgroundGenerator::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 250 of file JLightCurveBackgroundGenerator.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;
    }

◆ build_H2D()

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

inline

Generate 2D histogram.

Definition at line 289 of file JLightCurveBackgroundGenerator.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;
 
    }

◆ build_NC()

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

inline

Build NC sequence.

Definition at line 328 of file JLightCurveBackgroundGenerator.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;
    }

◆ rebin()

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

inlinestatic

Rebin vector.

Definition at line 350 of file JLightCurveBackgroundGenerator.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;
 
    }

◆ generate_H2D()

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

inline

Generate 2D sample.

Definition at line 367 of file JLightCurveBackgroundGenerator.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;
    
    }

◆ fit_H2D()

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

inlinestatic

Fit 2D sample.

Definition at line 393 of file JLightCurveBackgroundGenerator.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;
 
    }

◆ generate_fitted()

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

inline

Generate fitted L1 sample.

Definition at line 445 of file JLightCurveBackgroundGenerator.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;      
    
    }   