[u/mrichter/AliRoot.git] / T0 / AliT0QADataMakerRec.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/


/* $Id$ */

//---
//  Produces the data needed to calculate the quality assurance. 
//  Alla.Maevskaya@cern.ch
//---

// --- ROOT system ---
#include <TClonesArray.h>
#include <TFile.h> 
#include <TH1F.h> 
#include <TH2F.h> 
#include <TDirectory.h>
// --- Standard library ---

// --- AliRoot header files ---
#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliT0digit.h" 
#include "AliT0hit.h"
#include "AliT0RecPoint.h"
#include "AliT0QADataMakerRec.h"
#include "AliQAChecker.h"
#include "AliT0RawReader.h"

#include "Riostream.h"
ClassImp(AliT0QADataMakerRec)
           
//____________________________________________________________________________ 
  AliT0QADataMakerRec::AliT0QADataMakerRec() : 
  AliQADataMakerRec(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")

{
  // ctor
  for (Int_t i=0; i<6; i++) {
    fNumTriggers[i]=0;
    fNumTriggersCal[i]=0;
  }
}

//____________________________________________________________________________ 
AliT0QADataMakerRec::AliT0QADataMakerRec(const AliT0QADataMakerRec& qadm) :
  AliQADataMakerRec() 
{
  //copy ctor 
 SetName((const char*)qadm.GetName()) ; 
  SetTitle((const char*)qadm.GetTitle()); 
}

//__________________________________________________________________
AliT0QADataMakerRec& AliT0QADataMakerRec::operator = (const AliT0QADataMakerRec& qadm )
{
  // Equal operator.
  this->~AliT0QADataMakerRec();
  new(this) AliT0QADataMakerRec(qadm);
  return *this;
}
//____________________________________________________________________________
void AliT0QADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list)
{
  //Detector specific actions at end of cycle
  // do the QA checking
  AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
 if ( task == AliQA::kRAWS ) {
  Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
 for (Int_t itr=0; itr<6; itr++) {
    GetRawsData(197)->Fill(triggers[itr],fNumTriggersCal[itr]);
    GetRawsData(197)->SetBinContent(itr+1, fNumTriggersCal[itr]);
  }  
    GetRawsData(205)->SetOption("COLZ");
    GetRawsData(206)->SetOption("COLZ");
    GetRawsData(207)->SetOption("COLZ");
 }   
}

//____________________________________________________________________________
void AliT0QADataMakerRec::StartOfDetectorCycle()
{
  //Detector specific actions at start of cycle

}
 
//____________________________________________________________________________ 
void AliT0QADataMakerRec::InitRaws()
{
  // create Raw histograms in Raw subdir
  TString timename, ampname, qtcname, ledname;
  TString timeCalname, ampCalname, ledCalname, qtcCalname;

  TH1F* fhRefPoint = new TH1F("hRefPoint","Ref Point", 10,1252170, 1252180);
  Add2RawsList( fhRefPoint,0);
   
  TH1F *fhRawCFD[24]; TH1F * fhRawLEDamp[24];
  TH1F *fhRawQTC[24]; TH1F * fhRawLED[24];
  TH1F *fhRawCFDcal[24]; TH1F * fhRawLEDampcal[24]; 
  TH1F *fhRawQTCcal[24];  TH1F * fhRawLEDcal[24];
  
  for (Int_t i=0; i<24; i++)
    {
      timename ="hRawCFD";
      ledname = "hRawLED";
      qtcname = "hRawQTC";
      ampname = "hRawLEDminCFD";
      timename += i;
      ampname += i;
      qtcname += i;
      ledname += i;
      fhRawCFD[i] = new TH1F(timename.Data(), timename.Data(),500,-250,250);
      Add2RawsList( fhRawCFD[i],i+1);
      fhRawLED[i] = new TH1F(ledname.Data(), ledname.Data(),2000,-1000,1000);
      Add2RawsList( fhRawLED[i],i+24+1);
      fhRawLEDamp[i] = new TH1F(ampname.Data(), ampname.Data(),100,300,600);
      Add2RawsList( fhRawLEDamp[i],i+48+1);
      fhRawQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),1500,1000,7000);
      Add2RawsList( fhRawQTC[i],i+72+1);
     }
  const Bool_t saveForCorr = kTRUE;
  TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers",5,0,5);
  Add2RawsList(fhRawTrigger ,97);
  
  TH1F* fhRawMean = new TH1F("hRawMean","online mean signal", 100,2400,2500);
  Add2RawsList( fhRawMean,98);
  TH1F* fhRawVertex = new TH1F("hRawVertex","online vertex signal", 100,0,600);
  Add2RawsList( fhRawVertex,99);
  TH1F* fhRawORA = new TH1F("hRawORA","online OR A", 100,2500,2800);
  Add2RawsList( fhRawORA,100);
  TH1F* fhRawORC = new TH1F("hRawORC","online OR C", 100,2000,2300);
  Add2RawsList( fhRawORC,101);
  
  for (Int_t i=0; i<24; i++)
    {
      // for events with trigger CALIBRATION_EVENT
      timeCalname ="hRawCFDcal";
      ledCalname = "hRawLEDcal";
      ampCalname = "hRawLEDminCFDcal";
      qtcCalname = "hRawQTCcal";
      timeCalname += i;
      ledCalname += i;
      ampCalname += i;
      qtcCalname += i;
      fhRawCFDcal[i] = new TH1F(timeCalname.Data(), timeCalname.Data(),2000,-1000,1000);
      Add2RawsList( fhRawCFDcal[i],101+i+1);
      fhRawLEDcal[i] = new TH1F(ledCalname.Data(), ledCalname.Data(),2000,-1000,1000);
      Add2RawsList( fhRawLEDcal[i],101+i+24+1);
      fhRawLEDampcal[i] = new TH1F(ampCalname.Data(), ampCalname.Data(),300,300,600);
      Add2RawsList( fhRawLEDampcal[i],101+i+48+1);
      fhRawQTCcal[i] = new TH1F(qtcCalname.Data(), qtcCalname.Data(),1000,0,7000);
      Add2RawsList( fhRawQTCcal[i],101+i+72+1);
    }

  TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6);
  Add2RawsList(fhRawTriggerCal ,197 ,saveForCorr);

  TH1F* fhRawMeanCal = new TH1F("hRawMeanCal","online mean signal, calibration event",
				10000,0,10000);
  Add2RawsList( fhRawMeanCal,198);
  TH1F* fhRawVertexCal = new TH1F("hRawVertexCal","online vertex signal, calibration even ",
				  10000,0,10000);
  Add2RawsList( fhRawVertexCal,199);
  TH1F* fhRawORAcal = new TH1F("hRawORAcal","online OR A", 10000,0,10000);
  Add2RawsList( fhRawORAcal,200 );
  TH1F* fhRawORCcal = new TH1F("hRawORCcal","online OR C", 10000,0,10000);
  Add2RawsList( fhRawORCcal,201);
  TH1F* fhMultcal = new TH1F("hMultcal","full mulltiplicity", 10000,0,10000);
  Add2RawsList( fhMultcal,202 );
  TH1F* fhMultScal = new TH1F("hMultScal","full multiplicity with semi-central trigger",
			      10000,0,10000);
  Add2RawsList( fhMultScal,203);
  TH1F* fhMultCcal = new TH1F("hMultCcal","full multiplicity with central trigger", 
			      1000,0,10000);
  Add2RawsList( fhMultCcal,204);

  TH2F* fhEffCFD = new TH2F("hEffCFD"," CFD time",24, 0 ,24, 
			      100,-500,500);
  Add2RawsList( fhEffCFD,205, saveForCorr);
  TH2F* fhEffLED = new TH2F("hEffLED","LED time",24, 0 ,24, 
			      100,-500,500);
  Add2RawsList( fhEffLED,206, saveForCorr);
  TH2F* fhEffQTC = new TH2F("hEffQTC","QTC amplitude",24, 0 ,24, 
			      100,0,7000);
  Add2RawsList( fhEffQTC,207, saveForCorr);
}

//____________________________________________________________________________ 

void AliT0QADataMakerRec::InitRecPoints()
{
  // create cluster histograms in RecPoint subdir


  TString timename,ampname, qtcname;
  TH1F *fhRecCFD[24]; TH1F *fhRecLEDAmp[24];  TH1F * fhRecQTC[24];
  for (Int_t i=0; i<24; i++)
    {
      timename ="hRecCFD";
      ampname = "hRecLED";
      qtcname = "hRecQTC";
      timename += i;
      ampname += i;
      qtcname += i;
      fhRecCFD[i] = new TH1F(timename.Data(), timename.Data(),2000,-1000,1000);
      //    fhRecCFD[i] = new TH1F(timename.Data(), timename.Data(),6000,1244000,1250000);
      Add2RecPointsList ( fhRecCFD[i],i);
      fhRecLEDAmp[i] = new TH1F(ampname.Data(), ampname.Data(),100,0, 100);
      Add2RecPointsList ( fhRecLEDAmp[i],i+24);
      fhRecQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),100,0,100);
      Add2RecPointsList ( fhRecQTC[i],i+48);
     }
  

  //  TH1F *fhOnlineMean = new TH1F("hOnlineMean","online mean",2000,-1000,1000);
  TH1F *fhOnlineMean = new TH1F("hOnlineMean","online mean",6000,1244000,1250000);
  Add2RecPointsList ( fhOnlineMean,72);
  //  TH1F * fhRecMean = new TH1F("hRecMean"," reconstructed mean signal",2000,-1000,1000);
  TH1F * fhRecMean = new TH1F("hRecMean"," reconstructed mean signal",6000,1244000,1250000);
  Add2RecPointsList( fhRecMean,73);
  
  
}

//____________________________________________________________________________
void AliT0QADataMakerRec::InitESDs()
{
  //create ESDs histograms in ESDs subdir

  TH1F *fhESDMean = new TH1F("hESDmean"," ESD mean",100,2400,2500);
  Add2ESDsList(fhESDMean, 0) ;
  TH1F * fhESDVertex = new TH1F("hESDvertex","ESD vertex",100,-50,50);
  Add2ESDsList(fhESDVertex, 1) ;
  

}

//____________________________________________________________________________
void AliT0QADataMakerRec::MakeRaws( AliRawReader* rawReader)
{
	rawReader->Reset() ; 
  //fills QA histos for RAW
  Int_t shift=0;
  AliT0RawReader *start = new AliT0RawReader(rawReader);
  //  start->Next();
  if (! start->Next())
    AliDebug(1,Form(" no raw data found!!"));
  else
    {  
      
      UInt_t type =rawReader->GetType();
      //     cout<<" !!!!! new event type = "<<type<<endl;
      Int_t allData[110][5];
      for (Int_t i0=0; i0<105; i0++)
	{
	  for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;
	}
      for (Int_t i=0; i<105; i++) 
	for (Int_t iHit=0; iHit<5; iHit++)
	  allData[i][iHit]= start->GetData(i,iHit);
      
      if (allData[0][0]>0)    GetRawsData(0) -> Fill( allData[0][0]);
      //  allData[0][0] = allData[0][0] - 7000; 
      if (type == 8) shift=101;
      if (type == 7) shift=0;
      
      for (Int_t ik = 0; ik<12; ik++){
	for (Int_t iHt=0; iHt<5; iHt++){
	  //cfd
	  if(allData[ik+1][iHt]>0)
	    GetRawsData(shift+ik+1) -> 
	      Fill(allData[ik+1][iHt]-allData[1][0]);
	  //led
	  if(allData[ik+13][iHt] > 0 && allData[13][iHt]>0) 
	    GetRawsData(shift+ik+24+1)->
	      Fill(allData[ik+13][iHt]-allData[13][iHt]);
	  //led -cfd

	  if(allData[ik+13][iHt] > 0 && allData[ik+1][iHt] >0 )
	    GetRawsData(shift+ik+48+1)->
	      Fill(allData[ik+13][iHt]-allData[ik+1][iHt]);
	  //qtc
	  if(allData[2*ik+25][iHt] > 0 && allData[2*ik+26][iHt] > 0)
	    GetRawsData(shift+ik+72+1)->
	      Fill(allData[2*ik+25][iHt]-allData[2*ik+26][iHt]);
	  
	  
	  if(type == 8 && allData[ik+1][iHt]>0 )  
	    GetRawsData(205)->Fill(ik,allData[ik+1][iHt]-allData[1][0]);
	  if(type == 8 && allData[ik+13][iHt]>0 ) 
	    GetRawsData(206)->Fill(ik,allData[ik+13][iHt]-allData[13][0]);
	  if(type == 8 && (allData[2*ik+25][iHt]>0 && allData[2*ik+26][iHt]>0) ) 
	    GetRawsData(207)->Fill(ik,allData[2*ik+25][iHt]-allData[2*ik+26][iHt]);
	}
      }
      for (Int_t ik = 12; ik<24; ik++) {
	for (Int_t iHt=0; iHt<5; iHt++) {
	  if(allData[ik+45][iHt]>0) 
	    //cfd
	    GetRawsData(shift+ik+1)->
	      Fill(allData[ik+45][iHt]-allData[57][0]);
	    //qtc	  
	  if(allData[2*ik+57][iHt]>0 && allData[2*ik+58][iHt]>0)
	    GetRawsData(shift+ik+72+1)->
	      Fill(allData[2*ik+57][iHt]-allData[2*ik+58][iHt]);
	  //led
	  if(allData[ik+57][iHt] > 0 )
	    GetRawsData(shift+ik+24+1)->
	      Fill(allData[ik+57][iHt]-allData[69][iHt]);
	    //led-cfd
	  if(allData[ik+57][iHt] > 0 &&allData[ik+45][iHt]>0)
	    GetRawsData(shift+ik+48+1)->
	      Fill(allData[ik+57][iHt]-allData[ik+45][iHt]);
	  
	  if(type == 8 && allData[ik+45][iHt]>0 ) 
	    GetRawsData(205)->Fill(ik,allData[ik+45][iHt]-allData[57][0]);
	  if(type == 8 && allData[ik+57][iHt]>0 ) 
	    GetRawsData(206)->Fill(ik,allData[ik+57][iHt]-allData[69][0]);
	  if(type == 8 && (allData[2*ik+57][iHt]>0 && allData[2*ik+58][iHt]>0) ) 
	    GetRawsData(207)->Fill(ik,allData[2*ik+57][iHt]-allData[2*ik+58][iHt]);
	  
	  
	}
      }
      Int_t trChannel[6] = {49,50,51,52,55,56};  
      if(type == 7)
	{
	  for (Int_t iHt=0; iHt<6; iHt++) {
	    for (Int_t itr=0; itr<6; itr++) {
	      if(allData[trChannel[itr]][iHt]>0) fNumTriggers[itr]++;
	    }
	  }
	}
      if(type == 8)
	{
	  for (Int_t iHt=0; iHt<5; iHt++) {
	    for (Int_t itr=0; itr<6; itr++) {
	      if(allData[trChannel[itr]][iHt]>0)
		{
		  
		  GetRawsData(198+itr)->Fill(allData[trChannel[itr]][iHt]-allData[1][0]);
		  
		  fNumTriggersCal[itr]++;
		}
	    }
	  if(allData[53][iHt]>0 && allData[54][iHt]>0) 
	    GetRawsData(204)->Fill(allData[53][iHt]-allData[54][iHt]);
	  }
	} 

    
      delete start;
    }
}
  

//____________________________________________________________________________
void AliT0QADataMakerRec::MakeRecPoints(TTree * clustersTree)
{
  //fills QA histos for clusters

  AliT0RecPoint* frecpoints= new AliT0RecPoint ();
    if (!frecpoints) {
    AliError("Reconstruct Fill ESD >> no recpoints found");
    return;
  }
  TBranch *brRec =clustersTree ->GetBranch("T0");
  if (brRec) {
    brRec->SetAddress(&frecpoints);
  }else{
      AliError(Form("EXEC Branch T0 rec not found "));
      return;
  } 
    
  brRec->GetEntry(0);
  
  for ( Int_t i=0; i<24; i++) {
    if(i<12)
      GetRecPointsData(i) -> Fill( frecpoints -> GetTime(i) - frecpoints -> GetTime(0)); 
    if(i>11)
      GetRecPointsData(i) -> Fill( frecpoints -> GetTime(i) - frecpoints -> GetTime(12)); 
    GetRecPointsData(i+24) -> Fill( frecpoints -> GetAmp(i));
    GetRecPointsData(i+48) -> Fill( frecpoints->AmpLED(i));
  }
   GetRecPointsData(72) ->Fill(frecpoints->GetOnlineMean());
   GetRecPointsData(73) ->Fill(frecpoints->GetMeanTime());
  
}

//____________________________________________________________________________
void AliT0QADataMakerRec::MakeESDs(AliESDEvent * esd)
{
  //fills QA histos for ESD

  GetESDsData(0) -> Fill(esd->GetT0());
  GetESDsData(1)-> Fill(esd->GetT0zVertex());

}
Commit	Line	Data
04236e67	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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
	16
	17	/* $Id$ */
	18
	19	//---
	20	// Produces the data needed to calculate the quality assurance.
1d7681da	21	// Alla.Maevskaya@cern.ch
04236e67	22	//---
	23
	24	// --- ROOT system ---
	25	#include <TClonesArray.h>
	26	#include <TFile.h>
	27	#include <TH1F.h>
1d7681da	28	#include <TH2F.h>
04236e67	29	#include <TDirectory.h>
	30	// --- Standard library ---
	31
	32	// --- AliRoot header files ---
	33	#include "AliESDEvent.h"
	34	#include "AliLog.h"
	35	#include "AliT0digit.h"
	36	#include "AliT0hit.h"
	37	#include "AliT0RecPoint.h"
	38	#include "AliT0QADataMakerRec.h"
	39	#include "AliQAChecker.h"
	40	#include "AliT0RawReader.h"
	41
1d7681da	42	#include "Riostream.h"
04236e67	43	ClassImp(AliT0QADataMakerRec)
	44
	45	//____________________________________________________________________________
	46	AliT0QADataMakerRec::AliT0QADataMakerRec() :
	47	AliQADataMakerRec(AliQA::GetDetName(AliQA::kT0), "T0 Quality Assurance Data Maker")
	48
	49	{
	50	// ctor
1d7681da	51	for (Int_t i=0; i<6; i++) {
	52	fNumTriggers[i]=0;
	53	fNumTriggersCal[i]=0;
04236e67	54	}
04236e67	55	}
	56
	57	//____________________________________________________________________________
	58	AliT0QADataMakerRec::AliT0QADataMakerRec(const AliT0QADataMakerRec& qadm) :
	59	AliQADataMakerRec()
	60	{
	61	//copy ctor
1d7681da	62	SetName((const char*)qadm.GetName()) ;
04236e67	63	SetTitle((const char*)qadm.GetTitle());
	64	}
	65
	66	//__________________________________________________________________
	67	AliT0QADataMakerRec& AliT0QADataMakerRec::operator = (const AliT0QADataMakerRec& qadm )
	68	{
	69	// Equal operator.
	70	this->~AliT0QADataMakerRec();
	71	new(this) AliT0QADataMakerRec(qadm);
	72	return *this;
	73	}
	74	//____________________________________________________________________________
92a357bf	75	void AliT0QADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list)
04236e67	76	{
	77	//Detector specific actions at end of cycle
	78	// do the QA checking
c4b97145	79	AliQAChecker::Instance()->Run(AliQA::kT0, task, list) ;
699d8c51	80	if ( task == AliQA::kRAWS ) {
1d7681da	81	Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
699d8c51	82	for (Int_t itr=0; itr<6; itr++) {
1d7681da	83	GetRawsData(197)->Fill(triggers[itr],fNumTriggersCal[itr]);
	84	GetRawsData(197)->SetBinContent(itr+1, fNumTriggersCal[itr]);
	85	}
	86	GetRawsData(205)->SetOption("COLZ");
	87	GetRawsData(206)->SetOption("COLZ");
	88	GetRawsData(207)->SetOption("COLZ");
699d8c51	89	}
04236e67	90	}
	91
	92	//____________________________________________________________________________
	93	void AliT0QADataMakerRec::StartOfDetectorCycle()
	94	{
	95	//Detector specific actions at start of cycle
	96
	97	}
	98
	99	//____________________________________________________________________________
	100	void AliT0QADataMakerRec::InitRaws()
	101	{
	102	// create Raw histograms in Raw subdir
1d7681da	103	TString timename, ampname, qtcname, ledname;
1d7681da	104	TString timeCalname, ampCalname, ledCalname, qtcCalname;
04236e67	105
86c020af	106	TH1F* fhRefPoint = new TH1F("hRefPoint","Ref Point", 10,1252170, 1252180);
	107	Add2RawsList( fhRefPoint,0);
	108
1d7681da	109	TH1F fhRawCFD[24]; TH1F fhRawLEDamp[24];
	110	TH1F fhRawQTC[24]; TH1F fhRawLED[24];
	111	TH1F fhRawCFDcal[24]; TH1F fhRawLEDampcal[24];
	112	TH1F fhRawQTCcal[24]; TH1F fhRawLEDcal[24];
86c020af	113
04236e67	114	for (Int_t i=0; i<24; i++)
	115	{
	116	timename ="hRawCFD";
1d7681da	117	ledname = "hRawLED";
04236e67	118	qtcname = "hRawQTC";
1d7681da	119	ampname = "hRawLEDminCFD";
04236e67	120	timename += i;
	121	ampname += i;
	122	qtcname += i;
1d7681da	123	ledname += i;
1d7681da	124	fhRawCFD[i] = new TH1F(timename.Data(), timename.Data(),500,-250,250);
86c020af	125	Add2RawsList( fhRawCFD[i],i+1);
1d7681da	126	fhRawLED[i] = new TH1F(ledname.Data(), ledname.Data(),2000,-1000,1000);
1d7681da	127	Add2RawsList( fhRawLED[i],i+24+1);
446d6ec4	128	fhRawLEDamp[i] = new TH1F(ampname.Data(), ampname.Data(),100,300,600);
1d7681da	129	Add2RawsList( fhRawLEDamp[i],i+48+1);
86c020af	130	fhRawQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),1500,1000,7000);
1d7681da	131	Add2RawsList( fhRawQTC[i],i+72+1);
04236e67	132	}
cf66e144	133	const Bool_t saveForCorr = kTRUE;
1d7681da	134	TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers",5,0,5);
	135	Add2RawsList(fhRawTrigger ,97);
	136
86c020af	137	TH1F* fhRawMean = new TH1F("hRawMean","online mean signal", 100,2400,2500);
1d7681da	138	Add2RawsList( fhRawMean,98);
86c020af	139	TH1F* fhRawVertex = new TH1F("hRawVertex","online vertex signal", 100,0,600);
1d7681da	140	Add2RawsList( fhRawVertex,99);
86c020af	141	TH1F* fhRawORA = new TH1F("hRawORA","online OR A", 100,2500,2800);
1d7681da	142	Add2RawsList( fhRawORA,100);
86c020af	143	TH1F* fhRawORC = new TH1F("hRawORC","online OR C", 100,2000,2300);
1d7681da	144	Add2RawsList( fhRawORC,101);
1d7681da	145
5ed41460	146	for (Int_t i=0; i<24; i++)
	147	{
	148	// for events with trigger CALIBRATION_EVENT
	149	timeCalname ="hRawCFDcal";
1d7681da	150	ledCalname = "hRawLEDcal";
1d7681da	151	ampCalname = "hRawLEDminCFDcal";
5ed41460	152	qtcCalname = "hRawQTCcal";
5ed41460	153	timeCalname += i;
1d7681da	154	ledCalname += i;
5ed41460	155	ampCalname += i;
5ed41460	156	qtcCalname += i;
1d7681da	157	fhRawCFDcal[i] = new TH1F(timeCalname.Data(), timeCalname.Data(),2000,-1000,1000);
	158	Add2RawsList( fhRawCFDcal[i],101+i+1);
	159	fhRawLEDcal[i] = new TH1F(ledCalname.Data(), ledCalname.Data(),2000,-1000,1000);
	160	Add2RawsList( fhRawLEDcal[i],101+i+24+1);
	161	fhRawLEDampcal[i] = new TH1F(ampCalname.Data(), ampCalname.Data(),300,300,600);
	162	Add2RawsList( fhRawLEDampcal[i],101+i+48+1);
5ed41460	163	fhRawQTCcal[i] = new TH1F(qtcCalname.Data(), qtcCalname.Data(),1000,0,7000);
1d7681da	164	Add2RawsList( fhRawQTCcal[i],101+i+72+1);
5ed41460	165	}
1d7681da	166
1d7681da	167	TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6);
c4b97145	168	Add2RawsList(fhRawTriggerCal ,197 ,saveForCorr);
1d7681da	169
5ed41460	170	TH1F* fhRawMeanCal = new TH1F("hRawMeanCal","online mean signal, calibration event",
54f32a55	171	10000,0,10000);
1d7681da	172	Add2RawsList( fhRawMeanCal,198);
5ed41460	173	TH1F* fhRawVertexCal = new TH1F("hRawVertexCal","online vertex signal, calibration even ",
54f32a55	174	10000,0,10000);
1d7681da	175	Add2RawsList( fhRawVertexCal,199);
54f32a55	176	TH1F* fhRawORAcal = new TH1F("hRawORAcal","online OR A", 10000,0,10000);
1d7681da	177	Add2RawsList( fhRawORAcal,200 );
54f32a55	178	TH1F* fhRawORCcal = new TH1F("hRawORCcal","online OR C", 10000,0,10000);
1d7681da	179	Add2RawsList( fhRawORCcal,201);
54f32a55	180	TH1F* fhMultcal = new TH1F("hMultcal","full mulltiplicity", 10000,0,10000);
1d7681da	181	Add2RawsList( fhMultcal,202 );
5ed41460	182	TH1F* fhMultScal = new TH1F("hMultScal","full multiplicity with semi-central trigger",
54f32a55	183	10000,0,10000);
1d7681da	184	Add2RawsList( fhMultScal,203);
5ed41460	185	TH1F* fhMultCcal = new TH1F("hMultCcal","full multiplicity with central trigger",
5ed41460	186	1000,0,10000);
1d7681da	187	Add2RawsList( fhMultCcal,204);
	188
	189	TH2F* fhEffCFD = new TH2F("hEffCFD"," CFD time",24, 0 ,24,
	190	100,-500,500);
c4b97145	191	Add2RawsList( fhEffCFD,205, saveForCorr);
1d7681da	192	TH2F* fhEffLED = new TH2F("hEffLED","LED time",24, 0 ,24,
1d7681da	193	100,-500,500);
c4b97145	194	Add2RawsList( fhEffLED,206, saveForCorr);
1d7681da	195	TH2F* fhEffQTC = new TH2F("hEffQTC","QTC amplitude",24, 0 ,24,
1d7681da	196	100,0,7000);
c4b97145	197	Add2RawsList( fhEffQTC,207, saveForCorr);
04236e67	198	}
	199
	200	//____________________________________________________________________________
	201
	202	void AliT0QADataMakerRec::InitRecPoints()
	203	{
	204	// create cluster histograms in RecPoint subdir
1d7681da	205
1d7681da	206
04236e67	207
	208	TString timename,ampname, qtcname;
	209	TH1F fhRecCFD[24]; TH1F fhRecLEDAmp[24]; TH1F * fhRecQTC[24];
	210	for (Int_t i=0; i<24; i++)
	211	{
	212	timename ="hRecCFD";
	213	ampname = "hRecLED";
	214	qtcname = "hRecQTC";
	215	timename += i;
	216	ampname += i;
	217	qtcname += i;
1d7681da	218	fhRecCFD[i] = new TH1F(timename.Data(), timename.Data(),2000,-1000,1000);
	219	// fhRecCFD[i] = new TH1F(timename.Data(), timename.Data(),6000,1244000,1250000);
	220	Add2RecPointsList ( fhRecCFD[i],i);
c724dd64	221	fhRecLEDAmp[i] = new TH1F(ampname.Data(), ampname.Data(),100,0, 100);
1d7681da	222	Add2RecPointsList ( fhRecLEDAmp[i],i+24);
c724dd64	223	fhRecQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),100,0,100);
1d7681da	224	Add2RecPointsList ( fhRecQTC[i],i+48);
04236e67	225	}
1d7681da	226
1d7681da	227
04236e67	228
1d7681da	229	// TH1F *fhOnlineMean = new TH1F("hOnlineMean","online mean",2000,-1000,1000);
1d7681da	230	TH1F *fhOnlineMean = new TH1F("hOnlineMean","online mean",6000,1244000,1250000);
c724dd64	231	Add2RecPointsList ( fhOnlineMean,72);
1d7681da	232	// TH1F * fhRecMean = new TH1F("hRecMean"," reconstructed mean signal",2000,-1000,1000);
1d7681da	233	TH1F * fhRecMean = new TH1F("hRecMean"," reconstructed mean signal",6000,1244000,1250000);
446d6ec4	234	Add2RecPointsList( fhRecMean,73);
1d7681da	235
04236e67	236
	237	}
	238
	239	//____________________________________________________________________________
	240	void AliT0QADataMakerRec::InitESDs()
	241	{
	242	//create ESDs histograms in ESDs subdir
f6c2d5e2	243
446d6ec4	244	TH1F *fhESDMean = new TH1F("hESDmean"," ESD mean",100,2400,2500);
04236e67	245	Add2ESDsList(fhESDMean, 0) ;
1d7681da	246	TH1F * fhESDVertex = new TH1F("hESDvertex","ESD vertex",100,-50,50);
04236e67	247	Add2ESDsList(fhESDVertex, 1) ;
c724dd64	248
04236e67	249
	250	}
	251
	252	//____________________________________________________________________________
	253	void AliT0QADataMakerRec::MakeRaws( AliRawReader* rawReader)
	254	{
78328afd	255	rawReader->Reset() ;
04236e67	256	//fills QA histos for RAW
5ed41460	257	Int_t shift=0;
86c020af	258	AliT0RawReader *start = new AliT0RawReader(rawReader);
	259	// start->Next();
	260	if (! start->Next())
	261	AliDebug(1,Form(" no raw data found!!"));
	262	else
	263	{
1d7681da	264
5ed41460	265	UInt_t type =rawReader->GetType();
5ed41460	266	// cout<<" !!!!! new event type = "<<type<<endl;
86c020af	267	Int_t allData[110][5];
	268	for (Int_t i0=0; i0<105; i0++)
	269	{
	270	for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;
04236e67	271	}
86c020af	272	for (Int_t i=0; i<105; i++)
	273	for (Int_t iHit=0; iHit<5; iHit++)
	274	allData[i][iHit]= start->GetData(i,iHit);
	275
1d7681da	276	if (allData[0][0]>0) GetRawsData(0) -> Fill( allData[0][0]);
	277	// allData[0][0] = allData[0][0] - 7000;
	278	if (type == 8) shift=101;
f6c2d5e2	279	if (type == 7) shift=0;
1d7681da	280
86c020af	281	for (Int_t ik = 0; ik<12; ik++){
86c020af	282	for (Int_t iHt=0; iHt<5; iHt++){
1d7681da	283	//cfd
	284	if(allData[ik+1][iHt]>0)
	285	GetRawsData(shift+ik+1) ->
	286	Fill(allData[ik+1][iHt]-allData[1][0]);
	287	//led
	288	if(allData[ik+13][iHt] > 0 && allData[13][iHt]>0)
	289	GetRawsData(shift+ik+24+1)->
	290	Fill(allData[ik+13][iHt]-allData[13][iHt]);
	291	//led -cfd
	292
	293	if(allData[ik+13][iHt] > 0 && allData[ik+1][iHt] >0 )
	294	GetRawsData(shift+ik+48+1)->
	295	Fill(allData[ik+13][iHt]-allData[ik+1][iHt]);
	296	//qtc
	297	if(allData[2ik+25][iHt] > 0 && allData[2ik+26][iHt] > 0)
	298	GetRawsData(shift+ik+72+1)->
	299	Fill(allData[2ik+25][iHt]-allData[2ik+26][iHt]);
	300
5ed41460	301
1d7681da	302	if(type == 8 && allData[ik+1][iHt]>0 )
	303	GetRawsData(205)->Fill(ik,allData[ik+1][iHt]-allData[1][0]);
	304	if(type == 8 && allData[ik+13][iHt]>0 )
	305	GetRawsData(206)->Fill(ik,allData[ik+13][iHt]-allData[13][0]);
	306	if(type == 8 && (allData[2ik+25][iHt]>0 && allData[2ik+26][iHt]>0) )
	307	GetRawsData(207)->Fill(ik,allData[2ik+25][iHt]-allData[2ik+26][iHt]);
04236e67	308	}
86c020af	309	}
86c020af	310	for (Int_t ik = 12; ik<24; ik++) {
86c020af	311	for (Int_t iHt=0; iHt<5; iHt++) {
1d7681da	312	if(allData[ik+45][iHt]>0)
	313	//cfd
	314	GetRawsData(shift+ik+1)->
	315	Fill(allData[ik+45][iHt]-allData[57][0]);
	316	//qtc
	317	if(allData[2ik+57][iHt]>0 && allData[2ik+58][iHt]>0)
	318	GetRawsData(shift+ik+72+1)->
	319	Fill(allData[2ik+57][iHt]-allData[2ik+58][iHt]);
	320	//led
	321	if(allData[ik+57][iHt] > 0 )
	322	GetRawsData(shift+ik+24+1)->
	323	Fill(allData[ik+57][iHt]-allData[69][iHt]);
	324	//led-cfd
	325	if(allData[ik+57][iHt] > 0 &&allData[ik+45][iHt]>0)
	326	GetRawsData(shift+ik+48+1)->
	327	Fill(allData[ik+57][iHt]-allData[ik+45][iHt]);
	328
	329	if(type == 8 && allData[ik+45][iHt]>0 )
	330	GetRawsData(205)->Fill(ik,allData[ik+45][iHt]-allData[57][0]);
	331	if(type == 8 && allData[ik+57][iHt]>0 )
	332	GetRawsData(206)->Fill(ik,allData[ik+57][iHt]-allData[69][0]);
	333	if(type == 8 && (allData[2ik+57][iHt]>0 && allData[2ik+58][iHt]>0) )
	334	GetRawsData(207)->Fill(ik,allData[2ik+57][iHt]-allData[2ik+58][iHt]);
	335
	336
86c020af	337	}
86c020af	338	}
1d7681da	339	Int_t trChannel[6] = {49,50,51,52,55,56};
f6c2d5e2	340	if(type == 7)
5ed41460	341	{
1d7681da	342	for (Int_t iHt=0; iHt<6; iHt++) {
	343	for (Int_t itr=0; itr<6; itr++) {
	344	if(allData[trChannel[itr]][iHt]>0) fNumTriggers[itr]++;
	345	}
f6c2d5e2	346	}
5ed41460	347	}
	348	if(type == 8)
	349	{
f6c2d5e2	350	for (Int_t iHt=0; iHt<5; iHt++) {
1d7681da	351	for (Int_t itr=0; itr<6; itr++) {
	352	if(allData[trChannel[itr]][iHt]>0)
	353	{
	354
	355	GetRawsData(198+itr)->Fill(allData[trChannel[itr]][iHt]-allData[1][0]);
	356
	357	fNumTriggersCal[itr]++;
	358	}
	359	}
	360	if(allData[53][iHt]>0 && allData[54][iHt]>0)
	361	GetRawsData(204)->Fill(allData[53][iHt]-allData[54][iHt]);
f6c2d5e2	362	}
1d7681da	363	}
	364
	365
	366
86c020af	367	delete start;
86c020af	368	}
04236e67	369	}
1d7681da	370
1d7681da	371
04236e67	372
	373	//____________________________________________________________________________
	374	void AliT0QADataMakerRec::MakeRecPoints(TTree * clustersTree)
	375	{
	376	//fills QA histos for clusters
	377
446d6ec4	378	AliT0RecPoint* frecpoints= new AliT0RecPoint ();
04236e67	379	if (!frecpoints) {
	380	AliError("Reconstruct Fill ESD >> no recpoints found");
	381	return;
	382	}
	383	TBranch *brRec =clustersTree ->GetBranch("T0");
	384	if (brRec) {
	385	brRec->SetAddress(&frecpoints);
	386	}else{
	387	AliError(Form("EXEC Branch T0 rec not found "));
	388	return;
	389	}
	390
	391	brRec->GetEntry(0);
	392
	393	for ( Int_t i=0; i<24; i++) {
1d7681da	394	if(i<12)
	395	GetRecPointsData(i) -> Fill( frecpoints -> GetTime(i) - frecpoints -> GetTime(0));
	396	if(i>11)
	397	GetRecPointsData(i) -> Fill( frecpoints -> GetTime(i) - frecpoints -> GetTime(12));
	398	GetRecPointsData(i+24) -> Fill( frecpoints -> GetAmp(i));
	399	GetRecPointsData(i+48) -> Fill( frecpoints->AmpLED(i));
04236e67	400	}
1d7681da	401	GetRecPointsData(72) ->Fill(frecpoints->GetOnlineMean());
1d7681da	402	GetRecPointsData(73) ->Fill(frecpoints->GetMeanTime());
04236e67	403
	404	}
	405
	406	//____________________________________________________________________________
	407	void AliT0QADataMakerRec::MakeESDs(AliESDEvent * esd)
	408	{
	409	//fills QA histos for ESD
	410
	411	GetESDsData(0) -> Fill(esd->GetT0());
	412	GetESDsData(1)-> Fill(esd->GetT0zVertex());
	413
	414	}