ELossTimeTask.C

Go to the documentation of this file.

#ifndef __CINT__
# include <AliFMDEventInspector.h>
# include <AliForwardCorrectionManager.h>
# include <TH2.h>
# include <AliESDFMD.h>
# include <AliAODForwardMult.h>
# include <AliESDEvent.h>
# include <TFile.h>
# include <TSystem.h>
#else
class AliFMDEventInspector;
class TH2;
class AliESDFMD;
#endif
#include <AliBaseESDTask.h>
#include <AliForwardUtil.h>
#define NO_TASK
#define NO_SORTER
#include "EventTimeTask.C"

struct ELossTimeTask : public AliBaseESDTask
{
  ELossTimeTask() 
    : AliBaseESDTask(),
      fEventInspector(),
      fFMD1i(),
      fFMD2i(),
      fFMD2o(), 
      fFMD3i(),
      fFMD3o(),
      fMap(0),
      fDt(0)
  {}
  ELossTimeTask(const char* name) 
    : AliBaseESDTask(name, "ELossTimeTask", 
         &(AliForwardCorrectionManager::Instance())),
      fEventInspector("fmdEventInspector"),
      fFMD1i(1, 'i'),
      fFMD2i(2, 'i'),
      fFMD2o(2, 'o'), 
      fFMD3i(3, 'i'),
      fFMD3o(3, 'o'),
      fMap(0),
      fDt(0)
  {
  }
  virtual Bool_t Book() 
  {
    fNeededCorrections = 0;
    fExtraCorrections  = 0;

    fDt = new TH1D("dt", "Time-to-last event (PS-triggered)", 60, 0, 15);
    fDt->SetXTitle("log_{10}(#Deltat)");
    fDt->SetFillColor(kYellow+2);
    fDt->SetLineColor(kYellow+2);
    fDt->SetFillStyle(3001);
    fDt->SetDirectory(0);
    fList->Add(fDt);

    fFMD1i.Book(fList, fDt);
    fFMD2i.Book(fList, fDt);
    fFMD2o.Book(fList, fDt);
    fFMD3i.Book(fList, fDt);
    fFMD3o.Book(fList, fDt);

    // Possibly re-read map
    ReadMap("map.root");

    return true;
  }
  virtual Bool_t Event(AliESDEvent& esd)
  {
    Bool_t   lowFlux   = kFALSE;
    UInt_t   triggers  = 0;
    UShort_t ivz       = 0;
    TVector3 ip;
    Double_t cent      = 0;
    UShort_t nClusters = 0;
    UInt_t   found     = fEventInspector.Process(&esd, triggers, lowFlux, 
             ivz, ip, cent, nClusters);
    if (found & AliFMDEventInspector::kNoEvent)    return false;
    if (found & AliFMDEventInspector::kNoTriggers) return false;
    if (found & AliFMDEventInspector::kNoSPD)      return false;
    if (found & AliFMDEventInspector::kNoFMD)      return false;
    if (found & AliFMDEventInspector::kNoVertex)   return false;
    if (found & AliFMDEventInspector::kBadVertex)  return false;

    // do not process pile-up, A, C, and E events 
    if (triggers & AliAODForwardMult::kPileUp)     return false;
    if (triggers & AliAODForwardMult::kA)          return false;
    if (triggers & AliAODForwardMult::kC)          return false;
    if (triggers & AliAODForwardMult::kE)          return false;
  
    // We want only the events found by off-line 
    if (!(triggers & AliAODForwardMult::kOffline)) return false;
    
    // Perhaps we should also insist on MB only 
    // if (fOnlyMB && (!(triggers & AliAODForwardMult::kInel))) return false;
    
    // Get FMD data 
    AliESDFMD* esdFMD = esd.GetFMDData();
    ULong64_t  period = esd.GetPeriodNumber();
    ULong64_t  orbit  = esd.GetOrbitNumber();
    ULong64_t  bc     = esd.GetBunchCrossNumber();
    ULong64_t  full   = EventTimeData::EncodeFull(period, orbit, bc);
    ULong64_t  dt     = fMap->Get(full);
    Double_t   logDt  = TMath::Log10(25. * dt);
    if (dt == EventTimeMap::kInvalidTime) {
      logDt = 0;
      Printf("!!! Failed to find dT for 0x%016llu", full);
    }
    // else 
    //   Printf("=== 0x%016llu -> 0x%016llu", full, dt);
    fDt->Fill(logDt);
    
    for (UShort_t d = 1; d <= 3; d++) { 
      UShort_t nQ = d == 1 ? 1 : 2;
      for (UShort_t q = 0; q < nQ; q++) { 
  RingHistos* r = 0;
  switch (d) { 
  case 1: r = &fFMD1i; break;
  case 2: r = (q == 0 ? &fFMD2i : &fFMD2o); break;
  case 3: r = (q == 0 ? &fFMD3i : &fFMD3o); break;
  }
  r->Event(*esdFMD, logDt);
      }
    }
    return true;
  }
  virtual Bool_t Finalize() 
  { 
    fDt = static_cast<TH1*>(fList->FindObject("dt"));

    fFMD1i.Finalize(fList, fResults, fDt);
    fFMD2i.Finalize(fList, fResults, fDt);
    fFMD2o.Finalize(fList, fResults, fDt);
    fFMD3i.Finalize(fList, fResults, fDt);
    fFMD3o.Finalize(fList, fResults, fDt);
    return true; 
  }
  virtual AliFMDEventInspector& GetEventInspector() { return fEventInspector; }
  virtual const AliFMDEventInspector& GetEventInspector() const 
  {
    return fEventInspector;
  }
  Bool_t ReadMap(const char* filename)
  {
    if (gSystem->AccessPathName(filename, kReadPermission)) {
      // TSystem::AccessPathName returns false if file can be accessed!
      Error("ReadMap", "File \"%s\" cannot be open for reading", filename);
      return false;
    }
    Printf("Opening \"%s\" ...", filename);
    TFile* file = TFile::Open(filename, "READ");
    if (!file) { 
      Error("ReadMap", "Failed to open file \"%s\"", filename);
      return false;
    }
    Printf("Opened \"%s\" ...", filename);
    TObject* o = file->Get("eventTimeMap");
    if (!o) { 
      Error("ReadMap", "Failed to get \"eventTimeMap\" from %s", filename);
      return false;
    }
    Printf("Got object \"eventTimeMap\" from \"%s\" ...", filename);
    if (!o->IsA()->InheritsFrom(EventTimeMap::Class())) { 
      Error("ReadMap", "Object \"%s\" is not an EventTimeMap, but a %s", 
      o->GetName(), o->ClassName());
      return false;
    }
    Printf("Set the \"eventTimeMap\" to use");
    if (fMap) { 
      delete fMap;
      fMap = 0;
    }
    fMap = static_cast<EventTimeMap*>(o);
    file->Close();
    return true;
  }
  static Bool_t Create(const char* mapfile) 
  {
    ELossTimeTask* task = new ELossTimeTask("elossTime");
    if (!task->ReadMap(mapfile)) return false;
    task->Connect();
    return true;
  }
protected:
  ELossTimeTask(const ELossTimeTask& o) : AliBaseESDTask(o) {}
  AliFMDEventInspector fEventInspector;
  struct RingHistos : public AliForwardUtil::RingHistos
  {
    RingHistos() 
      : AliForwardUtil::RingHistos(),
  fDtVsELoss(0)
    {}
    RingHistos(UShort_t d, Char_t r) 
      : AliForwardUtil::RingHistos(d,r),
  fDtVsELoss(0)
    {}
    Bool_t Book(TList* dir, TH1* dt)
    {
      TList* l = DefineOutputList(dir);
      // Double_t dtBins[] = { 0, 1, 2e3, 5e5, 1.1e6, 5e6, 1e12, 1e20 };
      fDtVsELoss = new TH2D("dtVsELoss", 
          Form("#Deltat vs #Delta/#Delta_{mip} - %s", 
         GetName()), 450, 0, 15, 
          dt->GetXaxis()->GetNbins(), 
          dt->GetXaxis()->GetXmin(), 
          dt->GetXaxis()->GetXmax());
      fDtVsELoss->SetXTitle("#Delta/#Delta_{mip}");
      fDtVsELoss->SetYTitle("log_{10}(#Deltat) [ns]");
      fDtVsELoss->SetMarkerColor(Color());
      fDtVsELoss->SetDirectory(0);
      l->Add(fDtVsELoss);

      return true;
    }
    void Event(AliESDFMD& fmd, Double_t logDt)
    {
      const UShort_t nSec = NSector();
      const UShort_t nStr = NStrip();
      for (UShort_t s = 0; s < nSec; s++) { 
  for (UShort_t t = 0; t < nStr; t++) { 
    Float_t mult = fmd.Multiplicity(fDet,fRing,s,t);
    if(mult == AliESDFMD::kInvalidMult || mult <= 0) 
      continue;
    fDtVsELoss->Fill(mult, logDt);
  }
      }
    }
    void Finalize(const TList* input, TList* output, TH1* dt)
    {
      TList* in  = GetOutputList(input);
      TList* out = DefineOutputList(output);

      fDtVsELoss = static_cast<TH2*>(in->FindObject("dtVsELoss"));

      TH2* dtVsELoss = static_cast<TH2*>(fDtVsELoss->Clone());
      dtVsELoss->SetDirectory(0);
      dtVsELoss->SetZTitle("1/N_{events}");
      dtVsELoss->Reset();
      for (UShort_t j = 1; j <= dt->GetNbinsX(); j++) { 
  Double_t norm = dt->GetBinContent(j);
  if (norm <= 0) {
    // Warning("Finalize", "Bin %d empty in dT", j);
    continue;
  }
  for (UShort_t i = 1; i <= fDtVsELoss->GetNbinsX(); i++) { 
    Double_t c = fDtVsELoss->GetBinContent(i, j);
    Double_t e = fDtVsELoss->GetBinError(i, j);
    dtVsELoss->SetBinContent(i,j,c/norm);
    dtVsELoss->SetBinError(i,j,e/norm);
  }
      }
      out->Add(dtVsELoss);
    }
    TH2* fDtVsELoss;
    ClassDef(RingHistos,1)
  };
  RingHistos    fFMD1i;
  RingHistos    fFMD2i;
  RingHistos    fFMD2o;
  RingHistos    fFMD3i;
  RingHistos    fFMD3o;
  EventTimeMap* fMap;
  TH1* fDt;
  ClassDef(ELossTimeTask,2)
};
//
// EOF
//