[u/mrichter/AliRoot.git] / T0 / AliT0QAChecker.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/
//...
//  Checks the quality assurance. 
//  By comparing with reference data
//  Skeleton for T0
//---------------------------------------------
//checkig without reference data:
//for RAW QA all histograms should have approximatly the same 
//number of entries as RefPoint
//for Rec Points checks 
//  - amplitude measured by 2 methos
//  - online and offline T0 measurements
// for ESD quality of reconstruction ( and measurements):
// RMS of vertex and T0 less than 75ps
//
// Alla.Maevskaya@cern.ch   
//...

// --- ROOT system ---
#include <Riostream.h>
#include <TClass.h>
#include <TH1F.h> 
#include <TH2.h> 
#include <TIterator.h> 
#include <TKey.h> 
#include <TFile.h> 
#include <TMath.h>
#include <TString.h>

// --- Standard library ---

// --- AliRoot header files ---
#include "AliLog.h"
#include "AliQA.h"
#include "AliQAChecker.h"
#include "AliT0QAChecker.h"

ClassImp(AliT0QAChecker)


//____________________________________________________________________________
Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t /*index*/)
{
  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ; 
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    rv[specie] = 0.0 ; 
  return rv ;  
}

//__________________________________________________________________
Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t index,TObjArray ** list)
{

  // Super-basic check on the QA histograms on the input list:
  // look whether they are empty!

  Double_t * test = new Double_t[AliRecoParam::kNSpecies] ; 
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    test[specie]    = 10.0 ; 

  Double_t nent[250];
  TString hname[250];
  const char *cname;
  memset(nent,0,250*sizeof(Double_t));
  Double_t w[250];
  memset(w,1,250*sizeof(Double_t));
  TH2 *fhRecDiff[3];  
  TH2 *fhRawEff[250];
  TH1 *fhESD[2];
  
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    //  TString dataType = AliQA::GetAliTaskName(index);
    if (list[specie]->GetEntries() == 0){
      test[specie] = 1. ; // nothing to check
    }
    else {
    TIter next(list[specie]) ;
    TH1 * hdata ;
    TH2 * h ;
    //  AliInfo(Form(" data type %i %s nentries %i\n",
    //	   index,dataType.Data(),list->GetEntries()));
    for (Int_t ir=0; ir<list[specie]->GetEntries(); ir++) {
      //raw
      if(index==0 ){
        /*
         if(ir < 205) {
         hdata = (TH1*) list[specie]->UncheckedAt(ir);
         if(hdata) {
         cname = hdata->GetName();
         hname[ir] = cname;
         AliDebug(10,Form("count %i %s \n",ir, hname[ir].Data())) ;
         fhRaw[ir] = hdata;
         }
         }*/
        if(ir > 204) {
          //	  else{
          h = (TH2*) list[specie]->UncheckedAt(ir);
          AliInfo(Form(" index %i ir %i \n", index,ir));
          if(h) {
            cname = h->GetName();
            hname[ir] = cname;
            AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
            fhRawEff[ir] = h;
          }
        }
      }
     
      //rec
      if(index==2){
        h = (TH2*) list[specie]->UncheckedAt(ir);
        if(h) {
          cname = h->GetName();
          hname[ir] = cname;
          AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
          fhRecDiff[ir] = h;
        }
      }
      //esd
      if(index==3){
        cout<<" ir "<<ir<<endl;
        hdata = (TH1*) list[specie]->UncheckedAt(ir);
        if(hdata){
          fhESD[ir] = hdata;
          AliDebug(1,Form("count %i %s ",ir, hname[ir].Data()) );
        }
      }
    }
      if (index == 0) {
        //raw data
	
        for (Int_t icase=205; icase<207; icase++) {
          for (Int_t idet=0; idet<24; idet++) {
            Double_t mean = fhRawEff[icase]->ProjectionY(Form("%s_py_%i_%i",
                                                              fhRawEff[icase]->GetName(), idet,icase),
                                                              idet,idet+1)->GetMean();
            Double_t rms= fhRawEff[icase]->ProjectionY(Form("%s_py%i_%i", 
                                                            fhRawEff[icase]->GetName(), idet,icase),
                                                            idet,idet+1)->GetRMS();
            AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
                    fhRawEff[icase]->GetName(), icase, idet, mean,rms));
            if (mean<1.2 && mean> 0.8 ) {
              test[specie] = 1;
              AliDebug(1,Form("All channels works meane efficieny %f with rms %f test %f",  mean, rms, test[specie])) ; 
            }
            if (mean<=0.8 && mean>= 0.5 ){
              test[specie] = 0.5;
              AliDebug(1,Form("%s problem in channel %i  efficieny %f test %f",
                              fhRawEff[icase]->GetName(), idet,  mean, test[specie])) ; 
            }
            if (mean<0.5 ) { 
              test[specie] = 0.25;
              AliDebug(1,Form("%s big problem in channel %i  efficieny %f test %f",
                              fhRawEff[icase]->GetName(), idet,  mean, test[specie])) ; 
            }
          }
        }
      }
      if(index == 2){
        //rec points
        for (Int_t icase=0; icase<2; icase++) {
          for (Int_t idet=0; idet<24; idet++) {
            Double_t mean = fhRecDiff[icase]->
            ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
                        idet,idet+1)->GetMean();
            Double_t rms= fhRecDiff[icase]->
            ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
                        idet,idet+1)->GetRMS();
            AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
                         fhRecDiff[icase]->GetName(), icase, idet, mean,rms)); 
	  	  
            if(TMath::Abs(mean) >1.5 || rms >1){
              AliDebug(1,Form(" calibration is nor perfect; test=%f", test)) ;
              test[specie]=0.25;
            }
            if(mean>3 || rms >5) {
              test[specie] = 0.1;
              AliDebug(1,Form(" wrong calibration test=%f", test[specie])) ;
            } 
          }
        }	 
      }
      if (index == 3) {
        //ESD
        for (Int_t icase=0; icase<2; icase++) {
          Double_t rmsVertex = fhESD[icase]->GetRMS();
          Double_t meanVertex = fhESD[icase]->GetMean();
          test[specie]=1;
          AliInfo(Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
          if (TMath::Abs(rmsVertex)>3) {
            test[specie]=0.25;
            AliDebug(1,Form("Vertex position resolution not good  , rms= %f test=%f",
                            rmsVertex, test[specie])) ; 
          }
          if (TMath::Abs(meanVertex)>3) {
            test[specie]=0.25;
            AliDebug(1,Form("Vertex position bad calibrated  , Mean= %f test=%f",
                            meanVertex, test[specie])) ; 
          }
        }
      }
    } //  if (list->GetEntries() != 0
    AliInfo(Form("Test Result = %f", test[specie])) ;
  } 
  return test ;
}
Commit	Line	Data
c03351ac	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	**************************************************************************/
c03351ac	15	//...
	16	// Checks the quality assurance.
	17	// By comparing with reference data
	18	// Skeleton for T0
f6c2d5e2	19	//---------------------------------------------
	20	//checkig without reference data:
	21	//for RAW QA all histograms should have approximatly the same
	22	//number of entries as RefPoint
	23	//for Rec Points checks
	24	// - amplitude measured by 2 methos
	25	// - online and offline T0 measurements
	26	// for ESD quality of reconstruction ( and measurements):
	27	// RMS of vertex and T0 less than 75ps
	28	//
	29	// Alla.Maevskaya@cern.ch
c03351ac	30	//...
	31
	32	// --- ROOT system ---
b09247a2	33	#include <Riostream.h>
c03351ac	34	#include <TClass.h>
c03351ac	35	#include <TH1F.h>
0d849919	36	#include <TH2.h>
c03351ac	37	#include <TIterator.h>
	38	#include <TKey.h>
	39	#include <TFile.h>
446d6ec4	40	#include <TMath.h>
0d849919	41	#include <TString.h>
c03351ac	42
	43	// --- Standard library ---
	44
	45	// --- AliRoot header files ---
	46	#include "AliLog.h"
	47	#include "AliQA.h"
	48	#include "AliQAChecker.h"
	49	#include "AliT0QAChecker.h"
	50
	51	ClassImp(AliT0QAChecker)
	52
3685c21c	53
57acd2d2	54	//____________________________________________________________________________
	55	Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t /index/)
	56	{
	57	Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
	58	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	59	rv[specie] = 0.0 ;
	60	return rv ;
	61	}
	62
4e67e173	63	//__________________________________________________________________
57acd2d2	64	Double_t * AliT0QAChecker::Check(AliQA::ALITASK_t index,TObjArray ** list)
3685c21c	65	{
	66
	67	// Super-basic check on the QA histograms on the input list:
	68	// look whether they are empty!
446d6ec4	69
57acd2d2	70	Double_t * test = new Double_t[AliRecoParam::kNSpecies] ;
	71	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
	72	test[specie] = 10.0 ;
c724dd64	73
0d849919	74	Double_t nent[250];
c4b97145	75	TString hname[250];
5ed41460	76	const char *cname;
c4b97145	77	memset(nent,0,250*sizeof(Double_t));
	78	Double_t w[250];
	79	memset(w,1,250*sizeof(Double_t));
0d849919	80	TH2 *fhRecDiff[3];
0d849919	81	TH2 *fhRawEff[250];
57acd2d2	82	TH1 *fhESD[2];
	83
	84	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
	85	// TString dataType = AliQA::GetAliTaskName(index);
	86	if (list[specie]->GetEntries() == 0){
	87	test[specie] = 1. ; // nothing to check
	88	}
	89	else {
	90	TIter next(list[specie]) ;
3685c21c	91	TH1 * hdata ;
0d849919	92	TH2 * h ;
57acd2d2	93	// AliInfo(Form(" data type %i %s nentries %i\n",
	94	// index,dataType.Data(),list->GetEntries()));
	95	for (Int_t ir=0; ir<list[specie]->GetEntries(); ir++) {
	96	//raw
	97	if(index==0 ){
	98	/*
	99	if(ir < 205) {
	100	hdata = (TH1*) list[specie]->UncheckedAt(ir);
	101	if(hdata) {
	102	cname = hdata->GetName();
	103	hname[ir] = cname;
	104	AliDebug(10,Form("count %i %s \n",ir, hname[ir].Data())) ;
	105	fhRaw[ir] = hdata;
	106	}
	107	}*/
	108	if(ir > 204) {
	109	// else{
	110	h = (TH2*) list[specie]->UncheckedAt(ir);
	111	AliInfo(Form(" index %i ir %i \n", index,ir));
	112	if(h) {
	113	cname = h->GetName();
	114	hname[ir] = cname;
	115	AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
	116	fhRawEff[ir] = h;
	117	}
	118	}
	119	}
0d849919	120
57acd2d2	121	//rec
	122	if(index==2){
	123	h = (TH2*) list[specie]->UncheckedAt(ir);
	124	if(h) {
	125	cname = h->GetName();
	126	hname[ir] = cname;
	127	AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
	128	fhRecDiff[ir] = h;
	129	}
	130	}
	131	//esd
	132	if(index==3){
	133	cout<<" ir "<<ir<<endl;
	134	hdata = (TH1*) list[specie]->UncheckedAt(ir);
	135	if(hdata){
	136	fhESD[ir] = hdata;
	137	AliDebug(1,Form("count %i %s ",ir, hname[ir].Data()) );
	138	}
0d849919	139	}
57acd2d2	140	}
	141	if (index == 0) {
	142	//raw data
5ed41460	143
57acd2d2	144	for (Int_t icase=205; icase<207; icase++) {
	145	for (Int_t idet=0; idet<24; idet++) {
	146	Double_t mean = fhRawEff[icase]->ProjectionY(Form("%s_py_%i_%i",
	147	fhRawEff[icase]->GetName(), idet,icase),
	148	idet,idet+1)->GetMean();
	149	Double_t rms= fhRawEff[icase]->ProjectionY(Form("%s_py%i_%i",
	150	fhRawEff[icase]->GetName(), idet,icase),
	151	idet,idet+1)->GetRMS();
	152	AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
	153	fhRawEff[icase]->GetName(), icase, idet, mean,rms));
	154	if (mean<1.2 && mean> 0.8 ) {
	155	test[specie] = 1;
	156	AliDebug(1,Form("All channels works meane efficieny %f with rms %f test %f", mean, rms, test[specie])) ;
	157	}
	158	if (mean<=0.8 && mean>= 0.5 ){
	159	test[specie] = 0.5;
	160	AliDebug(1,Form("%s problem in channel %i efficieny %f test %f",
	161	fhRawEff[icase]->GetName(), idet, mean, test[specie])) ;
	162	}
	163	if (mean<0.5 ) {
	164	test[specie] = 0.25;
	165	AliDebug(1,Form("%s big problem in channel %i efficieny %f test %f",
	166	fhRawEff[icase]->GetName(), idet, mean, test[specie])) ;
	167	}
	168	}
	169	}
3685c21c	170	}
57acd2d2	171	if(index == 2){
	172	//rec points
	173	for (Int_t icase=0; icase<2; icase++) {
	174	for (Int_t idet=0; idet<24; idet++) {
	175	Double_t mean = fhRecDiff[icase]->
	176	ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
	177	idet,idet+1)->GetMean();
	178	Double_t rms= fhRecDiff[icase]->
	179	ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
	180	idet,idet+1)->GetRMS();
	181	AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
	182	fhRecDiff[icase]->GetName(), icase, idet, mean,rms));
0d849919	183
57acd2d2	184	if(TMath::Abs(mean) >1.5 \|\| rms >1){
	185	AliDebug(1,Form(" calibration is nor perfect; test=%f", test)) ;
	186	test[specie]=0.25;
	187	}
	188	if(mean>3 \|\| rms >5) {
	189	test[specie] = 0.1;
	190	AliDebug(1,Form(" wrong calibration test=%f", test[specie])) ;
	191	}
	192	}
	193	}
3685c21c	194	}
57acd2d2	195	if (index == 3) {
	196	//ESD
	197	for (Int_t icase=0; icase<2; icase++) {
	198	Double_t rmsVertex = fhESD[icase]->GetRMS();
	199	Double_t meanVertex = fhESD[icase]->GetMean();
	200	test[specie]=1;
	201	AliInfo(Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
	202	if (TMath::Abs(rmsVertex)>3) {
	203	test[specie]=0.25;
	204	AliDebug(1,Form("Vertex position resolution not good , rms= %f test=%f",
	205	rmsVertex, test[specie])) ;
	206	}
	207	if (TMath::Abs(meanVertex)>3) {
	208	test[specie]=0.25;
	209	AliDebug(1,Form("Vertex position bad calibrated , Mean= %f test=%f",
	210	meanVertex, test[specie])) ;
	211	}
	212	}
	213	}
	214	} // if (list->GetEntries() != 0
	215	AliInfo(Form("Test Result = %f", test[specie])) ;
	216	}
3685c21c	217	return test ;
3685c21c	218	}
5ed41460	219