[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 "AliQAv1.h"
#include "AliQAChecker.h"
#include "AliCDBEntry.h"
#include "AliQAManager.h"
#include "AliT0QAChecker.h"

ClassImp(AliT0QAChecker)

//__________________________________________________________________
void AliT0QAChecker::Check(Double_t *  test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/)
{

  // Super-basic check on the QA histograms on the input list:
  // look whether they are empty!
    
  char * detOCDBDir = Form("T0/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ; 

  AliCDBEntry *QARefRec = AliQAManager::QAManager()->Get(detOCDBDir);
  //  QARefRec->Dump();
  if( !QARefRec){
    AliInfo("QA reference data NOT retrieved for Reconstruction check. No T0 reference distribution");
  }
  
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
    test[specie]    = 10.0 ; 

  Double_t nent[500];
  TString hname[500];
  const char *cname;
  memset(nent,0,500*sizeof(Double_t));
  Double_t w[500];
  memset(w,1,500*sizeof(Double_t));
  TH2 *fhRecDiff[3];  
  TH1 *fhRawEff[500];
  TH2 *fhRawTime[500];
  TH1 *fhESD[2];
  TH2 *fhHits[10];
  
  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
    //  TString dataType = AliQAv1::GetAliTaskName(index);
    if (list[specie]->GetEntries() == 0){
      test[specie] = 1. ; // nothing to check
    }
    else {
      TH1 * hdata ;
      TH2 * h ;
      for (Int_t ir=0; ir<list[specie]->GetEntries(); ir++) {
      
	//hits

	if(index == AliQAv1::kSIM && AliQAv1::GetTaskName(AliQAv1::kHITS)){
	  h =  (TH2*) list[specie]->UncheckedAt(ir);
	  cname = h->GetName();
	  hname[ir] = cname;
	  fhHits[ir] = h;
	}

	//raw
      if(index == AliQAv1::kRAW ){
        if(ir > 204 && ir<208 ) {
          hdata = (TH1*) list[specie]->UncheckedAt(ir);
          if(hdata) {
            cname = hdata->GetName();
            hname[ir] = cname;
            fhRawEff[ir] = hdata;
          }
        }
	if((ir>207 && ir<210)  && specie == AliRecoParam::kCalib) {
	  h =  (TH2*) list[specie]->UncheckedAt(ir);
	  if(h) {
	    cname = h->GetName();
	    hname[ir] = cname;
	    fhRawTime[ir] = h;
          AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s ",ir, hname[ir].Data()) );
	  }
	}
      }
      //rec
      if(index == AliQAv1::kREC){
        h = (TH2*) list[specie]->UncheckedAt(ir);
        if(h) {
          cname = h->GetName();
          hname[ir] = cname;
           fhRecDiff[ir] = h;
        }
      }
      //esd
      if(index ==  AliQAv1::kESD){
        hdata = (TH1*) list[specie]->UncheckedAt(ir);
        if(hdata){
          fhESD[ir] = hdata;
          AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s ",ir, hname[ir].Data()) );
        }
      }
    }


    //raw data

      if (index == AliQAv1::kRAW && specie == AliRecoParam::kCalib){
	test[specie] = CheckRaw(list[specie],dynamic_cast<TObjArray*>(dynamic_cast<TList *>(QARefRec->GetObject())->First()));
      }
      
      if(index == AliQAv1::kREC){
        //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();
            AliDebug(AliQAv1::GetQADebugLevel(), 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(AliQAv1::GetQADebugLevel(), Form(" calibration is nor perfect; test=%f", test)) ;
              test[specie]=0.25;
            }
            if(mean>3 || rms >5) {
              test[specie] = 0.1;
              AliDebug(AliQAv1::GetQADebugLevel(), Form(" wrong calibration test=%f", test[specie])) ;
            } 
          }
        }	 
      }
      if (index == AliQAv1::kESD) {
        //ESD
        for (Int_t icase=0; icase<2; icase++) {
          Double_t rmsVertex = fhESD[icase]->GetRMS();
          Double_t meanVertex = fhESD[icase]->GetMean();
          test[specie]=1;
          AliDebug(AliQAv1::GetQADebugLevel(), Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
          if (TMath::Abs(rmsVertex)>3) {
            test[specie]=0.25;
            AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position resolution not good  , rms= %f test=%f",
                            rmsVertex, test[specie])) ; 
          }
          if (TMath::Abs(meanVertex)>3) {
            test[specie]=0.25;
            AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position bad calibrated  , Mean= %f test=%f",
                            meanVertex, test[specie])) ; 
          }
        }
      }
    } //  if (list->GetEntries() != 0
    AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test[specie])) ;
  } 
}

//--------------------------------------------------------------------------
Double_t AliT0QAChecker::CheckRaw(TObjArray *listrec , TObjArray *listref) const
{
  
    //TH1 *fhRawEff;
    //TH1 *fhRawRef;
  TH2 *fhRawRec2d;
  TH2 *fhTime;

  TIter next(listref) ;
    //Int_t counter=0;
  Float_t refmean[50][25]; 
  Float_t refrms[50][25]; 
  Float_t checkr = 0;
  
    //Int_t nref = listref->GetEntries(); 
    //Int_t nrec = listrec->GetEntries(); 
  
  for (Int_t iii=4; iii<6; iii++){
    fhRawRec2d =(TH2*) listref->At(iii); 
    for (Int_t idet=1; idet<25; idet++) {
      
      refmean[iii-4][idet] = fhRawRec2d->	
	ProjectionY(Form("%s_py_%i_%i",                                                              fhRawRec2d ->GetName(), idet,iii-4),
		    idet,idet+1)->GetMean();
      
      refrms[iii-4][idet] = fhRawRec2d->
	ProjectionY(Form("%s_py%i_%i", 
			 fhRawRec2d ->GetName(), idet,iii-4),
		    idet,idet+1)->GetRMS();
      
      }
  }

  
  TString nameDev[2] = {"CDF", "LED"};
  for (Int_t icase=208; icase<210; icase++) {
    fhTime = (TH2*) listrec->At(icase);
    for (Int_t idet=1; idet<25; idet++) {
      Double_t binmean = fhTime->
      ProjectionY(Form("%s_py_%i_%i",                                                              fhTime ->GetName(), idet,icase),
		    idet,idet+1)->GetMean();
//        Double_t rms= fhTime ->ProjectionY(Form("%s_py%i_%i", 
//                                              fhTime ->GetName(), idet,icase),
//                                         idet,idet+1)->GetRMS();
      Double_t diffmean = binmean-refmean[icase-208][idet];
      
      if (TMath::Abs(diffmean) < 2 ) {
	checkr = 1;
	//	printf(" Laser calibration signal sits on its place %f for PMT %s %i : check = %f\n",  diffmean, nameDev[icase-208].Data() ,idet, checkr);
	AliDebug(AliQAv1::GetQADebugLevel(),
		 Form(" Laser calibration signal sits on its place %f for PMT %s %i : check = %f\n",  diffmean, nameDev[icase-208].Data(),idet, checkr)) ; 
     }
     if (TMath::Abs(diffmean) <= 5 && TMath::Abs(diffmean) >= 2 ){
       checkr = 0.5;
       // printf(" Laser calibration signal shifted by  %f ps for PMT %s %i : check = %f\n",  diffmean*24.4, nameDev[icase-208].Data(),idet, checkr);
       AliDebug(AliQAv1::GetQADebugLevel(),
		Form(" Laser calibration signal shifted by  %f ps (%f channels) for PMT %s %i : check = %f\n",  diffmean*24.4 ,diffmean , nameDev[icase-208].Data(),idet, checkr)) ; 
      }
     if (TMath::Abs(diffmean) > 5) { 
       checkr = 0.25;
       //   printf(" Big problems :laser calibration signal shifted by  %f ps (%f channels) for PMT %s %i : check = %f\n",  diffmean*24.4, diffmean, nameDev[icase-208].Data(),idet, checkr);
       AliDebug(AliQAv1::GetQADebugLevel(),
		Form(" Big problems :laser calibration signal shifted by  %f ps (%f channels) for PMT %s %i : check = %i\n",  diffmean*24.4, diffmean, nameDev[icase-208].Data(),idet, checkr)) ; 
       
     }
     
   }
 }

  return checkr;
}
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"
4e25ac79	47	#include "AliQAv1.h"
c03351ac	48	#include "AliQAChecker.h"
394c1a6d	49	#include "AliCDBEntry.h"
394c1a6d	50	#include "AliQAManager.h"
c03351ac	51	#include "AliT0QAChecker.h"
	52
	53	ClassImp(AliT0QAChecker)
	54
4e67e173	55	//__________________________________________________________________
a42ceb0e	56	void AliT0QAChecker::Check(Double_t * test, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /recoParam/)
3685c21c	57	{
	58
	59	// Super-basic check on the QA histograms on the input list:
	60	// look whether they are empty!
a42ceb0e	61
394c1a6d	62	char * detOCDBDir = Form("T0/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ;
8825d145	63
394c1a6d	64	AliCDBEntry *QARefRec = AliQAManager::QAManager()->Get(detOCDBDir);
	65	// QARefRec->Dump();
	66	if( !QARefRec){
	67	AliInfo("QA reference data NOT retrieved for Reconstruction check. No T0 reference distribution");
	68	}
8825d145	69
394c1a6d	70	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
57acd2d2	71	test[specie] = 10.0 ;
c724dd64	72
332b9234	73	Double_t nent[500];
332b9234	74	TString hname[500];
5ed41460	75	const char *cname;
332b9234	76	memset(nent,0,500*sizeof(Double_t));
	77	Double_t w[500];
	78	memset(w,1,500*sizeof(Double_t));
0d849919	79	TH2 *fhRecDiff[3];
332b9234	80	TH1 *fhRawEff[500];
8825d145	81	TH2 *fhRawTime[500];
57acd2d2	82	TH1 *fhESD[2];
8825d145	83	TH2 *fhHits[10];
57acd2d2	84
57acd2d2	85	for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
4e25ac79	86	// TString dataType = AliQAv1::GetAliTaskName(index);
57acd2d2	87	if (list[specie]->GetEntries() == 0){
	88	test[specie] = 1. ; // nothing to check
	89	}
	90	else {
8825d145	91	TH1 * hdata ;
	92	TH2 * h ;
	93	for (Int_t ir=0; ir<list[specie]->GetEntries(); ir++) {
	94
	95	//hits
	96
	97	if(index == AliQAv1::kSIM && AliQAv1::GetTaskName(AliQAv1::kHITS)){
	98	h = (TH2*) list[specie]->UncheckedAt(ir);
	99	cname = h->GetName();
	100	hname[ir] = cname;
	101	fhHits[ir] = h;
	102	}
	103
	104	//raw
	105	if(index == AliQAv1::kRAW ){
332b9234	106	if(ir > 204 && ir<208 ) {
332b9234	107	hdata = (TH1*) list[specie]->UncheckedAt(ir);
332b9234	108	if(hdata) {
332b9234	109	cname = hdata->GetName();
57acd2d2	110	hname[ir] = cname;
332b9234	111	fhRawEff[ir] = hdata;
57acd2d2	112	}
57acd2d2	113	}
352f9267	114	if((ir>207 && ir<210) && specie == AliRecoParam::kCalib) {
8825d145	115	h = (TH2*) list[specie]->UncheckedAt(ir);
	116	if(h) {
	117	cname = h->GetName();
	118	hname[ir] = cname;
	119	fhRawTime[ir] = h;
	120	AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s ",ir, hname[ir].Data()) );
	121	}
	122	}
	123	}
57acd2d2	124	//rec
8825d145	125	if(index == AliQAv1::kREC){
57acd2d2	126	h = (TH2*) list[specie]->UncheckedAt(ir);
	127	if(h) {
	128	cname = h->GetName();
	129	hname[ir] = cname;
394c1a6d	130	fhRecDiff[ir] = h;
57acd2d2	131	}
	132	}
	133	//esd
8825d145	134	if(index == AliQAv1::kESD){
57acd2d2	135	hdata = (TH1*) list[specie]->UncheckedAt(ir);
	136	if(hdata){
	137	fhESD[ir] = hdata;
5379c4a3	138	AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s ",ir, hname[ir].Data()) );
57acd2d2	139	}
0d849919	140	}
57acd2d2	141	}
394c1a6d	142
394c1a6d	143
8825d145	144
	145	//raw data
	146
352f9267	147	if (index == AliQAv1::kRAW && specie == AliRecoParam::kCalib){
8825d145	148	test[specie] = CheckRaw(list[specie],dynamic_cast<TObjArray>(dynamic_cast<TList >(QARefRec->GetObject())->First()));
8825d145	149	}
394c1a6d	150
8825d145	151	if(index == AliQAv1::kREC){
57acd2d2	152	//rec points
	153	for (Int_t icase=0; icase<2; icase++) {
	154	for (Int_t idet=0; idet<24; idet++) {
	155	Double_t mean = fhRecDiff[icase]->
	156	ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
	157	idet,idet+1)->GetMean();
	158	Double_t rms= fhRecDiff[icase]->
	159	ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
	160	idet,idet+1)->GetRMS();
5379c4a3	161	AliDebug(AliQAv1::GetQADebugLevel(), Form("name %s icase %i idet %i mean %f, rms %f\n",
57acd2d2	162	fhRecDiff[icase]->GetName(), icase, idet, mean,rms));
0d849919	163
57acd2d2	164	if(TMath::Abs(mean) >1.5 \|\| rms >1){
5379c4a3	165	AliDebug(AliQAv1::GetQADebugLevel(), Form(" calibration is nor perfect; test=%f", test)) ;
57acd2d2	166	test[specie]=0.25;
	167	}
	168	if(mean>3 \|\| rms >5) {
	169	test[specie] = 0.1;
5379c4a3	170	AliDebug(AliQAv1::GetQADebugLevel(), Form(" wrong calibration test=%f", test[specie])) ;
57acd2d2	171	}
	172	}
	173	}
3685c21c	174	}
8825d145	175	if (index == AliQAv1::kESD) {
57acd2d2	176	//ESD
	177	for (Int_t icase=0; icase<2; icase++) {
	178	Double_t rmsVertex = fhESD[icase]->GetRMS();
	179	Double_t meanVertex = fhESD[icase]->GetMean();
	180	test[specie]=1;
5379c4a3	181	AliDebug(AliQAv1::GetQADebugLevel(), Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
57acd2d2	182	if (TMath::Abs(rmsVertex)>3) {
57acd2d2	183	test[specie]=0.25;
5379c4a3	184	AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position resolution not good , rms= %f test=%f",
57acd2d2	185	rmsVertex, test[specie])) ;
	186	}
	187	if (TMath::Abs(meanVertex)>3) {
	188	test[specie]=0.25;
5379c4a3	189	AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position bad calibrated , Mean= %f test=%f",
57acd2d2	190	meanVertex, test[specie])) ;
	191	}
	192	}
	193	}
	194	} // if (list->GetEntries() != 0
5379c4a3	195	AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test[specie])) ;
57acd2d2	196	}
3685c21c	197	}
5ed41460	198
394c1a6d	199	//--------------------------------------------------------------------------
8825d145	200	Double_t AliT0QAChecker::CheckRaw(TObjArray listrec , TObjArray listref) const
394c1a6d	201	{
394c1a6d	202
eedcd663	203	//TH1 *fhRawEff;
eedcd663	204	//TH1 *fhRawRef;
8825d145	205	TH2 *fhRawRec2d;
	206	TH2 *fhTime;
	207
	208	TIter next(listref) ;
eedcd663	209	//Int_t counter=0;
8825d145	210	Float_t refmean[50][25];
8825d145	211	Float_t refrms[50][25];
394c1a6d	212	Float_t checkr = 0;
394c1a6d	213
eedcd663	214	//Int_t nref = listref->GetEntries();
eedcd663	215	//Int_t nrec = listrec->GetEntries();
8825d145	216
	217	for (Int_t iii=4; iii<6; iii++){
	218	fhRawRec2d =(TH2*) listref->At(iii);
	219	for (Int_t idet=1; idet<25; idet++) {
	220
	221	refmean[iii-4][idet] = fhRawRec2d->
	222	ProjectionY(Form("%s_py_%i_%i", fhRawRec2d ->GetName(), idet,iii-4),
	223	idet,idet+1)->GetMean();
	224
	225	refrms[iii-4][idet] = fhRawRec2d->
	226	ProjectionY(Form("%s_py%i_%i",
	227	fhRawRec2d ->GetName(), idet,iii-4),
	228	idet,idet+1)->GetRMS();
	229
	230	}
394c1a6d	231	}
8825d145	232
332b9234	233
8825d145	234	TString nameDev[2] = {"CDF", "LED"};
	235	for (Int_t icase=208; icase<210; icase++) {
	236	fhTime = (TH2*) listrec->At(icase);
	237	for (Int_t idet=1; idet<25; idet++) {
	238	Double_t binmean = fhTime->
eedcd663	239	ProjectionY(Form("%s_py_%i_%i", fhTime ->GetName(), idet,icase),
8825d145	240	idet,idet+1)->GetMean();
eedcd663	241	// Double_t rms= fhTime ->ProjectionY(Form("%s_py%i_%i",
	242	// fhTime ->GetName(), idet,icase),
	243	// idet,idet+1)->GetRMS();
8825d145	244	Double_t diffmean = binmean-refmean[icase-208][idet];
	245
	246	if (TMath::Abs(diffmean) < 2 ) {
394c1a6d	247	checkr = 1;
8825d145	248	// printf(" Laser calibration signal sits on its place %f for PMT %s %i : check = %f\n", diffmean, nameDev[icase-208].Data() ,idet, checkr);
394c1a6d	249	AliDebug(AliQAv1::GetQADebugLevel(),
8825d145	250	Form(" Laser calibration signal sits on its place %f for PMT %s %i : check = %f\n", diffmean, nameDev[icase-208].Data(),idet, checkr)) ;
	251	}
	252	if (TMath::Abs(diffmean) <= 5 && TMath::Abs(diffmean) >= 2 ){
	253	checkr = 0.5;
	254	// printf(" Laser calibration signal shifted by %f ps for PMT %s %i : check = %f\n", diffmean*24.4, nameDev[icase-208].Data(),idet, checkr);
	255	AliDebug(AliQAv1::GetQADebugLevel(),
eedcd663	256	Form(" Laser calibration signal shifted by %f ps (%f channels) for PMT %s %i : check = %f\n", diffmean*24.4 ,diffmean , nameDev[icase-208].Data(),idet, checkr)) ;
8825d145	257	}
	258	if (TMath::Abs(diffmean) > 5) {
	259	checkr = 0.25;
	260	// printf(" Big problems :laser calibration signal shifted by %f ps (%f channels) for PMT %s %i : check = %f\n", diffmean*24.4, diffmean, nameDev[icase-208].Data(),idet, checkr);
	261	AliDebug(AliQAv1::GetQADebugLevel(),
	262	Form(" Big problems :laser calibration signal shifted by %f ps (%f channels) for PMT %s %i : check = %i\n", diffmean*24.4, diffmean, nameDev[icase-208].Data(),idet, checkr)) ;
	263
394c1a6d	264	}
394c1a6d	265
394c1a6d	266	}
8825d145	267	}
394c1a6d	268
394c1a6d	269	return checkr;
	270	}
	271