-/**************************************************************************
- * 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 -
-}
-
+/**************************************************************************\r
+ * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *\r
+ * *\r
+ * Author: The ALICE Off-line Project. *\r
+ * Contributors are mentioned in the code where appropriate. *\r
+ * *\r
+ * Permission to use, copy, modify and distribute this software and its *\r
+ * documentation strictly for non-commercial purposes is hereby granted *\r
+ * without fee, provided that the above copyright notice appears in all *\r
+ * copies and that both the copyright notice and this permission notice *\r
+ * appear in the supporting documentation. The authors make no claims *\r
+ * about the suitability of this software for any purpose. It is *\r
+ * provided "as is" without express or implied warranty. *\r
+ **************************************************************************/\r
+/* $Id$ */\r
+// *************************************************************\r
+// Checks the quality assurance \r
+// by comparing with reference data\r
+// contained in a DB\r
+// -------------------------------------------------------------\r
+// W. Ferrarese + P. Cerello Feb 2008\r
+// INFN Torino\r
+\r
+// --- ROOT system ---\r
+#include <TH2D.h>\r
+#include <TTree.h>\r
+#include <TMath.h>\r
+#include <TString.h>\r
+#include <TSystem.h>\r
+\r
+// --- Standard library ---\r
+\r
+// --- AliRoot header files ---\r
+#include "AliITSQASSDDataMakerRec.h"\r
+#include "AliQADataMakerRec.h"\r
+#include "AliLog.h"\r
+#include "AliQA.h"\r
+#include "AliQAChecker.h"\r
+#include "AliRawReader.h"\r
+#include "AliRawReaderRoot.h"\r
+#include "AliITSRawStreamSSD.h"\r
+#include "AliITSgeomTGeo.h"\r
+#include "AliRawEventHeaderBase.h"\r
+#include "AliITSRecPoint.h"\r
+#include "AliITSBadChannelsSSDv2.h"\r
+\r
+#include "AliCDBManager.h"\r
+#include "AliCDBEntry.h"\r
+\r
+ClassImp(AliITSQASSDDataMakerRec)\r
+\r
+AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :\r
+TObject(),\r
+fAliITSQADataMakerRec(aliITSQADataMakerRec),\r
+fSSDEvent(0),\r
+fSSDEventPerCycle(0),\r
+fkOnline(kMode),\r
+fLDC(ldc),\r
+fSSDRawsOffset(0), fSSDRawsDAOffset(0),\r
+fSSDRawsCommonLevelOffset(0),\r
+fSSDhTask(0),\r
+fGenOffset(0),\r
+fCDBManager(0) {\r
+ // Default constructor \r
+ //initilize the raw signal vs strip number histograms\r
+ if(fkOnline) {\r
+ fCDBManager = AliCDBManager::Instance();\r
+ //fCDBManager->SetDefaultStorage("local://$ALICE_ROOT");\r
+ fCDBManager->SetDefaultStorage(gSystem->Getenv("AMORE_CDB_URI"));\r
+ Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER"));\r
+ if(!runNumber) \r
+ AliInfo("DATE_RUN_NUMBER not defined!!!\n");\r
+ \r
+ fCDBManager->SetRun(runNumber);\r
+ AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data");\r
+ if(!geomGRP) AliInfo("GRP geometry not found!!!\n");\r
+ \r
+ Int_t gLayer = 0,gLadder = 0, gModule = 0;\r
+ Int_t gHistCounter = 0;\r
+ TString gTitle; \r
+\r
+ for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {\r
+ AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);\r
+ gTitle = "SSD_RawSignal_Layer"; gTitle += gLayer;\r
+ gTitle += "_Ladder"; gTitle += gLadder;\r
+ gTitle += "_Module"; gTitle += gModule;\r
+ fHistSSDRawSignalModule[gHistCounter] = new TH1D(gTitle.Data(),gTitle.Data(),\r
+ 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);\r
+ gHistCounter += 1;\r
+ \r
+ for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)\r
+ fOccupancyMatrix[iModule-500][iStrip] = 0; \r
+ }//module loop\r
+ }//online flag\r
+ else {\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) \r
+ fHistSSDRawSignalModule[iModule]=NULL;\r
+ fCDBManager = NULL;\r
+ }\r
+}\r
+\r
+//____________________________________________________________________________ \r
+AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :\r
+TObject(),\r
+fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),\r
+fSSDEvent(qadm.fSSDEvent),\r
+fSSDEventPerCycle(qadm.fSSDEventPerCycle),\r
+fkOnline(qadm.fkOnline),\r
+fLDC(qadm.fLDC),\r
+fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset),\r
+fSSDRawsCommonLevelOffset(qadm.fSSDRawsCommonLevelOffset),\r
+fSSDhTask(qadm.fSSDhTask),\r
+fGenOffset(qadm.fGenOffset),\r
+fCDBManager(qadm.fCDBManager) {\r
+ //copy ctor \r
+ fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ; \r
+ fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());\r
+}\r
+\r
+//__________________________________________________________________\r
+AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )\r
+{\r
+ // Equal operator.\r
+ this->~AliITSQASSDDataMakerRec();\r
+ new(this) AliITSQASSDDataMakerRec(qac);\r
+ return *this;\r
+}\r
+\r
+//__________________________________________________________________\r
+AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() {\r
+ // destructor\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)\r
+ if(fHistSSDRawSignalModule[iModule]) delete fHistSSDRawSignalModule[iModule];\r
+ if(fCDBManager) delete fCDBManager;\r
+}\r
+\r
+//____________________________________________________________________________ \r
+void AliITSQASSDDataMakerRec::StartOfDetectorCycle()\r
+{\r
+ //Detector specific actions at start of cycle\r
+ AliDebug(1,"AliITSQADM::Start of SSD Cycle\n"); \r
+\r
+ //Data size per DDL\r
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->Reset();\r
+ //Data size per LDC\r
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->Reset();\r
+\r
+ //online part\r
+ if(fkOnline) {\r
+ for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {\r
+ for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)\r
+ fOccupancyMatrix[iModule-500][iStrip] = 0; \r
+ }//module loop\r
+\r
+ Int_t gHistPositionOccupancyPerLadder = 0;\r
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {\r
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);\r
+ \r
+ gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);\r
+ \r
+ //P-SIDE OCCUPANCY\r
+ fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();\r
+ //N-SIDE OCCUPANCY\r
+ fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();\r
+\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset();\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset();\r
+ }//module loop\r
+ }//online flag\r
+}\r
+\r
+//____________________________________________________________________________ \r
+void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list)\r
+{\r
+ // launch the QA checking\r
+ AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); \r
+ //Data size per DDL\r
+ for(Int_t i = 0; i < fgkNumOfDDLs; i++) {\r
+ Double_t gSizePerDDL = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->GetMean())/1e+06;\r
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->SetBinContent(i+2,gSizePerDDL);\r
+ }\r
+ \r
+ //Data size per LDC\r
+ for(Int_t i = 0; i < fgkNumOfLDCs; i++) {\r
+ Double_t gSizePerLDC = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->GetMean())/1e+06;\r
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->SetBinContent(i+6,gSizePerLDC);\r
+ }\r
+\r
+ //online part\r
+ if(fkOnline) {\r
+ //Output of the DA\r
+ MonitorOCDBObjects();\r
+\r
+ Int_t gHistPositionOccupancyPerModule = 0;\r
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;\r
+ //occupancy per module\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {\r
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);\r
+\r
+ gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);\r
+ for(Int_t iBins = 1; iBins < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBins++)\r
+ fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)->SetBinContent(iBins,fOccupancyMatrix[iModule][iBins-1]);\r
+ \r
+ if(fSSDEventPerCycle != 0)\r
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)))->Scale(100./fSSDEventPerCycle);\r
+ }//module loop\r
+\r
+ //occupancy per ladder\r
+ Int_t gHistPositionOccupancyPerLadder = 0;\r
+ Int_t lLadderLocationY = 0;\r
+ Double_t occupancy = 0.0;\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {\r
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);\r
+ \r
+ gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);\r
+ gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);\r
+ \r
+ //P-SIDE OCCUPANCY\r
+ occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0);\r
+ fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Fill(gModule,occupancy);\r
+ lLadderLocationY = 3*gLadder; // sideP=1 sideN=0 \r
+ if(gLayer == 5)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY,occupancy);\r
+ else if(gLayer == 6)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY,occupancy);\r
+\r
+ //N-SIDE OCCUPANCY\r
+ occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1); \r
+ fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Fill(gModule,occupancy);\r
+ if(gLayer == 5)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY-1,occupancy);\r
+ else if(gLayer == 6)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY-1,occupancy);\r
+ }//module loop\r
+ }//online flag for SSD\r
+\r
+ fSSDEventPerCycle = 0;\r
+ \r
+ AliQAChecker::Instance()->Run( AliQA::kITS , task, list);\r
+}\r
+\r
+//____________________________________________________________________________ \r
+void AliITSQASSDDataMakerRec::InitRaws() { \r
+ // Initialization for RAW data - SSD -\r
+ fGenOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries();\r
+\r
+ if(fkOnline) {\r
+ AliInfo("Book Online Histograms for SSD\n");\r
+ }\r
+ else {\r
+ AliInfo("Book Offline Histograms for SSD\n ");\r
+ }\r
+ AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fGenOffset));\r
+ TString gTitle = 0;\r
+ //book online-offline QA histos\r
+ TH1F *fHistSSDEventType = new TH1F("fHistSSDEventType",\r
+ ";Event type;Events",\r
+ 31,-1,30);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSize = new TH1F("fHistSSDDataSize",\r
+ ";log(SSD data size) [Bytes];Events",\r
+ 100,3,8);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSizePercentage = new TH1F("fHistSSDDataSizePercentage",\r
+ ";SSD data size [%];Events",\r
+ 100,0,100);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDDLId = new TH1F("fHistSSDDDLId",\r
+ ";DDL id;Events",20,510.5,530.5);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSizePerDDL = new TH1F("fHistSSDDataSizePerDDL",\r
+ ";DDL id;<SSD data size> [MB]",\r
+ 20,510.5,530.5);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSizeDDL[fgkNumOfDDLs];\r
+ for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) {\r
+ gTitle = "fHistSSDDataSizeDDL"; gTitle += i+511;\r
+ fHistSSDDataSizeDDL[i-1] = new TH1F(gTitle.Data(),\r
+ ";log(SSD data size) [Bytes];Events",\r
+ 100,1,8);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1], \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ }\r
+ \r
+ TH1F *fHistSSDLDCId = new TH1F("fHistSSDLDCId",";LDC id;Events",10,0.5,10.5);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSizePerLDC = new TH1F("fHistSSDDataSizePerLDC",\r
+ ";LDC id;<SSD data size> [MB]",\r
+ 20,0.5,20.5);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC, \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH1F *fHistSSDDataSizeLDC[fgkNumOfLDCs];\r
+ for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) {\r
+ gTitle = "fHistSSDDataSizeLDC"; \r
+ if(i == 1) gTitle += "082";\r
+ if(i == 2) gTitle += "086";\r
+ if(i == 3) gTitle += "085";\r
+ fHistSSDDataSizeLDC[i-1] = new TH1F(gTitle.Data(),\r
+ ";log(SSD data size) [Bytes];Events",\r
+ 100,1,8);\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1], \r
+ fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ }\r
+ fSSDRawsCommonLevelOffset = fSSDRawsOffset;\r
+\r
+ if(fkOnline) {\r
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;\r
+ //occupancy per SSD module\r
+ TH1D *fHistSSDOccupancyModule[fgkSSDMODULES]; \r
+ for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {\r
+ AliITSgeomTGeo::GetModuleId(i,gLayer,gLadder,gModule);\r
+ gTitle = "fHistSSD_Occupancy_Layer"; gTitle += gLayer;\r
+ gTitle += "_Ladder"; \r
+ if(gLayer == 5)\r
+ gTitle += 499+gLadder;\r
+ if(gLayer == 6)\r
+ gTitle += 599+gLadder;\r
+ gTitle += "_Module"; gTitle += gModule; \r
+ fHistSSDOccupancyModule[i-500] = new TH1D(gTitle.Data(),gTitle.Data(),\r
+ 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);\r
+ fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1);\r
+ fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}");\r
+ fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500], fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ }\r
+\r
+ //Occupancy per SSD ladder\r
+ Int_t occupancyCounter = 0;\r
+ TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];\r
+ for(Int_t iLayer = 5; iLayer < 7; iLayer++) {\r
+ for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {\r
+ //P-side occupancy plots\r
+ gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer;\r
+ gTitle += "_Ladder"; \r
+ if(iLayer == 5)\r
+ gTitle += 499+iLadder;\r
+ if(iLayer == 6)\r
+ gTitle += 599+iLadder;\r
+ gTitle += "_PSide";\r
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),\r
+ gTitle.Data(),\r
+ AliITSgeomTGeo::GetNDetectors(iLayer),\r
+ 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], \r
+ fGenOffset+fSSDRawsOffset);\r
+ occupancyCounter += 1; fSSDRawsOffset += 1;\r
+ //N-side occupancy plots\r
+ gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer;\r
+ gTitle += "_Ladder"; \r
+ if(iLayer == 5)\r
+ gTitle += 499+iLadder;\r
+ if(iLayer == 6)\r
+ gTitle += 599+iLadder;\r
+ gTitle += "_NSide";\r
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),\r
+ gTitle.Data(),\r
+ AliITSgeomTGeo::GetNDetectors(iLayer),\r
+ 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");\r
+ fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], \r
+ fGenOffset+fSSDRawsOffset);\r
+ occupancyCounter += 1; fSSDRawsOffset += 1;\r
+ }//ladder loop\r
+ }//layer loop\r
+\r
+ //top level occupancy plots\r
+ TH2D *fHistSSDOccupancyLayer5 = new TH2D("fHistSSDOccupancyLayer5",\r
+ ";N_{modules};N_{Ladders}",\r
+ fgkSSDMODULESPERLADDERLAYER5,\r
+ 0,fgkSSDMODULESPERLADDERLAYER5,\r
+ 3*fgkSSDLADDERSLAYER5,\r
+ 0,fgkSSDLADDERSLAYER5); \r
+ Char_t fLabel[3];\r
+ for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){\r
+ sprintf(fLabel,"%d",iBin);\r
+ fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);\r
+ }\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+ TH2D *fHistSSDOccupancyLayer6 = new TH2D("fHistSSDOccupancyLayer6",\r
+ ";N_{modules};N_{Ladders}",\r
+ fgkSSDMODULESPERLADDERLAYER6,\r
+ 0,fgkSSDMODULESPERLADDERLAYER6,\r
+ 3*fgkSSDLADDERSLAYER6,\r
+ 0,fgkSSDLADDERSLAYER6);\r
+ for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){\r
+ sprintf(fLabel,"%d",iBin);\r
+ fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);\r
+ }\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1;\r
+\r
+ //Output of the DA\r
+ TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5",\r
+ "Layer 5;N_{module};N_{ladder}",\r
+ 22,1,23,\r
+ 34,500,534);\r
+ fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);\r
+ fHistPSideBadChannelMapLayer5->SetStats(kFALSE);\r
+ fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);\r
+ fHistPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);\r
+ fHistPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);\r
+ fHistPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);\r
+ fHistPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);\r
+ fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);\r
+ fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;\r
+\r
+ TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5",\r
+ "Layer 5;N_{module};N_{ladder}",\r
+ 22,1,23,\r
+ 34,500,534);\r
+ fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);\r
+ fHistNSideBadChannelMapLayer5->SetStats(kFALSE);\r
+ fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);\r
+ fHistNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);\r
+ fHistNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);\r
+ fHistNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);\r
+ fHistNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);\r
+ fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);\r
+ fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;\r
+\r
+ TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6",\r
+ "Layer 6;N_{module};N_{ladder}",\r
+ 25,1,26,\r
+ 38,600,638);\r
+ fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);\r
+ fHistPSideBadChannelMapLayer6->SetStats(kFALSE);\r
+ fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);\r
+ fHistPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);\r
+ fHistPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);\r
+ fHistPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);\r
+ fHistPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);\r
+ fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);\r
+ fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;\r
+\r
+ TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6",\r
+ "Layer 6;N_{module};N_{ladder}",\r
+ 25,1,26,\r
+ 38,600,638);\r
+ fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);\r
+ fHistNSideBadChannelMapLayer6->SetStats(kFALSE);\r
+ fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);\r
+ fHistNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);\r
+ fHistNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);\r
+ fHistNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);\r
+ fHistNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);\r
+ fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);\r
+ fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");\r
+ fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset);\r
+ fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;\r
+ }//online flag\r
+ fSSDhTask = fSSDRawsOffset;\r
+ AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask));\r
+ AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDhTask)); \r
+ AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDRawsOffset));\r
+}\r
+\r
+//____________________________________________________________________________\r
+void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) { \r
+ // Fill QA for RAW - SSD -\r
+ Int_t gStripNumber;\r
+ Int_t gHistPosition;\r
+ Int_t gLayer = 0,gLadder = 0, gModule = 0;\r
+ \r
+ Double_t gSizePerDDL[fgkNumOfDDLs] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};\r
+ Double_t gSizePerLDC[fgkNumOfLDCs] = {0.,0.,0.};\r
+ Double_t sumSSDDataSize = 0.0;\r
+ Double_t eventSize = -1.0;\r
+\r
+ if(fkOnline) {\r
+ //reset the signal vs strip number histograms\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)\r
+ fHistSSDRawSignalModule[iModule]->Reset();\r
+ }//online flag\r
+\r
+ rawReader->Select("ITSSSD",-1,-1); \r
+ rawReader->Reset(); //rawReader->NextEvent(); \r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset))->Fill(rawReader->GetType());\r
+ if(rawReader->GetType() == 7) {\r
+ fSSDEvent += 1;\r
+ fSSDEventPerCycle += 1;\r
+ }\r
+\r
+ AliITSRawStreamSSD gSSDStream(rawReader); \r
+ AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;\r
+ if(rootReader) {\r
+ const AliRawEventHeaderBase *header = rootReader->GetEventHeader();\r
+ if(header)\r
+ eventSize = header->GetEventSize();\r
+ }\r
+ while (gSSDStream.Next()) {\r
+ if(gSSDStream.GetModuleID() < 0) continue;\r
+ /*cout<<"DDL: "<<rawReader->GetDDLID()<<\r
+ " - LDC: "<<rawReader->GetLDCId()<<\r
+ " - Size: "<<rawReader->GetDataSize()<<\r
+ " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/\r
+ gSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize();\r
+ gSizePerLDC[rawReader->GetLDCId()-6] = rawReader->GetDataSize();\r
+ AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);\r
+ if(gSSDStream.GetStrip() < 0) continue;\r
+ gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;\r
+ gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);\r
+ //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));\r
+ if(fkOnline)\r
+ fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());\r
+ //fAliITSQADataMakerRec->GetRawsData(fGenOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());\r
+ }//streamer loop \r
+ \r
+ //event size calculation and filling info\r
+ for(Int_t i = 0; i < fgkNumOfDDLs; i++) {\r
+ sumSSDDataSize += gSizePerDDL[i];\r
+ if(gSizePerDDL[i] > 0) {\r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+3))->Fill(i+512);\r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->Fill(TMath::Log10(gSizePerDDL[i]));\r
+ }\r
+ //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4))->Fill(i+512,gSizePerDDL[i]/1e+06);\r
+ }\r
+ for(Int_t i = 0; i < fgkNumOfLDCs; i++) {\r
+ if(gSizePerLDC[i] > 0) {\r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+21))->Fill(i+6);\r
+ //LDC 082\r
+ if(i == 0)\r
+ gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9] + gSizePerDDL[10] +\r
+ gSizePerDDL[11] + gSizePerDDL[12] + gSizePerDDL[13];\r
+ //LDC 086\r
+ if(i == 1)\r
+ gSizePerLDC[i] = gSizePerDDL[3] + gSizePerDDL[4] + gSizePerDDL[5] +\r
+ gSizePerDDL[6] + gSizePerDDL[7];\r
+ //LDC 085\r
+ if(i == 2)\r
+ gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1] + gSizePerDDL[2] +\r
+ gSizePerDDL[14] + gSizePerDDL[15];\r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->Fill(TMath::Log10(gSizePerLDC[i]));\r
+ //cout<<"Event: "<<fSSDEventPerCycle<<" - LDC: "<<i+6<<\r
+ //" - Data size: "<<gSizePerLDC[i]<<endl;\r
+ }\r
+ //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22))->Fill(i+6,gSizePerLDC[i]/1e+06);\r
+ }\r
+ if(sumSSDDataSize) \r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+1))->Fill(TMath::Log10(sumSSDDataSize));\r
+ if(eventSize)\r
+ (fAliITSQADataMakerRec->GetRawsData(fGenOffset+2))->Fill(100.*sumSSDDataSize/eventSize);\r
+\r
+ //Occupancy calculation\r
+ if(fkOnline) {\r
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {\r
+ GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]);\r
+ //if(iModule == 156) { \r
+ //cout<<"========================================"<<endl;\r
+ //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule);\r
+ /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) {\r
+ if((iBin >= 750)&&(iBin <= 780))\r
+ cout<<"Event: "<<fSSDEventPerCycle<<" - Ladder: "<<gLadder+499<<\r
+ " - Module: "<<gModule<<" - Strip: "<<iBin<<\r
+ " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl;\r
+ }*///strip loop --> to be removed\r
+ //}//module cut --> to be removed\r
+ }//module loop\r
+ }//online flag for SSD\r
+}\r
+\r
+//____________________________________________________________________________ //\r
+void AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) { \r
+ //Increments the entries in the occupancy matrix based \r
+ //on whether the signal for each strip is larger than the cutoff\r
+ //Currently the cutoff is at 0 which means that if ZS\r
+ //works, whatever comes from the FEROM is considered as "signal"\r
+ //Double_t cutoff = 0.0;\r
+ TString histname = lHisto->GetName();\r
+ //cout<<histname.Data()<<endl;\r
+ //if(histname.Contains("Layer5_Ladder8_Module3")) {\r
+ for(Int_t iBin = 1; iBin < lHisto->GetXaxis()->GetNbins(); iBin++) {\r
+ Double_t y = lHisto->GetBinContent(iBin);\r
+ if(y) {\r
+ occupancyMatrix[iBin-1] += 1;\r
+ }\r
+ //if((iBin >= 750)&&(iBin <= 780))\r
+ //cout<<"Strip: "<<iBin<<\r
+ //" - Signal: "<<y<<\r
+ //" - Occupancy: "<<occupancyMatrix[iBin-1]<<endl;\r
+ \r
+ }\r
+ //}\r
+}\r
+\r
+//____________________________________________________________________________ \r
+Double_t AliITSQASSDDataMakerRec::GetOccupancyModule(TH1 *lHisto, Int_t stripside) { \r
+ // bo: TDC >0 or # of sigmas wrt noise ?\r
+ //stripside == 0 --> P-side\r
+ //stripside == 1 --> N-side\r
+ Int_t lNumFiredBins = 0;\r
+ TString histname = lHisto->GetName();\r
+ for(Int_t iBin = 1 + stripside*fgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips*(1 + stripside); iBin++){\r
+ /*if(histname.Contains("Layer5_Ladder507_Module3")) {\r
+ cout<<lHisto->GetName()<<\r
+ " - Strip: "<<iBin<<\r
+ " - Bin content: "<<lHisto->GetBinContent(iBin)<<endl;\r
+ }*/\r
+ if (lHisto->GetBinContent(iBin) > 0)\r
+ lNumFiredBins++; \r
+ }\r
+ \r
+ Double_t lOccupancy = (100.*lNumFiredBins)/fgkNumberOfPSideStrips; // percentage\r
+ \r
+ /*if(histname.Contains("Layer5_Ladder507_Module3"))\r
+ cout<<"Fired strips: "<<lNumFiredBins<<\r
+ " - Occupancy: "<<lOccupancy<<endl;*/\r
+ //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));\r
+ \r
+ return lOccupancy;\r
+}\r
+\r
+//____________________________________________________________________________\r
+void AliITSQASSDDataMakerRec::MonitorOCDBObjects() { \r
+ //Monitor in AMORE the output of the DA\r
+ //Currently only the bad channel list is monitored\r
+ //Todo: Noise - Pedestal\r
+ AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD");\r
+ if(!entryBadChannelsSSD) \r
+ AliError("OCDB entry for the bad channel list is not valid!"); \r
+ AliITSBadChannelsSSDv2 *badchannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject();\r
+ if(!badchannelsSSD)\r
+ AliError("Bad channel list object is not a valid AliITSBadChannelsSSD object!");\r
+\r
+ //_____________________________________________________________________________// \r
+ Int_t nBadPSideChannels = 0, nBadNSideChannels = 0;\r
+ Int_t layer = 0, ladder = 0, module = 0;\r
+ Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;\r
+ Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;\r
+ //_____________________________________________________________________________// \r
+\r
+ for(Int_t i = 0; i < fgkSSDMODULES; i++) {\r
+ AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module);\r
+ nBadPSideChannels = 0, nBadNSideChannels = 0;\r
+ nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;\r
+ nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;\r
+\r
+ Int_t badChannel = 0;\r
+ for(Int_t j = 0; j < fgkNumberOfPSideStrips; j++) {\r
+ badChannel = (Int_t)(badchannelsSSD->GetBadChannelP(i,j));\r
+ if(badChannel != 0) {\r
+ if(layer == 5)\r
+ nPSideChannelsLayer5 += 1;\r
+ if(layer == 6)\r
+ nPSideChannelsLayer6 += 1;\r
+ nBadPSideChannels += 1;\r
+ }//badchannel flag != 0\r
+ badChannel = (Int_t)(badchannelsSSD->GetBadChannelN(i,j));\r
+ if(badChannel != 0) {\r
+ if(layer == 5)\r
+ nNSideChannelsLayer5 += 1;\r
+ if(layer == 6)\r
+ nNSideChannelsLayer6 += 1;\r
+ nBadNSideChannels += 1;\r
+ }//badchannel flag != 0\r
+ }//loop over strips\r
+ if(layer == 5) {\r
+ if(nPSideChannelsLayer5 > 0)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,\r
+ 100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips);\r
+ else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,0.0001);\r
+ if(nNSideChannelsLayer5 > 0)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,\r
+ 100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips);\r
+ else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,0.0001);\r
+ }//layer 5 \r
+ if(layer == 6) {\r
+ if(nPSideChannelsLayer6 > 0)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,\r
+ 100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips);\r
+ else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,0.0001);\r
+ if(nNSideChannelsLayer6 > 0)\r
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,\r
+ 100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips);\r
+ else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,0.0001);\r
+ }//layer 6 \r
+ }//module loop\r
+}\r
+\r
+//____________________________________________________________________________ \r
+void AliITSQASSDDataMakerRec::InitRecPoints()\r
+{\r
+ // Initialization for RECPOINTS - SSD -\r
+ \r
+ fGenOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();\r
+ Int_t nModuleOffset = 500;\r
+ Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();\r
+\r
+ TH1F *fHistModuleIdLayer5 = new TH1F("fHistModuleIdLayer5",\r
+ "Module Id - Layer 5;Module Id;Entries",\r
+ fgkSSDMODULESLAYER5,\r
+ nModuleOffset - 0.5,\r
+ nITSTotalModules-fgkSSDMODULESLAYER6+0.5);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer5, \r
+ fGenOffset + 0);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistModuleIdLayer6 = new TH1F("fHistModuleIdLayer6",\r
+ "Module Id - Layer 6;Module Id;Entries",\r
+ fgkSSDMODULESLAYER6,\r
+ nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,\r
+ nITSTotalModules + 0.5);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer6, \r
+ fGenOffset + 1);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistClusterPerEventLayer5 = new TH1F("fHistClusterPerEventLayer5",\r
+ "N_{clusters} - Layer 5;N_{clusters};Entries;",\r
+ 100,0.1,5000);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer5,\r
+ fGenOffset + 2);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistClusterPerEventLayer6 = new TH1F("fHistClusterPerEventLayer6",\r
+ "N_{clusters} - Layer 6;N_{clusters};Entries;",\r
+ 100,0.1,5000);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer6,\r
+ fGenOffset + 3);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistLocalXLayer5 = new TH1F("fHistLocalXLayer5",\r
+ "Local x coord.- Layer 5;x [cm];Entries;",\r
+ 100,-4.,4.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer5,\r
+ fGenOffset + 4);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistLocalXLayer6 = new TH1F("fHistLocalXLayer6",\r
+ "Local x coord.- Layer 6;x [cm];Entries;",\r
+ 100,-4.,4.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer6, \r
+ fGenOffset + 5);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistLocalZLayer5 = new TH1F("fHistLocalZLayer5",\r
+ "Local z coord.- Layer 5;z [cm];Entries;",\r
+ 100,-4.,4.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer5, \r
+ fGenOffset + 6);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistLocalZLayer6 = new TH1F("fHistLocalZLayer6",\r
+ "Local z coord.- Layer 6;z [cm];Entries;",\r
+ 100,-4.,4.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer6, \r
+ fGenOffset + 7);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalXLayer5 = new TH1F("fHistGlobalXLayer5",\r
+ "Global x - Layer 5;x [cm];Entries;",\r
+ 100,-40.,40.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer5, \r
+ fGenOffset + 8);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalXLayer6 = new TH1F("fHistGlobalXLayer6",\r
+ "Global x - Layer 6;x [cm];Entries;",\r
+ 100,-45.,45.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer6, \r
+ fGenOffset + 9);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalYLayer5 = new TH1F("fHistGlobalYLayer5",\r
+ "Global y - Layer 5;y [cm];Entries;",\r
+ 100,-40.,40);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer5, \r
+ fGenOffset + 10);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalYLayer6 = new TH1F("fHistGlobalYLayer6",\r
+ "Global y - Layer 6;y [cm];Entries;",\r
+ 100,-45.,45.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer6, \r
+ fGenOffset + 11);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalZLayer5 = new TH1F("fHistGlobalZLayer5",\r
+ "Global z - Layer 5;z [cm];Entries;",\r
+ 100,-45.,45);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer5, \r
+ fGenOffset + 12);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistGlobalZLayer6 = new TH1F("fHistGlobalZLayer6",\r
+ "Global z - Layer 6;z [cm];Entries;",\r
+ 100,-55.,55.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer6, \r
+ fGenOffset + 13);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistPhiLayer5 = new TH1F("fHistPhiLayer5",\r
+ "#phi - Layer 5;#phi [rad];Entries;",\r
+ 100,-TMath::Pi(),TMath::Pi());\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer5, \r
+ fGenOffset + 14);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistPhiLayer6 = new TH1F("fHistPhiLayer6",\r
+ "#phi - Layer 6;#phi [rad];Entries;",\r
+ 100,-TMath::Pi(),TMath::Pi());\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer6, \r
+ fGenOffset + 15);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistThetaLayer5 = new TH1F("fHistThetaLayer5",\r
+ "#theta - Layer 5;#theta [rad];Entries;",\r
+ 100,-TMath::Pi(),TMath::Pi());\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer5, \r
+ fGenOffset + 16);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistThetaLayer6 = new TH1F("fHistThetaLayer6",\r
+ "#theta - Layer 6;#theta [rad];Entries;",\r
+ 100,-TMath::Pi(),TMath::Pi());\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer6, \r
+ fGenOffset + 17);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistRadiusLayer5 = new TH1F("fHistRadiusLayer5",\r
+ "r - Layer 5;r [cm];Entries;",\r
+ 100,35.,50.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer5, \r
+ fGenOffset + 18);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistRadiusLayer6 = new TH1F("fHistRadiusLayer6",\r
+ "r - Layer 6;r [cm];Entries;",\r
+ 100,35.,50.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer6, \r
+ fGenOffset + 19);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistClusterTypeLayer5 = new TH1F("fHistClusterTypeLayer5",\r
+ "CL type - Layer 5;Cluster type;Entries;",\r
+ 150,0,150);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer5, \r
+ fGenOffset + 20);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistClusterTypeLayer6 = new TH1F("fHistClusterTypeLayer6",\r
+ "CL type - Layer 6;Cluster type;Entries;",\r
+ 150,0,150);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer6, \r
+ fGenOffset + 21);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeRatioLayer5 = new TH1F("fHistChargeRatioLayer5",\r
+ "Charge ratio - Layer 5;q_{ratio};Entries;",\r
+ 100,-2.0,2.0);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer5, \r
+ fGenOffset + 22);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeRatioLayer6 = new TH1F("fHistChargeRatioLayer6",\r
+ "Charge ratio - Layer 6;q_{ratio};Entries;",\r
+ 100,-2.0,2.0);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer6, \r
+ fGenOffset + 23);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargekeVLayer5 = new TH1F("fHistChargekeVLayer5",\r
+ "Charge - Layer 5;q [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer5, \r
+ fGenOffset + 24);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargekeVLayer6 = new TH1F("fHistChargekeVLayer6",\r
+ "Charge - Layer 6;q [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer6, \r
+ fGenOffset + 25);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargePSideLayer5 = new TH1F("fHistChargePSideLayer5",\r
+ "Charge P- Layer 5;q_{P} [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer5,\r
+ fGenOffset + 26);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargePSideLayer6 = new TH1F("fHistChargePSideLayer6",\r
+ "Charge P- Layer 6;q_{P} [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer6,\r
+ fGenOffset + 27);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeNSideLayer5 = new TH1F("fHistChargeNSideLayer5",\r
+ "Charge N- Layer 5;q_{N} [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer5,\r
+ fGenOffset + 28);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeNSideLayer6 = new TH1F("fHistChargeNSideLayer6",\r
+ "Charge N- Layer 6;q_{N} [keV];Entries;",\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer6,\r
+ fGenOffset + 29);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeRatio2Layer5 = new TH1F("fHistChargeRatio2Layer5",\r
+ "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",\r
+ 100,0,2);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer5,\r
+ fGenOffset + 30);\r
+ fSSDhTask += 1;\r
+ TH1F *fHistChargeRatio2Layer6 = new TH1F("fHistChargeRatio2Layer6",\r
+ "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",\r
+ 100,0,2);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer6,\r
+ fGenOffset + 31);\r
+ fSSDhTask += 1;\r
+ TH2F *fHistChargePNSideLayer5 = new TH2F("fHistChargePNSideLayer5",\r
+ "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",\r
+ 100,0.,300.,\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer5,\r
+ fGenOffset + 32);\r
+ fSSDhTask += 1;\r
+ TH2F *fHistChargePNSideLayer6 = new TH2F("fHistChargePNSideLayer6",\r
+ "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",\r
+ 100,0.,300.,\r
+ 100,0.,300.);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer6,\r
+ fGenOffset + 33);\r
+ fSSDhTask += 1;\r
+ TH2F *fHistChargeMapLayer5 = new TH2F("fHistChargeMapLayer5",\r
+ "Charge map;N_{modules};N_{Ladders}",\r
+ fgkSSDMODULESPERLADDERLAYER5,\r
+ -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,\r
+ 3*fgkSSDLADDERSLAYER5,\r
+ -0.5,fgkSSDLADDERSLAYER5+0.5);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer5, \r
+ fGenOffset + 34);\r
+ fSSDhTask += 1;\r
+ TH2F *fHistChargeMapLayer6 = new TH2F("fHistChargeMapLayer6",\r
+ "Charge map;N_{modules};N_{Ladders}",\r
+ fgkSSDMODULESPERLADDERLAYER6,\r
+ -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,\r
+ 3*fgkSSDLADDERSLAYER6,\r
+ -0.5,fgkSSDLADDERSLAYER6+0.5);\r
+ fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer6, \r
+ fGenOffset + 35);\r
+ fSSDhTask += 1;\r
+\r
+ AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhTask));\r
+}\r
+\r
+//____________________________________________________________________________ \r
+void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree)\r
+{\r
+ // Fill QA for recpoints - SSD -\r
+\r
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;\r
+ Int_t lLadderLocationY = 0;\r
+ TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints");\r
+ if (!branchRecP) { \r
+ AliError("can't get the branch with the ITS clusters !");\r
+ return;\r
+ }\r
+ static TClonesArray statRecpoints("AliITSRecPoint");\r
+ TClonesArray *recpoints = &statRecpoints;\r
+ branchRecP->SetAddress(&recpoints);\r
+ Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;\r
+ Int_t npoints = 0; \r
+ Float_t cluglo[3]={0.,0.,0.}; \r
+ for(Int_t module = 0; module < clustersTree->GetEntries(); module++){\r
+ branchRecP->GetEvent(module);\r
+ npoints += recpoints->GetEntries();\r
+ AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);\r
+ lLadderLocationY = 3*gLadder;\r
+\r
+ for(Int_t j = 0;j < recpoints->GetEntries(); j++){\r
+ AliITSRecPoint *recp = (AliITSRecPoint*)recpoints->At(j); \r
+ Int_t layer = recp->GetLayer();\r
+ recp->GetGlobalXYZ(cluglo);\r
+ Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]); \r
+ Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);\r
+ Float_t theta = TMath::ATan2(radius,cluglo[2]);\r
+ Double_t chargeRatio = recp->GetChargeRatio();\r
+ Double_t clusterCharge = recp->GetQ();\r
+ Double_t chargePSide = clusterCharge*(1. + chargeRatio);\r
+ Double_t chargeNSide = clusterCharge*(1. - chargeRatio);\r
+ if(layer == 4) {\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 0)->Fill(module);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 4)->Fill(recp->GetDetLocalX());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 6)->Fill(recp->GetDetLocalZ());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 8)->Fill(cluglo[0]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 10)->Fill(cluglo[1]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 12)->Fill(cluglo[2]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 14)->Fill(phi);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 16)->Fill(theta);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 18)->Fill(radius);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 20)->Fill(recp->GetType());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 22)->Fill(recp->GetChargeRatio());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 24)->Fill(recp->GetQ());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 26)->Fill(chargePSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 28)->Fill(chargeNSide);\r
+ if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 30)->Fill(chargeNSide/chargePSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 32)->Fill(chargePSide,chargeNSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 34)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());\r
+ nClustersLayer5 += 1;\r
+ }//layer 5 histograms\r
+ if(layer == 5) {\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 1)->Fill(module);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 5)->Fill(recp->GetDetLocalX());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 7)->Fill(recp->GetDetLocalZ());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 9)->Fill(cluglo[0]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 11)->Fill(cluglo[1]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 13)->Fill(cluglo[2]);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 15)->Fill(phi);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 17)->Fill(theta);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 19)->Fill(radius);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 21)->Fill(recp->GetType());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 23)->Fill(recp->GetChargeRatio());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 25)->Fill(recp->GetQ());\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 27)->Fill(chargePSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 29)->Fill(chargeNSide);\r
+ if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 31)->Fill(chargeNSide/chargePSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 33)->Fill(chargePSide,chargeNSide);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 35)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());\r
+ nClustersLayer6 += 1;\r
+ }//layer 6 histograms\r
+ }//rec. points loop\r
+ }//module loop\r
+\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 2)->Fill(nClustersLayer5);\r
+ fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 3)->Fill(nClustersLayer6);\r
+\r
+ statRecpoints.Clear();\r
+}\r
+\r
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff