[u/mrichter/AliRoot.git] / ITS / AliITSQADataMaker.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 Nov 2007
//  INFN Torino

// --- ROOT system ---
#include <TH2D.h>
#include <TBranch.h>
#include <TTree.h>
#include <TGaxis.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliITSQADataMaker.h"
#include "AliLog.h"
#include "AliQA.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"
#include "AliITSRawStreamSDD.h"
#include "AliITSRecPoint.h"
#include "AliITSgeomTGeo.h"
#include "AliRawReader.h"


ClassImp(AliITSQADataMaker)

//____________________________________________________________________________ 
AliITSQADataMaker::AliITSQADataMaker() : 
  AliQADataMaker(AliQA::GetDetName(AliQA::kITS), "SDD Quality Assurance Data Maker")
{ 
  fkOnline = kFALSE;
  fnSDDHistos = 0;
  // ctor 
}

//____________________________________________________________________________ 
AliITSQADataMaker::AliITSQADataMaker(Int_t ldc, Bool_t kMode) :
  AliQADataMaker(AliQA::GetDetName(AliQA::kITS), "SDD Quality Assurance Data Maker")
{
  //ctor used to discriminate OnLine-Offline analysis
  fkOnline = kMode;
  fLDC = ldc; 
  fnSDDHistos = 0;
}

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

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

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

//____________________________________________________________________________ 
void AliITSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList *list)
{
  // launch the QA checking
  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
  
  AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
}

//____________________________________________________________________________ 
void AliITSQADataMaker::EndOfDetectorCycle(const char * fgDataName)
{
  //eventually used for different  AliQAChecker::Instance()->Run
}

//____________________________________________________________________________ 
void AliITSQADataMaker::InitRaws()
{  
  // create SDD histo of raw
  
  Int_t lay, lad, det;
  
  if(fkOnline) {
    AliInfo("Book Online Histograms\n");
  }
  else {
    AliInfo("Book Offline Histograms\n ");
  }

  TH1F *h0 = new TH1F("ModPattern","Modules pattern",fgknSDDmodules,-0.5,259.5); 
  Add2RawsList(h0,0);
  fnSDDHistos++;
  TH1F *h1 = new TH1F("ModPatternL3","Modules pattern L3",14,0.5,14.5);  
  Add2RawsList(h1,1);
  fnSDDHistos++;
  TH1F *h2 = new TH1F("ModPatternL4","Modules pattern L4",22,0.5,22.5);  
  Add2RawsList(h2,2);
  fnSDDHistos++;

  Char_t *hname0[fgkLADDonLAY3] ; 
  TH1D *h3[fgkLADDonLAY3] ; 
  for(Int_t i=1; i<=fgkLADDonLAY3; i++) {
    hname0[i-1] = new Char_t[20];
    sprintf(hname0[i-1],"ModPattern_L3_%d",i);
    h3[i-1] = new TH1D(hname0[i-1],hname0[i-1],6,0.5,6.5);
    Add2RawsList(h3[i-1],i-1+3);
    fnSDDHistos++;
  }

  Char_t *hname1[fgkLADDonLAY4] ;
  TH1D *h4[fgkLADDonLAY4] ; 
  for(Int_t i=1; i<=fgkLADDonLAY4; i++) {
    hname1[i-1] = new Char_t[20];
    sprintf(hname1[i-1],"ModPattern_L4_%d",i);
    h4[i-1] = new TH1D(hname1[i-1],hname1[i-1],8,0.5,8.5);
    Add2RawsList(h4[i-1],i-1+17);  
    fnSDDHistos++;
  }

  if(fkOnline) {
	Int_t indexlast = 0;
    Char_t *hname2[fgknSDDmodules*2] ;
    TH1D *h5[fgknSDDmodules*2] ; 
    Int_t index1 = 0;
    for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
	  if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		for(Int_t iside=0; iside<fgknSide; iside++){
			//Int_t index1 = moduleSDD * 2 + iside;
			hname2[index1] = new Char_t[50];
			AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
                        sprintf(hname2[index1],"ProjYMap_L%d_%d_%d_%d",lay,lad,det,iside);

			h5[index1] = new TH1D(hname2[index1],hname2[index1],256,-0.5,255.5);
			Add2RawsList(h5[index1],index1+39);
			fnSDDHistos++;
			index1++;
			indexlast = index1+39;
		}
	  }
    }
    
    Char_t *hname3[fgknSDDmodules*8] ;
    TH1D *h6[fgknSDDmodules*8] ; 
	Int_t indextot = 0;
	Int_t indexlast1 = 0;
	for(Int_t htype=0; htype<4; htype++){
      for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
		if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		  for(Int_t iside=0; iside<fgknSide; iside++){
			//Int_t index1 = moduleSDD*2 + iside;
			hname3[indextot] = new Char_t[50]; 
			AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
			if(htype == 0) sprintf(hname3[indextot],"CountsVSAnode_L%d_%d_%d_%d",lay,lad,det,iside);
			if(htype == 1) sprintf(hname3[indextot],"ChargeVSAnode_L%d_%d_%d_%d",lay,lad,det,iside);
			if(htype == 2) sprintf(hname3[indextot],"CountsVSTbin_L%d_%d_%d_%d",lay,lad,det,iside);
			if(htype == 3) sprintf(hname3[indextot],"ChargeVSTbin_L%d_%d_%d_%d",lay,lad,det,iside);
			h6[indextot] = new TH1D(hname3[indextot],hname3[indextot],256,-0.5,255.5);
			Add2RawsList(h6[indextot],indexlast + indextot);
			fnSDDHistos++;
			indextot++;
			indexlast1 = indexlast + indextot;
		  }
		}
      }
    }
    
	Int_t indexlast2 = 0;
    Char_t *hname4[fgknSDDmodules*2];
    TH2D *h7[fgknSDDmodules*2] ;
	index1 = 0;
    for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
		if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		  for(Int_t iside=0; iside<fgknSide; iside++){
			//Int_t index1 = moduleSDD * 2 + iside;
			AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
			hname4[index1] = new Char_t[50]; 
			sprintf(hname4[index1],"Anode_vs_Charge_L%d_%d_%d_%d",lay,lad,det,iside);
			h7[index1] = new TH2D(hname4[index1],hname4[index1],fgknSDDmodules*2,-0.5,-0.5+fgknSDDmodules*2,256,0.5,256.5);
			Add2RawsList(h7[index1],indexlast1 + index1);
			fnSDDHistos++;
			index1++;
			indexlast2 = indexlast1 + index1;
		  }
		}
	}

    Char_t *hname[3][2 * fgknSDDmodules] ;
    index1 = 0;
    for(Int_t moduleSDD =0; moduleSDD<fgknSDDmodules; moduleSDD++){
	  if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		for(Int_t iside=0;iside<fgknSide;iside++){
			//Int_t index1 = moduleSDD * 2 + iside ;
			for(Int_t i=0; i<3; i++) hname[i][index1]= new Char_t[50];
			AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
			sprintf(hname[0][index1],"chargeMap_L%d_%d_%d_%d",lay,lad,det,iside);
			sprintf(hname[1][index1],"TotalCharge_L%d_%d_%d_%d",lay,lad,det,iside);
			sprintf(hname[2][index1],"hmonoDMap_L%d_%d_%d_%d",lay,lad,det,iside);
			fModuleChargeMap[index1] = new TH2D(hname[0][index1],hname[1][index1],256,-0.5,255.5,256,-0.5,255.5);
			Add2RawsList(fModuleChargeMap[index1],indexlast2 + index1);
			fnSDDHistos++;
			fmonoD[index1] = new TH1D(hname[2][index1],hname[2][index1],256,-0.5,255.5);
			index1++;
		}
	  }
	}
  }
  
  AliDebug(1,Form("%d SDD histograms booked\n",fnSDDHistos));
}

//____________________________________________________________________________
void AliITSQADataMaker::MakeRaws(AliRawReader* rawReader)
{ 
  //Fills Raw QA list of histos
    Int_t index=0;
    if(fkOnline) {
        for(Int_t moduleSDD =0; moduleSDD<fgknSDDmodules; moduleSDD++){
	  if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		for(Int_t iside=0;iside<fgknSide;iside++) {
			if(fnSDDHistos > 39+12 * 132 + index) GetRawsData(39+12 * 132 + index)->Reset();
			index++;
		}
	  }		
	}
    }
  AliDebug(1,"entering MakeRaws\n");
  rawReader->RequireHeader(kFALSE);               
  rawReader->SelectEvents(7);                    
  rawReader->SelectEquipment(17,fgkeqOffset+1,fgkeqOffset + fgkDDLidRange); 
  rawReader->Reset();                         
  AliITSRawStreamSDD s(rawReader); 
  Int_t lay, lad, det; 

  Int_t cnt = 0;
  while(s.Next()) {
    Int_t iddl = rawReader->GetDDLID() - fgkDDLIDshift;
    Int_t isddmod = s.GetModuleNumber(iddl,s.GetCarlosId());
    if(s.IsCompletedModule()) {
      AliDebug(1,Form("IsCompletedModule == KTRUE\n"));
      continue;
    } 
    Int_t coord1 = s.GetCoord1();
    Int_t coord2 = s.GetCoord2();
    Int_t signal = s.GetSignal();
    Int_t moduleSDD = isddmod - fgkmodoffset;
    if(moduleSDD < 0 || moduleSDD>fgknSDDmodules+fgkmodoffset) {
      AliDebug(1,Form( "Module SDD = %d, resetting it to 1 \n",moduleSDD));
      moduleSDD = 1;
    }
    GetRawsData(0)->Fill(moduleSDD); 
    
    AliITSgeomTGeo::GetModuleId(isddmod, lay, lad, det);
    //printf("modnumb %d, lay %d, lad %d, det %d \n",isddmod, lay, lad, det);
    Int_t ioffset = 3;
    Int_t iorder = 1;
    if(lay==4) { 
      ioffset += 14;
      iorder = 2;   
    } 
    GetRawsData(iorder)->Fill(lad);
    GetRawsData(ioffset+lad-1)->Fill(det); //-1 because ladder# starts from 1    
    
    Short_t iside = s.GetChannel();
	Int_t activeModule = moduleSDD;
	if(moduleSDD > 35) activeModule -= 48;
    Int_t index1 = activeModule * 2 + iside;
    
    if(index1<0){
      AliDebug(1,Form("Wrong index number %d - patched to 0\n",index1));
      index1 = 0;
    }
    
    if(fkOnline) {
      if(fnSDDHistos > 39+12 * 132 + index1) {
        GetRawsData(39+ 2 * 132 + index1)->Fill(coord1); 
        GetRawsData(39+ 4 * 132 + index1)->Fill(coord1,signal); 
        GetRawsData(39+ 6 * 132 + index1)->Fill(coord2);	
        GetRawsData(39+ 8 * 132 + index1)->Fill(coord2,signal); 
        GetRawsData(39+10 * 132 + index1)->Fill(signal,coord1);
        ((TH2D *)(GetRawsData(39+12 * 132 + index1)))->Fill(coord2, coord1, signal);
      }
    }
    cnt++;
    if(!(cnt%10000)) AliDebug(1,Form(" %d raw digits read",cnt));
  }
  AliDebug(1,Form("Event completed, %d raw digits read",cnt));
  
  if(fkOnline) {
    Int_t nBins = 256;
    for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
		if((moduleSDD >= 0 && moduleSDD < 36) || (moduleSDD >= 84 && moduleSDD < 180)) {
		  for(Int_t iside=0; iside<fgknSide; iside++){
			Int_t activeModule = moduleSDD;
			if(moduleSDD > 35) activeModule -= 48;
			Int_t index1 = activeModule * 2 + iside;
			if(fnSDDHistos > 39 + 2 * 132 + index1) {
	 		  fmonoD[index1] = ((TH2D *) (GetRawsData(39+12 * 132 + index1)))->ProjectionY();
			  for(Int_t bin=0; bin<nBins; bin++) GetRawsData(index1+39)->Fill(bin,fmonoD[index1]->GetBinContent(bin+1) );
		        }  
		  }
		}
    }
    for(Int_t i=0; i<fnSDDHistos; i++){
      Int_t entries = static_cast<Int_t>(GetRawsData(i)->GetEntries());
      if(entries != 0)
	AliDebug(1,Form("histo %d, name %s , entries %d ",i,GetRawsData(i)->GetName(),entries));
    }
    rawReader->RequireHeader(kTRUE); 
  }
}


//____________________________________________________________________________ 
void AliITSQADataMaker::InitRecPoints()
{
  // create SDD histo of RecPoints
  
  TH1F * h0 = new TH1F("Lay3TotCh","Layer 3 total charge",1000,-0.5, 499.5);
  Add2RecPointsList(h0, 0);
 
  TH1F * h1 = new TH1F("Lay4TotCh","Layer 4 total charge",1000,-0.5, 499.5);
  Add2RecPointsList(h1, 1);

    
  Char_t *hisnam[3];
  TH1F *h2[3]; 
  for(Int_t i=1; i<=3; i++){
    hisnam[i] = new Char_t[50];
    sprintf(hisnam[i],"Charge_L3_Strip%d",i);
    h2[i] = new TH1F(hisnam[i],hisnam[i],1000,-0.5, 499.5);
    Add2RecPointsList(h2[i],i+1);
  }
  
  Char_t *hisnam2[4] ;
  TH1F *h3[4]; 
  for(Int_t i=1; i<=4; i++){
    hisnam2[i] = new Char_t[50];
    sprintf(hisnam2[i],"Charge_L4_Strip%d",i);
    h3[i] = new TH1F(hisnam2[i],hisnam2[i],1000,-0.5, 499.5);
    Add2RecPointsList(h3[i],i+4);
  }
  
}


//____________________________________________________________________________ 
void AliITSQADataMaker::MakeRecPoints(TTree * clustersTree)
{
  // makes data from RecPoints
  /*  
  TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints");
  if (!branchRecP) { 
    AliError("can't get the branch with the ITS clusters !");
    return;
  }
  TObjArray * recpoints = new TObjArray(100) ;
  branchRecP->SetAddress(&recpoints);
  branchRecP->GetEntry(0);
  
  TIter next(recpoints);
  AliITSRecPoint * rp;
  while ( rp = dynamic_cast<AliITSRecPoint *>(next())  ) {
    if(rp->GetLayer() ==3) GetRecPointsData(0)->Fill( rp->GetQ()) ;
    else if(rp->GetLayer() ==4) GetRecPointsData(1)->Fill( rp->GetQ()) ;
  }
  recpoints->Delete();
  delete recpoints;
  */
}
Commit	Line	Data
1507771f	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	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	// *************************************************************
	19	// Checks the quality assurance
	20	// by comparing with reference data
	21	// contained in a DB
	22	// -------------------------------------------------------------
	23	// W. Ferrarese Nov 2007
	24	// INFN Torino
	25
	26	// --- ROOT system ---
	27	#include <TH2D.h>
	28	#include <TBranch.h>
	29	#include <TTree.h>
	30	#include <TGaxis.h>
	31
	32	// --- Standard library ---
	33
	34	// --- AliRoot header files ---
	35	#include "AliITSQADataMaker.h"
b7b9d122	36	#include "AliLog.h"
1507771f	37	#include "AliQA.h"
	38	#include "AliQAChecker.h"
	39	#include "AliRawReader.h"
	40	#include "AliITSRawStreamSDD.h"
	41	#include "AliITSRecPoint.h"
	42	#include "AliITSgeomTGeo.h"
	43	#include "AliRawReader.h"
	44
57614902	45
1507771f	46	ClassImp(AliITSQADataMaker)
	47
	48	//____________________________________________________________________________
	49	AliITSQADataMaker::AliITSQADataMaker() :
	50	AliQADataMaker(AliQA::GetDetName(AliQA::kITS), "SDD Quality Assurance Data Maker")
	51	{
57614902	52	fkOnline = kFALSE;
b5f2a6d3	53	fnSDDHistos = 0;
1507771f	54	// ctor
	55	}
	56
	57	//____________________________________________________________________________
57614902	58	AliITSQADataMaker::AliITSQADataMaker(Int_t ldc, Bool_t kMode) :
1507771f	59	AliQADataMaker(AliQA::GetDetName(AliQA::kITS), "SDD Quality Assurance Data Maker")
	60	{
	61	//ctor used to discriminate OnLine-Offline analysis
	62	fkOnline = kMode;
	63	fLDC = ldc;
b5f2a6d3	64	fnSDDHistos = 0;
1507771f	65	}
	66
	67	//____________________________________________________________________________
	68	AliITSQADataMaker::AliITSQADataMaker(const AliITSQADataMaker& qadm) :
	69	AliQADataMaker()
	70	{
	71	//copy ctor
	72	SetName((const char*)qadm.GetName()) ;
	73	SetTitle((const char*)qadm.GetTitle());
	74	}
	75
	76	//__________________________________________________________________
	77	AliITSQADataMaker& AliITSQADataMaker::operator = (const AliITSQADataMaker& qac )
	78	{
	79	// Equal operator.
	80	this->~AliITSQADataMaker();
	81	new(this) AliITSQADataMaker(qac);
	82	return *this;
	83	}
	84
	85	//____________________________________________________________________________
	86	void AliITSQADataMaker::StartOfDetectorCycle() const
	87	{
	88	//Detector specific actions at start of cycle
b7b9d122	89	AliDebug(1,"AliITSQADM::Start of ITS Cycle\n");
1507771f	90	}
	91
	92	//____________________________________________________________________________
	93	void AliITSQADataMaker::EndOfDetectorCycle(AliQA::TASKINDEX task, TList *list)
	94	{
	95	// launch the QA checking
b7b9d122	96	AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
b7b9d122	97
1507771f	98	AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
	99	}
	100
	101	//____________________________________________________________________________
	102	void AliITSQADataMaker::EndOfDetectorCycle(const char * fgDataName)
	103	{
	104	//eventually used for different AliQAChecker::Instance()->Run
	105	}
	106
	107	//____________________________________________________________________________
	108	void AliITSQADataMaker::InitRaws()
	109	{
	110	// create SDD histo of raw
	111
	112	Int_t lay, lad, det;
	113
b7b9d122	114	if(fkOnline) {
	115	AliInfo("Book Online Histograms\n");
	116	}
	117	else {
	118	AliInfo("Book Offline Histograms\n ");
	119	}
b5f2a6d3	120
1507771f	121	TH1F *h0 = new TH1F("ModPattern","Modules pattern",fgknSDDmodules,-0.5,259.5);
1507771f	122	Add2RawsList(h0,0);
b5f2a6d3	123	fnSDDHistos++;
1507771f	124	TH1F *h1 = new TH1F("ModPatternL3","Modules pattern L3",14,0.5,14.5);
1507771f	125	Add2RawsList(h1,1);
b5f2a6d3	126	fnSDDHistos++;
1507771f	127	TH1F *h2 = new TH1F("ModPatternL4","Modules pattern L4",22,0.5,22.5);
1507771f	128	Add2RawsList(h2,2);
b5f2a6d3	129	fnSDDHistos++;
1507771f	130
	131	Char_t *hname0[fgkLADDonLAY3] ;
	132	TH1D *h3[fgkLADDonLAY3] ;
	133	for(Int_t i=1; i<=fgkLADDonLAY3; i++) {
b7b9d122	134	hname0[i-1] = new Char_t[20];
	135	sprintf(hname0[i-1],"ModPattern_L3_%d",i);
	136	h3[i-1] = new TH1D(hname0[i-1],hname0[i-1],6,0.5,6.5);
	137	Add2RawsList(h3[i-1],i-1+3);
b5f2a6d3	138	fnSDDHistos++;
1507771f	139	}
	140
	141	Char_t *hname1[fgkLADDonLAY4] ;
	142	TH1D *h4[fgkLADDonLAY4] ;
	143	for(Int_t i=1; i<=fgkLADDonLAY4; i++) {
b7b9d122	144	hname1[i-1] = new Char_t[20];
	145	sprintf(hname1[i-1],"ModPattern_L4_%d",i);
	146	h4[i-1] = new TH1D(hname1[i-1],hname1[i-1],8,0.5,8.5);
	147	Add2RawsList(h4[i-1],i-1+17);
b5f2a6d3	148	fnSDDHistos++;
1507771f	149	}
1507771f	150
57614902	151	if(fkOnline) {
b5f2a6d3	152	Int_t indexlast = 0;
57614902	153	Char_t hname2[fgknSDDmodules2] ;
57614902	154	TH1D h5[fgknSDDmodules2] ;
b5f2a6d3	155	Int_t index1 = 0;
57614902	156	for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
b5f2a6d3	157	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	158	for(Int_t iside=0; iside<fgknSide; iside++){
	159	//Int_t index1 = moduleSDD * 2 + iside;
	160	hname2[index1] = new Char_t[50];
d886b9e7	161	AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
	162	sprintf(hname2[index1],"ProjYMap_L%d_%d_%d_%d",lay,lad,det,iside);
	163
b5f2a6d3	164	h5[index1] = new TH1D(hname2[index1],hname2[index1],256,-0.5,255.5);
	165	Add2RawsList(h5[index1],index1+39);
	166	fnSDDHistos++;
	167	index1++;
	168	indexlast = index1+39;
	169	}
	170	}
57614902	171	}
	172
	173	Char_t hname3[fgknSDDmodules8] ;
	174	TH1D h6[fgknSDDmodules8] ;
b5f2a6d3	175	Int_t indextot = 0;
	176	Int_t indexlast1 = 0;
	177	for(Int_t htype=0; htype<4; htype++){
57614902	178	for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
b5f2a6d3	179	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	180	for(Int_t iside=0; iside<fgknSide; iside++){
	181	//Int_t index1 = moduleSDD*2 + iside;
	182	hname3[indextot] = new Char_t[50];
	183	AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
	184	if(htype == 0) sprintf(hname3[indextot],"CountsVSAnode_L%d_%d_%d_%d",lay,lad,det,iside);
	185	if(htype == 1) sprintf(hname3[indextot],"ChargeVSAnode_L%d_%d_%d_%d",lay,lad,det,iside);
	186	if(htype == 2) sprintf(hname3[indextot],"CountsVSTbin_L%d_%d_%d_%d",lay,lad,det,iside);
	187	if(htype == 3) sprintf(hname3[indextot],"ChargeVSTbin_L%d_%d_%d_%d",lay,lad,det,iside);
	188	h6[indextot] = new TH1D(hname3[indextot],hname3[indextot],256,-0.5,255.5);
	189	Add2RawsList(h6[indextot],indexlast + indextot);
	190	fnSDDHistos++;
	191	indextot++;
	192	indexlast1 = indexlast + indextot;
	193	}
	194	}
57614902	195	}
	196	}
	197
b5f2a6d3	198	Int_t indexlast2 = 0;
57614902	199	Char_t hname4[fgknSDDmodules2];
57614902	200	TH2D h7[fgknSDDmodules2] ;
b5f2a6d3	201	index1 = 0;
57614902	202	for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
b5f2a6d3	203	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	204	for(Int_t iside=0; iside<fgknSide; iside++){
	205	//Int_t index1 = moduleSDD * 2 + iside;
	206	AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
	207	hname4[index1] = new Char_t[50];
	208	sprintf(hname4[index1],"Anode_vs_Charge_L%d_%d_%d_%d",lay,lad,det,iside);
	209	h7[index1] = new TH2D(hname4[index1],hname4[index1],fgknSDDmodules2,-0.5,-0.5+fgknSDDmodules2,256,0.5,256.5);
	210	Add2RawsList(h7[index1],indexlast1 + index1);
	211	fnSDDHistos++;
	212	index1++;
	213	indexlast2 = indexlast1 + index1;
	214	}
	215	}
	216	}
	217
	218	Char_t hname[3][2 fgknSDDmodules] ;
	219	index1 = 0;
	220	for(Int_t moduleSDD =0; moduleSDD<fgknSDDmodules; moduleSDD++){
	221	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	222	for(Int_t iside=0;iside<fgknSide;iside++){
	223	//Int_t index1 = moduleSDD * 2 + iside ;
	224	for(Int_t i=0; i<3; i++) hname[i][index1]= new Char_t[50];
d886b9e7	225	AliITSgeomTGeo::GetModuleId(moduleSDD+fgkmodoffset, lay, lad, det);
	226	sprintf(hname[0][index1],"chargeMap_L%d_%d_%d_%d",lay,lad,det,iside);
	227	sprintf(hname[1][index1],"TotalCharge_L%d_%d_%d_%d",lay,lad,det,iside);
	228	sprintf(hname[2][index1],"hmonoDMap_L%d_%d_%d_%d",lay,lad,det,iside);
b5f2a6d3	229	fModuleChargeMap[index1] = new TH2D(hname[0][index1],hname[1][index1],256,-0.5,255.5,256,-0.5,255.5);
	230	Add2RawsList(fModuleChargeMap[index1],indexlast2 + index1);
	231	fnSDDHistos++;
	232	fmonoD[index1] = new TH1D(hname[2][index1],hname[2][index1],256,-0.5,255.5);
	233	index1++;
	234	}
	235	}
	236	}
1507771f	237	}
b5f2a6d3	238
b5f2a6d3	239	AliDebug(1,Form("%d SDD histograms booked\n",fnSDDHistos));
1507771f	240	}
	241
	242	//____________________________________________________________________________
	243	void AliITSQADataMaker::MakeRaws(AliRawReader* rawReader)
	244	{
	245	//Fills Raw QA list of histos
b5f2a6d3	246	Int_t index=0;
	247	if(fkOnline) {
	248	for(Int_t moduleSDD =0; moduleSDD<fgknSDDmodules; moduleSDD++){
	249	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	250	for(Int_t iside=0;iside<fgknSide;iside++) {
	251	if(fnSDDHistos > 39+12 * 132 + index) GetRawsData(39+12 * 132 + index)->Reset();
	252	index++;
	253	}
	254	}
	255	}
	256	}
b7b9d122	257	AliDebug(1,"entering MakeRaws\n");
1507771f	258	rawReader->RequireHeader(kFALSE);
	259	rawReader->SelectEvents(7);
	260	rawReader->SelectEquipment(17,fgkeqOffset+1,fgkeqOffset + fgkDDLidRange);
	261	rawReader->Reset();
	262	AliITSRawStreamSDD s(rawReader);
	263	Int_t lay, lad, det;
	264
	265	Int_t cnt = 0;
b5f2a6d3	266	while(s.Next()) {
57614902	267	Int_t iddl = rawReader->GetDDLID() - fgkDDLIDshift;
1507771f	268	Int_t isddmod = s.GetModuleNumber(iddl,s.GetCarlosId());
57614902	269	if(s.IsCompletedModule()) {
	270	AliDebug(1,Form("IsCompletedModule == KTRUE\n"));
	271	continue;
	272	}
	273	Int_t coord1 = s.GetCoord1();
	274	Int_t coord2 = s.GetCoord2();
	275	Int_t signal = s.GetSignal();
	276	Int_t moduleSDD = isddmod - fgkmodoffset;
	277	if(moduleSDD < 0 \|\| moduleSDD>fgknSDDmodules+fgkmodoffset) {
	278	AliDebug(1,Form( "Module SDD = %d, resetting it to 1 \n",moduleSDD));
	279	moduleSDD = 1;
	280	}
57614902	281	GetRawsData(0)->Fill(moduleSDD);
	282
	283	AliITSgeomTGeo::GetModuleId(isddmod, lay, lad, det);
b5f2a6d3	284	//printf("modnumb %d, lay %d, lad %d, det %d \n",isddmod, lay, lad, det);
57614902	285	Int_t ioffset = 3;
	286	Int_t iorder = 1;
	287	if(lay==4) {
	288	ioffset += 14;
	289	iorder = 2;
	290	}
	291	GetRawsData(iorder)->Fill(lad);
	292	GetRawsData(ioffset+lad-1)->Fill(det); //-1 because ladder# starts from 1
	293
b5f2a6d3	294	Short_t iside = s.GetChannel();
	295	Int_t activeModule = moduleSDD;
	296	if(moduleSDD > 35) activeModule -= 48;
	297	Int_t index1 = activeModule * 2 + iside;
57614902	298
	299	if(index1<0){
	300	AliDebug(1,Form("Wrong index number %d - patched to 0\n",index1));
	301	index1 = 0;
	302	}
	303
	304	if(fkOnline) {
b5f2a6d3	305	if(fnSDDHistos > 39+12 * 132 + index1) {
	306	GetRawsData(39+ 2 * 132 + index1)->Fill(coord1);
	307	GetRawsData(39+ 4 * 132 + index1)->Fill(coord1,signal);
	308	GetRawsData(39+ 6 * 132 + index1)->Fill(coord2);
	309	GetRawsData(39+ 8 * 132 + index1)->Fill(coord2,signal);
	310	GetRawsData(39+10 * 132 + index1)->Fill(signal,coord1);
	311	((TH2D )(GetRawsData(39+12 132 + index1)))->Fill(coord2, coord1, signal);
	312	}
57614902	313	}
1507771f	314	cnt++;
b7b9d122	315	if(!(cnt%10000)) AliDebug(1,Form(" %d raw digits read",cnt));
1507771f	316	}
b7b9d122	317	AliDebug(1,Form("Event completed, %d raw digits read",cnt));
57614902	318
	319	if(fkOnline) {
	320	Int_t nBins = 256;
	321	for(Int_t moduleSDD=0; moduleSDD<fgknSDDmodules; moduleSDD++){
b5f2a6d3	322	if((moduleSDD >= 0 && moduleSDD < 36) \|\| (moduleSDD >= 84 && moduleSDD < 180)) {
	323	for(Int_t iside=0; iside<fgknSide; iside++){
	324	Int_t activeModule = moduleSDD;
	325	if(moduleSDD > 35) activeModule -= 48;
	326	Int_t index1 = activeModule * 2 + iside;
	327	if(fnSDDHistos > 39 + 2 * 132 + index1) {
	328	fmonoD[index1] = ((TH2D ) (GetRawsData(39+12 132 + index1)))->ProjectionY();
	329	for(Int_t bin=0; bin<nBins; bin++) GetRawsData(index1+39)->Fill(bin,fmonoD[index1]->GetBinContent(bin+1) );
	330	}
	331	}
	332	}
	333	}
	334	for(Int_t i=0; i<fnSDDHistos; i++){
57614902	335	Int_t entries = static_cast<Int_t>(GetRawsData(i)->GetEntries());
	336	if(entries != 0)
	337	AliDebug(1,Form("histo %d, name %s , entries %d ",i,GetRawsData(i)->GetName(),entries));
1507771f	338	}
57614902	339	rawReader->RequireHeader(kTRUE);
b7b9d122	340	}
1507771f	341	}
	342
	343
	344
	345	//____________________________________________________________________________
	346	void AliITSQADataMaker::InitRecPoints()
	347	{
	348	// create SDD histo of RecPoints
	349
	350	TH1F * h0 = new TH1F("Lay3TotCh","Layer 3 total charge",1000,-0.5, 499.5);
	351	Add2RecPointsList(h0, 0);
	352
	353	TH1F * h1 = new TH1F("Lay4TotCh","Layer 4 total charge",1000,-0.5, 499.5);
	354	Add2RecPointsList(h1, 1);
	355
	356
	357	Char_t *hisnam[3];
	358	TH1F *h2[3];
	359	for(Int_t i=1; i<=3; i++){
	360	hisnam[i] = new Char_t[50];
	361	sprintf(hisnam[i],"Charge_L3_Strip%d",i);
	362	h2[i] = new TH1F(hisnam[i],hisnam[i],1000,-0.5, 499.5);
	363	Add2RecPointsList(h2[i],i+1);
	364	}
	365
	366	Char_t *hisnam2[4] ;
	367	TH1F *h3[4];
	368	for(Int_t i=1; i<=4; i++){
	369	hisnam2[i] = new Char_t[50];
	370	sprintf(hisnam2[i],"Charge_L4_Strip%d",i);
	371	h3[i] = new TH1F(hisnam2[i],hisnam2[i],1000,-0.5, 499.5);
	372	Add2RecPointsList(h3[i],i+4);
	373	}
	374
	375	}
	376
	377
	378	//____________________________________________________________________________
	379	void AliITSQADataMaker::MakeRecPoints(TTree * clustersTree)
	380	{
	381	// makes data from RecPoints
b7b9d122	382	/*
1507771f	383	TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints");
	384	if (!branchRecP) {
	385	AliError("can't get the branch with the ITS clusters !");
	386	return;
	387	}
	388	TObjArray * recpoints = new TObjArray(100) ;
	389	branchRecP->SetAddress(&recpoints);
	390	branchRecP->GetEntry(0);
	391
	392	TIter next(recpoints);
	393	AliITSRecPoint * rp;
	394	while ( rp = dynamic_cast<AliITSRecPoint *>(next()) ) {
	395	if(rp->GetLayer() ==3) GetRecPointsData(0)->Fill( rp->GetQ()) ;
	396	else if(rp->GetLayer() ==4) GetRecPointsData(1)->Fill( rp->GetQ()) ;
	397	}
	398	recpoints->Delete();
	399	delete recpoints;
b7b9d122	400	*/
1507771f	401	}
b5f2a6d3	402
b5f2a6d3	403