PndTimeStructureAnaTask.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *         GNU Lesser General Public Licence version 3 (LGPL) version 3,        *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
 
#ifndef PndTimeStructureAnaTask_H
#define PndTimeStructureAnaTask_H

#include "FairTask.h" // for FairTask, InitStatus
#include "FairTSBufferFunctional.h"
#include "FairEventHeader.h"

#include "TH1.h"
#include "TGraph.h"

#include "Rtypes.h"  // for Bool_t, Int_t, kTRUE, etc
#include "TString.h" // for TString

class FairTimeStamp;
class TClonesArray;

struct DataObject {
  DataObject() : fBranchName(""), fBranch(nullptr), fTimeHisto(0), fEventHisto(0), fOldEventNr(-1), fOldTimeStamp(0), fEventMixture(kFALSE), fTimeGap(0.), fNEventsInSelection(0){};

  DataObject(TString branchName, Double_t timeGap)
    : fBranchName(branchName), fBranch(nullptr), fOldEventNr(-1), fOldTimeStamp(0), fEventMixture(kFALSE), fTimeGap(timeGap), fNEventsInSelection(0)
  {
    TString histoName("hBetweenEvents");
    histoName += fBranchName;
    TString eventHistoName("hInsideEvent");
    eventHistoName += fBranchName;
    TString eventDiffHistoName("hEventLength");
    eventDiffHistoName += fBranchName;
    TString eventsInSelection("hEventsInSelection");
    eventsInSelection += fBranchName;
    fTimeHisto = new TH1D(histoName, histoName, 10000, 0, 10000);
    fEventHisto = new TH1D(eventHistoName, eventHistoName, 100, 0, 100);
    fEventDiffHisto = new TH1D(eventDiffHistoName, eventDiffHistoName, 1000, 0, 1000);
    fEventsInSelection = new TH1D(eventsInSelection, eventsInSelection, 100, 0, 100);
  }
  std::vector<Double_t> CalcIntegral(TH1 *h1)
  {
    std::vector<Double_t> result;
    Double_t sum = 0;
    for (int i = 0; i < h1->GetNbinsX(); i++) {
      sum += h1->GetBinContent(i);
      result.push_back(sum);
    }
    return result;
  }

  std::vector<Double_t> GetBinCenters(TH1 *h1)
  {
    std::vector<Double_t> result;
    for (int i = 0; i < h1->GetNbinsX(); i++) {
      result.push_back(h1->GetBinCenter(i));
    }
    return result;
  }
  void FillGraphs()
  {

    TString eventGapName = fBranchName + "EventGap";
    fEventGap = new TH1D(eventGapName.Data(), eventGapName.Data(), fTimeHisto->GetNbinsX(), fTimeHisto->GetXaxis()->GetXmin(), fTimeHisto->GetXaxis()->GetXmax());
    FillGraph(fEventGap, fTimeHisto);

    TString eventGapPercName = fBranchName + "EventGapPerc";
    fEventGapPerc = new TH1D(eventGapPercName.Data(), eventGapPercName.Data(), fTimeHisto->GetNbinsX(), fTimeHisto->GetXaxis()->GetXmin(), fTimeHisto->GetXaxis()->GetXmax());
    FillGraphPercent(fEventGapPerc, fTimeHisto);

    TString overlapName = fBranchName + "Overlap";
    fOverlap = new TH1D(overlapName.Data(), overlapName.Data(), fEventHisto->GetNbinsX(), fEventHisto->GetXaxis()->GetXmin(), fEventHisto->GetXaxis()->GetXmax());
    FillGraph(fOverlap, fEventHisto);

    TString overlapPercName = fBranchName + "OverlapPerc";
    fOverlapPerc = new TH1D(overlapPercName.Data(), overlapPercName.Data(), fEventHisto->GetNbinsX(), fEventHisto->GetXaxis()->GetXmin(), fEventHisto->GetXaxis()->GetXmax());
    FillGraphPercent(fOverlapPerc, fEventHisto);
  }

  void FillGraph(TH1D *theGraph, TH1 *h1)
  {
    std::vector<Double_t> values = CalcIntegral(h1);
    std::vector<Double_t> binCenters = GetBinCenters(h1);
    for (size_t i = 0; i < values.size(); i++)
      theGraph->Fill(binCenters[i], values[i]);
  }

  void FillGraphPercent(TH1D *theGraph, TH1 *h1)
  {
    std::vector<Double_t> values = CalcIntegral(h1);
    std::vector<Double_t> binCenters = GetBinCenters(h1);
    for (size_t i = 0; i < values.size(); i++)
      theGraph->Fill(binCenters[i], values[i] / values.back() * 100.0);
  }

  TString fBranchName;
  TClonesArray *fBranch;
  TH1D *fTimeHisto;
  TH1D *fEventHisto;
  TH1D *fEventDiffHisto;
  TH1D *fEventGap;
  TH1D *fEventGapPerc;
  TH1D *fEventsInSelection;
  TH1D *fOverlap;
  TH1D *fOverlapPerc;
  Int_t fOldEventNr;
  Double_t fOldTimeStamp;
  Bool_t fEventMixture;
  Double_t fTimeGap;
  Int_t fNEventsInSelection;
  std::map<Int_t, std::pair<Double_t, Double_t>> fEventStartStopMap;
};

class PndTimeStructureAnaTask : public FairTask {
 public:
  PndTimeStructureAnaTask() : FairTask("TimeStructureAnaTask"), fTimeOfPreviousEvent(0.), fEntryNr(0) { SetVerbose(0); }

  PndTimeStructureAnaTask(const char *name) : FairTask(name), fEntryNr(0) { SetVerbose(0); }

  virtual ~PndTimeStructureAnaTask() {}

  virtual InitStatus Init();
  virtual InitStatus ReInit();

  virtual void Exec(Option_t *opt);
  virtual void FinishEvent();
  virtual void FinishTask();

  virtual void SetParContainers(){};

  void AddBranchName(TString name, Double_t gap)
  {
    fData.push_back(DataObject(name, gap));
    name += "Prim";
    fDataPrim.push_back(DataObject(name, gap));
  }

 protected:
  void FillTimeGapsEvent();

 private:
  std::vector<DataObject> fData;     // data for all type of particles
  std::vector<DataObject> fDataPrim; // data for primary particles
  TH1D *fHistoMixedEvents;
  TH1D *fHistoMixedEventsPrim;
  TH1D *fHistoTimeGapsEvents;
  FairEventHeader *fEventHeader;
  double fTimeOfPreviousEvent;

  Int_t fEntryNr;

  ClassDef(PndTimeStructureAnaTask, 1);
};

#endif