[u/mrichter/AliRoot.git] / FMD / AliFMDQADataMakerRec.cxx

/**************************************************************************
 * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
// --- ROOT system ---
#include <iostream>
#include <TClonesArray.h>
#include <TFile.h> 
#include <TH1F.h> 
#include <TH1I.h> 
#include <TH2I.h> 

// --- AliRoot header files ---
#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliFMDQADataMakerRec.h"
#include "AliFMDDigit.h"
#include "AliFMDRecPoint.h"
#include "AliQAChecker.h"
#include "AliESDFMD.h"
#include "AliFMDParameters.h"
#include "AliFMDRawReader.h"
#include "AliRawReader.h"
#include "AliFMDAltroMapping.h"
#include "AliFMDDebug.h"

namespace {
  Int_t colors[3] = {kRed,kGreen,kBlue};
}
//_____________________________________________________________________
// This is the class that collects the QA data for the FMD during
// reconstruction.  
//
// The following data types are picked up:
// - rec points
// - esd data
// - raws
// Author : Hans Hjersing Dalsgaard, hans.dalsgaard@cern.ch
//_____________________________________________________________________

ClassImp(AliFMDQADataMakerRec)
#if 0
; // For Emacs - do not delete!
#endif
           
//_____________________________________________________________________
AliFMDQADataMakerRec::AliFMDQADataMakerRec() : 
  AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD), 
		    "FMD Quality Assurance Data Maker"),
  fRecPointsArray("AliFMDRecPoint", 1000)
{
  // ctor
 
}

//_____________________________________________________________________
AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm) 
  : AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD), 
		      "FMD Quality Assurance Data Maker"),
    fRecPointsArray(qadm.fRecPointsArray)
{
  // copy ctor 
  // Parameters: 
  //    qadm    Object to copy from
  
}
//_____________________________________________________________________
AliFMDQADataMakerRec& 
AliFMDQADataMakerRec::operator = (const AliFMDQADataMakerRec& qadm ) 
{
  // 
  // Assignment operator 
  // 
  // Parameters:
  //    qadm What to assign from 
  // 
  // Return:
  //    Reference to this
  //
  fRecPointsArray = qadm.fRecPointsArray;
  
  return *this;
}
//_____________________________________________________________________
AliFMDQADataMakerRec::~AliFMDQADataMakerRec()
{
  // 
  // Destrcutor 
  // 
}


//_____________________________________________________________________ 

void 
AliFMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, 
					 TObjArray ** list)
{
  // Detector specific actions at end of cycle
  // do the QA checking
  ResetEventTrigClasses(); // reset triggers list to select all histos
  AliLog::Message(5,"FMD: end of detector cycle",
		  "AliFMDQADataMakerRec","AliFMDQADataMakerRec",
		  "AliFMDQADataMakerRec::EndOfDetectorCycle",
		  "AliFMDQADataMakerRec.cxx",95);
  AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list);
}

//_____________________________________________________________________ 
TH1* AliFMDQADataMakerRec::MakeADCHist(UShort_t d, Char_t r, Short_t b)
{
  TString name("adc"); 
  TString title("ADC counts");
  Int_t   color = kRed+1; 
  if (d > 0) { 
    name.Append(Form("FMD%d%c", d, r));
    title.Append(Form(" in FMD%d%c", d, r));
    color = colors[d-1]+3+(r == 'I' || r == 'i' ? 0 : 1);
    if (b >= 0) {
      name.Append(Form("_0x%02x", b));
      title.Append(Form("[0x%02x]", b));
    }
  }
  TH1* hist = new TH1F(name, title,1024,0,1024);
  hist->SetXTitle("Amplitude [ADC counts]");
  hist->SetYTitle("Events [log]");
  hist->SetFillStyle(3001);
  hist->SetFillColor(color);
  hist->SetLineColor(color);
  hist->SetMarkerColor(color);
  hist->GetXaxis()->SetNdivisions(408,false);
  hist->SetDirectory(0);
  // hist->SetStats(0);

  return hist;
}
//_____________________________________________________________________ 
TH1* AliFMDQADataMakerRec::MakeELossHist(UShort_t d, Char_t r, Short_t b)
{
  TString name("eloss"); 
  TString title("Energy loss");
  Int_t   color = kBlue+1;
  if (d > 0) { 
    name.Append(Form("FMD%d%c", d, r));
    title.Append(Form(" in FMD%d%c", d, r));
    color = colors[d-1]+3+(r == 'I' || r == 'i' ? 0 : 1);
    if (b >= 0) {
      name.Append(Form("_0x%02x", b));
      title.Append(Form("[0x%02x]", b));
    }
  }
  TH1* hist = new TH1F(name, title,300,0, 15);
  hist->SetXTitle("#Delta E/#Delta_{mip}");
  hist->SetYTitle("Events [log]");
  hist->SetFillStyle(3001);
  hist->SetFillColor(color);
  hist->SetLineColor(color);
  hist->SetMarkerColor(color);
  hist->SetDirectory(0);
  // hist->SetStats(0);

  return hist;
}


//_____________________________________________________________________ 
void AliFMDQADataMakerRec::InitESDs()
{
  // create Digits histograms in Digits subdir
  const Bool_t expert   = kTRUE ; 
  const Bool_t image    = kTRUE ; 
  
  TH1* hist = MakeELossHist();
  Add2ESDsList(hist, 0, !expert, image);
  ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line    
}

//_____________________________________________________________________
void AliFMDQADataMakerRec::InitDigits()
{
  // create Digits histograms in Digits subdir
  const Bool_t expert   = kTRUE ; 
  const Bool_t image    = kTRUE ; 
  
  TH1* hist = MakeADCHist();
  Add2DigitsList(hist, 0, !expert, image);
  ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}

//_____________________________________________________________________ 
void AliFMDQADataMakerRec::InitRecPoints()
{
  // create Reconstructed Points histograms in RecPoints subdir
  const Bool_t expert   = kTRUE ; 
  const Bool_t image    = kTRUE ; 

  TH1* hist = MakeELossHist();
  Add2RecPointsList(hist,0, !expert, image);
  ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last linea
}

//_____________________________________________________________________ 
void AliFMDQADataMakerRec::InitRaws()
{
  // create Raws histograms in Raws subdir  
  const Bool_t expert   = kTRUE ; 
  const Bool_t saveCorr = kTRUE ; 
  const Bool_t image    = kTRUE ; 
  TH2I* hErrors = new TH2I("readoutErrors", "Read out errors", 3, .5, 3.5,
			   160, -.5, 159.5); 
  hErrors->GetXaxis()->SetBinLabel(1, "FMD1");
  hErrors->GetXaxis()->SetBinLabel(2, "FMD2");
  hErrors->GetXaxis()->SetBinLabel(3, "FMD3");
  hErrors->SetYTitle("# errors");
  hErrors->SetZTitle("Events [log]");
  hErrors->SetDirectory(0);
  Add2RawsList(hErrors, 1, !expert, image, !saveCorr);
  //AliInfo(Form("Adding %30s to raw list @ %2d", hErrors->GetName(), 1));

  TH1* hist;
  Int_t idx = 0;
  for(UShort_t d = 1; d<=3; d++) {
    UShort_t nR = (d == 1 ? 1 : 2); 
    for(UShort_t q = 0; q < nR; q++) {
      Char_t r = (q == 1 ? 'O' : 'I');
      hist = MakeADCHist(d, r, -1);

      Int_t index1 = GetHalfringIndex(d, r, 0, 1);
      idx          = TMath::Max(index1, idx);
      Add2RawsList(hist, index1, !expert, image, !saveCorr);
      //AliInfo(Form("Adding %30s to raw list @ %2d", hist->GetName(), index1));
      
      for(UShort_t b = 0; b <= 1; b++) {
	//Hexadecimal board numbers 0x0, 0x1, 0x10, 0x11;
	UShort_t board = (q == 1 ? 0 : 1) + b*16;

	hist = MakeADCHist(d, r, board);
	Int_t index2 = GetHalfringIndex(d, r, board/16,0);
	idx          = TMath::Max(index2, idx);
	Add2RawsList(hist, index2, expert, !image, !saveCorr);
	//AliInfo(Form("Adding %30s to raw list @ %2d",hist->GetName(),index2));
      }
    }
  }
  //
  ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}

#if 0
struct FillESDHist : public AliESDFMD::ForOne
{
  FillESDHist(AliFMDQADataMakerRec* m) : fM(m) {}
  FillESDHist(const FillESDHist& o) : fM(o.fM) {}
  FillESDHist& operator=(const FillESDHist& o) { fM = o.fM; return *this;  }
  Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Float_t m, Float_t) 
  {
    // Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
    if(m == AliESDFMD::kInvalidMult) return true;
    
    fM->FillESDsData(0,m);
    return true;
  }
  AliFMDQADataMakerRec* fM;
};
#endif

//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
  // 
  // Analyse ESD event
  // 
  // Parameters:
  //    esd ESD event
  //
  if(!esd) {
    AliError("FMD ESD object not found!!") ; 
    return;
  }
  AliFMDDebug(2, ("Will loop over ESD data and fill histogram"));

  AliESDFMD* fmd = esd->GetFMDData();
  if (!fmd) return;

#if 0
  FillESDHist f(this);
  fmd->ForEach(f);
#else


  // FIXME - we should use AliESDFMD::ForOne subclass to do this!
  for(UShort_t det=1;det<=3;det++) {
    UShort_t nrng = (det == 1 ? 1 : 2);
    for (UShort_t ir = 0; ir < nrng; ir++) {
      Char_t   ring = (ir == 0 ? 'I' : 'O');
      UShort_t nsec = (ir == 0 ? 20  : 40);
      UShort_t nstr = (ir == 0 ? 512 : 256);
      for(UShort_t sec =0; sec < nsec;  sec++)  {
	for(UShort_t strip = 0; strip < nstr; strip++) {
	  Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
	  if(mult == AliESDFMD::kInvalidMult) continue;
	  
	  FillESDsData(0,mult);
	}
      }
    }
  }
#endif
  IncEvCountCycleESDs();
  IncEvCountTotalESDs();
}


//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeDigits()
{
  // makes data from Digits  
  if(!fDigitsArray)  {
    AliError("FMD Digit object not found!!") ;
    return;
  }
  
  for(Int_t i=0;i<fDigitsArray->GetEntriesFast();i++) {
    //Raw ADC counts
    AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
    FillDigitsData(0,digit->Counts());
  }
}

//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeDigits(TTree * digitTree)
{
  // 
  // Analyse digits
  // 
  // Parameters:
  //    digitTree Tree of digits
  //
  if (fDigitsArray) 
    fDigitsArray->Clear();
  else 
    fDigitsArray = new TClonesArray("AliFMDDigit", 1000);

  TBranch*      branch = digitTree->GetBranch("FMD");
  if (!branch) {
    AliWarning("FMD branch in Digit Tree not found") ; 
    return;
  } 
  branch->SetAddress(&fDigitsArray);
  branch->GetEntry(0); 
  MakeDigits();
  //
  IncEvCountCycleDigits();
  IncEvCountTotalDigits();
}

//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
  // 
  // Analyse raw 
  // 
  // Parameters:
  //    rawReader Raw reader
  //
 
  AliFMDRawReader fmdReader(rawReader,0);
  
  if (fDigitsArray) 
    fDigitsArray->Clear();
  else 
    fDigitsArray = new TClonesArray("AliFMDDigit", 1000);

  TClonesArray* digitsAddress = fDigitsArray;
  
  rawReader->Reset();
		
  digitsAddress->Clear();
  fmdReader.ReadAdcs(digitsAddress);
  for(Int_t i=0;i<digitsAddress->GetEntriesFast();i++) {
    //Raw ADC counts
    AliFMDDigit*      digit = static_cast<AliFMDDigit*>(digitsAddress->At(i));
    UShort_t          det   = digit->Detector();
    Char_t            ring  = digit->Ring();
    UShort_t          sec   = digit->Sector();
    // UShort_t strip = digit->Strip();
    AliFMDParameters* pars  = AliFMDParameters::Instance();
    Short_t           board = pars->GetAltroMap()->Sector2Board(ring, sec);
    
    Int_t index1 = GetHalfringIndex(det, ring, 0, 1);
    FillRawsData(index1,digit->Counts());
    Int_t index2 = GetHalfringIndex(det, ring, board/16,0);
    FillRawsData(index2,digit->Counts());
    
  }
  //
  FillRawsData(1,1, fmdReader.GetNErrors(0));
  FillRawsData(1,2, fmdReader.GetNErrors(1));
  FillRawsData(1,3, fmdReader.GetNErrors(2));
  //
  IncEvCountCycleRaws();
  IncEvCountTotalRaws();
}

//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeRecPoints(TTree* clustersTree)
{
  // makes data from RecPoints
  
   AliFMDParameters* pars = AliFMDParameters::Instance();
  fRecPointsArray.Clear();
  TBranch *fmdbranch = clustersTree->GetBranch("FMD");
  if (!fmdbranch) { 
    AliError("can't get the branch with the FMD recpoints !");
    return;
  }
  
  TClonesArray* RecPointsAddress = &fRecPointsArray;
  
  fmdbranch->SetAddress(&RecPointsAddress);
  fmdbranch->GetEntry(0);
  TIter next(RecPointsAddress) ; 
  AliFMDRecPoint * rp ; 
  while ((rp = static_cast<AliFMDRecPoint*>(next()))) {
    FillRecPointsData(0,rp->Edep()/pars->GetEdepMip());
  }
  IncEvCountCycleRecPoints();
  IncEvCountTotalRecPoints();
  //
}

//_____________________________________________________________________ 
void AliFMDQADataMakerRec::StartOfDetectorCycle()
{
  // What 
  // to 
  // do?
}
//_____________________________________________________________________ 
Int_t AliFMDQADataMakerRec::GetHalfringIndex(UShort_t det, 
					     Char_t ring, 
					     UShort_t board, 
					     UShort_t monitor) const
{
  // 
  // Get the half-ring index
  // 
  // Parameters:
  //    det      Detector
  //    ring     Ring
  //    board    Board number
  //    monitor  Monitor 
  // 
  // Return:
  //    Half ring index
  //  
  UShort_t iring = (ring == 'I' || ring == 'i' ? 1 : 0);
  Int_t    index = ((((det-1) & 0x3) << 3) | 
		    ((iring   & 0x1) << 2) |
		    ((board   & 0x1) << 1) | 
		    ((monitor & 0x1) << 0));
#if 0
  AliInfo(Form("d=%d, r=%c, b=%d, m=%d -> (%d<<3)|(%d<<2)|(%d<<1)|(%d<<0)=%2d",
	       det, ring, board, monitor, (det-1) & 0x3, iring & 0x1, 
	       board & 0x1, monitor & 0x1, index));
#endif
  return index-2;
}

//_____________________________________________________________________ 


//
// EOF
//
Commit	Line	Data
c9dd1c4d	1	/**************************************************************************
	2	* Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	// --- ROOT system ---
	16	#include <iostream>
	17	#include <TClonesArray.h>
	18	#include <TFile.h>
	19	#include <TH1F.h>
	20	#include <TH1I.h>
05e5e0c1	21	#include <TH2I.h>
c9dd1c4d	22
	23	// --- AliRoot header files ---
	24	#include "AliESDEvent.h"
	25	#include "AliLog.h"
	26	#include "AliFMDQADataMakerRec.h"
	27	#include "AliFMDDigit.h"
	28	#include "AliFMDRecPoint.h"
	29	#include "AliQAChecker.h"
	30	#include "AliESDFMD.h"
	31	#include "AliFMDParameters.h"
86c6cec8	32	#include "AliFMDRawReader.h"
3ceaa9ad	33	#include "AliRawReader.h"
b995fc28	34	#include "AliFMDAltroMapping.h"
f4b5062e	35	#include "AliFMDDebug.h"
c9dd1c4d	36
05e5e0c1	37	namespace {
	38	Int_t colors[3] = {kRed,kGreen,kBlue};
	39	}
c9dd1c4d	40	//_____________________________________________________________________
	41	// This is the class that collects the QA data for the FMD during
	42	// reconstruction.
	43	//
	44	// The following data types are picked up:
c9dd1c4d	45	// - rec points
c9dd1c4d	46	// - esd data
c9dd1c4d	47	// - raws
	48	// Author : Hans Hjersing Dalsgaard, hans.dalsgaard@cern.ch
	49	//_____________________________________________________________________
	50
	51	ClassImp(AliFMDQADataMakerRec)
	52	#if 0
	53	; // For Emacs - do not delete!
	54	#endif
	55
	56	//_____________________________________________________________________
	57	AliFMDQADataMakerRec::AliFMDQADataMakerRec() :
4e25ac79	58	AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
a7e41e8d	59	"FMD Quality Assurance Data Maker"),
198942c7	60	fRecPointsArray("AliFMDRecPoint", 1000)
c9dd1c4d	61	{
c9dd1c4d	62	// ctor
56236ce9	63
c9dd1c4d	64	}
	65
	66	//_____________________________________________________________________
a7e41e8d	67	AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm)
4e25ac79	68	: AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
a7e41e8d	69	"FMD Quality Assurance Data Maker"),
a7e41e8d	70	fRecPointsArray(qadm.fRecPointsArray)
c9dd1c4d	71	{
ffa78f64	72	// copy ctor
c9dd1c4d	73	// Parameters:
	74	// qadm Object to copy from
	75
	76	}
9bd2ccc2	77	//_____________________________________________________________________
63720979	78	AliFMDQADataMakerRec&
63720979	79	AliFMDQADataMakerRec::operator = (const AliFMDQADataMakerRec& qadm )
a7e41e8d	80	{
09b6c804	81	//
	82	// Assignment operator
	83	//
	84	// Parameters:
	85	// qadm What to assign from
	86	//
	87	// Return:
	88	// Reference to this
	89	//
a7e41e8d	90	fRecPointsArray = qadm.fRecPointsArray;
	91
	92	return *this;
	93	}
	94	//_____________________________________________________________________
9bd2ccc2	95	AliFMDQADataMakerRec::~AliFMDQADataMakerRec()
9bd2ccc2	96	{
09b6c804	97	//
	98	// Destrcutor
	99	//
9bd2ccc2	100	}
c9dd1c4d	101
	102
	103	//_____________________________________________________________________
	104
	105	void
4e25ac79	106	AliFMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task,
57acd2d2	107	TObjArray ** list)
c9dd1c4d	108	{
	109	// Detector specific actions at end of cycle
	110	// do the QA checking
92664bc8	111	ResetEventTrigClasses(); // reset triggers list to select all histos
ffa78f64	112	AliLog::Message(5,"FMD: end of detector cycle",
	113	"AliFMDQADataMakerRec","AliFMDQADataMakerRec",
	114	"AliFMDQADataMakerRec::EndOfDetectorCycle",
	115	"AliFMDQADataMakerRec.cxx",95);
4e25ac79	116	AliQAChecker::Instance()->Run(AliQAv1::kFMD, task, list);
c9dd1c4d	117	}
c9dd1c4d	118
05e5e0c1	119	//_____________________________________________________________________
	120	TH1* AliFMDQADataMakerRec::MakeADCHist(UShort_t d, Char_t r, Short_t b)
	121	{
	122	TString name("adc");
	123	TString title("ADC counts");
	124	Int_t color = kRed+1;
	125	if (d > 0) {
	126	name.Append(Form("FMD%d%c", d, r));
	127	title.Append(Form(" in FMD%d%c", d, r));
	128	color = colors[d-1]+3+(r == 'I' \|\| r == 'i' ? 0 : 1);
	129	if (b >= 0) {
	130	name.Append(Form("_0x%02x", b));
	131	title.Append(Form("[0x%02x]", b));
	132	}
	133	}
	134	TH1* hist = new TH1F(name, title,1024,0,1024);
	135	hist->SetXTitle("Amplitude [ADC counts]");
	136	hist->SetYTitle("Events [log]");
	137	hist->SetFillStyle(3001);
	138	hist->SetFillColor(color);
	139	hist->SetLineColor(color);
	140	hist->SetMarkerColor(color);
	141	hist->GetXaxis()->SetNdivisions(408,false);
dacd22c9	142	hist->SetDirectory(0);
05e5e0c1	143	// hist->SetStats(0);
	144
	145	return hist;
	146	}
	147	//_____________________________________________________________________
	148	TH1* AliFMDQADataMakerRec::MakeELossHist(UShort_t d, Char_t r, Short_t b)
	149	{
	150	TString name("eloss");
	151	TString title("Energy loss");
	152	Int_t color = kBlue+1;
	153	if (d > 0) {
	154	name.Append(Form("FMD%d%c", d, r));
	155	title.Append(Form(" in FMD%d%c", d, r));
	156	color = colors[d-1]+3+(r == 'I' \|\| r == 'i' ? 0 : 1);
	157	if (b >= 0) {
	158	name.Append(Form("_0x%02x", b));
	159	title.Append(Form("[0x%02x]", b));
	160	}
	161	}
	162	TH1* hist = new TH1F(name, title,300,0, 15);
	163	hist->SetXTitle("#Delta E/#Delta_{mip}");
	164	hist->SetYTitle("Events [log]");
	165	hist->SetFillStyle(3001);
	166	hist->SetFillColor(color);
	167	hist->SetLineColor(color);
	168	hist->SetMarkerColor(color);
dacd22c9	169	hist->SetDirectory(0);
05e5e0c1	170	// hist->SetStats(0);
	171
	172	return hist;
	173	}
	174
	175
c9dd1c4d	176	//_____________________________________________________________________
	177	void AliFMDQADataMakerRec::InitESDs()
	178	{
	179	// create Digits histograms in Digits subdir
7d297381	180	const Bool_t expert = kTRUE ;
	181	const Bool_t image = kTRUE ;
	182
05e5e0c1	183	TH1* hist = MakeELossHist();
05e5e0c1	184	Add2ESDsList(hist, 0, !expert, image);
92664bc8	185	ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
c9dd1c4d	186	}
c9dd1c4d	187
44ed7a66	188	//_____________________________________________________________________
	189	void AliFMDQADataMakerRec::InitDigits()
	190	{
	191	// create Digits histograms in Digits subdir
	192	const Bool_t expert = kTRUE ;
	193	const Bool_t image = kTRUE ;
	194
05e5e0c1	195	TH1* hist = MakeADCHist();
05e5e0c1	196	Add2DigitsList(hist, 0, !expert, image);
92664bc8	197	ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
44ed7a66	198	}
44ed7a66	199
c9dd1c4d	200	//_____________________________________________________________________
	201	void AliFMDQADataMakerRec::InitRecPoints()
	202	{
7d297381	203	// create Reconstructed Points histograms in RecPoints subdir
	204	const Bool_t expert = kTRUE ;
	205	const Bool_t image = kTRUE ;
	206
05e5e0c1	207	TH1* hist = MakeELossHist();
05e5e0c1	208	Add2RecPointsList(hist,0, !expert, image);
92664bc8	209	ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last linea
c9dd1c4d	210	}
	211
	212	//_____________________________________________________________________
	213	void AliFMDQADataMakerRec::InitRaws()
	214	{
7d297381	215	// create Raws histograms in Raws subdir
	216	const Bool_t expert = kTRUE ;
	217	const Bool_t saveCorr = kTRUE ;
	218	const Bool_t image = kTRUE ;
05e5e0c1	219	TH2I* hErrors = new TH2I("readoutErrors", "Read out errors", 3, .5, 3.5,
0f666f27	220	160, -.5, 159.5);
05e5e0c1	221	hErrors->GetXaxis()->SetBinLabel(1, "FMD1");
	222	hErrors->GetXaxis()->SetBinLabel(2, "FMD2");
	223	hErrors->GetXaxis()->SetBinLabel(3, "FMD3");
	224	hErrors->SetYTitle("# errors");
	225	hErrors->SetZTitle("Events [log]");
dacd22c9	226	hErrors->SetDirectory(0);
05e5e0c1	227	Add2RawsList(hErrors, 1, !expert, image, !saveCorr);
	228	//AliInfo(Form("Adding %30s to raw list @ %2d", hErrors->GetName(), 1));
	229
	230	TH1* hist;
	231	Int_t idx = 0;
	232	for(UShort_t d = 1; d<=3; d++) {
	233	UShort_t nR = (d == 1 ? 1 : 2);
	234	for(UShort_t q = 0; q < nR; q++) {
	235	Char_t r = (q == 1 ? 'O' : 'I');
	236	hist = MakeADCHist(d, r, -1);
	237
	238	Int_t index1 = GetHalfringIndex(d, r, 0, 1);
	239	idx = TMath::Max(index1, idx);
	240	Add2RawsList(hist, index1, !expert, image, !saveCorr);
	241	//AliInfo(Form("Adding %30s to raw list @ %2d", hist->GetName(), index1));
c18fe410	242
05e5e0c1	243	for(UShort_t b = 0; b <= 1; b++) {
c18fe410	244	//Hexadecimal board numbers 0x0, 0x1, 0x10, 0x11;
05e5e0c1	245	UShort_t board = (q == 1 ? 0 : 1) + b*16;
c18fe410	246
05e5e0c1	247	hist = MakeADCHist(d, r, board);
	248	Int_t index2 = GetHalfringIndex(d, r, board/16,0);
	249	idx = TMath::Max(index2, idx);
	250	Add2RawsList(hist, index2, expert, !image, !saveCorr);
	251	//AliInfo(Form("Adding %30s to raw list @ %2d",hist->GetName(),index2));
b4da452d	252	}
	253	}
	254	}
92664bc8	255	//
92664bc8	256	ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
c9dd1c4d	257	}
c9dd1c4d	258
408bf2b4	259	#if 0
	260	struct FillESDHist : public AliESDFMD::ForOne
	261	{
	262	FillESDHist(AliFMDQADataMakerRec* m) : fM(m) {}
	263	FillESDHist(const FillESDHist& o) : fM(o.fM) {}
	264	FillESDHist& operator=(const FillESDHist& o) { fM = o.fM; return *this; }
	265	Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Float_t m, Float_t)
	266	{
	267	// Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
	268	if(m == AliESDFMD::kInvalidMult) return true;
	269
92664bc8	270	fM->FillESDsData(0,m);
408bf2b4	271	return true;
	272	}
	273	AliFMDQADataMakerRec* fM;
	274	};
	275	#endif
	276
c9dd1c4d	277	//_____________________________________________________________________
	278	void AliFMDQADataMakerRec::MakeESDs(AliESDEvent * esd)
	279	{
09b6c804	280	//
	281	// Analyse ESD event
	282	//
	283	// Parameters:
	284	// esd ESD event
	285	//
c9dd1c4d	286	if(!esd) {
	287	AliError("FMD ESD object not found!!") ;
	288	return;
	289	}
f4b5062e	290	AliFMDDebug(2, ("Will loop over ESD data and fill histogram"));
f4b5062e	291
c9dd1c4d	292	AliESDFMD* fmd = esd->GetFMDData();
c9dd1c4d	293	if (!fmd) return;
f4b5062e	294
408bf2b4	295	#if 0
	296	FillESDHist f(this);
	297	fmd->ForEach(f);
	298	#else
	299
	300
	301
f4b5062e	302	// FIXME - we should use AliESDFMD::ForOne subclass to do this!
c9dd1c4d	303	for(UShort_t det=1;det<=3;det++) {
f4b5062e	304	UShort_t nrng = (det == 1 ? 1 : 2);
f4b5062e	305	for (UShort_t ir = 0; ir < nrng; ir++) {
c9dd1c4d	306	Char_t ring = (ir == 0 ? 'I' : 'O');
	307	UShort_t nsec = (ir == 0 ? 20 : 40);
	308	UShort_t nstr = (ir == 0 ? 512 : 256);
	309	for(UShort_t sec =0; sec < nsec; sec++) {
	310	for(UShort_t strip = 0; strip < nstr; strip++) {
	311	Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
	312	if(mult == AliESDFMD::kInvalidMult) continue;
	313
92664bc8	314	FillESDsData(0,mult);
c9dd1c4d	315	}
	316	}
	317	}
	318	}
408bf2b4	319	#endif
92664bc8	320	IncEvCountCycleESDs();
92664bc8	321	IncEvCountTotalESDs();
c9dd1c4d	322	}
c9dd1c4d	323
44ed7a66	324
c9dd1c4d	325	//_____________________________________________________________________
6252ceeb	326	void AliFMDQADataMakerRec::MakeDigits()
c9dd1c4d	327	{
c9dd1c4d	328	// makes data from Digits
6252ceeb	329	if(!fDigitsArray) {
ffa78f64	330	AliError("FMD Digit object not found!!") ;
ffa78f64	331	return;
c9dd1c4d	332	}
eca4fa66	333
6252ceeb	334	for(Int_t i=0;i<fDigitsArray->GetEntriesFast();i++) {
c9dd1c4d	335	//Raw ADC counts
6252ceeb	336	AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
92664bc8	337	FillDigitsData(0,digit->Counts());
c9dd1c4d	338	}
	339	}
	340
	341	//_____________________________________________________________________
	342	void AliFMDQADataMakerRec::MakeDigits(TTree * digitTree)
	343	{
09b6c804	344	//
	345	// Analyse digits
	346	//
	347	// Parameters:
	348	// digitTree Tree of digits
	349	//
6252ceeb	350	if (fDigitsArray)
	351	fDigitsArray->Clear();
	352	else
	353	fDigitsArray = new TClonesArray("AliFMDDigit", 1000);
	354
ffa78f64	355	TBranch* branch = digitTree->GetBranch("FMD");
ffa78f64	356	if (!branch) {
c9dd1c4d	357	AliWarning("FMD branch in Digit Tree not found") ;
	358	return;
	359	}
6252ceeb	360	branch->SetAddress(&fDigitsArray);
ffa78f64	361	branch->GetEntry(0);
6252ceeb	362	MakeDigits();
92664bc8	363	//
	364	IncEvCountCycleDigits();
	365	IncEvCountTotalDigits();
c9dd1c4d	366	}
44ed7a66	367
c9dd1c4d	368	//_____________________________________________________________________
86c6cec8	369	void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
c9dd1c4d	370	{
09b6c804	371	//
	372	// Analyse raw
	373	//
	374	// Parameters:
	375	// rawReader Raw reader
	376	//
198942c7	377
09b6c804	378	AliFMDRawReader fmdReader(rawReader,0);
6252ceeb	379
	380	if (fDigitsArray)
	381	fDigitsArray->Clear();
	382	else
	383	fDigitsArray = new TClonesArray("AliFMDDigit", 1000);
eca4fa66	384
6252ceeb	385	TClonesArray* digitsAddress = fDigitsArray;
3ceaa9ad	386
3ceaa9ad	387	rawReader->Reset();
78328afd	388
c18fe410	389	digitsAddress->Clear();
	390	fmdReader.ReadAdcs(digitsAddress);
	391	for(Int_t i=0;i<digitsAddress->GetEntriesFast();i++) {
	392	//Raw ADC counts
b995fc28	393	AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitsAddress->At(i));
	394	UShort_t det = digit->Detector();
	395	Char_t ring = digit->Ring();
	396	UShort_t sec = digit->Sector();
	397	// UShort_t strip = digit->Strip();
	398	AliFMDParameters* pars = AliFMDParameters::Instance();
	399	Short_t board = pars->GetAltroMap()->Sector2Board(ring, sec);
c18fe410	400
c18fe410	401	Int_t index1 = GetHalfringIndex(det, ring, 0, 1);
92664bc8	402	FillRawsData(index1,digit->Counts());
c18fe410	403	Int_t index2 = GetHalfringIndex(det, ring, board/16,0);
92664bc8	404	FillRawsData(index2,digit->Counts());
92664bc8	405
c18fe410	406	}
92664bc8	407	//
	408	FillRawsData(1,1, fmdReader.GetNErrors(0));
	409	FillRawsData(1,2, fmdReader.GetNErrors(1));
	410	FillRawsData(1,3, fmdReader.GetNErrors(2));
	411	//
	412	IncEvCountCycleRaws();
	413	IncEvCountTotalRaws();
c9dd1c4d	414	}
	415
	416	//_____________________________________________________________________
	417	void AliFMDQADataMakerRec::MakeRecPoints(TTree* clustersTree)
	418	{
	419	// makes data from RecPoints
eca4fa66	420
6252ceeb	421	AliFMDParameters* pars = AliFMDParameters::Instance();
56236ce9	422	fRecPointsArray.Clear();
c9dd1c4d	423	TBranch *fmdbranch = clustersTree->GetBranch("FMD");
	424	if (!fmdbranch) {
	425	AliError("can't get the branch with the FMD recpoints !");
	426	return;
	427	}
	428
56236ce9	429	TClonesArray* RecPointsAddress = &fRecPointsArray;
9bd2ccc2	430
56236ce9	431	fmdbranch->SetAddress(&RecPointsAddress);
c9dd1c4d	432	fmdbranch->GetEntry(0);
56236ce9	433	TIter next(RecPointsAddress) ;
c9dd1c4d	434	AliFMDRecPoint * rp ;
c9dd1c4d	435	while ((rp = static_cast<AliFMDRecPoint*>(next()))) {
92664bc8	436	FillRecPointsData(0,rp->Edep()/pars->GetEdepMip());
c9dd1c4d	437	}
92664bc8	438	IncEvCountCycleRecPoints();
	439	IncEvCountTotalRecPoints();
	440	//
c9dd1c4d	441	}
	442
	443	//_____________________________________________________________________
	444	void AliFMDQADataMakerRec::StartOfDetectorCycle()
	445	{
	446	// What
	447	// to
	448	// do?
	449	}
	450	//_____________________________________________________________________
b4da452d	451	Int_t AliFMDQADataMakerRec::GetHalfringIndex(UShort_t det,
b4da452d	452	Char_t ring,
c18fe410	453	UShort_t board,
09b6c804	454	UShort_t monitor) const
	455	{
	456	//
	457	// Get the half-ring index
	458	//
	459	// Parameters:
	460	// det Detector
	461	// ring Ring
	462	// board Board number
	463	// monitor Monitor
	464	//
	465	// Return:
	466	// Half ring index
	467	//
05e5e0c1	468	UShort_t iring = (ring == 'I' \|\| ring == 'i' ? 1 : 0);
	469	Int_t index = ((((det-1) & 0x3) << 3) \|
	470	((iring & 0x1) << 2) \|
	471	((board & 0x1) << 1) \|
	472	((monitor & 0x1) << 0));
	473	#if 0
	474	AliInfo(Form("d=%d, r=%c, b=%d, m=%d -> (%d<<3)\|(%d<<2)\|(%d<<1)\|(%d<<0)=%2d",
	475	det, ring, board, monitor, (det-1) & 0x3, iring & 0x1,
	476	board & 0x1, monitor & 0x1, index));
	477	#endif
b4da452d	478	return index-2;
b4da452d	479	}
	480
	481	//_____________________________________________________________________
	482
	483
c9dd1c4d	484	//
	485	// EOF
	486	//