[u/mrichter/AliRoot.git] / HMPID / AliHMPIDSelector.C

#include <TF1.h>
#include <TH2F.h>
#include <TCanvas.h>  //Terminate()
#include <TChain.h>
#include <TBenchmark.h>
#include <TFile.h>    //docosmic()    
#include <fstream>    //caf()      
#include <TProof.h>   //caf()
#include <AliSelector.h>      //base class
#include <AliESD.h>           
#include <AliBitPacking.h> //HmpidPayload()
#include "AliHMPIDDigit.h" 
#include "AliHMPIDCluster.h" 
#include "AliHMPIDReconstructor.h" //docosmic()

class AliHMPIDSelector : public AliSelector {
 public :
           AliHMPIDSelector():AliSelector(),fChain(0),fEsd(0),fCkovP(0),fMipXY(0),fDifXY(0),fSigP(0) {for(Int_t i=0;i<5;i++) fProb[i]=0;}
  virtual ~AliHMPIDSelector()                                                                      {delete fEsd;}


  virtual Int_t   Version        () const {return 2;}
  virtual void    Begin          (TTree *) {}
  virtual void    SlaveBegin     (TTree *tree);
  virtual void    Init           (TTree *tree);
  virtual Bool_t  Notify         ()    {return kTRUE;}
  virtual Bool_t  Process        (Long64_t entry);
  virtual void    SetOption      (const char *option) { fOption = option; }
  virtual void    SetObject      (TObject *obj) { fObject = obj; }
  virtual void    SetInputList   (TList *input) {fInput = input;}
  virtual TList  *GetOutputList  () const { return fOutput; }
  virtual void    SlaveTerminate ();
  virtual void    Terminate      ();

 private: 
  TTree          *fChain ;   //!pointer to the analyzed TTree or TChain
  AliESD         *fEsd ;     //!

  TH2F           *fCkovP,*fMipXY,*fDifXY,*fSigP; //!
  TH1F           *fProb[5];                      //!

  ClassDef(AliHMPIDSelector,0);  
};


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDSelector::SlaveBegin(TTree *tree)
{
// The SlaveBegin() function is called after the Begin() function.  When running with PROOF SlaveBegin() is called on each slave server.
// The tree argument is deprecated (on PROOF 0 is passed).

   Init(tree);

   TString option = GetOption();

   // create histograms on each slave server
   fCkovP    = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]", 150,   0,  7  ,100, -3, 1); 
   fSigP     = new TH2F("SigP"  ,"#sigma_{#theta_c}"          , 150,   0,  7  ,100, 0, 1e20);
   fMipXY    = new TH2F("MipXY" ,"mip position"               , 260,   0,130  ,252,0,126); 
   fDifXY    = new TH2F("DifXY" ,"diff"                       , 260, -10, 10  ,252,-10,10); 

   fProb[0] = new TH1F("PidE" ,"PID: e yellow #mu magenta"  ,100,0,1); fProb[0]->SetLineColor(kYellow);
   fProb[1] = new TH1F("PidMu","pid of #mu"                 ,100,0,1); fProb[1]->SetLineColor(kMagenta);
   fProb[2] = new TH1F("PidPi","PID: #pi red K green p blue",100,0,1); fProb[2]->SetLineColor(kRed);
   fProb[3] = new TH1F("PidK" ,"pid of K"                   ,100,0,1); fProb[3]->SetLineColor(kGreen);
   fProb[4] = new TH1F("PidP" ,"pid of p"                   ,100,0,1); fProb[4]->SetLineColor(kBlue);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDSelector::Init(TTree *pTr)
{
// Called when the selector needs to initialize a new tree of chain. Typically here the branch addresses of the tree is set
// Init() will be called many times when running with PROOF.

  if ( !pTr )  return ;
  fChain = pTr ;
  fChain->SetBranchAddress("ESD", &fEsd) ;
  fChain->SetBranchStatus("*", 0);
  fChain->SetBranchStatus("fTracks.*", 1);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Bool_t AliHMPIDSelector::Process(Long64_t entry)
{

  fChain->GetTree()->GetEntry(entry);

  for(Int_t iTrk=0;iTrk<fEsd->GetNumberOfTracks();iTrk++){
     AliESDtrack *pTrk=fEsd->GetTrack(iTrk);
     
//     if(pTrk->GetHMPIDsignal()<0) continue;
     
     fCkovP->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal()) ; 
     fSigP ->Fill(pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
     
//   Float_t xm,ym; Int_t q,np;  pTrk->GetHMPIDmip(xm,ym,q,np);  fMipXY->Fill(xm,ym); //mip info
//   Float_t xd,yd,th,ph;        pTrk->GetHMPIDtrk(xd,yd,th,ph); fDifXY->Fill(xd,yd); //track info 
     
     Double_t pid[5];  pTrk->GetHMPIDpid(pid); for(Int_t i =0;i<5;i++) fProb[i]->Fill(pid[i]);
  }//tracks loop 
     
  return kTRUE;
}//Process()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDSelector::SlaveTerminate()
{
  // The SlaveTerminate() function is called after all entries or objects
  // have been processed. When running with PROOF SlaveTerminate() is called
  // on each slave server.
  
  // Add the histograms to the output on each slave server
  
  fOutput->Add(fCkovP);
  fOutput->Add(fSigP); 
  fOutput->Add(fMipXY);
  fOutput->Add(fDifXY);
  
  for(Int_t i=0;i<5;i++) fOutput->Add(fProb[i]);
}//SlaveTerminate()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDSelector::Terminate()
{
// The last function to be called. It always runs on the client, it can be used to present
// the results graphically or save the results to file.
  fCkovP   = dynamic_cast<TH2F*>(fOutput->FindObject("CkovP")) ;
  fSigP    = dynamic_cast<TH2F*>(fOutput->FindObject("SigP")) ; 
  fMipXY   = dynamic_cast<TH2F*>(fOutput->FindObject("MipXY")) ;
  fDifXY   = dynamic_cast<TH2F*>(fOutput->FindObject("DifXY")) ;
  
  fProb[0] = dynamic_cast<TH1F*>(fOutput->FindObject("PidE")) ;
  fProb[1] = dynamic_cast<TH1F*>(fOutput->FindObject("PidMu")) ;
  fProb[2] = dynamic_cast<TH1F*>(fOutput->FindObject("PidPi")) ;
  fProb[3] = dynamic_cast<TH1F*>(fOutput->FindObject("PidK")) ;
  fProb[4] = dynamic_cast<TH1F*>(fOutput->FindObject("PidP")) ;

  Float_t n=1.292; //mean freon ref idx 
  TF1 *pPi=new TF1("RiPiTheo","acos(sqrt(x*x+[0]*[0])/(x*[1]))",1.2,7); pPi->SetLineWidth(1); pPi->SetParameter(1,n); 
  AliPID ppp;                 pPi->SetLineColor(kRed);   pPi->SetParameter(0,AliPID::ParticleMass(AliPID::kPion));    //mass
  TF1 *pK=(TF1*)pPi->Clone(); pK ->SetLineColor(kGreen); pK ->SetParameter(0,AliPID::ParticleMass(AliPID::kKaon)); 
  TF1 *pP=(TF1*)pPi->Clone(); pP ->SetLineColor(kBlue);  pP ->SetParameter(0,AliPID::ParticleMass(AliPID::kProton)); 

  TCanvas *pC=new TCanvas("c1","ESD QA");pC->SetFillColor(10); pC->SetHighLightColor(10); pC->Divide(3,2);
  pC->cd(1); fCkovP->Draw(); pPi->Draw("same"); pK->Draw("same"); pP->Draw("same");   pC->cd(2); fMipXY->Draw();   pC->cd(3); fProb[0]->Draw(); fProb[1]->Draw("same"); 
  pC->cd(4); fSigP ->Draw();                                                          pC->cd(5); fDifXY->Draw();   pC->cd(6); fProb[2]->Draw(); fProb[3]->Draw("same"); fProb[4]->Draw("same"); 
}//Terminate()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void loc()
{
  TChain* pChain =new TChain("esdTree");  pChain->Add("AliESDs.root");

  pChain->Process("AliHMPIDSelector.C+");	
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void caf()
{
  gBenchmark->Start("PRooF exec");
  TChain* pChain =new TChain("esdTree");
  
  ifstream list; list.open("list.txt");

  TString file;
  while(list.good()) {
    list>>file;
    if (!file.Contains("root")) continue; //it's wrong file name
    pChain->Add(file.Data());
  }
  list.close();
  
  pChain->GetListOfFiles()->Print();
  
  TVirtualProof *pProof=TProof::Open("kir@lxb6046.cern.ch");	
  pProof->UploadPackage("ESD.par");
  pProof->EnablePackage("ESD");
  
  pChain->SetProof(pProof);
  pChain->Process("AliHMPIDSelector.C+");
  
  gBenchmark->Show("PRooF exec");
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Int_t DateHeader(ifstream *pFile,Bool_t isPrint=0)
{
  Int_t iSize=-1;
  pFile->read((char*)&iSize,4);
  if(!isPrint)     
    pFile->seekg(16*4,ios::cur);
  else{
    Int_t w32=-1; 
                                Printf("");
                                Printf("Event size        %i bytes",iSize);                           //1  common DATE header 17 words
    pFile->read((char*)&w32,4); Printf("Event magic       0x%x"    ,w32);                             //2
    pFile->read((char*)&w32,4); Printf("Event head size   %i bytes",w32);                             //3  
    pFile->read((char*)&w32,4); Printf("Event version     0x%x"    ,w32);                             //4
    pFile->read((char*)&w32,4); Printf("Event type        %i (%s)" ,w32,(w32==7)? "physics":"SOR");   //5 
    pFile->read((char*)&w32,4); Printf("Run number        %i"      ,w32);                             //6
  
    pFile->read((char*)&w32,4); Printf("Event ID 1        %i"      ,w32);                             //7
    pFile->read((char*)&w32,4); Printf("Event ID 2        %i"      ,w32);                             //8
  
    pFile->read((char*)&w32,4); Printf("Trigger pattern 1 %i"      ,w32);                             //9
    pFile->read((char*)&w32,4); Printf("Trigger pattern 2 %i"      ,w32);                             //10
  
    pFile->read((char*)&w32,4); Printf("Detector pattern  %i"      ,w32);                             //11
  
    pFile->read((char*)&w32,4); Printf("Type attribute 1  %i"      ,w32);                             //12
    pFile->read((char*)&w32,4); Printf("Type attribute 2  %i"      ,w32);                             //13
    pFile->read((char*)&w32,4); Printf("Type attribute 3  %i"      ,w32);                             //14
  
    pFile->read((char*)&w32,4); Printf("LDC ID            %i"      ,w32);                             //15
    pFile->read((char*)&w32,4); Printf("GDC ID            %i"      ,w32);                             //16
    pFile->read((char*)&w32,4); TDatime time(w32); time.Print();                                      //17
  
    Printf("");
  }
  return iSize;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void HmpidHeader(ifstream *pFile,Bool_t isPrint=kFALSE)
{
// Prints hmpid trailer and returns number of words for this trailer  
  if(!isPrint) {pFile->seekg(15*4,ios::cur);return;}
  Int_t w32=-1;
  Printf("\nHMPID Header:");//private HEADER is 15 words
  for(Int_t i=1;i<=11;i++) { pFile->read((char*)&w32,4); Printf("Word #%2i=%12i meaningless",i,w32);}
                             pFile->read((char*)&w32,4); Printf("Word #12=%12i event counter",w32);   
  for(Int_t i=13;i<=15;i++){ pFile->read((char*)&w32,4); Printf("Word #%2i=%12i empty",i,w32);}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void HmpidPayload(ifstream *pFile,Int_t iDdl,TObjArray *pDigAll)
{
// payload is 8 sequences with structure: WC36A8 then WC number of w32
  
  TClonesArray *pDig1=(TClonesArray*)pDigAll->At(iDdl/2); //get list of digits for requested chamber
  
  UInt_t w32=0;
  Int_t iDigCnt=pDig1->GetEntriesFast();
  for(Int_t row=1;row<=8;row++){  
    pFile->read((char*)&w32,4);  Int_t wc=AliBitPacking::UnpackWord(w32,16,31); Int_t ma=AliBitPacking::UnpackWord(w32, 0,15);    
    if(ma!=0x36a8) Printf("ERROR ERROR ERROR WRONG Marker=0x%x ERROR ERROR ERROR",ma);    
    for(Int_t i=1;i<=wc;i++){//words loop
      pFile->read((char*)&w32,4);
      if(w32&0x08000000) continue; //it's DILOGIC CW
      AliHMPIDDigit *pDig=new AliHMPIDDigit;
      pDig->Raw(iDdl,w32);   
      new ((*pDig1)[iDigCnt++]) AliHMPIDDigit(*pDig);
    }//words loop 
  }//rows loop
}//HmpidPayload()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void docosmic(const char* name,Int_t iMaxEvt=9999999)
{
  gBenchmark->Start("Cosmic converter");
  ifstream in(name);

  
  Bool_t isPrint=kFALSE;
  
  TString rooName=name; rooName.Replace(1+rooName.First('.'),4,"root");
  Int_t ddl=0;    
  
  TFile *pOut=new TFile(rooName,"recreate");
  TTree *pTr=new TTree("cosmic","some for time being");
  
  
  TObjArray *pDigAll=new TObjArray(7); pDigAll->SetOwner(); for(Int_t i=0;i<7;i++) pDigAll->AddAt(new TClonesArray("AliHMPIDDigit")  ,i); pTr->Branch("Digs",&pDigAll,64000,0); 
  TObjArray *pCluAll=new TObjArray(7); pCluAll->SetOwner(); for(Int_t i=0;i<7;i++) pCluAll->AddAt(new TClonesArray("AliHMPIDCluster"),i); pTr->Branch("Clus",&pCluAll,64000,0);

  Int_t iEvt=0;
  while(1){      
    Int_t iSize=DateHeader(&in,      isPrint);  if(iSize==68) continue;  //DATE header 
    if(in.eof()) break;
    HmpidHeader (&in,      isPrint);    //HMPID header 
    HmpidPayload(&in,ddl+1,pDigAll);    //HMPID payload
    HmpidHeader (&in,      isPrint);    //HMPID header 
    HmpidPayload(&in,ddl  ,pDigAll);    //HMPID payload
    
    AliHMPIDReconstructor::Dig2Clu(pDigAll,pCluAll);
    pTr->Fill();
    for(Int_t i=0;i<7;i++){
      ((TClonesArray*)pDigAll->At(i))->Clear(); 
      ((TClonesArray*)pCluAll->At(i))->Clear(); 
    }
    
    if(!(iEvt%200)) Printf("Event %i processed",iEvt);
    iEvt++;
    if(iEvt==iMaxEvt) break;
  }//events loop
  
  pTr->Write();  pOut->Close();
  pDigAll->Delete(); pCluAll->Delete();
  in.close();
  
  Printf("Total %i events processed",iEvt);
  gBenchmark->Show("Cosmic converter");
}//docosmic()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void cosmic()
{
  TChain *pCh=new TChain("cosmic");  pCh->Add("test.root");

  
  TH1F *pDigQ=new TH1F("digQ","Digits QDC",500,0,4100);
  TH1F *pDigO=new TH1F("digO","Digits # per event",500,0,8000);
  TH2F *pDigM=new TH2F("digM","Digits map",500,0,131,500,0,127);
    
  TH1F *pCluQ   =new TH1F("cluQ","Clusters QDC",500,0,12100);
  TH1F *pCluQmax=new TH1F("cluQmax","Clusters Max QDC",500,0,12100); pCluQmax->SetLineColor(kRed);
  TH1F *pCluO=new TH1F("cluO","Clusters # per event",500,0,5000);
  TH2F *pCluM=new TH2F("cluM","Clusters map",500,0,131,500,0,127);
  
  TObjArray *pDigAll=0; pCh->SetBranchAddress("Digs",&pDigAll);
  TObjArray *pCluAll=0; pCh->SetBranchAddress("Clus",&pCluAll);

    
  for(Int_t iEvt=0;iEvt<pCh->GetEntries();iEvt++){
    pCh->GetEntry(iEvt);
    
    TClonesArray *pDigCh=(TClonesArray*)pDigAll->At(0);
    TClonesArray *pCluCh=(TClonesArray*)pCluAll->At(0);
    pDigO->Fill(pDigCh->GetEntriesFast());
    pCluO->Fill(pCluCh->GetEntriesFast());
    
    for(Int_t iDig=0;iDig<pDigCh->GetEntriesFast();iDig++){//digits loop
      AliHMPIDDigit *pDig=(AliHMPIDDigit*)pDigCh->UncheckedAt(iDig);
      pDigQ->Fill(pDig->Q());
      pDigM->Fill(pDig->LorsX(),pDig->LorsY());
    }//digits loop
    Int_t qmax=0;    
    for(Int_t iClu=0;iClu<pCluCh->GetEntriesFast();iClu++){//clusters loop
      AliHMPIDCluster *pClu=(AliHMPIDCluster*)pCluCh->UncheckedAt(iClu);
      pCluQ->Fill(pClu->Q());
      if(pClu->Q()>qmax) qmax=pClu->Q();
      pCluM->Fill(pClu->X(),pClu->Y());
    }//digits loop
    pCluQmax->Fill(qmax);
  }//entries loop
  
  TCanvas *pC=new TCanvas("comic","cosmic"); pC->Divide(2,3);
  
  pC->cd(1); pDigM->Draw(); pC->cd(2); pCluM->Draw();
  pC->cd(3); gPad->SetLogy(); pDigQ->Draw(); pC->cd(4); gPad->SetLogy(); pCluQ->Draw(); pCluQmax->Draw("same");
  pC->cd(5); gPad->SetLogy(); pDigO->Draw(); pC->cd(6); gPad->SetLogy(); pCluO->Draw();
}//cosmic()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Commit	Line	Data
d3da6dc4	1	#include <TF1.h>
	2	#include <TH2F.h>
	3	#include <TCanvas.h> //Terminate()
	4	#include <TChain.h>
	5	#include <TBenchmark.h>
da08475b	6	#include <TFile.h> //docosmic()
d3da6dc4	7	#include <fstream> //caf()
	8	#include <TProof.h> //caf()
	9	#include <AliSelector.h> //base class
	10	#include <AliESD.h>
da08475b	11	#include <AliBitPacking.h> //HmpidPayload()
	12	#include "AliHMPIDDigit.h"
	13	#include "AliHMPIDCluster.h"
	14	#include "AliHMPIDReconstructor.h" //docosmic()
d3da6dc4	15
	16	class AliHMPIDSelector : public AliSelector {
	17	public :
	18	AliHMPIDSelector():AliSelector(),fChain(0),fEsd(0),fCkovP(0),fMipXY(0),fDifXY(0),fSigP(0) {for(Int_t i=0;i<5;i++) fProb[i]=0;}
	19	virtual ~AliHMPIDSelector() {delete fEsd;}
	20
	21
	22	virtual Int_t Version () const {return 2;}
	23	virtual void Begin (TTree *) {}
	24	virtual void SlaveBegin (TTree *tree);
	25	virtual void Init (TTree *tree);
	26	virtual Bool_t Notify () {return kTRUE;}
	27	virtual Bool_t Process (Long64_t entry);
	28	virtual void SetOption (const char *option) { fOption = option; }
	29	virtual void SetObject (TObject *obj) { fObject = obj; }
	30	virtual void SetInputList (TList *input) {fInput = input;}
	31	virtual TList *GetOutputList () const { return fOutput; }
	32	virtual void SlaveTerminate ();
	33	virtual void Terminate ();
	34
	35	private:
	36	TTree *fChain ; //!pointer to the analyzed TTree or TChain
	37	AliESD *fEsd ; //!
	38
	39	TH2F fCkovP,fMipXY,fDifXY,fSigP; //!
	40	TH1F *fProb[5]; //!
	41
	42	ClassDef(AliHMPIDSelector,0);
	43	};
	44
	45
	46	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	47	void AliHMPIDSelector::SlaveBegin(TTree *tree)
	48	{
	49	// The SlaveBegin() function is called after the Begin() function. When running with PROOF SlaveBegin() is called on each slave server.
	50	// The tree argument is deprecated (on PROOF 0 is passed).
	51
	52	Init(tree);
	53
	54	TString option = GetOption();
	55
	56	// create histograms on each slave server
	57	fCkovP = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]", 150, 0, 7 ,100, -3, 1);
	58	fSigP = new TH2F("SigP" ,"#sigma_{#theta_c}" , 150, 0, 7 ,100, 0, 1e20);
	59	fMipXY = new TH2F("MipXY" ,"mip position" , 260, 0,130 ,252,0,126);
	60	fDifXY = new TH2F("DifXY" ,"diff" , 260, -10, 10 ,252,-10,10);
	61
	62	fProb[0] = new TH1F("PidE" ,"PID: e yellow #mu magenta" ,100,0,1); fProb[0]->SetLineColor(kYellow);
	63	fProb[1] = new TH1F("PidMu","pid of #mu" ,100,0,1); fProb[1]->SetLineColor(kMagenta);
	64	fProb[2] = new TH1F("PidPi","PID: #pi red K green p blue",100,0,1); fProb[2]->SetLineColor(kRed);
	65	fProb[3] = new TH1F("PidK" ,"pid of K" ,100,0,1); fProb[3]->SetLineColor(kGreen);
	66	fProb[4] = new TH1F("PidP" ,"pid of p" ,100,0,1); fProb[4]->SetLineColor(kBlue);
	67	}
	68	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	69	void AliHMPIDSelector::Init(TTree *pTr)
	70	{
ca579b7d	71	// Called when the selector needs to initialize a new tree of chain. Typically here the branch addresses of the tree is set
ca579b7d	72	// Init() will be called many times when running with PROOF.
d3da6dc4	73
ca579b7d	74	if ( !pTr ) return ;
	75	fChain = pTr ;
	76	fChain->SetBranchAddress("ESD", &fEsd) ;
	77	fChain->SetBranchStatus("*", 0);
	78	fChain->SetBranchStatus("fTracks.*", 1);
d3da6dc4	79	}
	80	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	81	Bool_t AliHMPIDSelector::Process(Long64_t entry)
	82	{
	83
	84	fChain->GetTree()->GetEntry(entry);
	85
	86	for(Int_t iTrk=0;iTrk<fEsd->GetNumberOfTracks();iTrk++){
	87	AliESDtrack *pTrk=fEsd->GetTrack(iTrk);
	88
	89	// if(pTrk->GetHMPIDsignal()<0) continue;
	90
	91	fCkovP->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal()) ;
	92	fSigP ->Fill(pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
	93
ca579b7d	94	// Float_t xm,ym; Int_t q,np; pTrk->GetHMPIDmip(xm,ym,q,np); fMipXY->Fill(xm,ym); //mip info
ca579b7d	95	// Float_t xd,yd,th,ph; pTrk->GetHMPIDtrk(xd,yd,th,ph); fDifXY->Fill(xd,yd); //track info
d3da6dc4	96
	97	Double_t pid[5]; pTrk->GetHMPIDpid(pid); for(Int_t i =0;i<5;i++) fProb[i]->Fill(pid[i]);
	98	}//tracks loop
	99
	100	return kTRUE;
	101	}//Process()
	102	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	103	void AliHMPIDSelector::SlaveTerminate()
	104	{
	105	// The SlaveTerminate() function is called after all entries or objects
	106	// have been processed. When running with PROOF SlaveTerminate() is called
	107	// on each slave server.
	108
	109	// Add the histograms to the output on each slave server
	110
	111	fOutput->Add(fCkovP);
	112	fOutput->Add(fSigP);
	113	fOutput->Add(fMipXY);
	114	fOutput->Add(fDifXY);
	115
	116	for(Int_t i=0;i<5;i++) fOutput->Add(fProb[i]);
	117	}//SlaveTerminate()
	118	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	119	void AliHMPIDSelector::Terminate()
	120	{
ca579b7d	121	// The last function to be called. It always runs on the client, it can be used to present
ca579b7d	122	// the results graphically or save the results to file.
d3da6dc4	123	fCkovP = dynamic_cast<TH2F*>(fOutput->FindObject("CkovP")) ;
	124	fSigP = dynamic_cast<TH2F*>(fOutput->FindObject("SigP")) ;
	125	fMipXY = dynamic_cast<TH2F*>(fOutput->FindObject("MipXY")) ;
	126	fDifXY = dynamic_cast<TH2F*>(fOutput->FindObject("DifXY")) ;
	127
	128	fProb[0] = dynamic_cast<TH1F*>(fOutput->FindObject("PidE")) ;
	129	fProb[1] = dynamic_cast<TH1F*>(fOutput->FindObject("PidMu")) ;
	130	fProb[2] = dynamic_cast<TH1F*>(fOutput->FindObject("PidPi")) ;
	131	fProb[3] = dynamic_cast<TH1F*>(fOutput->FindObject("PidK")) ;
	132	fProb[4] = dynamic_cast<TH1F*>(fOutput->FindObject("PidP")) ;
	133
	134	Float_t n=1.292; //mean freon ref idx
	135	TF1 pPi=new TF1("RiPiTheo","acos(sqrt(xx+[0][0])/(x[1]))",1.2,7); pPi->SetLineWidth(1); pPi->SetParameter(1,n);
	136	AliPID ppp; pPi->SetLineColor(kRed); pPi->SetParameter(0,AliPID::ParticleMass(AliPID::kPion)); //mass
	137	TF1 pK=(TF1)pPi->Clone(); pK ->SetLineColor(kGreen); pK ->SetParameter(0,AliPID::ParticleMass(AliPID::kKaon));
	138	TF1 pP=(TF1)pPi->Clone(); pP ->SetLineColor(kBlue); pP ->SetParameter(0,AliPID::ParticleMass(AliPID::kProton));
	139
	140	TCanvas *pC=new TCanvas("c1","ESD QA");pC->SetFillColor(10); pC->SetHighLightColor(10); pC->Divide(3,2);
	141	pC->cd(1); fCkovP->Draw(); pPi->Draw("same"); pK->Draw("same"); pP->Draw("same"); pC->cd(2); fMipXY->Draw(); pC->cd(3); fProb[0]->Draw(); fProb[1]->Draw("same");
	142	pC->cd(4); fSigP ->Draw(); pC->cd(5); fDifXY->Draw(); pC->cd(6); fProb[2]->Draw(); fProb[3]->Draw("same"); fProb[4]->Draw("same");
ca579b7d	143	}//Terminate()
d3da6dc4	144	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
d3da6dc4	145	void loc()
d3da6dc4	146	{
ca579b7d	147	TChain* pChain =new TChain("esdTree"); pChain->Add("AliESDs.root");
d3da6dc4	148
	149	pChain->Process("AliHMPIDSelector.C+");
	150	}
	151	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	152	void caf()
	153	{
	154	gBenchmark->Start("PRooF exec");
	155	TChain* pChain =new TChain("esdTree");
	156
	157	ifstream list; list.open("list.txt");
	158
	159	TString file;
	160	while(list.good()) {
	161	list>>file;
	162	if (!file.Contains("root")) continue; //it's wrong file name
	163	pChain->Add(file.Data());
	164	}
	165	list.close();
	166
	167	pChain->GetListOfFiles()->Print();
	168
	169	TVirtualProof *pProof=TProof::Open("kir@lxb6046.cern.ch");
	170	pProof->UploadPackage("ESD.par");
	171	pProof->EnablePackage("ESD");
	172
	173	pChain->SetProof(pProof);
	174	pChain->Process("AliHMPIDSelector.C+");
	175
	176	gBenchmark->Show("PRooF exec");
	177	}
	178	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
da08475b	179	Int_t DateHeader(ifstream *pFile,Bool_t isPrint=0)
	180	{
	181	Int_t iSize=-1;
	182	pFile->read((char*)&iSize,4);
	183	if(!isPrint)
	184	pFile->seekg(16*4,ios::cur);
	185	else{
	186	Int_t w32=-1;
	187	Printf("");
	188	Printf("Event size %i bytes",iSize); //1 common DATE header 17 words
	189	pFile->read((char*)&w32,4); Printf("Event magic 0x%x" ,w32); //2
	190	pFile->read((char*)&w32,4); Printf("Event head size %i bytes",w32); //3
	191	pFile->read((char*)&w32,4); Printf("Event version 0x%x" ,w32); //4
	192	pFile->read((char*)&w32,4); Printf("Event type %i (%s)" ,w32,(w32==7)? "physics":"SOR"); //5
	193	pFile->read((char*)&w32,4); Printf("Run number %i" ,w32); //6
	194
	195	pFile->read((char*)&w32,4); Printf("Event ID 1 %i" ,w32); //7
	196	pFile->read((char*)&w32,4); Printf("Event ID 2 %i" ,w32); //8
	197
	198	pFile->read((char*)&w32,4); Printf("Trigger pattern 1 %i" ,w32); //9
	199	pFile->read((char*)&w32,4); Printf("Trigger pattern 2 %i" ,w32); //10
	200
	201	pFile->read((char*)&w32,4); Printf("Detector pattern %i" ,w32); //11
	202
	203	pFile->read((char*)&w32,4); Printf("Type attribute 1 %i" ,w32); //12
	204	pFile->read((char*)&w32,4); Printf("Type attribute 2 %i" ,w32); //13
	205	pFile->read((char*)&w32,4); Printf("Type attribute 3 %i" ,w32); //14
	206
	207	pFile->read((char*)&w32,4); Printf("LDC ID %i" ,w32); //15
	208	pFile->read((char*)&w32,4); Printf("GDC ID %i" ,w32); //16
	209	pFile->read((char*)&w32,4); TDatime time(w32); time.Print(); //17
	210
	211	Printf("");
	212	}
	213	return iSize;
	214	}
	215	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	216	void HmpidHeader(ifstream *pFile,Bool_t isPrint=kFALSE)
	217	{
	218	// Prints hmpid trailer and returns number of words for this trailer
	219	if(!isPrint) {pFile->seekg(15*4,ios::cur);return;}
	220	Int_t w32=-1;
	221	Printf("\nHMPID Header:");//private HEADER is 15 words
	222	for(Int_t i=1;i<=11;i++) { pFile->read((char*)&w32,4); Printf("Word #%2i=%12i meaningless",i,w32);}
	223	pFile->read((char*)&w32,4); Printf("Word #12=%12i event counter",w32);
	224	for(Int_t i=13;i<=15;i++){ pFile->read((char*)&w32,4); Printf("Word #%2i=%12i empty",i,w32);}
	225	}
	226	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c6274c1	227	void HmpidPayload(ifstream pFile,Int_t iDdl,TObjArray pDigAll)
da08475b	228	{
da08475b	229	// payload is 8 sequences with structure: WC36A8 then WC number of w32
3c6274c1	230
	231	TClonesArray pDig1=(TClonesArray)pDigAll->At(iDdl/2); //get list of digits for requested chamber
	232
da08475b	233	UInt_t w32=0;
3c6274c1	234	Int_t iDigCnt=pDig1->GetEntriesFast();
da08475b	235	for(Int_t row=1;row<=8;row++){
	236	pFile->read((char*)&w32,4); Int_t wc=AliBitPacking::UnpackWord(w32,16,31); Int_t ma=AliBitPacking::UnpackWord(w32, 0,15);
	237	if(ma!=0x36a8) Printf("ERROR ERROR ERROR WRONG Marker=0x%x ERROR ERROR ERROR",ma);
	238	for(Int_t i=1;i<=wc;i++){//words loop
	239	pFile->read((char*)&w32,4);
	240	if(w32&0x08000000) continue; //it's DILOGIC CW
	241	AliHMPIDDigit *pDig=new AliHMPIDDigit;
	242	pDig->Raw(iDdl,w32);
3c6274c1	243	new ((pDig1)[iDigCnt++]) AliHMPIDDigit(pDig);
da08475b	244	}//words loop
	245	}//rows loop
	246	}//HmpidPayload()
	247	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c6274c1	248	void docosmic(const char* name,Int_t iMaxEvt=9999999)
da08475b	249	{
	250	gBenchmark->Start("Cosmic converter");
	251	ifstream in(name);
	252
	253
	254	Bool_t isPrint=kFALSE;
	255
	256	TString rooName=name; rooName.Replace(1+rooName.First('.'),4,"root");
	257	Int_t ddl=0;
	258
	259	TFile *pOut=new TFile(rooName,"recreate");
	260	TTree *pTr=new TTree("cosmic","some for time being");
	261
3c6274c1	262
	263	TObjArray *pDigAll=new TObjArray(7); pDigAll->SetOwner(); for(Int_t i=0;i<7;i++) pDigAll->AddAt(new TClonesArray("AliHMPIDDigit") ,i); pTr->Branch("Digs",&pDigAll,64000,0);
	264	TObjArray *pCluAll=new TObjArray(7); pCluAll->SetOwner(); for(Int_t i=0;i<7;i++) pCluAll->AddAt(new TClonesArray("AliHMPIDCluster"),i); pTr->Branch("Clus",&pCluAll,64000,0);
da08475b	265
3c6274c1	266	Int_t iEvt=0;
da08475b	267	while(1){
	268	Int_t iSize=DateHeader(&in, isPrint); if(iSize==68) continue; //DATE header
	269	if(in.eof()) break;
	270	HmpidHeader (&in, isPrint); //HMPID header
3c6274c1	271	HmpidPayload(&in,ddl+1,pDigAll); //HMPID payload
da08475b	272	HmpidHeader (&in, isPrint); //HMPID header
3c6274c1	273	HmpidPayload(&in,ddl ,pDigAll); //HMPID payload
da08475b	274
3c6274c1	275	AliHMPIDReconstructor::Dig2Clu(pDigAll,pCluAll);
da08475b	276	pTr->Fill();
3c6274c1	277	for(Int_t i=0;i<7;i++){
	278	((TClonesArray*)pDigAll->At(i))->Clear();
	279	((TClonesArray*)pCluAll->At(i))->Clear();
	280	}
	281
	282	if(!(iEvt%200)) Printf("Event %i processed",iEvt);
	283	iEvt++;
	284	if(iEvt==iMaxEvt) break;
	285	}//events loop
da08475b	286
3c6274c1	287	pTr->Write(); pOut->Close();
3c6274c1	288	pDigAll->Delete(); pCluAll->Delete();
da08475b	289	in.close();
3c6274c1	290
3c6274c1	291	Printf("Total %i events processed",iEvt);
da08475b	292	gBenchmark->Show("Cosmic converter");
	293	}//docosmic()
	294	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	295	void cosmic()
	296	{
3c6274c1	297	TChain *pCh=new TChain("cosmic"); pCh->Add("test.root");
da08475b	298
	299
	300	TH1F *pDigQ=new TH1F("digQ","Digits QDC",500,0,4100);
	301	TH1F *pDigO=new TH1F("digO","Digits # per event",500,0,8000);
	302	TH2F *pDigM=new TH2F("digM","Digits map",500,0,131,500,0,127);
	303
3c6274c1	304	TH1F *pCluQ =new TH1F("cluQ","Clusters QDC",500,0,12100);
3c6274c1	305	TH1F *pCluQmax=new TH1F("cluQmax","Clusters Max QDC",500,0,12100); pCluQmax->SetLineColor(kRed);
da08475b	306	TH1F *pCluO=new TH1F("cluO","Clusters # per event",500,0,5000);
	307	TH2F *pCluM=new TH2F("cluM","Clusters map",500,0,131,500,0,127);
	308
3c6274c1	309	TObjArray *pDigAll=0; pCh->SetBranchAddress("Digs",&pDigAll);
	310	TObjArray *pCluAll=0; pCh->SetBranchAddress("Clus",&pCluAll);
	311
	312
da08475b	313	for(Int_t iEvt=0;iEvt<pCh->GetEntries();iEvt++){
	314	pCh->GetEntry(iEvt);
	315
3c6274c1	316	TClonesArray pDigCh=(TClonesArray)pDigAll->At(0);
	317	TClonesArray pCluCh=(TClonesArray)pCluAll->At(0);
	318	pDigO->Fill(pDigCh->GetEntriesFast());
	319	pCluO->Fill(pCluCh->GetEntriesFast());
da08475b	320
3c6274c1	321	for(Int_t iDig=0;iDig<pDigCh->GetEntriesFast();iDig++){//digits loop
3c6274c1	322	AliHMPIDDigit pDig=(AliHMPIDDigit)pDigCh->UncheckedAt(iDig);
da08475b	323	pDigQ->Fill(pDig->Q());
	324	pDigM->Fill(pDig->LorsX(),pDig->LorsY());
	325	}//digits loop
3c6274c1	326	Int_t qmax=0;
	327	for(Int_t iClu=0;iClu<pCluCh->GetEntriesFast();iClu++){//clusters loop
	328	AliHMPIDCluster pClu=(AliHMPIDCluster)pCluCh->UncheckedAt(iClu);
da08475b	329	pCluQ->Fill(pClu->Q());
3c6274c1	330	if(pClu->Q()>qmax) qmax=pClu->Q();
da08475b	331	pCluM->Fill(pClu->X(),pClu->Y());
da08475b	332	}//digits loop
3c6274c1	333	pCluQmax->Fill(qmax);
da08475b	334	}//entries loop
	335
	336	TCanvas *pC=new TCanvas("comic","cosmic"); pC->Divide(2,3);
	337
	338	pC->cd(1); pDigM->Draw(); pC->cd(2); pCluM->Draw();
3c6274c1	339	pC->cd(3); gPad->SetLogy(); pDigQ->Draw(); pC->cd(4); gPad->SetLogy(); pCluQ->Draw(); pCluQmax->Draw("same");
3c6274c1	340	pC->cd(5); gPad->SetLogy(); pDigO->Draw(); pC->cd(6); gPad->SetLogy(); pCluO->Draw();
da08475b	341	}//cosmic()
da08475b	342	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++