[u/mrichter/AliRoot.git] / STEER / AliTagCreator.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$ */

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

//ROOT
#include <TObject.h>
#include <Riostream.h>
#include <TSystem.h>
#include <TChain.h>
#include <TFile.h>
#include <TString.h>
#include <THashTable.h>

//ROOT-AliEn
#include <TGrid.h>
//#include <TAlienCollection.h>
#include <TGridResult.h>
#include <TFileMerger.h>
#include <TMap.h>
#include <TXMLParser.h>
#include <TThread.h>
#include <TTreePlayer.h>
#include <TProof.h>

//AliRoot
#include "AliRunTag.h"
#include "AliEventTag.h"
#include "AliESD.h"
#include "AliESDVertex.h"
#include "AliPID.h"
#include "AliESDpid.h"
#include "AliLog.h"


#include "AliTagCreator.h"


ClassImp(AliTagCreator)


//______________________________________________________________________________
AliTagCreator::AliTagCreator() //local mode
{
  //==============Default constructor for a AliTagCreator==================
  fUser = "";
  fPasswd = "";  
  fSE = "";   
  fHost = "";
  fPort = 0; 
  fresult = 0;
}

//______________________________________________________________________________
AliTagCreator::AliTagCreator(const char *host, Int_t port, const char *username)
{
  //==============Default constructor for a AliTagCreator==================
  fresult = 0;
  fHost = host;
  fUser = username;
  fPort = port;

  TString grid = "alien://";
  grid += fHost;
  grid += ":";
  grid += port;
  
  //connect to the grid
  TGrid::Connect(grid.Data(),fUser.Data());
  if(!gGrid)
    {
      AliError("Connection failed!!!");
      return;
    }
}


//______________________________________________________________________________
AliTagCreator::AliTagCreator(const char *host, Int_t port, const char *username, const char *passwd)
{
  //==============Default constructor for a AliTagCreator==================
  fresult = 0;
  fHost = host;
  fUser = username;
  fPasswd = passwd;
  fPort = port;

  TString grid = "alien://";
  grid += fHost;
  grid += ":";
  grid += port;
  
  //connect to the grid
  TGrid::Connect(grid.Data(),fUser.Data(),fPasswd.Data());
   if(!gGrid)
    {
      AliError("Connection failed!!!");
      return;
    }
}


//______________________________________________________________________________
AliTagCreator::~AliTagCreator()
{
//================Default destructor for a AliTagCreator=======================
}

//______________________________________________________________________________
void AliTagCreator::SetSE(const char *se)
{
  fSE = se;
}

//______________________________________________________________________________
Bool_t AliTagCreator::ConnectToGrid(const char *host, Int_t port, const char *username)
{
  fHost = host;
  fUser = username;
  fPort = port;

  TString grid = "alien://";
  grid += fHost;
  grid += ":";
  grid += port;
  
  //connect to the grid
  TGrid::Connect(grid.Data(),fUser.Data());
  if(!gGrid)
    {
      AliError("Connection failed!!!");
      return kFALSE;
    } //connect to the grid

  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliTagCreator::ReadESDCollection(TGridResult *res)
{
  fresult = res;
  Int_t NEntries = fresult->GetEntries();

  TString gridname = "alien://";
  TString AlienUrl;
  const char *guid;
 
  Int_t counter = 0;
  for(Int_t i = 0; i < NEntries; i++)
    {
      AlienUrl = gridname;
      AlienUrl += fresult->GetKey(i,"lfn");
      guid = fresult->GetKey(i,"guid");
      TFile *f = TFile::Open(AlienUrl,"READ");
      CreateTag(f,guid,counter);
      f->Close();
      delete f;	 
      counter += 1;
    }//grid result loop

  return kTRUE;
}


//_____________________________________________________________________________
void AliTagCreator::CreateTag(TFile* file, const char *guid, Int_t Counter)
{
  Int_t ntrack;
  Int_t NProtons, NKaons, NPions, NMuons, NElectrons;
  Int_t Npos, Nneg, Nneutr;
  Int_t NK0s, Nneutrons, Npi0s, Ngamas;
  Int_t Nch1GeV, Nch3GeV, Nch10GeV;
  Int_t Nmu1GeV, Nmu3GeV, Nmu10GeV;
  Int_t Nel1GeV, Nel3GeV, Nel10GeV;
  Float_t MaxPt = .0, MeanPt = .0, TotalP = .0;

  AliRunTag *tag = new AliRunTag();
  AliDetectorTag *detTag = new AliDetectorTag();
  AliEventTag *evTag = new AliEventTag();
  TTree ttag("T","A Tree with event tags");
  TBranch * btag = ttag.Branch("AliTAG", "AliRunTag", &tag);
  btag->SetCompressionLevel(9);
  
  AliInfo(Form("Creating the tags......."));	
  
  Int_t firstEvent = 0,lastEvent = 0;
  TTree *t = (TTree*) file->Get("esdTree");
  TBranch * b = t->GetBranch("ESD");
  AliESD *esd = 0;
  b->SetAddress(&esd);
  
  tag->SetRunId(esd->GetRunNumber());
  
  Int_t i_NumberOfEvents = b->GetEntries();
  for (Int_t i_EventNumber = 0; i_EventNumber < i_NumberOfEvents; i_EventNumber++)
    {
      ntrack = 0;
      Npos = 0;
      Nneg = 0;
      Nneutr =0;
      NK0s = 0;
      Nneutrons = 0;
      Npi0s = 0;
      Ngamas = 0;
      NProtons = 0;
      NKaons = 0;
      NPions = 0;
      NMuons = 0;
      NElectrons = 0;	  
      Nch1GeV = 0;
      Nch3GeV = 0;
      Nch10GeV = 0;
      Nmu1GeV = 0;
      Nmu3GeV = 0;
      Nmu10GeV = 0;
      Nel1GeV = 0;
      Nel3GeV = 0;
      Nel10GeV = 0;
      MaxPt = .0;
      MeanPt = .0;
      TotalP = .0;
      
      b->GetEntry(i_EventNumber);
      const AliESDVertex * VertexIn = esd->GetVertex();
      
      for (Int_t i_TrackNumber = 0; i_TrackNumber < esd->GetNumberOfTracks(); i_TrackNumber++)
	{
	  AliESDtrack * ESDTrack = esd->GetTrack(i_TrackNumber);
	  UInt_t status = ESDTrack->GetStatus();
	  
	  //select only tracks with ITS refit
	  if ((status&AliESDtrack::kITSrefit)==0) continue;
	  
	  //select only tracks with TPC refit-->remove extremely high Pt tracks
	  if ((status&AliESDtrack::kTPCrefit)==0) continue;
	  
	  //select only tracks with the "combined PID"
	  if ((status&AliESDtrack::kESDpid)==0) continue;
	  Double_t p[3];
	  ESDTrack->GetPxPyPz(p);
	  Double_t P = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
	  Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
	  TotalP += P;
	  MeanPt += fPt;
	  if(fPt > MaxPt)
	    MaxPt = fPt;
	  
	  if(ESDTrack->GetSign() > 0)
	    {
	      Npos++;
	      if(fPt > 1.0)
		Nch1GeV++;
	      if(fPt > 3.0)
		Nch3GeV++;
	      if(fPt > 10.0)
		Nch10GeV++;
	    }
	  if(ESDTrack->GetSign() < 0)
	    {
	      Nneg++;
	      if(fPt > 1.0)
		Nch1GeV++;
	      if(fPt > 3.0)
		Nch3GeV++;
	      if(fPt > 10.0)
		Nch10GeV++;
	    }
	  if(ESDTrack->GetSign() == 0)
	    Nneutr++;
	  
	  //PID
	  Double_t prob[10];
	  ESDTrack->GetESDpid(prob);
	  
	  //K0s
	  if ((prob[8]>prob[7])&&(prob[8]>prob[6])&&(prob[8]>prob[5])&&(prob[8]>prob[4])&&(prob[8]>prob[3])&&(prob[8]>prob[2])&&(prob[8]>prob[1])&&(prob[8]>prob[0]))
	    NK0s++;
	  //neutrons
	  if ((prob[7]>prob[8])&&(prob[7]>prob[6])&&(prob[7]>prob[5])&&(prob[7]>prob[4])&&(prob[7]>prob[3])&&(prob[7]>prob[2])&&(prob[7]>prob[1])&&(prob[7]>prob[0]))
	    Nneutrons++; 
	  //pi0s
	  if ((prob[6]>prob[8])&&(prob[6]>prob[7])&&(prob[6]>prob[5])&&(prob[6]>prob[4])&&(prob[6]>prob[3])&&(prob[6]>prob[2])&&(prob[6]>prob[1])&&(prob[6]>prob[0]))
	    Npi0s++;
	  //gamas
	  if ((prob[5]>prob[8])&&(prob[5]>prob[7])&&(prob[5]>prob[6])&&(prob[5]>prob[4])&&(prob[5]>prob[3])&&(prob[5]>prob[2])&&(prob[5]>prob[1])&&(prob[5]>prob[0]))
	    Ngamas++;
	  //protons
	  if ((prob[4]>prob[8])&&(prob[4]>prob[7])&&(prob[4]>prob[6])&&(prob[4]>prob[5])&&(prob[4]>prob[3])&&(prob[4]>prob[2])&&(prob[4]>prob[1])&&(prob[4]>prob[0]))
	    NProtons++;
	  //kaons
	  if ((prob[3]>prob[8])&&(prob[3]>prob[7])&&(prob[3]>prob[6])&&(prob[3]>prob[5])&&(prob[3]>prob[4])&&(prob[3]>prob[2])&&(prob[3]>prob[1])&&(prob[3]>prob[0]))
	    NKaons++;
	  //pions
	  if ((prob[2]>prob[8])&&(prob[2]>prob[7])&&(prob[2]>prob[6])&&(prob[2]>prob[5])&&(prob[2]>prob[4])&&(prob[2]>prob[3])&&(prob[2]>prob[1])&&(prob[2]>prob[0]))
	    NPions++; 
	  //muons
	  if ((prob[1]>prob[8])&&(prob[1]>prob[7])&&(prob[1]>prob[6])&&(prob[1]>prob[5])&&(prob[1]>prob[4])&&(prob[1]>prob[3])&&(prob[1]>prob[2])&&(prob[1]>prob[0]))
	    {
	      NMuons++;
	      if(fPt > 1.0)
		Nmu1GeV++;
	      if(fPt > 3.0)
		Nmu3GeV++;
	      if(fPt > 10.0)
		Nmu10GeV++;
	    }
	  //electrons
	  if ((prob[0]>prob[8])&&(prob[0]>prob[7])&&(prob[0]>prob[6])&&(prob[0]>prob[5])&&(prob[0]>prob[4])&&(prob[0]>prob[3])&&(prob[0]>prob[2])&&(prob[0]>prob[1]))
	    {
	      NElectrons++;
	      if(fPt > 1.0)
		Nel1GeV++;
	      if(fPt > 3.0)
		Nel3GeV++;
	      if(fPt > 10.0)
		Nel10GeV++;
	    }
	  
	  
	  ntrack++;
	}//track loop
      // Fill the event tags 
      if(ntrack != 0)
	MeanPt = MeanPt/ntrack;
      
      evTag->SetEventId(i_EventNumber+1);
      evTag->SetGUID(guid);
      evTag->SetVertexX(VertexIn->GetXv());
      evTag->SetVertexY(VertexIn->GetYv());
      evTag->SetVertexZ(VertexIn->GetZv());
      
      evTag->SetT0VertexZ(esd->GetT0zVertex());
      
      evTag->SetTrigger(esd->GetTrigger());
      
      evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy());
      evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy());
      evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
      evTag->SetNumOfParticipants(esd->GetZDCParticipants());
      
      
      evTag->SetNumOfTracks(esd->GetNumberOfTracks());
      evTag->SetNumOfPosTracks(Npos);
      evTag->SetNumOfNegTracks(Nneg);
      evTag->SetNumOfNeutrTracks(Nneutr);
      
      evTag->SetNumOfV0s(esd->GetNumberOfV0s());
      evTag->SetNumOfCascades(esd->GetNumberOfCascades());
      evTag->SetNumOfKinks(esd->GetNumberOfKinks());
      evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
      
      evTag->SetNumOfProtons(NProtons);
      evTag->SetNumOfKaons(NKaons);
      evTag->SetNumOfPions(NPions);
      evTag->SetNumOfMuons(NMuons);
      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);
      
      evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles());
      evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles());
      
      evTag->SetTotalMomentum(TotalP);
      evTag->SetMeanPt(MeanPt);
      evTag->SetMaxPt(MaxPt);
  
      tag->AddEventTag(evTag);
    }
  lastEvent = i_NumberOfEvents;
  
  t->Delete("");
	
  ttag.Fill();
  tag->Clear();

  TString LocalfileName = "Run"; LocalfileName += tag->GetRunId(); 
  LocalfileName += ".Event"; LocalfileName += firstEvent; LocalfileName += "_"; LocalfileName += lastEvent; LocalfileName += "."; LocalfileName += Counter;
  LocalfileName += ".ESD.tag.root";

  cout<<"Writing tags to local file: "<<LocalfileName<<endl;

  TFile* ftag = TFile::Open(LocalfileName, "recreate");
  ftag->cd();
  ttag.Write();
  ftag->Close();

  delete ftag;
  delete esd;

  delete tag;
  delete detTag;
  delete evTag;
}

//_____________________________________________________________________________
Bool_t AliTagCreator::StoreGridTagFile(const char *localpath, const char *gridpath)
{
  gSystem->Load("libThread.so");
  gSystem->Load("libTreePlayer.so");
  gSystem->Load("libProof.so");
  cout<<"Storing tag file to alien's file catalog..."<<endl;
  TFileMerger merger;
  const char * pattern = "tag.root";
  // Open the working directory
  void * dirp = gSystem->OpenDirectory(localpath);
  const char * name = 0x0;
  TString AlienLocation;
  Char_t LocalLocation[256];
 
  // Add all files matching *pattern* to the chain
  while((name = gSystem->GetDirEntry(dirp)))
    {
      if (strstr(name,pattern))
	{
	  sprintf(LocalLocation,"file:%s/%s",localpath,name);
	  AlienLocation = "/alien";
	  AlienLocation += gGrid->Pwd();
	  AlienLocation += gridpath;
	  AlienLocation += "/";
	  AlienLocation += name;
	  AlienLocation += "?se=";
	  AlienLocation += fSE.Data();
	  merger.Cp(LocalLocation,AlienLocation);
	    
	}
    }	
  gSystem->FreeDirectory(dirp);
   
  return kTRUE;
}
Commit	Line	Data
b45e5084	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	// AliTagCreator 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 <TObject.h>
	24	#include <Riostream.h>
	25	#include <TSystem.h>
	26	#include <TChain.h>
	27	#include <TFile.h>
	28	#include <TString.h>
	29	#include <THashTable.h>
	30
	31	//ROOT-AliEn
	32	#include <TGrid.h>
09c52d4a	33	//#include <TAlienCollection.h>
b45e5084	34	#include <TGridResult.h>
	35	#include <TFileMerger.h>
	36	#include <TMap.h>
	37	#include <TXMLParser.h>
	38	#include <TThread.h>
	39	#include <TTreePlayer.h>
	40	#include <TProof.h>
	41
	42	//AliRoot
	43	#include "AliRunTag.h"
	44	#include "AliEventTag.h"
	45	#include "AliESD.h"
	46	#include "AliESDVertex.h"
	47	#include "AliPID.h"
	48	#include "AliESDpid.h"
	49	#include "AliLog.h"
	50
	51
	52	#include "AliTagCreator.h"
	53
	54
	55	ClassImp(AliTagCreator)
	56
	57
	58	//______________________________________________________________________________
	59	AliTagCreator::AliTagCreator() //local mode
	60	{
	61	//==============Default constructor for a AliTagCreator==================
	62	fUser = "";
	63	fPasswd = "";
	64	fSE = "";
b45e5084	65	fHost = "";
b45e5084	66	fPort = 0;
09c52d4a	67	fresult = 0;
b45e5084	68	}
	69
	70	//______________________________________________________________________________
	71	AliTagCreator::AliTagCreator(const char host, Int_t port, const char username)
	72	{
	73	//==============Default constructor for a AliTagCreator==================
09c52d4a	74	fresult = 0;
b45e5084	75	fHost = host;
	76	fUser = username;
	77	fPort = port;
	78
	79	TString grid = "alien://";
	80	grid += fHost;
	81	grid += ":";
	82	grid += port;
	83
	84	//connect to the grid
	85	TGrid::Connect(grid.Data(),fUser.Data());
	86	if(!gGrid)
	87	{
	88	AliError("Connection failed!!!");
	89	return;
	90	}
	91	}
	92
	93
	94	//______________________________________________________________________________
	95	AliTagCreator::AliTagCreator(const char host, Int_t port, const char username, const char *passwd)
	96	{
	97	//==============Default constructor for a AliTagCreator==================
09c52d4a	98	fresult = 0;
b45e5084	99	fHost = host;
	100	fUser = username;
	101	fPasswd = passwd;
	102	fPort = port;
	103
	104	TString grid = "alien://";
	105	grid += fHost;
	106	grid += ":";
	107	grid += port;
	108
	109	//connect to the grid
	110	TGrid::Connect(grid.Data(),fUser.Data(),fPasswd.Data());
	111	if(!gGrid)
	112	{
	113	AliError("Connection failed!!!");
	114	return;
	115	}
	116	}
	117
	118
	119	//______________________________________________________________________________
	120	AliTagCreator::~AliTagCreator()
	121	{
	122	//================Default destructor for a AliTagCreator=======================
	123	}
	124
	125	//______________________________________________________________________________
	126	void AliTagCreator::SetSE(const char *se)
	127	{
	128	fSE = se;
	129	}
	130
	131	//______________________________________________________________________________
	132	Bool_t AliTagCreator::ConnectToGrid(const char host, Int_t port, const char username)
	133	{
	134	fHost = host;
	135	fUser = username;
	136	fPort = port;
	137
	138	TString grid = "alien://";
	139	grid += fHost;
	140	grid += ":";
	141	grid += port;
	142
	143	//connect to the grid
	144	TGrid::Connect(grid.Data(),fUser.Data());
	145	if(!gGrid)
	146	{
	147	AliError("Connection failed!!!");
	148	return kFALSE;
	149	} //connect to the grid
	150
	151	return kTRUE;
	152	}
	153
	154	//______________________________________________________________________________
09c52d4a	155	Bool_t AliTagCreator::ReadESDCollection(TGridResult *res)
b45e5084	156	{
09c52d4a	157	fresult = res;
09c52d4a	158	Int_t NEntries = fresult->GetEntries();
b45e5084	159
b45e5084	160	TString gridname = "alien://";
b45e5084	161	TString AlienUrl;
b45e5084	162	const char *guid;
b45e5084	163
b45e5084	164	Int_t counter = 0;
09c52d4a	165	for(Int_t i = 0; i < NEntries; i++)
	166	{
	167	AlienUrl = gridname;
	168	AlienUrl += fresult->GetKey(i,"lfn");
	169	guid = fresult->GetKey(i,"guid");
	170	TFile *f = TFile::Open(AlienUrl,"READ");
	171	CreateTag(f,guid,counter);
	172	f->Close();
	173	delete f;
b45e5084	174	counter += 1;
09c52d4a	175	}//grid result loop
b45e5084	176
	177	return kTRUE;
	178	}
	179
	180
	181	//_____________________________________________________________________________
	182	void AliTagCreator::CreateTag(TFile* file, const char *guid, Int_t Counter)
	183	{
	184	Int_t ntrack;
	185	Int_t NProtons, NKaons, NPions, NMuons, NElectrons;
	186	Int_t Npos, Nneg, Nneutr;
	187	Int_t NK0s, Nneutrons, Npi0s, Ngamas;
	188	Int_t Nch1GeV, Nch3GeV, Nch10GeV;
	189	Int_t Nmu1GeV, Nmu3GeV, Nmu10GeV;
	190	Int_t Nel1GeV, Nel3GeV, Nel10GeV;
	191	Float_t MaxPt = .0, MeanPt = .0, TotalP = .0;
	192
	193	AliRunTag *tag = new AliRunTag();
	194	AliDetectorTag *detTag = new AliDetectorTag();
	195	AliEventTag *evTag = new AliEventTag();
	196	TTree ttag("T","A Tree with event tags");
	197	TBranch * btag = ttag.Branch("AliTAG", "AliRunTag", &tag);
	198	btag->SetCompressionLevel(9);
	199
	200	AliInfo(Form("Creating the tags......."));
	201
	202	Int_t firstEvent = 0,lastEvent = 0;
	203	TTree t = (TTree) file->Get("esdTree");
	204	TBranch * b = t->GetBranch("ESD");
	205	AliESD *esd = 0;
	206	b->SetAddress(&esd);
	207
	208	tag->SetRunId(esd->GetRunNumber());
	209
	210	Int_t i_NumberOfEvents = b->GetEntries();
	211	for (Int_t i_EventNumber = 0; i_EventNumber < i_NumberOfEvents; i_EventNumber++)
	212	{
	213	ntrack = 0;
	214	Npos = 0;
	215	Nneg = 0;
	216	Nneutr =0;
	217	NK0s = 0;
	218	Nneutrons = 0;
	219	Npi0s = 0;
	220	Ngamas = 0;
	221	NProtons = 0;
	222	NKaons = 0;
	223	NPions = 0;
	224	NMuons = 0;
	225	NElectrons = 0;
	226	Nch1GeV = 0;
	227	Nch3GeV = 0;
	228	Nch10GeV = 0;
	229	Nmu1GeV = 0;
	230	Nmu3GeV = 0;
	231	Nmu10GeV = 0;
	232	Nel1GeV = 0;
	233	Nel3GeV = 0;
	234	Nel10GeV = 0;
	235	MaxPt = .0;
	236	MeanPt = .0;
	237	TotalP = .0;
	238
	239	b->GetEntry(i_EventNumber);
240	const AliESDVertex * VertexIn = esd->GetVertex();
241
242	for (Int_t i_TrackNumber = 0; i_TrackNumber < esd->GetNumberOfTracks(); i_TrackNumber++)
243	{
244	AliESDtrack * ESDTrack = esd->GetTrack(i_TrackNumber);
245	UInt_t status = ESDTrack->GetStatus();
246
247	//select only tracks with ITS refit
248	if ((status&AliESDtrack::kITSrefit)==0) continue;
249
250	//select only tracks with TPC refit-->remove extremely high Pt tracks
251	if ((status&AliESDtrack::kTPCrefit)==0) continue;
252
253	//select only tracks with the "combined PID"
254	if ((status&AliESDtrack::kESDpid)==0) continue;
255	Double_t p[3];
256	ESDTrack->GetPxPyPz(p);
257	Double_t P = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
258	Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
259	TotalP += P;
260	MeanPt += fPt;
261	if(fPt > MaxPt)
262	MaxPt = fPt;
263
264	if(ESDTrack->GetSign() > 0)
265	{
266	Npos++;
267	if(fPt > 1.0)
268	Nch1GeV++;
269	if(fPt > 3.0)
270	Nch3GeV++;
271	if(fPt > 10.0)
272	Nch10GeV++;
273	}
274	if(ESDTrack->GetSign() < 0)
275	{
276	Nneg++;
277	if(fPt > 1.0)
278	Nch1GeV++;
279	if(fPt > 3.0)
280	Nch3GeV++;
281	if(fPt > 10.0)
282	Nch10GeV++;
283	}
284	if(ESDTrack->GetSign() == 0)
285	Nneutr++;
286
287	//PID
288	Double_t prob[10];
289	ESDTrack->GetESDpid(prob);
290
291	//K0s
292	if ((prob[8]>prob[7])&&(prob[8]>prob[6])&&(prob[8]>prob[5])&&(prob[8]>prob[4])&&(prob[8]>prob[3])&&(prob[8]>prob[2])&&(prob[8]>prob[1])&&(prob[8]>prob[0]))
293	NK0s++;
294	//neutrons
295	if ((prob[7]>prob[8])&&(prob[7]>prob[6])&&(prob[7]>prob[5])&&(prob[7]>prob[4])&&(prob[7]>prob[3])&&(prob[7]>prob[2])&&(prob[7]>prob[1])&&(prob[7]>prob[0]))
296	Nneutrons++;
297	//pi0s
298	if ((prob[6]>prob[8])&&(prob[6]>prob[7])&&(prob[6]>prob[5])&&(prob[6]>prob[4])&&(prob[6]>prob[3])&&(prob[6]>prob[2])&&(prob[6]>prob[1])&&(prob[6]>prob[0]))
299	Npi0s++;
300	//gamas
301	if ((prob[5]>prob[8])&&(prob[5]>prob[7])&&(prob[5]>prob[6])&&(prob[5]>prob[4])&&(prob[5]>prob[3])&&(prob[5]>prob[2])&&(prob[5]>prob[1])&&(prob[5]>prob[0]))
302	Ngamas++;
303	//protons
304	if ((prob[4]>prob[8])&&(prob[4]>prob[7])&&(prob[4]>prob[6])&&(prob[4]>prob[5])&&(prob[4]>prob[3])&&(prob[4]>prob[2])&&(prob[4]>prob[1])&&(prob[4]>prob[0]))
305	NProtons++;
306	//kaons
307	if ((prob[3]>prob[8])&&(prob[3]>prob[7])&&(prob[3]>prob[6])&&(prob[3]>prob[5])&&(prob[3]>prob[4])&&(prob[3]>prob[2])&&(prob[3]>prob[1])&&(prob[3]>prob[0]))
308	NKaons++;
309	//pions
310	if ((prob[2]>prob[8])&&(prob[2]>prob[7])&&(prob[2]>prob[6])&&(prob[2]>prob[5])&&(prob[2]>prob[4])&&(prob[2]>prob[3])&&(prob[2]>prob[1])&&(prob[2]>prob[0]))
311	NPions++;
312	//muons
313	if ((prob[1]>prob[8])&&(prob[1]>prob[7])&&(prob[1]>prob[6])&&(prob[1]>prob[5])&&(prob[1]>prob[4])&&(prob[1]>prob[3])&&(prob[1]>prob[2])&&(prob[1]>prob[0]))
314	{
315	NMuons++;
316	if(fPt > 1.0)
317	Nmu1GeV++;
318	if(fPt > 3.0)
319	Nmu3GeV++;
320	if(fPt > 10.0)
321	Nmu10GeV++;
322	}
323	//electrons
324	if ((prob[0]>prob[8])&&(prob[0]>prob[7])&&(prob[0]>prob[6])&&(prob[0]>prob[5])&&(prob[0]>prob[4])&&(prob[0]>prob[3])&&(prob[0]>prob[2])&&(prob[0]>prob[1]))
325	{
326	NElectrons++;
327	if(fPt > 1.0)
328	Nel1GeV++;
329	if(fPt > 3.0)
330	Nel3GeV++;
331	if(fPt > 10.0)
332	Nel10GeV++;
333	}
334
335
336
337	ntrack++;
338	}//track loop
339	// Fill the event tags
340	if(ntrack != 0)
341	MeanPt = MeanPt/ntrack;
342
343	evTag->SetEventId(i_EventNumber+1);
344	evTag->SetGUID(guid);
345	evTag->SetVertexX(VertexIn->GetXv());
346	evTag->SetVertexY(VertexIn->GetYv());
347	evTag->SetVertexZ(VertexIn->GetZv());
348
349	evTag->SetT0VertexZ(esd->GetT0zVertex());
350
351	evTag->SetTrigger(esd->GetTrigger());
352
353	evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy());
354	evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy());
355	evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
356	evTag->SetNumOfParticipants(esd->GetZDCParticipants());
357
358
359	evTag->SetNumOfTracks(esd->GetNumberOfTracks());
360	evTag->SetNumOfPosTracks(Npos);
361	evTag->SetNumOfNegTracks(Nneg);
362	evTag->SetNumOfNeutrTracks(Nneutr);
363
364	evTag->SetNumOfV0s(esd->GetNumberOfV0s());
365	evTag->SetNumOfCascades(esd->GetNumberOfCascades());
366	evTag->SetNumOfKinks(esd->GetNumberOfKinks());
367	evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
368
369	evTag->SetNumOfProtons(NProtons);
370	evTag->SetNumOfKaons(NKaons);
371	evTag->SetNumOfPions(NPions);
372	evTag->SetNumOfMuons(NMuons);
373	evTag->SetNumOfElectrons(NElectrons);
374	evTag->SetNumOfPhotons(Ngamas);
375	evTag->SetNumOfPi0s(Npi0s);
376	evTag->SetNumOfNeutrons(Nneutrons);
377	evTag->SetNumOfKaon0s(NK0s);
378
379	evTag->SetNumOfChargedAbove1GeV(Nch1GeV);
380	evTag->SetNumOfChargedAbove3GeV(Nch3GeV);
381	evTag->SetNumOfChargedAbove10GeV(Nch10GeV);
382	evTag->SetNumOfMuonsAbove1GeV(Nmu1GeV);
383	evTag->SetNumOfMuonsAbove3GeV(Nmu3GeV);
384	evTag->SetNumOfMuonsAbove10GeV(Nmu10GeV);
385	evTag->SetNumOfElectronsAbove1GeV(Nel1GeV);
386	evTag->SetNumOfElectronsAbove3GeV(Nel3GeV);
387	evTag->SetNumOfElectronsAbove10GeV(Nel10GeV);
388
389	evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles());
390	evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles());
391
392	evTag->SetTotalMomentum(TotalP);
393	evTag->SetMeanPt(MeanPt);
394	evTag->SetMaxPt(MaxPt);
395
396	tag->AddEventTag(evTag);
397	}
398	lastEvent = i_NumberOfEvents;
399
400	t->Delete("");
401
402	ttag.Fill();
403	tag->Clear();
404
405	TString LocalfileName = "Run"; LocalfileName += tag->GetRunId();
406	LocalfileName += ".Event"; LocalfileName += firstEvent; LocalfileName += "_"; LocalfileName += lastEvent; LocalfileName += "."; LocalfileName += Counter;
407	LocalfileName += ".ESD.tag.root";
408
409	cout<<"Writing tags to local file: "<<LocalfileName<<endl;
410
411	TFile* ftag = TFile::Open(LocalfileName, "recreate");
412	ftag->cd();
413	ttag.Write();
414	ftag->Close();
415
416	delete ftag;
417	delete esd;
418
419	delete tag;
420	delete detTag;
421	delete evTag;
422	}
423
424	//_____________________________________________________________________________
425	Bool_t AliTagCreator::StoreGridTagFile(const char localpath, const char gridpath)
426	{
427	gSystem->Load("libThread.so");
428	gSystem->Load("libTreePlayer.so");
429	gSystem->Load("libProof.so");
430	cout<<"Storing tag file to alien's file catalog..."<<endl;
431	TFileMerger merger;
432	const char * pattern = "tag.root";
433	// Open the working directory
434	void * dirp = gSystem->OpenDirectory(localpath);
435	const char * name = 0x0;
436	TString AlienLocation;
437	Char_t LocalLocation[256];
438
439	// Add all files matching pattern to the chain
440	while((name = gSystem->GetDirEntry(dirp)))
441	{
442	if (strstr(name,pattern))
443	{
444	sprintf(LocalLocation,"file:%s/%s",localpath,name);
445	AlienLocation = "/alien";
446	AlienLocation += gGrid->Pwd();
447	AlienLocation += gridpath;
448	AlienLocation += "/";
449	AlienLocation += name;
450	AlienLocation += "?se=";
451	AlienLocation += fSE.Data();
452	merger.Cp(LocalLocation,AlienLocation);
453
454	}
455	}
456	gSystem->FreeDirectory(dirp);
457
458	return kTRUE;
459	}