[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
44f32dd2	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>
be4f1702	52	#include <TString.h>
be4f1702	53	#include <TSystem.h>
44f32dd2	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"
adcdb395	63	#include "AliTPCCalROC.h"
44f32dd2	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"),
57acd2d2	73	fTPCdataQA(NULL)
44f32dd2	74	{
44f32dd2	75	// ctor
57acd2d2	76	fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
	77	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	78	fTPCdataQA[specie] = NULL ;
	79
be4f1702	80	for(Int_t i = 0; i < 6; i++)
be4f1702	81	fMapping[i] = 0;
44f32dd2	82	}
	83
	84	//____________________________________________________________________________
	85	AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
336156cc	86	AliQADataMakerRec(),
57acd2d2	87	fTPCdataQA(NULL)
44f32dd2	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
57acd2d2	95	fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
	96	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	97	fTPCdataQA[specie] = NULL ;
	98
be4f1702	99	for(Int_t i = 0; i < 6; i++)
	100	fMapping[i] = 0;
	101
44f32dd2	102	//
	103	// Associate class histogram objects to the copies in the list
	104	// Could also be done with the indexes
	105	//
57acd2d2	106
44f32dd2	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	}
be4f1702	117
	118	//__________________________________________________________________
	119	AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
	120	{
	121	// Destructor
57acd2d2	122	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	123	if ( fTPCdataQA[specie] != NULL )
	124	delete fTPCdataQA[specie] ;
	125	delete[] fTPCdataQA;
be4f1702	126
	127	for(Int_t i = 0; i < 6; i++)
	128	delete fMapping[i];
	129	}
44f32dd2	130
44f32dd2	131	//____________________________________________________________________________
57acd2d2	132	void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray ** list)
44f32dd2	133	{
44f32dd2	134	//Detector specific actions at end of cycle
57acd2d2	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
44f32dd2	140
57acd2d2	141	fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
c75bf2f1	142	// RAW data files with no TPC data
57acd2d2	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();
adcdb395	172
57acd2d2	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++) {
adcdb395	181
57acd2d2	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++) {
adcdb395	200
57acd2d2	201	histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
	202	hNorm72->Fill(iSec);
	203	histRawsOccupancyVsSector
	204	->Fill(iSec, occupancyROC->GetValue(iRow, iPad));
adcdb395	205
57acd2d2	206	const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
adcdb395	207
57acd2d2	208	if(nClusters>0) {
adcdb395	209
57acd2d2	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
adcdb395	220
57acd2d2	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	}
c75bf2f1	229	}
44f32dd2	230	}
44f32dd2	231	AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;
	232	}
	233
	234	//____________________________________________________________________________
	235	void AliTPCQADataMakerRec::InitESDs()
	236	{
	237	//create ESDs histograms in ESDs subdir
57acd2d2	238	TH1F * histESDclusters =
44f32dd2	239	new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
44f32dd2	240	160, 0, 160);
57acd2d2	241	histESDclusters->Sumw2();
57acd2d2	242	Add2ESDsList(histESDclusters, KClusters);
44f32dd2	243
57acd2d2	244	TH1F * histESDratio =
44f32dd2	245	new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
44f32dd2	246	100, 0, 1);
57acd2d2	247	histESDratio->Sumw2();
57acd2d2	248	Add2ESDsList(histESDratio, kRatio);
44f32dd2	249
57acd2d2	250	TH1F * histESDpt =
44f32dd2	251	new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
44f32dd2	252	50, 0, 5);
57acd2d2	253	histESDpt->Sumw2();
57acd2d2	254	Add2ESDsList(histESDpt, kPt);
44f32dd2	255	}
	256
	257	//____________________________________________________________________________
	258	void AliTPCQADataMakerRec::InitRaws()
	259	{
336156cc	260	//
336156cc	261	// Adding the raw
be4f1702	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
57acd2d2	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	}
be4f1702	275
57acd2d2	276	TH1F * histRawsOccupancy =
adcdb395	277	new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
adcdb395	278	100, 0, 1);
57acd2d2	279	histRawsOccupancy->Sumw2();
	280	Add2RawsList(histRawsOccupancy, kOccupancy);
	281
	282	TH1F * histRawsOccupancyVsSector =
adcdb395	283	new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
adcdb395	284	72, 0, 72);
57acd2d2	285	histRawsOccupancyVsSector->Sumw2();
57acd2d2	286	Add2RawsList(histRawsOccupancyVsSector, kOccupancyVsSector);
adcdb395	287
57acd2d2	288	TH1F * histRawsNClustersPerEventVsSector =
adcdb395	289	new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
adcdb395	290	72, 0, 72);
57acd2d2	291	histRawsNClustersPerEventVsSector->Sumw2();
57acd2d2	292	Add2RawsList(histRawsNClustersPerEventVsSector, kNClustersPerEventVsSector);
adcdb395	293
57acd2d2	294	TH1F * histRawsQVsSector =
adcdb395	295	new TH1F("hRawsQVsSector", "<Q> vs sector (OROC med: 36-71, long: 72-107); Sector; <Q>",
adcdb395	296	108, 0, 108);
57acd2d2	297	histRawsQVsSector->Sumw2();
57acd2d2	298	Add2RawsList(histRawsQVsSector, kQVsSector);
adcdb395	299
57acd2d2	300	TH1F * histRawsQmaxVsSector =
adcdb395	301	new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector (OROC med: 36-71, long: 72-107); Sector; <Qmax>",
adcdb395	302	108, 0, 108);
57acd2d2	303	histRawsQmaxVsSector->Sumw2();
57acd2d2	304	Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector);
44f32dd2	305	}
	306
	307	//____________________________________________________________________________
	308	void AliTPCQADataMakerRec::InitRecPoints()
	309	{
57acd2d2	310	TH1F * histRecPointsQmaxShort =
44f32dd2	311	new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
adcdb395	312	100, 0, 300);
57acd2d2	313	histRecPointsQmaxShort->Sumw2();
57acd2d2	314	Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort);
44f32dd2	315
57acd2d2	316	TH1F * histRecPointsQmaxMedium =
44f32dd2	317	new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
adcdb395	318	100, 0, 300);
57acd2d2	319	histRecPointsQmaxMedium->Sumw2();
57acd2d2	320	Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium);
44f32dd2	321
57acd2d2	322	TH1F * histRecPointsQmaxLong =
44f32dd2	323	new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
adcdb395	324	100, 0, 300);
57acd2d2	325	histRecPointsQmaxLong->Sumw2();
57acd2d2	326	Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong);
44f32dd2	327
57acd2d2	328	TH1F * histRecPointsQShort =
44f32dd2	329	new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
adcdb395	330	100, 0, 2000);
57acd2d2	331	histRecPointsQShort->Sumw2();
57acd2d2	332	Add2RecPointsList(histRecPointsQShort, kQShort);
44f32dd2	333
57acd2d2	334	TH1F * histRecPointsQMedium =
44f32dd2	335	new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
adcdb395	336	100, 0, 2000);
57acd2d2	337	histRecPointsQMedium->Sumw2();
57acd2d2	338	Add2RecPointsList(histRecPointsQMedium, kQMedium);
44f32dd2	339
57acd2d2	340	TH1F * histRecPointsQLong =
44f32dd2	341	new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
adcdb395	342	100, 0, 2000);
57acd2d2	343	histRecPointsQLong->Sumw2();
57acd2d2	344	Add2RecPointsList(histRecPointsQLong, kQLong);
44f32dd2	345
57acd2d2	346	TH1F * histRecPointsRow =
44f32dd2	347	new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
44f32dd2	348	159, 0, 159);
57acd2d2	349	histRecPointsRow->Sumw2();
57acd2d2	350	Add2RecPointsList(histRecPointsRow, kRow);
44f32dd2	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();
47a596d8	371	if ( nTPCclustersFindable<=0) continue;
57acd2d2	372	GetESDsData(KClusters)->Fill(nTPCclusters);
	373	GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
	374	GetESDsData(kPt)->Fill(track->Pt());
44f32dd2	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	//
78328afd	385	rawReader->Reset() ;
57acd2d2	386	fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
57acd2d2	387	}
44f32dd2	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
57acd2d2	417	GetRecPointsData(kQmaxShort)->Fill(Qmax);
57acd2d2	418	GetRecPointsData(kQShort)->Fill(Q);
44f32dd2	419	} else { // OROC (medium and long pads)
	420	row += 63;
	421	if(cluster->GetRow()<64) { // medium pads
	422
57acd2d2	423	GetRecPointsData(kQmaxMedium)->Fill(Qmax);
57acd2d2	424	GetRecPointsData(kQMedium)->Fill(Q);
44f32dd2	425	} else { // long pads
44f32dd2	426
57acd2d2	427	GetRecPointsData(kQmaxLong)->Fill(Qmax);
57acd2d2	428	GetRecPointsData(kQLong)->Fill(Q);
44f32dd2	429	}
	430	}
	431
57acd2d2	432	GetRecPointsData(kRow)->Fill(row);
44f32dd2	433	} // end loop over clusters
	434	} // end loop over tree
	435
	436	delete clrow;
	437	}
be4f1702	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