[u/mrichter/AliRoot.git] / STEER / AliAODTagCreator.cxx

/**************************************************************************
 * Author: Panos Christakoglou.                                           *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           AliAODTagCreator class
//   This is the class to deal with the tag creation (post process)
//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//-----------------------------------------------------------------

//ROOT
#include <Riostream.h>
#include <TFile.h>
#include <TString.h>
#include <TTree.h>
#include <TSystem.h>
#include <TChain.h>
#include <TLorentzVector.h>
#include <TRefArray.h>

//ROOT-AliEn
#include <TGrid.h>
#include <TGridResult.h>

//AliRoot
#include "AliRunTag.h"
#include "AliEventTag.h"
#include "AliFileTag.h"
#include "AliPID.h"
#include "AliAODEvent.h"
#include "AliAODVertex.h"
#include "AliLog.h"

#include "AliAODTagCreator.h"


ClassImp(AliAODTagCreator)


//______________________________________________________________________________
  AliAODTagCreator::AliAODTagCreator() :
    AliTagCreator(), 
    fChain(0), 
    fAODEvent(0), 
    fTreeT(0), 
    fRunTag(0),
    fTreeTEsd(0), 
    fRunTagEsd(0)  
{
  //==============Default constructor for a AliAODTagCreator================
}

//______________________________________________________________________________
AliAODTagCreator::~AliAODTagCreator() {
//================Default destructor for a AliAODTagCreator===================
  delete fChain;
  delete fAODEvent;
}

//______________________________________________________________________________
Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
  // Reads the entry of the TGridResult and creates the tags
  Int_t nEntries = fresult->GetEntries();

  TString alienUrl;
  const char* guid;
  const char* md5;
  const char* turl;
  Long64_t size = -1;

  fChain = new TChain("aodTree");
 
  for(Int_t i = 0; i < nEntries; i++) {
    alienUrl = fresult->GetKey(i,"turl");
    guid = fresult->GetKey(i,"guid");
    if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
    md5 = fresult->GetKey(i,"md5");
    turl = fresult->GetKey(i,"turl");
    if(md5 && !strlen(guid)) md5 = 0;
    if(guid && !strlen(guid)) guid = 0;
    
    fChain->Add(alienUrl);
  }//grid result loop
  
  AliInfo(Form("AOD chain created......."));	
  AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));	

  CreateTag(fChain, "grid");
  
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliAODTagCreator::ReadLocalCollection(const char *localpath, const char* pattern) {
  // Checks the different subdirs of the given local path and in the
  // case where it finds an AliAOD.root file it creates the tags
  
  void *dira =  gSystem->OpenDirectory(localpath);
  Char_t fPath[256];
  const char * dirname  = 0x0;
  const char * filename = 0x0;

  fChain = new TChain("aodTree");

  while((dirname = gSystem->GetDirEntry(dira))) {
    sprintf(fPath,"%s/%s",localpath,dirname);
    void *dirb =  gSystem->OpenDirectory(fPath);
    while((filename = gSystem->GetDirEntry(dirb))) {
	TString bstr = dirname;
	if(bstr.Contains("..")) continue;
	if(strstr(filename,pattern)) {
	    TString aodFileName;
	    aodFileName = fPath;
	    aodFileName += "/";
	    aodFileName += pattern;
	    fChain->Add(aodFileName);
	} //pattern check
    } //child directory's entry loop
  } //parent directory's entry loop
  
  AliInfo(Form("AOD chain created......."));	
  AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));	

  CreateTag(fChain, "local");

  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
  // Temporary solution for CAF: Takes as an input the ascii file that
  // lists the AODs stored in the SE of the CAF and creates the tags.

  // Open the input stream
  ifstream in;
  in.open(filename);

  TString aodfile;

  fChain = new TChain("aodTree");

  // Read the input list of files and add them to the chain
  while(in.good()) {
    in >> aodfile;
    if (!aodfile.Contains("root")) continue; // protection
    fChain->Add(aodfile);
  }

  AliInfo(Form("AOD chain created......."));	
  AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));	

  CreateTag(fChain, "proof");

  return kTRUE;
}

//__________________________________________________________________________
void AliAODTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent, TList */*grpList*/) {
  // Creates tag files for AODs

    AliInfo(Form("Creating the AOD tags......."));	
    
    TFile *file = TFile::Open("AliAOD.root");
    if (!file || !file->IsOpen()) {
	AliError(Form("opening failed"));
	delete file;
	return ;
    }

    fChain = new TChain("aodTree");
    fChain->Add("AliAOD.root");
    
    fAODEvent = new AliAODEvent();
    fAODEvent->ReadFromTree(fChain);
    
    Int_t lastEvent = 0;  
    if(fLastEvent == -1) lastEvent = (Int_t)fChain->GetEntries();
    else lastEvent = fLastEvent;

    char fileName[256];
    sprintf(fileName, "Run%d.Event%d_%d.AOD.tag.root", 
	    fAODEvent->GetRunNumber(), fFirstEvent, lastEvent );
    AliInfo(Form("writing tags to file %s", fileName));
    AliDebug(1, Form("writing tags to file %s", fileName));
 
    TFile* ftag = TFile::Open(fileName, "recreate");

    fRunTag = new AliRunTag();
    fTreeT = new TTree("T","A Tree with event tags");
    TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
    btag->SetCompressionLevel(9);

    CreateTags();

    ftag->cd();
    fTreeT->Fill();
    fRunTag->Clear();
    fTreeT->Write();
    ftag->Close();
    file->cd();
    file->Close();
}

//_____________________________________________________________________________
void AliAODTagCreator::CreateTag(TChain* chain, const char *type) {
    
    // Private method that creates tag files
    //

    //reading the esd tag file 
    fTreeTEsd = new TChain("T");
    const char * tagPattern = "ESD.tag";
    // Open the working directory
    void * dirp = gSystem->OpenDirectory(gSystem->pwd());
    const char * name = 0x0;
    // Add all files matching *pattern* to the chain
    while((name = gSystem->GetDirEntry(dirp))) {
	if (strstr(name,tagPattern)) fTreeTEsd->Add(name);
    }//directory loop
    AliInfo(Form("Chained tag files: %lld",fTreeTEsd->GetEntries()));
      
    fChain = chain;
    
    TString fSession = type;
    TString fguid, fmd5, fturl;
    fAODEvent = new AliAODEvent();
    fAODEvent->ReadFromTree(fChain);

    Int_t firstEvent = 0;
    
    TString localFileName = "Run"; 
    localFileName += fAODEvent->GetRunNumber(); 
    localFileName += ".Event"; 
    localFileName += firstEvent; 
    localFileName += "_"; 
    localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
    localFileName += ".AOD.tag.root";
    
    TString fileName;
    
    if(fStorage == 0) {
	fileName = localFileName.Data();      
	AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
    }
    else if(fStorage == 1) {
	TString alienLocation = "/alien";
	alienLocation += gGrid->Pwd();
	alienLocation += fgridpath.Data();
	alienLocation += "/";
	alienLocation +=  localFileName;
	alienLocation += "?se=";
	alienLocation += fSE.Data();
	fileName = alienLocation.Data();
	AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
    }
    
    TFile* ftag = TFile::Open(fileName, "recreate");
    
    fRunTag = new AliRunTag();
    fTreeT  = new TTree("T", "A Tree with event tags");
    TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
    btag->SetCompressionLevel(9);
    
    // Access information from esd tag
    fRunTagEsd = new AliRunTag();
    fTreeTEsd->SetBranchAddress("AliTAG",&fRunTagEsd);
    // Creating new information of aod
    AliInfo(Form("Creating the AOD tags......."));
    CreateTags(type);
    ftag->cd();
    fRunTag->Clear();
    fTreeT->Write();
    ftag->Close();
}

void AliAODTagCreator::CreateTags(const char* type)
{
    // Event loop for tag creation
    TString fturl;
    TString fguid;
    Int_t   oldRun = -1;
    fChain->GetEntry(0);
    TFile *f = fChain->GetFile();
    TString ftempGuid = f->GetUUID().AsString();
    // Loop over events 
    Int_t nEvents = fChain->GetEntries();
    Int_t ntags    = 0;
    Int_t tagentry = 0;
    //    const TClonesArray *evTagList = 0;
    TString foldguid = "";

    for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
	// Copy old tag information
	if (iEventNumber >= ntags) {
	    fTreeTEsd->GetEntry(tagentry++);
	    fRunTag->CopyStandardContent(fRunTagEsd);
// 	    evTagList = fRunTagEsd->GetEventTags();
// 	    ntags += evTagList->GetEntries();
	    ntags = fRunTagEsd->GetNEvents();
	}

	// Create a new Tag
	AliEventTag* evTag = new AliEventTag();
	// Read event
	fChain->GetEntry(iEventNumber);
	if (iEventNumber == 0) oldRun = fAODEvent->GetRunNumber();
	// Reference to the input file
	TFile *file = fChain->GetFile();
	const TUrl *url = file->GetEndpointUrl();
	fguid = file->GetUUID().AsString();

	if (!strcmp(type,"grid")) {
	    TString fturltemp = "alien://"; fturltemp += url->GetFile();
	    fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
	} else {
	    fturl = url->GetFile();
	}
	
	fAODEvent->GetStdContent();
	
	// Fill the event tag from the aod informatiom
	FillEventTag(fAODEvent, evTag);
	// Set the event and input file references
	//evTag->SetEventId(iEventNumber+1);
	
	// **** FIXME ****
// 	evTag->SetGUID(fguid);
// 	if(!strcmp(type,"grid")) {
// 	    evTag->SetMD5("");
// 	    evTag->SetTURL(fturl);
// 	    evTag->SetSize(0);
// 	    }
// 	else evTag->SetPath(fturl);
	//  **** FIXME ****

	// Check if a new run has to be created
	// File has changed
	if(fguid != ftempGuid) {
	    ftempGuid = fguid;
	    fTreeT->Fill();
	    fRunTag->Clear("");

	    AliFileTag *nftag = new AliFileTag();
	    
	    // if(fSession == "grid") {
	      nftag->SetMD5("");
	      nftag->SetTURL(fturl);
	      nftag->SetSize(0);
	    // }
	    // else {
	    //   nftag->SetPath(fturl);
	    //   nftag->SetSize(0);
	    //   nftag->SetMD5("");
	    //   nftag->SetTURL(fturl);
	    // }
      
	    if (fRunTag->GetFileId(fguid) > -1)
	      AliFatal("Adding a file which is already in the RunTag.");
	    
	    fRunTag->AddFileTag(nftag);
	    
	}

	// Run# has changed
	if (oldRun != (fAODEvent->GetRunNumber()))
	{
	    oldRun = fAODEvent->GetRunNumber();

	    fTreeT->Fill();
	    fRunTag->Clear("");
	    ftempGuid = fguid;
	    fTreeT->Fill();
	    fRunTag->Clear("");

	    AliFileTag *nftag = new AliFileTag();
	    
	    // if(fSession == "grid") {
	      nftag->SetMD5("");
	      nftag->SetTURL(fturl);
	      nftag->SetSize(0);
	    // }
	    // else {
	    //   nftag->SetPath(fturl);
	    //   nftag->SetSize(0);
	    //   nftag->SetMD5("");
	    //   nftag->SetTURL(fturl);
	    // }
      
	    if (fRunTag->GetFileId(fguid) > -1)
	      AliFatal("Adding a file which is already in the RunTag.");
	    
	    fRunTag->AddFileTag(nftag);
	    
	}
	
	// Add the event tag
	fRunTag->AddEventTag(*evTag);
	delete evTag;
	// Last event
	if(iEventNumber+1 == fChain->GetEntries()) {
	    fTreeT->Fill();
	    fRunTag->Clear("");
	}      
    }//event loop
}


void AliAODTagCreator::FillEventTag(AliAODEvent* aod, AliEventTag* evTag)
{
// 
// Fill the event tag information	
    //
    fAODEvent = aod;
    
    //
    Float_t fLowPtCut      =  1.0;
    Float_t fHighPtCut     =  3.0;
    Float_t fVeryHighPtCut = 10.0;
    ////////////                            
    Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
    
    // Creates the tags for all the events in a given AOD file
    Int_t   ntrack = 0;
    Int_t   nPos = 0, nNeg = 0, nNeutr =0;
    Int_t   nKinks = 0, nV0s = 0, nCascades = 0;
    Int_t   nK0s = 0, nNeutrons = 0, nPi0s = 0, nGamas = 0;
    Int_t   nProtons = 0,  nKaons = 0, nPions = 0, nMuons = 0, nElectrons = 0, nFWMuons = 0;
    Int_t   nCh1GeV = 0, nCh3GeV = 0, nCh10GeV = 0;
    Int_t   nMu1GeV = 0, nMu3GeV = 0, nMu10GeV = 0;
    Int_t   nEl1GeV = 0, nEl3GeV = 0, nEl10GeV = 0;
    Float_t maxPt =  .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP =  .0;

    TRefArray tmp;


    // Primary Vertex
    AliAODVertex *pVertex = fAODEvent->GetPrimaryVertex();
    if (pVertex) {
	evTag->SetVertexX(pVertex->GetX());
	evTag->SetVertexY(pVertex->GetY());
	evTag->SetVertexZ(pVertex->GetZ());
	Double_t covmatrix[6];
	pVertex->GetCovarianceMatrix(covmatrix);
	evTag->SetVertexZError(sqrt(covmatrix[5]));
    }
    // loop over vertices 
    Int_t nVtxs = fAODEvent->GetNumberOfVertices();
    for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
	AliAODVertex *vertex = fAODEvent->GetVertex(nVtx);
	if(vertex->GetType() == 1) nKinks    += 1;
	if(vertex->GetType() == 2) nV0s      += 1;
	if(vertex->GetType() == 3) nCascades += 1;
    }
    Int_t nTracks = fAODEvent->GetNTracks();
    for (Int_t nTr = 0; nTr < nTracks; nTr++) {
	AliAODTrack *track = fAODEvent->GetTrack(nTr);
	
	Double_t fPt = track->Pt();
	if(fPt > maxPt) {
	    maxPt = fPt;
	    etamaxPt = track->Eta();
	    phimaxPt = track->Phi();
	}
	
	if(track->Charge() > 0) {
	    nPos++;
	    if(fPt > fLowPtCut)      nCh1GeV++;
	    if(fPt > fHighPtCut)     nCh3GeV++;
	    if(fPt > fVeryHighPtCut) nCh10GeV++;
	}
	if(track->Charge() < 0) {
	    nNeg++;
	    if(fPt > fLowPtCut)      nCh1GeV++;
	    if(fPt > fHighPtCut)     nCh3GeV++;
	    if(fPt > fVeryHighPtCut) nCh10GeV++;
	    }
	if(track->Charge() == 0) nNeutr++;
	//PID
	const Double32_t *prob = track->PID();
	Double_t rcc = 0.0;
	for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
	if(rcc == 0.0) continue;
	//Bayes' formula  
	Double_t w[10];
	for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
	
	//protons
	if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
	//kaons
	if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
	//pions
	if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
	//muons 
	if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
	    nMuons++;
	    if(fPt > fLowPtCut)      nMu1GeV++;
	    if(fPt > fHighPtCut)     nMu3GeV++;
	    if(fPt > fVeryHighPtCut) nMu10GeV++;
	}
	//electrons  
	if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
	    nElectrons++;
	    if(fPt > fLowPtCut) nEl1GeV++;
	    if(fPt > fHighPtCut) nEl3GeV++;
	    if(fPt > fVeryHighPtCut) nEl10GeV++;
	}
	totalP += track->P();
	meanPt += fPt;
	ntrack++;
	// forward muons (in the dimuon spectrometer)
	if(track->IsMuonTrack()) nFWMuons++;   
  	                          
    }//track loop
    //
    // Fill the event tags  
    if(ntrack != 0)
	meanPt = meanPt/ntrack;
    
    
    evTag->SetNumOfTracks(nTracks);
    evTag->SetNumOfPosTracks(nPos);
    evTag->SetNumOfNegTracks(nNeg);
    evTag->SetNumOfNeutrTracks(nNeutr);
    
    evTag->SetNumOfV0s(nV0s);
    evTag->SetNumOfCascades(nCascades);
    evTag->SetNumOfKinks(nKinks);
    
    evTag->SetNumOfProtons(nProtons);
    evTag->SetNumOfKaons(nKaons);
    evTag->SetNumOfPions(nPions);
    evTag->SetNumOfMuons(nMuons);
    evTag->SetNumOfFWMuons(nFWMuons);
    evTag->SetNumOfElectrons(nElectrons);
    evTag->SetNumOfPhotons(nGamas);
    evTag->SetNumOfPi0s(nPi0s);
    evTag->SetNumOfNeutrons(nNeutrons);
    evTag->SetNumOfKaon0s(nK0s);
    
    evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
    evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
    evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
    evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
    evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
    evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
    evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
    evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
    evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);

    tmp.Clear();
    evTag->SetNumOfPHOSClusters(fAODEvent->GetPHOSClusters(&tmp));
    tmp.Clear();
    evTag->SetNumOfEMCALClusters(fAODEvent->GetEMCALClusters(&tmp));
	
    evTag->SetTotalMomentum(totalP);
    evTag->SetMeanPt(meanPt);
    evTag->SetMaxPt(maxPt);
    evTag->SetEtaMaxPt(etamaxPt);
    evTag->SetPhiMaxPt(phimaxPt);
}
Commit	Line	Data
a1069ee1	1	/**************************************************************************
	2	* Author: Panos Christakoglou. *
	3	* Contributors are mentioned in the code where appropriate. *
	4	* *
	5	* Permission to use, copy, modify and distribute this software and its *
	6	* documentation strictly for non-commercial purposes is hereby granted *
	7	* without fee, provided that the above copyright notice appears in all *
	8	* copies and that both the copyright notice and this permission notice *
	9	* appear in the supporting documentation. The authors make no claims *
	10	* about the suitability of this software for any purpose. It is *
	11	* provided "as is" without express or implied warranty. *
	12	**************************************************************************/
	13
	14	/* $Id$ */
	15
	16	//-----------------------------------------------------------------
	17	// AliAODTagCreator class
	18	// This is the class to deal with the tag creation (post process)
	19	// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
	20	//-----------------------------------------------------------------
	21
	22	//ROOT
	23	#include <Riostream.h>
	24	#include <TFile.h>
	25	#include <TString.h>
	26	#include <TTree.h>
	27	#include <TSystem.h>
	28	#include <TChain.h>
	29	#include <TLorentzVector.h>
a69c1246	30	#include <TRefArray.h>
a1069ee1	31
	32	//ROOT-AliEn
	33	#include <TGrid.h>
	34	#include <TGridResult.h>
	35
	36	//AliRoot
	37	#include "AliRunTag.h"
	38	#include "AliEventTag.h"
04cb11d4	39	#include "AliFileTag.h"
a1069ee1	40	#include "AliPID.h"
a1069ee1	41	#include "AliAODEvent.h"
	42	#include "AliAODVertex.h"
	43	#include "AliLog.h"
	44
	45	#include "AliAODTagCreator.h"
	46
	47
	48	ClassImp(AliAODTagCreator)
	49
	50
	51	//______________________________________________________________________________
	52	AliAODTagCreator::AliAODTagCreator() :
6e557e6d	53	AliTagCreator(),
	54	fChain(0),
	55	fAODEvent(0),
	56	fTreeT(0),
	57	fRunTag(0),
	58	fTreeTEsd(0),
	59	fRunTagEsd(0)
	60	{
a1069ee1	61	//==============Default constructor for a AliAODTagCreator================
	62	}
	63
	64	//______________________________________________________________________________
	65	AliAODTagCreator::~AliAODTagCreator() {
	66	//================Default destructor for a AliAODTagCreator===================
103d3fba	67	delete fChain;
6e557e6d	68	delete fAODEvent;
a1069ee1	69	}
	70
	71	//______________________________________________________________________________
	72	Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
	73	// Reads the entry of the TGridResult and creates the tags
	74	Int_t nEntries = fresult->GetEntries();
	75
103d3fba	76	TString alienUrl;
	77	const char* guid;
	78	const char* md5;
	79	const char* turl;
	80	Long64_t size = -1;
	81
6e557e6d	82	fChain = new TChain("aodTree");
6e557e6d	83
103d3fba	84	for(Int_t i = 0; i < nEntries; i++) {
	85	alienUrl = fresult->GetKey(i,"turl");
	86	guid = fresult->GetKey(i,"guid");
	87	if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
	88	md5 = fresult->GetKey(i,"md5");
	89	turl = fresult->GetKey(i,"turl");
	90	if(md5 && !strlen(guid)) md5 = 0;
	91	if(guid && !strlen(guid)) guid = 0;
	92
	93	fChain->Add(alienUrl);
103d3fba	94	}//grid result loop
	95
	96	AliInfo(Form("AOD chain created......."));
73bbf779	97	AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
6e557e6d	98
6e557e6d	99	CreateTag(fChain, "grid");
103d3fba	100
	101	return kTRUE;
	102	}
	103
a1069ee1	104	//______________________________________________________________________________
4811fe8e	105	Bool_t AliAODTagCreator::ReadLocalCollection(const char localpath, const char pattern) {
103d3fba	106	// Checks the different subdirs of the given local path and in the
4811fe8e	107	// case where it finds an AliAOD.root file it creates the tags
103d3fba	108
	109	void *dira = gSystem->OpenDirectory(localpath);
	110	Char_t fPath[256];
4811fe8e	111	const char * dirname = 0x0;
103d3fba	112	const char * filename = 0x0;
103d3fba	113
6e557e6d	114	fChain = new TChain("aodTree");
6e557e6d	115
103d3fba	116	while((dirname = gSystem->GetDirEntry(dira))) {
	117	sprintf(fPath,"%s/%s",localpath,dirname);
	118	void *dirb = gSystem->OpenDirectory(fPath);
	119	while((filename = gSystem->GetDirEntry(dirb))) {
6d81c8d4	120	TString bstr = dirname;
	121	if(bstr.Contains("..")) continue;
	122	if(strstr(filename,pattern)) {
	123	TString aodFileName;
	124	aodFileName = fPath;
	125	aodFileName += "/";
	126	aodFileName += pattern;
	127	fChain->Add(aodFileName);
	128	} //pattern check
	129	} //child directory's entry loop
	130	} //parent directory's entry loop
	131
103d3fba	132	AliInfo(Form("AOD chain created......."));
73bbf779	133	AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
6e557e6d	134
6e557e6d	135	CreateTag(fChain, "local");
103d3fba	136
	137	return kTRUE;
	138	}
	139
a1069ee1	140	//______________________________________________________________________________
a1069ee1	141	Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
103d3fba	142	// Temporary solution for CAF: Takes as an input the ascii file that
6e557e6d	143	// lists the AODs stored in the SE of the CAF and creates the tags.
103d3fba	144
	145	// Open the input stream
	146	ifstream in;
	147	in.open(filename);
	148
6e557e6d	149	TString aodfile;
	150
	151	fChain = new TChain("aodTree");
	152
103d3fba	153	// Read the input list of files and add them to the chain
103d3fba	154	while(in.good()) {
6e557e6d	155	in >> aodfile;
	156	if (!aodfile.Contains("root")) continue; // protection
	157	fChain->Add(aodfile);
103d3fba	158	}
	159
	160	AliInfo(Form("AOD chain created......."));
73bbf779	161	AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
6e557e6d	162
6e557e6d	163	CreateTag(fChain, "proof");
103d3fba	164
	165	return kTRUE;
	166	}
	167
a1069ee1	168	//__________________________________________________________________________
786172af	169	void AliAODTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent, TList /grpList*/) {
6e557e6d	170	// Creates tag files for AODs
a1069ee1	171
6e557e6d	172	AliInfo(Form("Creating the AOD tags......."));
a1069ee1	173
6e557e6d	174	TFile *file = TFile::Open("AliAOD.root");
	175	if (!file \|\| !file->IsOpen()) {
	176	AliError(Form("opening failed"));
	177	delete file;
	178	return ;
a1069ee1	179	}
a1069ee1	180
6e557e6d	181	fChain = new TChain("aodTree");
6e557e6d	182	fChain->Add("AliAOD.root");
a1069ee1	183
6e557e6d	184	fAODEvent = new AliAODEvent();
6e557e6d	185	fAODEvent->ReadFromTree(fChain);
a1069ee1	186
6e557e6d	187	Int_t lastEvent = 0;
	188	if(fLastEvent == -1) lastEvent = (Int_t)fChain->GetEntries();
	189	else lastEvent = fLastEvent;
	190
6e557e6d	191	char fileName[256];
	192	sprintf(fileName, "Run%d.Event%d_%d.AOD.tag.root",
	193	fAODEvent->GetRunNumber(), fFirstEvent, lastEvent );
	194	AliInfo(Form("writing tags to file %s", fileName));
	195	AliDebug(1, Form("writing tags to file %s", fileName));
	196
	197	TFile* ftag = TFile::Open(fileName, "recreate");
	198
24ae0874	199	fRunTag = new AliRunTag();
6e557e6d	200	fTreeT = new TTree("T","A Tree with event tags");
	201	TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
	202	btag->SetCompressionLevel(9);
	203
	204	CreateTags();
	205
	206	ftag->cd();
	207	fTreeT->Fill();
	208	fRunTag->Clear();
	209	fTreeT->Write();
	210	ftag->Close();
	211	file->cd();
	212	file->Close();
a1069ee1	213	}
a1069ee1	214
103d3fba	215	//_____________________________________________________________________________
5222362f	216	void AliAODTagCreator::CreateTag(TChain* chain, const char *type) {
6e557e6d	217
	218	// Private method that creates tag files
	219	//
	220
a69c1246	221	//reading the esd tag file
6e557e6d	222	fTreeTEsd = new TChain("T");
	223	const char * tagPattern = "ESD.tag";
	224	// Open the working directory
	225	void * dirp = gSystem->OpenDirectory(gSystem->pwd());
	226	const char * name = 0x0;
	227	// Add all files matching pattern to the chain
	228	while((name = gSystem->GetDirEntry(dirp))) {
	229	if (strstr(name,tagPattern)) fTreeTEsd->Add(name);
	230	}//directory loop
04cb11d4	231	AliInfo(Form("Chained tag files: %lld",fTreeTEsd->GetEntries()));
a69c1246	232
6e557e6d	233	fChain = chain;
	234
	235	TString fSession = type;
	236	TString fguid, fmd5, fturl;
	237	fAODEvent = new AliAODEvent();
	238	fAODEvent->ReadFromTree(fChain);
103d3fba	239
6e557e6d	240	Int_t firstEvent = 0;
	241
	242	TString localFileName = "Run";
	243	localFileName += fAODEvent->GetRunNumber();
	244	localFileName += ".Event";
	245	localFileName += firstEvent;
	246	localFileName += "_";
	247	localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
	248	localFileName += ".AOD.tag.root";
	249
	250	TString fileName;
103d3fba	251
6e557e6d	252	if(fStorage == 0) {
	253	fileName = localFileName.Data();
	254	AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
103d3fba	255	}
6e557e6d	256	else if(fStorage == 1) {
	257	TString alienLocation = "/alien";
	258	alienLocation += gGrid->Pwd();
	259	alienLocation += fgridpath.Data();
	260	alienLocation += "/";
	261	alienLocation += localFileName;
	262	alienLocation += "?se=";
	263	alienLocation += fSE.Data();
	264	fileName = alienLocation.Data();
	265	AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
103d3fba	266	}
103d3fba	267
6e557e6d	268	TFile* ftag = TFile::Open(fileName, "recreate");
	269
	270	fRunTag = new AliRunTag();
	271	fTreeT = new TTree("T", "A Tree with event tags");
	272	TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
	273	btag->SetCompressionLevel(9);
	274
	275	// Access information from esd tag
	276	fRunTagEsd = new AliRunTag();
	277	fTreeTEsd->SetBranchAddress("AliTAG",&fRunTagEsd);
	278	// Creating new information of aod
	279	AliInfo(Form("Creating the AOD tags......."));
	280	CreateTags(type);
	281	ftag->cd();
	282	fRunTag->Clear();
	283	fTreeT->Write();
	284	ftag->Close();
103d3fba	285	}
103d3fba	286
6e557e6d	287	void AliAODTagCreator::CreateTags(const char* type)
	288	{
	289	// Event loop for tag creation
	290	TString fturl;
	291	TString fguid;
	292	Int_t oldRun = -1;
	293	fChain->GetEntry(0);
	294	TFile *f = fChain->GetFile();
	295	TString ftempGuid = f->GetUUID().AsString();
	296	// Loop over events
	297	Int_t nEvents = fChain->GetEntries();
	298	Int_t ntags = 0;
	299	Int_t tagentry = 0;
1435c1da	300	// const TClonesArray *evTagList = 0;
04cb11d4	301	TString foldguid = "";
04cb11d4	302
6e557e6d	303	for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
	304	// Copy old tag information
	305	if (iEventNumber >= ntags) {
	306	fTreeTEsd->GetEntry(tagentry++);
	307	fRunTag->CopyStandardContent(fRunTagEsd);
04cb11d4	308	// evTagList = fRunTagEsd->GetEventTags();
	309	// ntags += evTagList->GetEntries();
	310	ntags = fRunTagEsd->GetNEvents();
6e557e6d	311	}
5b8d5d69	312
6e557e6d	313	// Create a new Tag
	314	AliEventTag* evTag = new AliEventTag();
	315	// Read event
	316	fChain->GetEntry(iEventNumber);
	317	if (iEventNumber == 0) oldRun = fAODEvent->GetRunNumber();
	318	// Reference to the input file
	319	TFile *file = fChain->GetFile();
	320	const TUrl *url = file->GetEndpointUrl();
	321	fguid = file->GetUUID().AsString();
	322
f12d42ce	323	if (!strcmp(type,"grid")) {
6e557e6d	324	TString fturltemp = "alien://"; fturltemp += url->GetFile();
	325	fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
	326	} else {
	327	fturl = url->GetFile();
	328	}
	329
	330	fAODEvent->GetStdContent();
	331
	332	// Fill the event tag from the aod informatiom
	333	FillEventTag(fAODEvent, evTag);
	334	// Set the event and input file references
7e3c2e04	335	//evTag->SetEventId(iEventNumber+1);
04cb11d4	336
	337	// ** FIXME **
	338	// evTag->SetGUID(fguid);
	339	// if(!strcmp(type,"grid")) {
	340	// evTag->SetMD5("");
	341	// evTag->SetTURL(fturl);
	342	// evTag->SetSize(0);
	343	// }
	344	// else evTag->SetPath(fturl);
	345	// ** FIXME **
6e557e6d	346
	347	// Check if a new run has to be created
	348	// File has changed
	349	if(fguid != ftempGuid) {
	350	ftempGuid = fguid;
	351	fTreeT->Fill();
	352	fRunTag->Clear("");
04cb11d4	353
	354	AliFileTag *nftag = new AliFileTag();
	355
29137589	356	// if(fSession == "grid") {
04cb11d4	357	nftag->SetMD5("");
	358	nftag->SetTURL(fturl);
	359	nftag->SetSize(0);
29137589	360	// }
	361	// else {
	362	// nftag->SetPath(fturl);
	363	// nftag->SetSize(0);
	364	// nftag->SetMD5("");
	365	// nftag->SetTURL(fturl);
	366	// }
04cb11d4	367
	368	if (fRunTag->GetFileId(fguid) > -1)
	369	AliFatal("Adding a file which is already in the RunTag.");
	370
	371	fRunTag->AddFileTag(nftag);
	372
6e557e6d	373	}
04cb11d4	374
6e557e6d	375	// Run# has changed
	376	if (oldRun != (fAODEvent->GetRunNumber()))
	377	{
	378	oldRun = fAODEvent->GetRunNumber();
04cb11d4	379
	380	fTreeT->Fill();
	381	fRunTag->Clear("");
	382	ftempGuid = fguid;
6e557e6d	383	fTreeT->Fill();
6e557e6d	384	fRunTag->Clear("");
04cb11d4	385
	386	AliFileTag *nftag = new AliFileTag();
	387
29137589	388	// if(fSession == "grid") {
04cb11d4	389	nftag->SetMD5("");
	390	nftag->SetTURL(fturl);
	391	nftag->SetSize(0);
29137589	392	// }
	393	// else {
	394	// nftag->SetPath(fturl);
	395	// nftag->SetSize(0);
	396	// nftag->SetMD5("");
	397	// nftag->SetTURL(fturl);
	398	// }
04cb11d4	399
	400	if (fRunTag->GetFileId(fguid) > -1)
	401	AliFatal("Adding a file which is already in the RunTag.");
	402
	403	fRunTag->AddFileTag(nftag);
	404
6e557e6d	405	}
	406
	407	// Add the event tag
	408	fRunTag->AddEventTag(*evTag);
	409	delete evTag;
	410	// Last event
	411	if(iEventNumber+1 == fChain->GetEntries()) {
	412	fTreeT->Fill();
	413	fRunTag->Clear("");
	414	}
	415	}//event loop
	416	}
5b8d5d69	417
5b8d5d69	418
5b8d5d69	419
6e557e6d	420	void AliAODTagCreator::FillEventTag(AliAODEvent* aod, AliEventTag* evTag)
	421	{
	422	//
	423	// Fill the event tag information
	424	//
	425	fAODEvent = aod;
	426
	427	//
	428	Float_t fLowPtCut = 1.0;
	429	Float_t fHighPtCut = 3.0;
	430	Float_t fVeryHighPtCut = 10.0;
	431	////////////
	432	Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
	433
	434	// Creates the tags for all the events in a given AOD file
	435	Int_t ntrack = 0;
	436	Int_t nPos = 0, nNeg = 0, nNeutr =0;
	437	Int_t nKinks = 0, nV0s = 0, nCascades = 0;
	438	Int_t nK0s = 0, nNeutrons = 0, nPi0s = 0, nGamas = 0;
d3893274	439	Int_t nProtons = 0, nKaons = 0, nPions = 0, nMuons = 0, nElectrons = 0, nFWMuons = 0;
6e557e6d	440	Int_t nCh1GeV = 0, nCh3GeV = 0, nCh10GeV = 0;
	441	Int_t nMu1GeV = 0, nMu3GeV = 0, nMu10GeV = 0;
	442	Int_t nEl1GeV = 0, nEl3GeV = 0, nEl10GeV = 0;
73e1181d	443	Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
6e557e6d	444
a69c1246	445	TRefArray tmp;
a69c1246	446
73e1181d	447
	448	// Primary Vertex
	449	AliAODVertex *pVertex = fAODEvent->GetPrimaryVertex();
	450	if (pVertex) {
	451	evTag->SetVertexX(pVertex->GetX());
	452	evTag->SetVertexY(pVertex->GetY());
	453	evTag->SetVertexZ(pVertex->GetZ());
	454	Double_t covmatrix[6];
	455	pVertex->GetCovarianceMatrix(covmatrix);
	456	evTag->SetVertexZError(sqrt(covmatrix[5]));
	457	}
5b8d5d69	458	// loop over vertices
6e557e6d	459	Int_t nVtxs = fAODEvent->GetNumberOfVertices();
5b8d5d69	460	for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
6e557e6d	461	AliAODVertex *vertex = fAODEvent->GetVertex(nVtx);
	462	if(vertex->GetType() == 1) nKinks += 1;
	463	if(vertex->GetType() == 2) nV0s += 1;
	464	if(vertex->GetType() == 3) nCascades += 1;
5b8d5d69	465	}
73e1181d	466	Int_t nTracks = fAODEvent->GetNTracks();
5b8d5d69	467	for (Int_t nTr = 0; nTr < nTracks; nTr++) {
6e557e6d	468	AliAODTrack *track = fAODEvent->GetTrack(nTr);
	469
	470	Double_t fPt = track->Pt();
73e1181d	471	if(fPt > maxPt) {
	472	maxPt = fPt;
	473	etamaxPt = track->Eta();
	474	phimaxPt = track->Phi();
	475	}
	476
6e557e6d	477	if(track->Charge() > 0) {
	478	nPos++;
	479	if(fPt > fLowPtCut) nCh1GeV++;
	480	if(fPt > fHighPtCut) nCh3GeV++;
	481	if(fPt > fVeryHighPtCut) nCh10GeV++;
	482	}
	483	if(track->Charge() < 0) {
	484	nNeg++;
	485	if(fPt > fLowPtCut) nCh1GeV++;
	486	if(fPt > fHighPtCut) nCh3GeV++;
	487	if(fPt > fVeryHighPtCut) nCh10GeV++;
	488	}
	489	if(track->Charge() == 0) nNeutr++;
	490	//PID
	491	const Double32_t *prob = track->PID();
	492	Double_t rcc = 0.0;
	493	for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
	494	if(rcc == 0.0) continue;
	495	//Bayes' formula
	496	Double_t w[10];
	497	for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
	498
	499	//protons
	500	if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
	501	//kaons
	502	if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
	503	//pions
	504	if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
	505	//muons
	506	if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
	507	nMuons++;
	508	if(fPt > fLowPtCut) nMu1GeV++;
	509	if(fPt > fHighPtCut) nMu3GeV++;
	510	if(fPt > fVeryHighPtCut) nMu10GeV++;
	511	}
	512	//electrons
	513	if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
	514	nElectrons++;
	515	if(fPt > fLowPtCut) nEl1GeV++;
	516	if(fPt > fHighPtCut) nEl3GeV++;
	517	if(fPt > fVeryHighPtCut) nEl10GeV++;
	518	}
6e557e6d	519	totalP += track->P();
	520	meanPt += fPt;
	521	ntrack++;
d3893274	522	// forward muons (in the dimuon spectrometer)
	523	if(track->IsMuonTrack()) nFWMuons++;
	524
5b8d5d69	525	}//track loop
6e557e6d	526	//
5b8d5d69	527	// Fill the event tags
5b8d5d69	528	if(ntrack != 0)
6e557e6d	529	meanPt = meanPt/ntrack;
a1069ee1	530
7ee67d2a	531
5b8d5d69	532	evTag->SetNumOfTracks(nTracks);
a1069ee1	533	evTag->SetNumOfPosTracks(nPos);
	534	evTag->SetNumOfNegTracks(nNeg);
	535	evTag->SetNumOfNeutrTracks(nNeutr);
	536
5b8d5d69	537	evTag->SetNumOfV0s(nV0s);
	538	evTag->SetNumOfCascades(nCascades);
	539	evTag->SetNumOfKinks(nKinks);
a1069ee1	540
	541	evTag->SetNumOfProtons(nProtons);
	542	evTag->SetNumOfKaons(nKaons);
	543	evTag->SetNumOfPions(nPions);
	544	evTag->SetNumOfMuons(nMuons);
d3893274	545	evTag->SetNumOfFWMuons(nFWMuons);
a1069ee1	546	evTag->SetNumOfElectrons(nElectrons);
	547	evTag->SetNumOfPhotons(nGamas);
	548	evTag->SetNumOfPi0s(nPi0s);
	549	evTag->SetNumOfNeutrons(nNeutrons);
	550	evTag->SetNumOfKaon0s(nK0s);
	551
	552	evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
	553	evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
	554	evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
	555	evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
	556	evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
	557	evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
	558	evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
	559	evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
	560	evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
a69c1246	561
	562	tmp.Clear();
	563	evTag->SetNumOfPHOSClusters(fAODEvent->GetPHOSClusters(&tmp));
	564	tmp.Clear();
	565	evTag->SetNumOfEMCALClusters(fAODEvent->GetEMCALClusters(&tmp));
6e557e6d	566
a1069ee1	567	evTag->SetTotalMomentum(totalP);
	568	evTag->SetMeanPt(meanPt);
	569	evTag->SetMaxPt(maxPt);
73e1181d	570	evTag->SetEtaMaxPt(etamaxPt);
73e1181d	571	evTag->SetPhiMaxPt(phimaxPt);
5b8d5d69	572	}