adding ct analysis
authorakalweit <Alexander.Philipp.Kalweit@cern.ch>
Wed, 10 Sep 2014 20:11:11 +0000 (22:11 +0200)
committerakalweit <Alexander.Philipp.Kalweit@cern.ch>
Wed, 10 Sep 2014 20:11:11 +0000 (22:11 +0200)
13 files changed:
PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.cxx [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.cxx [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJCard.cxx [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJCard.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJConst.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.cxx [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.cxx [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.h [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/card_xT.input [new file with mode: 0644]
PWGLF/SPECTRA/XtAnalysis/macros/AddTaskXtAnalysis.C [new file with mode: 0644]

diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.cxx b/PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.cxx
new file mode 100644 (file)
index 0000000..75576fd
--- /dev/null
@@ -0,0 +1,273 @@
+//====================================
+//last modified FK 6.NOV 2009
+//====================================
+//blah
+// blah
+
+#include "AliJBaseCard.h"
+
+//ClassImp(AliJBaseCard);
+
+AliJBaseCard::AliJBaseCard()
+  //:TObject()
+{   
+  //constructor
+}
+
+AliJBaseCard::AliJBaseCard(const char *filename)
+  //:TObject()
+{  
+  //constructor
+
+  strcpy(fcardname, filename);  //needed in PrintOut()
+
+  fnentry = 0; //initialize nr of lines
+
+  if( strlen( filename ) > 0 ){
+
+    //----  r e a d   t h e   c a r d ----
+    ReadInputCard();//read config file fill Tvectors
+  }
+}
+
+
+AliJBaseCard& AliJBaseCard::operator=(const AliJBaseCard& obj){
+  // copy constructor
+  return *this;
+}
+
+AliJBaseCard::~AliJBaseCard(){
+  // destructor
+}
+
+
+unsigned int AliJBaseCard::GetTVectorIndex(TString keyword, int tol){
+
+  //   //returns findex of a TVector according to its position in std::hash_map 
+  //   std::hash_map< TString, unsigned int >::iterator iter = MapKeyWordToTVector.begin();
+  //   iter = MapKeyWordToTVector.find(keyword);
+  //   if(iter != MapKeyWordToTVector.end()){
+  //     return (unsigned int) iter->second;
+  //   }else{
+  //     cout << "ERROR: \""<<keyword.Data()<<"\" must be defined  "<< endl;
+  //     exit(1);
+  //   }
+
+  UInt_t i;
+  Int_t ind;
+  i = 0;
+  ind = -1;
+
+  //cout<<"ALIJBASECARD_SEARCH_MODE_HASHLIST"<<endl;
+  TNamed * ko = (TNamed*)fKeyTable.FindObject( keyword.Data() ); 
+  //cout<<ko<<endl;
+  if(ko) ind = ko->GetUniqueID();
+  if( ind == -1 ){
+    for( UInt_t i=0;i<fKeyWordVector.size();i++ ){
+      if( fKeyWordVector[i] == keyword ) return i;
+    }
+    if( tol == 0 ){
+      cout << "ERROR: \""<<keyword.Data()<<"\" must be defined  "<< endl;
+      exit(1);
+    }else{
+      cout << "Warning: \""<<keyword.Data()<<"\" is not exist. return default value  "<< endl;
+      return -1;
+    }
+  }
+
+  return ind;
+}
+
+int AliJBaseCard::GetN(TString keyword){
+  //returns size of TVector
+  unsigned int findex = GetTVectorIndex(keyword);
+  return (int) fValuesVector[findex].GetNrows();
+}
+
+TVector *  AliJBaseCard::GetVector(TString keyword ){
+  int findex = GetTVectorIndex(keyword);
+  return &fValuesVector[findex];
+}
+
+float AliJBaseCard::Get(TString keyword, int VectorComponent){
+  //returns VectorComponent Component of  fValuesVecto`uor TVector for given keyword
+  int findex = GetTVectorIndex(keyword);
+  if(0<=VectorComponent && VectorComponent<GetNwithIndex(findex)){
+    return fValuesVector[findex](VectorComponent+1);
+  }else{
+    cout<<"ERROR: fValuesVector findex out of range "<<keyword.Data()<<endl;
+    cout << "   Max findex: " << GetN(keyword) -  1<< " Asked: " <<  VectorComponent << endl;
+    exit(1);
+  }
+}
+
+TString AliJBaseCard::GetStr(TString keyword ){
+  int findex = GetTVectorIndex(keyword, 1);
+  if( findex < 0  ) return TString("");
+  return fValueString[findex];
+}
+
+
+void AliJBaseCard::InitCard(){
+  // set the length of fIndexVector and disable all indices
+}
+
+/*
+void AliJBaseCard::FinishCard(){
+  // recompute fast idices
+}
+*/
+
+void AliJBaseCard::ReadInputCard(){
+  // read card
+
+  char buffer[kMaxDimBuffer];
+  ifstream incard;
+
+  cout << "Reading fcard from file: " << fcardname << endl;
+  incard.open(fcardname,ios::in);
+
+  if(!incard){
+    cout<<"ERROR: Config file <"<<fcardname<<"> not found!"<<endl;
+    exit(1);
+  }
+
+  InitCard();
+
+  while(!incard.eof()){ //loop over the input fcard
+
+    incard.getline(buffer,kMaxDimBuffer); //read a line
+
+    if(fnentry > 1000){//is the file reasonably long?
+      cout<<"Maximum number of 1000 lines reached in AliJBaseCard.C"<<endl;
+      exit(1);
+    }
+
+    ReadInputLine( buffer );
+
+    fnentry++;
+  }//while eof
+
+  FinishCard();
+
+  return;
+}
+
+void AliJBaseCard::ReadInputLine( const char *buffer ){
+  // parse a line
+
+
+
+  TString tstr(buffer); //convert the line in the buffer to TString
+
+  if( tstr.BeginsWith("#") ) return;//skipp comments
+  tstr.ReplaceAll("\t"," ");//get rid of tabelators
+
+  //remove comment in line
+  Ssiz_t startOFcomment = tstr.First('#');
+  if(startOFcomment>0){
+    tstr.Remove(startOFcomment,tstr.Length() - startOFcomment);
+  }
+
+  //remove white spaces from the begining
+  if(tstr.BeginsWith(" ")){
+    Ssiz_t startOFkeyword = 0;
+    while(1){
+      TString s = tstr[startOFkeyword];
+      if(s.CompareTo(" ")) break;
+      startOFkeyword++;
+    }
+    tstr.Replace(0,startOFkeyword,"",0);
+  }
+
+  //separate inputs 
+  TObjArray *lineContents = tstr.Tokenize(" ");
+
+  if(lineContents->GetEntriesFast() < 1) return;//skipp empty lines
+
+  //----- Read a keyword -----
+  TString entryname = ((TObjString*)(lineContents->At(0)))->String(); //read a key word
+
+  if(lineContents->GetEntriesFast() == 1){
+    cout<<"WARNING: single keyword "<<entryname.Data()<<" on line"<<endl;
+  }else{
+
+
+    //----- Read parameters -----
+    vector< float > items;//auxiliary vector
+
+    for(int i=1; i<lineContents->GetEntriesFast(); i++){ //loop over the numbers 
+      TString token = ((TObjString*)(lineContents->At(i)))->String();//read a string
+
+      if(token.IsFloat()){
+        items.push_back(token.Atof());//if string is float number store it to vector
+      }else{
+        items.push_back(0);
+        // cout<<"ERROR: char "<<token.Data()<<" among numbers"<<endl;
+        // exit(1);
+      }
+    }//end of the for loop
+
+
+    //Fill TVectors and Map 
+    fKeyWordVector.push_back( entryname.Data() );//put the new keyword at the end of the array
+
+
+    fValuesVector.push_back( TVector( 1, items.size(), &items[0]) );//store TVector to array
+    fValueString.push_back( ((TObjString*)(lineContents->At(1)))->String() );
+
+    //       MapKeyWordToTVector.insert(pair<TString, unsigned int>(entryname.Data(),fKeyWordVector.size()-1)); 
+    AddToKeyTable( entryname, fValuesVector.size()-1 ); 
+
+
+  }//else
+
+  lineContents->~TObjArray();//remove array from heap
+}
+
+void AliJBaseCard::PrintOut(){
+  // echo
+  cout<<endl<<"======== "<<fcardname<<" ========="<<endl;
+  for(unsigned int i=0; i<fValuesVector.size();i++){
+    cout<<Form("%15s",fKeyWordVector[i].Data());//print keyword
+    cout<<" (dim ="<<fValuesVector[i].GetNrows()<<") ";//print size of TVector
+    for(int j=1; j<=fValuesVector[i].GetNrows(); j++){
+      cout<<fValuesVector[i][j]<<" ";//TVector components
+    }
+    cout<<endl;
+  }
+}
+
+
+void AliJBaseCard::WriteCard(TFile *file){
+  // write
+  cout<<endl<<"====== Writing into file ========="<<endl;
+
+  if(!file->GetDirectory("JCard")) {
+    file->mkdir("JCard");//directory to store input parameters
+  }
+  file->cd("JCard");
+  for(unsigned int i=0;i<fValuesVector.size();i++){ 
+    fValuesVector[i].Write(fKeyWordVector[i]);
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.h b/PWGLF/SPECTRA/XtAnalysis/AliJBaseCard.h
new file mode 100644 (file)
index 0000000..6b2ef9e
--- /dev/null
@@ -0,0 +1,102 @@
+//=================================================
+// AliJBaseCard.h
+// last modified FK 6.NOV 2009
+//=================================================
+
+#ifndef ALIJBASECARD_H
+#define ALIJBASECARD_H
+
+#include <TObject.h>
+
+#include <iostream>
+#include <fstream>
+
+#include <TString.h>
+#include <TVector.h>
+#include <TMath.h>
+#include <TObjArray.h>
+#include <TObjString.h>
+#include <TFile.h>
+#include <TF1.h>
+#include <vector>
+#include <THashList.h>
+#include <TNamed.h>
+
+using namespace std;
+#ifndef AliJMaxDimBuffer
+#define AliJMaxDimBuffer
+const int kMaxDimBuffer = 300;//max length of a line read to a buffe
+#endif
+
+class AliJBaseCard {
+
+  //====   M e m b e r    F u n c t i o n s   ========
+
+public:
+
+  AliJBaseCard(); // constructor
+  AliJBaseCard(const char *filename); // constructor
+  AliJBaseCard& operator=(const AliJBaseCard& obj);
+
+  virtual ~AliJBaseCard();
+
+  void AddToKeyTable( TString key, int index ){
+    TNamed * ko = new TNamed(key.Data(),"");
+    ko->SetUniqueID(index);
+    fKeyTable.Add(ko);// TODO check duplicate
+  }
+
+  float  Get(TString keyword, int VectorComponent=0); //get TVector component 
+  TString  GetStr(TString keyword ); //get TVector component 
+  TVector* GetVector( TString keyword );
+  int    GetN(TString keyword);       //get TVector dimension
+  void   PrintOut(); 
+  void   WriteCard(TFile *file);  
+
+  virtual void InitCard();
+  void FinishCard() const {cout << "card finished" << endl;};
+  void ReadInputLine( const char* buffer );
+
+protected:
+  void    ReadInputCard();
+
+  int     GetNwithIndex(int i){ return fValuesVector[i].GetNrows(); }
+
+  unsigned int GetTVectorIndex(TString keyword, int tol=0);
+
+  //====   D a t a    M e m b e r s  ========
+
+  char fcardname[255];   // file name
+  int  fnentry;                   //Number of lines in cfg file
+  std::vector< TString >   fKeyWordVector;    //array of key words
+  std::vector< TVector >   fValuesVector;     //array of float number confg parameter vectors 
+  std::vector< TString >   fValueString;      // Storage of raw inut string for each item
+  //std::map< TString, unsigned int > MapKeyWordToTVector;//mapping keywords to TVector
+  THashList           fKeyTable;              // key map with hash algorithm
+
+  //ClassDef(AliJBaseCard, 1); // EMCAL for jcorran
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.cxx b/PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.cxx
new file mode 100644 (file)
index 0000000..9dfbf7e
--- /dev/null
@@ -0,0 +1,140 @@
+/**************************************************************************
+ * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Comment describing what this class does needed!
+
+// $Id: AliJBaseTrack.cxx,v 1.5 2008/05/08 15:19:52 djkim Exp $
+////////////////////////////////////////////////////
+/*!
+  \file AliJBaseTrack.cxx
+  \brief
+  \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla)
+  \email: djkim@jyu.fi
+  \version $Revision: 1.5 $
+  \date $Date: 2008/05/08 15:19:52 $
+  */
+////////////////////////////////////////////////////
+
+#include "AliJBaseTrack.h"
+
+//______________________________________________________________________________
+AliJBaseTrack::AliJBaseTrack():
+    fID(-1),
+    fLabel(-9999), 
+    fParticleType(-1), 
+    fCharge(0), 
+    fStatus(0), 
+    fFlags(0),
+    fTriggID(-1),
+    fAssocID(-1),
+    fTracEff(-1),
+    fMCIndex(-9999),
+    fWeight(1.0)
+{
+  // constructor
+}
+
+//_____________________________________________________________
+AliJBaseTrack::AliJBaseTrack(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge):
+    TLorentzVector( px, py, pz, e ), 
+    fID(id),
+    fLabel(-9999),
+    fParticleType(ptype), 
+    fCharge(charge), 
+    fStatus(0), 
+    fFlags(0),
+    fTriggID(-1),
+    fAssocID(-1),
+    fTracEff(-1),
+    fMCIndex(-9999),
+    fWeight(1.0)
+{
+  // constructor
+}
+
+//_____________________________________________________________
+AliJBaseTrack::AliJBaseTrack(const AliJBaseTrack& a):
+    TLorentzVector  (a), 
+    fID             (a.fID),
+    fLabel          (a.fLabel),
+    fParticleType   ( a.fParticleType ), 
+    fCharge         ( a.fCharge ), 
+    fStatus         ( a.fStatus ), 
+    fFlags       ( a.fFlags ),
+    fTriggID( a.fTriggID ),
+    fAssocID( a.fAssocID ),
+    fTracEff( a.fTracEff ),
+    fMCIndex( a.fMCIndex ),
+    fWeight ( a.fWeight  )
+{
+  //copy constructor
+}
+
+//_____________________________________________________________
+AliJBaseTrack::AliJBaseTrack(const TLorentzVector& a):
+    TLorentzVector  (a),
+    fID             ( -1 ),
+    fLabel          ( -9999 ),
+    fParticleType   ( -1 ),
+    fCharge         ( 0 ),
+    fStatus         ( 0 ),
+    fFlags       ( 0 ),
+    fTriggID(-1),
+    fAssocID(-1),
+    fTracEff(-1),
+    fMCIndex(-9999),
+    fWeight(1.0)
+{
+  //copy constructor
+}
+//_____________________________________________________________
+AliJBaseTrack& AliJBaseTrack::operator=(const AliJBaseTrack& trk){
+  //operator =  
+  if(this != &trk){
+    TLorentzVector::operator=(trk);
+    fID           = trk.fID;
+    fLabel        = trk.fLabel;
+    fParticleType = trk.fParticleType;
+    fCharge       = trk.fCharge;
+    fStatus       = trk.fStatus;
+    fFlags     = trk.fFlags;
+    fTriggID   = trk.fTriggID;
+    fAssocID   = trk.fAssocID;
+    fTracEff   = trk.fTracEff;
+    fMCIndex   = trk.fMCIndex;
+    fWeight       = trk.fWeight;
+  }
+  return *this;
+}
+
+//_____________________________________________________________
+void AliJBaseTrack::Print() const{
+  //object print out
+  std::cout<<Form("(ID,Type,Charge,Flags)=(%d, %d, %d, %d)" , 
+                  fID, fParticleType, fCharge,  fFlags );
+  TLorentzVector::Print();
+  cout<<"ID ="<<fID <<endl; 
+  cout<<"fLabel="<<fLabel <<endl; 
+  cout<<"fParticleType="<<fParticleType <<endl; 
+  cout<<"fCharge="<<fCharge <<endl; 
+  cout<<"fStatus="<<fStatus <<endl; 
+  cout<<"fFlags="<<fFlags <<endl; 
+  cout<<"fTriggID="<<fTriggID <<endl; 
+  cout<<"fAssocID="<<fAssocID <<endl; 
+  cout<<"fTracEff="<<fTracEff <<endl; 
+}
+
+ClassImp(AliJBaseTrack)
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.h b/PWGLF/SPECTRA/XtAnalysis/AliJBaseTrack.h
new file mode 100644 (file)
index 0000000..0627dad
--- /dev/null
@@ -0,0 +1,105 @@
+/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+// Short comment describing what this class does needed!
+
+// $Id: AliJBaseTrack.h,v 1.5 2008/05/08 15:19:52 djkim Exp $
+
+///////////////////////////////////////////////////
+/*
+   \file AliJBaseTrack.h
+   \brief
+   \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla)
+   \email: djkim@jyu.fi
+   \version $Revision: 1.5 $
+   \date $Date: 2008/05/08 15:19:52 $
+   */
+///////////////////////////////////////////////////
+
+#ifndef ALIJBASETRACK_H
+#define ALIJBASETRACK_H
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+#include <iostream>
+#include <TLorentzVector.h>
+#include <TMath.h>
+#include  "AliJConst.h"
+
+using namespace std;
+
+class AliJBaseTrack : public TLorentzVector {
+    public:
+        enum { kIsIsolated, kNFlag };
+        AliJBaseTrack();
+        AliJBaseTrack(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge); // constructor
+        AliJBaseTrack(const AliJBaseTrack& a);
+        AliJBaseTrack(const TLorentzVector & a);
+        virtual ~AliJBaseTrack(){;}    //destructor
+
+        double EtaAbs(){ return TMath::Abs(Eta()); }
+        float   GetTwoPiPhi() const {return Phi()>-kJPi/3 ? Phi() : kJTwoPi+Phi();} 
+        TLorentzVector GetLorentzVector(){ return TLorentzVector(Px(), Py(), Pz(), E());}
+
+        Int_t         GetID()           const { return fID;}
+        Int_t         GetLabel()        const { return fLabel; }
+        Short_t       GetParticleType() const { return fParticleType;}
+        ULong_t       GetStatus()       const { return fStatus; }
+        Short_t       GetCharge()       const { return fCharge; } 
+        UInt_t        GetFlags()        const { return fFlags; }
+        Bool_t        GetIsIsolated()   const { return IsTrue(kIsIsolated);}
+
+        Int_t         GetTriggBin()     const { return fTriggID; }
+        Int_t         GetAssocBin()     const { return fAssocID; }
+        Double32_t    GetTrackEff()     const { 
+            if(fTracEff==-1) {  cout<<"AliJBaseTrack: Uninitilized track eff " <<endl;  exit(-1);
+            } else return fTracEff;  }
+        Bool_t        IsInTriggerBin()  const { return fTriggID>=0; }
+        Bool_t        IsInAssocBin()    const { return fAssocID>=0; }
+        Double_t      GetWeight()       const { return fWeight;}             
+        Int_t         GetMCIndex()      const { return fMCIndex;}
+
+        void SetID      (const int id){fID=id;}
+        void SetLabel   (const Int_t label ){ fLabel=label; }
+        void SetParticleType(const Short_t ptype){ fParticleType=ptype; }
+        void SetStatus  (const ULong_t status){ fStatus=status; }
+        void SetCharge  (const Char_t charge){ fCharge=charge; }
+        void SetFlags   (const UInt_t bits ){ fFlags=bits; }        //MC, is primary flag
+        void SetIsIsolated(Bool_t tf){ SetFlag( kIsIsolated, tf); }
+
+        void SetTriggBin(const int id){fTriggID = id;}
+        void SetAssocBin(const int id){fAssocID = id;}
+        void SetTrackEff(const Double32_t inEff){fTracEff = inEff;}
+
+        void SetWeight(Double_t weight) { fWeight = weight;}
+        void SetMCIndex(Int_t idx) {      fMCIndex = idx;}
+
+        virtual void Print() const;
+
+        // Handel BitsData
+        Bool_t IsTrue(int i ) const { return TESTBIT(fFlags, i); }
+        void SetFlag(int i, Bool_t t){ if(t){SETBIT(fFlags,i);}else{CLRBIT(fFlags, i);}}
+
+        // Operators
+        AliJBaseTrack& operator=(const AliJBaseTrack& trk);
+
+    protected:
+        Int_t         fID;            // Unique track ID
+        Int_t         fLabel;         // Unique track label for MC-Data relation
+        Short_t       fParticleType;  // ParticleType 
+        Char_t        fCharge;        // track charge for real data
+        ULong_t       fStatus;        // reconstruction status flags or MC status 
+        UInt_t        fFlags;         // store series of any boolen value.
+
+        Int_t         fTriggID, fAssocID; //!   //id of trigger and assoc particle 
+        Double32_t    fTracEff;           //!   //track efficiency
+        Int_t         fMCIndex;           //!   //index of corresp. MC track
+        Double_t      fWeight;            //!   //particle weight
+
+        ClassDef(AliJBaseTrack,1)
+};
+
+#endif
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJCard.cxx b/PWGLF/SPECTRA/XtAnalysis/AliJCard.cxx
new file mode 100644 (file)
index 0000000..72c8dbb
--- /dev/null
@@ -0,0 +1,338 @@
+//====================================
+//last modified FK 6.NOV 2009
+//====================================
+//blah
+// blah
+
+#include "AliJCard.h"
+
+//ClassImp(AliJCard);
+
+AliJCard::AliJCard():
+    AliJBaseCard(),
+    fhCorr(0),
+    fpi0massbin(0)
+{   
+    //constructor
+}
+
+AliJCard::AliJCard(const char *filename):
+    AliJBaseCard(filename),
+    fhCorr(0),
+    fpi0massbin(0)
+{  
+    //constructor
+    InitCard();
+    MakeFastCorrTypeIndex();
+}
+
+
+
+AliJCard::AliJCard(const AliJCard& obj){
+    // copy constructor
+}
+
+
+AliJCard& AliJCard::operator=(const AliJCard& obj){
+    // copy constructor
+    return *this;
+}
+
+AliJCard::~AliJCard(){
+    // destructor
+    if( fpi0massbin ){
+        for( int i = 0; i < GetNoOfBins( kCentrType ); i++ ){
+            delete [] fpi0massbin[i];
+        }    // destructor
+        delete [] fpi0massbin;
+    }
+    if( fhCorr ){
+        delete fhCorr;
+    }
+}
+
+void AliJCard::MakeFastCorrTypeIndex(){
+    // make fast findex array
+    for( unsigned int i=0;i<fKeyWordVector.size();i++ ){
+        int corrIndex = GetCorrType( fKeyWordVector[i] );
+        if( corrIndex != kNoType )
+            fIndexVector[corrIndex] = i;
+    }
+
+}
+
+int AliJCard::IsLessThanUpperPairPtCut(double inPairPt){ 
+    // pt cut
+    int nB = GetN("UpperPairPtCut");
+    if(inPairPt == -999) return nB;
+    if(-999 < inPairPt && inPairPt <=0) return int(Get("UpperPairPtCut",-int(inPairPt)));
+    int bin=-1, i=0;
+    while(i<nB && inPairPt>Get("UpperPairPtCut",i)) i++;
+    if(i<nB) bin=i;
+    //cout<<" i="<<i<<" bin="<<bin<<" inval="<<inPairPt<<endl;;
+    return bin;
+}
+
+
+
+TString AliJCard::GetKeyWord(corrType ctype){
+    // get keyword
+    TString kw;
+
+    switch(ctype){
+        case kTriggType:  kw = "TriggPtBorders"; break;
+        case kAssocType:  kw = "AssocPtBorders"; break;
+        case kXeType:     kw = "xEBorders"; break;
+        case kLongType:   kw = "KlongBorders"; break;
+        case kCentrType:  kw = "CentBinBorders"; break;
+        case kZVertType:  kw = "zVertBins"; break;
+        case kMassType:   kw = "PairInvariantMassBins"; break;
+        case kEtaGapType: kw = "EtaGapThresholds"; break;
+        case kDiJetType:  kw = "DiJetMassBorders"; break;
+        case kRGapType:   kw = "RGapThresholds"; break;
+                          //case kEPType:  kw = "EPBorders"; break;
+        default : cout<<"ERROR: kNoType on input to AliJCard::GetKeyWord"<<endl; exit(1); break;
+    }
+    return kw; 
+}
+
+corrType AliJCard::GetCorrType( TString inStr ){
+    // get corr type
+    TString kw;
+
+    int i;
+    TString s;
+
+    // go through all corrType to check if the parameter should be added
+    // into fast findex array
+    for( i = 0; i < kNcorrType; i++ ){
+        if( i == kNoType )
+            continue;
+
+        s = GetKeyWord( (corrType)i );
+        if( ! strcmp( s.Data(), inStr.Data() ))
+            return (corrType)i;
+    }
+
+    return kNoType; 
+}
+
+int AliJCard::GetN(corrType ctype){
+    //returns size of TVector
+    return GetN(GetKeyWord(ctype));
+}
+
+int AliJCard::GetNFast(corrType ctype){
+    //returns size of TVector
+    int findex = fIndexVector[ctype];
+    if( findex > -1 ){
+        return (int) fValuesVector[findex].GetNrows();
+    }else{
+        cout<<"ERROR: fValuesVector fast findex out of range "<< findex << " " << (GetKeyWord( ctype )).Data() << endl;
+        exit(1);
+    }
+}
+
+
+float AliJCard::Get(corrType ctype, int VectorComponent){
+    //returns VectorComponent Component of  fValuesVecto`uor TVector for given keyword
+    return Get(GetKeyWord(ctype), VectorComponent);
+}
+
+float AliJCard::GetFast(corrType ctype, int VectorComponent){
+    // fast get
+
+    if(0<=VectorComponent && VectorComponent<GetNFast(ctype) && fIndexVector[ctype] > -1 ){
+        return fValuesVector[fIndexVector[ctype]][VectorComponent+1];
+    }else{
+        cout<<"ERROR: fValuesVector fast findex out of range "<< (GetKeyWord(ctype)).Data()<<endl;
+        exit(1);
+    }
+}
+
+
+void AliJCard::InitCard(){
+    // Init card
+    cout<<"Init of AliJCard"<<endl;
+    // set the length of fIndexVector and disable all indices
+    fIndexVector.resize( kNcorrType  );
+    for( int i = 0; i < kNcorrType; i++ )
+        fIndexVector[i] = -1;
+}
+
+void AliJCard::FinishCard(){
+    // Finish loading of card
+    AliJBaseCard::FinishCard();
+    // recompute fast idices
+
+    fpi0massbin = new Double_t*[GetNoOfBins( kCentrType )];
+
+    char centstr[10];
+
+    // read the pi0 mass bin parameters
+    for( int i = 0; i < GetNoOfBins( kCentrType ); i++ ){
+        fpi0massbin[i] = new Double_t[8];
+
+        for( int j = 0; j < 8; j++ ){
+            sprintf( centstr, "cent%d", i );
+            fpi0massbin[i][j] = Get( centstr, j );
+        }
+    }
+
+}
+
+void AliJCard::PrintOut(){
+    // Print out contents of card
+    AliJBaseCard::PrintOut();
+    cout << "----- fast array ----------" << endl;
+    for( unsigned int ii = 0; ii < fIndexVector.size(); ii++ ){
+        if( ii == kNoType )
+            continue;
+        cout << (GetKeyWord( (corrType)ii )).Data() << " " << fIndexVector[ii];
+        if( fIndexVector[ii] > -1 ){
+            cout<<" (dim ="<<fValuesVector[fIndexVector[ii]].GetNrows()<<") ";//print size of TVector
+            for(int j=1; j<=fValuesVector[fIndexVector[ii]].GetNrows(); j++){
+                cout<<fValuesVector[fIndexVector[ii]][j]<<" ";//TVector components
+            }
+        }
+        else
+            cout << " no link!";
+
+        cout << endl;  
+    }
+}
+
+int AliJCard::GetBin(corrType ctype, float val){
+    // get bin
+
+    if(ctype == kNoType) return 0;
+
+    TVector * v = &fValuesVector[fIndexVector[ctype]];
+    int iBin2 = TMath::BinarySearch( v->GetNrows(), v->GetMatrixArray(), val );
+    if( iBin2 >= v->GetNrows()-1 ) iBin2 = -1;
+
+    return iBin2;
+}
+
+int AliJCard::GetBinFast(corrType ctype, float val){
+    // fast get bin
+
+    if(ctype == kNoType) return 0;
+
+    for(int i=0; i<(GetNFast(ctype)-1); i++)
+        if(GetFast(ctype,i)<=val && val<GetFast(ctype,i+1))
+            return i;
+
+    return -1;
+}
+
+
+
+bool AliJCard::IsGoodRun(int runID){
+    // run quality
+    bool isgood = true;
+    for(int i=0; i<GetN("badRuns");i++) if(((int) Get("badRuns",i)) == runID) isgood = false;
+
+    return isgood;
+}
+
+bool AliJCard::MbTrigger(int triggin) const {
+    // MB trigger
+    return (triggin & (1<<kMinBiasTriggerBitJCorran)) > 0; //masking on >0 masking off ==0 desired trigger
+}
+
+
+bool AliJCard::SimilarVertZ(float Z1, float Z2){
+    // z vert
+    static double v = Get("maxMixDZ");
+    if( v < 0 ) return 1;
+    return fabs(Z1-Z2) < v ;
+}
+
+bool AliJCard::SimilarMultiplicity(float mult1, float mult2){
+    // multi
+    static double v = Get("maxMixDMult");
+    if( v <0) return 1;
+    return fabs(mult1-mult2) < v;
+}
+
+
+bool AliJCard::SimilarCentrality(float c1, float c2, int cbin){
+    // centra
+    static TVector *v = GetVector("maxDCent");
+    if(v==NULL) return 1;
+    return fabs(c1-c2) < (*v)[cbin+1]; // TODO
+}
+
+
+//--------- P H E N I X    C G L --------------
+
+/*
+bool AliJCard::InPhiRange(float Phi){
+    // phi
+    bool isIn = false; 
+    for(int i=1; i<GetN("phiDCRange"); i+=2 ) 
+        isIn = isIn || (Get("phiDCRange",i-1)<Phi && Phi<Get("phiDCRange",i));
+    return isIn;
+} 
+*/
+
+
+bool  AliJCard::CheckTrackParamsInTPC(int NClustersTPC,float Chi2PerClusterTPC){
+    // tpc pars
+    bool isGoodTrack = true;
+    if(NClustersTPC < Get("MinNClustersTPC"))           isGoodTrack = false;
+    if(Chi2PerClusterTPC > Get("MaxChi2PerClusterTPC")) isGoodTrack = false;
+    return isGoodTrack;
+}
+
+bool  AliJCard::CheckMinNumTPCClustPt(int NClustersTPC, float fpt){
+    // tpc pars
+    float minNTPCCls =  Get("ParMinNClustTPCPt",0)*log(Get("ParMinNClustTPCPt",1)*fpt + Get("ParMinNClustTPCPt",2)); 
+    if(NClustersTPC > minNTPCCls) return true; //track had enough clusters
+    else return false;  //track did not have sufficient number of clusters
+}
+
+
+bool  AliJCard::CheckTrackImpact(float xyIm, float zIm, float fpt){
+    // tpc pars
+    bool isGoodTrack = true;
+    if(TMath::Abs(xyIm) > Get("ParMaxDCAToVertexXYPtDep",0)+Get("ParMaxDCAToVertexXYPtDep",1)/pow(fpt,Get("ParMaxDCAToVertexXYPtDep",2))){
+        isGoodTrack = false;
+    }
+    if(TMath::Abs(zIm) > Get("MaxDCAToVertexZ")) isGoodTrack = false;
+
+    return isGoodTrack;
+}
+
+
+/*
+bool AliJCard::DeltaEtaCheck(const AliJBaseTrack *ftk1, const AliJBaseTrack *ftk2) {
+    // deta
+    double delta = fabs( log(tan(ftk1->Theta()/2.0)) -  log(tan(ftk2->Theta()/2.0)) );
+    if(Get("etaCut")>0) return delta < Get("etaCut");
+    if(Get("etaCut")<0) return delta > Get("etaCut");
+
+    return true;
+}
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJCard.h b/PWGLF/SPECTRA/XtAnalysis/AliJCard.h
new file mode 100644 (file)
index 0000000..fb94b4c
--- /dev/null
@@ -0,0 +1,203 @@
+//=================================================
+// AliJCard.h
+// last modified FK 6.NOV 2009
+//=================================================
+
+#ifndef ALIJCARD_H
+#define ALIJCARD_H
+
+#include <TObject.h>
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <iomanip>
+
+#include <string.h>
+#include <TString.h>
+#include <TVector.h>
+#include <TMath.h>
+#include <TObjArray.h>
+#include <TObjString.h>
+#include <TFile.h>
+#include <TF1.h>
+#include <TH1D.h>
+#include <TH2D.h>
+#include <vector>
+#include <TVector3.h>
+#include <THashList.h>
+#include <TNamed.h>
+
+#include "AliJConst.h"
+#include "AliJBaseCard.h"
+
+class AliJBaseTrack;
+//#include "AliJPhoton.h"
+//class AliJTrack;
+
+using namespace std;
+
+
+class AliJCard : public AliJBaseCard {
+
+    public:
+
+        AliJCard(); // constructor
+        AliJCard(const char *filename); // constructor
+        AliJCard(const AliJCard& obj);
+        AliJCard& operator=(const AliJCard& obj);
+
+        virtual ~AliJCard();
+
+        void MakeFastCorrTypeIndex();
+
+        void   PrintOut(); 
+
+        float  Get(TString keyword, int VectorComponent=0){ return AliJBaseCard::Get(keyword, VectorComponent); }
+        float  Get(corrType ctype, int VectorComponent =0);  //get TVector component
+        float  GetFast(corrType ctype, int VectorComponent=0);  //get TVector component
+        int    GetN(TString keyword){ return AliJBaseCard::GetN(keyword); }       //get TVector dimension
+        int    GetN(corrType ctype);        //get TVector dimension
+        int    GetNFast(corrType ctype);    //get TVector dimension
+
+        //---- Collision Species --
+        float  GetCollisionType()  { return Get("CollisionType");}
+
+        //------  v e r t e x -----
+
+        float  VertInZRange(float Z) {
+            //cout<< "zv " << Z <<" "<< ( GetBinBorder(kZVertType,0) < Z && Z < GetBinBorder(kZVertType, GetNoOfBins(kZVertType)) ) <<endl; 
+            return ( GetBinBorder(kZVertType,0) < Z && Z < GetBinBorder(kZVertType, GetNoOfBins(kZVertType)) ); }
+
+        //Alice vertex  cuts
+        bool CheckEventZVetrex(double fZVertex, double ZVertErr){
+            if(Get("ZVertexRange",0)<fZVertex && fZVertex <Get("ZVertexRange",1) && (Get("MaxZVertexError") > ZVertErr))        return true; 
+            else    return false;
+        }
+
+        int IsLessThanUpperPairPtCut(double inPairPt);
+
+
+        //--- c o r r e l a t i o n  bins & borders --
+        int    GetNoOfBins (corrType ctype){ return GetNFast(ctype)-1; }
+        float  GetBinBorder(corrType ctype, int ii){ return GetFast(ctype,ii); }
+        int    GetBin(corrType ctype, float val);
+        int    GetBinFast(corrType ctype, float val);
+        double GetBinCenter(corrType ctype, int ii){ return (GetFast(ctype,ii)+GetFast(ctype,ii+1))/2.;}
+
+        //-----  m i x i n g ----
+        int    GetEventPoolDepth(int cBin){ return (int) Get("EventPoolDepth",cBin);}
+        bool   SimilarVertZ(float Z1, float Z2);
+        bool   SimilarMultiplicity(float mult1, float mult2);
+        bool   SimilarCentrality(float c1, float c2, int cbin);
+
+        //run characteristics
+        bool   IsGoodRun(int runID);
+
+        //trigger
+        bool   MbTrigger(int triggin) const;
+
+        //photon
+    /*
+        bool   IsPhoton(AliJPhoton *g){ return g->GetProbPhot() > Get("probPhot"); }
+        float  GetPhotEnergyCut(){ return Get("minEnergy"); }
+
+        bool   InPhiRange(float Phi);
+        bool   IsInZEDandThetaRange(float zedDC, float theta){
+            return (fabs(zedDC)<Get("zedRange") && fabs(kJPi/2-theta)<Get("thetaRange"));
+        }
+     */
+    
+    
+        bool   IsInEtaRange(float eta){return fabs(eta)<Get("EtaRange"); }
+        //  bool   likeSgnCheck(PhJCgl *cgl1, PhJCgl *cgl2);
+        // bool   DeltaEtaCheck(const AliJBaseTrack *ftk1, const AliJBaseTrack *ftk2);
+        bool   NotGhost(float zedDC, float PhiDC){ 
+            return (zedDC > Get("deltaZEDPhiDC",0) && fabs(PhiDC) > Get("deltaZEDPhiDC",1));
+        }
+
+        /* bool CheckCovDiagonalElements(double *element){
+           if(Get("MaxCovDiagonalElements",0)<0) return true;
+           bool isGoodTrack = true;
+           for(Int_t i=0;i<5;i++){
+           if(Get("MaxCovDiagonalElements",i) < element[i]) isGoodTrack = false;
+           }
+           return isGoodTrack; 
+           }*/
+
+        bool CheckTrackParamsInTPC(int NClustersTPC,float Chi2PerClusterTPC);
+
+        bool CheckMinNumTPCClustPt(int NClustersTPC, float fpt);
+
+        bool CheckTrackImpact(float xyIm, float zIm, float fpt);
+
+
+        bool AcceptKinkDaughters(int kinkIndex){
+            if(( ! (bool) Get("AcceptKinkDaughters")) && kinkIndex > 0 ) return false;//we do not want kinks but kink findex>0
+            else return true;
+        }
+
+
+        double GetCutOnBkgActivity(){
+            return (double) Get("CutOnBkgActivity");
+        }
+
+        void   SetEventV3kv(double inV3kv) {feventV3kv = inV3kv;}
+        double GetEventV3kv() const {return feventV3kv;}
+
+        //Alice CALO
+        bool ReadEmcalSm(int sm){ return (bool) Get("EMCAL_SM",sm);}
+        bool ReadPhosSm(int sm){ return (bool) Get("PHOS_SM",sm);}
+
+        bool  MixPhotonForPi0Mass() {return ((int) Get("massMix")==1);}//FK//
+        bool  MixMBForPi0Mass() {return ((int) Get("massMixMB")>0);}
+        bool  MixMBMBForPi0Mass() {return ((int) Get("massMixMB")==2);}
+
+        virtual void InitCard(); //TODO
+        void FinishCard(); // TODO
+
+
+    protected:
+
+
+        TString GetKeyWord(corrType ctype);
+        corrType GetCorrType( TString inStr );
+
+        //   double effPar[16];
+        //   double corrCent[10]; //FK// additional scaling factor to effPar to correct on hi fcentrality
+        TH2D *fhCorr;  // comment me
+
+        double feventV3kv;  // comment me
+        //====   D a t a    M e m b e r s  ========
+
+        vector< int >       fIndexVector;     //array of float number confg parameter vectors 
+
+        Double_t **fpi0massbin; //! faster access to pi0 mass bins
+
+        //ClassDef(AliJCard, 1); // EMCAL for jcorran
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJConst.h b/PWGLF/SPECTRA/XtAnalysis/AliJConst.h
new file mode 100644 (file)
index 0000000..bef02a5
--- /dev/null
@@ -0,0 +1,94 @@
+/**************************************************************************
+ * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Comment describing what this class does needed!
+
+// $Id: JConst.h,v 1.5 2008/05/08 15:19:52 djkim Exp $
+
+////////////////////////////////////////////////////
+/*!
+  \file JConst.h
+  \brief
+  \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla)
+  \email: djkim@jyu.fi
+  \version $Revision: 1.5 $
+  \date $Date: 2008/05/08 15:19:52 $
+*/
+////////////////////////////////////////////////////
+
+#ifndef JCONST_H
+#define JCONST_H
+
+//
+//  Constants
+//
+// for JHisto and PhxJHisto
+#define kMaxNoCentrBin 10   // Maximum no of centrality bins defined in JCard.h
+#define kMaxTriggParticleType 35           // 
+#define kMaxJetType  32          // 
+#define kPtDim 15           // 
+#define kMaxNoRuns 100      // Maximum no of runs in a nanoDST file
+#define kMaxNoEPBin 24
+
+const double kJPi           = 3.14159265358979; //TMath::Pi();
+const double kJTwoPi        = 2*kJPi;
+const double kJToRadian     = kJPi/180.;
+const double kJToDegree     = 180./kJPi;
+const double kElectronMass = .51099906e-3;
+const double kPionMass     = .1395675;
+
+
+//====================== particle types ============================================
+const int kNumberOfParticleTypes = 10;
+enum particleType   {kHadron, kPion, kKaon, kProton, kPhoton, kDecayphoton, kPizero, kEta,kHadronMC, kJet, kJNone};
+
+const char* const kParticleTypeStrName[kNumberOfParticleTypes] =
+                    {"hadron", "pion", "kaon", "proton", "photon", "decayphoton", "pizero", "eta", "hadronMC", "none"};
+const char* const kParticleProtoType[kNumberOfParticleTypes] =
+                     {"AliJTrack", "AliJTrack", "AliJTrack", "AliJTrack", "AliJPhoton", "AliJPhoton", "AliJPiZero", "AliJPiZero", "None"};
+
+//=======================JCorran trigger table definition===========================
+//internal JCorran trigger mask  TBit=0 is MinBias, TBit=1 HighMultiplicityTrigger
+enum TriggerBitJCorran   {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran,
+                          kEmc0TriggerBitJCorran,
+                          kEmc1GammaTriggerBitJCorran, kEmc1JetTriggerBitJCorran,
+                          kCentralTriggerBitJCorran,kSemiCentralTriggerBitJCorran,
+                          kFastOnlyBitJCorran,
+                                                 kINT7TriggerBitJCorran
+                          };  
+const int kRangeTriggerTableAlice   = 50;
+const int kRangeTriggerTableJCorran = 16;
+
+//==================================================================================
+enum fillType { kReal, kMixed, kEtaGap };
+enum corrFillType {kAzimuthFill=0,kPionFill=1};
+enum corrType { kTriggType, kAssocType, kXeType, kLongType, kCentrType, kZVertType, kMassType, kEtaGapType, kDiJetType, kRGapType, kNoType, kNcorrType };
+enum TriggerParticleType { kTriggParticles, kLeadingParticle, kIsolatedParticle }; 
+
+const char* const kTriggerParticleTypeName[] = 
+      {"TriggParticles","LeadingParticle","IsolatedParticle"};
+
+// JETs =====
+const int kNJetAlg = 10;
+enum JetAlg   {kkt,kantikt,ksiscone,krecomE,krecomB,kcdfmidpoint,kjade,kd0run2cone,kGF,kSimpleCone};
+const char* const kJetAlgStrName[kNJetAlg] =
+                    {"kt","antikt","siscone","recomE","recomB","cdfmidpoint","jade","d0run2cone","GF","SimpleCone"};
+
+enum EPType { kEPV0A, kEPV0C, kEPV0AC, kNEPType };
+const int kNHarmonics = 5;
+// PHENIX  constants
+enum TEMC {kPbSc, kPbGl}; 
+
+#endif
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.cxx b/PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.cxx
new file mode 100644 (file)
index 0000000..ff450c4
--- /dev/null
@@ -0,0 +1,212 @@
+/**************************************************************************
+ * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/**************************************************************************
+ * AliJXtHistos.h
+ * This class encapsulated all histograms that the analysis provides
+ *
+ *
+ * contact: Sami Räsänen
+ *          University of Jyväskylä, Finland
+ *          sami.s.rasanen@jyu.fi
+ **************************************************************************/
+
+#include  "AliJXtHistos.h"
+#include  "AliJCard.h"
+
+//______________________________________________________________________________
+AliJXtHistos::AliJXtHistos(AliJCard* cardP):
+       fUseDirectory(true)
+{   // constructor
+
+       fcard=cardP;
+       fmaxEtaRange = fcard->Get("EtaRange");
+
+       fhistoList = new TList();
+       fTopDirectory = gDirectory;
+}
+
+//______________________________________________________________________________
+AliJXtHistos::AliJXtHistos(const AliJXtHistos& obj){
+       // copy constructor
+}
+
+//______________________________________________________________________________
+AliJXtHistos& AliJXtHistos::operator=(const AliJXtHistos& obj){
+       // copy constructor
+       return *this;
+}
+//______________________________________________________________________________
+TDirectory * AliJXtHistos::MakeDirectory(TString name){
+    // Make directory with given name and move into it
+    JumpToDefaultDirectory();
+    TDirectory * dir = gDirectory->GetDirectory(name);
+    if( !dir ) dir = gDirectory->mkdir(name);
+    dir->cd();
+    return dir;
+}
+//______________________________________________________________________________
+TDirectory * AliJXtHistos::JumpToDefaultDirectory(){
+    // Move to default directory
+    fTopDirectory->cd();
+    return gDirectory;
+}
+//______________________________________________________________________________
+void AliJXtHistos::FillInclusiveHistograms(double pT, double xT, double eta, double phi, double effCorr, int centBin){
+    // Fill all inclusive histograms
+    fhChargedEta[centBin]->Fill(eta, effCorr);
+    fhChargedPhi[centBin]->Fill(phi, effCorr);
+    fhChargedPt[centBin]->Fill(pT, effCorr);
+    fhChargedXt[centBin]->Fill(xT, effCorr);
+    fhInvariantChargedPt[centBin]->Fill(pT, pT > 0. ? effCorr/pT : 0.); // Can you do 1/pT here???
+    fhInvariantChargedXt[centBin]->Fill(xT, xT > 0. ? effCorr/xT : 0.); // Can you do 1/xT here???
+    // For checks, fill also without efficiency correction
+    fhChargedEtaNoCorr[centBin]->Fill(eta);
+    fhChargedPhiNoCorr[centBin]->Fill(phi);
+    fhChargedPtNoCorr[centBin]->Fill(pT);
+    fhChargedXtNoCorr[centBin]->Fill(xT);
+}
+//______________________________________________________________________________
+void AliJXtHistos::FillIsolatedHistograms(double pT, double xT, double eta, double phi, double effCorr, int centBin){
+    // Fill all inclusive histograms
+    fhIsolatedChargedEta[centBin]->Fill(eta, effCorr);
+    fhIsolatedChargedPhi[centBin]->Fill(phi, effCorr);
+    fhIsolatedChargedPt[centBin]->Fill(pT, effCorr);
+    fhIsolatedChargedXt[centBin]->Fill(xT, effCorr);
+    fhInvariantIsolatedChargedPt[centBin]->Fill(pT, pT > 0. ? effCorr/pT : 0.); // Can you do 1/pT here???
+    fhInvariantIsolatedChargedXt[centBin]->Fill(xT, xT > 0. ? effCorr/xT : 0.); // Can you do 1/xT here???
+}
+//______________________________________________________________________________
+void AliJXtHistos::CreateXtHistos(){
+    // all the histograms of xT analysis
+    
+       MakeDirectory("xT");
+       TH1::SetDefaultSumw2(kTRUE);
+       cout << "GetDefaultSumw2() = " << TH1::GetDefaultSumw2() << endl;
+    
+       // === pT binning
+       int nBins=150;
+       double logBinsPt[nBins+1], limL=0.1, limH=100;
+       double logBW = (log(limH)-log(limL))/nBins;
+       for(int ij=0;ij<=nBins;ij++) logBinsPt[ij]=limL*exp(ij*logBW);
+
+       // === xT binning
+       int nBinsXt=200;
+       double logBinsXt[nBinsXt+1];
+       double xTlimL = 1e-5, xTlimH = 1.0, xTlogBW = (log(xTlimH)-log(xTlimL))/nBinsXt;
+       for(int ij=0;ij<=nBinsXt;ij++) logBinsXt[ij]=xTlimL*exp(ij*xTlogBW);
+    
+    // === create histos
+       for (int hic = 0;hic < fcard->GetNoOfBins(kCentrType);hic++) {
+               float b1 = fcard->GetBinBorder(kCentrType, hic);
+               float b2 = fcard->GetBinBorder(kCentrType, hic + 1);
+        
+               fhChargedPt[hic] = new TH1D(Form("hChargedPt%d",hic), Form("C: %2.0f-%2.0f%%",b1,b2), nBins, logBinsPt );
+               fhChargedPt[hic]->Sumw2();
+               fhistoList->Add(fhChargedPt[hic]);
+        
+               fhInvariantChargedPt[hic] = new TH1D(Form("hInvariantChargedPt%d",hic), Form("C: %2.0f-%2.0f%%",b1,b2), nBins, logBinsPt );
+               fhInvariantChargedPt[hic]->Sumw2();
+               fhistoList->Add(fhInvariantChargedPt[hic]);
+        
+               fhChargedPtNoCorr[hic] = new TH1D(Form("hChargedPtNoCorr%d",hic), Form("C: %2.0f-%2.0f%%",b1,b2), nBins, logBinsPt );
+               fhChargedPtNoCorr[hic]->Sumw2();
+               fhistoList->Add(fhChargedPtNoCorr[hic]);
+        
+               fhIsolatedChargedPt[hic] = new TH1D(Form("hIsolatedChargedPt%d",hic), Form("C: %2.0f-%2.0f%%",b1,b2), nBins, logBinsPt );
+               fhIsolatedChargedPt[hic]->Sumw2();
+               fhistoList->Add(fhIsolatedChargedPt[hic]);
+        
+               fhInvariantIsolatedChargedPt[hic] = new TH1D(Form("hInvariantIsolatedChargedPt%d",hic), Form("C: %2.0f-%2.0f%%",b1,b2), nBins, logBinsPt );
+               fhInvariantIsolatedChargedPt[hic]->Sumw2();
+               fhistoList->Add(fhInvariantIsolatedChargedPt[hic]);
+        
+        fhChargedXt[hic] = new TH1D(Form("hChargedXt%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), nBinsXt, logBinsXt );
+        fhChargedXt[hic]->Sumw2();
+        fhistoList->Add( fhChargedXt[hic] );
+        
+        fhInvariantChargedXt[hic] = new TH1D(Form("hInvariantChargedXt%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), nBinsXt, logBinsXt );
+        fhInvariantChargedXt[hic]->Sumw2();
+        fhistoList->Add( fhInvariantChargedXt[hic] );
+        
+        fhChargedXtNoCorr[hic] = new TH1D(Form("hChargedXtNoCorr%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), nBinsXt, logBinsXt );
+        fhChargedXtNoCorr[hic]->Sumw2();
+        fhistoList->Add( fhChargedXtNoCorr[hic] );
+        
+        fhIsolatedChargedXt[hic] = new TH1D(Form("hIsolatedChargedXt%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), nBinsXt, logBinsXt );
+        fhIsolatedChargedXt[hic]->Sumw2();
+        fhistoList->Add( fhIsolatedChargedXt[hic] );
+        
+        fhInvariantIsolatedChargedXt[hic] = new TH1D(Form("hInvariantIsolatedChargedXt%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), nBinsXt, logBinsXt );
+        fhInvariantIsolatedChargedXt[hic]->Sumw2();
+        fhistoList->Add( fhInvariantIsolatedChargedXt[hic] );
+        
+        fhChargedEta[hic] = new TH1D(Form("hChargedEta%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),100,-1.0,1.0);
+        fhChargedEta[hic]->Sumw2();
+        fhistoList->Add(fhChargedEta[hic]);
+        
+        fhChargedEtaNoCorr[hic] = new TH1D(Form("hChargedEtaNoCorr%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),100,-1.0,1.0);
+        fhChargedEtaNoCorr[hic]->Sumw2();
+        fhistoList->Add(fhChargedEtaNoCorr[hic]);
+        
+        fhIsolatedChargedEta[hic] = new TH1D(Form("hIsolatedChargedEta%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),100,-1.0,1.0);
+        fhIsolatedChargedEta[hic]->Sumw2();
+        fhistoList->Add(fhIsolatedChargedEta[hic]);
+        
+        fhChargedPhi[hic] = new TH1D(Form("hChargedPhi%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),128,-0.2,6.4);
+        fhChargedPhi[hic]->Sumw2();
+        fhistoList->Add(fhChargedPhi[hic]);
+        
+        fhChargedPhiNoCorr[hic] = new TH1D(Form("hChargedPhiNoCorr%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),128,-0.2,6.4);
+        fhChargedPhiNoCorr[hic]->Sumw2();
+        fhistoList->Add(fhChargedPhiNoCorr[hic]);
+        
+        fhIsolatedChargedPhi[hic] = new TH1D(Form("hIsolatedChargedPhi%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2),128,-0.2,6.4);
+        fhIsolatedChargedPhi[hic]->Sumw2();
+        fhistoList->Add(fhIsolatedChargedPhi[hic]);
+        
+        fhZVert[hic] = new TH1D(Form("hZVert%d",hic),Form("C: %2.0f-%2.0f%%",b1,b2), 120, -30., 30.);
+        fhistoList->Add(fhZVert[hic]);
+       }
+
+       fhZVertRaw  = new TH1D("hZVertRaw","vertex 0", 120, -30., 30.);
+       fhistoList->Add(fhZVertRaw);
+       fhCentr          = new TH1D("hCentr","centrality", 101, -0.5, 100.5);
+       fhistoList->Add(fhCentr);
+       fhiCentr         = new TH1D("hiCentr","centrality",10, -0.5, 9.5);
+       fhistoList->Add(fhiCentr);
+       fhEventPerRun = new TH1D("hEventPerRun","log(eve)/run",200, 0, 30.0);
+       fhistoList->Add(fhEventPerRun);
+
+       //------------------ for Abs Norm FK --------------------------------
+       double   binsVertexMult[] = {0,1,2,3,4,5,10000};
+       int   nBinsVertexMult  = sizeof(binsVertexMult)/sizeof(double)-1;
+       double binsVertexZ[]    = {-10,-6,-3,-2,-1.5,-1,-0.5,0,0.5,1,1.5,2,3,6,10};
+       int   nBinsVertexZ   = sizeof(binsVertexZ)/sizeof(double)-1;
+       fhVertexZTriggVtx = new TH2D("hVertexZTriggVtx","Vertex counts", nBinsVertexMult, binsVertexMult, nBinsVertexZ, binsVertexZ);
+       fhistoList->Add(fhVertexZTriggVtx);
+
+       sprintf(fhtit, "Mean activity inside cone");
+       sprintf(fhname, "hActivity");
+       fhConeActivity = new TProfile(fhname, fhtit, nBins, logBinsPt );
+       fhistoList->Add(fhConeActivity);
+
+       sprintf(fhtit, "Mean pion activity inside cone isolated");
+       sprintf(fhname, "hActivityIsolated");
+       fhConeActivityIsolated = new TProfile(fhname, fhtit, nBins, logBinsPt );
+       fhistoList->Add(fhConeActivityIsolated);
+
+       JumpToDefaultDirectory();
+}
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.h b/PWGLF/SPECTRA/XtAnalysis/AliJXtHistos.h
new file mode 100644 (file)
index 0000000..e078dc2
--- /dev/null
@@ -0,0 +1,115 @@
+/**************************************************************************
+ * AliJXtHistos.h
+ * This class encapsulated all histograms that the analysis provides
+ *
+ * contact: Sami Räsänen
+ *          University of Jyväskylä, Finland
+ *          sami.s.rasanen@jyu.fi
+ **************************************************************************/
+
+#ifndef ALIJXTHISTOS_H
+#define ALIJXTHISTOS_H
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <TH1.h>
+#include <TH2.h>
+#include <TProfile.h>
+#include <TFile.h>
+#include <TList.h>
+
+#define kMaxNoCentrBin 10   // Maximum no of centrality bins defined in JCard.h
+
+class AliJCard;
+
+using namespace std;
+
+class AliJXtHistos {
+
+    public:
+        AliJXtHistos(AliJCard* cardP); //constructor
+        virtual ~AliJXtHistos(){delete fhistoList;}    //destructor
+        AliJXtHistos(const AliJXtHistos& obj);
+        AliJXtHistos& operator=(const AliJXtHistos& obj);
+
+        // create histograms 
+        void CreateXtHistos();
+
+        TList *GetHistoList() { return fhistoList; } //return the list of histograms
+
+        bool UseDirectory() const { return fUseDirectory; } // Are there directories in the final root file, yes/no
+        void UseDirectory(bool b) { fUseDirectory=b; } // Decide weather to use directories
+
+        TDirectory * MakeDirectory(TString name); // Make new directory into final root file
+        TDirectory * JumpToDefaultDirectory(); // move into default directory at the final root file
+    
+        // Fill various histograms
+        void FillCentralityHistos(double fcent, int fCentBin){
+            // Fill centrality histograms
+            fhCentr->Fill(fcent);
+            fhiCentr->Fill(1.0*fCentBin);
+        }
+        void FillRawVertexHisto(double zVert){fhZVertRaw->Fill(zVert);} // fill raw z-vertex histogram
+        void FillAcceptedVertexHisto(double zVert, int centBin){fhZVert[centBin]->Fill(zVert);} // fill accepted z-vertex histograms
+        void FillInclusiveHistograms(double pT, double xT, double eta, double phi, double effCorr, int centBin); // Fill histograms
+        void FillIsolatedHistograms(double pT, double xT, double eta, double phi, double effCorr, int centBin);  // Fill histograms
+        void FillInclusiveConeActivities(double pT, double sumPt){fhConeActivity->Fill(pT,sumPt);} // Fill TProfile
+        void FillIsolatedConeActivities(double pT, double sumPt){fhConeActivityIsolated->Fill(pT,sumPt);}  // Fill TProfile
+    
+    protected:
+        AliJCard  *fcard; // parameters in card
+    
+        double fmaxEtaRange; // charged track eta acceptance
+    
+        TList *fhistoList; // list of histograms
+        bool   fUseDirectory; // to create sub-directories in the final results, used more in case of JCORRAN
+        TDirectory * fTopDirectory; // top directory, different analysis (JCORRAN) in sub-directories.
+
+    private:
+        char  fhname[40], fhtit[40]; // dummy variables to create histogram names and titles
+
+        TH1D *fhChargedPt[kMaxNoCentrBin], *fhInvariantChargedPt[kMaxNoCentrBin], *fhChargedPtNoCorr[kMaxNoCentrBin]; // inclusive pT distribution - dN/dpT and 1/pT dN/dpT, last without efficiency correction
+        TH1D *fhIsolatedChargedPt[kMaxNoCentrBin], *fhInvariantIsolatedChargedPt[kMaxNoCentrBin]; // the same as above but for isolated pT
+        TH1D *fhChargedXt[kMaxNoCentrBin], *fhInvariantChargedXt[kMaxNoCentrBin], *fhChargedXtNoCorr[kMaxNoCentrBin]; // The same as inclusive, but for xT
+        TH1D *fhIsolatedChargedXt[kMaxNoCentrBin], *fhInvariantIsolatedChargedXt[kMaxNoCentrBin]; // the same, but for isolated xT
+        TH1D *fhChargedPhi[kMaxNoCentrBin], *fhChargedPhiNoCorr[kMaxNoCentrBin], *fhIsolatedChargedPhi[kMaxNoCentrBin]; // phi -distributions - inclusive, without efficiency correction and for isolated
+        TH1D *fhChargedEta[kMaxNoCentrBin], *fhChargedEtaNoCorr[kMaxNoCentrBin], *fhIsolatedChargedEta[kMaxNoCentrBin]; // the same as above but for eta
+
+        TProfile *fhConeActivity;          // pT sum in cone, to be compared to the ALICE UE results
+        TProfile *fhConeActivityIsolated;  // activity for isolated particles
+
+               TH1D *fhZVertRaw; // raw z-vertex distribution
+               TH1D *fhZVert[kMaxNoCentrBin]; // accepted z-vertex as a function of centrality
+               TH1D *fhCentr; // centrality
+               TH1D *fhiCentr; // centrality, accepted
+               TH1D *fhEventPerRun; // number of events per run
+               TH2D* fhVertexZTriggVtx; // z-vertex distribution of triggered events, needed somewhere?
+
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.cxx b/PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.cxx
new file mode 100644 (file)
index 0000000..fc51993
--- /dev/null
@@ -0,0 +1,386 @@
+/**************************************************************************
+ * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/**************************************************************************
+ *     AliXtAnalysis:
+ * This class constructs inclusive and isolated (based on charged tracks)
+ * invariant spectra. Isolated case uses a different efficiency where the
+ * contamination from cases where non-isolated particle appears as an
+ * isolated one due to finite detector efficiency is taken into account.
+ *
+ * contact: Sami Räsänen
+ *          University of Jyväskylä, Finland 
+ *          sami.s.rasanen@jyu.fi
+**************************************************************************/
+
+// general + root classes
+#include <TList.h>
+#include <TChain.h>
+#include <TObjArray.h>
+
+// AliRoot classes
+#include <AliAnalysisManager.h>
+#include <AliInputEventHandler.h>
+#include <AliAnalysisUtils.h>
+#include <AliAODTrack.h>
+#include <AliAODEvent.h>
+
+// Jyväskylä classes
+#include "AliJCard.h"
+#include "AliJXtHistos.h"
+//#include "AliIsolatedEfficiency.h"
+
+// This analysis
+#include "AliXtAnalysis.h"
+ClassImp(AliXtAnalysis)
+
+//________________________________________________________________________
+AliXtAnalysis::AliXtAnalysis() 
+       : AliAnalysisTaskSE(), fOutputList(0x0)
+{
+       // Constructor
+       fhEvents = NULL;
+       fAnaUtils = NULL;
+    fHistDir = NULL;
+       fHistos = NULL;
+    fhEvents = NULL;
+       //fEfficiency = NULL;
+       fCard = NULL;
+       fChargedList = NULL;
+       fIsolatedChargedList = NULL;
+    fCentBin = -1;
+    fZBin = -1;
+    fZVert = 999999.;
+       fevt = 0;
+       fDebugMode = 0;
+}
+//________________________________________________________________________
+AliXtAnalysis::AliXtAnalysis(const char *name, const char * cardname) 
+       : AliAnalysisTaskSE(name), 
+       fOutputList(0x0), 
+       fAnaUtils(0x0),
+    fHistDir(0x0),
+       fHistos(0x0),
+    fhEvents(0x0),
+       //fEfficiency(0x0),
+       fChargedList(0x0),
+       fIsolatedChargedList(0x0),
+    fCentBin(-1),
+    fZBin(-1),
+    fZVert(999999.),
+       fevt(0),
+       fDebugMode(0)
+{
+    // All parameters of the analysis
+    fCard = new AliJCard(cardname);
+    fCard->PrintOut();
+
+       fAnaUtils = new AliAnalysisUtils();
+       fAnaUtils->SetUseOutOfBunchPileUp( kTRUE );
+       fAnaUtils->SetUseSPDCutInMultBins( kTRUE);
+
+    // Define input and output slots here
+    // Input slot #0 works with a TChain
+    DefineInput(0, TChain::Class());
+    // Output slot #0 writes into a TH1 container
+    DefineOutput(1, TList::Class());
+    // JHistos into TDirectory
+    DefineOutput(2, TDirectory::Class());
+}
+//________________________________________________________________________
+AliXtAnalysis::AliXtAnalysis(const AliXtAnalysis& a):
+       AliAnalysisTaskSE(a.GetName()),
+       fOutputList(a.fOutputList),
+       fAnaUtils(a.fAnaUtils),
+    fCard(a.fCard),
+    fHistDir(a.fHistDir),
+    fHistos(a.fHistos),
+    fhEvents(a.fhEvents),
+       //fEfficiency(a.fEfficiency),
+       fChargedList(a.fChargedList),
+       fIsolatedChargedList(a.fIsolatedChargedList),
+    fCentBin(-1),
+    fZBin(-1),
+    fZVert(999999.),
+    fevt(0),
+    fDebugMode(0)
+{
+    //copy constructor
+    fhEvents = (TH1D*) a.fhEvents->Clone(a.fhEvents->GetName());
+}
+//________________________________________________________________________
+AliXtAnalysis& AliXtAnalysis::operator = (const AliXtAnalysis& ap){
+       // assignment operator
+       this->~AliXtAnalysis();
+       new(this) AliXtAnalysis(ap);
+       return *this;
+}
+//________________________________________________________________________
+AliXtAnalysis::~AliXtAnalysis() {
+    // destructor
+    delete fOutputList;
+    delete [] fAnaUtils;
+    delete [] fhEvents;
+    delete fHistos;
+    //delete fEfficiency;
+    delete fCard;
+    delete fChargedList;
+    delete fIsolatedChargedList;
+}
+//________________________________________________________________________
+void AliXtAnalysis::UserCreateOutputObjects(){
+    // Create histograms
+    // Called once
+    
+    cout<<"\n=============== CARD =============="<<endl;
+    fCard->PrintOut();
+    cout<<"===================================\n"<<endl;
+    
+    fhEvents = new TH1D("hEvents","events passing cuts", 11, -0.5, 10.5 );
+    fhEvents->SetXTitle( "0 - all, 1 - pileup, 2 - kMB selected, 3 - has vertex, 4 - good vertex, 5 - MB + good vertex, 6 - MB + good vertex + centrality" );
+    fhEvents->Sumw2();
+    
+    fOutputList = new TList();
+    fOutputList->SetOwner(kTRUE);
+    //for any MC track filled with MC pt
+    fOutputList->Add(fhEvents);
+
+    fChargedList = new TObjArray;
+    fChargedList->SetOwner(kTRUE);
+    fIsolatedChargedList = new TObjArray;
+    
+    PostData(1, fOutputList);
+    
+    bool orignalTH1AdddirectoryStatus=TH1::AddDirectoryStatus();
+    TH1::AddDirectory(kTRUE);
+    if( !orignalTH1AdddirectoryStatus ) cout<<"DEBUG : TH1::AddDirectory is turned on"<<endl;
+    TFile * file2 = OpenFile(2);
+    file2-> SetCompressionLevel(9);
+    file2->cd();
+    
+    fHistDir=gDirectory;
+    fHistos = new AliJXtHistos(fCard);
+    fHistos->CreateXtHistos();
+    
+    PostData(2, fHistDir);
+    TH1::AddDirectory( orignalTH1AdddirectoryStatus );
+    cout<<"DEBUG : TH1::AddDirectory get orignal Value = "<<( orignalTH1AdddirectoryStatus?"True":"False" )<<endl;
+    
+    //fEfficiency = new AliJEfficiency();
+    
+    fevt = 0;
+}
+//________________________________________________________________________
+void AliXtAnalysis::UserExec(Option_t *) {
+    
+    // Main loop - called for each event
+    
+    fevt++;
+    if(fevt % 10000 == 0) cout << "Number of event scanned = "<< fevt << endl;
+    
+    Int_t filterBit = AliAODTrack::kTrkGlobal; //fCard->Get("TrackFilterBit");
+    
+    AliVEvent *event = InputEvent();
+    if(!event) return;
+    
+    // check if the event was triggered or not and vertex
+    if( !IsGoodEvent( event ) ) return; // fZBin is set there
+    fhEvents->Fill( 5 );
+    if(fDebugMode > 0) cout << "zvtx = " << fZVert << endl;
+    
+    AliAODEvent* aodEvent = dynamic_cast<AliAODEvent*>(event);
+    if(!aodEvent) return;
+    
+    // centrality - in case of pPb and PbPb, dictated by DataType in the card
+    double fcent;
+    if( fCard->Get("DataType") > 0.5 ){
+        AliCentrality *cent = event->GetCentrality();
+        if( ! cent ) return;
+        fcent = cent->GetCentralityPercentile("V0M");
+        fCentBin = fCard->GetBin(kCentrType, fcent);;
+        //cout <<"Centrality = "<< fcent <<"\t"<< fCentBin << endl;
+    }else{
+        fcent = 0.0;
+        fCentBin = 0;
+    }
+    
+    if(fCentBin<0) return;
+    fhEvents->Fill( 6 );
+    Int_t nt = aodEvent->GetNumberOfTracks();
+    
+    fHistos->FillCentralityHistos(fcent, fCentBin);
+    
+    // clear them up for every event
+    fChargedList->Clear();
+    fIsolatedChargedList->Clear();
+    
+    // Is there a better way than hard code this into card???
+    double sqrts = fCard->Get("Sqrts");
+    
+    // Isolation method: 0 = relative, 1 = absolute
+    double isolMethod = fCard->Get("IsolationMethod");
+    
+    // Minimum isolation pT that is considered
+    double minIsolationPt = fCard->Get("MinimumIsolatedPt");
+    
+    // Dummy numbers; either of these is updated based on selected method (other is void)
+    double isolationFraction  = 99999.;
+    double isolationThreshold = 99999.;
+    
+    if( isolMethod > 0.5 ){
+        isolationThreshold = fCard->Get("IsolationThreshold");  // this is fixed threshold
+    }else{
+        isolationFraction = fCard->Get("IsolationFraction");  // fraction in pT, threshold updated later in a loop
+    }
+    
+    // Isolation radius
+    double isolR = fCard->Get("IsolationRadius");
+    
+    // Get good tracks to the list
+    for(Int_t it = 0; it < nt; it++) {
+        AliAODTrack *track = aodEvent->GetTrack(it);
+        if( !track ) continue;
+        if( !track->TestFilterBit(filterBit) ) continue;
+        double eta = track->Eta();
+        if( !fCard->IsInEtaRange( eta ) ) continue; // Do not use fiducial cut here
+        AliAODTrack *acceptedTrack = new AliAODTrack( *track );
+        double pT = acceptedTrack->Pt();
+        double xT = 2.*pT/sqrts;
+        double phi = acceptedTrack->Phi();
+        
+        // TODO:
+        double effCorr = 1.0;
+        
+        // Fill histos
+        fHistos->FillInclusiveHistograms(pT, xT, eta, phi, effCorr, fCentBin);
+        
+        // Add an accepted track into list of inclusive charged particles
+        fChargedList->Add( acceptedTrack );
+    }
+    
+    // Check isolation of the found good tracks
+    Int_t nAcc = fChargedList->GetEntriesFast();
+    
+    // Get eta range for fiducial cut
+    double etaRange = fCard->Get("EtaRange");
+    
+    for( Int_t it = 0; it < nAcc; it++ ){
+        AliAODTrack *track = (AliAODTrack*)fChargedList->At(it);
+        // Fiducial eta cut for isolated particles
+        double eta = track->Eta();
+        if( abs(eta) > etaRange - isolR ) continue;
+        
+        // To check the isolation with cone, use TLorentzVector -routines
+        TLorentzVector lvTrack = TLorentzVector( track->Px(), track->Py(), track->Pz(), track->P() );
+        
+        // Set isolation threshold, if relative isolation
+        double pT = lvTrack.Pt();
+        if( pT < minIsolationPt ) continue;
+        if( isolMethod < 0.5 ) isolationThreshold = pT * isolationFraction; // here: relative isolation
+        
+        // Isolation check
+        double sum = 0.0;
+        for( Int_t ia = 0; ia < nAcc; ia++ ){
+            if( ia == it ) continue; // Do not count the particle itself
+            AliAODTrack *assocTrack = (AliAODTrack*)fChargedList->At(ia);
+            TLorentzVector lvAssoc = TLorentzVector( assocTrack->Px(), assocTrack->Py(), assocTrack->Pz(), assocTrack->P() );
+            if( lvTrack.DeltaR( lvAssoc ) < isolR ) sum += lvAssoc.Pt();
+        }
+        
+        // Cone activity
+        fHistos->FillInclusiveConeActivities(pT,sum);  // efficiency correction?
+        
+        // If the particle was isolated, fill histograms and the list
+        if( sum < isolationThreshold ){
+            
+            double xT = 2.*pT/sqrts;
+            
+            if( fDebugMode > 0 ){
+                cout << "DEBUG: isolated particle found " << endl;
+                cout << "fCentBin = " << fCentBin << ", pT = " << pT << ", xT = " << xT << " and eta = " << eta << endl;
+            }
+            
+            fHistos->FillIsolatedConeActivities(pT, sum);  // efficiency correction?
+            
+            // TODO:
+            double effCorr = 1.0;
+
+            // Fill histos
+            fHistos->FillIsolatedHistograms(pT, xT, eta, track->Phi(), effCorr, fCentBin);
+            
+            // Add tracks to the isolated list
+            AliAODTrack *acceptedIsolatedTrack = new AliAODTrack( *track );
+            fIsolatedChargedList->Add( acceptedIsolatedTrack );
+        }
+    }
+    
+    // For further analysis, there is now lists of all charged and isolated charged available, will be usefull.
+    
+    return;  // END
+}
+//________________________________________________________________________
+void AliXtAnalysis::Terminate(Option_t *)
+{
+    OpenFile(2);
+    fHistDir->Write();
+    
+    cout<<"Successfully finished"<<endl;
+}
+//________________________________________________________________________
+bool AliXtAnalysis::IsGoodEvent(AliVEvent *event) {
+    
+    // This function checks that the event has the requested trigger
+    // and that the z-vertex is in given range
+    
+    
+    fhEvents->Fill( 0 );
+    
+    if(fAnaUtils->IsPileUpEvent(event)) {
+        return kFALSE;
+    } else {
+        Bool_t triggeredEventMB = kFALSE; //init
+        
+        fhEvents->Fill( 1 );
+        
+        Bool_t triggerkMB = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & ( AliVEvent::kMB );
+        
+        if( triggerkMB ){
+            triggeredEventMB = kTRUE;  //event triggered as minimum bias
+            fhEvents->Fill( 2 );
+        }
+        //--------------------------------------------------------------
+        // check reconstructed vertex
+        int ncontributors = 0;
+        Bool_t goodRecVertex = kFALSE;
+        const AliVVertex *vtx = event->GetPrimaryVertex();
+        if(vtx){
+            fhEvents->Fill( 3 );
+            fZVert = vtx->GetZ();
+            fHistos->FillRawVertexHisto(fZVert);
+            ncontributors = vtx->GetNContributors();
+            if(ncontributors > 0){
+                if(fCard->VertInZRange(fZVert)) {
+                    goodRecVertex = kTRUE;
+                    fhEvents->Fill( 4 );
+                    fHistos->FillAcceptedVertexHisto(fZVert, fCentBin);
+                    fZBin  = fCard->GetBin(kZVertType, fZVert);
+                }
+            }
+        }
+        return triggerkMB && goodRecVertex;
+    }
+    //---------------------------------
+}
diff --git a/PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.h b/PWGLF/SPECTRA/XtAnalysis/AliXtAnalysis.h
new file mode 100644 (file)
index 0000000..17047f0
--- /dev/null
@@ -0,0 +1,68 @@
+/**************************************************************************
+ *     AliXtAnalysis:
+ * This class constructs inclusive and isolated (based on charged tracks)
+ * invariant spectra. Isolated case uses a different efficiency where the
+ * contamination from cases where non-isolated particle appears as an
+ * isolated one due to finite detector efficiency is taken into account.
+ *
+ * contact: Sami Räsänen
+ *          University of Jyväskylä, Finland
+ *          sami.s.rasanen@jyu.fi
+ **************************************************************************/
+
+#ifndef ALIXTANALYSIS_H
+#define ALIXTANALYSIS_H
+
+#include <AliAnalysisTaskSE.h>
+
+class AliVEvent;
+class TList;
+class AliAnalysisUtils;
+class AliJCard;
+class TDirectory;
+class AliJXtHistos;
+class TH1D;
+class TObjArray;
+
+class AliXtAnalysis : public AliAnalysisTaskSE {
+
+       public:
+               AliXtAnalysis();
+               AliXtAnalysis(const char *name, const char *cardname);
+               AliXtAnalysis(const AliXtAnalysis& a);
+               AliXtAnalysis& operator=(const AliXtAnalysis& ap);
+               
+               virtual ~AliXtAnalysis(); 
+
+               virtual void   UserCreateOutputObjects();
+               virtual void   UserExec(Option_t *option);
+               virtual void   Terminate(Option_t *);
+
+               bool IsGoodEvent(AliVEvent *event);
+               void SetDebugMode( int debug) { fDebugMode = debug; };
+
+       private:
+               TList               *fOutputList;       // Output list
+               AliAnalysisUtils        *fAnaUtils;     // Analysis utils
+               
+        //AliIsolatedEfficiency        *fEfficiency;   // TODO: isolated efficiency, currently eff = 1
+        AliJCard            *fCard;            // All parameters
+    
+        TDirectory          *fHistDir;  // histograms to the directory, structure compatible with JCORRAN
+        AliJXtHistos           *fHistos;       // encapsulate (almost) all histograms
+        TH1D                *fhEvents;  // general event statistics
+    
+               TObjArray           *fChargedList;      // accepted charged tracks in an event
+               TObjArray           *fIsolatedChargedList;      // isolated charged tracks in an event
+               
+        int fCentBin;       // centrality bin
+        int fZBin;          // z -vertex bin
+        double fZVert;      // z -vertex
+    
+               Int_t fevt;     // event number
+               int fDebugMode; // debug mode
+                               
+               ClassDef(AliXtAnalysis, 1);
+};
+
+#endif
diff --git a/PWGLF/SPECTRA/XtAnalysis/card_xT.input b/PWGLF/SPECTRA/XtAnalysis/card_xT.input
new file mode 100644 (file)
index 0000000..94d1312
--- /dev/null
@@ -0,0 +1,8 @@
+TrackFilterBit         1
+Sqrts                  7000.
+EtaRange               0.8
+IsolationMethod                0.0   # 0 = relative, 1 = absolute
+IsolationThreshold     0.5
+IsolationFraction      0.1
+IsolationRadius                0.4
+
diff --git a/PWGLF/SPECTRA/XtAnalysis/macros/AddTaskXtAnalysis.C b/PWGLF/SPECTRA/XtAnalysis/macros/AddTaskXtAnalysis.C
new file mode 100644 (file)
index 0000000..b29c340
--- /dev/null
@@ -0,0 +1,34 @@
+AliAnalysisTask *AddTaskXtAnalysis() {
+
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  if (!mgr) {
+    ::Error("AddTaskFluctuations", "No analysis manager to connect to.");
+    return NULL;
+  }
+
+  if (!mgr->GetInputEventHandler()) {
+    ::Error("AddTaskFluctuations", "This task requires an input event handler");
+    return NULL;
+  }
+
+  TString type = mgr->GetInputEventHandler()->GetDataType();
+  
+  AliXtAnalysis *xtTask = new AliXtAnalysis("AliXtAnalysis","./card_xT.input");
+  xtTask->SetDebugLevel(0);
+  xtTask->SetDebugMode(0);  
+
+  mgr->AddTask((AliAnalysisTask*) xtTask);
+
+  // Create containers for input/output
+  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
+
+  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("xtAnalysis", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:xtAnalysis",AliAnalysisManager::GetCommonFileName()));
+  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("xtHistos", TDirectory::Class(), AliAnalysisManager::kOutputContainer, Form("%s:xtHistos",AliAnalysisManager::GetCommonFileName()));
+  // Connect input/output
+  mgr->ConnectInput(xtTask, 0, cinput);
+  mgr->ConnectOutput(xtTask, 1, coutput1);
+  mgr->ConnectOutput(xtTask, 2, coutput2);
+
+  return xtTask;
+}
+