TShapeAnalysis.cc

Go to the documentation of this file.

/* 
 *  \class TShapeAnalysis
 *
 *  original author: Patrice Verrecchia 
 *   modified by Julie Malcles - CEA/Saclay
 */

#include <CalibCalorimetry/EcalLaserAnalyzer/interface/TShapeAnalysis.h>
#include <CalibCalorimetry/EcalLaserAnalyzer/interface/TFParams.h>

#include <iostream>
#include <cmath>
#include <ctime>
#include <cassert>

#include <TFile.h>
#include <TTree.h>
#include <TBranch.h>

//ClassImp(TShapeAnalysis)

using namespace std;

// Constructor...
TShapeAnalysis::TShapeAnalysis(double alpha0, double beta0, double width0, double chi20) {
  init(alpha0, beta0, width0, chi20);
}

TShapeAnalysis::TShapeAnalysis(TTree *tAB, double alpha0, double beta0, double width0, double chi20) {
  init(tAB, alpha0, beta0, width0, chi20);
}

// Destructor
TShapeAnalysis::~TShapeAnalysis() {}

void TShapeAnalysis::init(double alpha0, double beta0, double width0, double chi20) {
  tABinit = nullptr;
  nchsel = fNchsel;
  for (int cris = 0; cris < fNchsel; cris++) {
    index[cris] = -1;
    npass[cris] = 0;
    npassok[cris] = 0.;

    alpha_val[cris] = alpha0;
    beta_val[cris] = beta0;
    width_val[cris] = width0;
    chi2_val[cris] = chi20;
    flag_val[cris] = 0;

    alpha_init[cris] = alpha0;
    beta_init[cris] = beta0;
    width_init[cris] = width0;
    chi2_init[cris] = chi20;
    flag_init[cris] = 0;

    phi_init[cris] = 0;
    eta_init[cris] = 0;
    side_init[cris] = 0;
    dcc_init[cris] = 0;
    tower_init[cris] = 0;
    ch_init[cris] = 0;
    assignChannel(cris, cris);
  }
}

void TShapeAnalysis::init(TTree *tAB, double alpha0, double beta0, double width0, double chi20) {
  init(alpha0, beta0, width0, chi20);

  tABinit = tAB->CloneTree();

  // Declaration of leaf types
  Int_t sidei;
  Int_t iphii;
  Int_t ietai;
  Int_t dccIDi;
  Int_t towerIDi;
  Int_t channelIDi;
  Double_t alphai;
  Double_t betai;
  Double_t widthi;
  Double_t chi2i;
  Int_t flagi;

  // List of branches
  TBranch *b_iphi;       
  TBranch *b_ieta;       
  TBranch *b_side;       
  TBranch *b_dccID;      
  TBranch *b_towerID;    
  TBranch *b_channelID;  
  TBranch *b_alpha;      
  TBranch *b_beta;       
  TBranch *b_width;      
  TBranch *b_chi2;       
  TBranch *b_flag;       

  if (tABinit) {
    tABinit->SetBranchAddress("iphi", &iphii, &b_iphi);
    tABinit->SetBranchAddress("ieta", &ietai, &b_ieta);
    tABinit->SetBranchAddress("side", &sidei, &b_side);
    tABinit->SetBranchAddress("dccID", &dccIDi, &b_dccID);
    tABinit->SetBranchAddress("towerID", &towerIDi, &b_towerID);
    tABinit->SetBranchAddress("channelID", &channelIDi, &b_channelID);
    tABinit->SetBranchAddress("alpha", &alphai, &b_alpha);
    tABinit->SetBranchAddress("beta", &betai, &b_beta);
    tABinit->SetBranchAddress("width", &widthi, &b_width);
    tABinit->SetBranchAddress("chi2", &chi2i, &b_chi2);
    tABinit->SetBranchAddress("flag", &flagi, &b_flag);

    nchsel = tABinit->GetEntries();
    assert(nchsel <= fNchsel);

    for (int cris = 0; cris < nchsel; cris++) {
      tABinit->GetEntry(cris);

      //      std::cout<< "Loop 1 "<< cris<<" "<<alphai<< std::endl;

      putalphaVal(cris, alphai);
      putchi2Val(cris, chi2i);
      putbetaVal(cris, betai);
      putwidthVal(cris, widthi);
      putflagVal(cris, flagi);

      putalphaInit(cris, alphai);
      putchi2Init(cris, chi2i);
      putbetaInit(cris, betai);
      putwidthInit(cris, widthi);
      putflagInit(cris, flagi);
      putetaInit(cris, ietai);
      putphiInit(cris, iphii);
    }
  }
}

void TShapeAnalysis::set_const(int ns, int ns1, int ns2, int ps, int nevtmax, double noise_val, double chi2_cut) {
  nsamplecristal = ns;
  presample = ps;
  sampbmax = ns1;
  sampamax = ns2;
  nevt = nevtmax;
  noise = noise_val;
  chi2cut = chi2_cut;
}

void TShapeAnalysis::set_presample(int ps) { presample = ps; }
void TShapeAnalysis::set_nch(int nch) {
  assert(nch <= fNchsel);
  if (tABinit)
    assert(nch == nchsel);
  nchsel = nch;
}
void TShapeAnalysis::assignChannel(int n, int ch) {
  if (n >= nchsel)
    printf(" number of channels exceed maximum allowed\n");

  index[n] = ch;
}

void TShapeAnalysis::putDateStart(long int timecur) { timestart = timecur; }

void TShapeAnalysis::putDateStop(long int timecur) { timestop = timecur; }

void TShapeAnalysis::getDateStart() {
  time_t t, timecur;
  timecur = time(&t);
  timestart = ((long int)timecur);
}

void TShapeAnalysis::getDateStop() {
  time_t t, timecur;
  timecur = time(&t);
  timestop = ((long int)timecur);
}

void TShapeAnalysis::putAllVals(int ch, double *sampl, int ieta, int iphi, int dcc, int side, int tower, int chid) {
  dcc_init[ch] = dcc;
  tower_init[ch] = side;
  ch_init[ch] = chid;
  side_init[ch] = side;
  eta_init[ch] = ieta;
  phi_init[ch] = iphi;
  putAllVals(ch, sampl, ieta, iphi);
}

void TShapeAnalysis::putAllVals(int ch, double *sampl, int ieta, int iphi) {
  int i, k;
  int n = -1;
  for (i = 0; i < nchsel; i++)
    if (index[i] == ch)
      n = i;

  if (n >= 0) {
    if (npass[n] < nevt) {
      for (k = 0; k < nsamplecristal; k++) {
        rawsglu[n][npass[n]][k] = sampl[k];
      }

      npass[n]++;
    }
  } else {
    printf("no index found for ch=%d\n", ch);
  }
}

void TShapeAnalysis::computeShape(string namefile, TTree *tAB) {
  double tm_atmax[200];
  double parout[3];

  double chi2_all = 0.;

  double **dbi;
  dbi = new double *[200];
  for (int k = 0; k < 200; k++)
    dbi[k] = new double[2];

  double **signalu;
  signalu = new double *[200];
  for (int k = 0; k < 200; k++)
    signalu[k] = new double[10];

  TFParams *pjf = new TFParams();

  for (int i = 0; i < nchsel; i++) {
    if (index[i] >= 0) {
      if (npass[i] <= 10) {
        putalphaVal(i, alpha_init[i]);
        putbetaVal(i, beta_init[i]);
        putwidthVal(i, width_init[i]);
        putchi2Val(i, chi2_init[i]);
        putflagVal(i, 0);

      } else {
        pjf->set_const(nsamplecristal, sampbmax, sampamax, alpha_init[i], beta_init[i], npass[i]);

        for (int pass = 0; pass < npass[i]; pass++) {
          double ped = 0;
          for (int k = 0; k < presample; k++) {
            ped += rawsglu[i][pass][k];
          }
          ped /= double(presample);

          for (int k = 0; k < nsamplecristal; k++) {
            signalu[pass][k] = rawsglu[i][pass][k] - ped;
          }
        }

        int debug = 0;
        chi2_all = pjf->fitpj(signalu, &parout[0], dbi, noise, debug);

        if (parout[0] >= 0.0 && parout[1] >= 0.0 && chi2_all <= chi2cut && chi2_all > 0.0) {
          putalphaVal(i, parout[0]);
          putbetaVal(i, parout[1]);
          putchi2Val(i, chi2_all);
          putflagVal(i, 1);

        } else {
          putalphaVal(i, alpha_init[i]);
          putbetaVal(i, beta_init[i]);
          putwidthVal(i, width_init[i]);
          putchi2Val(i, chi2_init[i]);
          putflagVal(i, 0);
        }

        for (int kj = 0; kj < npass[i]; kj++) {  // last event wrong here
          tm_atmax[kj] = dbi[kj][1];
        }
        computetmaxVal(i, &tm_atmax[0]);
      }
    }
  }

  if (tAB)
    tABinit = tAB->CloneTree();

  // Declaration of leaf types
  Int_t sidei;
  Int_t iphii;
  Int_t ietai;
  Int_t dccIDi;
  Int_t towerIDi;
  Int_t channelIDi;
  Double_t alphai;
  Double_t betai;
  Double_t widthi;
  Double_t chi2i;
  Int_t flagi;

  // List of branches
  TBranch *b_iphi;       
  TBranch *b_ieta;       
  TBranch *b_side;       
  TBranch *b_dccID;      
  TBranch *b_towerID;    
  TBranch *b_channelID;  
  TBranch *b_alpha;      
  TBranch *b_beta;       
  TBranch *b_width;      
  TBranch *b_chi2;       
  TBranch *b_flag;       

  if (tABinit) {
    tABinit->SetBranchAddress("iphi", &iphii, &b_iphi);
    tABinit->SetBranchAddress("ieta", &ietai, &b_ieta);
    tABinit->SetBranchAddress("side", &sidei, &b_side);
    tABinit->SetBranchAddress("dccID", &dccIDi, &b_dccID);
    tABinit->SetBranchAddress("towerID", &towerIDi, &b_towerID);
    tABinit->SetBranchAddress("channelID", &channelIDi, &b_channelID);
    tABinit->SetBranchAddress("alpha", &alphai, &b_alpha);
    tABinit->SetBranchAddress("beta", &betai, &b_beta);
    tABinit->SetBranchAddress("width", &widthi, &b_width);
    tABinit->SetBranchAddress("chi2", &chi2i, &b_chi2);
    tABinit->SetBranchAddress("flag", &flagi, &b_flag);
  }

  TFile *fABout = new TFile(namefile.c_str(), "RECREATE");
  tABout = new TTree("ABCol0", "ABCol0");

  // Declaration of leaf types
  Int_t side;
  Int_t iphi;
  Int_t ieta;
  Int_t dccID;
  Int_t towerID;
  Int_t channelID;
  Double_t alpha;
  Double_t beta;
  Double_t width;
  Double_t chi2;
  Int_t flag;

  tABout->Branch("iphi", &iphi, "iphi/I");
  tABout->Branch("ieta", &ieta, "ieta/I");
  tABout->Branch("side", &side, "side/I");
  tABout->Branch("dccID", &dccID, "dccID/I");
  tABout->Branch("towerID", &towerID, "towerID/I");
  tABout->Branch("channelID", &channelID, "channelID/I");
  tABout->Branch("alpha", &alpha, "alpha/D");
  tABout->Branch("beta", &beta, "beta/D");
  tABout->Branch("width", &width, "width/D");
  tABout->Branch("chi2", &chi2, "chi2/D");
  tABout->Branch("flag", &flag, "flag/I");

  tABout->SetBranchAddress("ieta", &ieta);
  tABout->SetBranchAddress("iphi", &iphi);
  tABout->SetBranchAddress("side", &side);
  tABout->SetBranchAddress("dccID", &dccID);
  tABout->SetBranchAddress("towerID", &towerID);
  tABout->SetBranchAddress("channelID", &channelID);
  tABout->SetBranchAddress("alpha", &alpha);
  tABout->SetBranchAddress("beta", &beta);
  tABout->SetBranchAddress("width", &width);
  tABout->SetBranchAddress("chi2", &chi2);
  tABout->SetBranchAddress("flag", &flag);

  for (int i = 0; i < nchsel; i++) {
    if (tABinit) {
      tABinit->GetEntry(i);
      iphi = iphii;
      ieta = ietai;
      side = sidei;
      dccID = dccIDi;
      towerID = towerIDi;
      channelID = channelIDi;

    } else {
      iphi = phi_init[i];
      ieta = eta_init[i];
      side = side_init[i];
      dccID = dcc_init[i];
      towerID = tower_init[i];
      channelID = ch_init[i];
    }

    alpha = alpha_val[i];
    beta = beta_val[i];
    width = width_val[i];
    chi2 = chi2_val[i];
    flag = flag_val[i];

    tABout->Fill();
  }

  tABout->Write();
  fABout->Close();

  delete pjf;
}

void TShapeAnalysis::computetmaxVal(int i, double *tm_val) {
  double tm_mean = 0;  //double tm_sig=0;

  double tm = 0.;
  double sigtm = 0.;
  for (int k = 0; k < npass[i] - 1; k++) {
    if (1. < tm_val[k] && tm_val[k] < 10.) {
      npassok[i]++;
      tm += tm_val[k];
      sigtm += tm_val[k] * tm_val[k];
    }
  }
  if (npassok[i] <= 0) {
    tm_mean = 0.;  //tm_sig=0.;
  } else {
    for (int k = 0; k < npass[i] - 1; k++) {
      if (1. < tm_val[k] && tm_val[k] < 10.) {
        double ss = (sigtm / npassok[i] - tm / npassok[i] * tm / npassok[i]);
        if (ss < 0.)
          ss = 0.;
        //tm_sig=sqrt(ss);
        tm_mean = tm / npassok[i];
      }
    }
  }
  //printf("npassok[%d]=%f tm_mean=%f tm_sig=%f\n",i,npassok[i],tm_mean,tm_sig);
  putwidthVal(i, tm_mean);
}

void TShapeAnalysis::putalphaVal(int n, double val) { alpha_val[n] = val; }

void TShapeAnalysis::putchi2Val(int n, double val) { chi2_val[n] = val; }
void TShapeAnalysis::putbetaVal(int n, double val) { beta_val[n] = val; }

void TShapeAnalysis::putwidthVal(int n, double val) { width_val[n] = val; }

void TShapeAnalysis::putflagVal(int n, int val) { flag_val[n] = val; }

void TShapeAnalysis::putalphaInit(int n, double val) { alpha_init[n] = val; }

void TShapeAnalysis::putchi2Init(int n, double val) { chi2_init[n] = val; }
void TShapeAnalysis::putbetaInit(int n, double val) { beta_init[n] = val; }

void TShapeAnalysis::putwidthInit(int n, double val) { width_init[n] = val; }

void TShapeAnalysis::putetaInit(int n, int val) { eta_init[n] = val; }

void TShapeAnalysis::putphiInit(int n, int val) { phi_init[n] = val; }

void TShapeAnalysis::putflagInit(int n, int val) { flag_init[n] = val; }
std::vector<double> TShapeAnalysis::getVals(int n) {
  std::vector<double> v;

  v.push_back(alpha_val[n]);
  v.push_back(beta_val[n]);
  v.push_back(width_val[n]);
  v.push_back(chi2_val[n]);
  v.push_back(flag_val[n]);

  return v;
}
std::vector<double> TShapeAnalysis::getInitVals(int n) {
  std::vector<double> v;

  v.push_back(alpha_init[n]);
  v.push_back(beta_init[n]);
  v.push_back(width_init[n]);
  v.push_back(chi2_init[n]);
  v.push_back(flag_init[n]);

  return v;
}

void TShapeAnalysis::printshapeData(int gRunNumber) {
  FILE *fd;
  int nev;
  sprintf(filename, "runABW%d.pedestal", gRunNumber);
  fd = fopen(filename, "w");
  if (fd == nullptr)
    printf("Error while opening file : %s\n", filename);

  for (int i = 0; i < nchsel; i++) {
    if (index[i] >= 0) {
      nev = (int)npassok[i];
      double trise = alpha_val[i] * beta_val[i];
      fprintf(fd,
              "%d %d 1 %ld %ld %f %f %f %f\n",
              index[i],
              nev,
              timestart,
              timestop,
              alpha_val[i],
              beta_val[i],
              trise,
              width_val[i]);
    }
  }
  int iret = fclose(fd);
  printf(" Closing file : %d\n", iret);
}