[u/mrichter/AliRoot.git] / TPC / AliTPCQADataMakerRec.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, 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: $ */

/*
  Based on AliPHOSQADataMaker
  Produces the data needed to calculate the quality assurance. 
  All data must be mergeable objects.
  P. Christiansen, Lund, January 2008
*/

/*
  Implementation:

  We have chosen to have the histograms as non-persistent meber to
  allow better debugging. In the copy constructor we then have to
  assign the pointers to the existing histograms in the copied
  list. This have been implemented but not tested.

  For the QA of the RAW data we use the class, AliTPCdataQA, from the
  existing TPC Calibration framework (which is more advanced than the
  standard QA framework) and extract the histograms at the end. This
  has been tested with zero-suppressed data. The Analyse method of the
  AliTPCdataQA class is called in the method, EndOfDetectorCycle, and
  there also: 1d histogram(s) are projected and added to the QA list.
*/

/*
  TODO:
  Sumw2 for RAW histogram(s)?
  RecPoints and ESD could have many more histograms
*/

#include "AliTPCQADataMakerRec.h"

// --- ROOT system ---
#include <TClonesArray.h>
#include <TString.h>
#include <TSystem.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliQAChecker.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliLog.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
#include "AliTPCClustersRow.h"
#include "AliTPCclusterMI.h"

ClassImp(AliTPCQADataMakerRec)

//____________________________________________________________________________ 
AliTPCQADataMakerRec::AliTPCQADataMakerRec() : 
  AliQADataMakerRec(AliQA::GetDetName(AliQA::kTPC), 
		    "TPC Rec Quality Assurance Data Maker"),
  fTPCdataQA(NULL)
{
  // ctor
  fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    fTPCdataQA[specie] = NULL ; 
  
  for(Int_t i = 0; i < 6; i++)
    fMapping[i] = 0;
}

//____________________________________________________________________________ 
AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
  AliQADataMakerRec(),
  fTPCdataQA(NULL)
{
  //copy ctor 
  // Does not copy the calibration object, instead InitRaws have to be
  // called again
  SetName((const char*)qadm.GetName()) ; 
  SetTitle((const char*)qadm.GetTitle()); 

  fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    fTPCdataQA[specie] = NULL ; 
  
  for(Int_t i = 0; i < 6; i++)
    fMapping[i] = 0;

  //
  // Associate class histogram objects to the copies in the list
  // Could also be done with the indexes
  //

}

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

//__________________________________________________________________
AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
{
  // Destructor
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    if ( fTPCdataQA[specie] != NULL )
      delete fTPCdataQA[specie] ; 
  delete[] fTPCdataQA; 

  for(Int_t i = 0; i < 6; i++) 
    delete fMapping[i];
}
 
//____________________________________________________________________________ 
void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
{
  //Detector specific actions at end of cycle
  
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    if ( !AliQA::Instance()->IsEventSpecieSet(specie) ) 
      continue ; 
    if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data

      fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
                           //         RAW data files with no TPC data

      SetEventSpecie(specie) ; 
      TH1F * histRawsOccupancy                 = (TH1F*)GetRawsData(kOccupancy) ;
      TH1F * histRawsOccupancyVsSector         = (TH1F*)GetRawsData(kOccupancyVsSector) ;
      TH1F * histRawsNClustersPerEventVsSector = (TH1F*)GetRawsData(kNClustersPerEventVsSector) ;
      TH1F * histRawsQVsSector                 = (TH1F*)GetRawsData(kQVsSector) ;
      TH1F * histRawsQmaxVsSector              = (TH1F*)GetRawsData(kQmaxVsSector) ;
      if ( !histRawsOccupancy ||
          !histRawsOccupancyVsSector ||
          !histRawsNClustersPerEventVsSector ||
          !histRawsQVsSector ||
          !histRawsQmaxVsSector) {
        AliError("Something very wrong here, corrupted memory ?????. Please check\n") ; 
        continue ; 
      }
        
      //Add2RawsList(fTPCdataQA, 0);
      // get the histograms and add them to the output
      // 31/8-08 Histogram is only added if the Calibration class 
      //         receives TPC data 
      const Int_t eventCounter = fTPCdataQA[specie]->GetEventCounter();
      if(eventCounter>0) { // some TPC data has been processed

        // Reset histograms and refill them 
        histRawsOccupancy->Reset();
        histRawsOccupancyVsSector->Reset();
        histRawsNClustersPerEventVsSector->Reset();
        histRawsQVsSector->Reset();
        histRawsQmaxVsSector->Reset();
      
        TH1F* hNorm72 = new TH1F("hNorm72", "histogram to normalize 72 sectors",
                                 72, 0, 72);
        hNorm72->Sumw2();
        TH1F* hNorm108 = new TH1F("hNorm108", "histogram to normalize 108 sectors (medium and long pads are split up)",
                                  108, 0, 108);
        hNorm108->Sumw2();

        for (Int_t iSec = 0; iSec < 72; iSec++) {
	
          AliTPCCalROC* occupancyROC = 
          fTPCdataQA[specie]->GetNoThreshold()->GetCalROC(iSec); 
          AliTPCCalROC* nclusterROC = 
          fTPCdataQA[specie]->GetNLocalMaxima()->GetCalROC(iSec); 
          AliTPCCalROC* qROC = 
          fTPCdataQA[specie]->GetMeanCharge()->GetCalROC(iSec); 
          AliTPCCalROC* qmaxROC = 
          fTPCdataQA[specie]->GetMaxCharge()->GetCalROC(iSec); 

          const Int_t nRows = occupancyROC->GetNrows(); 
          for (Int_t iRow = 0; iRow < nRows; iRow++) {

            Int_t helpSector = iSec;
            if(iRow>=64)
              helpSector += 36; // OROC (long pads)

            const Int_t nPads = occupancyROC->GetNPads(iRow); 
            for (Int_t iPad = 0; iPad < nPads; iPad++) {
	
              histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
              hNorm72->Fill(iSec);
              histRawsOccupancyVsSector
              ->Fill(iSec, occupancyROC->GetValue(iRow, iPad));

              const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
	    
              if(nClusters>0) {
	      
                histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
                hNorm108->Fill(helpSector, nClusters);
                histRawsQVsSector->Fill(helpSector, 
                                       nClusters*qROC->GetValue(iRow, iPad));
                histRawsQmaxVsSector->Fill(helpSector, 
                                          nClusters*qmaxROC->GetValue(iRow, iPad));
              }
            }
          }
        } // end loop over sectors
      
        // Normalize histograms
        histRawsOccupancyVsSector->Divide(hNorm72);
        histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
        histRawsQVsSector->Divide(hNorm108);
        histRawsQmaxVsSector->Divide(hNorm108);
        delete hNorm72;
        delete hNorm108;
      }
    }
  }
  AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;  
}

//____________________________________________________________________________ 
void AliTPCQADataMakerRec::InitESDs()
{
  //create ESDs histograms in ESDs subdir  
  TH1F * histESDclusters = 
    new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
	     160, 0, 160);
  histESDclusters->Sumw2();
  Add2ESDsList(histESDclusters, KClusters);

  TH1F * histESDratio = 
    new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
	     100, 0, 1);
  histESDratio->Sumw2();
  Add2ESDsList(histESDratio, kRatio);
  
  TH1F * histESDpt = 
    new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
	     50, 0, 5);
  histESDpt->Sumw2();
  Add2ESDsList(histESDpt, kPt);
}

//____________________________________________________________________________ 
void AliTPCQADataMakerRec::InitRaws()
{
  //
  // Adding the raw 
  //  

  // Modified: 7/7 - 2008
  // Laurent Aphecetche pointed out that the mapping was read from file
  // for each event, so now we read in the map here and set if for 
  // the raw data qa
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::Convert(specie));
    LoadMaps(); // Load Altro maps
    fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
    fTPCdataQA[specie]->SetRangeTime(100, 920); // set time bin interval 
//    Add2RawsList(fTPCdataQA, kTPCdataQA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
  }

  TH1F * histRawsOccupancy = 
    new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
	     100, 0, 1);
  histRawsOccupancy->Sumw2();
  Add2RawsList(histRawsOccupancy, kOccupancy);
  
  TH1F * histRawsOccupancyVsSector = 
    new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
	     72, 0, 72);
  histRawsOccupancyVsSector->Sumw2();
  Add2RawsList(histRawsOccupancyVsSector, kOccupancyVsSector);

  TH1F * histRawsNClustersPerEventVsSector = 
    new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
	     72, 0, 72);
  histRawsNClustersPerEventVsSector->Sumw2();
  Add2RawsList(histRawsNClustersPerEventVsSector, kNClustersPerEventVsSector);
  
  TH1F * histRawsQVsSector = 
    new TH1F("hRawsQVsSector", "<Q> vs sector (OROC med: 36-71, long: 72-107); Sector; <Q>",
	     108, 0, 108);
  histRawsQVsSector->Sumw2();
  Add2RawsList(histRawsQVsSector, kQVsSector);

  TH1F * histRawsQmaxVsSector = 
    new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector (OROC med: 36-71, long: 72-107); Sector; <Qmax>",
	     108, 0, 108);
  histRawsQmaxVsSector->Sumw2();
  Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector);
}

//____________________________________________________________________________ 
void AliTPCQADataMakerRec::InitRecPoints()
{
  TH1F * histRecPointsQmaxShort = 
    new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
	     100, 0, 300);
  histRecPointsQmaxShort->Sumw2();
  Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort);

  TH1F * histRecPointsQmaxMedium = 
    new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
	     100, 0, 300);
  histRecPointsQmaxMedium->Sumw2();
  Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium);

  TH1F * histRecPointsQmaxLong = 
    new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
	     100, 0, 300);
  histRecPointsQmaxLong->Sumw2();
  Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong);

  TH1F * histRecPointsQShort = 
    new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
	     100, 0, 2000);
  histRecPointsQShort->Sumw2();
  Add2RecPointsList(histRecPointsQShort, kQShort);

  TH1F * histRecPointsQMedium = 
    new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
	     100, 0, 2000);
  histRecPointsQMedium->Sumw2();
  Add2RecPointsList(histRecPointsQMedium, kQMedium);

  TH1F * histRecPointsQLong = 
    new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
	     100, 0, 2000);
  histRecPointsQLong->Sumw2();
  Add2RecPointsList(histRecPointsQLong, kQLong);

  TH1F * histRecPointsRow = 
    new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
	     159, 0, 159);
  histRecPointsRow->Sumw2();
  Add2RecPointsList(histRecPointsRow, kRow);
}

//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
  // make QA data from ESDs
  
  const Int_t nESDTracks = esd->GetNumberOfTracks();
  Int_t nTPCtracks = 0; 
  for(Int_t i = 0; i < nESDTracks; i++) {
    
    AliESDtrack * track = esd->GetTrack(i);
    
    if ((track->GetStatus() & AliESDtrack::kTPCrefit)==0)
      continue;
    
    nTPCtracks++;
    
    Int_t nTPCclusters         = track->GetTPCNcls();
    Int_t nTPCclustersFindable = track->GetTPCNclsF();
    if ( nTPCclustersFindable<=0) continue;
    GetESDsData(KClusters)->Fill(nTPCclusters);
    GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
    GetESDsData(kPt)->Fill(track->Pt()); 
  }
}

//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
  //
  // To make QA for the RAW data we use the TPC Calibration framework 
  // to handle the data and then in the end extract the data
  //
	rawReader->Reset() ; 
  fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);  
 }

//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
{
  AliTPCClustersRow *clrow = new AliTPCClustersRow();
  clrow->SetClass("AliTPCclusterMI");
  clrow->SetArray(0);
  clrow->GetArray()->ExpandCreateFast(10000);

  TBranch* branch = recTree->GetBranch("Segment");
  branch->SetAddress(&clrow);

  const Int_t nEntries = Int_t(recTree->GetEntries());
  for (Int_t i = 0; i < nEntries; i++) {
    
    branch->GetEntry(i);
    
    const Int_t nClusters = clrow->GetArray()->GetEntriesFast();
    for (Int_t icl=0; icl < nClusters; icl++){
      
      AliTPCclusterMI* cluster = 
	(AliTPCclusterMI*)clrow->GetArray()->At(icl);
      
      Float_t Qmax = cluster->GetMax();
      Float_t Q    = cluster->GetQ();
      Int_t   row  = cluster->GetRow();

      if(cluster->GetDetector()<36) { // IROC (short pads)

	GetRecPointsData(kQmaxShort)->Fill(Qmax);
	GetRecPointsData(kQShort)->Fill(Q);
      } else { // OROC (medium and long pads)
	row += 63;
	if(cluster->GetRow()<64) { // medium pads

	  GetRecPointsData(kQmaxMedium)->Fill(Qmax);
	  GetRecPointsData(kQMedium)->Fill(Q);
	} else { // long pads

	  GetRecPointsData(kQmaxLong)->Fill(Qmax);
	  GetRecPointsData(kQLong)->Fill(Q);
	}
      }
      
      GetRecPointsData(kRow)->Fill(row);
    } // end loop over clusters
  } // end loop over tree

  delete clrow;
}

//____________________________________________________________________________
void AliTPCQADataMakerRec::LoadMaps()
{
  TString path = gSystem->Getenv("ALICE_ROOT");
  path += "/TPC/mapping/Patch";

  for(Int_t i = 0; i < 6; i++) {
    TString path2 = path;
    path2 += i;
    path2 += ".data";
    fMapping[i] = new AliTPCAltroMapping(path2.Data());
  }
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16
	17	/* $Id: $ */
	18
	19	/*
	20	Based on AliPHOSQADataMaker
	21	Produces the data needed to calculate the quality assurance.
	22	All data must be mergeable objects.
	23	P. Christiansen, Lund, January 2008
	24	*/
	25
	26	/*
	27	Implementation:
	28
	29	We have chosen to have the histograms as non-persistent meber to
	30	allow better debugging. In the copy constructor we then have to
	31	assign the pointers to the existing histograms in the copied
	32	list. This have been implemented but not tested.
	33
	34	For the QA of the RAW data we use the class, AliTPCdataQA, from the
	35	existing TPC Calibration framework (which is more advanced than the
	36	standard QA framework) and extract the histograms at the end. This
	37	has been tested with zero-suppressed data. The Analyse method of the
	38	AliTPCdataQA class is called in the method, EndOfDetectorCycle, and
	39	there also: 1d histogram(s) are projected and added to the QA list.
	40	*/
	41
	42	/*
	43	TODO:
	44	Sumw2 for RAW histogram(s)?
	45	RecPoints and ESD could have many more histograms
	46	*/
	47
	48	#include "AliTPCQADataMakerRec.h"
	49
	50	// --- ROOT system ---
	51	#include <TClonesArray.h>
	52	#include <TString.h>
	53	#include <TSystem.h>
	54
	55	// --- Standard library ---
	56
	57	// --- AliRoot header files ---
	58	#include "AliQAChecker.h"
	59	#include "AliESDEvent.h"
	60	#include "AliESDtrack.h"
	61	#include "AliLog.h"
	62	#include "AliTPCCalPad.h"
	63	#include "AliTPCCalROC.h"
	64	#include "AliTPCClustersRow.h"
	65	#include "AliTPCclusterMI.h"
	66
	67	ClassImp(AliTPCQADataMakerRec)
	68
	69	//____________________________________________________________________________
	70	AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
	71	AliQADataMakerRec(AliQA::GetDetName(AliQA::kTPC),
	72	"TPC Rec Quality Assurance Data Maker"),
	73	fTPCdataQA(NULL)
	74	{
	75	// ctor
	76	fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
	77	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	78	fTPCdataQA[specie] = NULL ;
	79
	80	for(Int_t i = 0; i < 6; i++)
	81	fMapping[i] = 0;
	82	}
	83
	84	//____________________________________________________________________________
	85	AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
	86	AliQADataMakerRec(),
	87	fTPCdataQA(NULL)
	88	{
	89	//copy ctor
	90	// Does not copy the calibration object, instead InitRaws have to be
	91	// called again
	92	SetName((const char*)qadm.GetName()) ;
	93	SetTitle((const char*)qadm.GetTitle());
	94
	95	fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
	96	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	97	fTPCdataQA[specie] = NULL ;
	98
	99	for(Int_t i = 0; i < 6; i++)
	100	fMapping[i] = 0;
	101
	102	//
	103	// Associate class histogram objects to the copies in the list
	104	// Could also be done with the indexes
	105	//
	106
	107	}
	108
	109	//__________________________________________________________________
	110	AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerRec& qadm )
	111	{
	112	// Equal operator.
	113	this->~AliTPCQADataMakerRec();
	114	new(this) AliTPCQADataMakerRec(qadm);
	115	return *this;
	116	}
	117
	118	//__________________________________________________________________
	119	AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
	120	{
	121	// Destructor
	122	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	123	if ( fTPCdataQA[specie] != NULL )
	124	delete fTPCdataQA[specie] ;
	125	delete[] fTPCdataQA;
	126
	127	for(Int_t i = 0; i < 6; i++)
	128	delete fMapping[i];
	129	}
	130
	131	//____________________________________________________________________________
	132	void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
	133	{
	134	//Detector specific actions at end of cycle
	135
	136	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	137	if ( !AliQA::Instance()->IsEventSpecieSet(specie) )
	138	continue ;
	139	if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data
	140
	141	fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
	142	// RAW data files with no TPC data
	143
	144	SetEventSpecie(specie) ;
	145	TH1F * histRawsOccupancy = (TH1F*)GetRawsData(kOccupancy) ;
	146	TH1F * histRawsOccupancyVsSector = (TH1F*)GetRawsData(kOccupancyVsSector) ;
	147	TH1F * histRawsNClustersPerEventVsSector = (TH1F*)GetRawsData(kNClustersPerEventVsSector) ;
	148	TH1F * histRawsQVsSector = (TH1F*)GetRawsData(kQVsSector) ;
	149	TH1F * histRawsQmaxVsSector = (TH1F*)GetRawsData(kQmaxVsSector) ;
	150	if ( !histRawsOccupancy \|\|
	151	!histRawsOccupancyVsSector \|\|
	152	!histRawsNClustersPerEventVsSector \|\|
	153	!histRawsQVsSector \|\|
	154	!histRawsQmaxVsSector) {
	155	AliError("Something very wrong here, corrupted memory ?????. Please check\n") ;
	156	continue ;
	157	}
	158
	159	//Add2RawsList(fTPCdataQA, 0);
	160	// get the histograms and add them to the output
	161	// 31/8-08 Histogram is only added if the Calibration class
	162	// receives TPC data
	163	const Int_t eventCounter = fTPCdataQA[specie]->GetEventCounter();
	164	if(eventCounter>0) { // some TPC data has been processed
	165
	166	// Reset histograms and refill them
	167	histRawsOccupancy->Reset();
	168	histRawsOccupancyVsSector->Reset();
	169	histRawsNClustersPerEventVsSector->Reset();
	170	histRawsQVsSector->Reset();
	171	histRawsQmaxVsSector->Reset();
	172
	173	TH1F* hNorm72 = new TH1F("hNorm72", "histogram to normalize 72 sectors",
	174	72, 0, 72);
	175	hNorm72->Sumw2();
	176	TH1F* hNorm108 = new TH1F("hNorm108", "histogram to normalize 108 sectors (medium and long pads are split up)",
	177	108, 0, 108);
	178	hNorm108->Sumw2();
	179
	180	for (Int_t iSec = 0; iSec < 72; iSec++) {
	181
	182	AliTPCCalROC* occupancyROC =
	183	fTPCdataQA[specie]->GetNoThreshold()->GetCalROC(iSec);
	184	AliTPCCalROC* nclusterROC =
	185	fTPCdataQA[specie]->GetNLocalMaxima()->GetCalROC(iSec);
	186	AliTPCCalROC* qROC =
	187	fTPCdataQA[specie]->GetMeanCharge()->GetCalROC(iSec);
	188	AliTPCCalROC* qmaxROC =
	189	fTPCdataQA[specie]->GetMaxCharge()->GetCalROC(iSec);
	190
	191	const Int_t nRows = occupancyROC->GetNrows();
	192	for (Int_t iRow = 0; iRow < nRows; iRow++) {
	193
	194	Int_t helpSector = iSec;
	195	if(iRow>=64)
	196	helpSector += 36; // OROC (long pads)
	197
	198	const Int_t nPads = occupancyROC->GetNPads(iRow);
	199	for (Int_t iPad = 0; iPad < nPads; iPad++) {
	200
	201	histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
	202	hNorm72->Fill(iSec);
	203	histRawsOccupancyVsSector
	204	->Fill(iSec, occupancyROC->GetValue(iRow, iPad));
	205
	206	const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
	207
	208	if(nClusters>0) {
	209
	210	histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
	211	hNorm108->Fill(helpSector, nClusters);
	212	histRawsQVsSector->Fill(helpSector,
	213	nClusters*qROC->GetValue(iRow, iPad));
	214	histRawsQmaxVsSector->Fill(helpSector,
	215	nClusters*qmaxROC->GetValue(iRow, iPad));
	216	}
	217	}
	218	}
	219	} // end loop over sectors
	220
	221	// Normalize histograms
	222	histRawsOccupancyVsSector->Divide(hNorm72);
	223	histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
	224	histRawsQVsSector->Divide(hNorm108);
	225	histRawsQmaxVsSector->Divide(hNorm108);
	226	delete hNorm72;
	227	delete hNorm108;
	228	}
	229	}
	230	}
	231	AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;
	232	}
	233
	234	//____________________________________________________________________________
	235	void AliTPCQADataMakerRec::InitESDs()
	236	{
	237	//create ESDs histograms in ESDs subdir
	238	TH1F * histESDclusters =
	239	new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
	240	160, 0, 160);
	241	histESDclusters->Sumw2();
	242	Add2ESDsList(histESDclusters, KClusters);
	243
	244	TH1F * histESDratio =
	245	new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
	246	100, 0, 1);
	247	histESDratio->Sumw2();
	248	Add2ESDsList(histESDratio, kRatio);
	249
	250	TH1F * histESDpt =
	251	new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
	252	50, 0, 5);
	253	histESDpt->Sumw2();
	254	Add2ESDsList(histESDpt, kPt);
	255	}
	256
	257	//____________________________________________________________________________
	258	void AliTPCQADataMakerRec::InitRaws()
	259	{
	260	//
	261	// Adding the raw
	262	//
	263
	264	// Modified: 7/7 - 2008
	265	// Laurent Aphecetche pointed out that the mapping was read from file
	266	// for each event, so now we read in the map here and set if for
	267	// the raw data qa
	268	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	269	fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::Convert(specie));
	270	LoadMaps(); // Load Altro maps
	271	fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
	272	fTPCdataQA[specie]->SetRangeTime(100, 920); // set time bin interval
	273	// Add2RawsList(fTPCdataQA, kTPCdataQA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
	274	}
	275
	276	TH1F * histRawsOccupancy =
	277	new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
	278	100, 0, 1);
	279	histRawsOccupancy->Sumw2();
	280	Add2RawsList(histRawsOccupancy, kOccupancy);
	281
	282	TH1F * histRawsOccupancyVsSector =
	283	new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
	284	72, 0, 72);
	285	histRawsOccupancyVsSector->Sumw2();
	286	Add2RawsList(histRawsOccupancyVsSector, kOccupancyVsSector);
	287
	288	TH1F * histRawsNClustersPerEventVsSector =
	289	new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
	290	72, 0, 72);
	291	histRawsNClustersPerEventVsSector->Sumw2();
	292	Add2RawsList(histRawsNClustersPerEventVsSector, kNClustersPerEventVsSector);
	293
	294	TH1F * histRawsQVsSector =
	295	new TH1F("hRawsQVsSector", "<Q> vs sector (OROC med: 36-71, long: 72-107); Sector; <Q>",
	296	108, 0, 108);
	297	histRawsQVsSector->Sumw2();
	298	Add2RawsList(histRawsQVsSector, kQVsSector);
	299
	300	TH1F * histRawsQmaxVsSector =
	301	new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector (OROC med: 36-71, long: 72-107); Sector; <Qmax>",
	302	108, 0, 108);
	303	histRawsQmaxVsSector->Sumw2();
	304	Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector);
	305	}
	306
	307	//____________________________________________________________________________
	308	void AliTPCQADataMakerRec::InitRecPoints()
	309	{
	310	TH1F * histRecPointsQmaxShort =
	311	new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
	312	100, 0, 300);
	313	histRecPointsQmaxShort->Sumw2();
	314	Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort);
	315
	316	TH1F * histRecPointsQmaxMedium =
	317	new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
	318	100, 0, 300);
	319	histRecPointsQmaxMedium->Sumw2();
	320	Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium);
	321
	322	TH1F * histRecPointsQmaxLong =
	323	new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
	324	100, 0, 300);
	325	histRecPointsQmaxLong->Sumw2();
	326	Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong);
	327
	328	TH1F * histRecPointsQShort =
	329	new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
	330	100, 0, 2000);
	331	histRecPointsQShort->Sumw2();
	332	Add2RecPointsList(histRecPointsQShort, kQShort);
	333
	334	TH1F * histRecPointsQMedium =
	335	new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
	336	100, 0, 2000);
	337	histRecPointsQMedium->Sumw2();
	338	Add2RecPointsList(histRecPointsQMedium, kQMedium);
	339
	340	TH1F * histRecPointsQLong =
	341	new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
	342	100, 0, 2000);
	343	histRecPointsQLong->Sumw2();
	344	Add2RecPointsList(histRecPointsQLong, kQLong);
	345
	346	TH1F * histRecPointsRow =
	347	new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
	348	159, 0, 159);
	349	histRecPointsRow->Sumw2();
	350	Add2RecPointsList(histRecPointsRow, kRow);
	351	}
	352
	353	//____________________________________________________________________________
	354	void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
	355	{
	356	// make QA data from ESDs
	357
	358	const Int_t nESDTracks = esd->GetNumberOfTracks();
	359	Int_t nTPCtracks = 0;
	360	for(Int_t i = 0; i < nESDTracks; i++) {
	361
	362	AliESDtrack * track = esd->GetTrack(i);
	363
	364	if ((track->GetStatus() & AliESDtrack::kTPCrefit)==0)
	365	continue;
	366
	367	nTPCtracks++;
	368
	369	Int_t nTPCclusters = track->GetTPCNcls();
	370	Int_t nTPCclustersFindable = track->GetTPCNclsF();
	371	if ( nTPCclustersFindable<=0) continue;
	372	GetESDsData(KClusters)->Fill(nTPCclusters);
	373	GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
	374	GetESDsData(kPt)->Fill(track->Pt());
	375	}
	376	}
	377
	378	//____________________________________________________________________________
	379	void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
	380	{
	381	//
	382	// To make QA for the RAW data we use the TPC Calibration framework
	383	// to handle the data and then in the end extract the data
	384	//
	385	rawReader->Reset() ;
	386	fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
	387	}
	388
	389	//____________________________________________________________________________
	390	void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
	391	{
	392	AliTPCClustersRow *clrow = new AliTPCClustersRow();
	393	clrow->SetClass("AliTPCclusterMI");
	394	clrow->SetArray(0);
	395	clrow->GetArray()->ExpandCreateFast(10000);
	396
	397	TBranch* branch = recTree->GetBranch("Segment");
	398	branch->SetAddress(&clrow);
	399
	400	const Int_t nEntries = Int_t(recTree->GetEntries());
	401	for (Int_t i = 0; i < nEntries; i++) {
	402
	403	branch->GetEntry(i);
	404
	405	const Int_t nClusters = clrow->GetArray()->GetEntriesFast();
	406	for (Int_t icl=0; icl < nClusters; icl++){
	407
	408	AliTPCclusterMI* cluster =
	409	(AliTPCclusterMI*)clrow->GetArray()->At(icl);
	410
	411	Float_t Qmax = cluster->GetMax();
	412	Float_t Q = cluster->GetQ();
	413	Int_t row = cluster->GetRow();
	414
	415	if(cluster->GetDetector()<36) { // IROC (short pads)
	416
	417	GetRecPointsData(kQmaxShort)->Fill(Qmax);
	418	GetRecPointsData(kQShort)->Fill(Q);
	419	} else { // OROC (medium and long pads)
	420	row += 63;
	421	if(cluster->GetRow()<64) { // medium pads
	422
	423	GetRecPointsData(kQmaxMedium)->Fill(Qmax);
	424	GetRecPointsData(kQMedium)->Fill(Q);
	425	} else { // long pads
	426
	427	GetRecPointsData(kQmaxLong)->Fill(Qmax);
	428	GetRecPointsData(kQLong)->Fill(Q);
	429	}
	430	}
	431
	432	GetRecPointsData(kRow)->Fill(row);
	433	} // end loop over clusters
	434	} // end loop over tree
	435
	436	delete clrow;
	437	}
	438
	439	//____________________________________________________________________________
	440	void AliTPCQADataMakerRec::LoadMaps()
	441	{
	442	TString path = gSystem->Getenv("ALICE_ROOT");
	443	path += "/TPC/mapping/Patch";
	444
	445	for(Int_t i = 0; i < 6; i++) {
	446	TString path2 = path;
	447	path2 += i;
	448	path2 += ".data";
	449	fMapping[i] = new AliTPCAltroMapping(path2.Data());
	450	}
	451	}
	452