[u/mrichter/AliRoot.git] / PHOS / testsimglobal.C

// Root
#include "TH2.h"
#include "TH1.h"
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"
#include "TClonesArray.h"
#include "TCanvas.h"
#include "TSystem.h"
#include "TString.h"
#include "TF1.h"
#include "TFormula.h"
#include "TFolder.h"
#include "TStopwatch.h"
#include "TObjArray.h"

//AliRoot
#include "AliPHOSHit.h"
#include "AliPHOSGetter.h"
#include "AliPHOSGeometry.h"
#include "AliPHOSDigit.h"
#include "AliPHOSSDigitizer.h"
#include "AliPHOSDigitizer.h"
#include "AliPHOSClusterizer.h"
#include "AliPHOSClusterizerv1.h"
#include "AliPHOSTrackSegmentMaker.h"
#include "AliPHOSTrackSegmentMakerv1.h"
#include "AliPHOSPID.h"
#include "AliPHOSPIDv1.h"

Bool_t sim_exam() ;
Bool_t sdigit() ;
Bool_t digit() ;
Bool_t recpoint() ;
Bool_t track() ;
Bool_t particle() ;
void write_info(TString) ;


//____________________________________________________________________________ 
void testsimglobal() 
{
  
  gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I.");
  Bool_t error = kFALSE ;
  TString mess("") ;
  
  if ( sim_exam() ){
    mess = "Examination ended successfully." ;
    write_info(mess) ;
  }
  else
    error = kTRUE ;
  
  if (!error){
    mess = "Beginning of the PHOS reconstruction."  ;
    write_info(mess) ;
    if(sdigit()){
      mess = "SDigits process ended successfully."  ;
      write_info(mess) ;
    }
    else
      error = kTRUE ;
  }
  
  if (!error){
    if (digit()){
      mess = "Digits process ended successfully."  ;
      write_info(mess) ;
    }
    else
      error = kTRUE ;
  }
  
  if (!error){
    if (recpoint()){
      mess = "Cluster process ended successfully."  ;
      write_info(mess) ;
    }
    else
      error = kTRUE ;
  }
  
  if (!error){
    if (track()){
      mess = "TrackSegments process ended successfully."  ;
      write_info(mess) ;
    }
    else
      error = kTRUE ;
  }
  
  if (!error){
    if (particle()){
      mess = "RecParticles process ended successfully."  ;
      write_info(mess) ;
    }
    else
      error = kTRUE ;
  }
  
  if(!error){
    mess = "reconstruction ended successfully."  ;
    write_info(mess) ;
  }
  else {
    gSystem->Exec("uuencode $ALICE_ROOT/PHOS/testPHOS.root testPHOS.root | mail -s 'PHOS INSTALLATION ERROR' schutz@in2p3.fr") ;
    mess = "Error message to PHOS director has been sent, please wait for his answer before launching the whole simulation again."  ;
    write_info(mess) ;
  }
}


//____________________________________________________________________________ 
Bool_t sim_exam()
{
  
  // Definition of the alarm bounds for the examination
  const Float_t maxAlaHitsM = 12.79  ;  // total multiplicity
  const Float_t maxAlaTotEn = 19.34  ;    // total energy
  const Float_t maxAlaTotEnB = 18.35 ;     // per block multiplicity
  const Float_t maxAlaHitsMB = 11.1  ;  // per block energy
  
  TString mess("") ;

  mess = "Beginning of the simulation examination." ;
  write_info(mess) ;
  
  // define the array in which the events that have not reach th EMCA will be put.
  Bool_t error = kFALSE ;
  
  TStopwatch timer ;
  timer.Start() ;
   
  // Get the number of events generated in the simulation
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
  Int_t maxevent = gime->MaxEvent() ;
  gime->Event(0,"Q") ;
  
  // Examine the alarms
  TObjArray * alahm = dynamic_cast<TObjArray*>(dynamic_cast<TFolder*>(gime->Alarms())->FindObject("HitsM")) ;
  Float_t ratiohm = 100.0*static_cast<Float_t>(alahm->GetEntries())/static_cast<Float_t>(maxevent) ;
  
  TObjArray * alaet = dynamic_cast<TObjArray*>(gime->Alarms()->FindObject("TotEn")) ;
  Float_t ratioet = 100.0*static_cast<Float_t>(alaet->GetEntries())/static_cast<Float_t>(maxevent) ;
  
  // Define the alarms per block and examine them
  char namemul[80], namen[80] ;
  TObjArray* alahmb[5] ;
  TObjArray* alaenb[5] ;
  Float_t ratiohmb[5], ratioenb[5] ;
  
  Int_t i = 0 ;
  for (i = 0 ; i < 5 ; i++){
    sprintf(namemul,"HitsMB%d",i+1) ;
    sprintf(namen,"TotEnB%d",i+1) ;
    alahmb[i]   = (TObjArray*) (gime->Alarms()->FindObject(namemul)) ;
    ratiohmb[i] = 100.0*(Float_t)alahmb[i]->GetEntries()/(Float_t)maxevent ;
    alaenb[i]   = (TObjArray*)(gime->Alarms()->FindObject(namen)) ;
    ratioenb[i] = 100.0*(Float_t)alaenb[i]->GetEntries()/(Float_t)maxevent ;
    
    if (ratiohmb[i] > maxAlaHitsMB){
      error = kTRUE ;
      mess = "Examination detected an error in " + TString(namemul) ;
      write_info(mess) ;
    }
    
    if (ratioenb[i] > maxAlaTotEnB) {
      error = kTRUE ;
      mess = "Examination detected an error in " + TString(namen)  ;
      write_info(mess) ;
    }
  }
  
  
  timer.Stop() ;
  timer.Print() ;
  
  
  if (ratiohm > maxAlaHitsM){
    error = kTRUE ;
    mess = "Examination detected an error in HitsM: "; 
    mess += ratiohm ; 
    mess += " > " ; 
    mess += maxAlaHitsM ;  
    write_info(mess) ;
  }
  
  if (ratioet>maxAlaTotEn){
    error = kTRUE ;
    mess = "Examination detected an error in TotEn: ";
    mess += ratioet;
    mess += " > ";
    mess += maxAlaTotEn;
    write_info(mess) ;
  }
  
  // Condition that will launch the general loop that builds the histograms in order to allow a further analysis.
  
  if (!error)
    return kTRUE ;
  else {
    mess = "Examination sets up the file that will be sent to PHOS director (30s)." ;
    write_info(mess) ;
    
    Int_t index = 0 ;
    Int_t nhits = 0 ;
    
    TH1F * his    = new TH1F("Total Multiplicity", "Total Multiplicity in PHOS", 200, 0., 200.) ;
    TH1F * hisnrg = new TH1F("Total Energy", "Total energy in PHOS", 200, 0., 12.) ;
    
    // name and define the different histograms per block involved in the analysis
    
    TClonesArray hisba("TH1F") ;
    TClonesArray hisbanrg("TH1F") ;
    Int_t i = 0 ;
    
    char name[80], title[80] ;
    for (i = 0 ; i < 6 ; i++) {
      sprintf(name,"multiplicity for block %d",i) ;
      sprintf(title,"multiplicity per blocks, block %d",i) ;
      new(hisba[i]) TH1F(name, title, 100, 0., 100.) ;
      
      sprintf(name,"total energy for block %d",i) ;
      sprintf(title,"total energy per block, block %d",i) ;
      new(hisbanrg[i]) TH1F(name, title, 200, 0., 12.) ;
    }
    
    // define the global histograms, the hit pointer and give the means to get the actual block reached by the photon
    
    AliPHOSHit * hit ;
    TH1F * hist ;
    TH1F * histnrg ;
    TH2F * hbiz = new TH2F ("hbiz","hbiz", 200, 0., 200., 200, 0., 12.) ;
    const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
    
    // the very general loop
    
    for (index = 0 ; index < maxevent ; index++) {
      //get the number of the event
      gime->Event(index) ;
      // get the number of cells reached during this event and fill the total multiplicity histogram
      Int_t n = gime->Hits()->GetEntries() ;
      nhits += n ;
      his->Fill(n) ;
      // Get the data per block
      const TClonesArray * hita = static_cast<const TClonesArray *>(gime -> Hits()) ;
      TIter next(hita) ;
      Float_t Et = 0. ;
      Int_t id = 0, block = 0 ;
      Int_t nhit[6], rid[4] ;
      Float_t etblock[6] ;
      Int_t i = 0 ;
      
      for ( i = 0; i < 6 ; i++) {
	nhit[i] = 0 ;
	etblock[i] = 0 ;
      }
      
      while ( (hit = static_cast<AliPHOSHit *>(next())) ) {
	id = hit->GetId() ;
	if  (geom->IsInEMC(id) ) {
	  Et += ( hit -> GetEnergy()) ;
	  geom->AbsToRelNumbering(id,rid) ;
	  block = rid[0] ;
	  nhit[block]++ ;
	  etblock[block] +=  ( hit -> GetEnergy()) ;
	}
      }
      
      //Fill all the histograms but total multiplicity, already done
      hist = static_cast<TH1F*>(hisba.At(block)) ;
      hist->Fill(nhit[block]) ;
      histnrg = static_cast<TH1F*>(hisbanrg.At(block)) ;
      histnrg->Fill(etblock[block]) ;
      hisnrg -> Fill(Et) ;
      hbiz->Fill(n,Et) ;
    }
         
    TFile * file = gROOT -> GetFile("testPHOS.root") ;
    file -> Write() ;
    file->Close() ;
    return kFALSE ;
  }
}


//____________________________________________________________________________ 
Bool_t sdigit()
{
  //SDigits process
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;  
  const Float_t maxSDigits = 62.89 ;
  const Float_t widSDigits = TMath::Sqrt(maxSDigits) ;

  TString mess("") ;
  TString reconame = "test suite" ;
  
  AliPHOSSDigitizer *sd = new AliPHOSSDigitizer("testPHOS.root",reconame.Data()) ;
  
  sd->ExecuteTask("deb") ;
  
  Float_t nSDigits =  static_cast<Float_t>((dynamic_cast<const AliPHOSSDigitizer*>(gime->SDigitizer()))->GetSDigitsInRun()) / static_cast<Float_t>(gime->MaxEvent()) ;
  if ( nSDigits < maxSDigits-widSDigits ||
       nSDigits > maxSDigits+widSDigits ) {
    mess = "Error detected in the SDigits process. Sending error file to PHOS director." ;
    cout <<  "sdigit() : nsDigits = " << nSDigits 
	 << " maxSDigits,widSDigits= " << maxSDigits << "," << widSDigits << endl ;    
    write_info(mess) ;
    return kFALSE ;
  }
  else
    return kTRUE ;
}


//____________________________________________________________________________ 
Bool_t digit()
{
  
  //Digits process
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
  TString reconame = "test suite" ;
  const Float_t maxDigits = 40. ;
  const Float_t widDigits = TMath::Sqrt(maxDigits) ;
  
  TString mess("") ;

  AliPHOSDigitizer *d = new AliPHOSDigitizer("testPHOS.root",reconame.Data()) ;
  
  d->ExecuteTask("deb") ;
  
  Float_t nDigits = static_cast<Float_t>((dynamic_cast<const AliPHOSDigitizer*>(gime->Digitizer()))->GetDigitsInRun()) / static_cast<Float_t>(gime->MaxEvent()) ;
  
  if ( nDigits < maxDigits-widDigits || nDigits > maxDigits+widDigits ) {
    cout <<  "digit() : nDigits = " << nDigits 
	 << " maxDigits,widDigits= " << maxDigits << "," << widDigits << endl ;    
    mess = "Error detected in the Digits process. Sending error file to PHOS director." ;
    write_info(mess) ;
    return kFALSE ;
  }
  else
    return kTRUE ;
}


//____________________________________________________________________________ 
Bool_t recpoint()
{
  
  //RecPoints process
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
  TString reconame = "test suite" ;
  
  const Float_t maxRecPoints = 1.0 ;
  const Float_t widRecPoints = TMath::Sqrt(maxRecPoints) ;
  
  TString mess("") ;

  AliPHOSClusterizer * cluster = new  AliPHOSClusterizerv1("testPHOS.root", reconame.Data()) ;
  
  cluster->ExecuteTask("deb") ;
  
  Float_t nRecPoints =  static_cast<Float_t>(gime->Clusterizer(reconame.Data())->GetRecPointsInRun()) /
    static_cast<Float_t>(gime->MaxEvent()) ;
  
  if ( nRecPoints < maxRecPoints-widRecPoints
       || nRecPoints > maxRecPoints+widRecPoints ) {
    cout <<  "recpoint() : nRecPoints = " << nRecPoints 
	 << " maxRecPoints,widRecPoints= " << maxRecPoints << "," << widRecPoints << endl ;    
    mess = "Error detected in the Clusterizing process. Sending error file to PHOS director." ;
    write_info(mess) ;
    return kFALSE ;
  }
  else
    return kTRUE ;
}


//____________________________________________________________________________ 
Bool_t track()
{
  
  //TrackSegments process
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
  const Float_t maxTrackSegments = 1 ;

  TString mess("") ;
  TString reconame = "test suite" ;
  
  AliPHOSTrackSegmentMaker * tracks = new AliPHOSTrackSegmentMakerv1("testPHOS.root",reconame.Data()) ;
  
  tracks->ExecuteTask("deb") ;
  
  Float_t nTrackSegments =  static_cast<Float_t> (gime->TrackSegmentMaker(reconame.Data())->GetTrackSegmentsInRun()) /
    static_cast<Float_t>(gime->MaxEvent()) ;
  
  if ( nTrackSegments < maxTrackSegments-0.25 ||
       nTrackSegments > maxTrackSegments+0.25 ) {
    cout <<  "track() : nTrackSegments = " << nTrackSegments
	 << " maxTrackSegments,widTrackSegments= " << maxTrackSegments << "," << "0.25" << endl ;    
    mess = "Error detected in the TrackSegments process. Sending error file to PHOS director." ;
    write_info(mess) ;
    return kFALSE ;
  }
  else
    return kTRUE ;
}


//____________________________________________________________________________ 
Bool_t particle()
{
  
  //RecParticles process
  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
  const Float_t maxRecParticles = 1 ;

  TString mess("") ;
  TString reconame = "test suite" ;
  
  AliPHOSPID * pid = new AliPHOSPIDv1("testPHOS.root",reconame.Data()) ;
  
  pid->ExecuteTask("deb") ;
  
  Float_t nRecParticles =  static_cast<Float_t> (gime->PID(reconame.Data())->GetRecParticlesInRun()) /
    static_cast<Float_t>(gime->MaxEvent()) ;
  
  
  if ( nRecParticles < maxRecParticles-0.25 ||
       nRecParticles > maxRecParticles+0.25 ) {
    cout <<  "particle() : nRecParticles = " << nRecParticles 
	 << " maxRecParticles,widRecParticles= " << maxRecParticles << "," << "0.25" << endl ;    
    mess = "Error detected in the RecParticles process. Sending error file to PHOS director.Stop reconstruction." ;
    write_info(mess) ;
    return kFALSE ;
  }
  else
    return kTRUE ;
}


//____________________________________________________________________________ 
void write_info(TString mess)
{
  cerr << " _____________________________________________________________ " << endl
       << " " << endl
       << "MESS ==> " << mess <<endl
       << " _____________________________________________________________ " <<endl ;
}
Commit	Line	Data
493ef90d	1	// Root
cede0770	2	#include "TH2.h"
	3	#include "TH1.h"
	4	#include "TFile.h"
	5	#include "TTree.h"
	6	#include "TBranch.h"
	7	#include "TClonesArray.h"
	8	#include "TCanvas.h"
	9	#include "TSystem.h"
493ef90d	10	#include "TString.h"
cede0770	11	#include "TF1.h"
	12	#include "TFormula.h"
	13	#include "TFolder.h"
	14	#include "TStopwatch.h"
	15	#include "TObjArray.h"
493ef90d	16
	17	//AliRoot
	18	#include "AliPHOSHit.h"
	19	#include "AliPHOSGetter.h"
cede0770	20	#include "AliPHOSGeometry.h"
	21	#include "AliPHOSDigit.h"
	22	#include "AliPHOSSDigitizer.h"
	23	#include "AliPHOSDigitizer.h"
	24	#include "AliPHOSClusterizer.h"
	25	#include "AliPHOSClusterizerv1.h"
	26	#include "AliPHOSTrackSegmentMaker.h"
	27	#include "AliPHOSTrackSegmentMakerv1.h"
	28	#include "AliPHOSPID.h"
	29	#include "AliPHOSPIDv1.h"
	30
493ef90d	31	Bool_t sim_exam() ;
	32	Bool_t sdigit() ;
	33	Bool_t digit() ;
	34	Bool_t recpoint() ;
	35	Bool_t track() ;
	36	Bool_t particle() ;
	37	void write_info(TString) ;
cede0770	38
493ef90d	39
	40	//____________________________________________________________________________
	41	void testsimglobal()
cede0770	42	{
cede0770	43
94de8339	44	gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I.");
493ef90d	45	Bool_t error = kFALSE ;
	46	TString mess("") ;
	47
	48	if ( sim_exam() ){
	49	mess = "Examination ended successfully." ;
	50	write_info(mess) ;
	51	}
	52	else
	53	error = kTRUE ;
	54
	55	if (!error){
	56	mess = "Beginning of the PHOS reconstruction." ;
	57	write_info(mess) ;
	58	if(sdigit()){
	59	mess = "SDigits process ended successfully." ;
	60	write_info(mess) ;
	61	}
	62	else
	63	error = kTRUE ;
	64	}
	65
	66	if (!error){
	67	if (digit()){
	68	mess = "Digits process ended successfully." ;
	69	write_info(mess) ;
	70	}
	71	else
	72	error = kTRUE ;
	73	}
	74
	75	if (!error){
	76	if (recpoint()){
	77	mess = "Cluster process ended successfully." ;
	78	write_info(mess) ;
	79	}
	80	else
	81	error = kTRUE ;
	82	}
	83
	84	if (!error){
	85	if (track()){
	86	mess = "TrackSegments process ended successfully." ;
	87	write_info(mess) ;
	88	}
	89	else
	90	error = kTRUE ;
	91	}
	92
	93	if (!error){
	94	if (particle()){
	95	mess = "RecParticles process ended successfully." ;
	96	write_info(mess) ;
	97	}
	98	else
	99	error = kTRUE ;
	100	}
	101
	102	if(!error){
	103	mess = "reconstruction ended successfully." ;
	104	write_info(mess) ;
	105	}
	106	else {
69c46d16	107	gSystem->Exec("uuencode $ALICE_ROOT/PHOS/testPHOS.root testPHOS.root \| mail -s 'PHOS INSTALLATION ERROR' schutz@in2p3.fr") ;
493ef90d	108	mess = "Error message to PHOS director has been sent, please wait for his answer before launching the whole simulation again." ;
	109	write_info(mess) ;
	110	}
	111	}
cede0770	112
cede0770	113
493ef90d	114	//____________________________________________________________________________
	115	Bool_t sim_exam()
	116	{
	117
	118	// Definition of the alarm bounds for the examination
	119	const Float_t maxAlaHitsM = 12.79 ; // total multiplicity
94de8339	120	const Float_t maxAlaTotEn = 19.34 ; // total energy
94de8339	121	const Float_t maxAlaTotEnB = 18.35 ; // per block multiplicity
493ef90d	122	const Float_t maxAlaHitsMB = 11.1 ; // per block energy
	123
	124	TString mess("") ;
cede0770	125
493ef90d	126	mess = "Beginning of the simulation examination." ;
	127	write_info(mess) ;
	128
	129	// define the array in which the events that have not reach th EMCA will be put.
	130	Bool_t error = kFALSE ;
	131
	132	TStopwatch timer ;
	133	timer.Start() ;
	134
	135	// Get the number of events generated in the simulation
	136	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
	137	Int_t maxevent = gime->MaxEvent() ;
	138	gime->Event(0,"Q") ;
	139
cede0770	140	// Examine the alarms
607fc376	141	TObjArray * alahm = dynamic_cast<TObjArray>(dynamic_cast<TFolder>(gime->Alarms())->FindObject("HitsM")) ;
493ef90d	142	Float_t ratiohm = 100.0*static_cast<Float_t>(alahm->GetEntries())/static_cast<Float_t>(maxevent) ;
cede0770	143
493ef90d	144	TObjArray * alaet = dynamic_cast<TObjArray*>(gime->Alarms()->FindObject("TotEn")) ;
493ef90d	145	Float_t ratioet = 100.0*static_cast<Float_t>(alaet->GetEntries())/static_cast<Float_t>(maxevent) ;
cede0770	146
493ef90d	147	// Define the alarms per block and examine them
	148	char namemul[80], namen[80] ;
	149	TObjArray* alahmb[5] ;
	150	TObjArray* alaenb[5] ;
	151	Float_t ratiohmb[5], ratioenb[5] ;
	152
	153	Int_t i = 0 ;
	154	for (i = 0 ; i < 5 ; i++){
	155	sprintf(namemul,"HitsMB%d",i+1) ;
	156	sprintf(namen,"TotEnB%d",i+1) ;
	157	alahmb[i] = (TObjArray*) (gime->Alarms()->FindObject(namemul)) ;
	158	ratiohmb[i] = 100.0*(Float_t)alahmb[i]->GetEntries()/(Float_t)maxevent ;
	159	alaenb[i] = (TObjArray*)(gime->Alarms()->FindObject(namen)) ;
	160	ratioenb[i] = 100.0*(Float_t)alaenb[i]->GetEntries()/(Float_t)maxevent ;
	161
	162	if (ratiohmb[i] > maxAlaHitsMB){
	163	error = kTRUE ;
69c46d16	164	mess = "Examination detected an error in " + TString(namemul) ;
493ef90d	165	write_info(mess) ;
	166	}
	167
	168	if (ratioenb[i] > maxAlaTotEnB) {
	169	error = kTRUE ;
69c46d16	170	mess = "Examination detected an error in " + TString(namen) ;
493ef90d	171	write_info(mess) ;
493ef90d	172	}
cede0770	173	}
493ef90d	174
	175
	176	timer.Stop() ;
	177	timer.Print() ;
	178
	179
	180	if (ratiohm > maxAlaHitsM){
	181	error = kTRUE ;
607fc376	182	mess = "Examination detected an error in HitsM: ";
	183	mess += ratiohm ;
	184	mess += " > " ;
	185	mess += maxAlaHitsM ;
493ef90d	186	write_info(mess) ;
	187	}
	188
cede0770	189	if (ratioet>maxAlaTotEn){
493ef90d	190	error = kTRUE ;
8b3d8e88	191	mess = "Examination detected an error in TotEn: ";
	192	mess += ratioet;
	193	mess += " > ";
	194	mess += maxAlaTotEn;
493ef90d	195	write_info(mess) ;
cede0770	196	}
493ef90d	197
cede0770	198	// Condition that will launch the general loop that builds the histograms in order to allow a further analysis.
cede0770	199
493ef90d	200	if (!error)
	201	return kTRUE ;
	202	else {
	203	mess = "Examination sets up the file that will be sent to PHOS director (30s)." ;
	204	write_info(mess) ;
cede0770	205
493ef90d	206	Int_t index = 0 ;
493ef90d	207	Int_t nhits = 0 ;
cede0770	208
493ef90d	209	TH1F * his = new TH1F("Total Multiplicity", "Total Multiplicity in PHOS", 200, 0., 200.) ;
	210	TH1F * hisnrg = new TH1F("Total Energy", "Total energy in PHOS", 200, 0., 12.) ;
	211
	212	// name and define the different histograms per block involved in the analysis
	213
	214	TClonesArray hisba("TH1F") ;
	215	TClonesArray hisbanrg("TH1F") ;
	216	Int_t i = 0 ;
	217
	218	char name[80], title[80] ;
	219	for (i = 0 ; i < 6 ; i++) {
	220	sprintf(name,"multiplicity for block %d",i) ;
	221	sprintf(title,"multiplicity per blocks, block %d",i) ;
	222	new(hisba[i]) TH1F(name, title, 100, 0., 100.) ;
cede0770	223
493ef90d	224	sprintf(name,"total energy for block %d",i) ;
	225	sprintf(title,"total energy per block, block %d",i) ;
	226	new(hisbanrg[i]) TH1F(name, title, 200, 0., 12.) ;
	227	}
	228
	229	// define the global histograms, the hit pointer and give the means to get the actual block reached by the photon
	230
	231	AliPHOSHit * hit ;
	232	TH1F * hist ;
	233	TH1F * histnrg ;
	234	TH2F * hbiz = new TH2F ("hbiz","hbiz", 200, 0., 200., 200, 0., 12.) ;
	235	const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
	236
	237	// the very general loop
	238
	239	for (index = 0 ; index < maxevent ; index++) {
	240	//get the number of the event
	241	gime->Event(index) ;
	242	// get the number of cells reached during this event and fill the total multiplicity histogram
	243	Int_t n = gime->Hits()->GetEntries() ;
	244	nhits += n ;
	245	his->Fill(n) ;
	246	// Get the data per block
75236460	247	const TClonesArray * hita = static_cast<const TClonesArray *>(gime -> Hits()) ;
493ef90d	248	TIter next(hita) ;
	249	Float_t Et = 0. ;
	250	Int_t id = 0, block = 0 ;
	251	Int_t nhit[6], rid[4] ;
	252	Float_t etblock[6] ;
	253	Int_t i = 0 ;
cede0770	254
493ef90d	255	for ( i = 0; i < 6 ; i++) {
	256	nhit[i] = 0 ;
	257	etblock[i] = 0 ;
	258	}
	259
	260	while ( (hit = static_cast<AliPHOSHit *>(next())) ) {
	261	id = hit->GetId() ;
	262	if (geom->IsInEMC(id) ) {
	263	Et += ( hit -> GetEnergy()) ;
	264	geom->AbsToRelNumbering(id,rid) ;
	265	block = rid[0] ;
	266	nhit[block]++ ;
	267	etblock[block] += ( hit -> GetEnergy()) ;
	268	}
	269	}
	270
	271	//Fill all the histograms but total multiplicity, already done
	272	hist = static_cast<TH1F*>(hisba.At(block)) ;
	273	hist->Fill(nhit[block]) ;
	274	histnrg = static_cast<TH1F*>(hisbanrg.At(block)) ;
	275	histnrg->Fill(etblock[block]) ;
	276	hisnrg -> Fill(Et) ;
	277	hbiz->Fill(n,Et) ;
cede0770	278	}
493ef90d	279
	280	TFile * file = gROOT -> GetFile("testPHOS.root") ;
	281	file -> Write() ;
	282	file->Close() ;
	283	return kFALSE ;
	284	}
	285	}
cede0770	286
cede0770	287
493ef90d	288	//____________________________________________________________________________
	289	Bool_t sdigit()
	290	{
	291	//SDigits process
607fc376	292	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
cede0770	293	const Float_t maxSDigits = 62.89 ;
cede0770	294	const Float_t widSDigits = TMath::Sqrt(maxSDigits) ;
493ef90d	295
	296	TString mess("") ;
	297	TString reconame = "test suite" ;
	298
	299	AliPHOSSDigitizer *sd = new AliPHOSSDigitizer("testPHOS.root",reconame.Data()) ;
493ef90d	300
	301	sd->ExecuteTask("deb") ;
	302
8b3d8e88	303	Float_t nSDigits = static_cast<Float_t>((dynamic_cast<const AliPHOSSDigitizer*>(gime->SDigitizer()))->GetSDigitsInRun()) / static_cast<Float_t>(gime->MaxEvent()) ;
493ef90d	304	if ( nSDigits < maxSDigits-widSDigits \|\|
	305	nSDigits > maxSDigits+widSDigits ) {
	306	mess = "Error detected in the SDigits process. Sending error file to PHOS director." ;
25b01074	307	cout << "sdigit() : nsDigits = " << nSDigits
25b01074	308	<< " maxSDigits,widSDigits= " << maxSDigits << "," << widSDigits << endl ;
493ef90d	309	write_info(mess) ;
	310	return kFALSE ;
	311	}
	312	else
	313	return kTRUE ;
	314	}
	315
	316
	317	//____________________________________________________________________________
	318	Bool_t digit()
	319	{
	320
	321	//Digits process
	322	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
	323	TString reconame = "test suite" ;
607fc376	324	const Float_t maxDigits = 40. ;
cede0770	325	const Float_t widDigits = TMath::Sqrt(maxDigits) ;
493ef90d	326
	327	TString mess("") ;
	328
	329	AliPHOSDigitizer *d = new AliPHOSDigitizer("testPHOS.root",reconame.Data()) ;
	330
	331	d->ExecuteTask("deb") ;
	332
8b3d8e88	333	Float_t nDigits = static_cast<Float_t>((dynamic_cast<const AliPHOSDigitizer*>(gime->Digitizer()))->GetDigitsInRun()) / static_cast<Float_t>(gime->MaxEvent()) ;
493ef90d	334
493ef90d	335	if ( nDigits < maxDigits-widDigits \|\| nDigits > maxDigits+widDigits ) {
25b01074	336	cout << "digit() : nDigits = " << nDigits
25b01074	337	<< " maxDigits,widDigits= " << maxDigits << "," << widDigits << endl ;
493ef90d	338	mess = "Error detected in the Digits process. Sending error file to PHOS director." ;
	339	write_info(mess) ;
	340	return kFALSE ;
cede0770	341	}
493ef90d	342	else
	343	return kTRUE ;
	344	}
cede0770	345
cede0770	346
493ef90d	347	//____________________________________________________________________________
	348	Bool_t recpoint()
	349	{
	350
	351	//RecPoints process
	352	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
	353	TString reconame = "test suite" ;
	354
94de8339	355	const Float_t maxRecPoints = 1.0 ;
493ef90d	356	const Float_t widRecPoints = TMath::Sqrt(maxRecPoints) ;
	357
	358	TString mess("") ;
cede0770	359
493ef90d	360	AliPHOSClusterizer * cluster = new AliPHOSClusterizerv1("testPHOS.root", reconame.Data()) ;
	361
	362	cluster->ExecuteTask("deb") ;
	363
	364	Float_t nRecPoints = static_cast<Float_t>(gime->Clusterizer(reconame.Data())->GetRecPointsInRun()) /
	365	static_cast<Float_t>(gime->MaxEvent()) ;
	366
	367	if ( nRecPoints < maxRecPoints-widRecPoints
	368	\|\| nRecPoints > maxRecPoints+widRecPoints ) {
25b01074	369	cout << "recpoint() : nRecPoints = " << nRecPoints
25b01074	370	<< " maxRecPoints,widRecPoints= " << maxRecPoints << "," << widRecPoints << endl ;
493ef90d	371	mess = "Error detected in the Clusterizing process. Sending error file to PHOS director." ;
	372	write_info(mess) ;
	373	return kFALSE ;
	374	}
	375	else
	376	return kTRUE ;
	377	}
cede0770	378
cede0770	379
493ef90d	380	//____________________________________________________________________________
	381	Bool_t track()
	382	{
	383
	384	//TrackSegments process
	385	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
	386	const Float_t maxTrackSegments = 1 ;
	387
	388	TString mess("") ;
	389	TString reconame = "test suite" ;
	390
	391	AliPHOSTrackSegmentMaker * tracks = new AliPHOSTrackSegmentMakerv1("testPHOS.root",reconame.Data()) ;
	392
	393	tracks->ExecuteTask("deb") ;
cede0770	394
493ef90d	395	Float_t nTrackSegments = static_cast<Float_t> (gime->TrackSegmentMaker(reconame.Data())->GetTrackSegmentsInRun()) /
	396	static_cast<Float_t>(gime->MaxEvent()) ;
	397
	398	if ( nTrackSegments < maxTrackSegments-0.25 \|\|
	399	nTrackSegments > maxTrackSegments+0.25 ) {
25b01074	400	cout << "track() : nTrackSegments = " << nTrackSegments
25b01074	401	<< " maxTrackSegments,widTrackSegments= " << maxTrackSegments << "," << "0.25" << endl ;
493ef90d	402	mess = "Error detected in the TrackSegments process. Sending error file to PHOS director." ;
	403	write_info(mess) ;
	404	return kFALSE ;
cede0770	405	}
493ef90d	406	else
	407	return kTRUE ;
	408	}
	409
	410
	411	//____________________________________________________________________________
	412	Bool_t particle()
	413	{
cede0770	414
493ef90d	415	//RecParticles process
	416	AliPHOSGetter * gime = AliPHOSGetter::GetInstance("testPHOS.root") ;
	417	const Float_t maxRecParticles = 1 ;
cede0770	418
493ef90d	419	TString mess("") ;
	420	TString reconame = "test suite" ;
	421
	422	AliPHOSPID * pid = new AliPHOSPIDv1("testPHOS.root",reconame.Data()) ;
	423
	424	pid->ExecuteTask("deb") ;
	425
	426	Float_t nRecParticles = static_cast<Float_t> (gime->PID(reconame.Data())->GetRecParticlesInRun()) /
	427	static_cast<Float_t>(gime->MaxEvent()) ;
	428
	429
	430	if ( nRecParticles < maxRecParticles-0.25 \|\|
	431	nRecParticles > maxRecParticles+0.25 ) {
25b01074	432	cout << "particle() : nRecParticles = " << nRecParticles
9e9b9801	433	<< " maxRecParticles,widRecParticles= " << maxRecParticles << "," << "0.25" << endl ;
493ef90d	434	mess = "Error detected in the RecParticles process. Sending error file to PHOS director.Stop reconstruction." ;
	435	write_info(mess) ;
	436	return kFALSE ;
cede0770	437	}
493ef90d	438	else
493ef90d	439	return kTRUE ;
cede0770	440	}
493ef90d	441
	442
	443	//____________________________________________________________________________
	444	void write_info(TString mess)
	445	{
	446	cerr << " _____________________________________________________________ " << endl
	447	<< " " << endl
	448	<< "MESS ==> " << mess <<endl
	449	<< " _____________________________________________________________ " <<endl ;
	450	}
	451