[u/mrichter/AliRoot.git] / ITS / AliITSQASSDDataMakerRec.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, 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:$    */
//  *************************************************************
//  Checks the quality assurance 
//  by comparing with reference data
//  contained in a DB
//  -------------------------------------------------------------
//  W. Ferrarese + P. Cerello Feb 2008
//  INFN Torino

// --- ROOT system ---
#include <TH2D.h>
#include <TTree.h>
#include <TMath.h>
#include <TString.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliITSQASSDDataMakerRec.h"
#include "AliQADataMakerRec.h"
#include "AliLog.h"
#include "AliQA.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"
#include "AliRawReaderRoot.h"
#include "AliITSRawStreamSSD.h"
#include "AliITSgeomTGeo.h"
#include "AliRawEventHeaderBase.h"

ClassImp(AliITSQASSDDataMakerRec)

AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :
TObject(),
fAliITSQADataMakerRec(aliITSQADataMakerRec),
fSSDEvent(0),
fkOnline(kMode),
fLDC(ldc),
fSSDhRaws(0),
fSSDhRecs(0),
fRawsOffset(0),
fRecsOffset(0) {
  // Default constructor   
  //initilize the raw signal vs strip number histograms
  Int_t fLayer = 0,fLadder = 0, fModule = 0;
  TString fTitle; Int_t fHistCounter = 0;
  if(fkOnline) {
    for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
      AliITSgeomTGeo::GetModuleId(i,fLayer,fLadder,fModule);
      fTitle = "SSD_RawSignal_Layer"; fTitle += fLayer;
      fTitle += "_Ladder"; fTitle += fLadder;
      fTitle += "_Module"; fTitle += fModule; 
      fHistSSDRawSignalModule[fHistCounter] = new TH1D(fTitle.Data(),fTitle.Data(),1540,0,1540);
      fHistCounter += 1;
    }
  }//online flag
  else {
    for(Int_t i = 0; i < fgkSSDMODULES; i++) {
      fHistSSDRawSignalModule[i]=NULL;
    }
  }
}

//____________________________________________________________________________ 
AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :
TObject(),
fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
fSSDEvent(qadm.fSSDEvent),
fkOnline(qadm.fkOnline),
fLDC(qadm.fLDC),
fSSDhRaws(qadm.fSSDhRaws),
fSSDhRecs(qadm.fSSDhRecs),
fRawsOffset(qadm.fRawsOffset),
fRecsOffset(qadm.fRecsOffset) {
  //copy ctor 
  fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ; 
  fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
}

//__________________________________________________________________
AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )
{
  // Equal operator.
  this->~AliITSQASSDDataMakerRec();
  new(this) AliITSQASSDDataMakerRec(qac);
  return *this;
}

//__________________________________________________________________
AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() {
  // destructor
  for(Int_t i = 0; i < fgkSSDMODULES; i++) 
    if(fHistSSDRawSignalModule[i]) delete fHistSSDRawSignalModule[i];
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
{
  //Detector specific actions at start of cycle
  AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
  // launch the QA checking
  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
  
  //SSD occupancy plots
  if(fkOnline) {
    Int_t fLayer = 0, fLadder = 0;
    Int_t fOccPosition = 0; 
    for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
      if(fSSDEvent != 0)
	((TH2F *)fAliITSQADataMakerRec->GetRawsData(fLayer))->Scale(1./fSSDEvent);
      for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
	fOccPosition  = (fLayer == 5) ? fLadder : fLadder + fgkSSDLADDERSLAYER5;
	if(fSSDEvent != 0) {
	  //P-SIDE OCCUPANCY - scaling
	  fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder - 1)->Scale(1./fSSDEvent);

	  //N-SIDE OCCUPANCY - scaling
	  fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder)->Scale(1./fSSDEvent);
	}
      }      
    }
  }//online flag for SSD
  //AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerRec::InitRaws() {  

  // Initialization for RAW data - SSD -
  fRawsOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries();

  if(fkOnline) {
    AliInfo("Book Online Histograms for SSD\n");
  }
  else {
    AliInfo("Book Offline Histograms for SSD\n ");
  }
  AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fRawsOffset));
  TString fTitle = 0;
  //book online QA histos
  if(fkOnline) {
    //data size plots
    TH1F *hSSDDataSize = new TH1F("hSSDDataSize",";log(SSD data size) [Bytes];Events",100,3,8);
    fAliITSQADataMakerRec->Add2RawsList(hSSDDataSize, 0);
    TH1F *hSSDDataSizePercentage = new TH1F("hSSDDataSizePercentage",";SSD data size [%];Events",100,0,100);
    fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePercentage, 1);
    TH1F *hDDLId = new TH1F("hDDLId",";DDL id;Events",100,510,530);
    fAliITSQADataMakerRec->Add2RawsList(hDDLId, 2);
    TH1F *hSSDDataSizePerDDL = new TH1F("hSSDDataSizePerDDL",";DDL id;<SSD data size> [MB]",100,510,530);
    fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePerDDL, 3);
    TH1F *hSSDDataSizePerLDC = new TH1F("hSSDDataSizePerLDC",";LDC id;<SSD data size> [MB]",100,0,20);
    fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePerLDC, 4);

    //top level occupancy plots
    TH2D *hSSDOccupancyLayer5 = new TH2D("hSSDOccupancyLayer5",";N_{modules};N_{Ladders}",fgkSSDMODULESPERLADDERLAYER5,0,fgkSSDMODULESPERLADDERLAYER5,3*fgkSSDLADDERSLAYER5,0,fgkSSDLADDERSLAYER5);  
    Char_t fLabel[3];
    for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
      sprintf(fLabel,"%d",iBin);
      hSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
    }
    fAliITSQADataMakerRec->Add2RawsList(hSSDOccupancyLayer5, 5);
    TH2D *hSSDOccupancyLayer6 = new TH2D("hSSDOccupancyLayer6",";N_{modules};N_{Ladders}",fgkSSDMODULESPERLADDERLAYER6,0,fgkSSDMODULESPERLADDERLAYER6,3*fgkSSDLADDERSLAYER6,0,fgkSSDLADDERSLAYER6);
    for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
      sprintf(fLabel,"%d",iBin);
      hSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
    }
    fAliITSQADataMakerRec->Add2RawsList(hSSDOccupancyLayer6, 6);
    fRawsOffset = 7;
    
    TH1D *hOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
    for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
      for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
	//P-side occupancy plots
	fTitle = "SSD_Occupancy_Layer"; fTitle += iLayer;
	fTitle += "_Ladder"; fTitle += iLadder; fTitle += "_PSide";
	hOccupancyLadder[fSSDhRaws] = new TH1D(fTitle.Data(),fTitle.Data(),AliITSgeomTGeo::GetNDetectors(iLayer),0,AliITSgeomTGeo::GetNDetectors(iLayer));
	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitleColor(1);
	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitle("Module number");
	hOccupancyLadder[fSSDhRaws]->GetYaxis()->SetTitle("Occupancy [%]");
	fAliITSQADataMakerRec->Add2RawsList(hOccupancyLadder[fSSDhRaws], fRawsOffset + fSSDhRaws);	
	fSSDhRaws++;
	//N-side occupancy plots
	fTitle = "SSD_Occupancy_Layer"; fTitle += iLayer;
	fTitle += "_Ladder"; fTitle += iLadder; fTitle += "_NSide";
	hOccupancyLadder[fSSDhRaws] = new TH1D(fTitle.Data(),fTitle.Data(),AliITSgeomTGeo::GetNDetectors(iLayer),0,AliITSgeomTGeo::GetNDetectors(iLayer));
	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitleColor(1);
	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitle("Module number");
	hOccupancyLadder[fSSDhRaws]->GetYaxis()->SetTitle("Occupancy [%]");
	fAliITSQADataMakerRec->Add2RawsList(hOccupancyLadder[fSSDhRaws], fRawsOffset + fSSDhRaws);	
	fSSDhRaws++;
       }//ladder loop
    }//layer loop
  }//online flag
  AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhRaws));
  AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fRawsOffset+fSSDhRaws));  
}

//____________________________________________________________________________
void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) { 
  // Fill QA for RAW - SSD -
  Int_t fStripNumber;
  Int_t fHistPosition;
  Int_t fLayer = 0,fLadder = 0, fModule = 0;
  
  Double_t fSizePerDDL[fgkNumOfDDLs];
  Double_t fSizePerLDC[20];
  Double_t sumSSDDataSize = 0.0;
  Double_t eventSize = -1.0;

  if(fkOnline) {
    //reset the signal vs strip number histograms
    for(Int_t i = 0; i < fgkSSDMODULES; i++) 
      fHistSSDRawSignalModule[i]->Reset();
  
    rawReader->Select("ITSSSD",-1,-1);  
    rawReader->Reset(); //rawReader->NextEvent();   
    fSSDEvent += 1;
    AliITSRawStreamSSD fSSDStream(rawReader);    
    AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
    if(rootReader) {
      const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
      if(header)
	eventSize = header->GetEventSize();
    }
    while (fSSDStream.Next()) {
      if(fSSDStream.GetModuleID() < 0) continue;
      fSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize();
      fSizePerLDC[rawReader->GetLDCId()] = rawReader->GetDataSize();
      AliITSgeomTGeo::GetModuleId(fSSDStream.GetModuleID(),fLayer,fLadder,fModule);
      fStripNumber = (fSSDStream.GetSideFlag() == 0) ? fSSDStream.GetStrip() : fSSDStream.GetStrip() + fgkNumberOfPSideStrips;
      fHistPosition = (fLayer == 5) ? ((fLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + fModule - 1) : ((fLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + fModule + fgkSSDMODULESLAYER5 - 1);
      //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",fHistPosition,fLayer,fLadder,fModule));
      fHistSSDRawSignalModule[fHistPosition]->Fill(fStripNumber,fSSDStream.GetSignal());
    }//streamer loop   

    
    for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
      sumSSDDataSize += fSizePerDDL[i];
      if(fSizePerDDL[i] > 0) 
	(fAliITSQADataMakerRec->GetRawsData(2))->Fill(i+512);
      (fAliITSQADataMakerRec->GetRawsData(3))->Fill(i+512,fSizePerDDL[i]/1e+06);
    }
    for(Int_t i = 0; i < 20; i++) 
      (fAliITSQADataMakerRec->GetRawsData(4))->Fill(i,fSizePerLDC[i]/1e+06);
    if(sumSSDDataSize) 
      (fAliITSQADataMakerRec->GetRawsData(0))->Fill(TMath::Log10(sumSSDDataSize));
    if(eventSize)
      (fAliITSQADataMakerRec->GetRawsData(1))->Fill(100.*sumSSDDataSize/eventSize);
 
    //AliInfo(Form("EVENT: %d\n",fSSDEvent));
    Double_t occupancy = 0.0;
    Int_t lLadderLocationY = 0;
    
    Int_t fOccPosition = 0;
    for(Int_t i = 0; i < fgkSSDMODULES; i++) {
      AliITSgeomTGeo::GetModuleId(i+500,fLayer,fLadder,fModule); 
      fOccPosition  = (fLayer == 5) ? fLadder : fLadder + fgkSSDLADDERSLAYER5;
      //P-SIDE OCCUPANCY
      occupancy = GetSSDOccupancyRaws(fHistSSDRawSignalModule[i],0);
      fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder - 1)->Fill(fModule,occupancy);
      lLadderLocationY = 3*fLadder; // sideP=1 sideN=0
      ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fLayer))->SetBinContent(fModule,lLadderLocationY,occupancy);
      //N-SIDE OCCUPANCY
      occupancy = GetSSDOccupancyRaws(fHistSSDRawSignalModule[i],1);
      fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder)->Fill(fModule,occupancy);
      ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fLayer))->SetBinContent(fModule,lLadderLocationY-1,occupancy);
    }
  }//online flag for SSD
}

//____________________________________________________________________________ 
Double_t AliITSQASSDDataMakerRec::GetSSDOccupancyRaws(TH1 *lHisto, Int_t stripside) { 
  // bo: TDC >0 or # of sigmas wrt noise ?
  //stripside == 0 --> P-side
  //stripside == 1 --> N-side
  Int_t lNumFiredBins = 0;
  for(Int_t iBin = 1 + stripside*fgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips*(1 + stripside); iBin++){
    if (lHisto->GetBinContent(iBin))
      lNumFiredBins++; 
  }
  
  Double_t lOccupancy = (100.*lNumFiredBins)/lHisto->GetNbinsX(); // percentage
  //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
  
  return lOccupancy;
}


//____________________________________________________________________________ 
void AliITSQASSDDataMakerRec::InitRecPoints()
{
  // Initialization for RECPOINTS - SSD -
  fRecsOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();

// custom code here
//fSSDhRecs must be incremented by one unit every time a histogram is ADDED to the QA List

  AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhRecs));
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerRec::MakeRecPoints(TTree * /*clustersTree*/)
{
  // Fill QA for recpoints - SSD -
}
Commit	Line	Data
8c823e5a	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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	**************************************************************************/
f91768e0	15	/* $Id:$ */
8c823e5a	16	// *************************************************************
	17	// Checks the quality assurance
	18	// by comparing with reference data
	19	// contained in a DB
	20	// -------------------------------------------------------------
	21	// W. Ferrarese + P. Cerello Feb 2008
	22	// INFN Torino
	23
	24	// --- ROOT system ---
	25	#include <TH2D.h>
	26	#include <TTree.h>
f91768e0	27	#include <TMath.h>
8c823e5a	28	#include <TString.h>
	29
	30	// --- Standard library ---
	31
	32	// --- AliRoot header files ---
	33	#include "AliITSQASSDDataMakerRec.h"
f91768e0	34	#include "AliQADataMakerRec.h"
8c823e5a	35	#include "AliLog.h"
	36	#include "AliQA.h"
	37	#include "AliQAChecker.h"
	38	#include "AliRawReader.h"
f91768e0	39	#include "AliRawReaderRoot.h"
8c823e5a	40	#include "AliITSRawStreamSSD.h"
8c823e5a	41	#include "AliITSgeomTGeo.h"
f91768e0	42	#include "AliRawEventHeaderBase.h"
8c823e5a	43
	44	ClassImp(AliITSQASSDDataMakerRec)
	45
8c823e5a	46	AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :
	47	TObject(),
	48	fAliITSQADataMakerRec(aliITSQADataMakerRec),
f91768e0	49	fSSDEvent(0),
8c823e5a	50	fkOnline(kMode),
	51	fLDC(ldc),
	52	fSSDhRaws(0),
	53	fSSDhRecs(0),
	54	fRawsOffset(0),
f91768e0	55	fRecsOffset(0) {
f91768e0	56	// Default constructor
8c823e5a	57	//initilize the raw signal vs strip number histograms
	58	Int_t fLayer = 0,fLadder = 0, fModule = 0;
	59	TString fTitle; Int_t fHistCounter = 0;
f91768e0	60	if(fkOnline) {
	61	for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
	62	AliITSgeomTGeo::GetModuleId(i,fLayer,fLadder,fModule);
	63	fTitle = "SSD_RawSignal_Layer"; fTitle += fLayer;
	64	fTitle += "_Ladder"; fTitle += fLadder;
	65	fTitle += "_Module"; fTitle += fModule;
	66	fHistSSDRawSignalModule[fHistCounter] = new TH1D(fTitle.Data(),fTitle.Data(),1540,0,1540);
	67	fHistCounter += 1;
	68	}
	69	}//online flag
617e9eb7	70	else {
	71	for(Int_t i = 0; i < fgkSSDMODULES; i++) {
	72	fHistSSDRawSignalModule[i]=NULL;
	73	}
	74	}
8c823e5a	75	}
	76
	77	//____________________________________________________________________________
	78	AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :
	79	TObject(),
	80	fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
f91768e0	81	fSSDEvent(qadm.fSSDEvent),
8c823e5a	82	fkOnline(qadm.fkOnline),
	83	fLDC(qadm.fLDC),
	84	fSSDhRaws(qadm.fSSDhRaws),
	85	fSSDhRecs(qadm.fSSDhRecs),
	86	fRawsOffset(qadm.fRawsOffset),
f91768e0	87	fRecsOffset(qadm.fRecsOffset) {
8c823e5a	88	//copy ctor
	89	fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
	90	fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
	91	}
	92
	93	//__________________________________________________________________
	94	AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )
	95	{
	96	// Equal operator.
	97	this->~AliITSQASSDDataMakerRec();
	98	new(this) AliITSQASSDDataMakerRec(qac);
	99	return *this;
	100	}
	101
f91768e0	102	//__________________________________________________________________
	103	AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() {
	104	// destructor
	105	for(Int_t i = 0; i < fgkSSDMODULES; i++)
	106	if(fHistSSDRawSignalModule[i]) delete fHistSSDRawSignalModule[i];
	107	}
	108
8c823e5a	109	//____________________________________________________________________________
	110	void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
	111	{
	112	//Detector specific actions at start of cycle
	113	AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
	114	}
	115
	116	//____________________________________________________________________________
92a357bf	117	void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t /task/, TObjArray* /list/)
8c823e5a	118	{
	119	// launch the QA checking
	120	AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
	121
	122	//SSD occupancy plots
	123	if(fkOnline) {
f91768e0	124	Int_t fLayer = 0, fLadder = 0;
	125	Int_t fOccPosition = 0;
	126	for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
	127	if(fSSDEvent != 0)
	128	((TH2F *)fAliITSQADataMakerRec->GetRawsData(fLayer))->Scale(1./fSSDEvent);
	129	for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
	130	fOccPosition = (fLayer == 5) ? fLadder : fLadder + fgkSSDLADDERSLAYER5;
	131	if(fSSDEvent != 0) {
	132	//P-SIDE OCCUPANCY - scaling
	133	fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder - 1)->Scale(1./fSSDEvent);
	134
	135	//N-SIDE OCCUPANCY - scaling
	136	fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder)->Scale(1./fSSDEvent);
	137	}
	138	}
8c823e5a	139	}
	140	}//online flag for SSD
	141	//AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
	142	}
	143
	144	//____________________________________________________________________________
	145	void AliITSQASSDDataMakerRec::InitRaws() {
	146
	147	// Initialization for RAW data - SSD -
	148	fRawsOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries();
	149
8c823e5a	150	if(fkOnline) {
	151	AliInfo("Book Online Histograms for SSD\n");
	152	}
	153	else {
	154	AliInfo("Book Offline Histograms for SSD\n ");
	155	}
	156	AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fRawsOffset));
	157	TString fTitle = 0;
8c823e5a	158	//book online QA histos
8c823e5a	159	if(fkOnline) {
f91768e0	160	//data size plots
	161	TH1F *hSSDDataSize = new TH1F("hSSDDataSize",";log(SSD data size) [Bytes];Events",100,3,8);
	162	fAliITSQADataMakerRec->Add2RawsList(hSSDDataSize, 0);
	163	TH1F *hSSDDataSizePercentage = new TH1F("hSSDDataSizePercentage",";SSD data size [%];Events",100,0,100);
	164	fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePercentage, 1);
	165	TH1F *hDDLId = new TH1F("hDDLId",";DDL id;Events",100,510,530);
	166	fAliITSQADataMakerRec->Add2RawsList(hDDLId, 2);
	167	TH1F *hSSDDataSizePerDDL = new TH1F("hSSDDataSizePerDDL",";DDL id;<SSD data size> [MB]",100,510,530);
	168	fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePerDDL, 3);
	169	TH1F *hSSDDataSizePerLDC = new TH1F("hSSDDataSizePerLDC",";LDC id;<SSD data size> [MB]",100,0,20);
	170	fAliITSQADataMakerRec->Add2RawsList(hSSDDataSizePerLDC, 4);
	171
	172	//top level occupancy plots
	173	TH2D hSSDOccupancyLayer5 = new TH2D("hSSDOccupancyLayer5",";N_{modules};N_{Ladders}",fgkSSDMODULESPERLADDERLAYER5,0,fgkSSDMODULESPERLADDERLAYER5,3fgkSSDLADDERSLAYER5,0,fgkSSDLADDERSLAYER5);
	174	Char_t fLabel[3];
	175	for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
	176	sprintf(fLabel,"%d",iBin);
	177	hSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
	178	}
	179	fAliITSQADataMakerRec->Add2RawsList(hSSDOccupancyLayer5, 5);
	180	TH2D hSSDOccupancyLayer6 = new TH2D("hSSDOccupancyLayer6",";N_{modules};N_{Ladders}",fgkSSDMODULESPERLADDERLAYER6,0,fgkSSDMODULESPERLADDERLAYER6,3fgkSSDLADDERSLAYER6,0,fgkSSDLADDERSLAYER6);
	181	for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
	182	sprintf(fLabel,"%d",iBin);
	183	hSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
	184	}
	185	fAliITSQADataMakerRec->Add2RawsList(hSSDOccupancyLayer6, 6);
	186	fRawsOffset = 7;
	187
	188	TH1D hOccupancyLadder[2(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
8c823e5a	189	for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
8c823e5a	190	for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
f91768e0	191	//P-side occupancy plots
8c823e5a	192	fTitle = "SSD_Occupancy_Layer"; fTitle += iLayer;
f91768e0	193	fTitle += "_Ladder"; fTitle += iLadder; fTitle += "_PSide";
8c823e5a	194	hOccupancyLadder[fSSDhRaws] = new TH1D(fTitle.Data(),fTitle.Data(),AliITSgeomTGeo::GetNDetectors(iLayer),0,AliITSgeomTGeo::GetNDetectors(iLayer));
	195	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitleColor(1);
	196	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitle("Module number");
	197	hOccupancyLadder[fSSDhRaws]->GetYaxis()->SetTitle("Occupancy [%]");
8c823e5a	198	fAliITSQADataMakerRec->Add2RawsList(hOccupancyLadder[fSSDhRaws], fRawsOffset + fSSDhRaws);
8c823e5a	199	fSSDhRaws++;
f91768e0	200	//N-side occupancy plots
	201	fTitle = "SSD_Occupancy_Layer"; fTitle += iLayer;
	202	fTitle += "_Ladder"; fTitle += iLadder; fTitle += "_NSide";
	203	hOccupancyLadder[fSSDhRaws] = new TH1D(fTitle.Data(),fTitle.Data(),AliITSgeomTGeo::GetNDetectors(iLayer),0,AliITSgeomTGeo::GetNDetectors(iLayer));
	204	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitleColor(1);
	205	hOccupancyLadder[fSSDhRaws]->GetXaxis()->SetTitle("Module number");
	206	hOccupancyLadder[fSSDhRaws]->GetYaxis()->SetTitle("Occupancy [%]");
	207	fAliITSQADataMakerRec->Add2RawsList(hOccupancyLadder[fSSDhRaws], fRawsOffset + fSSDhRaws);
	208	fSSDhRaws++;
	209	}//ladder loop
8c823e5a	210	}//layer loop
	211	}//online flag
	212	AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhRaws));
f91768e0	213	AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fRawsOffset+fSSDhRaws));
8c823e5a	214	}
	215
	216	//____________________________________________________________________________
	217	void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) {
	218	// Fill QA for RAW - SSD -
	219	Int_t fStripNumber;
	220	Int_t fHistPosition;
	221	Int_t fLayer = 0,fLadder = 0, fModule = 0;
f91768e0	222
	223	Double_t fSizePerDDL[fgkNumOfDDLs];
	224	Double_t fSizePerLDC[20];
	225	Double_t sumSSDDataSize = 0.0;
	226	Double_t eventSize = -1.0;
8c823e5a	227
f91768e0	228	if(fkOnline) {
	229	//reset the signal vs strip number histograms
	230	for(Int_t i = 0; i < fgkSSDMODULES; i++)
	231	fHistSSDRawSignalModule[i]->Reset();
	232
	233	rawReader->Select("ITSSSD",-1,-1);
	234	rawReader->Reset(); //rawReader->NextEvent();
	235	fSSDEvent += 1;
	236	AliITSRawStreamSSD fSSDStream(rawReader);
	237	AliRawReaderRoot rootReader = (AliRawReaderRoot )rawReader;
	238	if(rootReader) {
	239	const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
	240	if(header)
	241	eventSize = header->GetEventSize();
	242	}
	243	while (fSSDStream.Next()) {
	244	if(fSSDStream.GetModuleID() < 0) continue;
	245	fSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize();
	246	fSizePerLDC[rawReader->GetLDCId()] = rawReader->GetDataSize();
	247	AliITSgeomTGeo::GetModuleId(fSSDStream.GetModuleID(),fLayer,fLadder,fModule);
	248	fStripNumber = (fSSDStream.GetSideFlag() == 0) ? fSSDStream.GetStrip() : fSSDStream.GetStrip() + fgkNumberOfPSideStrips;
	249	fHistPosition = (fLayer == 5) ? ((fLadder - 1)fgkSSDMODULESPERLADDERLAYER5 + fModule - 1) : ((fLadder - 1)fgkSSDMODULESPERLADDERLAYER6 + fModule + fgkSSDMODULESLAYER5 - 1);
	250	//AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",fHistPosition,fLayer,fLadder,fModule));
	251	fHistSSDRawSignalModule[fHistPosition]->Fill(fStripNumber,fSSDStream.GetSignal());
	252	}//streamer loop
	253
	254
	255	for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
	256	sumSSDDataSize += fSizePerDDL[i];
	257	if(fSizePerDDL[i] > 0)
	258	(fAliITSQADataMakerRec->GetRawsData(2))->Fill(i+512);
	259	(fAliITSQADataMakerRec->GetRawsData(3))->Fill(i+512,fSizePerDDL[i]/1e+06);
	260	}
	261	for(Int_t i = 0; i < 20; i++)
	262	(fAliITSQADataMakerRec->GetRawsData(4))->Fill(i,fSizePerLDC[i]/1e+06);
	263	if(sumSSDDataSize)
	264	(fAliITSQADataMakerRec->GetRawsData(0))->Fill(TMath::Log10(sumSSDDataSize));
	265	if(eventSize)
	266	(fAliITSQADataMakerRec->GetRawsData(1))->Fill(100.*sumSSDDataSize/eventSize);
	267
	268	//AliInfo(Form("EVENT: %d\n",fSSDEvent));
	269	Double_t occupancy = 0.0;
	270	Int_t lLadderLocationY = 0;
	271
	272	Int_t fOccPosition = 0;
	273	for(Int_t i = 0; i < fgkSSDMODULES; i++) {
	274	AliITSgeomTGeo::GetModuleId(i+500,fLayer,fLadder,fModule);
	275	fOccPosition = (fLayer == 5) ? fLadder : fLadder + fgkSSDLADDERSLAYER5;
	276	//P-SIDE OCCUPANCY
	277	occupancy = GetSSDOccupancyRaws(fHistSSDRawSignalModule[i],0);
	278	fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder - 1)->Fill(fModule,occupancy);
	279	lLadderLocationY = 3*fLadder; // sideP=1 sideN=0
	280	((TH2D *)fAliITSQADataMakerRec->GetRawsData(fLayer))->SetBinContent(fModule,lLadderLocationY,occupancy);
	281	//N-SIDE OCCUPANCY
	282	occupancy = GetSSDOccupancyRaws(fHistSSDRawSignalModule[i],1);
	283	fAliITSQADataMakerRec->GetRawsData(fRawsOffset -1 + 2*fLadder)->Fill(fModule,occupancy);
	284	((TH2D *)fAliITSQADataMakerRec->GetRawsData(fLayer))->SetBinContent(fModule,lLadderLocationY-1,occupancy);
	285	}
	286	}//online flag for SSD
8c823e5a	287	}
	288
	289	//____________________________________________________________________________
f91768e0	290	Double_t AliITSQASSDDataMakerRec::GetSSDOccupancyRaws(TH1 *lHisto, Int_t stripside) {
8c823e5a	291	// bo: TDC >0 or # of sigmas wrt noise ?
f91768e0	292	//stripside == 0 --> P-side
f91768e0	293	//stripside == 1 --> N-side
8c823e5a	294	Int_t lNumFiredBins = 0;
f91768e0	295	for(Int_t iBin = 1 + stripsidefgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips(1 + stripside); iBin++){
8c823e5a	296	if (lHisto->GetBinContent(iBin))
	297	lNumFiredBins++;
	298	}
f91768e0	299
8c823e5a	300	Double_t lOccupancy = (100.*lNumFiredBins)/lHisto->GetNbinsX(); // percentage
8c823e5a	301	//AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
	302
	303	return lOccupancy;
	304	}
	305
	306
	307	//____________________________________________________________________________
	308	void AliITSQASSDDataMakerRec::InitRecPoints()
	309	{
	310	// Initialization for RECPOINTS - SSD -
	311	fRecsOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();
	312
	313	// custom code here
	314	//fSSDhRecs must be incremented by one unit every time a histogram is ADDED to the QA List
	315
	316	AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhRecs));
	317	}
	318
	319	//____________________________________________________________________________
	320	void AliITSQASSDDataMakerRec::MakeRecPoints(TTree * /clustersTree/)
	321	{
	322	// Fill QA for recpoints - SSD -
	323	}
	324