--- /dev/null
+//====================================
+//last modified FK 6.NOV 2009
+//====================================
+//blah
+// blah
+
+#include "AliJConst.h"
+#include "AliJBaseCard.h"
+
+//ClassImp(AliJBaseCard);
+
+AliJBaseCard::AliJBaseCard() :
+ fnentry(0),
+ fKeyWordVector(0),
+ fValuesVector(0),
+ fValueString(0),
+ fKeyTable(0)
+{
+ //constructor
+}
+
+AliJBaseCard::AliJBaseCard(const char *filename) :
+ fnentry(0),
+ fKeyWordVector(0),
+ fValuesVector(0),
+ fValueString(0),
+ fKeyTable(0)
+{
+ //constructor
+
+ strcpy(fcardname, filename); //needed in PrintOut()
+
+ 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){
+ // equal operator
+ JUNUSED(obj);
+ 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 ii=0;ii<fKeyWordVector.size();ii++ ){
+ if( fKeyWordVector[ii] == 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 fValuesVector 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(TDirectory *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]);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+//=================================================
+// 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(TDirectory *file);
+
+ virtual void InitCard();
+ void FinishCard();
+ 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
/**************************************************************************
-* Copyright(c) 1998-1999, 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 notifce *
-* 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. *
-**************************************************************************/
+ * 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: AliJBaseEventHeader.cxx,v 1.4 2008/05/08 13:44:45 djkim Exp $
////////////////////////////////////////////////////
//
-// \file AliJBaseEventHeader.cc
-// \brief
-// \author J. Rak, D.J.Kim, R.Diaz, M.Bondila, Chang Yeong (University of Jyvaskyla) email: djkim@cc.jyu.fi
-// \version $Revision: 1.4 $
-// \date $Date: 2008/05/08 13:44:45 $
+// \file AliJBaseEventHeader.cc
+// \brief
+// \author J. Rak, D.J.Kim, R.Diaz, M.Bondila, Chang Yeong (University of Jyvaskyla) email: djkim@cc.jyu.fi
+// \version $Revision: 1.4 $
+// \date $Date: 2008/05/08 13:44:45 $
//
// Base class for event headers
////////////////////////////////////////////////////
fVtxX(-999),
fVtxY(-999),
fVtxZ(-999),
- fVtxZErr(-999)
+ fVtxZErr(-999),
+ fVtxMCX(9999),
+ fVtxMCY(9999),
+ fVtxMCZ(9999)
{
// default constructor
}
fVtxX(-999),
fVtxY(-999),
fVtxZ(vtxz),
- fVtxZErr(-999)
+ fVtxZErr(-999),
+ fVtxMCX(9999),
+ fVtxMCY(9999),
+ fVtxMCZ(9999)
{
//constructor
}
fVtxX(a.fVtxX),
fVtxY(a.fVtxY),
fVtxZ(a.fVtxZ),
- fVtxZErr(a.fVtxZErr)
+ fVtxZErr(a.fVtxZErr),
+ fVtxMCX(a.fVtxMCX),
+ fVtxMCY(a.fVtxMCY),
+ fVtxMCZ(a.fVtxMCZ)
{
//copy constructor
}
fVtxY = header.fVtxY;
fVtxZ = header.fVtxZ;
fVtxZErr = header.fVtxZErr;
+ fVtxMCX = header.fVtxMCX;
+ fVtxMCY = header.fVtxMCY;
+ fVtxMCZ = header.fVtxMCZ;
}
return *this;
+/* 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: AliJBaseEventHeader.h,v 1.5 2008/05/08 13:44:45 djkim Exp $
////////////////////////////////////////////////////
float GetZVertex() const {return fVtxZ;}
float GetZVertexErr() const {return fVtxZErr;}
+ float GetXVertexMC() const {return fVtxMCX;}
+ float GetYVertexMC() const {return fVtxMCY;}
+ float GetZVertexMC() const {return fVtxMCZ;}
+
//setter
void SetEventID(int evid) {fEventID=evid;}
void SetCentrality(float cent) {fCentrality=cent;}
void SetZVertexErr(float vt) {fVtxZErr=vt;}
void SetVertex(float x, float y, float z, float err){ fVtxX=x;fVtxY=y;fVtxZ=z;fVtxZErr=err; }
+ void SetXVertexMC(float vt) {fVtxMCX=vt;}
+ void SetYVertexMC(float vt) {fVtxMCY=vt;}
+ void SetZVertexMC(float vt) {fVtxMCZ=vt;}
+
AliJBaseEventHeader& operator=(const AliJBaseEventHeader& header);
private:
Double32_t fVtxZ; //vertex Z
Double32_t fVtxZErr; //vertex error
+ Double32_t fVtxMCX; //vertex X MC
+ Double32_t fVtxMCY; //vertex Y MC
+ Double32_t fVtxMCZ; //vertex Z MC
+
ClassDef(AliJBaseEventHeader,1)
};
+/**************************************************************************
+ * 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 $
////////////////////////////////////////////////////
/*!
*/
////////////////////////////////////////////////////
-#include <iostream>
-#include <TLorentzVector.h>
#include "AliJBaseTrack.h"
//______________________________________________________________________________
AliJBaseTrack::AliJBaseTrack():
fID(-1),
- fLabel(-1),
+ fLabel(-9999),
fParticleType(-1),
fCharge(0),
fStatus(0),
- fFlags(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(-1),
+ fLabel(-9999),
fParticleType(ptype),
fCharge(charge),
fStatus(0),
- fFlags(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),
+ fLabel (a.fLabel),
fParticleType ( a.fParticleType ),
fCharge ( a.fCharge ),
fStatus ( a.fStatus ),
- fFlags ( a.fFlags )
+ 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 ( -1 ),
+ fLabel ( -9999 ),
fParticleType ( -1 ),
fCharge ( 0 ),
fStatus ( 0 ),
- fFlags ( 0 )
+ fFlags ( 0 ),
+ fTriggID(-1),
+ fAssocID(-1),
+ fTracEff(-1),
+ fMCIndex(-9999),
+ fWeight(1.0)
{
//copy constructor
}
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(Option_t* option = "" ) const{
+void AliJBaseTrack::Print(Option_t *option) const{
//object print out
+ JUNUSED(option);
std::cout<<Form("(ID,Type,Charge,Flags)=(%d, %d, %d, %d)" ,
fID, fParticleType, fCharge, fFlags );
- TLorentzVector::Print(option);
+ 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)
+/* 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 $
///////////////////////////////////////////////////
#include <TObject.h>
#endif
+#include <iostream>
+#include <TLorentzVector.h>
+#include <TMath.h>
#include "AliJConst.h"
-#include "TLorentzVector.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
-
- float GetTwoPiPhi() const {return Phi()>-AliJConst::kJPi/3 ? Phi() : AliJConst::kJTwoPi+Phi();}
- TLorentzVector GetLorentzVector(){ return TLorentzVector( *this);}
-
- 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);}
-
-
- 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; }
- void SetIsIsolated(Bool_t tf){ SetFlag( kIsIsolated, tf); }
-
- void Print(Option_t* option) 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.
-
- ClassDef(AliJBaseTrack,1)
+ 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(Option_t *option="") 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
--- /dev/null
+/**************************************************************************
+ * 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!
+
+// jcorran main class
+// used in local and grid execution
+// blah
+// blah
+// blah
+
+#include <TH1D.h>
+#include "AliJCORRAN.h"
+
+#include "AliJTrackCounter.h"
+#include <TClonesArray.h>
+
+#include "AliJCard.h"
+#include "AliJHistos.h"
+#include "AliJCorrelations.h"
+#include "AliJEventPool.h"
+#include "AliJDataManager.h"
+
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+#include "AliJTrack.h"
+#include "AliJPhoton.h"
+#include "AliJMCTrack.h"
+#include "AliJConst.h"
+
+
+
+
+#include "AliJEfficiency.h"
+#include <iostream>
+
+ClassImp(AliJCORRAN)
+
+ AliJCORRAN::AliJCORRAN() :
+ TObject(),
+ fExecLocal(kTRUE),
+ fFirstEvent(kTRUE),
+ fjtrigg((particleType)-100),
+ fjassoc((particleType)-100),
+ fcard(0),
+ finputFile(0),
+ fInclusiveFile(""),
+ fevt(0),
+ fhistos(0),
+ fcorrelations(0),
+ fphotonPool(0),
+ fassocPool(0),
+ fphotonList(0),
+ fchargedHadronList(0),
+ fpizeroList(0),
+ ftriggList(0),
+ fassocList(0),
+ fpairList(0),
+ fpairCounterList(0),
+ finputList(0),
+ fdmg(0),
+ feventHeader(0),
+ frunHeader(0),
+ fnumberEvents(0),
+ fieout(0),
+ fEventCounter(0),
+ fcent(0),
+ fncBin(0),
+ fnPttBin(0),
+ fbTriggCorrel(0),
+ fbLPCorrel(0),
+ fbLPpairCorrel(0),
+ fTrackEtaRange(0),
+ flowerPtAssocBoarder(0),
+ fCentMultLow(0),
+ fCentMultHigh(0),
+ fEventBC(0),
+ fSQRTS(0),
+ fEfficiency(0),
+ fRunTable(0),
+ fIsolationR(0),
+ fHadronSelectionCut(0)
+{
+ // constructor
+}
+
+AliJCORRAN::AliJCORRAN(Bool_t execLocal) :
+ TObject(),
+ fExecLocal(execLocal),
+ fFirstEvent(kTRUE),
+ fjtrigg((particleType)-100),
+ fjassoc((particleType)-100),
+ fcard(0),
+ finputFile(0),
+ fInclusiveFile(""),
+ fevt(0),
+ fhistos(0),
+ fcorrelations(0),
+ fphotonPool(0),
+ fassocPool(0),
+ fphotonList(0),
+ fchargedHadronList(0),
+ fpizeroList(0),
+ ftriggList(0),
+ fassocList(0),
+ fpairList(0),
+ fpairCounterList(0),
+ finputList(0),
+ fdmg(0),
+ feventHeader(0),
+ frunHeader(0),
+ fnumberEvents(0),
+ fieout(0),
+ fEventCounter(0),
+ fcent(0),
+ fncBin(0),
+ fnPttBin(0),
+ fbTriggCorrel(0),
+ fbLPCorrel(0),
+ fbLPpairCorrel(0),
+ fTrackEtaRange(0),
+ flowerPtAssocBoarder(0),
+ fCentMultLow(0),
+ fCentMultHigh(0),
+ fEventBC(0),
+ fSQRTS(0),
+ fEfficiency(0),
+ fRunTable(0),
+ fIsolationR(0),
+ fHadronSelectionCut(0)
+{
+ // constructor
+}
+
+AliJCORRAN::~AliJCORRAN(){
+ // destructor
+}
+
+AliJCORRAN::AliJCORRAN(const AliJCORRAN& obj) :
+ TObject(),
+ fExecLocal(obj.fExecLocal),
+ fFirstEvent(obj.fFirstEvent),
+ fjtrigg(obj.fjtrigg),
+ fjassoc(obj.fjassoc),
+ fcard(obj.fcard),
+ finputFile(obj.finputFile),
+ fInclusiveFile(obj.fInclusiveFile),
+ fevt(obj.fevt),
+ fhistos(obj.fhistos),
+ fcorrelations(obj.fcorrelations),
+ fphotonPool(obj.fphotonPool),
+ fassocPool(obj.fassocPool),
+ fphotonList(obj.fphotonList),
+ fchargedHadronList(obj.fchargedHadronList),
+ fpizeroList(obj.fpizeroList),
+ ftriggList(obj.ftriggList),
+ fassocList(obj.fassocList),
+ fpairList(obj.fpairList),
+ fpairCounterList(obj.fpairCounterList),
+ finputList(obj.finputList),
+ fdmg(obj.fdmg),
+ feventHeader(obj.feventHeader),
+ frunHeader(obj.frunHeader),
+ fnumberEvents(obj.fnumberEvents),
+ fieout(obj.fieout),
+ fEventCounter(obj.fEventCounter),
+ fcent(obj.fcent),
+ fncBin(obj.fncBin),
+ fnPttBin(obj.fnPttBin),
+ fbTriggCorrel(obj.fbTriggCorrel),
+ fbLPCorrel(obj.fbLPCorrel),
+ fbLPpairCorrel(obj.fbLPpairCorrel),
+ fTrackEtaRange(obj.fTrackEtaRange),
+ flowerPtAssocBoarder(obj.flowerPtAssocBoarder),
+ fCentMultLow(obj.fCentMultLow),
+ fCentMultHigh(obj.fCentMultHigh),
+ fEventBC(obj.fEventBC),
+ fSQRTS(obj.fSQRTS),
+ fEfficiency(obj.fEfficiency),
+ fRunTable(obj.fRunTable),
+ fIsolationR(obj.fIsolationR),
+ fHadronSelectionCut(obj.fHadronSelectionCut)
+{
+ // copy constructor
+ JUNUSED(obj);
+}
+
+AliJCORRAN& AliJCORRAN::operator=(const AliJCORRAN& obj){
+ // copy constructor
+ JUNUSED(obj);
+ return *this;
+}
+
+
+void AliJCORRAN::Initialize() const{
+ // init
+
+}
+
+void AliJCORRAN::UserCreateOutputObjects(){
+ // local init
+
+
+ cout << "jcorran user create output objects ----------------" << endl;
+
+ fHadronSelectionCut =int ( fcard->Get("HadronSelectionCut"));
+ fIsolationR = fcard->Get("IsolationR");
+
+ fhistos = new AliJHistos( fcard );
+ fhistos->CreateEventTrackHistos();
+ fhistos->CreateAzimuthCorrHistos();
+ fhistos->CreateIAAMoons();
+ fhistos->CreateXEHistos();
+ fhistos->CreateXtHistos();
+ fhistos->CreatePairPtCosThetaStar();
+
+ fhistos->fHMG->Print();
+
+ fEventBC = (Int_t)(fcard->Get( "eventBC" ));
+ fSQRTS = 0.;
+
+
+ //TODO: inclusive fhistos shipping along
+
+ fcorrelations = new AliJCorrelations( fcard, fhistos);
+ cout<<endl<< " -----" <<endl;
+ if( fInclusiveFile.Length() ) {
+ fhistos->ReadInclusiveHistos(fInclusiveFile);
+ fcorrelations->SetSampligInclusive(); //kperp background and triangle. Default is flat
+ cout<<"Sampling kperp and triangle from " << fInclusiveFile <<endl;
+ } else cout << "Sampling kperp and triangle from flat" <<endl;
+ cout<< " -----" <<endl <<endl;
+
+ //==================================
+
+ //cout<<kParticleTypeStrName[kPhoton]<<" "<<kParticleTypeStrName[fjtrigg]<<endl;
+ // EventPool for Mixing
+ fphotonPool = new AliJEventPool( fcard, fhistos, fcorrelations, kPhoton); // for pi0 mass
+ fassocPool = new AliJEventPool( fcard, fhistos, fcorrelations, fjassoc);
+
+ fphotonList = new TClonesArray(kParticleProtoType[kPhoton],1500);
+ // TClonesArray *cellList = new TClonesArray("AliJCaloCell",1500);
+ fchargedHadronList = new TClonesArray(kParticleProtoType[kHadron],1500);
+ fpizeroList = new TClonesArray(kParticleProtoType[kPizero],1500);
+ ftriggList = new TClonesArray(kParticleProtoType[fjtrigg],1500);
+ fassocList = new TClonesArray(kParticleProtoType[fjassoc],1500);
+ fpairList = new TClonesArray(kParticleProtoType[fjtrigg],1500);
+ fpairCounterList = new TClonesArray("AliJTrackCounter",1500);
+ finputList = NULL;
+ //TClonesArray *isolPizeroList = new TClonesArray("AliPhJPiZero",1500);
+
+ fdmg = new AliJDataManager(fcard, fhistos, fcorrelations, fExecLocal);
+ fdmg->SetExecLocal( fExecLocal );
+
+ //==== Read the Data files =====
+ if( fExecLocal ){
+ fdmg->ChainInputStream(finputFile);
+ // TODO: run header is not supposed to be here
+ // doesn't work fSQRTS = 2.*frunHeader->GetBeamEnergy();
+
+ // for grid running, numberEvents is filled by the encapsulating
+ // grid task, which has access to the input handlers and can
+ // extract event numbers out of it
+ fnumberEvents = fdmg->GetNEvents();
+ fieout = fnumberEvents/20;
+ frunHeader = fdmg->GetRunHeader();
+ cout<<"RunID = "<<frunHeader->GetRunNumber()<< " Looping over "<<fnumberEvents<<" events"<<endl;
+
+ } else {
+ fdmg->SetRunHeader( frunHeader );
+ frunHeader = fdmg->GetRunHeader();
+ }
+
+ //==== Efficiency ====
+ fEfficiency = new AliJEfficiency;
+ fEfficiency->SetMode( fcard->Get("EfficiencyMode") ); // 0:NoEff, 1:Period 2:RunNum 3:Auto
+
+ //-------------------------------------------------------------------
+ fEventCounter=0;
+
+ fcent = -1;
+ fncBin = fcard->GetNoOfBins( kCentrType );
+ fnPttBin = fcard->GetNoOfBins( kTriggType );
+
+ fbTriggCorrel = fcard->Get("CorrelationType")==0;
+ fbLPCorrel = fcard->Get("CorrelationType")==1;
+ fbLPpairCorrel = fcard->Get("CorrelationType")==2;
+ fTrackEtaRange = fcard->Get("EtaRange");
+ flowerPtAssocBoarder = fcard->GetBinBorder(kAssocType, 0);
+
+ //==== Limit the no of track for each fcentrality ======
+ fCentMultLow = new TF1("fCentMultLow","[0]*sqrt([1]-x)+[2]", 0, 75);
+ fCentMultHigh = new TF1("fCentMultHigh","[0]*sqrt([1]-x)+[2]", 0, 90);
+
+ // fast parameter load
+
+
+ fhistos->fHMG->WriteConfig();
+ fFirstEvent = kTRUE;
+ fevt = -1;
+
+ cout << "end of jcorran user create output objects ----------------" << endl;
+
+}
+
+void AliJCORRAN::UserExec(){
+ // event loop
+ fevt++;
+
+ // TODO Add train mode if( !fExecLocal && fFirstEvent ){
+ if( 0 && !fExecLocal && fFirstEvent ){
+ fdmg->ChainInputStream("");
+ fieout = fnumberEvents/20;
+ if (fieout<1) fieout=1;
+ cout<<"RunID = "<<frunHeader->GetRunNumber()<< " Looping over "<<fnumberEvents<<" events"<<endl;
+
+ //==== Efficiency ====
+ // TODO run can be different in a job?
+ fhistos->fhEventPerRun->Fill(fnumberEvents>0?log(fnumberEvents):1);
+ fFirstEvent = kFALSE;
+ }
+
+ // TODO
+ if( fExecLocal ) {
+ if(fevt % fieout == 0) cout << fevt << "\t" << int(float(fevt)/fnumberEvents*100) << "%" << endl ;
+ }
+
+ if( fFirstEvent ) {
+ //==== RunTable
+ fRunTable = & AliJRunTable::GetSpecialInstance();
+ fRunTable->SetRunNumber( frunHeader->GetRunNumber() );
+ fSQRTS = fRunTable->GetBeamEnergy(fRunTable->GetPeriod());
+ cout << "sqrts = "<< fSQRTS << ",runnumber = "<< frunHeader->GetRunNumber() << endl;
+ fEfficiency->SetRunNumber( frunHeader->GetRunNumber() );
+ TString effTag = fcard->GetStr("EfficiencyTag");
+
+ if( effTag.Length() > 0 ){
+ fEfficiency->SetTag( effTag );
+ }
+ fEfficiency->Load();
+ fFirstEvent = kFALSE;
+ }
+
+ if(fRunTable->IsHeavyIon()){
+ fCentMultLow->SetParameters( fcard->Get("CentMultCutLow",0), fcard->Get("CentMultCutLow",1), fcard->Get("CentMultCutLow",2) );
+ fCentMultHigh->SetParameters(fcard->Get("CentMultCutHigh",0), fcard->Get("CentMultCutHigh",1), fcard->Get("CentMultCutHigh",2) );
+ //fCentMultLow->Print();
+ //fCentMultHigh->Print();
+ }
+
+ fdmg->LoadEvent(fevt); // to be here to load EventHeader
+ fhistos->fhEvents->Fill( 0 );
+
+ if(!fdmg->IsGoodEvent()) return; // Vertex cut applied in IsGoodEvent and histo saved there too
+
+ feventHeader = fdmg->GetEventHeader();
+ double zVert = feventHeader->GetZVertex();
+ //----------------------------------------------------------
+
+ UInt_t triggermaskJCorran = feventHeader->GetTriggerMaskJCorran();
+ //cout << fevt <<"\t"<< zVert << "\t"<< triggermaskJCorran << endl;
+
+ if( fdmg->IsSelectedTrigger((int) triggermaskJCorran))
+ fhistos->fhEvents->Fill( 5 );
+
+ // select only some BC%4
+ if( feventHeader->GetBunchCrossNumber() % 4 != fEventBC &&
+ fEventBC > -1 )
+ return;
+
+ if( fdmg->IsSelectedTrigger((int) triggermaskJCorran))
+ fhistos->fhEvents->Fill( 6 );
+
+ if(fRunTable->IsHeavyIon() || fRunTable->IsPA()){
+ fcent = feventHeader->GetCentrality();
+ }else {
+ fcent = 1; //ntracks;
+ }
+
+ //cout<<"evt="<<fevt <<" c="<< fcent <<endl;
+ int cBin = fcard->GetBin(kCentrType, fcent);
+ if(cBin<0) return;
+
+ if( fdmg->IsSelectedTrigger((int) triggermaskJCorran))
+ fhistos->fhEvents->Fill( 7 );
+
+ int zBin = fcard->GetBin(kZVertType, zVert); //should be alway >0; checked in fdmg->IsGoodEvent()
+
+ // do not fill MB in case of MB mixing
+ if( fdmg->IsSelectedTrigger((int) triggermaskJCorran))
+ fhistos->fhZVert[cBin]->Fill(zVert);
+
+ //temporary fevent skip
+ //Trigger to be selected from the JCorran trigger mask is specified in the fCard
+ // if(! fdmg->IsSelectedTrigger((int) triggermaskJCorran))
+ // continue;
+
+ fEventCounter++;
+
+ //==== QA Event
+ fhistos->fhV0AMult[cBin]->Fill( feventHeader->GetV0AMult() );
+
+ //------------------------------------------------------------------
+ // Triggers and associated
+ //----------------------ooooo---------------------------------------
+
+ if(fjtrigg==kPizero || fjassoc==kPizero || fjtrigg==kPhoton || fjassoc==kPhoton){
+ } // pizero || photon
+ if(fjtrigg==kHadron || fjassoc==kHadron){
+ fchargedHadronList->Clear();
+ fdmg->RegisterList(fchargedHadronList, NULL, cBin, zBin, kHadron);
+ // apply efficiencies
+
+ for( int i = 0; i < fchargedHadronList->GetEntries(); i++ ){
+
+ AliJBaseTrack *triggTr = (AliJBaseTrack*)fchargedHadronList->At(i);
+ double ptt = triggTr->Pt();
+
+ double effCorr = 1./fEfficiency->GetCorrection(ptt, fHadronSelectionCut, fcent); // here you generate warning if ptt>30
+ fhistos->fhTrackingEfficiency[cBin]->Fill( ptt, 1./effCorr );
+ triggTr->SetTrackEff( 1./effCorr );
+ }
+ }
+
+ //---- assign input list ----
+ if(fjtrigg==kPizero) finputList = fpizeroList;
+ else if(fjtrigg==kHadron) finputList = fchargedHadronList;
+ else if(fjtrigg==kPhoton) finputList = fphotonList;
+ int noAllTriggTracks = finputList->GetEntries();
+ int noAllChargedTracks = fchargedHadronList->GetEntries();
+ fhistos->fhChargedMult[cBin]->Fill(noAllChargedTracks);
+ fhistos->fhChargedMultCent->Fill(fcent, noAllChargedTracks>0 ? log(noAllChargedTracks) : 0);
+
+ //---------------------------------------------
+ //-- Check fcentrality outliers ---
+ //-- and count enevents only here ---
+ //---------------------------------------------
+ if(fRunTable->IsHeavyIon() && fCentMultLow->GetParameter(0) >0 ){
+ double logMult = noAllChargedTracks>0 ? log(noAllChargedTracks) : 0 ;
+ if( fcent<fCentMultLow->GetParameter(1) && logMult <fCentMultLow->Eval(fcent) ) return;
+ if( fCentMultHigh->Eval(fcent) < logMult) return;
+ }
+ fhistos->fhChargedMultCut[cBin]->Fill(noAllChargedTracks);
+ fhistos->fhCentr->Fill(fcent);
+ fhistos->fhiCentr->Fill(cBin);
+
+ // ------------------------------
+ // --- calculate e-b-e vn
+ // ------------------------------
+ if(fRunTable->IsHeavyIon()){
+ double vdelta[2] = {0};
+ int vdeltaNorm = 0;
+ for(int it1=0; it1<noAllTriggTracks-1; it1++){
+ AliJBaseTrack *ftk1 = (AliJBaseTrack*)finputList->At(it1);
+ if(ftk1->Pt()<flowerPtAssocBoarder) continue;
+ for(int it2=it1+1; it2<noAllTriggTracks; it2++){
+ AliJBaseTrack *ftk2 = (AliJBaseTrack*)finputList->At(it2);
+ if(ftk2->Pt()<flowerPtAssocBoarder) continue;
+ if(fabs(ftk1->Eta() - ftk2->Eta())<1.0) continue;
+ double fdphi = ftk1->DeltaPhi(*ftk2);
+ fhistos->fhVN[cBin]->Fill(fdphi);
+ vdelta[0] += cos(2*fdphi);
+ vdelta[1] += cos(3*fdphi);
+ //cout<< ftk1->Pt() <<" "<< ftk2->Pt() <<" "<< fabs(ftk1->Eta() - ftk2->Eta()) <<" "<< 2*fdphi <<" "<< 3*fdphi <<endl;
+ vdeltaNorm++;
+ }
+ }
+ vdelta[0] = vdeltaNorm>0 ? vdelta[0]/vdeltaNorm : 0;
+ vdelta[1] = vdeltaNorm>0 ? vdelta[1]/vdeltaNorm : 0;
+ fhistos->fhVdelta2[cBin]->Fill(vdelta[0]*100);
+ fhistos->fhVdelta3[cBin]->Fill(vdelta[1]*100);
+ if(vdelta[0]>0) fhistos->fpV2->Fill( fcent, sqrt(vdelta[0])*100 );
+ if(vdelta[1]>0) {
+ fhistos->fpV3->Fill( fcent, sqrt(vdelta[1])*100 );
+ fcard->SetEventV3kv(vdelta[1]);
+ }
+ fhistos->fpVdeltaNorm->Fill( fcent, vdeltaNorm );
+ }
+
+ //----------------------------------------------------
+ //----- Generate trigg list and find LP --
+ //----- Fiducial cut should be used in AliJCorrelations--
+ //----------------------------------------------------
+ AliJTrackCounter *lpTrackCounter = new AliJTrackCounter(), *lpPairCounter = new AliJTrackCounter();
+ AliJBaseTrack *lPTr = NULL;
+ int noTriggs=0;
+ ftriggList->Clear();
+ for(int itrack=0; itrack<noAllTriggTracks; itrack++){
+ AliJBaseTrack *triggTr = (AliJBaseTrack*)finputList->At(itrack);
+ triggTr->SetTriggBin( fcard->GetBin(kTriggType, triggTr->Pt()) );
+
+ double ptt = triggTr->Pt();
+ double etat = triggTr->Eta();
+ //TODO iCut == 0;
+
+ double effCorr = 1.0/triggTr->GetTrackEff();
+
+ if( ptt>flowerPtAssocBoarder ){
+ //FK//double effCorr = 1./fcard->TrackEfficiency(ptt, fcent); // here you generate warning if ptt>30
+ //double effCorr = 1./fcard->TrackEfficiency(ptt, etat, cBin); // here you generate warning if ptt>30
+ fhistos->fhChargedPt[cBin]->Fill(ptt, effCorr );
+ fhistos->fhChargedPtNoCorr[cBin]->Fill( ptt );
+ fhistos->fhChargedEta->Fill(triggTr->Eta(), effCorr);
+ //fhistos->fhChargedPtJacek[cBin]->Fill(ptt, effCorr );
+ fhistos->fhChargedPtJacek[cBin]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); //One CANNOT do 1/ptt here!! First unfold.
+ if( -0.8<etat && etat<-0.2) fhistos->fhChargedPtJacekEta[cBin][0]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0);
+ if( -0.2<etat && etat< 0.3) fhistos->fhChargedPtJacekEta[cBin][1]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0);
+ if( 0.3<etat && etat< 0.8) fhistos->fhChargedPtJacekEta[cBin][2]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0);
+ fhistos->fhChargedPtFiete->Fill(ptt, effCorr );
+ }
+
+ if( !triggTr->IsInTriggerBin() ) continue;
+ //FK//triggTr->SetTrackEff( fcard->TrackEfficiency(triggTr->Pt(), fcent) );
+ int iptt = triggTr->GetTriggBin();
+ fhistos->fhIphiTrigg[cBin][iptt]->Fill( triggTr->Phi(), effCorr);
+ fhistos->fhIetaTrigg[cBin][iptt]->Fill( triggTr->Eta(), effCorr);
+
+ if( ptt > lpTrackCounter->Pt() ) {
+ lpTrackCounter->Store(noTriggs, ptt, iptt);
+ lPTr = triggTr;
+ }
+ //cout <<"1 ptt="<< triggTr->Pt() <<" bin="<< triggTr->GetTriggBin() << " st=" << triggTr->GetStatus() << " trigg eff=" << triggTr->GetTrackEff() << endl;
+ new ((*ftriggList)[noTriggs++]) AliJBaseTrack(*triggTr);
+ fhistos->fhTriggMult[cBin][iptt]->Fill(noAllTriggTracks);
+ }
+
+ //----------------------------------------------------
+ //----- Find sum of two leading particles ------------
+ //----------------------------------------------------
+ if(fbLPpairCorrel){
+ int noPairs=0;
+ fpairList->Clear();
+ fpairCounterList->Clear();
+ for(int ii=0;ii<noTriggs-1;ii++){
+ AliJBaseTrack *triggTr1 = (AliJBaseTrack*)ftriggList->At(ii);
+ for(int jj=ii+1;jj<noTriggs;jj++){
+ AliJBaseTrack *triggTr2 = (AliJBaseTrack*)ftriggList->At(jj);
+ TLorentzVector lVPair = triggTr1->GetLorentzVector()+triggTr2->GetLorentzVector();
+ double fdphi = DeltaPhi(triggTr1->Phi(), triggTr2->Phi());
+ new ((*fpairList)[noPairs]) AliJBaseTrack(lVPair);
+ new ((*fpairCounterList)[noPairs++])
+ AliJTrackCounter( triggTr1->GetID(), triggTr2->GetID(), ii, jj, fdphi );
+ }
+ }
+
+ // ----- Find the Leading Pair --------------------------
+ AliJBaseTrack *pairTr = NULL;
+ for(int ii=0;ii<noPairs;ii++){
+ pairTr = (AliJBaseTrack*)fpairList->At(ii);
+ AliJTrackCounter *pairCounter = (AliJTrackCounter*)fpairCounterList->At(ii);
+ //cout<<pairTr->Pt()<<endl; pairCounter->Print();
+ if(pairTr->Pt() > lpPairCounter->Pt() && fabs(pairCounter->GetPairDPhi())<1.0) {
+ int iptt = fcard->GetBin(kTriggType, pairTr->Pt());
+ lpPairCounter = pairCounter;
+ lpPairCounter->Store(ii, pairTr->Pt(), iptt);
+ }
+ }
+ if(lpPairCounter->Exists()){
+ pairTr->SetParticleType(kHadron);
+ //double effCorr = 1./fcard->TrackEfficiency(lpTrackCounter->GetLPpt());
+ fhistos->fhLPpairPt->Fill(pairTr->Pt());
+ }
+ }
+
+ //--------------------------------------------------
+ //--- Generate assoc list and pool ---
+ //--------------------------------------------------
+ fassocList->Clear();
+ int noAssocs=0;
+ double sumPtAroundLP = 0;
+ if(fjassoc==kPizero) finputList = fpizeroList;
+ else if(fjassoc==kHadron) finputList = fchargedHadronList;
+ else if(fjassoc==kPhoton) finputList = fphotonList;
+
+ int noAllAssocTracks = finputList->GetEntries();
+
+
+ for(int itrack=0;itrack<noAllAssocTracks; itrack++){
+
+ AliJBaseTrack *assocTr = (AliJBaseTrack*)finputList->At(itrack);
+ assocTr->SetAssocBin( fcard->GetBin(kAssocType, assocTr->Pt()) );
+
+ if(assocTr->IsInAssocBin()){
+
+ int ipta = assocTr->GetAssocBin();
+ double effCorr = 1.0/assocTr->GetTrackEff();
+ fhistos->fhIphiAssoc[cBin][ipta]->Fill( assocTr->Phi(), effCorr);
+ fhistos->fhIetaAssoc[cBin][ipta]->Fill( assocTr->Eta(), effCorr);
+ new ((*fassocList)[noAssocs++]) AliJBaseTrack(*assocTr);
+ }
+ // determine an activity in the cone around trigger
+ if(lpTrackCounter->Exists() && (lPTr->GetID()!=assocTr->GetID()) && (0.5 < assocTr->Pt())){
+ double dPhi = DeltaPhi( assocTr->Phi(), lPTr->Phi() );
+ double dEta = assocTr->Eta() - lPTr->Eta();
+ if(fIsolationR > sqrt(dPhi*dPhi+dEta*dEta)) sumPtAroundLP += assocTr->Pt();//FK//
+ }
+ }
+
+ FillXtHistos(finputList, lpTrackCounter);
+
+ //-----------------------------------------------
+ // Set the isolation flag
+ //-----------------------------------------------
+ if( lpTrackCounter->Exists() ){
+ //double effCorr = 1./fcard->TrackEfficiency(lpTrackCounter->Pt(), fcent);
+ //TODO ??? AGAIN AGAIN???
+ double effCorr = 1./fEfficiency->GetCorrection(lpTrackCounter->Pt(), fHadronSelectionCut, fcent );
+ fhistos->fhLPpt->Fill(lpTrackCounter->Pt(), effCorr);
+ fhistos->fhLPeta->Fill(lPTr->Eta(), effCorr);
+ fhistos->fhBkgActivity[lpTrackCounter->GetPtBin()]->Fill(sumPtAroundLP/lpTrackCounter->Pt());
+
+ if( sumPtAroundLP/lpTrackCounter->Pt()< fcard->GetCutOnBkgActivity() && ///relative activity
+ ( fabs(lPTr->Eta()) < (fTrackEtaRange - fIsolationR) ) ){ //fiducial cut
+
+ fhistos->fhIsolatedLPpt->Fill(lpTrackCounter->Pt(), effCorr );
+
+ AliJBaseTrack* lpTrigger = (AliJBaseTrack*) ftriggList->At(lpTrackCounter->GetIndex());
+ lpTrigger->SetIsIsolated(1);
+ }
+ }
+
+ fhistos->fhAssocMult->Fill(noAssocs);
+ //cout<"Triggs = "<<<noTriggs<<" Assoc = "<<noAssocs<<" all = "<<noAllTracks<<endl;
+
+ //============================================================
+ //there is obviously a problem when you do "fixed" correlation.
+ //In this case the noTriggs==0 condition is never fullfilled
+ //============================================================
+ //if(noTriggs==0 || ((fjtrigg==kPizero) && (fjassoc==kPizero)) )
+ //if(leadingPt<1.5) //should be fixed
+ //if(noTriggs==0 && noAssocs>0 ){}
+ if(noAssocs>0 ) fassocPool->AcceptList(fassocList, fcent, zVert, noAllChargedTracks, fevt);
+
+ //------------------------------------------------------------------
+ // Do the Correlation
+ //----------------------ooooo---------------------------------------
+ int noTriggTracs=-1;
+ noTriggTracs = fbTriggCorrel ? noTriggs : 1;
+ if(fbLPCorrel && !lpTrackCounter->Exists()) return;
+ if(fbLPpairCorrel && !lpPairCounter->Exists()) return;
+ AliJBaseTrack *triggTr = NULL;
+
+ for(int ii=0;ii<noTriggTracs;ii++){ // trigger loop
+ if (fbTriggCorrel) triggTr = (AliJBaseTrack*)ftriggList->At(ii);
+ if (fbLPCorrel) triggTr = (AliJBaseTrack*)ftriggList->At(lpTrackCounter->GetIndex());
+ if (fbLPpairCorrel) triggTr = (AliJBaseTrack*)fpairList->At(lpPairCounter->GetIndex());
+ //for(int ii=0;ii<noIsolPizero;ii++){ // trigger loop }
+ //AliJBaseTrack *triggTr = (AliJBaseTrack*)isolPizeroList->At(ii);
+ double ptt = triggTr->Pt();
+ int iptt = triggTr->GetTriggBin();
+ if(iptt<0) {
+ cout<<"Not registered trigger ! I better stop here." <<endl;
+ exit(-1);
+ }
+ double effCorr = 1.0/triggTr->GetTrackEff();
+ fhistos->fhTriggPtBin[cBin][zBin][iptt]->Fill(ptt, effCorr);//inclusive
+
+ if(triggTr->GetIsIsolated()>0) fhistos->fhTriggPtBinIsolTrigg[kReal][cBin][iptt]->Fill(ptt, effCorr);
+
+ for(int jj=0;jj<noAssocs;jj++){ // assoc loop
+ AliJBaseTrack *assocTr = (AliJBaseTrack*)fassocList->At(jj);
+ //assocTr->PrintOut("assoc track");
+ if(fbLPpairCorrel &&
+ (assocTr->GetID()==lpPairCounter->GetPairTrackID(0) ||
+ assocTr->GetID()==lpPairCounter->GetPairTrackID(1)) ) continue;
+ //-------------------------------------------------------------
+ fcorrelations->FillAzimuthHistos(kReal, cBin, zBin, triggTr, assocTr);
+ //-------------------------------------------------------------
+ } // end assoc loop
+ } // end trigg loop
+ // == mix trigg with assoc
+ if (fbLPpairCorrel)
+ fassocPool->Mix(fpairList, kAzimuthFill, fcent, zVert, noAllChargedTracks, fevt);
+ else
+ fassocPool->Mix(ftriggList, kAzimuthFill, fcent, zVert, noAllChargedTracks, fevt);
+
+ //--------------------------------------------------------------
+ // End of the Correlation
+ //--------------------------------------------------------------
+
+
+
+}
+
+void AliJCORRAN::Terminate() {
+ // termination
+
+ /* TODO
+ for (int hic = 0;hic < fcard->GetNoOfBins(kCentrType);hic++){
+ ScaleNotEquidistantHisto( fhistos->fhChargedPt[hic], 1);
+ ScaleNotEquidistantHisto( fhistos->fhChargedPtNoCorr[hic], 1);
+ ScaleNotEquidistantHisto( fhistos->fhChargedPtJacek[hic], 1);
+ }
+ ScaleNotEquidistantHisto( fhistos->fhLPpt, 1);
+ ScaleNotEquidistantHisto( fhistos->fhLPpairPt, 1);
+ ScaleNotEquidistantHisto( fhistos->fhIsolatedLPpt, 1);
+ ScaleNotEquidistantHisto( fhistos->fhChargedPtFiete, 1);
+ */
+
+ // cout<<"MB's="<<noMB<<" "<<" ERT's="<<noERT<<endl;
+ fcorrelations->PrintOut();
+ fassocPool->PrintOut();
+ fEfficiency->Write();
+ fhistos->fHMG->Print();
+ //fhistos->fHMG->Write();
+}
+
+particleType AliJCORRAN::GetParticleType(char *inchar){
+ // part type
+ for(int i=0;i<kNumberOfParticleTypes;i++) {
+ //cout<<"<"<<inchar<<"> <"<<particleTypeStr[i]<<"> "<<strcmp(inchar,particleTypeStr[i])<<" "<<(particleType)i<<endl;
+ if(strcmp(inchar,kParticleTypeStrName[i])==0) return (particleType)i;
+ }
+ std::cout<<"Particle type <"<<inchar<<"> not recognized"<<std::endl;
+ exit(1);
+}
+
+double AliJCORRAN::DeltaPhi(double phi1, double phi2) {
+ // dphi
+ double res = atan2(sin(phi1-phi2), cos(phi1-phi2));
+ //return res>-kJPi/3.0 ? res : kJTwoPi+res ;
+ return res>-kJPi*9./20. ? res : kJTwoPi+res ;
+}
+
+void AliJCORRAN::ScaleNotEquidistantHisto(TH1D *hid, const double sc=1){
+ // histo scaler
+ for(int i=1;i<= hid->GetNbinsX();i++){
+ hid->SetBinContent(i,hid->GetBinContent(i)*sc/hid->GetBinWidth(i));
+ hid->SetBinError(i,hid->GetBinError(i)*sc/hid->GetBinWidth(i));
+ }
+}
+
+// Fill xT histograms (Esko)
+void AliJCORRAN::FillXtHistos(TClonesArray *inputList, AliJTrackCounter *lpTrackCounter){
+ // Here should be a comment describing this method
+ JUNUSED(lpTrackCounter);
+
+ enum xTtype { kInclusive=0, kIsolated=1, kIsolatedLP=2} ;
+ double lowerPtCut = 0.2;
+ double isolationR = 0.4;
+ double fCutOnBkgActivity = 0.10;
+ int cBin = fcard->GetBin(kCentrType, fcent);
+ double sqrts = fSQRTS;
+ int noAllTriggTracks = inputList->GetEntries();
+ //cout << "Entering Esko's analysis loop" << endl;
+ //cout << "Sqrts = " << sqrts << " pT = " << ptt << " xT = " << xtt << endl;
+ for(int itrack=0; itrack<noAllTriggTracks; itrack++){
+ AliJBaseTrack *triggTr = (AliJBaseTrack*)inputList->At(itrack);
+ double sumPtAroundTrigger = 0;
+ double ptt = triggTr->Pt();
+ double xtt = 2.0 * ptt / (1.0 * sqrts);
+ double effCorr = 1.0/triggTr->GetTrackEff();
+ fhistos->fhPtForXt[kInclusive][cBin]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0);
+ fhistos->fhXt[kInclusive][cBin]->Fill(xtt, effCorr );
+ fhistos->fhXtWeighted[kInclusive][cBin]->Fill(xtt, effCorr*1.0/xtt );
+
+ for(int jj=0;jj<inputList->GetEntriesFast();jj++){ // assoc loop
+ AliJBaseTrack *assocTr = (AliJBaseTrack*)inputList->At(jj);
+ if(triggTr->GetID()==assocTr->GetID()) continue;
+ double pta = assocTr->Pt();
+ // determine the activity in the cone around trigger (Esko)
+ if( lowerPtCut < pta ){
+ double dPhi = DeltaPhi( assocTr->Phi(), triggTr->Phi() );
+ double dEta = assocTr->Eta() - triggTr->Eta();
+ if(isolationR > sqrt(dPhi*dPhi+dEta*dEta)) sumPtAroundTrigger += assocTr->Pt();//FK//
+ }
+ //cout << " Assoc number " << assocCounter++ << endl;
+ }
+ // If pT sum is below the limit, fill to the isolated histos
+ if( sumPtAroundTrigger/ptt < fCutOnBkgActivity && ///relative activity
+ ( fabs(triggTr->Eta()) < (fTrackEtaRange - isolationR) ) ){ //fiducial cut
+ // pT and xT
+ // kInclusive kIsolated, kLPIsolated
+ fhistos->fhPtForXt[kIsolated][cBin]->Fill(ptt,effCorr*1.0/ptt);
+ fhistos->fhXt[kIsolated][cBin]->Fill(xtt, effCorr );
+ fhistos->fhXtWeighted[kIsolated][cBin]->Fill(xtt,effCorr*1.0/xtt);
+ }
+ //cout<<"pT sum around trigger = " << sumPtAroundTrigger << endl;
+ }
+
+} // end FillXtHistos
--- /dev/null
+/* 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!
+
+#ifndef ALIJCORRAN_H
+#define ALIJCORRAN_H
+
+#include <AliJDataManager.h>
+#include <AliJConst.h>
+#include <TH1D.h>
+
+// jcorran main class
+// used in local and grid execution
+// blah
+
+class AliJCard;
+class AliJHistos;
+class AliJCorrelations;
+class AliJEventHeader;
+class AliJEventPool;
+class AliJHistos;
+class AliJRunHeader;
+class AliJEfficiency;
+class AliJTrackCounter;
+
+class TClonesArray;
+class TF1;
+class AliJRunTable;
+class TRandom3;
+
+class AliJCORRAN : public TObject
+{
+ public:
+ AliJCORRAN();
+ AliJCORRAN(Bool_t execLocal);
+ virtual ~AliJCORRAN();
+ AliJCORRAN(const AliJCORRAN& obj);
+ AliJCORRAN& operator=(const AliJCORRAN& obj);
+
+ void Initialize() const;
+ void Init(){ Initialize(); }
+ void UserCreateOutputObjects();
+ void UserExec();
+ void Terminate();
+
+ Int_t GetNumberEvents() const { return fnumberEvents; }
+ AliJHistos *GetHistos() { return fhistos; }
+ AliJCorrelations *GetCorrelations() { return fcorrelations; }
+ AliJEventPool *GetAssocPool() { return fassocPool; }
+ Int_t GetEventCounter() const { return fEventCounter; }
+ AliJCard *GetCard() { return fcard; }
+
+ void FillXtHistos(TClonesArray *inputList, AliJTrackCounter *lpTrackCounter); // Esko
+
+ void SetCard( AliJCard *c ) { fcard = c; }
+ void SetTrigger( char* p ) { fjtrigg = GetParticleType(p); }
+ void SetAssoc( char* p ) { fjassoc = GetParticleType(p); }
+ void SetInclusiveFile( const char *f ){ fInclusiveFile = f; }
+ void SetInputFile( char *f ) { finputFile = f; }
+ void SetNumberEvents( Int_t n ) { fnumberEvents = n; }
+
+ void SetTrackList( TClonesArray *a ) { fdmg->SetTrackList( a ); }
+ void SetPhotonList( TClonesArray *a ) { fdmg->SetPhotonList( a ); }
+ void SetCaloCellList( TClonesArray *a ) { fdmg->SetCaloCellList( a ); }
+ void SetMCTrackList( TClonesArray *a ) { fdmg->SetMCTrackList( a ); }
+ void SetHeaderList( TClonesArray *a ) { fdmg->SetHeaderList( a ); }
+ void SetRunHeader( AliJRunHeader *a ) { frunHeader = a; }
+ void SetRunInfoList( TList *a ) { fdmg->SetRunInfoList( a ); }
+ void SetESDVZERO( TObject *a ) { fdmg->SetESDVZERO( a ); }
+
+ // void SetESDTZERO( AliESDTZERO *a ) { fdmg->SetESDTZERO( a ); }
+ // void SetESDZDC( AliESDZDC *a ) { fdmg->SetESDZDC( a ); }
+
+
+ double DeltaPhi(double phi1, double phi2);
+ particleType GetParticleType(char *inchar);
+ void ScaleNotEquidistantHisto(TH1D *hid, const double sc);
+
+ private:
+
+ Bool_t fExecLocal; // exec mode
+ Bool_t fFirstEvent; //!
+
+ particleType fjtrigg; // assoc
+ particleType fjassoc; // trigger
+
+ AliJCard *fcard; // card
+ char * finputFile; //!
+ TString fInclusiveFile; // File for inclusive distributions
+
+ Int_t fevt; // event number
+ AliJHistos *fhistos; //!
+ AliJCorrelations *fcorrelations; //!
+ AliJEventPool *fphotonPool; //!
+ AliJEventPool *fassocPool; //!
+ TClonesArray *fphotonList; //!
+ TClonesArray *fchargedHadronList; //!
+ TClonesArray *fpizeroList; //!
+ TClonesArray *ftriggList; //!
+ TClonesArray *fassocList; //!
+ TClonesArray *fpairList; //!
+ TClonesArray *fpairCounterList; //!
+ TClonesArray *finputList; //!
+
+ AliJDataManager* fdmg; //!
+ AliJEventHeader *feventHeader; //!
+ AliJRunHeader* frunHeader; //!
+
+ int fnumberEvents; //!
+ int fieout; //!
+ int fEventCounter; //!
+ double fcent; //!
+ Int_t fncBin; //!
+ Int_t fnPttBin; //!
+ bool fbTriggCorrel; //!
+ bool fbLPCorrel; //!
+ bool fbLPpairCorrel; //!
+ double fTrackEtaRange; //!
+ double flowerPtAssocBoarder; //!
+
+ TF1 *fCentMultLow; //!
+ TF1 *fCentMultHigh; //!
+
+
+
+ Int_t fEventBC; //!
+ Float_t fSQRTS; // todo
+
+ AliJEfficiency *fEfficiency; // comment me
+ AliJRunTable *fRunTable; // comment needed
+ float fIsolationR; // comment1
+ int fHadronSelectionCut; /// comment2
+
+ ClassDef(AliJCORRAN, 1); // EMCAL for jcorran
+
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
// Adapted for AliAnalysisTaskSE and AOD objects
//////////////////////////////////////////////////////////////////////////////
+#include "TChain.h"
+#include "TList.h"
+#include "TTree.h"
+#include "TFile.h"
-#include <Riostream.h>
-#include <TChain.h>
-#include <TVectorT.h>
-#include <TVector3.h>
-#include <TFile.h>
-#include <TH1.h>
-#include <TClonesArray.h>
-#include <TObjArray.h>
-#include <TObjString.h>
-#include <TFormula.h>
-#include <TString.h>
-#include <TRefArray.h>
-#include <TNtuple.h>
#include "AliAnalysisTaskSE.h"
#include "AliAODHandler.h"
#include "AliJCORRANTask.h"
#include "AliAnalysisManager.h"
-#include "AliESDEvent.h"
-#include "AliMCEvent.h"
-#include "AliStack.h"
-#include "AliGenEventHeader.h"
-#include "AliGenCocktailEventHeader.h"
-#include "AliGenPythiaEventHeader.h"
-#include "AliInputEventHandler.h"
-#include "AliESDCaloCluster.h"
-#include "AliAODEvent.h"
-#include "AliAODHeader.h"
-#include "AliLog.h"
-#include "AliESDVertex.h"
-#include "AliESDtrack.h"
-#include "AliAODTrack.h"
-#include "AliAnalysisFilter.h"
-#include "AliESDtrackCuts.h"
-#include "AliAODVertex.h"
-#include "AliAODTracklets.h"
-#include "AliAODPid.h"
-#include "AliESDUtils.h"
-//#include "AliESDVZERO.h"
-#include "AliCentrality.h"
-#include "AliAODTracklets.h"
-#include "AliMultiplicity.h"
-#include "AliJConst.h"
-#include "AliESDRun.h"
-#include "AliESDVZERO.h"
-#include "AliExternalTrackParam.h"
-//== EMCAL
-#include "AliESDCaloCluster.h"
-#include "AliEMCALGeometry.h"
-#include "AliVCluster.h"
-#include "AliVCaloCells.h"
-#include "AliEMCALRecoUtils.h"
-#include "AliEMCALPIDUtils.h"
#include "AliJTrack.h"
#include "AliJMCTrack.h"
#include "AliJPhoton.h"
+//#include "AliJCaloCell.h"
#include "AliJEventHeader.h"
#include "AliJRunHeader.h"
//______________________________________________________________________________
AliJCORRANTask::AliJCORRANTask() :
AliAnalysisTaskSE("PWG4JCORRAN"),
- fRunType("LHC10h"), // enable filling EP info
- fInputFormat("ESD"),
- fEsdTrackCuts(0x0),
- fESDFilter(0x0),
- fIsRealOrMC(),
+ fFilter(0x0),
fAODName("jcorran.root"),
- fStoreEventPlaneSource(false),
- fStoreTPCTrack(false),
- fOADBPath(),
- fTrackList(0),
- fMCTrackList(0x0),
- fPhotonList(0x0),
- fHeaderList(0x0),
- fRunInfoList(0x0),
- fPIDesd(0x0),
- fPIDResponse(0x0),
- fPIDCombined(0x0),
- fVZEROData(0x0),
- fTZEROData(0x0),
- //fFMDData(0x0),
- fZDCData(0x0),
- fAliRunHeader(0x0),
- fEMCALGeoUtils(0x0),
- fPHOSGeom(0x0)
-{
- //Default constructor
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableAlice;i++) fActiveTriggers[i]=" ";
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableJCorran;i++) fTriggerTableJCorran[i]=" ";
+ fJODTree(0x0),
+ fAliJRunHeader(0x0),
+ fDoStoreJOD(kFALSE)
- fIsRealOrMC.ResizeTo(1);
- fIsRealOrMC[0]=0;
+{
DefineInput (0, TChain::Class());
- DefineInput (1, TList::Class());
- DefineOutput (1, TList::Class());
- // DefineOutput (2, TList::Class());
+ DefineOutput (1, TTree::Class());
+ DefineOutput (2, TList::Class());
+
+ fFilter = new AliJFilter();
}
//______________________________________________________________________________
AliJCORRANTask::AliJCORRANTask(const char *name, TString inputformat):
AliAnalysisTaskSE(name),
- fRunType("LHC10h"), // enable filling EP info
- fInputFormat(inputformat),
- fEsdTrackCuts(0x0),
- fESDFilter(0x0),
- fIsRealOrMC(),
+ fFilter(0x0),
fAODName("jcorran.root"),
- fStoreEventPlaneSource(false),
- fStoreTPCTrack(false),
- fOADBPath(),
- fTrackList(0),
- fMCTrackList(0x0),
- fPhotonList(0x0),
- fHeaderList(0x0),
- fRunInfoList(0x0),
- fPIDesd(0x0),
- fPIDResponse(0x0),
- fPIDCombined(0x0),
- fVZEROData(0x0),
- fTZEROData(0x0),
- //fFMDData(0x0),
- fZDCData(0x0),
- fAliRunHeader(0x0),
- fEMCALGeoUtils(0x0),
- fPHOSGeom(0x0)
+ fJODTree(0x0),
+ fAliJRunHeader(0x0),
+ fDoStoreJOD(kFALSE)
{
// Constructor
- if(fDebug > 5) cout << "---- AliJCORRANTask Constructor ----"<<endl;
-
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableAlice;i++) fActiveTriggers[i]=" ";
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableJCorran;i++) fTriggerTableJCorran[i]=" ";
-
- fIsRealOrMC.ResizeTo(1);
+ AliInfo("---- AliJCORRANTask Constructor ----");
- fIsRealOrMC[0]=0;
+ JUNUSED(inputformat);
DefineInput (0, TChain::Class());
- // DefineInput (1, TList::Class());
- DefineOutput (1, TList::Class());
- // DefineOutput (2, TList::Class());
+ DefineOutput (1, TTree::Class());
+ DefineOutput (2, TList::Class());
+
+ fFilter = new AliJFilter( Form("%sFilter",name), this );
}
//____________________________________________________________________________
AliJCORRANTask::AliJCORRANTask(const AliJCORRANTask& ap) :
AliAnalysisTaskSE(ap.GetName()),
- fRunType(ap.fRunType),
- fInputFormat(ap.fInputFormat),
- fEsdTrackCuts(ap.fEsdTrackCuts),
- fESDFilter(ap.fESDFilter),
- fIsRealOrMC(ap.fIsRealOrMC),
- fAODName(ap.fAODName),
- fStoreEventPlaneSource(ap.fStoreEventPlaneSource),
- fStoreTPCTrack(ap.fStoreTPCTrack),
- fOADBPath(ap.fOADBPath),
- fTrackList(ap.fTrackList),
- fMCTrackList(ap.fMCTrackList),
- fPhotonList(ap.fPhotonList),
- fHeaderList(ap.fHeaderList),
- fRunInfoList(ap.fRunInfoList),
- fPIDesd(ap.fPIDesd),
- fPIDResponse(ap.fPIDResponse),
- fPIDCombined(ap.fPIDCombined),
- fVZEROData(ap.fVZEROData),
- fTZEROData(ap.fTZEROData),
- //fFMDData(ap.fFMDData),
- fZDCData(ap.fZDCData),
- fAliRunHeader(ap.fAliRunHeader),
- fEMCALGeoUtils(ap.fEMCALGeoUtils),
- fPHOSGeom(ap.fPHOSGeom)
+ fFilter(ap.fFilter),
+ fAODName(ap.fAODName),
+ fJODTree(ap.fJODTree),
+ fAliJRunHeader(ap.fAliJRunHeader),
+ fDoStoreJOD(ap.fDoStoreJOD)
{
- // cpy ctor
- for(int k=0; k < AliJConst::kRangeTriggerTableAlice; k++)
- fActiveTriggers[k] = ap.fActiveTriggers[k];
-
- for(int j=0; j < AliJConst::kRangeTriggerTableJCorran; j++)
- fTriggerTableJCorran[j] = ap.fTriggerTableJCorran[j];
-
- fIsRealOrMC.ResizeTo(1);
- fIsRealOrMC[0] = ap.fIsRealOrMC[0];
+ AliInfo("----DEBUG AliJCORRANTask COPY ----");
}
{
// assignment operator
+ AliInfo("----DEBUG AliJCORRANTask operator= ----");
this->~AliJCORRANTask();
new(this) AliJCORRANTask(ap);
return *this;
AliJCORRANTask::~AliJCORRANTask()
{
// destructor
- delete fTrackList;
- delete fMCTrackList;
- delete fPhotonList;
- delete fHeaderList;
- delete fAliRunHeader;
- delete fRunInfoList;
- delete fPIDesd;
- delete fOADBPath;
- delete fPIDResponse;
- delete fPIDCombined;
- delete fEMCALGeoUtils;
- delete fPHOSGeom;
- delete fVZEROData;
- delete fTZEROData;
- delete fZDCData;
- // delete fFMDData;
+ delete fFilter;
+ delete fJODTree;
+ delete fAliJRunHeader;
}
{
//=== create the jcorran outputs objects
if(fDebug > 1) printf("AliJCORRANTask::UserCreateOutPutData() \n");
-
+
//=== Get AnalysisManager
AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
if(!man->GetOutputEventHandler()) {
Fatal("UserCreateOutputObjects", "This task needs an AOD handler");
return;
}
- man->RegisterExtraFile(fAODName.Data());
-
- //=== Other Objects
- fEMCALGeoUtils = AliEMCALGeometry::GetInstance("EMCAL_COMPLETE");
- fPHOSGeom = new AliPHOSGeoUtils();
-
- //=== Set Tree and TClonesArray
- //== TRACKS
- AddListAODBranch("AliJTrackList", "AliJTrack", &fTrackList, 1000);
- AddListAODBranch("AliJPhotonList", "AliJPhoton", &fPhotonList, 1000);
- if((bool)fIsRealOrMC[0])
- AddListAODBranch("AliJTMCrackList", "AliJMCTrack", &fMCTrackList, 1000);
- //== Event Header
- AddListAODBranch("AliJEventHeaderList", "AliJEventHeader", &fHeaderList, 1000);
- //== RUN HEADER
- fAliRunHeader = new AliJRunHeader();
- fRunInfoList = new TList();
- fRunInfoList->SetName("RunInfoList");
- fRunInfoList->SetOwner();
- fRunInfoList->Clear();
- fRunInfoList->Add(fAliRunHeader);
- //== EventPlane SRC
- if( fStoreEventPlaneSource ){
- fVZEROData = new AliESDVZERO;
- fTZEROData = new AliESDTZERO;
- fZDCData = new AliESDZDC;
- AddAODBranch("AliESDVZERO", &fVZEROData, fAODName.Data());
- AddAODBranch("AliESDTZERO", &fTZEROData, fAODName.Data());
- AddAODBranch("AliESDZDC", &fZDCData, fAODName.Data());
- }
- //== PID
- fPIDesd = new AliESDpid;
- fPIDCombined = new AliPIDCombined;
- fPIDCombined->SetDefaultTPCPriors();
- fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF);
- fPIDResponse = ((AliInputEventHandler*) (man->GetInputEventHandler()))->GetPIDResponse();
- fPIDResponse->SetOADBPath(AliAnalysisManager::GetOADBPath());
- if (!fOADBPath.IsNull()) fPIDResponse->SetOADBPath(fOADBPath.Data());
-
- cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl;
- PostData(1,fRunInfoList);
-
-}
-//______________________________________________________________________________
-void AliJCORRANTask::UserExec(Option_t* /*option*/)
-{
+ // run the filter class
+ fFilter->SetMyTask( this );
+ fFilter->SetAliJRunHeader( fAliJRunHeader );
+ fFilter->UserCreateOutputObjects();
- // Processing of one event
- if(fDebug > 5) cout << "------- AliJCORRANTask Exec-------"<<endl;
- if(!((Entry()-1)%100)) AliInfo(Form(" Processing event # %lld", Entry()));
-
- //=== Init Variables
- fTrackList->Clear();
- if((bool)fIsRealOrMC[0]) fMCTrackList->Clear();
- fPhotonList->Clear();
- fHeaderList->Clear();
-
- //=== COMMON for ESD and AOD
- static int runId=-1;
- AliVEvent *event = InputEvent();
- if(!event) return;
- AliMCEvent* mcEvent = NULL;
- if((bool)fIsRealOrMC[0]) mcEvent = MCEvent();
- // RUN Header
- if(event->GetRunNumber() != runId){ //new run has started
- runId = event->GetRunNumber();
- //Polarity of magnetic field in L3 solenoid
- Short_t l3MgFieldPolarity=0; // (LHC convention: +current -> +Bz)
- //Create internal JCorran trigger mask. Mapping between trigger and trigger bit
- fTriggerTableJCorran[AliJConst::kMinBiasTriggerBitJCorran]="Minimum Bias";//minimum bias occupies first trigger bit
- fTriggerTableJCorran[AliJConst::kHighMultTriggerBitJCorran]="High Multiplicity";//high multiplicity trigger => second trigger bit
- //=========== Fill Run header object ===============
- fAliRunHeader->SetRunNumber(runId);
- fAliRunHeader->SetActiveTriggersJCorran(fTriggerTableJCorran,AliJConst::kRangeTriggerTableJCorran);
- SetAliceTriggerDef(fAliRunHeader);//TODO for AOD
- SetAliceFilterMapDef(fAliRunHeader);// TODO for AOD
- //FOR ESD
- if(fInputFormat=="ESD"){
- AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
- if(!esd) return;
- if(esd->GetCurrentL3() >0) l3MgFieldPolarity = 1;
- if(esd->GetCurrentL3() <0) l3MgFieldPolarity = -1;
- fAliRunHeader->SetL3Field(l3MgFieldPolarity, esd->GetMagneticField());
- const AliESDRun* esdRun = esd->GetESDRun();
- for(Int_t triggerBit=0; triggerBit<AliJConst::kRangeTriggerTableAlice; triggerBit++){
- fActiveTriggers[triggerBit] = esdRun->GetTriggerClass(triggerBit);
- }
- fAliRunHeader->SetActiveTriggersAlice(fActiveTriggers);
- }
- fRunInfoList->Add(fAliRunHeader);
- cout << "Add(fAliRunHeader) is done =============" << endl;
- }
+ // register ouput branches
- //=== If ESD or AOD
- if(fInputFormat=="ESD"){ //Reading ESD
- if(fDebug > 5) cout << "\t------- Start ESD "<<endl;
- AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
- if(!esd) return;
- ReadESDHeader(esd);
- ReadESDTracks(esd);
- //ReadESDCaloClusters(esd);
- if((bool)fIsRealOrMC[0]) ReadMCTracks(mcEvent);
- }else if( fInputFormat == "AOD") {
- if(fDebug > 5) cout << "\t------- Start AOD "<<endl;
- AliAODEvent* aod = dynamic_cast<AliAODEvent*>(event);
- if(!aod) return;
- ReadAODHeader(aod);
- ReadAODTracks(aod);
- //ReadAODCaloClusters(aod);
- }else{
- cout << "Error: Not correct InputDataFormat especified " << endl;
- return;
+ if(fDoStoreJOD){
+ TFile * file1 = OpenFile(1);
+ file1-> SetCompressionLevel(9);
+ TTree * tree = new TTree("JODTree","JYFL Object Data");
+ int split = 2;
+ int basketsize = 32000;
+ tree->Branch("TrackList", fFilter->GetTrackList(),basketsize, split);
+ if( fFilter->IsMC() )
+ tree->Branch("MCTrackList", fFilter->GetMCTrackList(),basketsize, split );
+ //== Event Header
+ tree->Branch("HeaderList", fFilter->GetHeaderList(),basketsize, split );
+ //== EventPlane SRC
+ if( fFilter->GetStoreEventPlaneSource() ){
+ tree->Branch("AliESDVZERO", fFilter->GetESDVZERO());
+ tree->Branch("AliESDTZERO", fFilter->GetESDTZERO());
+ tree->Branch("AliESDZDC", fFilter->GetESDZDC());
+ }
+ fJODTree = tree;
}
- //=== TODO : need this?
- AliAODHandler* outputHandler =
- (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
- outputHandler->SetFillAOD(kTRUE);
- outputHandler->SetFillExtension(kTRUE);
- PostData(1,fRunInfoList);
-
- if(fDebug > 5) cout << "\t------- End UserExec "<<endl;
-}
+ PostData( 1, fJODTree );
+ //OpenFile(2);
+ PostData( 2,fFilter->GetRunInfoList());
-//______________________________________________________________________________
-void AliJCORRANTask::Init()
-{
- // Intialisation of parameters
- AliInfo("Doing initialization") ;
-
- TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep());
- if(formula.Length()>0){ // momentum dep DCA cut for AOD
- formula.ReplaceAll("pt","x");
- }
-}
-//______________________________________________________________________________
-void AliJCORRANTask::Terminate(Option_t *)
-{
- // Processing when the event loop is ended
- cout<<"PWG4JCORRAN Analysis DONE !!"<<endl;
- // Printout fRunInfoList here
- fRunInfoList = dynamic_cast<TList*> (GetOutputData(1));
- if(fRunInfoList)
- {
- fAliRunHeader = dynamic_cast<AliJRunHeader*> (fRunInfoList->FindObject("AliJRunHeader"));
- if(fAliRunHeader) {fAliRunHeader->Print();}
- }
- else
- {
- cout << "WARNING : Run Information List is empty" << endl;
- }
+ cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl;
}
//______________________________________________________________________________
-void AliJCORRANTask::ReadESDTracks(AliESDEvent * esd)
- //void AliJCORRANTask::ReadESDTracks(const AliESDEvent * esd)
+void AliJCORRANTask::UserExec(Option_t* /*option*/)
{
- // Read the AliESDtrack and fill the list of AliJTrack containers
- Int_t nt = esd->GetNumberOfTracks();
- if(fDebug > 5) cout << "ESD::NumberOfTracks = " << nt << endl;
- Short_t ntrk = 0;
-
- //loop over tracks
- for(Int_t it = 0; it < nt; it++) {
-
- AliESDtrack *track = esd->GetTrack(it);
- if( !track ) continue;
- if(! fEsdTrackCuts->IsSelected(track)) continue; // apply track selection criteria
- UInt_t filterMap = fESDFilter->IsSelected( track );
- //------------ T P C ------------
- Float_t tpcDca[2], tpcCov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
- track->GetImpactParametersTPC(tpcDca,tpcCov);
-
- Int_t nClust = track->GetTPCclusters(0);
- Int_t nFindableClust = track->GetTPCNclsF();
- Float_t tpcChi2PerCluster = 0.;
- if(nClust>0.) tpcChi2PerCluster = track->GetTPCchi2()/Float_t(nClust);
-
- Float_t tpcClustPerFindClust = 0.;
- if(nFindableClust>0.) tpcClustPerFindClust = Float_t(nClust)/nFindableClust;
- //--------------------------------
-
- //create a new AliJTrack and fill the track info
- AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack;
- ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
- ctrack->SetTPCdEdx( track->GetTPCsignal() );
- if( fStoreTPCTrack ){
- AliESDtrack *tpcTrack = AliESDtrackCuts::GetTPCOnlyTrack( esd, it );
- if( !tpcTrack ) continue;
- ctrack->SetTPCTrack( tpcTrack->Px(), tpcTrack->Py(), tpcTrack->Pz());
- }
- ReadESDPID( track, ctrack );
- ctrack->SetParticleType(AliJConst::kNone);
- ctrack->SetCharge(track->Charge());
- ctrack->SetFilterMap( filterMap );
-
- if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl;
-
- ++ntrk;
- } // end tracks loop
-}
-//_________________________________________________________________________________-
-void AliJCORRANTask::ReadESDPID(AliESDtrack *track, AliJTrack *ctrack)
-{
- // Probability calculation for PID
- Double_t probTPC[AliPID::kSPECIES]={0.};
- Double_t probTOF[AliPID::kSPECIES]={0.};
- Double_t probTPCTOF[AliPID::kSPECIES]={0.};
- //
- fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC);
- UInt_t detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPC);
- if (detUsed != 0) { // TPC is available
- for (Int_t ispec=0; ispec<AliPID::kSPECIES; ++ispec) {
- Double_t nSigmaTPC = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType)ispec);
- ctrack->SetTPCsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTPC);
- }
-
- // compute priors for TPC+TOF, even if we ask just TOF for PID
- fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF);
- detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTOF);
- if (detUsed != 0) { // TOF is available
- for (Int_t ispec=0; ispec<AliPID::kSPECIES; ++ispec) {
- Double_t nSigmaTOF = fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType)ispec);
- ctrack->SetTOFsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTOF);
- }
- }
-
- fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF|AliPIDResponse::kDetTPC);
- detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPCTOF);
- }
+ // Processing of one event
+ if(fDebug > 5) cout << "------- AliJCORRANTask Exec-------"<<endl;
+ if(!((Entry()-1)%100)) AliInfo(Form(" Processing event # %lld", Entry()));
- for (int ip=0 ; ip < (AliPID::kSPECIES); ip++) {
- ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTOF[ip], AliJTrack::kTOF);
- ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPC[ip], AliJTrack::kTPC);
- ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPCTOF[ip], AliJTrack::kTPCTOF);
- }
+ fFilter->UserExec("");
- // TOF beta and expected beta
- Float_t beta = -1; Float_t minP = 0.2; Float_t minTPCsignal = 40; Float_t minTOFLength = 365.; Float_t minTOFsignal = 12000;
- Double_t inttimes[10]; Float_t betaTh[10]; Double_t dEdxTh[10];
- track->GetIntegratedTimes(inttimes);
- for(int i=0;i<10;i++) {
- betaTh[i] = -1.; // initialize expected beta = -1
- dEdxTh[i] = -1.; // initialize expected dEdx = -1
- }
- if(track->P() > minP && track->GetTPCsignal() > minTPCsignal && (track->GetStatus() & AliESDtrack::kTOFout)
- && (track->GetStatus() & AliESDtrack::kTIME) && (track->GetIntegratedLength() > minTOFLength)&& track->GetTOFsignal() > minTOFsignal) {
- Double_t consCal = 33.3564095198152043;
- beta = track->GetIntegratedLength() / (track->GetTOFsignal() - fPIDesd->GetTOFResponse().GetStartTime(track->P())) * consCal;
- for(int i=0; i<10; i++) {
- betaTh[i] = track->GetIntegratedLength() / ( inttimes[i] ) * consCal;
- }
- }
- ctrack->SetTOFbeta(beta);
-
- Double_t ptpc[3];
- track->GetInnerPxPyPz(ptpc);
- Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]);
- for(int ip=0; ip < (AliJTrack::kNAliJTrkPID); ip++) {
- ctrack->SetExpectedTOFbeta(AliJTrack::AliJTrkPID(ip), betaTh[ip]);
- // expected dEdx
- dEdxTh[ip] = fPIDesd->GetTPCResponse().GetExpectedSignal(momtpc, AliPID::EParticleType(ip));
- ctrack->SetExpectedTPCdEdx(AliJTrack::AliJTrkPID(ip), dEdxTh[ip]);
- }
-
-
-
-}
-
-//______________________________________________________________________________
-void AliJCORRANTask::ReadAODTracks(const AliAODEvent * aod)
-{
- // Read the AliAODtrack and fill the list of AliJTrack containers
- Int_t nt = aod->GetNumberOfTracks();
- if(fDebug > 5) cout << "AOD::NumberOfTracks = " << nt << endl;
- cout << "AOD::NumberOfTracks = " << nt << endl;
- //Short_t ntrk = 0;
- //loop over tracks
- for(Int_t it = 0; it < nt; it++) {
-
- AliAODTrack *track = aod->GetTrack(it);
- //if(!AcceptAODTrack(track)) continue;
- //if(! fEsdTrackCuts->IsSelected(track)) continue; //apply loose selection criteria
- //FK//if(track->GetType() != AliAODTrack::kPrimary) continue; // only primaries
-
- AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack;
- ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
- //TODO if( fStoreTPCTrack )
- ctrack->SetParticleType(AliJConst::kNone);
- ctrack->SetCharge(track->Charge());
- ctrack->SetStatus(track->GetStatus());//
- ctrack->SetFlags( track->GetFlags() );
- ctrack->SetLabel( track->GetLabel() );
- //FilterMap
- UInt_t filterMap=0;
- for( unsigned int i=0;i<sizeof(filterMap)*8;i++ ){
- filterMap |= track->TestFilterBit( 1UL<<i );
- }
- ctrack->SetFilterMap( filterMap );
-
- //PID TODO
- double const * pid = track->PID();
- ctrack->SetPID(AliJTrack::kElectronAliJ,pid[AliAODTrack::kElectron],AliJTrack::kTOF);
- ctrack->SetPID(AliJTrack::kMuonAliJ, pid[AliAODTrack::kMuon], AliJTrack::kTOF);
- ctrack->SetPID(AliJTrack::kPionAliJ, pid[AliAODTrack::kPion], AliJTrack::kTOF);
- ctrack->SetPID(AliJTrack::kKaonAliJ, pid[AliAODTrack::kKaon], AliJTrack::kTOF);
- ctrack->SetPID(AliJTrack::kProtonAliJ, pid[AliAODTrack::kProton], AliJTrack::kTOF);
- //TPC
- ctrack->SetTPCnClust(track->GetTPCNcls());
- ctrack->SetTPCdEdx( track->GetTPCsignal() );
-
- if((bool) fIsRealOrMC[0]){
- //Int_t label = track->GetLabel();
- //ctrack->SetITSLabel(label);
- //ctrack->SetTPCLabel(label);
- }
-
-
- if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl;
- } // end tracks loop
-}
-
-//______________________________________________________________________________
-void AliJCORRANTask::ReadESDCaloClusters(const AliESDEvent* esd)
-{
- //AliVEvent * event = InputEvent();
- AliVEvent * event = (AliVEvent*)esd;
- TRefArray *caloClustersArr=new TRefArray();
- event->GetEMCALClusters(caloClustersArr);
- Double_t v[3];
- event->GetPrimaryVertex()->GetXYZ(v);
-
- AliEMCALRecoUtils * fRecoUtils = new AliEMCALRecoUtils;
-
- //const Int_t kNumberOfEMCALClusters =caloClustersArr->GetEntries();
- Int_t numberOfCaloClusters = caloClustersArr->GetEntries() ;
- if(fDebug > 5) cout << "ESD::number of ESD caloclusters " << numberOfCaloClusters << endl;
-
- AliVCaloCells *emCells =event->GetEMCALCells();
-
- int nPhotons = 0;
- for(Int_t icluster=0; icluster<numberOfCaloClusters; icluster++){
- AliVCluster *c1 = (AliVCluster*) caloClustersArr->At(icluster);
- if( !c1 ) continue;
- //== remove bad channels
- if(fRecoUtils->ClusterContainsBadChannel(fEMCALGeoUtils, c1->GetCellsAbsId(), c1->GetNCells())) continue;
- //== check energy and position
- if(fRecoUtils->IsRecalibrationOn()){
- fRecoUtils->RecalibrateClusterEnergy(fEMCALGeoUtils, c1, emCells);
- fRecoUtils->RecalculateClusterShowerShapeParameters(fEMCALGeoUtils, emCells, c1);
- fRecoUtils->RecalculateClusterPID(c1);
- }
- //== correct non linearity
- c1->SetE(fRecoUtils->CorrectClusterEnergyLinearity(c1));
-
- //== corrected clusters
- if(c1->E() < 0.8 || c1->E() > 30) continue; //TODO
- //fRecoUtils->GetMaxEnergyCell(fEMCALGeo, emCells, c1, absID1, iSM, ieta1, iphi1, shared);
-
- AliJPhoton *pht = new( (*fPhotonList)[nPhotons++] ) AliJPhoton;
- pht->SetParticleType(AliJConst::kNone);//kPhoton);
- pht->SetChi2(c1->Chi2());
- pht->SetPID(c1->GetPID());
- Float_t pos[3];
- TLorentzVector p1;
- c1->GetPosition(pos);
- c1->GetMomentum(p1, v);
- //TODO
- pht->SetPositionX(pos[0]);
- pht->SetPositionY(pos[1]);
- pht->SetPositionZ(pos[2]);
- pht->SetPxPyPzE( p1.Px(), p1.Py(), p1.Pz(), p1.E());
- pht->SetTrackDx( c1->GetTrackDx() );
- pht->SetTrackDz( c1->GetTrackDz() );
- pht->SetCharge(0);
- if(c1->IsEMCAL()) pht->SetCaloType(AliJPhoton::kEMCALCalo);
- if(c1->IsPHOS()) pht->SetCaloType(AliJPhoton::kPHOSCalo);
- pht->SetDistToBadChannel(c1->GetDistanceToBadChannel());
- pht->SetDispersion(c1->GetDispersion());
- pht->SetM20(c1->GetM20());
- pht->SetM02(c1->GetM02());
- pht->SetEmcCpvDist(c1->GetEmcCpvDistance());
- pht->SetNCells(c1->GetNCells());
- pht->SetCellsAmplitudeFraction( c1->GetCellsAmplitudeFraction() );
- pht->SetCellsAbsId(c1->GetCellsAbsId());
- Int_t imoduleID = GetSuperModuleNumber(c1->IsEMCAL(), c1->GetCellAbsId(0));
- pht->SetSuperModuleID(imoduleID);
- }
- delete fRecoUtils;
- delete caloClustersArr;
+ if( 1 || fFilter->GetEventSuccess() ){ // TODO
+ if( fDoStoreJOD ){
+ fJODTree->Fill();
+ }
+ }
+ PostData(1,fJODTree);
+ PostData(2,fFilter->GetRunInfoList());
-}
-//______________________________________________________________________________
-void AliJCORRANTask::ReadAODCaloClusters(const AliAODEvent* aod)
-{
- if( !aod ) aod=0;
- // Read the AliAODCaloClusters and fill the list of AliJPhoton containers
+ if(fDebug > 5) cout << "\t------- End UserExec "<<endl;
}
//______________________________________________________________________________
-AliJEventHeader* AliJCORRANTask::ReadCommonHeader(AliVEvent *event){
- //Read the AliVEvent and fill the list of AliJEventHeader containers
- //create a header and fill it
- AliJEventHeader *hdr = new( (*fHeaderList)[fHeaderList->GetEntriesFast()] ) AliJEventHeader;
-
- AliVVZERO *v0 = event->GetVZEROData();
- if( v0 ) hdr->SetV0Mult(v0->GetMTotV0A() + v0->GetMTotV0C());
- // Get Centrality as a percent from 0% to 100%
- AliCentrality *cent = event->GetCentrality();
- if( cent ){
- hdr->SetCentrality( cent->GetCentralityPercentile("V0M"));
- hdr->SetCentralityArray(AliJEventHeader::kcV0M, cent->GetCentralityPercentile("V0M"));
- hdr->SetCentralityArray(AliJEventHeader::kcFMD, cent->GetCentralityPercentile("FMD"));
- hdr->SetCentralityArray(AliJEventHeader::kcTRK, cent->GetCentralityPercentile("TRK"));
- hdr->SetCentralityArray(AliJEventHeader::kcTKL, cent->GetCentralityPercentile("TKL"));
- hdr->SetCentralityArray(AliJEventHeader::kcCL0, cent->GetCentralityPercentile("CL0"));
- hdr->SetCentralityArray(AliJEventHeader::kcCL1, cent->GetCentralityPercentile("CL1"));
- hdr->SetCentralityArray(AliJEventHeader::kcV0MvsFMD, cent->GetCentralityPercentile("V0MvsFMD"));
- hdr->SetCentralityArray(AliJEventHeader::kcTKLvsV0, cent->GetCentralityPercentile("TKLvsV0"));
- hdr->SetCentralityArray(AliJEventHeader::kcZEMvsZDC, cent->GetCentralityPercentile("ZEMvsZDC"));
- }
- hdr->SetTriggerMaskAlice(event->GetTriggerMask()); //ULong64_t
- hdr->SetTriggerMaskJCorran(ConvertTriggerMask()); //UInt_t
- hdr->SetEventType(event->GetEventType());
- int ncontributors = 0;
- const AliVVertex * vtxESD = event->GetPrimaryVertex();
- if(vtxESD){
- hdr->SetXVertex(vtxESD->GetX()); //FK// EFF
- hdr->SetYVertex(vtxESD->GetY()); //FK// EFF
- hdr->SetZVertex(vtxESD->GetZ());
- //hdr->SetZVertexErr(vtxESD->GetZRes());
- double covMat[6];
- vtxESD->GetCovarianceMatrix(covMat);
- hdr->SetZVertexErr(TMath::Sqrt(covMat[5])); // GetZRes := TMath::Sqrt(fCovZZ)
- ncontributors = vtxESD->GetNContributors(); // get number of contributors to vertex
- hdr->SetVtxMult( vtxESD->GetNContributors() );
- }else{
- hdr->SetZVertex(9999);
- hdr->SetZVertexErr(9999);
- }
- hdr->SetVtxMult(ncontributors); //FK// EFF contrib to vertex
- return hdr;
-}
-//______________________________________________________________________________
-void AliJCORRANTask::ReadESDHeader(AliESDEvent *esd)
+void AliJCORRANTask::Init()
{
- // Read the AliESDEvent and fill the list of AliJEventHeader containers
- if(!esd) return;
- AliESDUtils::RefitESDVertexTracks( esd ); // TODO only for LHC11a right?
- AliJEventHeader *hdr = ReadCommonHeader( esd );
- //create a header and fill it
- AliMultiplicity *fSPDMult =(AliMultiplicity *) esd->GetMultiplicity();
- if(fSPDMult) hdr->SetSPDTrackletMult(fSPDMult->GetNumberOfTracklets());
-
- //TODO Store Detector data
- if( fStoreEventPlaneSource ){
- *fVZEROData = *esd->GetVZEROData();
- *fTZEROData = AliESDTZERO(*esd->GetESDTZERO());
- *fZDCData = *esd->GetESDZDC();
- }
- hdr->SetEventID( esd->GetEventNumberInFile());
- const AliESDVertex * vtxESD = esd->GetPrimaryVertex();
- if( vtxESD->GetStatus() == 0 ) hdr->SetVtxMult( 0 );
- // if fNcontributes > 0 then status is always true. do we need this?
-}
+ // Intialisation of parameters
+ AliInfo("Doing initialization") ;
-//______________________________________________________________________________
-void AliJCORRANTask::ReadAODHeader(AliAODEvent *aod)
-{
- //Read the AliAODEvent and fill the list of AliJEventHeader containers
- AliJEventHeader *hdr = ReadCommonHeader( aod );
+ fFilter->Init();
- const AliAODTracklets *trackletsSPD = aod->GetTracklets();
- if(trackletsSPD){
- hdr->SetSPDTrackletMult(trackletsSPD->GetNumberOfTracklets());
- }
- //TODO hdr->SetEventID( esd->GetEventNumberInFile());
+ // TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep());
+ // if(formula.Length()>0){ // momentum dep DCA cut for AOD
+ // formula.ReplaceAll("pt","x");
+ // }
}
//______________________________________________________________________________
-Int_t AliJCORRANTask::GetSuperModuleNumber(bool isemcal, Int_t absId)
+void AliJCORRANTask::Terminate(Option_t * option)
{
- //get super module number
- if(isemcal){
- // return GetEMCALGeoUtils()->GetSuperModuleNumber(absId) ;
- return fEMCALGeoUtils->GetSuperModuleNumber(absId) ;
-
- } else {
- Int_t relId[4];
- if ( absId >= 0) {
- fPHOSGeom->AbsToRelNumbering(absId,relId);
- fPHOSGeom->AbsToRelNumbering(absId,relId);
- return relId[0]-1;
- } else return -1;
- }//PHOS
-
- return -1;
-}
-
-//_____________________________________________________________________________
-
-UInt_t AliJCORRANTask::ConvertTriggerMask(){
-
- //convert alice trigger mask to jcorran trigger mask
- UInt_t triggerMaskJC=0;
- if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
- ->IsEventSelected() & AliVEvent::kMB){
- // minimum bias TBit 0
- triggerMaskJC += (1<<AliJConst::kMinBiasTriggerBitJCorran);
- }
-
- if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
- ->IsEventSelected() & AliVEvent::kHighMult){
- //high multiplicity trigger TBit 1
- triggerMaskJC += (1<<AliJConst::kHighMultTriggerBitJCorran);
- }
-
- return triggerMaskJC;
-}
-
-
-//______________________________________________________________________________
-
-void AliJCORRANTask::ReadMCTracks(AliMCEvent *fMC){
- //store MC information from AliStack
- AliStack *stack = fMC->Stack();
- Int_t np = fMC->GetNumberOfTracks();
-
- // AliGenEventHeader* genHeader = fMC->GenEventHeader();
- // AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
- // Double_t ptHard = 0;
- // Double_t nTrials = 1; // Trials for MC trigger weigth for real data
- // nTrials = pythiaGenHeader->Trials();
- // ptHard = pythiaGenHeader->GetPtHard();
- // Int_t nprim = stack->GetNtrack();
-
- Short_t ntrack = 0;
-
- for(Int_t iTrack = 0; iTrack < np; iTrack++){
- AliMCParticle *track = (AliMCParticle*) fMC->GetTrack(iTrack);
- if(!track){
- Printf("ERROR: Could not receive track %d", iTrack);
- continue;
- }
- Bool_t isPrimary = fMC->Stack()->IsPhysicalPrimary(iTrack);
- if(isPrimary){
- //create a new JMCTrack and fill the track info
- AliJMCTrack *ctrack = new( (*fMCTrackList)[ntrack++] ) AliJMCTrack;;
-
- TParticle *partStack = stack->Particle(iTrack);
- Int_t pdg = partStack->GetPdgCode();
- // BS unused : Float_t engy = partStack->Energy();
- // BS unused : Float_t pt = partStack->Pt();
- // BS unused : Float_t ptot = partStack->P();
- // BS unused : Float_t eta = partStack->Eta();
- // BS unused : Float_t theta = partStack->Theta();
- // BS unused : Float_t phi = atan2(sin( partStack->Phi()), cos(partStack->Phi()));
- // BS unused : Short_t ch = (Short_t) partStack->GetPDG()->Charge();
- Int_t label = track->GetLabel();
-
- ctrack->SetLabel(label);
- ctrack->SetPdgCode(pdg);
- ctrack->SetPxPyPzE( partStack->Px(), partStack->Py(), partStack->Pz(), partStack->Energy());
- //ctrack->SetCharge(ch);
- ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary);
-
- ctrack->SetProductionVertex(partStack->Vx(),partStack->Vy(),partStack->Vz());
- /*
- Int_t status = partStack->GetStatusCode();
- ctrack->SetStatusCode(status);
-
- //ctrack->SetPtHard(ptHard);
-
- //bool isInc = (status == 1 && icode == 22); //Inclusive
- bool ispi0 = (status == 11 && pdg == 111); //kPizero
- bool isDgamma = (status == 6 || status == 7) && pdg == 22; // Direct photon
- bool inPHOS = (ispi0||isDgamma)&&fabs(eta)<0.12;
- bool inEMCAL = (ispi0||isDgamma)&&fabs(eta)<0.7;
- bool inTPC = fabs(eta)<0.9;
- ctrack->SetMother(0,partStack->GetFirstMother());
- ctrack->SetMother(1,partStack->GetSecondMother());
- ctrack->SetDaughter(0,partStack->GetFirstDaughter());
- ctrack->SetDaughter(1,partStack->GetLastDaughter());
- ctrack->SetIsInPHOS(inPHOS);
- ctrack->SetIsInEMCAL(inEMCAL);
- ctrack->SetIsInTPC(inTPC);
- */
- }// loop for al primary tracks
- }
-}
-
-//--------------------------------------------------------------------
-bool AliJCORRANTask::AcceptAODTrack(AliAODTrack* aodTrack){
- //This function mimics for the AliAODTracks object the AliESDtrackCut function IsSelected
- //Cuts are taken from fEsdTrackCuts object
- if(fEsdTrackCuts->GetMinNClusterTPC() > aodTrack->GetTPCNcls()) return kFALSE;
-
- //if(fEsdTrackCuts->GetMaxChi2PerClusterTPC() < );//<-------- how to check?
- // ctrack->SetChi2perNDF(track->Chi2perNDF());
-
- // C h e c k r e f i t
-
- /*
- if(fEsdTrackCuts->GetRequireTPCRefit() &&
- ((aodTrack->GetStatus() & AliJTrack::kTPCrefit) == 0)) return kFALSE;
- if(fEsdTrackCuts->GetRequireITSRefit() &&
- ((aodTrack->GetStatus() & AliJTrack::kITSrefit) == 0)) return kFALSE;
- */
-
- // C u t s o n D C A
- Float_t impactDCA[3];
- if( aodTrack->GetPosition(impactDCA)){
- if((fEsdTrackCuts->GetMaxDCAToVertexXY()>0) &&
- (fEsdTrackCuts->GetMaxDCAToVertexXY() < sqrt(impactDCA[0]*impactDCA[0] + impactDCA[1]*impactDCA[1]))) return kFALSE;
- if((fEsdTrackCuts->GetMaxDCAToVertexZ()>0) &&
- (fEsdTrackCuts->GetMaxDCAToVertexZ() < TMath::Abs(impactDCA[2]))) return kFALSE;
- } else return kFALSE;
-
-
-
- // if(fEsdTrackCuts->GetAcceptKinkDaughters()) //<--------how to check ?
- // esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
-
-
- return kTRUE;
-}
-
-bool AliJCORRANTask::SetAliceTriggerDef(AliJRunHeader *RunInfo){
- RunInfo->AddAliceTriggerDef( "kMB", AliVEvent::kMB );
- if( fRunType == "LHC10h" )
- {
- RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 );
- RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON );
- RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult );
- RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 );
- RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 );
- RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 );
- RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 );
- RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 );
- RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 );
- RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 );
- RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 );
- RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 );
- RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 );
- RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined );
- RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly );
- RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny );
- RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT );
- }
- else{
- // Default
- RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 );
- RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON );
- RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult );
- RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 );
- RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 );
- RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 );
- RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 );
- RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 );
- RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 );
- RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 );
- RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 );
- RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 );
- RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 );
- RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined );
- RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly );
- RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny );
- RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT );
- }
- return true;
-}
-
-bool AliJCORRANTask::SetAliceFilterMapDef(AliJRunHeader *RunInfo) {
- if( fRunType == "LHC10h" )
- {
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1));
- RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2));
- RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8));
- }
- else
- {
- // Default
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1));
- RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2));
- RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7));
- RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8));
- }
- return true;
-}
-
-void AliJCORRANTask::PrintOut() {
- AliJRunHeader * RunInfo = fAliRunHeader;
- cout << "===== TriggerDef =====" << endl;
- cout << RunInfo->GetAliceTriggerDef("kMB") << endl;
- cout << RunInfo->GetAliceTriggerDef("kINT7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kMUON") << endl;
- cout << RunInfo->GetAliceTriggerDef("kHighMult") << endl;
- cout << RunInfo->GetAliceTriggerDef("kEMC1") << endl;
- cout << RunInfo->GetAliceTriggerDef("kCINT5") << endl;
- cout << RunInfo->GetAliceTriggerDef("kCMUS5") << endl;
- cout << RunInfo->GetAliceTriggerDef("kMUSH7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kMUL7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kMUU7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kEMC7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kMUS7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kPHI1") << endl;
- cout << RunInfo->GetAliceTriggerDef("kPHI7") << endl;
- cout << RunInfo->GetAliceTriggerDef("kUserDefined") << endl;
- cout << RunInfo->GetAliceTriggerDef("kFastOnly") << endl;
- cout << RunInfo->GetAliceTriggerDef("kAny") << endl;
- cout << RunInfo->GetAliceTriggerDef("kAnyINT") << endl;
- cout << "===== FilterMapDef =====" << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsL") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsITsa") << endl;
- cout << RunInfo->GetAliceFilterMapDef("ItsStrong") << endl;
- cout << RunInfo->GetAliceFilterMapDef("ElectronID") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH2") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH3") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsTPCOnly") << endl;
- cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsRaa") << endl;
-}
-
+ fFilter->Terminate();
+
+ // Processing when the event loop is ended
+ fAliJRunHeader->PrintOut();
+ cout<<"AliJCORRANTask Analysis DONE !!"<<endl;
+ // Printout fRunInfoList here
+ TList* fRunInfoList = dynamic_cast<TList*> (GetOutputData(1));
+ if(fRunInfoList)
+ {
+ AliJRunHeader *fAliRunHeader = dynamic_cast<AliJRunHeader*> (fRunInfoList->FindObject("AliJRunHeader"));
+ if(fAliRunHeader) {fAliRunHeader->Print();}
+ }
+ else
+ {
+ cout << "WARNING : Run Information List is empty" << endl;
+ }
-//********************************************
-// UTILS
-//********************************************
-void AliJCORRANTask::AddListAODBranch(const char* aname, const char* cname, TClonesArray **obj, int nlist){
- *obj = new TClonesArray(cname, nlist);
- (*obj)->SetName(aname);
- AddAODBranch("TClonesArray", obj, fAODName.Data() );
}
#include "AliESDZDC.h"
#include "AliJConst.h"
#include "AliESDpid.h"
-#include "AliEMCALGeometry.h"
#include "AliPHOSGeoUtils.h"
#include "AliPIDResponse.h"
#include "AliPIDCombined.h"
+#include "AliJFilter.h"
+#include "AliJEfficiencyScanner.h"
//==============================================================
using namespace std;
-const int kMaxDimBuffer = 300;//max length of a line read to a buffe
-
class TH1D;
class TH2D;
class TNtuple;
// methods to fill from AliAnalysisTaskSE
virtual void UserCreateOutputObjects();
- virtual void Init();
+ virtual void Init();
virtual void LocalInit() { Init(); }
virtual void UserExec(Option_t *option);
- virtual void Terminate(Option_t * opt = "");
-
- TString GetRunType() const { return fRunType;}
- void SetRunType( const TString type ){ fRunType = type; }
- void SetESDtrackCuts(AliESDtrackCuts* esdTrackCuts){ fEsdTrackCuts = esdTrackCuts;}
- void SetESDFilter( AliAnalysisFilter * filter ){ fESDFilter = filter; }
- void SetRealOrMC(Bool_t realormc){fIsRealOrMC[0]=realormc;} //flags whether the input
- void SetStoreEventPlaneSource(bool dostore ){ fStoreEventPlaneSource = dostore; }
- bool GetStoreEventPlaneSource(){ return fStoreEventPlaneSource; };
- void SetStoreTPCTrack(bool dostore ){ fStoreTPCTrack = dostore; }
- bool GetStoreTPCTrack(){ return fStoreTPCTrack; };
- //are ESDs from real exp or MonteCarlo
+ virtual void Terminate(Option_t* option="");
+
+ AliJFilter *GetFilter() { return fFilter; }
+
+ AliJRunHeader * GetJRunHeader(){ return fAliJRunHeader; }
+ void SetJRunHeader( AliJRunHeader * hdr ){ fAliJRunHeader = hdr ; }
void SetOutputAODName(const char* aodname){ fAODName=aodname;}
- // AliEMCALGeoUtils* GetEMCALGeoUtils (bool doDelete=kFALSE);
+ TString *GetOutputAODName() {return &fAODName;}
+
+ void SetDoStoreJOD(Bool_t doeff){ fDoStoreJOD=doeff; }
+ Bool_t GetDoStoreJOD(){ return fDoStoreJOD; }
private:
- AliJEventHeader* ReadCommonHeader(AliVEvent *event);
- // methods to read data from ESD
- void ReadESDTracks(AliESDEvent* esd);
- void ReadESDCaloClusters(const AliESDEvent* esd);
- void ReadESDHeader(AliESDEvent* esd);
- void ReadESDPID(AliESDtrack* track, AliJTrack* ctrack);
- // methods to read data from AOD
- void ReadAODTracks(const AliAODEvent* aod);
- void ReadAODCaloClusters(const AliAODEvent* aod);
- void ReadAODHeader(AliAODEvent* aod);
- void ReadFilter();
- void ReadMCTracks(AliMCEvent* fMC);
- Int_t GetSuperModuleNumber(bool isemcal, Int_t absId);
-
- UInt_t ConvertTriggerMask();//Converts alice trigger mask to JCorran trigger mask
- //functions used for event selction:
- bool AcceptAODTrack(AliAODTrack* aodTrack);
- void SetOADBPath(const char* path) {fOADBPath=path;}
- const char* GetOADBPath() const { return fOADBPath.Data(); }
-
- // method to fill jcorran
- bool SetAliceTriggerDef(AliJRunHeader *runHeader);
- bool SetAliceFilterMapDef(AliJRunHeader *runHeader); //TODO Check
- void PrintOut();
- // UTILS
- void AddListAODBranch(const char* aname, const char* cname, TClonesArray **obj, int nlist);
-
- // d a t a m e m b e r s
- TString fRunType; // ex) LHC10h
- TString fInputFormat; // specify the input data format (ESD or AOD)
- AliESDtrackCuts* fEsdTrackCuts; //track selection cuts
- AliAnalysisFilter * fESDFilter; //filter set of track selection BS
- TVectorT<double> fIsRealOrMC; //flags if the input are real (0) ESDs or MonteCarlo ESDs (1)
+ AliJFilter *fFilter; // filter object
TString fAODName; //output delta AOD name
- TString fActiveTriggers[AliJConst::kRangeTriggerTableAlice];//alice table mapping trigger bit to trigger name
- TString fTriggerTableJCorran[AliJConst::kRangeTriggerTableJCorran];//JCorran trigger table TBit 0 =MinBias
- bool fStoreEventPlaneSource;
- bool fStoreTPCTrack;
- TString fOADBPath;
-
- // jcorran output objects
-
- TClonesArray * fTrackList; // list of charged track objects
- TClonesArray * fMCTrackList; // list of charged track objects
- TClonesArray * fPhotonList; // list of photons objects
- TClonesArray * fHeaderList; // event details
- TList * fRunInfoList; // run details
-
- AliESDpid *fPIDesd;
- AliPIDResponse *fPIDResponse; // PID response object
- AliPIDCombined *fPIDCombined;
-
- AliESDVZERO* fVZEROData;
- AliESDTZERO* fTZEROData;
- // AliESDFMD* fFMDData;
- AliESDZDC* fZDCData;
+ TTree *fJODTree;
+ AliJRunHeader * fAliJRunHeader;
- AliJRunHeader* fAliRunHeader;// run details (mg field, trigger mask,etc...)
- AliEMCALGeometry * fEMCALGeoUtils; // no AliEMCALGeoUtils.h in trunk aliroot (111130)
- AliPHOSGeoUtils * fPHOSGeom; //phos geometry matrix
+ Bool_t fDoStoreJOD;
- ClassDef(AliJCORRANTask, 1);
+ ClassDef(AliJCORRANTask, 2);
};
#endif // AliJCORRANTask_H
--- /dev/null
+//====================================
+//last modified FK 6.NOV 2009
+//====================================
+//blah
+// blah
+
+#include "AliJCard.h"
+
+//ClassImp(AliJCard);
+
+AliJCard::AliJCard():
+ AliJBaseCard(),
+ fhCorr(0),
+ feventV3kv(0),
+ fIndexVector(0),
+ fpi0massbin(0)
+{
+ //constructor
+}
+
+AliJCard::AliJCard(const char *filename):
+ AliJBaseCard(filename),
+ fhCorr(0),
+ feventV3kv(0),
+ fIndexVector(0),
+ fpi0massbin(0)
+{
+ //constructor
+ InitCard();
+ MakeFastCorrTypeIndex();
+}
+
+
+
+AliJCard::AliJCard(const AliJCard& obj) :
+ AliJBaseCard(),
+ fhCorr(obj.fhCorr),
+ feventV3kv(obj.feventV3kv),
+ fIndexVector(obj.fIndexVector),
+ fpi0massbin(obj.fpi0massbin)
+{
+ // copy constructor
+ JUNUSED(obj);
+}
+
+
+AliJCard& AliJCard::operator=(const AliJCard& obj){
+ // copy constructor
+ JUNUSED(obj);
+ 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;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+//=================================================
+// 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 );
+
+ //==== D a t a M e m b e r s ========
+
+ // 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
+
+ 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**************************************************************************
+ * 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 $
////////////////////////////////////////////////////
#ifndef JCONST_H
#define JCONST_H
+#define JUNUSED(expr) do { (void)(expr); } while (0)
+
//
// 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 20 //
+#define kMaxJetType 32 //
+#define kPtDim 15 //
#define kMaxNoRuns 100 // Maximum no of runs in a nanoDST file
+#define kMaxNoEPBin 24
-namespace AliJConst {
const double kJPi = 3.14159265358979; //TMath::Pi();
const double kJTwoPi = 2*kJPi;
const double kJToRadian = kJPi/180.;
const double kElectronMass = .51099906e-3;
const double kPionMass = .1395675;
-enum expName {kPHENIX, kALICE};
-const int kNumberOfExperiments = 2; //numberOfExperiments
-
-// Centrality
-const int kNCentBin = 5;
-const double kCentralityBins[kNCentBin+1] = { 0, 10, 20, 30, 40, 100 };
//====================== particle types ============================================
-const int kNumberOfParticleTypes = 9;
-enum particleType {kHadron, kPion, kKaon, kProton, kPhoton, kDecayphoton, kPizero, kEta, kNone};
+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", "none"};
-const char* const kParticleProtoType[kNumberOfExperiments][kNumberOfParticleTypes] =
- {{"PhJCgl", "PhJCgl", "PhJCgl", "PhJCgl", "PhJPhoton", "PhJPhoton", "AliPhJPiZero", "AliPhJPiZero", "None"},
- {"AliJTrack", "AliJTrack", "AliJTrack", "AliJTrack", "AliJPhoton", "AliJPhoton", "AliPhJPiZero", "AliPhJPiZero", "None"}};
-
+ {"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};
+enum TriggerBitJCorran {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran,
+ kEmc0TriggerBitJCorran,
+ kEmc1GammaTriggerBitJCorran, kEmc1JetTriggerBitJCorran,
+ kCentralTriggerBitJCorran,kSemiCentralTriggerBitJCorran,
+ kFastOnlyBitJCorran,
+ kINT7TriggerBitJCorran, kJNTriggerBit
+ };
const int kRangeTriggerTableAlice = 50;
const int kRangeTriggerTableJCorran = 16;
//==================================================================================
-enum fillType { kReal, kMixed, kRotated };
-enum corrType { kTriggType, kAssocType, kXeType, kCentrType, kMassType, kNoType };
-
-enum TriggerParticleType { kTriggParticles, kLeadingParticle, kIsolatedParticle, kJets }; // kJets for additional jet trigger counting.
+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 TriggerParticleTypeName[] =
- {"TriggParticles","LeadingParticle","IsolatedParticle"};
+const char* const kTriggerParticleTypeName[] =
+ {"TriggParticles","LeadingParticle","IsolatedParticle"};
// JETs =====
-const int NJetAlg = 10;
+const int kNJetAlg = 10;
enum JetAlg {kkt,kantikt,ksiscone,krecomE,krecomB,kcdfmidpoint,kjade,kd0run2cone,kGF,kSimpleCone};
-char const * const kJetAlgStrName[NJetAlg] =
+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
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJCorrelations.h"
+#include "AliJDataManager.h"
+
+#include "AliJCorrelations.h"
+#include "AliJHistos.h"
+#include "AliJBaseTrack.h"
+#include "AliJCard.h"
+#include "AliJHistos.h"
+#include "AliJRunTable.h"
+
+
+
+//==========================================================================
+// don't count the trigger here ! You'll miss the not associated triggers
+// but you will miss them in the main code too, unles you loop over those
+// fevent with no cgl (set the masMix to 1)
+//==========================================================================
+// blah
+
+AliJCorrelations::AliJCorrelations( AliJCard *cardIn, AliJHistos *histosIn) :
+ fcard(cardIn),
+ fhistos(histosIn),
+ fnReal(0),
+ fnMix(0),
+ fsumTriggerAndAssoc(0),
+ fsamplingMethod(0), // flat by default
+ fIsHeavyIon(0),
+ fawayPhiGap(0),
+ fmaxEtaRange(0),
+ fRSignalBin(0),
+ frandom(0x0),
+ fptt(0),
+ fpta(0),
+ fTrackPairEfficiency(0),
+ fIsIsolatedTrigger(false),
+ fpttBin(0),
+ fptaBin(0),
+ fPhiTrigger(0),
+ fPhiAssoc(0),
+ fDeltaPhi(0),
+ fDeltaPhiPiPi(0),
+ fDeltaEta(0),
+ fXlong(0),
+ fNearSide(true),
+ fEtaGapBin(0),
+ fPhiGapBinNear(0),
+ fPhiGapBinAway(0),
+ fRGapBinNear(0),
+ fRGapBinAway(0),
+ fCentralityBin(0),
+ fXlongBin(0),
+ fGeometricAcceptanceCorrection(1)
+{
+ // constructor
+
+ fsumTriggerAndAssoc = int( fcard->Get("sumTriggerAndAssoc") );
+ fmaxEtaRange = fcard->Get("EtaRange");
+ fRSignalBin = int(fcard->Get("EtaGapSignalBin"));
+
+ fDPhiUERegion[0] = fcard->Get("DPhiUERegion",0);
+ fDPhiUERegion[1] = fcard->Get("DPhiUERegion",1);
+ cout << fmaxEtaRange <<" fDPhiUERegion[0]="<< fDPhiUERegion[0] <<" fDPhiUERegion[1]="<< fDPhiUERegion[1] <<endl;
+ fIsHeavyIon = AliJRunTable::GetInstance().IsHeavyIon();
+
+ // -----------------------------------------------------------------------------------------------
+ // HARD CODED NUMBERS - VIOLATIONS - BREAKS the code when only on bin used in card.input!!!
+ // Who did this? Further more it us unused variable !!!!
+ // Jan
+ //fawayPhiGap = fcard->GetBinBorder(kEtaGapType, 2);
+ // -----------------------------------------------------------------------------------------------
+
+ for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++)
+ fRGap[iRGap] = fcard->GetBinBorder( kRGapType, iRGap);
+
+ //dPhiRange = fhistos->GetDphiRange();
+ frandom = new TRandom3(); //FK// frandom generator for jt flow UE
+ frandom->SetSeed(0); //FK//
+
+}
+
+AliJCorrelations::AliJCorrelations() :
+ fcard(0x0),
+ fhistos(0x0),
+ fnReal(0),
+ fnMix(0),
+ fsumTriggerAndAssoc(0),
+ fsamplingMethod(0), // flat by default
+ fIsHeavyIon(0),
+ fawayPhiGap(0),
+ fmaxEtaRange(0),
+ fRSignalBin(0),
+ frandom(0x0),
+ fptt(0),
+ fpta(0),
+ fTrackPairEfficiency(0),
+ fIsIsolatedTrigger(false),
+ fpttBin(0),
+ fptaBin(0),
+ fPhiTrigger(0),
+ fPhiAssoc(0),
+ fDeltaPhi(0),
+ fDeltaPhiPiPi(0),
+ fDeltaEta(0),
+ fXlong(0),
+ fNearSide(true),
+ fEtaGapBin(0),
+ fPhiGapBinNear(0),
+ fPhiGapBinAway(0),
+ fRGapBinNear(0),
+ fRGapBinAway(0),
+ fCentralityBin(0),
+ fXlongBin(0),
+ fGeometricAcceptanceCorrection(1)
+{
+ // default constructor
+}
+
+AliJCorrelations::AliJCorrelations(const AliJCorrelations& in) :
+ fcard(in.fcard),
+ fhistos(in.fhistos),
+ fnReal(in.fnReal),
+ fnMix(in.fnMix),
+ fsumTriggerAndAssoc(in.fsumTriggerAndAssoc),
+ fsamplingMethod(in.fsamplingMethod),
+ fIsHeavyIon(in.fIsHeavyIon),
+ fawayPhiGap(in.fawayPhiGap),
+ fmaxEtaRange(in.fmaxEtaRange),
+ fRSignalBin(in.fRSignalBin),
+ frandom(in.frandom),
+ fptt(in.fptt),
+ fpta(in.fpta),
+ fTrackPairEfficiency(in.fTrackPairEfficiency),
+ fIsIsolatedTrigger(in.fIsIsolatedTrigger),
+ fpttBin(in.fpttBin),
+ fptaBin(in.fptaBin),
+ fPhiTrigger(in.fPhiTrigger),
+ fPhiAssoc(in.fPhiAssoc),
+ fDeltaPhi(in.fDeltaPhi),
+ fDeltaPhiPiPi(in.fDeltaPhiPiPi),
+ fDeltaEta(in.fDeltaEta),
+ fXlong(in.fXlong),
+ fNearSide(in.fNearSide),
+ fEtaGapBin(in.fEtaGapBin),
+ fPhiGapBinNear(in.fPhiGapBinNear),
+ fPhiGapBinAway(in.fPhiGapBinAway),
+ fRGapBinNear(in.fRGapBinNear),
+ fRGapBinAway(in.fRGapBinAway),
+ fCentralityBin(in.fCentralityBin),
+ fXlongBin(in.fXlongBin),
+ fGeometricAcceptanceCorrection(in.fGeometricAcceptanceCorrection)
+{
+ // The pointers to card and histos are just copied. I think this is safe, since they are not created by
+ // AliJCorrelations and thus should not disappear if the AliJCorrelation managing them is destroyed.
+
+ fDPhiUERegion[0] = in.fDPhiUERegion[0];
+ fDPhiUERegion[1] = in.fDPhiUERegion[1];
+
+ for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++){
+ fRGap[iRGap] = in.fRGap[iRGap];
+ }
+
+ frandom = new TRandom3(); // frandom generator for jt flow UE
+ frandom->SetSeed(0);
+}
+
+AliJCorrelations& AliJCorrelations::operator=(const AliJCorrelations& in){
+ // Assingment operator
+
+ if (&in==this) return *this;
+
+ fptt = in.fptt;
+ fpta = in.fpta;
+ fTrackPairEfficiency = in.fTrackPairEfficiency;
+ fIsIsolatedTrigger = in.fIsIsolatedTrigger;
+ fpttBin = in.fpttBin;
+ fptaBin = in.fptaBin;
+ fPhiTrigger = in.fPhiTrigger;
+ fPhiAssoc = in.fPhiAssoc;
+ fDeltaPhi = in.fDeltaPhi;
+ fDeltaPhiPiPi = in.fDeltaPhiPiPi;
+ fDeltaEta = in.fDeltaEta;
+ fXlong = in.fXlong;
+ fNearSide = in.fNearSide;
+ fEtaGapBin = in.fEtaGapBin;
+ fPhiGapBinNear = in.fPhiGapBinNear;
+ fPhiGapBinAway = in.fPhiGapBinAway;
+ fRGapBinNear = in.fRGapBinNear;
+ fRGapBinAway = in.fRGapBinAway;
+ fCentralityBin = in.fCentralityBin;
+ fXlongBin = in.fXlongBin;
+ fGeometricAcceptanceCorrection = in.fGeometricAcceptanceCorrection;
+ fnReal = in.fnReal;
+ fnMix = in.fnMix;
+ fsumTriggerAndAssoc = in.fsumTriggerAndAssoc;
+ fsamplingMethod = in.fsamplingMethod;
+ fIsHeavyIon = in.fIsHeavyIon;
+ fawayPhiGap = in.fawayPhiGap;
+ fmaxEtaRange = in.fmaxEtaRange;
+ fRSignalBin = in.fRSignalBin;
+
+ // The pointers to card and histos are just copied. I think this is safe, since they are not created by
+ // AliJCorrelations and thus should not disappear if the AliJCorrelation managing them is destroyed.
+ fcard = in.fcard;
+ fhistos = in.fhistos;
+
+ fDPhiUERegion[0] = in.fDPhiUERegion[0];
+ fDPhiUERegion[1] = in.fDPhiUERegion[1];
+
+ for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++){
+ fRGap[iRGap] = in.fRGap[iRGap];
+ }
+
+ frandom = new TRandom3(); // frandom generator for jt flow UE
+ frandom->SetSeed(0);
+
+ return *this;
+ // copy constructor
+}
+
+
+void AliJCorrelations::FillHisto(corrFillType cFTyp, fillType fTyp, int cBin, int zBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2){
+ // histo filler
+ if( cFTyp == kAzimuthFill )
+ FillAzimuthHistos( fTyp, cBin, zBin, ftk1, ftk2);
+
+}
+
+//=============================================================================================
+void AliJCorrelations::FillAzimuthHistos(fillType fTyp, int CentBin, int ZBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2)
+//=============================================================================================
+{
+ // histo filler
+ bool twoTracks = false;
+ if(ftk1->GetParticleType()==kHadron && ftk2->GetParticleType()==kHadron) twoTracks =true;
+
+ //double-counting check
+ if(fTyp == kReal && twoTracks && ftk1->GetID()==ftk2->GetID()) return;
+
+ // Accept only unlike sign pairs
+ //if(ftk1->GetCharge() > 0 && ftk2->GetCharge() > 0) return;
+ //if(ftk1->GetCharge() < 0 && ftk2->GetCharge() < 0) return;
+
+ //----------------------------------------------------------------
+ fptt = ftk1->Pt();
+ fpta = ftk2->Pt();
+
+ fTrackPairEfficiency = 1./( ftk1->GetTrackEff() * ftk2->GetTrackEff() );
+
+ fIsIsolatedTrigger = ftk1->GetIsIsolated()>0 ? true : false; //FK// trigger particle is isolated hadron
+
+ //phit= ftk1->Phi(); //for RP
+ fpttBin = ftk1->GetTriggBin();
+ fptaBin = ftk2->GetAssocBin();
+ fPhiTrigger = ftk1->Phi();
+ fPhiAssoc = ftk2->Phi();
+ fDeltaPhi = DeltaPhi(fPhiTrigger, fPhiAssoc); //radians
+ fDeltaPhiPiPi = atan2(sin(fPhiTrigger-fPhiAssoc), cos(fPhiTrigger-fPhiAssoc));
+ fDeltaEta = ftk1->Eta() - ftk2->Eta();
+ //double dEtaFar = ftk1->Eta() + ftk2->Eta();
+
+ fNearSide = cos(fPhiTrigger-fPhiAssoc) > 0 ? true : false;
+
+ fEtaGapBin = fcard->GetBin( kEtaGapType, fabs(fDeltaEta));
+ fPhiGapBinNear = fcard->GetBin( kEtaGapType, fabs(fDeltaPhiPiPi) );
+ fPhiGapBinAway = fcard->GetBin( kEtaGapType, fabs(fDeltaPhi-kJPi) ); //here the angle must be 0-2pi and not (-pi,pi)
+ fRGapBinNear = fcard->GetBin( kRGapType, fabs(ftk1->DeltaR(*ftk2)));
+ fRGapBinAway = fcard->GetBin( kRGapType, sqrt(pow(fDeltaPhi-kJPi,2)+fDeltaEta*fDeltaEta) );
+ fCentralityBin = CentBin;
+
+ TLorentzVector vTrigger = ftk1->GetLorentzVector(), vAssoc = ftk2->GetLorentzVector(); // Lorentz vectors for trigger and associated particles
+ fXlong = vTrigger.Vect().Dot(vAssoc.Vect())/pow(vTrigger.P(),2);
+ fXlongBin = fcard->GetBin(kXeType, TMath::Abs(fXlong));
+
+ //if( rGapBin != fRGapBinNear ) cout<<"dR vs fRGapBinNear = "<<rGapBin<<"\t"<<fRGapBinNear<<endl;
+ //if( rGapBin != fRGapBinAway ) cout<<"dR vs fRGapBinAway = "<<rGapBin<<"\t"<<fRGapBinAway<<endl;
+ //----------------------------------------------------------------
+
+ //acceptance correction triangle or mixed fevent
+ // fGeometricAcceptanceCorrection = 1;
+ fGeometricAcceptanceCorrection = ( fsamplingMethod == 0 ) ? GetGeoAccCorrFlat(fDeltaEta) : GetGeoAccCorrIncl(fDeltaEta);
+
+
+ if(fpttBin<0 || fptaBin<0 || fEtaGapBin<0 ){
+ cout<<"Error in FillAzimuthHistos: some pT or eta out of bin. pttBin="<<fpttBin<<" pTaBin="<<fptaBin <<" etaGapBin="<< fEtaGapBin << endl;
+ ftk1->Print();
+ ftk2->Print();
+ exit(-1);
+ //return;
+ }
+
+ if(fDeltaPhi==0) cout <<" fdphi=0; fptt="<< fptt<<" fpta="<<fpta<<" TID="<<ftk1->GetID()<<" AID="<<ftk2->GetID() <<" tphi="<< fPhiTrigger <<" aphi="<< fPhiAssoc << endl;
+
+ // ===================================================================
+ // ===================== Fill Histograms ===========================
+ // ===================================================================
+
+ bool fill2DBackgroundQualityControlHistograms = false; // Choose whether to fill the DeltaPhi DeltaEta histograms for jT background
+
+ //FillPairPtAndCosThetaStarHistograms(fTyp, ftk1, ftk2); // Fill the pair pT and cos(theta*) histograms TODO: Does not work! Needs debugging
+ FillXeHistograms(fTyp); // Fill the xE and xLong histograms
+ FillJtHistograms(fTyp, ftk1, ftk2, fill2DBackgroundQualityControlHistograms); // Fill the jT and pout histograms togerher with some background quality assurance histograms
+ FillDeltaEtaHistograms(fTyp, ZBin); // Fill all the delta eta histograms
+ FillDeltaPhiHistograms(fTyp); // Fill the azimuthal correlation functions
+ FillPtaHistograms(fTyp); // Fill various pTa histograms
+ FillIAAAndMoonHistograms(fTyp, ZBin); // Fill the I_AA and moon histograms
+
+}
+
+
+void AliJCorrelations::FillPairPtAndCosThetaStarHistograms(fillType fTyp, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2)
+{
+ // This method fills the pair pT and Cos(thata*) histograms
+
+ TVector3 v3trigg = ftk1->GetLorentzVector().Vect();
+ TVector3 v3assoc = ftk2->GetLorentzVector().Vect();
+ double pairMass = sqrt(2*v3trigg.Mag()*v3assoc.Mag()*(1-cos(v3trigg.Angle(v3assoc))));
+ int imass = fcard->GetBin(kMassType, pairMass);
+ TVector3 v3pairPt = v3trigg + v3assoc;
+ double pairPt = v3pairPt.Perp();
+ double wPairPt = pairPt>0 ? 1/pairPt : 0;
+
+ //================================
+ // Pair pT and cos(Theta^star) === // TODO: Needs debugging, the code below does not work!
+ //================================
+
+ if(!fNearSide) {
+ fhistos->fhPairPt[fTyp][fpttBin][fptaBin]->Fill( pairPt, fTrackPairEfficiency);
+ double pairDphi = v3pairPt.DeltaPhi(v3trigg);
+ if(pairDphi<-kJPi/3.0) pairDphi += kJTwoPi;
+ fhistos->fhPairPtDphi[fTyp][fpttBin][fptaBin]->Fill( pairDphi/kJPi );
+ }
+
+ if ( fTyp == kReal ) {
+ //cout<<" fptt="<< fptt <<" fpta="<< fpta <<" fdphi="<< fDeltaPhi <<" pairPt="<< pairPt << endl;
+
+ int ipairPt = fcard->IsLessThanUpperPairPtCut(pairPt);
+ //cout<<"ppt="<<pairPt<<" mass="<<pairMass<<" ip="<<ipairPt<<" im="<<imass<<endl;
+ if(imass>=0) {
+ fhistos->fhPairPtMass[imass]->Fill( pairPt, fTrackPairEfficiency*wPairPt );
+ fhistos->fhPairDPhi[imass]->Fill( fDeltaPhi/kJPi, fTrackPairEfficiency );
+ fhistos->fhPairDpT[imass]->Fill( fptt-fpta, fTrackPairEfficiency );
+ }
+ if(imass>=0 && ipairPt>=0 ){
+ double cmsRap = (ftk1->Eta()+ftk2->Eta())/2.;
+ double cosThetaStar = fabs(cos(2*atan(exp(-ftk1->Eta()+cmsRap))));
+ fhistos->fhCosThetaStar[fTyp][ipairPt][imass]->Fill( cosThetaStar, fTrackPairEfficiency );
+
+ //frandom boost, Let's try just trigger phi as a cms boost.
+ cosThetaStar = fabs(cos(2*atan(exp(-ftk1->Eta()+fPhiTrigger))));
+ fhistos->fhCosThetaStar[kMixed][ipairPt][imass]->Fill( cosThetaStar, fTrackPairEfficiency );
+
+ fhistos->fhInvMass[ipairPt]->Fill(pairMass, fTrackPairEfficiency);
+ fhistos->fhCMSrap[ipairPt][imass]->Fill( cosThetaStar, cmsRap*fTrackPairEfficiency );
+ fhistos->fpCMSrap->Fill( cosThetaStar, fabs(cmsRap)*fTrackPairEfficiency );
+ }
+ }
+
+ //---------------------------------
+ //if(pairMass>10 && fcard->IsLessThanUpperPairPtCut(pairPt) ){
+ // cout<<pairMass<<" e1="<<ftk1->Eta()-cmsRap<<" e2="<<ftk2->Eta()-cmsRap<<" cms="<<cmsRap;
+ // cout<<" ppt="<<pairPt<<" tphi="<<fPhiTrigger<<" aphi="<<fPhiAssoc<<" t1="<<fptt<<" t2="<<fpta<<endl;
+ // double thetaStar = fabs(2*atan(exp(-ftk1->Eta()-cmsRap)));
+ // cout<<thetaStar<<" "<<fabs(cos(thetaStar))<<endl;
+ //}
+
+ //---------------------------------
+}
+
+void AliJCorrelations::FillXeHistograms(fillType fTyp)
+{
+ // This method fills the xE and xLong histograms
+
+ double xe = -fpta*cos(fPhiTrigger-fPhiAssoc)/fptt;
+
+ if( fTyp == kReal ) {
+ fhistos->fhxEPtBin[0][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ if( fNearSide ) {
+ fhistos->fhxEPtBin[1][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ } else {
+ fhistos->fhxEPtBin[2][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ }
+ }
+
+ if(fNearSide) {
+ fhistos->fhxEN [fTyp][fpttBin]->Fill(-xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ } else {
+ fhistos->fhxEF [fTyp][fpttBin]->Fill(xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ if(fIsIsolatedTrigger) fhistos->fhxEFIsolTrigg[fTyp][fpttBin]->Fill(xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ }
+}
+
+void AliJCorrelations::FillJtHistograms(fillType fTyp, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2, bool fill2DBackground)
+{
+ // This method fills the jT and pout histograms
+
+ double pout = fabs(fpta*sin(fPhiTrigger-fPhiAssoc));
+
+ if(fNearSide) {
+
+ TLorentzVector vTrigger = ftk1->GetLorentzVector(), vAssoc = ftk2->GetLorentzVector(); // Lorentz vectors for tracks
+
+ double jt = vAssoc.Perp(vTrigger.Vect());
+ double weight = jt > 1e-3 ? fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt : 0;
+
+ int iKlongBin = fcard->GetBin(kLongType, vTrigger.Vect().Dot(vAssoc.Vect())/vTrigger.P());
+ if(iKlongBin>=0){
+ fhistos->fhJTKlong[fTyp][fCentralityBin][fpttBin][iKlongBin]->Fill(jt, weight);
+ //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <<endl;
+ }
+ if(fXlongBin>=0){
+ fhistos->fhJT[fTyp][fCentralityBin][fpttBin][fXlongBin]->Fill(jt, weight);
+ //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <<endl;
+ }
+ if(fptaBin>=0){
+ fhistos->fhJTPta[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill(jt, weight);
+ //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <<endl;
+ }
+
+ TLorentzVector vAssocRndm;
+ TLorentzVector vThrustRndm;
+
+ //-------------------------------------
+ // Rapidity Gap background
+ // ------------------------------------
+ double etaTriggRndm, etaAssocRndm;
+ double dphiAssocRndm = 0;
+
+ if(fTyp==kReal && ( fEtaGapBin >=0 || fRGapBinNear >=0 ) ){
+ for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++) fhistos->fhPtaEtaGapN[fCentralityBin][iEtaGap][fpttBin]->Fill(fpta, fTrackPairEfficiency);
+ for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++) fhistos->fhPtaRGapN[fCentralityBin][iRGap][fpttBin]->Fill(fpta, fTrackPairEfficiency);
+ for(int itrial=0; itrial<20; itrial++){ //For each high eta gap track generate ten others
+
+ if(fsamplingMethod == 0){
+ etaTriggRndm = frandom->Uniform(-fmaxEtaRange, fmaxEtaRange);
+ etaAssocRndm = frandom->Uniform(-fmaxEtaRange, fmaxEtaRange);
+ } else {
+ etaTriggRndm = fhistos->fhIetaTriggFromFile[fCentralityBin][fpttBin]->GetRandom();
+ etaAssocRndm = fhistos->fhIetaAssocFromFile[fCentralityBin][fptaBin]->GetRandom();
+ }
+ if( fEtaGapBin >=0 || fRGapBinNear >=0 ) {
+ if( fsamplingMethod == 0) {
+ dphiAssocRndm = kJPi * frandom->Uniform(-0.5, 0.5);
+ } else {
+ dphiAssocRndm = fhistos->fhIphiAssocFromFile[fCentralityBin][fptaBin]->GetRandom();
+ }
+ vAssocRndm.SetPtEtaPhiM(fpta, etaAssocRndm, fPhiTrigger + dphiAssocRndm, 0); //set randomized assoc TLorentz vector
+ } else {
+ vAssocRndm.SetPtEtaPhiM(fpta, etaAssocRndm, fPhiAssoc, 0); //set randomized assoc TLorentz vector
+ }
+
+ vThrustRndm.SetPtEtaPhiM(vTrigger.Pt(),etaTriggRndm, fPhiTrigger, 0);
+
+ double dEtaRndm = etaTriggRndm - etaAssocRndm;
+ double geoAccCorrRndm = (fsamplingMethod == 0 || fPhiGapBinNear<0 ) ? GetGeoAccCorrFlat(dEtaRndm) : GetGeoAccCorrIncl(dEtaRndm);
+
+ jt = vAssocRndm.Perp(vThrustRndm.Vect());
+
+ // TODO : shadowing of iKlongBin
+ int jKlongBin = fcard->GetBin(kLongType, vThrustRndm.Vect().Dot(vAssocRndm.Vect())/vThrustRndm.P());
+ if(jKlongBin>=0){ //
+ if(jt>1e-3) { //here we used and BgFidCut
+ for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){
+ fhistos->fhJTKlongBg[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaKlong[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocKlong[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){
+ fhistos->fhJTKlongBgR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaKlongR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocKlongR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ }
+ }
+ int iXeBin = fcard->GetBin(kXeType, vThrustRndm.Vect().Dot(vAssocRndm.Vect())/pow(vThrustRndm.P(),2) );
+ if(iXeBin>=0){
+ if(jt>1e-3) { //here we used and BgFidCut
+ for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){
+ fhistos->fhJTBg[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaXe[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocXe[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){
+ fhistos->fhJTBgR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaXeR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocXeR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ }
+ }
+ if(fptaBin>=0){
+ if(jt>1e-3) { //here we used and BgFidCut
+ for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){
+ fhistos->fhJTPtaBg[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaPta[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocPta[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){
+ fhistos->fhJTPtaBgR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt);
+ if(fill2DBackground) fhistos->fhDphiDetaPtaR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency);
+ fhistos->fhBgAssocPtaR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(fpta, fTrackPairEfficiency);
+ }
+ }
+ }
+ } //trials
+ }// Eta Gap Random
+
+
+ } else {
+ fhistos->fhPoutF[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill(pout, fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ }
+}
+
+void AliJCorrelations::FillDeltaEtaHistograms(fillType fTyp, int ZBin)
+{
+ // This method fills the DeltaEta histograms
+
+ if( fNearSide ){ //one could check the phiGapBin, but in the pi/2 <1.6 and thus phiGap is always>-1
+ if( fTyp == 0 ) {
+ fhistos->fhDEtaNear[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fptaBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ if(fXlongBin>=0) fhistos->fhDEtaNearXEbin[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fXlongBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ } else {
+ fhistos->fhDEtaNearM[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fptaBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ if(fXlongBin>=0) fhistos->fhDEtaNearMXEbin[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fXlongBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ }
+ } else {
+ if(fPhiGapBinAway<=3) fhistos->fhDEtaFar[fTyp][fCentralityBin][fpttBin]->Fill( fDeltaEta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ }
+}
+
+void AliJCorrelations::FillDeltaPhiHistograms(fillType fTyp)
+{
+ // This method fills the DeltaPhi histograms
+
+ // When hists are filled for thresholds they are not properly normalized and need to be subtracted
+ // This induced improper errors - subtraction of not-independent entries
+
+ fhistos->fhDphiAssoc[fTyp][fCentralityBin][fEtaGapBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+ if(fXlongBin>=0) fhistos->fhDphiAssocXEbin[fTyp][fCentralityBin][fEtaGapBin][fpttBin][fXlongBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency);
+
+ if(fIsIsolatedTrigger) fhistos->fhDphiAssocIsolTrigg[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency); //FK//
+}
+
+void AliJCorrelations::FillPtaHistograms(fillType fTyp)
+{
+ // This method fills various pta histograms
+
+ if ( fTyp == kReal ) {
+ //must be here, not in main, to avoid counting triggers
+ fhistos->fhAssocPtBin[fCentralityBin][fpttBin][fptaBin]->Fill(fpta ); //I think It should not be weighted by Eff
+
+ //++++++++++++++++++++++++++++++++++++++++++++++++++
+ // in order to get mean pTa in the jet peak one has
+ // to fill fhMeanPtAssoc in |DeltaEta|<0.4
+ // +++++++++++++++++++++++++++++++++++++++++++++++++
+ if(fEtaGapBin>=0 && fEtaGapBin<2){
+ fhistos->fhMeanPtAssoc[fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fpta );
+ fhistos->fhMeanZtAssoc[fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fpta/fptt);
+ }
+
+ //UE distribution
+ if(fabs(fDeltaPhiPiPi/kJPi)>fDPhiUERegion[0] && fabs(fDeltaPhiPiPi/kJPi)<fDPhiUERegion[1]){
+ for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++) //FK// UE Pta spectrum for different eta gaps
+ fhistos->fhPtAssocUE[fCentralityBin][iEtaGap][fpttBin]->Fill(fpta, fTrackPairEfficiency);
+ if(fIsIsolatedTrigger){ //FK// trigger is isolated hadron
+ fhistos->fhPtAssocUEIsolTrigg[fpttBin]->Fill(fpta, fTrackPairEfficiency); //FK//
+ }
+ }
+ if(fabs(fDeltaPhi/kJPi)<0.15) fhistos->fhPtAssocN[fpttBin]->Fill(fpta, fTrackPairEfficiency);
+ if(fabs(fDeltaPhi/kJPi-1)<0.15) fhistos->fhPtAssocF[fpttBin]->Fill(fpta, fTrackPairEfficiency);
+
+ fnReal++;
+ } else { // only mix
+ fnMix++;
+ }
+}
+
+void AliJCorrelations::FillIAAAndMoonHistograms(fillType fTyp, int ZBin)
+{
+ // This method fills the I_AA and moon histograms
+
+ fhistos->fhDphiAssoc2DIAA[fTyp][fCentralityBin][ZBin][fpttBin][fptaBin]->Fill( fDeltaEta, fDeltaPhi/kJPi, fTrackPairEfficiency);
+
+ if(fRGapBinNear>=0){
+ if(fRGapBinNear <= fRSignalBin) fhistos->fhDRNearPt[fTyp][fCentralityBin][ZBin][fRGapBinNear][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ // - moon -
+ if(fRGapBinNear>0){
+ for( int irs = 0; irs <= fRSignalBin;irs++ ){
+ if( fRGapBinNear < irs ) continue;
+ if( fPhiGapBinNear > irs ) continue;
+ for ( int ir1=0;ir1<= fRGapBinNear;ir1++ ){
+ if( irs > ir1 ) continue;
+ if( ir1 > fRGapBinNear ) continue;
+ double rGapS= fRGap[irs+1];
+ double rGap1= fRGap[ir1+1];
+ if( rGap1 < TMath::Abs(fDeltaPhiPiPi) ) continue;
+ if( rGapS < TMath::Abs(fDeltaPhiPiPi) ) continue;
+ double dEtaMin = sqrt(rGap1*rGap1-fDeltaPhiPiPi*fDeltaPhiPiPi);
+ double dEtaMax = dEtaMin + sqrt(rGapS*rGapS-fDeltaPhiPiPi*fDeltaPhiPiPi);
+ double eta = TMath::Abs( fDeltaEta );
+ if( eta > dEtaMin && eta < dEtaMax ){
+ //if( eta > dEtaMin && eta < dEtaMax && fDeltaEta <0 ){
+ // xxx
+ // fhistos->hDRNearPtMoon[fTyp][fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+
+ if( fTyp == 0 )
+ fhistos->fhDRNearPtMoon[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ else
+ fhistos->fhDRNearPtMoonM[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ if(fTyp == kReal) fhistos->fhDphiAssoc2D[ir1][irs]->Fill( fDeltaEta, fDeltaPhi/kJPi, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ }
+ }
+ }
+ }
+ }
+
+ if(fRGapBinAway>=0){
+ if(fRGapBinAway <= fRSignalBin) fhistos->fhDRFarPt[fTyp][fCentralityBin][ZBin][fRGapBinAway][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ // - moon -
+ if(fRGapBinAway>0){
+ for( int irs = 0; irs <= fRSignalBin;irs++ ){
+ if( fRGapBinAway < irs ) continue;
+ if( fPhiGapBinAway > irs ) continue;
+ for ( int ir1=0;ir1<= fRGapBinAway;ir1++ ){
+ if( irs > ir1 ) continue;
+ if( ir1 > fRGapBinAway ) continue;
+ double rGapS= fRGap[irs+1];
+ double rGap1= fRGap[ir1+1];
+ if( rGap1 < TMath::Abs(fDeltaPhi-kJPi) ) continue;
+ if( rGapS < TMath::Abs(fDeltaPhi-kJPi) ) continue;
+ double dEtaMin = sqrt(rGap1*rGap1- (fDeltaPhi-kJPi)*(fDeltaPhi-kJPi) );
+ double dEtaMax = dEtaMin + sqrt(rGapS*rGapS-(fDeltaPhi-kJPi)*(fDeltaPhi-kJPi) );
+ double eta = TMath::Abs( fDeltaEta );
+ if( eta > dEtaMin && eta < dEtaMax ){
+ //if( eta > dEtaMin && eta < dEtaMax && fDeltaEta <0 ){
+ // xxx
+ // fhistos->hDRFarPtMoon[fTyp][fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ if( fTyp == 0 )
+ fhistos->fhDRFarPtMoon[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ else
+ fhistos->fhDRFarPtMoonM[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+
+ if(fTyp == kReal) fhistos->fhDphiAssoc2D[ir1][irs]->Fill( fDeltaEta, fDeltaPhi/kJPi, fGeometricAcceptanceCorrection * fTrackPairEfficiency );
+ }
+ }
+ }
+ }
+ }
+}
+
+
+double AliJCorrelations::GetGeoAccCorrFlat(double deltaEta){
+ //FK// calculate acceptance correction on pseudorapidity triangle
+ double absDEta = fabs(deltaEta);
+
+ double denominator = 1 - absDEta/(2*fmaxEtaRange);
+ //double denominator = 1 - (absDEta - ftriggFiducCut)/(2*fmaxEtaRange-2*ftriggFiducCut);//When Fid>0 max_Deta je mensi nez 2*EtaMax
+ //double denominator = 1 - (absDEta - ftriggFiducCut)/(2*fmaxEtaRange-ftriggFiducCut);
+ if(denominator > 1e-6)
+ return 1.0/denominator;
+ else
+ return 0;
+}
+
+double AliJCorrelations::GetGeoAccCorrIncl(double deltaEta){
+ // histo filler
+
+ if(fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->GetEntries()<1000) return GetGeoAccCorrFlat(deltaEta);
+
+ int bin = fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->FindBin(deltaEta);
+ double denominator = fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->GetBinContent(bin);
+ if(denominator > 1e-6)
+ return 1.0/denominator;
+ else
+ return 0;
+
+}
+
+double AliJCorrelations::DeltaPhi(double phi1, double phi2) {
+ // dphi
+ double res = atan2(sin(phi1-phi2), cos(phi1-phi2));
+ //double res = phi1 - phi2;
+ //return res>-kJPi/3.0 ? res : kJTwoPi+res ;
+ return res>-kJPi*9./20. ? res : kJTwoPi+res ;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/* 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!
+
+//===========================================================
+// AliJCorrelations.h
+// Created Thu Apr 17 12:40:29 EEST 2008 by classmaker
+// Jan Rak
+//===========================================================
+
+#ifndef ALIJCORRELATIONS_H
+#define ALIJCORRELATIONS_H
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <TRandom3.h> //FK//
+
+#include <AliJConst.h>
+
+using namespace std;
+
+class AliJCorrelations;
+class AliJHistos;
+class AliJBaseTrack;
+class AliJCard;
+
+class AliJCorrelations {
+
+public:
+
+ AliJCorrelations( AliJCard *cardIn, AliJHistos *histosIn);
+
+ virtual ~AliJCorrelations(){;} //destructor
+ AliJCorrelations();
+ AliJCorrelations(const AliJCorrelations& in);
+ AliJCorrelations& operator=(const AliJCorrelations& obj);
+
+ void PrintOut(){cout<<"Real correl = "<<fnReal<<" mixed = "<<fnMix<<endl;}
+
+ void FillHisto(corrFillType cFTyp, fillType fTyp, int cBin, int zBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2);
+ void FillAzimuthHistos (fillType fTyp, int cBin, int zBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2);
+
+ double GetGeoAccCorrFlat(double deltaEta);
+ double GetGeoAccCorrIncl(double deltaEta);
+
+ void SetSampligInclusive(){fsamplingMethod = 1;}
+
+
+ double DeltaPhi(double phi1, double phi2);
+
+ //double DeltaPhi(double phi1, double phi2) {
+ // double res = atan2(sin(phi1-phi2), cos(phi1-phi2));
+ // //return res>-kJPi/3.0 ? res : kJTwoPi+res ;
+ // return res > dPhiRange ? res : kJTwoPi+res ;
+ //}
+
+protected:
+
+ AliJCard* fcard; // card
+ AliJHistos* fhistos; // histos
+ int fnReal; // comment me
+ int fnMix; // comment me
+ int fsumTriggerAndAssoc; // comment me
+ int fsamplingMethod; // comment me
+ int fIsHeavyIon; // comment me
+ double fawayPhiGap; // comment me
+ double fDPhiUERegion[2]; // comment me
+ double fRGap[30]; // comment me
+ double fmaxEtaRange; // comment me
+
+ int fRSignalBin; // comment me
+
+ TRandom3 *frandom; // comment me
+
+ double fptt; // pT of the trigger particle in the correlation loop
+ double fpta; // pT ot the asociated particle in the correlation loop
+ double fTrackPairEfficiency; // pair efficiency for the tracks in the correlation loop
+ bool fIsIsolatedTrigger; // Tells whether the trigger is isolated or not
+ int fpttBin; // Bin index for the trigger pT bin
+ int fptaBin; // Bin index for the associated pT bin
+ double fPhiTrigger; // Azimuthal angle of the trigger particle
+ double fPhiAssoc; // Asimuthal angle of the associated particle
+ double fDeltaPhi; // Difference of the azimuthal angles of trigger and associated particles
+ double fDeltaPhiPiPi; // The same as above but measured from -pi to pi
+ double fDeltaEta; // Difference of the pseudorapidities of the trigger and associated particles
+ double fXlong; // The xlong value of the trigger and associated particles
+
+ bool fNearSide; // true if near side correlation, false if away side
+ int fEtaGapBin; // Bin index for the current eta gap
+ int fPhiGapBinNear; // Bin index for the phi gap in the near side
+ int fPhiGapBinAway; // Bin index for the phi gap in the away side
+ int fRGapBinNear; // Bin index for the R gap in the near side
+ int fRGapBinAway; // Bin index for the R gap in the away side
+ int fCentralityBin; // Bin index for the centrality bin
+ int fXlongBin; // Bin index for xlong bin
+
+ double fGeometricAcceptanceCorrection; // Acceptance correction due to the detector geometry
+
+private:
+
+ void FillPairPtAndCosThetaStarHistograms(fillType fTyp, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2);
+ void FillXeHistograms(fillType fTyp);
+ void FillJtHistograms(fillType fTyp, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2, bool fill2DBackground);
+ void FillDeltaEtaHistograms(fillType fTyp, int zBin);
+ void FillDeltaPhiHistograms(fillType fTyp);
+ void FillPtaHistograms(fillType fTyp);
+ void FillIAAAndMoonHistograms(fillType fTyp, int zBin);
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// $Id: AliJDataManager.cxx,v 1.13 2008/02/12 15:51:27 djkim Exp $
+////////////////////////////////////////////////////
+/*!
+ \file AliJDataManager.cxx
+ \brief
+ \author J. Rak, D.J.Kim, B.S Chang (University of Jyvaskyla)
+ \email: djkim@cc.jyu.fi
+ \version $Revision: 1.13 $
+ \date $Date: 2008/02/12 15:51:27 $
+ */
+////////////////////////////////////////////////////
+
+
+#include "AliJDataManager.h"
+
+#include <TH1.h>
+#include <TH2.h>
+#include <TProfile.h>
+#include <TFile.h>
+#include <TTree.h>
+#include <TChain.h>
+#include <TClonesArray.h>
+
+#include "AliJConst.h"
+#include "AliJBaseTrack.h"
+#include "AliJTrack.h"
+#include "AliJMCTrack.h"
+#include "AliJPhoton.h"
+#include "AliJEventHeader.h"
+// TODO #include "AliESDVZERO.h"
+#include "AliJHistos.h"
+
+#include "AliJCard.h"
+#include "AliJEventPool.h"
+
+#include "AliJRunHeader.h"
+#include "AliJCorrelations.h"
+#include "AliJTrackCut.h"
+#include <AliJRunTable.h>
+
+//______________________________________________________________________________
+AliJDataManager::AliJDataManager(AliJCard *inCard, AliJHistos *histin, AliJCorrelations *corrin, Bool_t execLocal ):
+ fChain(NULL),
+ fCard(inCard),
+ fhistos(histin),
+ fcorrelations(corrin),
+ fRunHeader(NULL),
+ fEventHeader(NULL),
+ fEventHeaderList(NULL),
+ fTrackList(NULL),
+ fPhotonList(NULL),
+ fCellList(NULL),
+ fPhotonListRecalib(NULL),
+ fCellListRecalib(NULL),
+ fMCTrackList(NULL),
+ fVZEROData(NULL),
+ fRunInfoList(NULL),
+ fhadronSelectionCut(0),
+ fFilterMap(0),
+ fFName(),
+ fExecLocal(execLocal),
+ fTriggerMask(0),
+ fTrackCut(NULL)
+{
+ // constructor
+ fChain = new TChain("JODTree");
+ fhadronSelectionCut = int(fCard->Get("HadronSelectionCut"));
+
+
+ fTriggerMask = fCard->Get("TriggerMask");
+
+ fTrackCut = new AliJTrackCut;
+}
+
+//______________________________________________________________________________
+AliJDataManager::~AliJDataManager(){
+ // destructor
+ if( fChain ) delete fChain;
+ if( fTrackCut) delete fTrackCut;
+}
+
+//______________________________________________________________________________
+AliJDataManager::AliJDataManager() :
+ fChain(NULL),
+ fCard(NULL),
+ fhistos(NULL),
+ fcorrelations(NULL),
+ fRunHeader(NULL),
+ fEventHeader(NULL),
+ fEventHeaderList(NULL),
+ fTrackList(NULL),
+ fPhotonList(NULL),
+ fCellList(NULL),
+ fPhotonListRecalib(NULL),
+ fCellListRecalib(NULL),
+ fMCTrackList(NULL),
+ fVZEROData(NULL),
+ fRunInfoList(NULL),
+ fhadronSelectionCut(0),
+ fFilterMap(0),
+ fFName(),
+ fExecLocal(true),
+ fTriggerMask(0),
+ fTrackCut(NULL)
+{
+ // default constructor
+}
+
+//______________________________________________________________________________
+AliJDataManager::AliJDataManager(const AliJDataManager& obj) :
+ fChain(obj.fChain),
+ fCard(obj.fCard),
+ fhistos(obj.fhistos),
+ fcorrelations(obj.fcorrelations),
+ fRunHeader(obj.fRunHeader),
+ fEventHeader(obj.fEventHeader),
+ fEventHeaderList(obj.fEventHeaderList),
+ fTrackList(obj.fTrackList),
+ fPhotonList(obj.fPhotonList),
+ fCellList(obj.fCellList),
+ fPhotonListRecalib(obj.fPhotonListRecalib),
+ fCellListRecalib(obj.fCellListRecalib),
+ fMCTrackList(obj.fMCTrackList),
+ fVZEROData(obj.fVZEROData),
+ fRunInfoList(obj.fRunInfoList),
+ fhadronSelectionCut(obj.fhadronSelectionCut),
+ fFilterMap(obj.fFilterMap),
+ fFName(obj.fFName),
+ fExecLocal(obj.fExecLocal),
+ fTriggerMask(obj.fTriggerMask),
+ fTrackCut(obj.fTrackCut)
+{
+ // copy constructor TODO: proper handling of pointer data members
+ JUNUSED(obj);
+}
+
+//______________________________________________________________________________
+AliJDataManager& AliJDataManager::operator=(const AliJDataManager& obj){
+ // equal sign TODO: contents
+ JUNUSED(obj);
+ return *this;
+}
+
+
+//______________________________________________________________________________
+
+bool AliJDataManager::IsGoodEvent(){
+ // event checker
+ if(fEventHeader==NULL) return false;
+ int nContributorVtx = fEventHeader->GetVtxMult();
+ double zVert = fEventHeader->GetZVertex();
+ UInt_t triggermaskJCorran = fEventHeader->GetTriggerMaskJCorran();
+ //double ZVertErr = fEventHeader->GetZVertexErr();
+ bool goodVertex = kFALSE;
+ bool triggerred = (IsSelectedTrigger((int) triggermaskJCorran)); // CUT1
+
+ bool aMB = triggermaskJCorran & ( 1<< kMinBiasTriggerBitJCorran );
+ bool aCentral = triggermaskJCorran & ( 1<<kCentralTriggerBitJCorran );
+ bool aSemiCentral = triggermaskJCorran & ( 1<<kSemiCentralTriggerBitJCorran );
+
+ /*
+ for( int i=0;i<32;i++ ){
+ cout<<(triggermaskJCorran&(1<<i)?1:0)<<" ";
+ }
+ cout<<endl;
+ */
+
+ if( aMB ) fhistos->fhEvents->Fill( 10 );
+ if( aCentral ) fhistos->fhEvents->Fill( 11 );
+ if( aSemiCentral ) fhistos->fhEvents->Fill( 12 );
+ if( aMB || aCentral ) fhistos->fhEvents->Fill( 13 );
+ if( aMB || aCentral || aSemiCentral ) fhistos->fhEvents->Fill( 14 );
+
+ for( int i=0;i < 31 ;i++ ){
+ if( fEventHeader->GetTriggerMaskAlice() & BIT(i) )
+ fhistos->fhEventTrigger->Fill(i);
+ }
+ fhistos->fhEventTrigger->Fill(41);
+
+ /*
+ if(!AliJRunTable::GetInstance().IsHeavyIon()){ //pp data
+ if(fRunHeader->GetRunNumber() >= 146686 && fRunHeader->GetRunNumber() <= 146860){ //p+p 2.76
+ if(!(fEventHeader->GetTriggerMaskAlice() & (1<<13))) triggerred= kFALSE; //noSDD CINT1-B-NOPF-FASTNOTRD
+ // Check with BS again about woSDD
+ }
+ }
+ */
+ // pPb run
+ /*
+ if(AliJRunTable::GetInstance().IsPA()){ //p+Pb
+ if(
+ //(fEventHeader->GetTriggerMaskAlice() & (1<<20)) ) // kINT7 MB
+ ////(fEventHeader->GetTriggerMaskJCorran() & (1<<3)) ) // Emc1Gamma
+ (fEventHeader->GetTriggerMaskJCorran() & (1<<4)) ) // kEMCEJE
+ triggerred= kTRUE; //
+ // Check with BS again about woSDD
+ }
+ */
+ //6 CINT7-B-NOPF-ALLNOTRD
+ //7 CINT7-ACE-NOPF-ALLNOTRD
+ //8 CINT7-A-NOPF-ALLNOTRD
+ //9 CINT7-C-NOPF-ALLNOTRD
+ //17 CEMC7EG1-B-NOPF-ALLNOTRD
+ //18 CEMC7EG2-B-NOPF-ALLNOTRD
+ //19 CEMC7EJ1-B-NOPF-ALLNOTRD
+ //20 CEMC7EJ2-B-NOPF-ALLNOTRD
+
+ //Emc1GammaTriggerBitJCorran
+
+ if(triggerred){
+ fhistos->fhEvents->Fill( 1 );
+ if(nContributorVtx==0){
+ fhistos->fhVertexZTriggVtx->Fill(nContributorVtx,0.);
+ }else{
+ fhistos->fhEvents->Fill( 2 );
+ //cout<<zVert << endl;
+ fhistos->fhZVertRaw->Fill(zVert);
+ //fhistos->fhZVertRawErr->Fill(ZVertErr);
+ fhistos->fhVertexZTriggVtx->Fill(nContributorVtx,zVert);
+ goodVertex = (bool) fCard->VertInZRange(zVert);
+
+ if( goodVertex )
+ fhistos->fhEvents->Fill( 3 );
+ }
+ }
+ //Trigger to be selected from the JCorran trigger mask is specified in the fCard
+ //if(( IsSelectedTrigger((int) triggermaskJCorran )
+ // || ( fCard->MbTrigger((int) triggermaskJCorran ) && fCard->MixMBForPi0Mass() ))
+ if(
+ triggerred
+ && goodVertex ){ //Cut2
+
+ fhistos->fhEvents->Fill( 4 );
+ return true;
+ }else{
+ return false;
+ }
+}
+
+//______________________________________________________________________________
+void AliJDataManager::RegisterList(TClonesArray* listToFill, TClonesArray* listFromToFill,
+ int cBin, int zBin, particleType whatToFill){
+ // corrType whatCorrType){
+
+ // this is here just to silence the bloody rule checker
+ JUNUSED( cBin );
+ JUNUSED( zBin );
+ JUNUSED(listFromToFill);
+ JUNUSED( listToFill );
+
+ int noIn=0, counter=0;
+ // Double_t pid[10]={0};
+ // bool isAliPion = 0;
+ // bool isAliKaon = 0;
+ // bool isAliProton = 0;
+
+ switch (whatToFill) {
+
+ case kPhoton:
+ break;
+ case kPizero:
+ break;
+ case kHadron:
+ noIn = fTrackList->GetEntriesFast();
+ counter = 0;
+ {
+ for(int ii=0;ii<noIn;ii++){ // loop for all tracks
+ AliJTrack *cgl = (AliJTrack*)fTrackList->At(ii);
+ //if(fhadronSelectionCut == kTrackCutJFG || fhadronSelectionCut == kTrackCutHBT) cgl->SetUseTPCTrack();
+
+ // checking bit convention
+ for(int iTrackSelection=0; iTrackSelection<32; iTrackSelection++) {
+ if( cgl->IsFiltered(iTrackSelection) ) fhistos->fhTrackSelection->Fill( iTrackSelection );
+ }
+ for(int iTrackSelection=0; iTrackSelection<32; iTrackSelection++) {
+ if( cgl->TestBit(BIT(iTrackSelection)) ) fhistos->fhTrackSelection->Fill( iTrackSelection+50 );
+ }
+
+ if( 1
+ //&& ( cgl->GetFilterMap() & GetFilterMap() )
+ && fTrackCut->IsSelected( cgl, fhadronSelectionCut )
+ && fTrackCut->SetMomentum( cgl, fhadronSelectionCut )
+ && fCard->IsInEtaRange(cgl->Eta())
+ ){ //
+ cgl->SetID(ii);
+ cgl->SetParticleType(kHadron);
+ new ((*listToFill)[counter++]) AliJTrack(*cgl);
+ }
+ }
+ }
+ break;
+
+ case kProton:
+ noIn = fTrackList->GetEntriesFast();
+ counter = 0;
+ for(int ii=0;ii<noIn;ii++){ // loop for all tracks
+ AliJTrack *cgl = (AliJTrack*)fTrackList->At(ii);
+ Double32_t prob = 0.9;//cgl->GetPID(AliJTrack::kProtonAliJ, AliJTrack::kTPCTOF);
+ //cout << AliJTrack::kProtonAli <<"\t"<< AliJTrack::kTPCTOF <<"\t"<< prob<< endl;
+ //Double32_t prob = cgl->GetPID(AliJTrack::AliJTrkPID(4), AliJTrack::AliJTrkPIDmethod(2));
+ if( 1
+ && fCard->IsInEtaRange(cgl->Eta())
+ && ( cgl->GetFilterMap() & GetFilterMap() )
+ && prob > 0.9
+ ){ // All cuts applied in the Train production stage
+ cgl->SetID(ii);
+ cgl->SetParticleType(kHadron);
+ new ((*listToFill)[counter++]) AliJTrack(*cgl);
+ }
+ }
+ break;
+
+ default :
+ cout<<"Unknown particle type in JDatamenager.cxx/fillList()"<<endl;
+ exit(0);
+ }//switch for PID
+
+ // make the indexing correct
+ listToFill->Compress();
+}
+
+
+//______________________________________________________________________________
+void AliJDataManager::ChainInputStream(const char* infileList){
+ // chainer
+
+ if( fExecLocal ){
+
+ // read root nano data files in a list
+ char inFile[200];
+ ifstream infiles(infileList);
+ while ( infiles >> inFile){
+ fChain->Add(inFile);
+ }
+ //fChain->Print();
+
+ if(fChain->GetEntriesFast()<=0){
+ cout<<"Empty chain from "<<infileList<<endl;
+ exit(0);
+ }
+ cout<<Form("there are %d events.\n", (int)fChain->GetEntries())<<endl;
+
+ // Load Branch
+ if( fChain->FindBranch("HeaderList") )
+ fChain->SetBranchAddress("HeaderList", &fEventHeaderList);
+ if( fChain->FindBranch("TrackList") )
+ fChain->SetBranchAddress("TrackList", &fTrackList);
+ if( fChain->FindBranch("PhotonList") )
+ fChain->SetBranchAddress("PhotonList", &fPhotonList);
+ if( fChain->FindBranch("CaloCellList") )
+ fChain->SetBranchAddress("CaloCellList", &fCellList);
+ if( fChain->FindBranch("MCTrackList") )
+ fChain->SetBranchAddress("MCTrackList", &fMCTrackList);
+
+ if( AliJRunTable::GetInstance().IsHeavyIon() && fChain->FindBranch("AliESDVZERO")) { // if fevent-plane sources were stored
+ fChain->SetBranchAddress("AliESDVZERO", &fVZEROData);
+ // TODO for FMD, TZERO
+ }
+
+ // fChain->SetBranchAddress("AliJMCTrackList", &fMCTrackList);
+ // Event Header
+ //Read Run Header
+ TFile* firstfile = fChain->GetFile();
+ cout<<"============================================DEBUG 10 "<<endl;
+ TList *fUserInfo =(TList*) firstfile->Get("RunInfo");
+ fUserInfo->Print();
+ fRunHeader=(AliJRunHeader*) fUserInfo->First();
+ }
+ else{
+ fRunHeader=(AliJRunHeader*) fRunInfoList->First();
+ }
+
+ if(fRunHeader){
+ fRunHeader->PrintOut();
+ }
+
+}
+
+
+//______________________________________________________________________________
+Double_t AliJDataManager::LoadEvent(int ievt){
+ //clear clones array and counters
+ //load the new fevent
+
+ int v;
+
+ v = 0;
+
+ if( fExecLocal ){
+ //fChain->GetEntry(ievt);
+ TString fp;
+
+ //if( fExperiment == kMC ){
+ // return fMCJDmg->GenerateEvent();
+ //} else {
+ v = ((TTree*)fChain)->GetEntry(ievt);
+
+ fp = fChain->GetCurrentFile()->GetPath();
+ if( fp != fFName ){
+ cout << fp.Data() << endl;
+ fFName = fp;
+ }
+
+ }
+
+ fEventHeader = dynamic_cast<AliJEventHeader*>(fEventHeaderList->At(0));
+
+ return v;
+ //}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// $Id: AliJDataManager.h,v 1.8 2008/02/12 15:51:27 djkim Exp $
+////////////////////////////////////////////////////
+/*!
+ \file AliJDataManager.h
+ \brief
+ \author J. Rak, D.J.Kim, B.S Chang (University of Jyvaskyla)
+ \email: djkim@cc.jyu.fi
+ \version $Revision: 1.8 $
+ \date $Date: 2008/02/12 15:51:27 $
+ */
+////////////////////////////////////////////////////
+
+#ifndef ALIJDATAMANAGER_H
+#define ALIJDATAMANAGER_H
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <TChain.h>
+
+#include "AliJConst.h"
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+
+class TClonesArray;
+class TList;
+class AliJHistos;
+class AliJCard;
+class AliJCorrelations;
+class AliJDataManager;
+class AliJRunHeader;
+class AliJTrackCut;
+//class AliESDVZERO;TODO
+
+
+
+class AliJDataManager {
+
+public:
+ enum { kTrackCutDefault=0, kTrackCutJFG=1, kTrackCutHBT=2, kTrackCutRaa=3, kTrackCutHybrid=4, kTrackCutpp=5 };
+ AliJDataManager(AliJCard *inCard, AliJHistos *fhistos, AliJCorrelations *corrin, Bool_t execLocal);
+
+ virtual ~AliJDataManager(); //destructor
+ AliJDataManager();
+ AliJDataManager(const AliJDataManager& obj);
+ AliJDataManager& operator=(const AliJDataManager& obj);
+
+ void ChainInputStream(const char* infileList);
+ Double_t LoadEvent( int ievt );
+ virtual void RegisterList(TClonesArray* listToFill, TClonesArray* listFromToFill, int cBin, int zBin,
+ particleType whatToFill);
+ // corrType whatCorrType);
+
+ virtual bool IsGoodEvent();
+ void SetRunHeader(AliJRunHeader *runHeader){
+ std::cout<<"DEBUG ########### "<<runHeader<<std::endl;
+ std::cout<<"DEBUG ########### "<<runHeader->GetRunNumber()<<std::endl;
+ fRunHeader = runHeader;
+ }
+
+ // GETTER
+ TChain * GetChain(){ return fChain; };
+ AliJCard * GetCard(){ return fCard; };
+ int GetNEvents(){ return fChain->GetEntries(); }
+ AliJRunHeader *GetRunHeader(){ return fRunHeader; };
+ AliJEventHeader * GetEventHeader(){ return fEventHeader; };
+ TClonesArray *GetEventHeaderList(){ return fEventHeaderList; };
+ TClonesArray *GetTrackList(){ return fTrackList; };
+ TClonesArray *GetPhotonList(){ return fPhotonList; };
+ TClonesArray *GetCellList(){ return fCellList; };
+ TClonesArray *GetPhotonListRecalib(){ return fPhotonListRecalib; };
+ TClonesArray *GetCellListRecalib(){ return fCellListRecalib; };
+ TClonesArray *GetMCTrackList(){ return fMCTrackList; };
+ //AliESDVZERO *GetVZERO(){ return fVZEROData; }
+ TObject *GetVZERO(){ return fVZEROData; }
+
+ void SetExecLocal( const Bool_t b ) { fExecLocal = b; }
+
+ void SetTrackList( TClonesArray *a ) { fTrackList = a; }
+ void SetPhotonList( TClonesArray *a ) { fPhotonList = a; }
+ void SetCaloCellList( TClonesArray *a ) { fCellList = a; }
+ void SetMCTrackList( TClonesArray *a ) { fMCTrackList = a; }
+ void SetHeaderList( TClonesArray *a ) { fEventHeaderList = a; }
+ void SetRunInfoList( TList *a ) { fRunInfoList = a; }
+ void SetESDVZERO( TObject *a ) { fVZEROData = a; }
+ // void SetESDTZERO( AliESDTZERO *a ) { AliESDTZERO = a; }
+ // void SetESDZDC( AliESDZDC *a ) { AliESDZDC = a; }
+
+ UInt_t GetFilterMap() const { return fFilterMap; }
+ void SetFilterMap( UInt_t fm ){ fFilterMap = fm; }
+ void AcceptTrackBit( UInt_t bit ){ SETBIT(fFilterMap, bit); }
+ Bool_t TestTrackBit( int i ){ return TESTBIT( GetFilterMap(), i );}
+
+ Bool_t IsSelectedTrigger(unsigned int triggin ) const { return (triggin & fTriggerMask) >0;}
+
+ protected:
+ TChain * fChain; // comment me
+ AliJCard * fCard; // comment me
+ AliJHistos *fhistos; // comment me
+ AliJCorrelations* fcorrelations; // comment me
+
+ // Alice specific
+ AliJRunHeader *fRunHeader; // comment me
+ AliJEventHeader * fEventHeader; // comment me
+ TClonesArray *fEventHeaderList; // comment me
+ TClonesArray *fTrackList; // comment me
+ TClonesArray *fPhotonList; // comment me
+ TClonesArray *fCellList; // comment me
+ TClonesArray *fPhotonListRecalib; // comment me
+ TClonesArray *fCellListRecalib; // comment me
+ TClonesArray *fMCTrackList; // comment me
+ TObject *fVZEROData; // comment me
+ TList *fRunInfoList; // comment me
+
+ int fhadronSelectionCut; // comment me
+
+ UInt_t fFilterMap; // comment me
+
+ TString fFName; // comment me
+ Bool_t fExecLocal; // comment me
+
+ int fTriggerMask; // Trigger mask;
+
+
+ AliJTrackCut * fTrackCut; // Trigg selection class
+
+
+
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, 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. *
+ **************************************************************************/
+
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+// Fill the analysis containers for ESD or AOD
+// Adapted for AliAnalysisTaskSE and AOD objects
+//////////////////////////////////////////////////////////////////////////////
+
+#include "AliAnalysisTaskSE.h"
+#include "AliAODHandler.h"
+#include "AliAnalysisManager.h"
+#include "AliLog.h"
+
+#include "AliJDiHadronCorrTask.h"
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+#include "AliJCORRANTask.h"
+#include "AliJCard.h"
+
+//______________________________________________________________________________
+AliJDiHadronCorrTask::AliJDiHadronCorrTask() :
+ AliAnalysisTaskSE("AliJDiHadronCorrTaskTask"),
+ fFilterTask(NULL),
+ fFilterTaskName(""),
+ fJCORRAN(0x0),
+ fOutput(NULL)
+{
+ DefineOutput (1, TDirectory::Class());
+}
+
+//______________________________________________________________________________
+AliJDiHadronCorrTask::AliJDiHadronCorrTask(const char *name, TString inputformat):
+ AliAnalysisTaskSE(name),
+ fFilterTask(NULL),
+ fFilterTaskName(""),
+ fJCORRAN(0x0),
+ fOutput(NULL)
+{
+ // Constructor
+ AliInfo("---- AliJDiHadronCorrTask Constructor ----");
+
+ JUNUSED(inputformat);
+ DefineOutput (1, TDirectory::Class());
+}
+
+//____________________________________________________________________________
+AliJDiHadronCorrTask::AliJDiHadronCorrTask(const AliJDiHadronCorrTask& ap) :
+ AliAnalysisTaskSE(ap.GetName()),
+ fFilterTask(ap.fFilterTask),
+ fFilterTaskName(ap.fFilterTaskName),
+ fJCORRAN( ap.fJCORRAN ),
+ fOutput( ap.fOutput )
+{
+
+ AliInfo("----DEBUG AliJDiHadronCorrTask COPY ----");
+
+}
+
+//_____________________________________________________________________________
+AliJDiHadronCorrTask& AliJDiHadronCorrTask::operator = (const AliJDiHadronCorrTask& ap)
+{
+ // assignment operator
+
+ AliInfo("----DEBUG AliJDiHadronCorrTask operator= ----");
+ this->~AliJDiHadronCorrTask();
+ new(this) AliJDiHadronCorrTask(ap);
+ return *this;
+}
+
+//______________________________________________________________________________
+AliJDiHadronCorrTask::~AliJDiHadronCorrTask()
+{
+ // destructor
+
+ delete fJCORRAN;
+
+}
+
+//________________________________________________________________________
+
+void AliJDiHadronCorrTask::UserCreateOutputObjects()
+{
+ //=== create the jcorran outputs objects
+ if(fDebug > 1) printf("AliJDiHadronCorrTask::UserCreateOutPutData() \n");
+
+ //=== Get AnalysisManager
+ AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
+ if(!man->GetOutputEventHandler()) {
+ Fatal("UserCreateOutputObjects", "This task needs an AOD handler");
+ return;
+ }
+
+ fFilterTask = (AliJCORRANTask*)(man->GetTask( fFilterTaskName ));
+
+ OpenFile(1);
+ fOutput = gDirectory;//->mkdir("JDiHadronCorr");
+ fOutput->cd();
+
+ // Order should be kept
+ // TODO : better implementation
+ //bool orignalTH1AdddirectoryStatus=TH1::AddDirectoryStatus();
+ // TODO Why?
+ //TH1::AddDirectory(kTRUE);
+ //if( !orignalTH1AdddirectoryStatus ) cout<<"DEBUG :: TH1::AddDirectory is turned on"<<endl;
+ fJCORRAN->SetRunHeader( fFilterTask->GetJRunHeader() );//TODO
+ fJCORRAN->UserCreateOutputObjects();
+ fJCORRAN->SetHeaderList(fFilterTask->GetFilter()->GetHeaderList() );
+ fJCORRAN->SetTrackList( fFilterTask->GetFilter()->GetTrackList() );
+ fJCORRAN->SetMCTrackList( fFilterTask->GetFilter()->GetMCTrackList() );
+ fJCORRAN->GetCard()->WriteCard(fOutput);
+
+ PostData( 1, fOutput );
+ //TH1::AddDirectory( orignalTH1AdddirectoryStatus );
+ //cout<<"DEBYG :: TH1::AddDirectory get orignal Value = "<<( orignalTH1AdddirectoryStatus?"True":"False" )<<endl;
+
+ cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl;
+
+}
+
+//______________________________________________________________________________
+void AliJDiHadronCorrTask::UserExec(Option_t* /*option*/)
+{
+
+ // Processing of one event
+ if(fDebug > 5) cout << "------- AliJDiHadronCorrTask Exec-------"<<endl;
+ //if(!((Entry()-1)%100)) cout << Form(" Processing event # %lld", Entry()) << endl;
+
+
+ //cout << "AliJDiHadronCorrTask::UserExec fFilterTask->GetFilter()->GetEventSuccess() = " << fFilterTask->GetFilter()->GetEventSuccess() << endl;
+ if( fFilterTask->GetFilter()->GetEventSuccess() ){
+ fJCORRAN->UserExec();
+ PostData(1, fOutput );
+ }
+
+
+ if(fDebug > 5) cout << "\t------- End UserExec "<<endl;
+}
+
+//______________________________________________________________________________
+void AliJDiHadronCorrTask::Init()
+{
+ // Intialisation of parameters
+ AliInfo("Doing initialization") ;
+ fJCORRAN->Init();
+}
+
+//______________________________________________________________________________
+void AliJDiHadronCorrTask::Terminate(Option_t *)
+{
+
+ fJCORRAN->Terminate();
+ OpenFile(1);
+ fOutput->cd();
+
+ cout<<"# Write Data "<<endl;
+ //write Trigg ID and Assoc ID
+ fOutput->Write(0,TObject::kOverwrite);
+ PostData(1,fOutput);
+ cout<<"AliJDiHadronCorrTask Analysis DONE !!"<<endl;
+
+}
--- /dev/null
+#ifndef ALIJDIHADRONCORRTASK_H
+#define ALIJDIHADRONCORRTASK_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+//
+// Fill the analysis containers for ESD or AOD
+// Note: Adapted for AliAnalysisTaskSE
+//////////////////////////////////////////////////////////////////////////////
+
+
+#include "AliAnalysisTaskSE.h"
+#include "AliJCORRAN.h"
+
+class AliJCORRANTask;
+//==============================================================
+
+using namespace std;
+
+class AliJDiHadronCorrTask : public AliAnalysisTaskSE {
+
+ public:
+ AliJDiHadronCorrTask();
+ AliJDiHadronCorrTask(const char *name, TString inputformat);
+ AliJDiHadronCorrTask(const AliJDiHadronCorrTask& ap);
+ AliJDiHadronCorrTask& operator = (const AliJDiHadronCorrTask& ap);
+ virtual ~AliJDiHadronCorrTask();
+
+ // methods to fill from AliAnalysisTaskSE
+ virtual void UserCreateOutputObjects();
+ virtual void Init();
+ virtual void LocalInit() { Init(); }
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t *);
+ virtual Bool_t UserNotify() { std::cout<<"DEBUG UserNotify"<<std::endl; return kTRUE;}
+
+ void SetFilterTaskName(TString name){ fFilterTaskName=name; }
+ void SetJCORRAN(AliJCORRAN * jco){ fJCORRAN=jco; }
+
+ private:
+
+ AliJCORRANTask * fFilterTask;
+ TString fFilterTaskName;
+ AliJCORRAN * fJCORRAN;
+ TDirectory * fOutput;
+
+ ClassDef(AliJDiHadronCorrTask, 1);
+};
+#endif // AliJDiHadronCorrTask_H
--- /dev/null
+#include "AliJEfficiency.h"
+#include <TSystem.h>
+#include <iostream>
+
+// AliJEfficiency
+// ...
+// ...
+// ...
+// ...
+// TODO
+
+using namespace std;
+
+AliJEfficiency::AliJEfficiency():
+ fMode(kAuto),
+ fPeriod(-1),
+ fTrackCut(),
+ fRunTable(),
+ fDataPath("$ALICE_ROOT/PWGCF/Correlations/macros/jcorran"),
+ fName(""),
+ fPeriodStr(""),
+ fMCPeriodStr(""),
+ fRunNumber(0),
+ fTag(""),
+ fInputRootName(""),
+ fInputRoot(NULL),
+ fCentBin(0x0)
+{
+
+}
+
+AliJEfficiency::AliJEfficiency(const AliJEfficiency& obj) :
+ fMode(obj.fMode),
+ fPeriod(obj.fPeriod),
+ fTrackCut(obj.fTrackCut),
+ fRunTable(obj.fRunTable),
+ fDataPath(obj.fDataPath),
+ fName(obj.fName),
+ fPeriodStr(obj.fPeriodStr),
+ fMCPeriodStr(obj.fMCPeriodStr),
+ fRunNumber(obj.fRunNumber),
+ fTag(obj.fTag),
+ fInputRootName(obj.fInputRootName),
+ fInputRoot(obj.fInputRoot),
+ fCentBin(obj.fCentBin)
+{
+ // copy constructor TODO: handling of pointer members
+ JUNUSED(obj);
+}
+
+AliJEfficiency& AliJEfficiency::operator=(const AliJEfficiency& obj){
+ // equal sign operator TODO: content
+ JUNUSED(obj);
+ return *this;
+}
+
+TString AliJEfficiency::GetEffName() {
+ /*
+ 1. kNotUse : no Load, efficiency is 1 always
+ 2. has fInputRootName : Load that or crash
+ 3. has fName : Load fName [+runnumber] or crash
+ 4. has runnumber : Find Good MC period from AliJRunTable, or crash
+ 3. has period : Find Good MC period from AliJRunTable, or crash
+
+*/
+ if( fMode == kNotUse ) {
+ cout<<"J_WARNING : Eff Mode is \"NOTUSE\". eff is 1 !!!"<<endl;
+ return "";
+ }
+
+ //==== 1. fInputRootName
+ //==== 2. Eff-fName-fPeriod-fMCPeriod-fRunNumber-fTag.root
+ if( fInputRootName.Length() == 0 ){
+
+ //==== SELECT Period : fPeriod, fPeriodStr
+ // 1. Use fPeriodStr if it is
+ // 2. Use fPeriod if it is
+ // 3. Use RunNumber
+ if( fPeriodStr.Length() == 0 ){
+ if( fRunNumber > 0 && fPeriod < 0 ) {
+ fPeriod = fRunTable.GetRunNumberToPeriod( fRunNumber );
+ }
+ fPeriodStr = fRunTable.GetPeriodName( fPeriod );
+ }
+ //==== Select McPeriod
+ //==== 1. Use fMCPeriodStr
+ //==== 2. Use fPeriod
+ if( fMCPeriodStr.Length() == 0 ){
+ fMCPeriodStr = fRunTable.GetMCPeriod( fPeriod );
+ }
+ //==== Select fRunNumber
+ //==== MODE 1 : runnumber = 0;
+ if( fMode == kPeriod ) fRunNumber = 0;
+ else if( fRunNumber < 0 ){
+ cout<< "J_ERROR : Runumber must be >=0. Input runnumber is "<<fRunNumber<<endl;
+ gSystem->Exit(1);
+ }
+
+ fInputRootName = Form("Eff-%s-%s-%s-%d-%s.root", fName.Data(), fPeriodStr.Data(), fMCPeriodStr.Data(), int(fRunNumber), fTag.Data() );
+ }
+
+ return fInputRootName;
+}
+
+TString AliJEfficiency::GetEffFullName() {
+ GetEffName();
+ fInputRootName = fDataPath + "/" + fInputRootName;
+ return fInputRootName;
+}
+
+
+bool AliJEfficiency::Load(){
+ // Load Efficiency File based on fMode
+ if( fMode == kNotUse ) {
+ cout<<"J_WARNING : Eff Mode is \"NOTUSE\". eff is 1 !!!"<<endl;
+ return true;
+ }
+ GetEffFullName();
+ fInputRoot = new TFile( fInputRootName,"READ");
+ if( !fInputRoot ) {
+ cout<< "J_ERROR : "<<fInputRootName <<" is not exist"<<endl;
+ gSystem->Exit(1);
+ }
+
+ //fEffDir[0] = (TDirectory*)fInputRoot->Get("EffRE");
+ ///fEffDir[1] = (TDirectory*)fInputRoot->Get("EffMC");
+ fEffDir[2] = (TDirectory*)fInputRoot->Get("Efficiency");
+ //iif( fEffDir[0] && fEffDir[1] && fEffDir[2] )
+ if( !fEffDir[2] )
+ {
+ cout<< "J_ERROR : Directory EFF is not exist"<<endl;
+ gSystem->Exit(1);
+ }
+
+ fCentBin = (TAxis*)fEffDir[2]->Get("CentralityBin");
+ if( !fCentBin ){
+ cout<< "J_ERROR : No CentralityBin in directory"<<endl;
+ gSystem->Exit(1);
+ }
+
+
+ int nVtx = 1;
+ int nCentBin = fCentBin->GetNbins();
+ for( int ivtx=0;ivtx<nVtx;ivtx++ ){
+ for( int icent=0;icent<nCentBin;icent++ ){
+ for( int icut=0;icut<fTrackCut.GetNCut();icut++ ){
+ fCorrection[ivtx][icent][icut]
+ = (TGraphErrors*) fEffDir[2]->Get(Form("gCor%02d%02d%02d", ivtx,icent,icut));
+ //cout<<"J_LOG : Eff graph - "<<Form("gCor%02d%02d%02d", ivtx,icent,icut)<<" - "<<g<<endl;
+ }
+ }
+ }
+ cout<<"J_LOG : Eff file is "<<fInputRootName<<endl;
+ cout<<"J_LOG : Eff Cent Bins are ";
+ for( int i=0;i<=nCentBin;i++ ){
+ cout<<fCentBin->GetXbins()->At(i)<<" ";
+ }
+ cout<<endl;
+ return true;
+}
+
+double AliJEfficiency::GetCorrection( double pt, int icut , double cent ) const {
+ // TODO : Function mode
+ if( fMode == kNotUse ) return 1;
+ int icent = fCentBin->FindBin( cent ) -1 ;
+ if( icent < 0 || icent > fCentBin->GetNbins()-1 ) {
+ cout<<"J_WARNING : Centrality "<<cent<<" is out of CentBinBorder"<<endl;
+ return 1;
+ }
+ // TODO error check for icent;
+ int ivtx = 0;
+ if( ! fCorrection[ivtx][icent][icut] ) {
+ cout<<"J_WARNING : No Eff Info "<<pt<<"\t"<<icut<<"\t"<<cent<<"\t"<<icent<<endl;
+ return 1;
+ }
+ TGraphErrors * gr = fCorrection[ivtx][icent][icut];
+ //=== TEMPERORY SETTING. IT will be removed soon.
+ if( pt > 30 ) pt = 30; // Getting eff of 30GeV for lager pt
+ double cor = gr->Eval(pt);
+ if ( cor < 0.2 ) cor = 0.2;
+ return cor;
+}
+
+void AliJEfficiency::Write(){
+ // Write Efficiency information to root file
+ if( fMode == kNotUse ){
+ cout<<"J_LOG : Efficiency mode is \"NotUse\", nothing will be Written" <<endl;
+ return;
+ }
+ cout<<"J_LOG : Efficiency Write to "<<gDirectory->GetName()<<endl;
+ TDirectory *cwd = gDirectory;
+ TDirectory *eff = gDirectory->mkdir("Efficiency");
+ eff->cd();
+ int nVtx = 1;
+ int nCentBin = fCentBin->GetNbins();
+ cout<<nCentBin<<endl;
+ for( int ivtx=0;ivtx<nVtx;ivtx++ ){
+ for( int icent=0;icent<nCentBin;icent++ ){
+ for( int icut=0;icut<fTrackCut.GetNCut();icut++ ){
+ cout<<fCorrection[ivtx][icent][icut]<<endl;
+ if( !fCorrection[ivtx][icent][icut]) continue;
+ fCorrection[ivtx][icent][icut]->Write(Form("gCor%02d%02d%02d", ivtx,icent,icut));
+ }
+ }
+ }
+ fCentBin->Write("CentralityBin");
+ cwd->cd();
+}
+
--- /dev/null
+#ifndef ALIJEFFICIENCY_H
+#define ALIJEFFICIENCY_H
+// Class to Load and Get efficiency inforamtion
+// ..
+// TODO
+
+#include <TString.h>
+#include <TFile.h>
+#include "AliJTrackCut.h"
+#include "AliJRunTable.h"
+#include "AliJConst.h"
+#include <TGraphErrors.h>
+#include <TAxis.h>
+#include <iostream>
+using namespace std;
+
+class AliJEfficiency{
+ public:
+ enum Mode { kNotUse, kPeriod, kRunNumber, kAuto };
+ enum Type { kRE, kMC, kMerge };
+ AliJEfficiency();
+ AliJEfficiency(const AliJEfficiency& obj);
+ AliJEfficiency& operator=(const AliJEfficiency& obj);
+
+ void SetMode( int i ){ fMode = i; }
+
+ void SetDataPath(TString s ){ fDataPath=s; }
+ void SetEffFile(TString s ){ fInputRootName=s; }
+ void SetName(TString s ){ fName=s; }
+ void SetPeriod(int period){ fPeriod = period; }
+ void SetPeriod(TString s){ fPeriodStr = s; }
+ void SetMCPeriod(TString s){ fMCPeriodStr = s; }
+ void SetRunNumber( Long64_t runnum ){ fRunNumber=runnum; }
+ void SetTag(TString s){ fTag=s; }
+
+ TString GetName() const { return fName; }
+ double GetCorrection( double pt, int icut, double cent ) const ;
+ TString GetEffName() ;
+ TString GetEffFullName() ;
+ bool Load();
+ void PrintOut() const {
+ cout<<fInputRootName<<endl;
+ }
+ void Write();
+
+ private:
+ int fMode; // Mode. see enum Mode
+ int fPeriod; // Data Period index
+ AliJTrackCut fTrackCut; // Track Cut Object. TODO:why not pointer?
+ AliJRunTable fRunTable; // run Table. TODO:why not pointer?
+
+ TString fDataPath; // locaction of eff files
+ TString fName; // name of efficiency. usually empty
+ TString fPeriodStr; // DATA period
+ TString fMCPeriodStr; // MC period
+ Long64_t fRunNumber; // Runnumber
+ TString fTag; // Tags to distinguish special eff file
+ TString fInputRootName; // name of input
+
+ TFile * fInputRoot; // input file
+ TDirectory * fEffDir[3]; // root directory of efficiency. only fEffDir[2] with "Efficiency" is being used.
+ TGraphErrors * fCorrection[20][20][20]; // Storage of Correction factor
+ TAxis * fCentBin; // Bin of Centrality. replace with AliJBin?
+};
+#endif
--- /dev/null
+//
+//#include <Riostream.h>
+// #include <TChain.h>
+// #include <TVectorT.h>
+// #include <TVector3.h>
+// #include <TFile.h>
+// #include <TH1.h>
+// #include <TObjArray.h>
+// #include <TObjString.h>
+// #include <TFormula.h>
+// #include <TString.h>
+// #include <TRefArray.h>
+// #include <TNtuple.h>
+// #include <TArrayF.h>
+
+#include <TClonesArray.h>
+#include <TH1D.h>
+#include <TH2D.h>
+
+#include "AliJEfficiencyScanner.h"
+#include "AliJTrack.h"
+#include "AliJMCTrack.h"
+#include "AliJPhoton.h"
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+#include <TFile.h>
+#include <TRandom.h>
+
+
+ClassImp(AliJEfficiencyScanner);
+
+//______________________________________________________________________________
+AliJEfficiencyScanner::AliJEfficiencyScanner() :
+ TNamed(),
+ fTrackList(0),
+ fMCTrackList(0x0),
+ fEventHeader(0x0),
+ fRunHeader(0x0),
+ fhVertexZMC(0x0),
+ fhVertexZTrigg(0x0),
+ fhVertexZTriggVtx(0x0),
+ fhVZRawMC(0x0),
+ fhVZRecMC(0x0),
+ fhVZRecAccMC(0x0),
+ fh2VtxCent(0x0),
+ fhL0Input(0x0),
+ fhTriggerAlice(0x0),
+ fhZVtxMCAll(0x0),
+ fhZVtxMCTrigg(0x0),
+ fhZVtxMCTriggVtx(0x0),
+ fhZVtxRecAll(0x0),
+ fhZVtxRecTrigg(0x0),
+ fhZVtxRecTriggVtx(0x0),
+ fVtxReFunc(0x0),
+ fVtxMCFunc(0x0),
+ fVtxRatioFunc(0x0),
+ fVtxRatioMax(1)
+{
+ //Default constructor
+ for( int ivtx=0;ivtx<kNVtxBin;ivtx++ ){
+ for( int icent=0;icent<kNCentBin;icent++ ){
+ fhChargedPtMCTriggVtx[ivtx][icent] = 0x0;
+ for( int ifilter=0;ifilter<AliJTrackCut::kJNTrackCuts;ifilter++ ){
+ for( int ipri=0;ipri<kNPrimaryStatus;ipri++ ){
+ for( int itt=0;itt<kNTrackType;itt++ ){
+ fhChargedPtMCRecoCentVtx[ivtx][icent][ifilter][ipri][itt] = 0x0;
+ }
+ }
+ }
+ }
+ }
+
+}
+
+//______________________________________________________________________________
+AliJEfficiencyScanner::AliJEfficiencyScanner(const char *name):
+ TNamed(name,name),
+ fTrackList(0),
+ fMCTrackList(0x0),
+ fEventHeader(0x0),
+ fRunHeader(0x0),
+ fhVertexZMC(0x0),
+ fhVertexZTrigg(0x0),
+ fhVertexZTriggVtx(0x0),
+ fhVZRawMC(0x0),
+ fhVZRecMC(0x0),
+ fhVZRecAccMC(0x0),
+ fh2VtxCent(0x0),
+ fhL0Input(0x0),
+ fhTriggerAlice(0x0),
+ fhZVtxMCAll(0x0),
+ fhZVtxMCTrigg(0x0),
+ fhZVtxMCTriggVtx(0x0),
+ fhZVtxRecAll(0x0),
+ fhZVtxRecTrigg(0x0),
+ fhZVtxRecTriggVtx(0x0),
+ fVtxReFunc(0x0),
+ fVtxMCFunc(0x0),
+ fVtxRatioFunc(0x0),
+ fVtxRatioMax(1)
+{
+ // Constructor
+ for( int ivtx=0;ivtx<kNVtxBin;ivtx++ ){
+ for( int icent=0;icent<kNCentBin;icent++ ){
+ fhChargedPtMCTriggVtx[ivtx][icent] = 0x0;
+ for( int ifilter=0;ifilter<AliJTrackCut::kJNTrackCuts;ifilter++ ){
+ for( int ipri=0;ipri<kNPrimaryStatus;ipri++ ){
+ for( int itt=0;itt<kNTrackType;itt++ ){
+ fhChargedPtMCRecoCentVtx[ivtx][icent][ifilter][ipri][itt] = 0x0;
+ }
+ }
+ }
+ }
+ }
+}
+
+//____________________________________________________________________________
+AliJEfficiencyScanner::AliJEfficiencyScanner(const AliJEfficiencyScanner& ap) :
+ TNamed(ap.GetName(), ap.GetTitle()),
+ fTrackList(ap.fTrackList),
+ fMCTrackList(ap.fMCTrackList),
+ fEventHeader( ap.fEventHeader ),
+ fRunHeader(ap.fRunHeader),
+ fhVertexZMC(ap.fhVertexZMC),
+ fhVertexZTrigg(ap.fhVertexZTrigg),
+ fhVertexZTriggVtx(ap.fhVertexZTriggVtx),
+ fhVZRawMC(ap.fhVZRawMC),
+ fhVZRecMC(ap.fhVZRecMC),
+ fhVZRecAccMC(ap.fhVZRecAccMC),
+ fh2VtxCent(ap.fh2VtxCent),
+ fhL0Input(ap.fhL0Input),
+ fhTriggerAlice(ap.fhTriggerAlice),
+ fhZVtxMCAll(ap.fhZVtxMCAll),
+ fhZVtxMCTrigg(ap.fhZVtxMCTrigg),
+ fhZVtxMCTriggVtx(ap.fhZVtxMCTriggVtx),
+ fhZVtxRecAll(ap.fhZVtxRecAll),
+ fhZVtxRecTrigg(ap.fhZVtxRecTrigg),
+ fhZVtxRecTriggVtx(ap.fhZVtxRecTriggVtx),
+ fVtxReFunc(ap.fVtxReFunc),
+ fVtxMCFunc(ap.fVtxMCFunc),
+ fVtxRatioFunc(ap.fVtxRatioFunc),
+ fVtxRatioMax(ap.fVtxRatioMax)
+{
+ // cpy ctor
+ for( int ivtx=0;ivtx<kNVtxBin;ivtx++ ){
+ for( int icent=0;icent<kNCentBin;icent++ ){
+ fhChargedPtMCTriggVtx[ivtx][icent] = ap.fhChargedPtMCTriggVtx[ivtx][icent];
+ for( int ifilter=0;ifilter<AliJTrackCut::kJNTrackCuts;ifilter++ ){
+ for( int ipri=0;ipri<kNPrimaryStatus;ipri++ ){
+ for( int itt=0;itt<kNTrackType;itt++ ){
+ fhChargedPtMCRecoCentVtx[ivtx][icent][ifilter][ipri][itt] = ap.fhChargedPtMCRecoCentVtx[ivtx][icent][ifilter][ipri][itt];
+ }
+ }
+ }
+ }
+ }
+
+}
+
+//_____________________________________________________________________________
+AliJEfficiencyScanner& AliJEfficiencyScanner::operator = (const AliJEfficiencyScanner& ap)
+{
+ // assignment operator
+
+ this->~AliJEfficiencyScanner();
+ new(this) AliJEfficiencyScanner(ap);
+ return *this;
+}
+
+//______________________________________________________________________________
+AliJEfficiencyScanner::~AliJEfficiencyScanner()
+{
+ // destructor
+}
+
+//________________________________________________________________________
+
+void AliJEfficiencyScanner::UserCreateOutputObjects()
+{
+ //=== create the jcorran outputs objects
+ cout<<"DEBUG Start AliJEfficiencyScanner::UserCreateOutputObjects() "<<"\t"<<gDirectory<<endl;
+
+ double ptbin[300] = {0};
+ double pt = 0;
+ int i = 0;
+ for( i=0;i<300;i++ ){
+ ptbin[i] = pt;
+ if( pt > 50 ) break;
+ if( pt < 3 ) pt+= 0.05;
+ else if( pt < 5 ) pt+= 0.1;
+ else if( pt < 10 ) pt+= 1;
+ else pt+= 1;
+ }
+ cout<<"n Ptbin = "<<i<<endl;
+ int nPtBin = i-1;
+
+ fh2VtxCent = new TH2D("h2VtxCent","h2VtxCent",100,0,10,110,0,110 );
+ fh2VtxCent->SetDirectory(gDirectory);
+
+ int nVtxBin = kNVtxBin;
+ int nCentBin = kNCentBin;
+ if( fRunHeader->IsPP() ) nCentBin = 1;
+
+ TString name ="";
+ for( int ivtx=0;ivtx<nVtxBin;ivtx++ ){
+ for( int icent=0;icent<nCentBin;icent++ ){
+ fhChargedPtMC[ivtx][icent] = AddTH1D( Form("hChargedPtMC%02d%02d",ivtx,icent),
+ new TH1D("","", nPtBin, ptbin) );
+ fhChargedPtMCTriggVtx[ivtx][icent]=AddTH1D(
+ Form("hChargedPtMCTriggVtx%02d%02d", ivtx, icent ),
+ new TH1D("", "", nPtBin, ptbin) );
+ fhChargedPtMCTrigg[ivtx][icent]=AddTH1D(
+ Form("hChargedPtMCTrigg%02d%02d", ivtx, icent ),
+ new TH1D("", "", nPtBin, ptbin) );
+ //for any MC track filled with MC pt in triggered event
+ name = Form("h2DChargedPtTrigg%02d%02d",ivtx,icent);
+ fh2DChargedPtTrigg[ivtx][icent]=AddTH2D(name, new TH2D(name,name, nPtBin, ptbin, 20, -0.8, 0.8));
+ //for any MC track filled with MC pt in triggered event with rec vertex
+ name = Form("h2DChargedPtTriggVtx%02d%02d",ivtx,icent);
+ fh2DChargedPtTriggVtx[ivtx][icent]=AddTH2D(name, new TH2D(name,name, nPtBin, ptbin, 20, -0.8, 0.8));
+
+ }
+ }
+ fhTriggerAlice = AddTH1D("hTriggerAlice",new TH1D("","",32,0,32));
+ fhL0Input = AddTH1D("hL0Input",new TH1D("","",32,0,32));
+ // DCA bin
+ double dcaBin[1000];
+ double dbin=-50-1;
+ int ndbin = 0;
+ dcaBin[0] = dbin;
+ double tol = 1e-5;
+ while(dbin < 50-1){
+ if( fabs(dbin) < 2-tol ) dbin+=0.01;
+ else if( fabs(dbin) < 5-tol ) dbin+= 0.05;
+ else if( fabs(dbin) <= 10-tol ) dbin+= 0.1;
+ else dbin += 1;
+ if( fabs(dbin) < tol ) dbin=0;
+ dcaBin[ndbin++] = dbin;
+ }
+
+ for( int ivtx=0;ivtx<nVtxBin;ivtx++ ){
+ for( int icent=0;icent<nCentBin;icent++ ){
+ for( int ifilter=0;ifilter<AliJTrackCut::kJNTrackCuts;ifilter++ ){
+
+ name = Form("h2DChargedPtAll%02d%02d%02d",ivtx,icent,ifilter);
+ fh2DChargedPtAll[ivtx][icent][ifilter]=AddTH2D(name, new TH2D(name,name, nPtBin, ptbin, 20, -0.8, 0.8));
+ name = Form("h2DChargedPtRec%02d%02d%02d",ivtx,icent,ifilter);
+ fh2DChargedPtRec[ivtx][icent][ifilter]=AddTH2D(name, new TH2D(name,name, nPtBin, ptbin, 20, -0.8, 0.8));
+ for( int ipri=0;ipri<kNPrimaryStatus;ipri++ ){
+ for( int itt=0;itt<kNTrackType;itt++ ){
+ name = Form("hChargedPtMCRecoCentVtx%02d%02d%02d%02d%02d", ivtx, icent, ifilter, ipri, itt );
+ fhChargedPtMCRecoCentVtx[ivtx][icent][ifilter][ipri][itt]=AddTH1D(name, new TH1D( name, name, nPtBin, ptbin));
+ }
+ }
+ name = Form("hDCA2VertexXY%02d%02d%02d", ivtx, icent, ifilter );
+ fhDCA2VertexXY[ivtx][icent][ifilter] = AddTH1D(name, new TH1D("","",ndbin-1, dcaBin ));
+ name = Form("hDCA2VertexZ%02d%02d%02d", ivtx, icent, ifilter );
+ fhDCA2VertexZ[ivtx][icent][ifilter] = AddTH1D( name, new TH1D("","",ndbin-1, dcaBin ));
+
+ }
+ }
+ }
+// TH2D * fh2MultGenRawPrimary[AliJTrackCut::kJNTrackCuts];
+// TH2D * fh2MultGenRawAll[AliJTrackCut::kJNTrackCuts];
+
+// TH1D * fhDCA2VertexXY[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts];
+ for( int ifilter=0;ifilter<AliJTrackCut::kJNTrackCuts;ifilter++ ){
+ name = Form("h2MultGenRawPrimary%02d", ifilter);
+ fh2MultGenRawPrimary[ifilter] = AddTH2D( name, new TH2D(name, name, 100,0,100,100,0,100 ));
+ name = Form("h2MultGenRawAll%02d", ifilter);
+ fh2MultGenRawAll[ifilter] = AddTH2D( name, new TH2D(name, name, 100,0,100,100,0,100 ));
+ }
+ 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;
+ fhVertexZMC = AddTH2D("hVertexZMC",new TH2D("hVertexZMC","hVertexZMC", NbinsVertexMult, binsVertexMult, NbinsVertexZ, binsVertexZ));
+ fhVertexZTrigg = AddTH2D("hVertexZTrigg",new TH2D("hVertexZTrigg","hVertexZTrigg", NbinsVertexMult, binsVertexMult, NbinsVertexZ, binsVertexZ));
+ fhVertexZTriggVtx = AddTH2D("hVertexZTriggVtx",new TH2D("hVertexZTriggVtx","hVertexZTriggVtx", NbinsVertexMult, binsVertexMult, NbinsVertexZ, binsVertexZ));
+ fhVZRawMC = AddTH1D("hVtxZMC", new TH1D("hVtxZMC","VertexZ in MC ",200,-50,50));
+ fhVZRecMC = AddTH1D("hVtxZRec", new TH1D("hVtxZRec","VertexZ Rec in MC",200,-50,50));
+ fhVZRecAccMC = AddTH1D("hVtxZRecAcc", new TH1D("hVtxZRecAcc","VertexZ Rec in MC and acc",200,-50,50));
+
+ int NvtxBins = 400;
+ double vtxedge = 50;
+ fhZVtxMCAll = AddTH1D("hZVtxMCAll", new TH1D("hZVtxMCAll","VetrexZ in MC for all event",NvtxBins, -vtxedge, vtxedge ));
+ fhZVtxMCTrigg = AddTH1D("hZVtxMCTrigg", new TH1D("hZVtxMCTrigg","VetrexZ in MC for triggered event",NvtxBins, -vtxedge, vtxedge ));
+ fhZVtxMCTriggVtx = AddTH1D("hZVtxMCTriggVtx", new TH1D("hZVtxMCTriggVtx","VetrexZ in MC for triggered and vtx reconstructed event",NvtxBins, -vtxedge, vtxedge ));
+
+ fhZVtxRecAll = AddTH1D("hZVtxRecAll", new TH1D("hZVtxRecAll","VetrexZ in Rec for all event",NvtxBins, -vtxedge, vtxedge ));
+ fhZVtxRecTrigg = AddTH1D("hZVtxRecTrigg", new TH1D("hZVtxRecTrigg","VetrexZ in Rec for triggered event",NvtxBins, -vtxedge, vtxedge ));
+ fhZVtxRecTriggVtx = AddTH1D("hZVtxRecTriggVtx", new TH1D("hZVtxRecTriggVtx","VetrexZ in Rec for triggered and vtx reconstructed event",NvtxBins, -vtxedge, vtxedge ));
+
+ double v0 = -20;
+ double v1 = 20;
+ fVtxReFunc = new TF1("VtxReFunc", "gaus",v0,v1);
+ fVtxReFunc->SetParameters(1 , -7.14076e-01, 6.27110 );
+ fVtxMCFunc = new TF1("VtxMCFunc", "gaus",v0,v1);
+ fVtxMCFunc->SetParameters(1, -4.53674e-01, 5.27088e+00 );
+ fVtxRatioFunc = new TF1("VtxRatioFunc", "VtxReFunc/VtxMCFunc",v0,v1);
+ fVtxRatioMax = fVtxRatioFunc->GetMaximum();
+
+
+
+ cout << "Add(fAliJRunHeader) in UserCreateObject() ======= " << endl;
+ cout<<"DEBUG END AliJEfficiencyScanner::UserCreateOutputObjects() "<<endl;
+
+}
+
+//______________________________________________________________________________
+
+void AliJEfficiencyScanner::UserExec(Option_t *option)
+{
+
+ // Main loop
+ // Called for each event
+ JUNUSED(option);
+
+ double zVtxCut = 10;
+ double etaCut = 0.8;
+ double nCentBin = 20;
+
+ AliJEventHeader * eventHeader = GetJEventHeader();
+
+ //== TRIGGER( MB ) TODO is this?
+ Bool_t triggeredEventMB = eventHeader->GetTriggerMaskJCorran() & 8; // 1:kMB 8:kINT7 //TODO
+ UInt_t trigAlice = eventHeader->GetTriggerMaskAlice();
+/*
+cout<<"Trigger"<<endl;
+ for( int i=0;i<32 ;i++ ) cout<<Form("%02d",i)<<" ";
+ cout<<endl;
+ for( int i=0;i<32 ;i++ ) cout<<(eventHeader->GetTriggerMaskJCorran()&(1<<i)?1:0)<<" ";
+ cout<<endl;
+ for( int i=0;i<32 ;i++ ) cout<<(eventHeader->GetTriggerMaskAlice()&(1<<i)?1:0)<<" ";
+ cout<<endl;
+*/
+ /*
+ bool isMB1 = trigAlice & (1UL<<0);
+ bool isMBBG1 = trigAlice & (1UL<<3);
+ bool isGFO = trigAlice & (1UL<<14);
+ bool isMBBG3 = trigAlice & (1UL<<1);
+ bool isV0A = trigAlice & (1UL<<10);
+ bool isV0C = trigAlice & (1UL<11);
+ */
+
+ // L0Input
+ UInt_t l0Input = eventHeader->GetL0TriggerInputs();
+ /*
+ bool isL0V0A = l0Input & (1UL<<9);
+ bool isL0V0C = l0Input & (1UL<<10);
+ bool isL0V0AND = l0Input & (1UL<<4);
+ bool isL0V0OR = l0Input & (1UL<<1);
+ bool isL0V0BeamGas = l0Input & (1UL<<2);
+ bool isL0SMB = l0Input & (1UL<<3);
+ bool isL0T0X = l0Input & (1UL<<0);
+ */
+
+
+
+ for( UInt_t i=0;i<32;i++ ){
+ if( l0Input & 1UL<<i ) fhL0Input->Fill(i);
+ if( trigAlice & 1UL<<i ) fhTriggerAlice->Fill(i);
+/*
+ if( isL0V0A != isV0A ) cout<<"J_WARN 0 : L0:V0A != Class:V0A "<<isL0V0A<<"\t"<<isV0A<<endl;
+ if( isL0V0C != isV0C ) cout<<"J_WARN 1 : L0:V0C != Class:V0C "<<isL0V0C<<"\t"<<isV0C<<endl;
+ if( isL0SMB != isGFO ) cout<<"J_WARN 2 : L0:SMB != Class:GFO "<<isL0SMB<<"\t"<<isGFO<<endl;
+ if( isL0V0OR != isMBBG1 ) cout<<"J_WARN 3 : L0:V0OR != Class:MBBG1 "<<isL0V0OR<<"\t"<<isMBBG1<<endl;
+ if( (isL0V0A||isL0V0C) != isMBBG1 ) cout<<"J_WARN 4 : L0:V0A|V0C != Class:MBBG1 "<<(isL0V0A||isL0V0C)<<"\t"<<isMBBG1<<endl;
+ if( ( isL0T0X || isL0V0OR || isL0SMB && !isL0V0BeamGas ) != isMB1 ) cout<<"J_WARN 5 : L0:MB1 != Class:MB1 "<<isMB1<<endl;
+ if( (isL0V0OR || isL0SMB && !isL0V0BeamGas ) != (( isMBBG1 || isGFO ) && isMB1 )) cout<<"J_WARN 6 : L0:MB != Class:MB "<<(isL0V0OR || isL0SMB && !isL0V0BeamGas)<<"\t"<<((isMBBG1 || isGFO ) && isMB1)<<endl;
+ if( (isL0V0OR || isL0SMB ) != (( isMBBG1 || isGFO ) )) cout<<"J_WARN 6 : L0:MB != Class:MB "<<(isL0V0OR || isL0SMB && !isL0V0BeamGas)<<"\t"<<((isMBBG1 || isGFO ) && isMB1)<<endl;
+*/
+
+ }
+ //* FOR TEST */
+ //Bool_t triggeredEventMB = ( isMBBG1 || isGFO ) && isMB1;
+ //Bool_t triggeredEventMB = isMB1;
+ //Bool_t triggeredEventMB = ( isMBBG1 || isGFO );
+ //
+ //== REAL MB with L0 INput
+ //triggeredEventMB = ( (isL0V0OR || isL0SMB) );
+ //== CENTRALITY
+ double centrality = eventHeader->GetCentrality();
+ int iCent = int( centrality/(100./nCentBin));
+ if( iCent< 0 || iCent>20 ) return;
+ //if( centrality < 0 || centrality > 100 ) return;
+ if( fRunHeader->IsPP() ) iCent = 0;
+
+ //== Vertex
+ //==== Reco
+ int ncontributors = eventHeader->GetVtxMult();
+ double zVtxRec = eventHeader->GetZVertex();
+ Bool_t goodRecVertex = (ncontributors>0) && (fabs(zVtxRec)<=zVtxCut);
+ int iVtx = 0;
+ //==== MC
+ double zVtxMC = eventHeader->GetZVertexMC();
+ //==== vtx sampling
+ /*
+ if( zVtxMC > fVtxRatioFunc->GetXmin() && zVtxMC < fVtxRatioFunc->GetXmax() ){
+ double vtxRatio = fVtxRatioFunc->Eval(zVtxMC)/fVtxRatioMax;
+ double random = gRandom->Uniform(0,1);
+ if( random > vtxRatio ) return;
+ }
+ */
+
+ fhVZRawMC->Fill(zVtxMC);
+ fhVertexZMC->Fill(ncontributors,zVtxMC);
+ // for crosscheck MC input events
+ fhZVtxMCAll->Fill(zVtxMC);
+ fhZVtxRecAll->Fill(zVtxRec);
+
+ if(triggeredEventMB){
+ fhVertexZTrigg->Fill(ncontributors,zVtxMC);
+ // for crosscheck passing trigger condition
+ fhZVtxMCTrigg->Fill(zVtxMC);
+ fhZVtxRecTrigg->Fill(zVtxRec);
+
+ if(ncontributors>0){//reconstructed vertex
+ fhVZRecMC->Fill(zVtxRec);
+ // for crosscheck passing trigger condition + reconstruted vtx
+ fhZVtxMCTriggVtx->Fill(zVtxMC);
+ fhZVtxRecTriggVtx->Fill(zVtxRec);
+ }
+ if(goodRecVertex){
+ fhVertexZTriggVtx->Fill(ncontributors,zVtxMC);
+ fhVZRecAccMC->Fill(zVtxRec);
+ }
+ }
+
+ fh2VtxCent->Fill( zVtxRec, centrality );
+
+ // TODO ? MC or REC?
+
+ int nRawMultPri = 0;
+ int nGenMultPri[AliJTrackCut::kJNTrackCuts] = {0};
+ int nGenMultAll[AliJTrackCut::kJNTrackCuts] = {0};
+
+ //==============================================
+ // LOOP over MC
+ //==============================================
+
+ //if( fabs(zVtxMC) > zVtxCut ) return;
+ int nMCTrks = 0;
+ if( fRunHeader->IsMC() )
+ nMCTrks = GetJMCTracks()->GetEntriesFast();
+ for( int it=0; it< nMCTrks; it++ ){
+ AliJMCTrack * track = GetJMCTrack( it );//Always IsPhysicalPrimary
+ if( !track ) continue;
+ if( !track->IsTrue( AliJMCTrack::kPrimary ) ) continue;
+ // TODO need? if( ! track->IsFinal() ) continue;
+ double eta = track->Eta();
+ double pt = track->Pt();
+ if( fabs(eta) > etaCut ) continue;
+ if( ! track->IsCharged() ) continue;
+
+
+ nRawMultPri++;
+ fhChargedPtMC[iVtx][iCent]->Fill(pt); //ALL charged physical primaries
+ if(triggeredEventMB){//triggered
+ fhChargedPtMCTrigg[iVtx][iCent]->Fill(pt);
+ fh2DChargedPtTrigg[iVtx][iCent]->Fill(pt, eta);
+ if(goodRecVertex){ //triggered+vertex
+ fhChargedPtMCTriggVtx[iVtx][iCent]->Fill(pt);
+ fh2DChargedPtTriggVtx[iVtx][iCent]->Fill(pt, eta);
+ }
+ }
+ }
+
+ //--------------------------------------------------------------
+ //---- Reconstracted TRACKS
+ //--------------------------------------------------------------
+ const int nTrkCut = AliJTrackCut::kJNTrackCuts;
+ if( ! triggeredEventMB ) return;
+ if( ! goodRecVertex ) return;
+ int nTrks = GetJTracks()->GetEntriesFast();
+ for(Int_t it = 0; it < nTrks; it++) {
+ AliJTrack * track = GetJTrack(it);
+ if( !track ) continue;
+ bool isTriggered = track->GetFilterMap();
+ if( !isTriggered ) continue;
+
+
+ //== init Vars of Track
+ double eta = track->Eta();
+ double etaTPC = eta;
+ double etaGCG = eta;
+ double ptRec = track->Pt();
+ double ptTPC = track->PtTPC();
+ if( fabs(ptTPC) < 1e-2 ) ptTPC=ptRec;
+ else{
+ TVector3 v(track->GetTPCTrack());
+ etaTPC = v.Eta();
+ }
+ double ptGCG = track->PtGCG();
+ if( fabs(ptGCG) < 1e-2 ) ptGCG=ptRec;
+ else{
+ TVector3 v(track->GetGCGTrack());
+ etaGCG = v.Eta();
+ }
+ double ptMC = -1;
+ int iPrimary = kJFake;
+
+ //== Skip tracks with out of Eta
+ if( fabs(eta) > etaCut && fabs(etaTPC)>etaCut && fabs(etaGCG)>etaCut) continue;
+
+ //== Find MC Info
+ for( int imc=0;imc<nMCTrks;imc++ ){
+ AliJMCTrack * mcTrack = GetJMCTrack(imc);
+ if( !mcTrack || !mcTrack->IsTrue( AliJMCTrack::kPrimary ) ) continue;
+ if( mcTrack && (TMath::Abs(track->GetLabel()) == TMath::Abs(mcTrack->GetLabel())) ){
+ iPrimary = kJPhysicsPrimary;
+ ptMC = mcTrack->Pt();
+ break;
+ }
+ }
+
+
+ //== FILL HIST
+ for( int icut=0;icut<nTrkCut;icut++ ){
+ if( IsSelected( track ,icut) ){
+ if( fabs(eta) < etaCut ){
+ fh2DChargedPtAll[iVtx][iCent][icut]->Fill(ptRec, eta);
+ fh2DChargedPtRec[iVtx][iCent][icut]->Fill(ptMC, eta);
+ fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJGlobal]->Fill( ptRec );
+ if( iPrimary == kJPhysicsPrimary ) nGenMultPri[icut]++;
+ nGenMultAll[icut]++;
+ //fhDCA2VertexXY[iVtx][iCent][icut]->Fill( track->GetDCAtoVertexXY() );
+ //fhDCA2VertexZ[iVtx][iCent][icut]->Fill( track->GetDCAtoVertexZ() );
+ }
+ if( fabs(etaTPC) < etaCut )
+ fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJTPCOnly]->Fill( ptTPC );
+ if( fabs(etaGCG) < etaCut )
+ fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJGCG]->Fill( ptGCG );
+ if( (icut==0 && fabs(etaTPC) < etaCut) || (icut!=0&&fabs(eta)<etaCut) )
+ fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJMCTrack]->Fill( ptMC );
+ }
+ }
+ }
+
+ for( int icut=0;icut<nTrkCut;icut++ ){
+ fh2MultGenRawPrimary[icut]->Fill( nRawMultPri, nGenMultPri[icut] );
+ fh2MultGenRawAll[icut]->Fill( nRawMultPri, nGenMultAll[icut] );
+ }
+ //cout<<"DEBUG END AliJEfficiencyScanner::UserExec"<<endl;
+}
+
+//______________________________________________________________________________
+void AliJEfficiencyScanner::Init()
+{
+ // Intialisation of parameters
+
+}
+
+//______________________________________________________________________________
+void AliJEfficiencyScanner::Terminate(Option_t *)
+{
+ // termination
+}
+
+
--- /dev/null
+// $Id: AliJEfficiencyScanner.h,v 1.5 2012/04/19 15:19:52 jkral Exp $
+
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+//
+// Fill the analysis containers for ESD or AOD
+// Note: Adapted for AliAnalysisTaskSE
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef ALIJEFFCIENCYSCANNER_H
+#define ALIJEFFCIENCYSCANNER_H
+
+#include <TNamed.h>
+#include "AliJRunHeader.h"
+#include <iostream>
+#include <TClonesArray.h>
+
+#include <AliJConst.h>
+#include <TVectorT.h>
+#include "AliJMCTrack.h"
+#include "AliJTrack.h"
+#include <AliJTrackCut.h>
+#include <TFile.h>
+#include <TF1.h>
+
+//==============================================================
+
+#ifndef AliJMaxDimBuffer
+#define AliJMaxDimBuffer
+const int kMaxDimBuffer = 300;//max length of a line read to a buffe
+#endif
+
+class AliJEventHeader;
+class AliJRunHeader;
+class AliJTrack;
+class AliAnalysisTaskSE;
+
+class TH1D;
+class TH2D;
+
+class AliJEfficiencyScanner : public TNamed {
+
+ public:
+ enum { kJPhysicsPrimary, kJFake, kNPrimaryStatus };
+ enum { kJMCTrack, kJGlobal, kJTPCOnly, kJGCG , kNTrackType };
+ enum { kNVtxBin=1 };
+ enum { kNCentBin=21};
+ AliJEfficiencyScanner();
+ AliJEfficiencyScanner(const char *name);
+ AliJEfficiencyScanner(const AliJEfficiencyScanner& ap);
+ AliJEfficiencyScanner& operator = (const AliJEfficiencyScanner& ap);
+ virtual ~AliJEfficiencyScanner();
+
+ // methods to fill from AliAnalysisTaskSE
+ virtual void UserCreateOutputObjects();
+ virtual void Init();
+ virtual void LocalInit() { Init(); }
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t * opt = "");
+
+ void SetJTrackList( TClonesArray * l ) { fTrackList = l ; }
+ void SetJMCTrackList( TClonesArray * l ) { fMCTrackList = l ; }
+ void SetJEventHeader( AliJEventHeader * h ){ fEventHeader = h ; }
+ void SetJRunHeader( AliJRunHeader *h ){ fRunHeader = h; }
+
+ bool IsSelected( AliJTrack * track, int itrigger )const { return AliJTrackCut::GetInstance().IsSelected(track, itrigger); }
+
+ AliJTrack * GetJTrack( int i ){ return (AliJTrack*) fTrackList->At(i); }
+ AliJMCTrack * GetJMCTrack( int i ){ return (AliJMCTrack*) fMCTrackList->At(i); }
+ TClonesArray * GetJMCTracks() { return fMCTrackList; }
+ TClonesArray * GetJTracks() { return fTrackList; }
+ AliJEventHeader * GetJEventHeader(){ return fEventHeader; }
+ AliJRunHeader * GetJRunHeader(){ return fRunHeader; }
+
+ TH1 * AddTH1(TString name, TH1*h ){
+ h->SetName(name);
+ h->SetTitle(name);
+ h->Sumw2();
+ h->SetDirectory(gDirectory);
+ return h;
+ }
+ TH1D * AddTH1D( TString name, TH1D*h){ return (TH1D*)AddTH1(name,h); }
+ TH2D * AddTH2D( TString name, TH2D*h){ return (TH2D*)AddTH1(name,h); }
+
+ private:
+
+ Int_t DebugLevel(){ return 5; }
+ inline void DEBUG(int level, int type, TString msg1, TString msg2=""){
+ if(DebugLevel()>level) std::cout<<msg1<<" : "<<msg2<<"\t"<<type<<std::endl;
+ }
+
+ void PrintOut() const;
+
+ TClonesArray * fTrackList; //! list of charged track objects
+ TClonesArray * fMCTrackList; //! list of charged track objects
+ AliJEventHeader * fEventHeader;
+ AliJRunHeader* fRunHeader; //! run details (mg field, trigger mask,etc...)
+
+ TH1D *fhChargedPtMC[kNVtxBin][kNCentBin]; //! all MC tracks filled with MC pt
+ TH2D *fh2DChargedPtTrigg[kNVtxBin][kNCentBin]; //! all MC track filled with MC pt in triggered event
+ TH2D *fh2DChargedPtTriggVtx[kNVtxBin][kNCentBin];//! all MC track filled with MC pt in trigg event with rec vertex
+ TH2D *fh2DChargedPtRec[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts]; //! [centr][cut] well reconstructed MC track filled with MC
+ TH2D *fh2DChargedPtAll[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts]; //! [centr][cut] all reconstructed tracks filled with reconstructed pT
+
+ TH2D* fhVertexZMC;
+ TH2D* fhVertexZTrigg;
+ TH2D* fhVertexZTriggVtx;
+
+ TH1D* fhVZRawMC;
+ TH1D* fhVZRecMC;
+ TH1D* fhVZRecAccMC;
+
+ TH1D * fhChargedPtMCTrigg[kNVtxBin][kNCentBin];
+ TH1D * fhChargedPtMCTriggVtx[kNVtxBin][kNCentBin];
+ TH1D * fhChargedPtMCRecoCentVtx[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts][kNPrimaryStatus][kNTrackType];
+ TH2D * fh2VtxCent;
+
+ TH2D * fh2MultGenRawPrimary[AliJTrackCut::kJNTrackCuts];
+ TH2D * fh2MultGenRawAll[AliJTrackCut::kJNTrackCuts];
+
+ TH1D * fhDCA2VertexXY[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts];
+ TH1D * fhDCA2VertexZ[kNVtxBin][kNCentBin][AliJTrackCut::kJNTrackCuts];
+
+ TH1D * fhL0Input;
+ TH1D * fhTriggerAlice;
+ TH1D * fhZVtxMCAll;
+ TH1D * fhZVtxMCTrigg;
+ TH1D * fhZVtxMCTriggVtx;
+ TH1D * fhZVtxRecAll;
+ TH1D * fhZVtxRecTrigg;
+ TH1D * fhZVtxRecTriggVtx;
+
+ TF1 * fVtxReFunc;
+ TF1 * fVtxMCFunc;
+ TF1 * fVtxRatioFunc;
+ double fVtxRatioMax;
+
+ ClassDef(AliJEfficiencyScanner, 1);
+};
+#endif // AliJEfficiencyScanner_H
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, 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. *
+ **************************************************************************/
+
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+// Fill the analysis containers for ESD or AOD
+// Adapted for AliAnalysisTaskSE and AOD objects
+//////////////////////////////////////////////////////////////////////////////
+
+#include "AliAnalysisTaskSE.h"
+#include "AliAODHandler.h"
+#include "AliAnalysisManager.h"
+#include "AliLog.h"
+
+#include "AliJEfficiencyTask.h"
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+#include "AliJCORRANTask.h"
+
+//______________________________________________________________________________
+AliJEfficiencyTask::AliJEfficiencyTask() :
+ AliAnalysisTaskSE("JEfficiencyTask"),
+ fFilterTask(NULL),
+ fFilterTaskName(""),
+ fEfficiencyScanner(0x0),
+ fEffHistDir(0x0)
+{
+ DefineOutput (1, TDirectory::Class());
+}
+
+//______________________________________________________________________________
+AliJEfficiencyTask::AliJEfficiencyTask(const char *name, TString inputformat):
+ AliAnalysisTaskSE(name),
+ fFilterTask(NULL),
+ fFilterTaskName(""),
+ fEfficiencyScanner(0x0),
+ fEffHistDir(0x0)
+{
+ // Constructor
+ AliInfo("---- AliJEfficiencyTask Constructor ----");
+
+ JUNUSED(inputformat);
+ DefineOutput (1, TDirectory::Class());
+ fEfficiencyScanner = new AliJEfficiencyScanner( Form("%sEffScanner",name ));
+}
+
+//____________________________________________________________________________
+AliJEfficiencyTask::AliJEfficiencyTask(const AliJEfficiencyTask& ap) :
+ AliAnalysisTaskSE(ap.GetName()),
+ fFilterTask(ap.fFilterTask),
+ fFilterTaskName(ap.fFilterTaskName),
+ fEfficiencyScanner( ap.fEfficiencyScanner ),
+ fEffHistDir( ap.fEffHistDir )
+{
+
+ AliInfo("----DEBUG AliJEfficiencyTask COPY ----");
+
+}
+
+//_____________________________________________________________________________
+AliJEfficiencyTask& AliJEfficiencyTask::operator = (const AliJEfficiencyTask& ap)
+{
+ // assignment operator
+
+ AliInfo("----DEBUG AliJEfficiencyTask operator= ----");
+ this->~AliJEfficiencyTask();
+ new(this) AliJEfficiencyTask(ap);
+ return *this;
+}
+
+//______________________________________________________________________________
+AliJEfficiencyTask::~AliJEfficiencyTask()
+{
+ // destructor
+
+ delete fEfficiencyScanner;
+
+}
+
+//________________________________________________________________________
+
+void AliJEfficiencyTask::UserCreateOutputObjects()
+{
+ //=== create the jcorran outputs objects
+ if(fDebug > 1) printf("AliJEfficiencyTask::UserCreateOutPutData() \n");
+
+ //=== Get AnalysisManager
+ AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
+ if(!man->GetOutputEventHandler()) {
+ Fatal("UserCreateOutputObjects", "This task needs an AOD handler");
+ return;
+ }
+
+ fFilterTask = (AliJCORRANTask*)(man->GetTask( fFilterTaskName ));
+
+ OpenFile(1);
+
+ fEfficiencyScanner->SetJRunHeader( fFilterTask->GetJRunHeader() );//TODO
+ fEfficiencyScanner->SetJTrackList( fFilterTask->GetFilter()->GetTrackList() );
+ fEfficiencyScanner->SetJMCTrackList( fFilterTask->GetFilter()->GetMCTrackList() );
+ fEffHistDir = gDirectory->mkdir("EffHist");
+ fEffHistDir->cd();
+ fEfficiencyScanner->UserCreateOutputObjects();
+ PostData( 1, fEffHistDir );
+
+ cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl;
+
+}
+
+//______________________________________________________________________________
+void AliJEfficiencyTask::UserExec(Option_t* /*option*/)
+{
+
+ // Processing of one event
+ if(fDebug > 5) cout << "------- AliJEfficiencyTask Exec-------"<<endl;
+ if(!((Entry()-1)%100)) AliInfo(Form(" Processing event # %lld", Entry()));
+
+ if( fFilterTask->GetFilter()->GetEventSuccess() ){
+ fEfficiencyScanner->SetJEventHeader( (AliJEventHeader*) fFilterTask->GetFilter()->GetHeaderList()->At(0) );
+ fEfficiencyScanner->UserExec("");
+ PostData(1, fEffHistDir );
+ }
+
+
+ if(fDebug > 5) cout << "\t------- End UserExec "<<endl;
+}
+
+//______________________________________________________________________________
+void AliJEfficiencyTask::Init()
+{
+ // Intialisation of parameters
+ AliInfo("Doing initialization") ;
+ fEfficiencyScanner->Init();
+}
+
+//______________________________________________________________________________
+void AliJEfficiencyTask::Terminate(Option_t *)
+{
+
+ fEfficiencyScanner->Terminate();
+ OpenFile(1);
+ fEffHistDir->Write();
+ cout<<"JEfficiency Analysis DONE !!"<<endl;
+
+}
--- /dev/null
+#ifndef ALIJEFFICIENCYTASK_H
+#define ALIJEFFICIENCYTASK_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+//
+// Fill the analysis containers for ESD or AOD
+// Note: Adapted for AliAnalysisTaskSE
+//////////////////////////////////////////////////////////////////////////////
+
+
+#include "AliAnalysisTaskSE.h"
+#include "AliJEfficiencyScanner.h"
+
+class AliJCORRANTask;
+//==============================================================
+
+using namespace std;
+
+class AliJEfficiencyTask : public AliAnalysisTaskSE {
+
+ public:
+ AliJEfficiencyTask();
+ AliJEfficiencyTask(const char *name, TString inputformat);
+ AliJEfficiencyTask(const AliJEfficiencyTask& ap);
+ AliJEfficiencyTask& operator = (const AliJEfficiencyTask& ap);
+ virtual ~AliJEfficiencyTask();
+
+ // methods to fill from AliAnalysisTaskSE
+ virtual void UserCreateOutputObjects();
+ virtual void Init();
+ virtual void LocalInit() { Init(); }
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t * opt = "");
+
+ void SetFilterTaskName(TString name){ fFilterTaskName=name; }
+
+ private:
+
+ AliJCORRANTask * fFilterTask;
+ TString fFilterTaskName;
+ AliJEfficiencyScanner * fEfficiencyScanner;
+ TDirectory * fEffHistDir;
+
+
+ ClassDef(AliJEfficiencyTask, 1);
+};
+#endif // AliJEfficiencyTask_H
/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * 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 notifce *
+ * 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: AliJEventHeader.cxx,v 1.2 2008/01/21 11:56:39 djkim Exp $
////////////////////////////////////////////////////
fTriggerMaskAlice(0),
fTriggerMaskJCorran(0),
fSPDTrackletMult(-999),
+ fTrackletsITSTPC(-999),
+ fTrackletsITSSA(-999),
fV0Mult(-999),
+ fV0AMult(-999),
+ fV0CMult(-999),
fEventType(0),
- fVtxMult(-9999) //FK// EFF
+ fFiredTriggers(),
+ fVtxMult(-9999),
+ fBunchCrossNumber(0),
+ fESDFileName(),
+ fEventNumberESDFile(0),
+ fL0TriggerInputs(0)
{
// default constructor
SetName("AliJEventHeader");
}
//______________________________________________________________________________
-AliJEventHeader::AliJEventHeader(int eventid, float cent, float vrtz, ULong64_t triggmaskAli,
- UInt_t triggmaskJC, Int_t refmult, Float_t v0mult,
- UInt_t eventType
- ):
+AliJEventHeader::AliJEventHeader(int eventid, float cent, float vrtz, ULong64_t triggmaskAli, UInt_t triggmaskJC, Int_t refmult, Int_t itstpcmult, Int_t itssamult, Float_t v0mult, Float_t v0Amult, Float_t v0Cmult, UInt_t eventType) :
AliJBaseEventHeader(eventid,cent,vrtz),
fTriggerMaskAlice(triggmaskAli),
fTriggerMaskJCorran(triggmaskJC),
fSPDTrackletMult(refmult),
+ fTrackletsITSTPC(itstpcmult),
+ fTrackletsITSSA(itssamult),
fV0Mult(v0mult),
+ fV0AMult(v0Amult),
+ fV0CMult(v0Cmult),
fEventType(eventType),
- fVtxMult(-9999) //FK// EFF
+ fFiredTriggers(),
+ fVtxMult(-9999),
+ fBunchCrossNumber(0),
+ fESDFileName(),
+ fEventNumberESDFile(0),
+ fL0TriggerInputs(0)
{
//constructor
SetName("AliJEventHeader");
fTriggerMaskAlice(a.fTriggerMaskAlice),
fTriggerMaskJCorran(a.fTriggerMaskJCorran),
fSPDTrackletMult(a.fSPDTrackletMult),
+ fTrackletsITSTPC(a.fTrackletsITSTPC),
+ fTrackletsITSSA(a.fTrackletsITSSA),
fV0Mult(a.fV0Mult),
+ fV0AMult(a.fV0AMult),
+ fV0CMult(a.fV0CMult),
fEventType(a.fEventType),
- fVtxMult(a.fVtxMult) //FK// EFF
+ fFiredTriggers(a.fFiredTriggers),
+ fVtxMult(a.fVtxMult),
+ fBunchCrossNumber(a.fBunchCrossNumber),
+ fESDFileName(a.fESDFileName),
+ fEventNumberESDFile(a.fEventNumberESDFile),
+ fL0TriggerInputs( a.fL0TriggerInputs )
{
//copy constructor
for( int i=0;i<kcNTYPE;i++ ) fCentralityArray[i] = a.fCentralityArray[i];
fTriggerMaskAlice = header.fTriggerMaskAlice;
fTriggerMaskJCorran = header.fTriggerMaskJCorran;
fSPDTrackletMult = header.fSPDTrackletMult;
+ fTrackletsITSTPC = header.fTrackletsITSTPC;
+ fTrackletsITSSA = header.fTrackletsITSSA;
fV0Mult = header.fV0Mult;
+ fV0AMult = header.fV0AMult;
+ fV0CMult = header.fV0CMult;
fEventType = header.fEventType;
- fVtxMult = header.fVtxMult; //FK// EFF
+ fVtxMult = header.fVtxMult;
+ fFiredTriggers = header.fFiredTriggers;
for( int i=0;i<kcNTYPE;i++ ) fCentralityArray[i] = header.fCentralityArray[i];
}
+/* 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: AliJEventHeader.h,v 1.1 2008/05/02 11:56:23 djkim Exp $
////////////////////////////////////////////////////
/*!
class AliJEventHeader : public AliJBaseEventHeader {
public:
- enum { kcV0M, kcFMD, kcTRK, kcTKL, kcCL0, kcCL1, kcV0MvsFMD, kcTKLvsV0, kcZEMvsZDC, kcNTYPE };
+ enum { kcV0M, kcFMD, kcTRK, kcTKL, kcCL0, kcCL1, kcV0MvsFMD, kcTKLvsV0, kcZEMvsZDC, kcV0A, kcV0C, kcNTYPE };
/*
* V0M = V0 multiplicity
ULong64_t triggmaskAli,
UInt_t triggmaskJC,
Int_t refmult,
+ Int_t refmult1,
+ Int_t refmult2,
Float_t v0mult,
+ Float_t v0Amult,
+ Float_t v0Cmult,
UInt_t eventType
);
ULong64_t GetTriggerMaskAlice() const {return fTriggerMaskAlice;}
UInt_t GetTriggerMaskJCorran() const {return fTriggerMaskJCorran;}
Int_t GetSPDTrackletMult() const {return fSPDTrackletMult;}
+ Int_t GetITSSATrackletMult() const {return fTrackletsITSSA;}
+ Int_t GetITSTPCTrackletMult() const {return fTrackletsITSTPC;}
UInt_t GetEventType() const {return fEventType;}
Float_t GetV0Mult() const {return fV0Mult;}
- Int_t GetVtxMult() const { return fVtxMult; };//FK// EFF
+ Float_t GetV0AMult() const {return fV0AMult;}
+ Float_t GetV0CMult() const {return fV0CMult;}
+ Int_t GetVtxMult() const { return fVtxMult; }
+ UShort_t GetBunchCrossNumber() const { return fBunchCrossNumber; }
Float_t GetCentralityArray( UInt_t it ) const { return it<kcNTYPE ? fCentralityArray[it] : -1; }
void SetTriggerMaskAlice(ULong64_t mask) {fTriggerMaskAlice = mask;}
void SetTriggerMaskJCorran(UInt_t mask) {fTriggerMaskJCorran = mask;}
void SetSPDTrackletMult(Int_t ref) { fSPDTrackletMult = ref;}
+ void SetITSSATrackletMult(Int_t ref) { fTrackletsITSSA = ref;}
+ void SetITSTPCTrackletMult(Int_t ref) { fTrackletsITSTPC = ref;}
void SetEventType(UInt_t eventype) {fEventType = eventype;}
void SetV0Mult(Float_t multV0) {fV0Mult = multV0;}
- void SetVtxMult(Int_t m){ fVtxMult = m; };//FK// EFF
+ void SetV0AMult(Float_t multV0) {fV0AMult = multV0;}
+ void SetV0CMult(Float_t multV0) {fV0CMult = multV0;}
+ void SetVtxMult(Int_t m){ fVtxMult = m; };
void SetCentralityArray(UInt_t it, Float_t cen ){ if( it < kcNTYPE ) fCentralityArray[it]=cen; }
+ void SetBunchCrossNumber( UShort_t n ){ fBunchCrossNumber = n; }
+
+ TString GetFiredTriggers() const { return fFiredTriggers; }
+ void SetFiredTriggers(TString s){ fFiredTriggers=s; }
AliJEventHeader& operator=(const AliJEventHeader& header);
+ TString GetESDFileName() const { return fESDFileName; }
+ void SetESDFileName(TString s){ fESDFileName=s; }
+ Int_t GetEventNumberESDFile() const { return fEventNumberESDFile; }
+ void SetEventNumberESDFile(Int_t s){ fEventNumberESDFile=s; }
+
+ void SetL0TriggerInputs(UInt_t n) {fL0TriggerInputs=n;}
+ UInt_t GetL0TriggerInputs() const {return fL0TriggerInputs;}
+
+
private:
ULong64_t fTriggerMaskAlice; //Alice Trigger MASK
UInt_t fTriggerMaskJCorran; // JCorran Trigger MASK
Int_t fSPDTrackletMult; //SPD tracklet multiplicity
+ Int_t fTrackletsITSTPC; // Multiplicity ITS and TPC
+ Int_t fTrackletsITSSA; // Multiplicity ITS standalone + ITS
Double32_t fV0Mult; // VZERO multiplicity
+ Double32_t fV0AMult; // VZERO multiplicity
+ Double32_t fV0CMult; // VZERO multiplicity
UInt_t fEventType; // Type of Event
+ TString fFiredTriggers; // String with fired triggers from AOD
Int_t fVtxMult; //FK// EFF number of vertex contributors
Double32_t fCentralityArray[kcNTYPE]; //?//
+ UShort_t fBunchCrossNumber; // bunch crossing identifier
+ TString fESDFileName; // file name for the ESD file
+ Int_t fEventNumberESDFile; // Number of event in the ESD file
+ UInt_t fL0TriggerInputs; //L0 Trigger Inputs (mask)
- ClassDef(AliJEventHeader,1)
+ ClassDef(AliJEventHeader,3)
};
--- /dev/null
+#include <TRandom.h>
+#include "AliJEventPool.h"
+
+#include <TH1D.h>
+
+#include "AliJTrack.h"
+#include "AliJPhoton.h"
+#include <TClonesArray.h>
+
+#include "AliJBaseTrack.h"
+#include "AliJPhoton.h"
+
+
+#include "AliJPiZero.h"
+
+#include "AliJCard.h"
+#include "AliJCorrelations.h"
+#include "AliJHistos.h"
+
+
+// event mixing
+// blah
+// blah
+// blah
+// blah
+
+AliJEventPool::AliJEventPool(AliJCard *cardin, AliJHistos *histosin, AliJCorrelations *coin, particleType particle ) :
+ fcard(cardin),
+ fcorrelations(coin),
+ fhistos(histosin),
+ ftk(NULL),
+ ftk1(NULL),
+ ftk2(NULL),
+ fthisPoolType(particle),
+ fpoolList(NULL)
+{
+ // constructor
+
+ if(fcard->GetNoOfBins(kCentrType) > kMaxNoCentrBin ){
+ cout<<"ERROR: No of Centrality bins exceed max dim in AliJEventPool.h"<<endl;
+ exit(0);
+ }
+ for(int ic=0;ic<fcard->GetNoOfBins(kCentrType);ic++){
+ cout<<"Mixing pool depth for icbin = "<< ic << " is " << fcard->GetEventPoolDepth(ic) <<" for <"<<kParticleTypeStrName[particle] <<"> and prototype "<<kParticleProtoType[particle]<<endl;
+ if(fcard->GetEventPoolDepth(ic) > MAXNOEVENT ){
+ cout<<"ERROR: Event pool depth exeed max="<<MAXNOEVENT<<" in AliJEventPool.h"<<endl;
+ exit(0);
+ }
+ } cout <<endl;
+
+ for(int ic=0;ic<fcard->GetNoOfBins(kCentrType);ic++){
+ for(int ie=0;ie<fcard->GetEventPoolDepth(ic); ie++){
+ fLists[ic][ie] = new TClonesArray(kParticleProtoType[particle],1500);
+ }
+ flastAccepted[ic] = -1; //to start from 0
+ fwhereToStore[ic] = -1; //to start from 0
+ fnoMix[ic] = 0;
+ fnoMixCut[ic] = 0;
+ }
+
+ ftk = new AliJBaseTrack;
+ ftk1 = new AliJBaseTrack;
+ ftk2 = new AliJBaseTrack;
+
+}
+
+AliJEventPool::~AliJEventPool( ){
+ // destructor
+ delete ftk;
+ delete ftk1;
+ delete ftk2;
+}
+
+AliJEventPool::AliJEventPool(const AliJEventPool& obj) :
+ fcard(obj.fcard),
+ fcorrelations(obj.fcorrelations),
+ fhistos(obj.fhistos),
+ ftk(obj.ftk),
+ ftk1(obj.ftk1),
+ ftk2(obj.ftk2),
+ fthisPoolType(obj.fthisPoolType),
+ fpoolList(obj.fpoolList)
+{
+ // copy constructor
+ JUNUSED(obj);
+}
+
+AliJEventPool& AliJEventPool::operator=(const AliJEventPool& obj){
+ // equal sign operator
+ JUNUSED(obj);
+ return *this;
+}
+
+
+//______________________________________________________________________________
+void AliJEventPool::Mix( TClonesArray *triggList,
+ corrFillType cFTyp,
+ float cent, float Z, float thisMult, int iev){
+ // mixer
+ int cBin = fcard->GetBin(kCentrType, cent);
+ int zBin = fcard->GetBin(kZVertType, Z);
+ int noTrigg=triggList->GetEntriesFast();
+ int noAssoc=0;
+
+// cout << "c: " << cBin << endl;
+
+
+ for(int backCounter=0; backCounter <= flastAccepted[cBin]; backCounter++){
+ fpoolList = fLists [cBin] [backCounter];
+ noAssoc = fpoolList->GetEntries();
+
+ if(noAssoc<=0) continue;
+
+ //mixit=======
+ fnoMix[cBin]++;
+
+ if(
+ fcard->SimilarCentrality(fcentrality[cBin][backCounter], cent, cBin) &&
+ fcard->SimilarMultiplicity(fmult[cBin][backCounter], thisMult) &&
+ fcard->GetBin(kZVertType, fZVertex[cBin][backCounter])==zBin &&
+ fevent[cBin][backCounter] != iev )
+ {
+ fnoMixCut[cBin]++;
+ //=================================================
+ // try to use only one track from each fevent
+ //=================================================
+ for(int ii=0;ii<noTrigg;ii++){
+ ftk1 = (AliJBaseTrack*)triggList->At(ii);
+ //fhistos->fhTriggPtBin[kMixed][cBin][iptt]->Fill(ptt); //who needs that?
+ for(int jj=0;jj<noAssoc ;jj++){
+ ftk2 = (AliJBaseTrack*)fpoolList->At(jj);
+ fcorrelations->FillHisto(cFTyp,kMixed, cBin, zBin, ftk1, ftk2);
+ } //inner loop mixing
+ }//outer loop mixing
+ }//if good for mix
+ }//mixed fevent loop
+}
+
+//______________________________________________________________________________
+void AliJEventPool::AcceptList(TClonesArray *inList, float cent, float Z, float inMult, int iev){
+ //////////////////////////////////////////////////////////////
+ // circular buffer. New fevent added after the previous one,
+ // mixing goes backwards
+ //////////////////////////////////////////////////////////////
+ int cBin = fcard->GetBin(kCentrType, cent);
+ flastAccepted[cBin]++;
+ fwhereToStore[cBin]++;
+ if( flastAccepted[cBin] >= fcard->GetEventPoolDepth(cBin) ) flastAccepted[cBin] = fcard->GetEventPoolDepth(cBin)-1;
+ if( fwhereToStore[cBin] >= fcard->GetEventPoolDepth(cBin) ) fwhereToStore[cBin] = 0;
+ fevent [cBin][fwhereToStore[cBin]] = iev;
+ fZVertex [cBin][fwhereToStore[cBin]] = Z;
+ fcentrality[cBin][fwhereToStore[cBin]] = cent;
+ fmult [cBin][fwhereToStore[cBin]] = inMult;
+
+ fLists[cBin][fwhereToStore[cBin]]->Clear();
+ for(int i=0;i<inList->GetEntriesFast();i++){
+ if( fthisPoolType == kPhoton || fthisPoolType == kDecayphoton ){
+ AliJPhoton *tkp = (AliJPhoton*)inList->At(i);
+ new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJPhoton(*tkp);
+ }
+ else if( fthisPoolType == kPizero || fthisPoolType == kEta ){
+ AliJPiZero *tkpz = (AliJPiZero*)inList->At(i);
+ new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJPiZero(*tkpz);
+ }
+ else{
+ AliJTrack *tk3 = (AliJTrack*)inList->At(i);
+ new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJTrack(*tk3);
+ }
+ }
+
+}
+
+
+
+
+
+//==================== Sampling ===========================
+void AliJEventPool::Mysample(TH1D *fromh, TH1D *toh )
+{
+ // sampler
+ if(fabs(toh->GetBinWidth(1)-fromh->GetBinWidth(1))>1e-5){
+ cout<<" Attempt to integrate histograms with non-compatible binning"<<endl;
+ printf("%16.14f %16.14f %16.14f \n", fromh->GetBinWidth(1), toh->GetBinWidth(1), fabs(toh->GetBinWidth(1)-fromh->GetBinWidth(1)) );
+ return;
+ }
+
+ for(int idphi=1; idphi<=toh->GetNbinsX(); idphi++){
+ double sum=0,err=0, a,b,e;
+ for (int i = 1;i <= fromh->GetNbinsX();i++)
+ {
+ double phi1 = fromh->GetBinCenter(i);
+ double fdphi = toh->GetBinCenter(idphi);
+ double phi2 = atan2(sin(phi1+fdphi),cos(phi1+fdphi));
+ a=fromh->GetBinContent(i);
+ b=fromh->GetBinContent(fromh->FindBin(phi2));
+ sum += a*b;
+ err += a*b*(a+b);
+ }
+ if( idphi==1 || idphi== toh->GetNbinsX() ) sum /= 2.0;
+ toh->SetBinContent(idphi,toh->GetBinContent(idphi)+sum);
+ e=toh->GetBinError(idphi);
+ toh->SetBinError(idphi,sqrt(err+e*e));
+ }
+}
+
+//______________________________________________________________________________
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+//===========================================================
+// AliJEventPool.h
+//
+//===========================================================
+
+#ifndef ALIJEVENTPOOL_H
+#define ALIJEVENTPOOL_H
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace std;
+
+#include <AliJConst.h>
+
+class TClonesArray;
+class AliJBaseTrack;
+class AliJPhoton;
+class AliJTrack;
+class AliJCard;
+class AliJCorrelations;
+class AliJHistos;
+class TH1D;
+
+#define MAXNOEVENT 1000 // Maximum no of events in pools (400 used for QM anal.)
+
+class AliJEventPool {
+
+ public:
+ AliJEventPool(AliJCard *cardin, AliJHistos *histosin, AliJCorrelations *coin, particleType particle );
+ virtual ~AliJEventPool( );
+ AliJEventPool(const AliJEventPool& obj);
+ AliJEventPool& operator=(const AliJEventPool& obj);
+
+
+ public:
+ void Mix( TClonesArray *triggList,
+ corrFillType cFTyp,
+ float cent, float Z, float thisMult, int iev);
+
+ //void MixRNDM( AliJEventPool *cross, void (AliJCorrelations::*fillHisto)(fillType, int, AliJBaseTrack*, AliJBaseTrack*) );
+
+ void AcceptList(TClonesArray *inList, float cent, float Z, float inMult, int iev);
+
+ void Mysample(TH1D *fromh, TH1D *toh );
+ void PrintOut(){for(int i=0;i<kMaxNoCentrBin;i++)
+ cout<<"c: "<<i<<" mixed "<<fnoMix[i]<<" accepted "<<fnoMixCut[i]<<" "<<(fnoMix[i]>0?fnoMixCut[i]*1.0/fnoMix[i]:0)<< endl;}
+
+ protected:
+
+ int fevent[kMaxNoCentrBin][MAXNOEVENT]; // comment me
+ float fZVertex[kMaxNoCentrBin][MAXNOEVENT]; // comment me
+ float fcentrality[kMaxNoCentrBin][MAXNOEVENT]; // comment me
+ float fmult[kMaxNoCentrBin][MAXNOEVENT]; // comment me
+ long flastAccepted[kMaxNoCentrBin]; // comment me
+ long fwhereToStore[kMaxNoCentrBin]; // comment me
+ long fnoMix[kMaxNoCentrBin]; // comment me
+ long fnoMixCut[kMaxNoCentrBin]; // comment me
+
+ TClonesArray *fLists[kMaxNoCentrBin][MAXNOEVENT]; // mix lists
+ AliJCard *fcard; // card
+ AliJCorrelations *fcorrelations; // correlation object
+ AliJHistos *fhistos; // histos
+ AliJBaseTrack *ftk; // track
+ AliJBaseTrack *ftk1; // track
+ AliJBaseTrack *ftk2; // track
+ particleType fthisPoolType; // pool type
+
+ TClonesArray *fpoolList; // pool list
+
+ //int trials[MAXNOEVENT];
+
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// #include <Riostream.h>
+// #include <TChain.h>
+// #include <TVectorT.h>
+// #include <TVector3.h>
+// #include <TFile.h>
+// #include <TH1.h>
+// #include <TClonesArray.h>
+// #include <TObjArray.h>
+// #include <TObjString.h>
+// #include <TFormula.h>
+// #include <TString.h>
+// #include <TRefArray.h>
+// #include <TNtuple.h>
+// #include <TArrayF.h>
+
+
+#include "AliJFilter.h"
+#include "AliAnalysisManager.h"
+#include "AliAnalysisTaskSE.h"
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+#include "AliStack.h"
+#include "AliGenEventHeader.h"
+#include "AliGenCocktailEventHeader.h"
+#include "AliGenPythiaEventHeader.h"
+#include "AliInputEventHandler.h"
+#include "AliESDCaloCluster.h"
+#include "AliAODEvent.h"
+#include "AliAODHeader.h"
+#include "AliAODHandler.h"
+#include "AliLog.h"
+#include "AliESDVertex.h"
+#include "AliESDtrack.h"
+#include "AliAODTrack.h"
+#include "AliAnalysisFilter.h"
+#include "AliESDtrackCuts.h"
+#include "AliAODVertex.h"
+#include "AliAODTracklets.h"
+#include "AliAODPid.h"
+#include "AliAODMCHeader.h"
+#include "AliAODMCParticle.h"
+#include "AliESDUtils.h"
+//#include "AliESDVZERO.h"
+#include "AliCentrality.h"
+#include "AliAODTracklets.h"
+#include "AliMultiplicity.h"
+#include "AliJConst.h"
+#include "AliESDRun.h"
+#include "AliDAQ.h"
+#include "AliESDVZERO.h"
+#include "AliExternalTrackParam.h"
+#include "AliHeader.h"
+//== EMCAL
+#include "AliESDCaloCluster.h"
+#include "AliEMCALGeometry.h"
+#include "AliVCluster.h"
+#include "AliVCaloCells.h"
+#include "AliEMCALRecoUtils.h"
+#include "AliEMCALPIDUtils.h"
+
+#include "AliJTrack.h"
+#include "AliJMCTrack.h"
+#include "AliJPhoton.h"
+//#include "AliJCaloCell.h"
+#include "AliJEventHeader.h"
+#include "AliJRunHeader.h"
+
+#include "AliPIDResponse.h"
+#include "AliPIDCombined.h"
+#include "AliPHOSGeoUtils.h"
+#include "AliAnalysisUtils.h"
+
+
+ClassImp(AliJFilter);
+
+//______________________________________________________________________________
+AliJFilter::AliJFilter() :
+ TNamed(),
+ fEsdTrackCuts(0x0),
+ fESDFilter(0x0),
+ fIsRealOrMC(0),
+ fStoreEventPlaneSource(0),
+ fOADBPath(),
+ fCaloClustersArr(0),
+ fClusterThreshold(0),
+ fTrackThreshold(0),
+ fEventSuccess(0),
+ fMcMap(0),
+ fTrackList(0),
+ fMCTrackList(0x0),
+ fPhotonList(0x0),
+ fCaloCellList(0x0),
+ fHeaderList(0x0),
+ fRunInfoList(0x0),
+ fPIDResponse(0x0),
+ fPIDCombined(0x0),
+ fVZEROData(0x0),
+ fTZEROData(0x0),
+ //fFMDData(0x0),
+ fZDCData(0x0),
+ fEMCLabels(0),
+ fEMCTreeLabels(0),
+ fAliJRunHeader(0x0),
+ fEMCALGeometry(0x0),
+ fEMCALRecoUtils(0x0),
+ fPHOSGeom(0x0),
+ fAnaUtils(0x0),
+ fMyTask(0x0)
+{
+ //Default constructor
+}
+
+//______________________________________________________________________________
+AliJFilter::AliJFilter(const char *name,AliAnalysisTaskSE *task):
+ TNamed(name,name),
+ fEsdTrackCuts(0x0),
+ fESDFilter(0x0),
+ fIsRealOrMC(0),
+ fStoreEventPlaneSource(0),
+ fOADBPath(),
+ fCaloClustersArr(0),
+ fClusterThreshold(0),
+ fTrackThreshold(0),
+ fEventSuccess(0),
+ fMcMap(0),
+ fTrackList(0),
+ fMCTrackList(0x0),
+ fPhotonList(0x0),
+ fCaloCellList(0x0),
+ fHeaderList(0x0),
+ fRunInfoList(0x0),
+ fPIDResponse(0x0),
+ fPIDCombined(0x0),
+ fVZEROData(0x0),
+ fTZEROData(0x0),
+ //fFMDData(0x0),
+ fZDCData(0x0),
+ fEMCLabels(0),
+ fEMCTreeLabels(0),
+ fAliJRunHeader(0x0),
+ fEMCALGeometry(0x0),
+ fEMCALRecoUtils(0x0),
+ fPHOSGeom(0x0),
+ fAnaUtils(0x0),
+ fMyTask(0x0)
+{
+ // Constructor
+ if(task->DebugLevel() > 5) cout << "---- AliJFilter Constructor ----"<<endl;
+
+}
+
+//____________________________________________________________________________
+AliJFilter::AliJFilter(const AliJFilter& ap) :
+ TNamed(ap.GetName(), ap.GetTitle()),
+ fEsdTrackCuts(ap.fEsdTrackCuts),
+ fESDFilter(ap.fESDFilter),
+ fIsRealOrMC(ap.fIsRealOrMC),
+ fStoreEventPlaneSource(ap.fStoreEventPlaneSource),
+ fOADBPath(ap.fOADBPath),
+ fCaloClustersArr(ap.fCaloClustersArr),
+ fClusterThreshold(ap.fClusterThreshold),
+ fTrackThreshold(ap.fTrackThreshold),
+ fEventSuccess(ap.fEventSuccess),
+ fMcMap(ap.fMcMap),
+ fTrackList(ap.fTrackList),
+ fMCTrackList(ap.fMCTrackList),
+ fPhotonList(ap.fPhotonList),
+ fCaloCellList(ap.fCaloCellList),
+ fHeaderList(ap.fHeaderList),
+ fRunInfoList(ap.fRunInfoList),
+ fPIDResponse(ap.fPIDResponse),
+ fPIDCombined(ap.fPIDCombined),
+ fVZEROData(ap.fVZEROData),
+ fTZEROData(ap.fTZEROData),
+ //fFMDData(ap.fFMDData),
+ fZDCData(ap.fZDCData),
+ fEMCLabels(ap.fEMCLabels),
+ fEMCTreeLabels(ap.fEMCTreeLabels),
+ fAliJRunHeader(ap.fAliJRunHeader),
+ fEMCALGeometry(ap.fEMCALGeometry),
+ fEMCALRecoUtils(ap.fEMCALRecoUtils),
+ fPHOSGeom(ap.fPHOSGeom),
+ fAnaUtils(ap.fAnaUtils),
+ fMyTask(ap.fMyTask)
+{
+ // cpy ctor
+}
+
+//_____________________________________________________________________________
+AliJFilter& AliJFilter::operator = (const AliJFilter& ap)
+{
+ // assignment operator
+
+ this->~AliJFilter();
+ new(this) AliJFilter(ap);
+ return *this;
+}
+
+//______________________________________________________________________________
+AliJFilter::~AliJFilter()
+{
+ // destructor
+ delete fMcMap;
+ delete fTrackList;
+ delete fMCTrackList;
+ delete fPhotonList;
+ delete fCaloCellList;
+ delete fHeaderList;
+ delete fAliJRunHeader;
+ delete fRunInfoList;
+ delete fPIDResponse;
+ delete fPIDCombined;
+ delete fEMCALRecoUtils;
+ delete fEMCALGeometry;
+ delete fPHOSGeom;
+ delete fAnaUtils;
+ delete fVZEROData;
+ delete fTZEROData;
+ delete fZDCData;
+ // delete fFMDData;
+
+
+}
+
+//________________________________________________________________________
+
+void AliJFilter::UserCreateOutputObjects()
+{
+ //=== create the jcorran outputs objects
+ if(fMyTask->DebugLevel() > 1) printf("AliJFilter::UserCreateOutPutData() \n");
+
+ //== RUN HEADER
+ cout<<"TEST2 "<<fAliJRunHeader<<endl;
+ if(!fAliJRunHeader) fAliJRunHeader = new AliJRunHeader();
+ fRunInfoList = new TList();
+ fRunInfoList->SetName("RunInfoList");
+ fRunInfoList->SetOwner();
+ fRunInfoList->Clear();
+ fRunInfoList->Add(fAliJRunHeader);
+
+ //=== Other Objects
+ fCaloClustersArr = new TRefArray();
+ fEMCALGeometry = AliEMCALGeometry::GetInstance("EMCAL_COMPLETEV1");
+ fEMCALRecoUtils = new AliEMCALRecoUtils();
+ fPHOSGeom = new AliPHOSGeoUtils();
+ fAnaUtils = new AliAnalysisUtils();
+ fAnaUtils->SetUseOutOfBunchPileUp( kTRUE );
+ fMcMap = new TArrayI();
+
+ //=== Set Tree and TClonesArray
+ //== TRACKS
+ AddList("AliJTrackList", "AliJTrack", &fTrackList, 1000);
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ AddList("AliJPhotonList", "AliJPhoton", &fPhotonList, 1000);
+ //BS AddList("AliJCaloCell", "AliJCaloCell", &fCaloCellList, 1000);
+ }
+ if( IsMC() )
+ AddList("AliJMCTrackList", "AliJMCTrack", &fMCTrackList, 1000);
+ //== Event Header
+ AddList("AliJEventHeaderList", "AliJEventHeader", &fHeaderList, 1000);
+
+ //== EventPlane SRC
+ if( fAliJRunHeader->GetStoreEventPlaneSource() ){
+ fVZEROData = new AliESDVZERO;
+ fTZEROData = new AliESDTZERO;
+ fZDCData = new AliESDZDC;
+ }
+ //== PID
+ // fPIDCombined = new AliPIDCombined;
+ // fPIDCombined->SetDefaultTPCPriors();
+ // fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF);
+ // fPIDResponse = ((AliInputEventHandler*) (man->GetInputEventHandler()))->GetPIDResponse();
+ // fPIDResponse->SetOADBPath(AliAnalysisManager::GetOADBPath());
+ // if (!fOADBPath.IsNull()) fPIDResponse->SetOADBPath(fOADBPath.Data());
+
+ cout << "Add(fAliJRunHeader) in UserCreateObject() ======= " << endl;
+
+}
+
+//______________________________________________________________________________
+void AliJFilter::UserExec(Option_t* /*option*/)
+{
+ // user loop
+ AliJRunHeader *runh = fAliJRunHeader;
+ Bool_t hasGoodTrack, hasGoodCluster;
+
+ fEventSuccess = kFALSE;
+
+ // Processing of one event
+ DEBUG( 5, 1, "------- AliJFilter Exec-------" );
+ if(!((fMyTask->Entry()-1)%100)) AliInfo(Form(" Processing event # %lld", fMyTask->Entry()));
+
+ //=== Init Variables
+ fTrackList->Clear();
+ if( IsMC() ){
+ fMCTrackList->Clear();
+ fEMCLabels.clear();
+ fEMCTreeLabels.clear();
+ }
+
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ fPhotonList->Clear("C");
+ fCaloCellList->Clear();
+ }
+ fHeaderList->Clear();
+
+ hasGoodCluster = kTRUE;
+ hasGoodTrack = kTRUE;
+
+ //=== CHECK ESD, AOD, MC event
+ if( !Event() ) return;
+
+ if( FromESD() ) { //Reading ESD
+ DEBUG( 5, 1, "\t------- Start ESD " );
+ if( !ESDEvent() ) return;
+ if( runh->GetWithoutSDD() && !(ESDEvent()->GetTriggerMask() & (1<<13)) ) return;
+
+ if( IsMC() ){
+ if( ! MCEvent() ) return;
+ }
+ }
+
+ if( FromAOD() ) {
+ DEBUG( 5, 1, "\t------- Start AOD " );
+ if( !AODEvent() ) return;
+ }
+
+
+ // pileup rejection
+ if( fAnaUtils->IsPileUpEvent( Event() ))
+ return;
+
+ //---------------------------------------------------------------
+ // RUN Header
+ //---------------------------------------------------------------
+ if(!runh->GetRunNumber()){ //new run has started : I suppose no change of run in process
+ runh->SetRunNumber( Event()->GetRunNumber() );
+ if( FromESD() ){
+ //==== General ====//
+ runh->SetBeamEnergy( ESDEvent()->GetBeamEnergy() );
+ runh->SetBeamType( ESDEvent()->GetBeamType() );
+ //==== Detector status ==//
+ if( ESDEvent()->GetCurrentL3() > 0 ) runh->SetL3MagnetFieldPolarity(1);
+ if( ESDEvent()->GetCurrentL3() < 0 ) runh->SetL3MagnetFieldPolarity(-1);
+ runh->SetL3MagnetFieldIntensity( ESDEvent()->GetMagneticField() );
+ runh->SetCurrentL3( ESDEvent()->GetCurrentL3() );
+ runh->SetCurrentDip( ESDEvent()->GetCurrentDip() );
+ runh->SetUniformBMap( ESDEvent()->IsUniformBMap() );
+ //==== Triggers ====//
+ const AliESDRun* esdRun = ESDEvent()->GetESDRun();
+ for(Int_t triggerBit=0; triggerBit<kRangeTriggerTableAlice; triggerBit++){
+ runh->SetActiveTriggersAlice( triggerBit, esdRun->GetTriggerClass(triggerBit) );
+ }
+ }
+ else if( FromAOD() ){
+ //==== General ====//
+ cout << "Run # = "<< AODEvent()->GetRunNumber() << endl;
+ runh->SetRunNumber( AODEvent()->GetRunNumber() );
+ //TODO runh->SetBeamEnergy( ESDEvent()->GetBeamEnergy() );
+ //TODO runh->SetBeamType( ESDEvent()->GetBeamType() );
+ //==== Detector status ==//
+ //TODO runh->Setl3MgFieldPolarity(1);
+ runh->SetL3MagnetFieldIntensity( AODEvent()->GetMagneticField() );
+ runh->SetCurrentL3( AODEvent()->GetMagneticField()*30000.0/5.00668 );
+ runh->SetCurrentDip( AODEvent()->GetMuonMagFieldScale()*6000.0 );
+ runh->SetUniformBMap( kFALSE ); // TODO is this?
+ }
+ cout << "Add(fAliJRunHeader) is done =============" << endl;
+ }
+
+ //---------------------------------------------------------------
+ // EventHeader and read Others
+ //---------------------------------------------------------------
+ if( FromESD() ){ //Reading ESD
+ DEBUG( 5, 1, "\t------- Start READ ESD " );
+
+ ReadESDHeader( ESDEvent() );
+ ReadESDTracks( ESDEvent() );
+
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ ReadESDCaloClusters( ESDEvent() );
+ ReadESDCaloCells( ESDEvent() );
+ }
+ if( IsMC() ){
+ ReadMCTracksFromESD();
+ //RemapMCLabels();
+ }
+ }else if( FromAOD() ){
+ DEBUG( 5, 1, "\t------- Start READ AOD " );
+ ReadAODHeader( AODEvent() );
+ ReadAODTracks( AODEvent() );
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ ReadAODCaloClusters( AODEvent() );
+ ReadAODCaloCells( AODEvent() );
+ }
+ if( IsMC() ){
+ ReadMCTracksFromAOD();
+ //RemapMCLabels();
+ }
+
+ }else{
+ cout << "Error: Not correct InputDataFormat especified " << endl;
+ return;
+ }
+
+ if( hasGoodCluster || hasGoodTrack ){
+ //=== TODO : need this?
+ AliAODHandler* outputHandler =
+ (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
+ outputHandler->SetFillAOD(kTRUE);
+ outputHandler->SetFillExtension(kTRUE);
+ fEventSuccess = kTRUE;
+ }
+ else{
+ fTrackList->Clear();
+ if( IsMC() ){
+ fMCTrackList->Clear();
+ fEMCLabels.clear();
+ fEMCTreeLabels.clear();
+ }
+
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ fPhotonList->Clear("C");
+ fCaloCellList->Clear();
+ }
+ fHeaderList->Clear();
+ }
+
+ DEBUG( 5, 1, "\t------- End UserExec " );
+}
+
+//______________________________________________________________________________
+void AliJFilter::Init()
+{
+ // Intialisation of parameters
+ AliInfo("Doing initialization") ;
+
+ // TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep());
+ // if(formula.Length()>0){ // momentum dep DCA cut for AOD
+ // formula.ReplaceAll("pt","x");
+ // }
+}
+
+//______________________________________________________________________________
+void AliJFilter::Terminate(Option_t *)
+{
+ // termination
+ fTrackList->Clear();
+ if( IsMC() ) fMCTrackList->Clear();
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ fPhotonList->Clear();
+ fCaloCellList->Clear();
+ }
+ fHeaderList->Clear();
+
+ // Processing when the event loop is ended
+ cout<<"PWG4JCORRAN Analysis DONE !!"<<endl;
+
+}
+
+//______________________________________________________________________________
+void AliJFilter::ReadESDTracks(AliESDEvent * esd)
+ //void AliJFilter::ReadESDTracks(const AliESDEvent * esd)
+{
+ // Read the AliESDtrack and fill the list of AliJTrack containers
+ Int_t nt = esd->GetNumberOfTracks();
+ DEBUG( 5, 1 , Form("ESD::NumberOfTracks = %d",nt), "AliJFilter::ReadESDTracks" );
+
+ //==== Prepare TPC, GCG track ====//
+ Float_t ptMaxTPC = 0;
+ Float_t ptMinTPC = 1E10;
+ Float_t ptMaxGCG = 0;
+ Float_t ptMinGCG = 1E10;
+ for(int i = 0;i<32;i++){
+ AliESDtrackCuts* cuts = (AliESDtrackCuts*)fESDFilter->GetCuts()->At(i);
+ if(!cuts) continue;
+ Float_t tmp1= 0,tmp2 = 0;
+ cuts->GetPtRange(tmp1,tmp2);
+ if( TESTBIT ( fAliJRunHeader->GetStoreTPCTrackBitMask(), i ) ){
+ if(tmp1<ptMinTPC)ptMinTPC=tmp1;
+ if(tmp2>ptMaxTPC)ptMaxTPC=tmp2;
+ }
+ if( TESTBIT(fAliJRunHeader->GetStoreGCGTrackBitMask() , i ) ){
+ if(tmp1<ptMinGCG)ptMinGCG=tmp1;
+ if(tmp2>ptMaxGCG)ptMaxGCG=tmp2;
+ }
+ }
+
+ //==== loop over tracks ====//
+ for(Int_t it = 0; it < nt; it++) {
+
+ AliESDtrack *track = esd->GetTrack(it);
+ if( !track ) continue;
+ UInt_t filterMap = fESDFilter->IsSelected( track );
+ if(! filterMap ) continue; // apply track selection criteria
+
+ //====create a new AliJTrack and fill the track info
+ AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack;
+ ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
+ Double32_t pos[3];
+ track->GetXYZ(pos);
+ ctrack->SetTrackPos( pos );
+ ctrack->SetTPCdEdx( track->GetTPCsignal() );
+ ctrack->SetParticleType(kJNone);
+ ctrack->SetCharge(track->Charge());
+ ctrack->SetFilterMap( filterMap );
+ ctrack->SetLabel( track->GetLabel() );
+
+ ReadESDPID( track, ctrack );
+ //==== TPC Tracks ====//
+ if( filterMap & fAliJRunHeader->GetStoreTPCTrackBitMask() ) {
+ ConvertESDTPCOnlyTracks( esd, it, ctrack, ptMinTPC, ptMaxTPC );
+ }
+ //==== GCG Tracks ====//
+ if( filterMap & fAliJRunHeader->GetStoreGCGTrackBitMask() ) {
+ ConvertESDGCGTracks( esd, it, ctrack, ptMinGCG, ptMaxGCG );
+ }
+
+ Float_t b[2];
+ Float_t bCov[3];
+ track->GetImpactParameters(b,bCov);
+ // ctrack->SetDCAtoVertexXY( b[0] );
+ // ctrack->SetDCAtoVertexZ( b[1] );
+
+ //if( track->P()>1 ) DEBUG( 5, 1, Form("P = %f", track->P() ) ) ;
+
+ } // end tracks loop
+}
+
+//______________________________________________________________________________
+void AliJFilter::ConvertESDTPCOnlyTracks(AliESDEvent* esd, int iTrack, AliJTrack * ctrack, double ptmin, double ptmax)
+{
+
+ const AliESDVertex *vtxSPD = esd->GetPrimaryVertexSPD();
+
+ Double_t pos[3] = { 0. };
+ Double_t covTr[21]={0.};
+ //Double_t pid[10]={0.};
+
+ Double_t p[3] = { 0. };
+
+ Double_t pDCA[3] = { 0. }; // momentum at DCA
+ Double_t rDCA[3] = { 0. }; // position at DCA
+ Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
+ Float_t cDCA[3] = {0.}; // covariance of impact parameters
+
+
+ AliESDtrack* esdTrack = esd->GetTrack(iTrack); //carefull do not modify it othwise need to work with a copy
+
+ // Track selection
+
+ AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(esd),esdTrack->GetID());
+ if(!track) return;
+
+ if(track->Pt()>0.)
+ {
+ // only constrain tracks above threshold
+ AliExternalTrackParam exParam;
+ // take the B-field from the ESD, no 3D fieldMap available at this point
+ Bool_t relate = false;
+ relate = track->RelateToVertexTPC(vtxSPD,esd->GetMagneticField(),kVeryBig,&exParam);
+ if(!relate){
+ delete track;
+ return;
+ }
+ // fetch the track parameters at the DCA (unconstraint)
+ if(track->GetTPCInnerParam()){
+ track->GetTPCInnerParam()->GetPxPyPz(pDCA);
+ track->GetTPCInnerParam()->GetXYZ(rDCA);
+ }
+ // get the DCA to the vertex:
+ track->GetImpactParametersTPC(dDCA,cDCA);
+ // set the constrained parameters to the track
+ track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
+ }
+
+ track->GetPxPyPz(p);
+
+ double p2[3];
+ esdTrack->GetInnerPxPyPz(p2);
+
+ Float_t pT = track->Pt();
+ if(pT<ptmin||pT>ptmax){
+ delete track;
+ return;
+ }
+
+ track->GetXYZ(pos);
+ track->GetCovarianceXYZPxPyPz(covTr);
+
+ ctrack->SetTPCTrack(p[0], p[1], p[2]);
+
+ delete track;
+}
+
+
+void AliJFilter::ConvertESDGCGTracks(AliESDEvent *esd, int iTrack, AliJTrack *ctrack, double ptMin, double ptMax)
+{
+
+ Double_t pos[3] = { 0. };
+ Double_t covTr[21]={0.};
+ Double_t p[3] = { 0. };
+
+ Double_t pDCA[3] = { 0. }; // momentum at DCA
+ Double_t rDCA[3] = { 0. }; // position at DCA
+ Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
+ Float_t cDCA[3] = {0.}; // covariance of impact parameters
+
+
+ AliESDtrack* esdTrack = esd->GetTrack(iTrack); //carefull do not modify it othwise need to work with a copy
+ const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();
+ if(!exParamGC) return;
+
+ // fetch the track parameters at the DCA (unconstrained)
+ esdTrack->GetPxPyPz(pDCA);
+ esdTrack->GetXYZ(rDCA);
+ // get the DCA to the vertex:
+ esdTrack->GetImpactParameters(dDCA,cDCA);
+
+ if (!esdTrack->GetConstrainedPxPyPz(p)) return;
+
+
+ Float_t pT = exParamGC->Pt();
+ if(pT<ptMin||pT>ptMax){
+ return;
+ }
+
+ esdTrack->GetConstrainedXYZ(pos);
+ exParamGC->GetCovarianceXYZPxPyPz(covTr);
+
+ ctrack->SetGCGTrack(p[0], p[1], p[2]);
+}
+
+
+
+//_________________________________________________________________________________-
+void AliJFilter::ReadESDPID(AliESDtrack *track, AliJTrack *ctrack)
+{
+ // To reduce the size of output, the variables which cannot be calculated later are only kept
+ // expected TOF signal, TPC momentum for expected TPC signal. Measured values are stored in ReadESDTrack()
+ // 1. expected TOF signal
+ Double_t times[AliPID::kSPECIES];
+ track->GetIntegratedTimes(times);
+ for(int ip=0; ip < (AliJTrack::kNAliJTrkPID); ip++) {
+ ctrack->SetExpectedTOFsignal(AliJTrack::AliJTrkPID(ip), times[ip]);
+
+ }
+ // 2. TPC momentum
+ Double_t momTPC = track->GetTPCmomentum();
+ ctrack->SetTPCmomentum(momTPC);
+}
+
+//______________________________________________________________________________
+Bool_t AliJFilter::ReadAODTracks(const AliAODEvent * aod)
+{
+ // AOD track reader
+ Bool_t hasGoodTrack;
+ hasGoodTrack = kFALSE;
+
+ // Read the AliAODtrack and fill the list of AliJTrack containers
+ Int_t nt = aod->GetNumberOfTracks();
+ Int_t listnt = 0;
+
+ DEBUG(5, 1, Form("AOD::NumberOfTracks = %d",nt) );
+
+ //==== loop over tracks ====//
+ for(Int_t it = 0; it < nt; it++) {
+
+ AliAODTrack *track = aod->GetTrack(it);
+ //if(track->GetFilterMap() & (1 << 7) ) continue;
+ //if(!AcceptAODTrack(track)) continue;
+ //if(! fEsdTrackCuts->IsSelected(track)) continue; //apply loose selection criteria
+ //FK//if(track->GetType() != AliAODTrack::kPrimary) continue; // only primaries
+ //
+
+ AliJTrack * ctrack = new( (*fTrackList)[listnt++] ) AliJTrack;
+ ctrack->SetID( track->GetID() );
+ ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
+ Double32_t pos[3];
+ track->GetXYZ(pos);
+ ctrack->SetTrackPos( pos );
+ //TODO if( fStoreTPCTrack )
+ ctrack->SetParticleType(kJNone);
+ ctrack->SetCharge(track->Charge());
+ ctrack->SetStatus(track->GetStatus());//
+ ctrack->SetFlags( track->GetFlags() );
+ ctrack->SetLabel( track->GetLabel() );
+ // //FilterMap
+ // UInt_t filterMap=0;
+ // for( unsigned int i=0;i<sizeof(filterMap)*8;i++ ){
+ // if( track->TestFilterBit( BIT(i) )){
+ // SETBIT( filterMap , i);
+ // }
+ // }
+ ctrack->SetFilterMap( track->GetFilterMap() );
+
+ //PID TODO
+ double const * pid = track->PID();
+ ctrack->SetPID(AliJTrack::kElectronAliJ,pid[AliAODTrack::kElectron],AliJTrack::kTOF);
+ ctrack->SetPID(AliJTrack::kMuonAliJ, pid[AliAODTrack::kMuon], AliJTrack::kTOF);
+ ctrack->SetPID(AliJTrack::kPionAliJ, pid[AliAODTrack::kPion], AliJTrack::kTOF);
+ ctrack->SetPID(AliJTrack::kKaonAliJ, pid[AliAODTrack::kKaon], AliJTrack::kTOF);
+ ctrack->SetPID(AliJTrack::kProtonAliJ, pid[AliAODTrack::kProton], AliJTrack::kTOF);
+ //TPC
+ ctrack->SetTPCnClust(track->GetTPCNcls());
+ ctrack->SetTPCdEdx( track->GetTPCsignal() );
+ ctrack->SetTOFsignal( track->GetTOFsignal() );
+ ctrack->SetLabel( track->GetLabel() );
+ for( int i=0;i<int(sizeof(UInt_t)*8);i++ ){
+ ctrack->SetBit( i, track->TestBit( i ));
+ }
+
+ // check track threshold
+ if( track->Pt() > fTrackThreshold )
+ hasGoodTrack = kTRUE;
+
+ //if(fMyTask->DebugLevel() > 5 && track->P()>1 ) cout << "P = " << track->P() << endl;
+ } // end tracks loop
+
+ return hasGoodTrack;
+}
+
+
+//______________________________________________________________________________
+AliJEventHeader* AliJFilter::ReadCommonHeader(AliVEvent *event){
+ //Read the AliVEvent and fill the list of AliJEventHeader containers
+ //create a header and fill it
+ AliJEventHeader *hdr = new( (*fHeaderList)[fHeaderList->GetEntriesFast()] ) AliJEventHeader;
+
+
+ // Get Centrality as a percent from 0% to 100%
+ AliCentrality *cent = event->GetCentrality();
+ if( cent ){
+ hdr->SetCentrality( cent->GetCentralityPercentile("V0M"));
+ hdr->SetCentralityArray(AliJEventHeader::kcV0M, cent->GetCentralityPercentile("V0M"));
+ hdr->SetCentralityArray(AliJEventHeader::kcFMD, cent->GetCentralityPercentile("FMD"));
+ hdr->SetCentralityArray(AliJEventHeader::kcTRK, cent->GetCentralityPercentile("TRK"));
+ hdr->SetCentralityArray(AliJEventHeader::kcTKL, cent->GetCentralityPercentile("TKL"));
+ hdr->SetCentralityArray(AliJEventHeader::kcCL0, cent->GetCentralityPercentile("CL0"));
+ hdr->SetCentralityArray(AliJEventHeader::kcCL1, cent->GetCentralityPercentile("CL1"));
+ hdr->SetCentralityArray(AliJEventHeader::kcV0MvsFMD, cent->GetCentralityPercentile("V0MvsFMD"));
+ hdr->SetCentralityArray(AliJEventHeader::kcTKLvsV0, cent->GetCentralityPercentile("TKLvsV0"));
+ hdr->SetCentralityArray(AliJEventHeader::kcZEMvsZDC, cent->GetCentralityPercentile("ZEMvsZDC"));
+ hdr->SetCentralityArray(AliJEventHeader::kcV0A, cent->GetCentralityPercentile("V0A"));
+ hdr->SetCentralityArray(AliJEventHeader::kcV0C, cent->GetCentralityPercentile("V0C"));
+ }
+ hdr->SetTriggerMaskAlice(event->GetTriggerMask()); //ULong64_t
+ hdr->SetTriggerMaskJCorran(ConvertTriggerMask()); //UInt_t
+ hdr->SetEventType(event->GetEventType());
+ hdr->SetBunchCrossNumber(event->GetBunchCrossNumber());
+
+ int ncontributors = 0;
+ const AliVVertex * vtxESD = event->GetPrimaryVertex();
+ if(vtxESD){
+ hdr->SetXVertex(vtxESD->GetX()); //FK// EFF
+ hdr->SetYVertex(vtxESD->GetY()); //FK// EFF
+ hdr->SetZVertex(vtxESD->GetZ());
+ //hdr->SetZVertexErr(vtxESD->GetZRes());
+ double covMat[6];
+ vtxESD->GetCovarianceMatrix(covMat);
+ hdr->SetZVertexErr(TMath::Sqrt(covMat[5])); // GetZRes := TMath::Sqrt(fCovZZ)
+ ncontributors = vtxESD->GetNContributors(); // get number of contributors to vertex
+ hdr->SetVtxMult( vtxESD->GetNContributors() );
+ }else{
+ hdr->SetZVertex(9999);
+ hdr->SetZVertexErr(9999);
+ }
+ hdr->SetVtxMult(ncontributors); //FK// EFF contrib to vertex
+ return hdr;
+}
+//______________________________________________________________________________
+void AliJFilter::ReadESDHeader(AliESDEvent *esd)
+{
+ // Read the AliESDEvent and fill the list of AliJEventHeader containers
+ if(!esd) return;
+ if( fAliJRunHeader->GetRefitESDVertexTracks() )
+ AliESDUtils::RefitESDVertexTracks( esd ); // TODO only for LHC11a right?
+ AliJEventHeader *hdr = ReadCommonHeader( esd );
+ // AliMultiplicity *fSPDMult =(AliMultiplicity *) esd->GetMultiplicity();
+ // if(fSPDMult) hdr->SetSPDTrackletMult(fSPDMult->GetNumberOfTracklets());
+ // This is moved from ReadCommonHeader. AOD should have same.TODO!!
+ AliESDVZERO *v0 = esd->GetVZEROData();
+
+ if( v0 ) hdr->SetV0Mult(v0->GetMTotV0A() + v0->GetMTotV0C());
+ if( v0 ) hdr->SetV0AMult(v0->GetMTotV0A());
+ if( v0 ) hdr->SetV0CMult(v0->GetMTotV0C());
+
+ const AliESDRun* esdRun = esd->GetESDRun();
+ //cout <<"========================"<<endl;
+ //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kSPD) << endl;
+ //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kSSD) << endl;
+ //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kSDD) << endl;
+ //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kTPC) << endl;
+ if(esdRun->GetDetectorsInReco() & AliDAQ::kSPD) hdr->SetSPDTrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTracklets, 1.0 ));
+ if((esdRun->GetDetectorsInReco() & AliDAQ::kSSD) || (esdRun->GetDetectorsInReco() & AliDAQ::kSDD)) hdr->SetITSSATrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTrackletsITSSA, 1.0 ));
+ if(esdRun->GetDetectorsInReco() & AliDAQ::kTPC) hdr->SetITSTPCTrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTrackletsITSTPC, 1.0 ));
+
+
+ //TODO Store Detector data
+ if( fAliJRunHeader->GetStoreEventPlaneSource() ){
+ *fVZEROData = *esd->GetVZEROData();
+ *fTZEROData = AliESDTZERO(*esd->GetESDTZERO());
+ *fZDCData = *esd->GetESDZDC();
+ }
+ hdr->SetEventID( esd->GetEventNumberInFile());
+ //const AliESDVertex * vtxESD = esd->GetPrimaryVertex();
+ //if( vtxESD->GetStatus() == 0 ) hdr->SetVtxMult( 0 );
+ // if fNcontributes > 0 then status is always true. do we need this?
+
+ //==== MC ====/
+ if( IsMC() ){
+ const AliVVertex * primaryMCVertex = MCEvent()->GetPrimaryVertex();
+ //cout<<"AliMCEvent = "<<MCEvent()<<endl;
+ //cout<<"AliVVertex = "<<primaryMCVertex<<endl;
+ if( primaryMCVertex ){
+ hdr->SetXVertexMC( primaryMCVertex->GetX() );
+ hdr->SetYVertexMC( primaryMCVertex->GetY() );
+ hdr->SetZVertexMC( primaryMCVertex->GetZ() );
+ }
+ AliESDHeader * esdHeader = esd->GetHeader();
+ hdr->SetL0TriggerInputs( esdHeader->GetL0TriggerInputs() );
+ }
+}
+
+//______________________________________________________________________________
+void AliJFilter::ReadAODHeader(AliAODEvent *aod)
+{
+ //Read the AliAODEvent and fill the list of AliJEventHeader containers
+ AliJEventHeader *hdr = ReadCommonHeader( aod );
+
+ const AliAODTracklets *trackletsSPD = aod->GetTracklets();
+ if(trackletsSPD){
+ hdr->SetSPDTrackletMult(trackletsSPD->GetNumberOfTracklets());
+ }
+
+ hdr->SetFiredTriggers( aod->GetFiredTriggerClasses() );
+ //TODO hdr->SetEventID( esd->GetEventNumberInFile());
+ //==== MC ====//
+ if( IsMC() ){
+ AliAODMCHeader *aodMCheader = (AliAODMCHeader *) aod->FindListObject(AliAODMCHeader::StdBranchName());
+ hdr->SetXVertexMC( aodMCheader->GetVtxX() );
+ hdr->SetYVertexMC( aodMCheader->GetVtxY() );
+ hdr->SetZVertexMC( aodMCheader->GetVtxZ() );
+ }
+
+ AliAODHeader * ah = aod->GetHeader();
+ hdr->SetESDFileName( ah->GetESDFileName() );
+ hdr->SetEventNumberESDFile( ah->GetEventNumberESDFile() );
+}
+
+//______________________________________________________________________________
+Int_t AliJFilter::GetSuperModuleNumber(bool isemcal, AliVCluster *cluster, AliVCaloCells *cells, Int_t absId)
+{
+ //get super module number
+ if(isemcal){
+ Int_t absIdMax = -1, iSM =-1, ieta = -1, iphi = -1;
+ Bool_t shared = kFALSE;
+ fEMCALRecoUtils->GetMaxEnergyCell(fEMCALGeometry, cells, cluster, absIdMax, iSM, ieta, iphi, shared);
+
+ if(iSM < 0 || iphi < 0 || ieta < 0 )
+ {
+ AliFatal(Form("Negative value for super module: %d, or cell ieta: %d, or cell iphi: %d, check EMCAL geometry name\n",
+ iSM,ieta,iphi));
+ }
+
+ return iSM ;
+
+ } else {
+ Int_t relId[4];
+ if ( absId >= 0) {
+ fPHOSGeom->AbsToRelNumbering(absId,relId);
+ fPHOSGeom->AbsToRelNumbering(absId,relId);
+ return relId[0]-1;
+ } else return -1;
+ }//PHOS
+
+ return -1;
+}
+
+//______________________________________________________________________________
+Double_t * AliJFilter::GetCellsAmplitude( bool isemcal, AliVCluster *cluster, AliVCaloCells *emCells, AliVCaloCells *phoCells )
+{
+ // cell amplitude reader
+ Int_t iCell, nCell;
+ UShort_t *cellAddrs;
+ Double_t *amps;
+
+ // get cluster cells
+ nCell = cluster->GetNCells();
+
+ amps = new Double_t[nCell];
+
+ // get the cell addresses
+ cellAddrs = cluster->GetCellsAbsId();
+
+ // get the cell amplitudes
+ for( iCell = 0; iCell < nCell; iCell++ ){
+ if( isemcal )
+ amps[iCell] = emCells->GetCellAmplitude( cellAddrs[iCell] );
+ else
+ amps[iCell] = phoCells->GetCellAmplitude( cellAddrs[iCell] );
+
+ }
+
+ return amps;
+}
+
+//_____________________________________________________________________________
+
+UInt_t AliJFilter::ConvertTriggerMask(){
+
+ //convert alice trigger mask to jcorran trigger mask
+ UInt_t triggerMaskJC=0;
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kMB){
+ // minimum bias TBit 0
+ triggerMaskJC |= (1<<kMinBiasTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kMinBiasTriggerBitJCorran, "MinBiasTriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kHighMult){
+ //high multiplicity trigger TBit 1
+ triggerMaskJC |= (1<<kHighMultTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kHighMultTriggerBitJCorran,"HighMultTriggerBitJCorran");
+ }
+
+ if((((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kEMC1) ||
+ (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kEMC7 )){
+ //EMCAL L0 TBit2
+ triggerMaskJC |= (1<<kEmc0TriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kEmc0TriggerBitJCorran,"Emc0TriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kEMCEGA){
+ //EMCAL Gamma TBit3
+ triggerMaskJC |= (1<<kEmc1GammaTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kEmc1GammaTriggerBitJCorran,"Emc1GammaTriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kEMCEJE){
+ //EMCAL JET TBit4
+ triggerMaskJC |= (1<<kEmc1JetTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kEmc1JetTriggerBitJCorran,"Emc1JetTriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kCentral){
+ //central trigger TBit 5
+ triggerMaskJC |= (1<<kCentralTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kCentralTriggerBitJCorran,"CentralTriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kSemiCentral){
+ //semi-central trigger TBit 6
+ triggerMaskJC |= (1<<kSemiCentralTriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kSemiCentralTriggerBitJCorran,"SemiCentralTriggerBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kFastOnly){
+ //semi-central trigger TBit 6
+ triggerMaskJC |= (1<<kFastOnlyBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kFastOnlyBitJCorran ,"FastOnlyBitJCorran");
+ }
+
+ if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kINT7){
+ // minimum bias TBit 0
+ triggerMaskJC |= (1<<kINT7TriggerBitJCorran);
+ fAliJRunHeader->SetActiveTriggersJCorran( kINT7TriggerBitJCorran, "INT7TriggerBitJCorran");
+ }
+
+ return triggerMaskJC;
+}
+
+
+//______________________________________________________________________________
+void AliJFilter::ReadMCTracksFromESD(){
+ //store MC information from AliStack
+ if(!MCEvent()) return;
+ AliStack *stack = MCEvent()->Stack();
+ if(!stack) return;
+ Int_t np = MCEvent()->GetNumberOfTracks();
+
+ // AliGenEventHeader* genHeader = fMC->GenEventHeader();
+ // AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
+ // Double_t ptHard = 0;
+ // Double_t nTrials = 1; // Trials for MC trigger weigth for real data
+ // nTrials = pythiaGenHeader->Trials();
+ // ptHard = pythiaGenHeader->GetPtHard();
+ // Int_t nprim = stack->GetNtrack();
+
+ Long64_t ntrack = 0;
+
+ for(Long64_t iTrack = 0; iTrack < np; iTrack++){
+ AliMCParticle *track = (AliMCParticle*) MCEvent()->GetTrack(iTrack);
+ if(!track){
+ Printf("ERROR: Could not receive track %d",(int) iTrack);
+ continue;
+ }
+ Bool_t isPrimary = stack->IsPhysicalPrimary(iTrack);
+ if(isPrimary){
+ //create a new JMCTrack and fill the track info
+ AliJMCTrack *ctrack = new( (*fMCTrackList)[ntrack++] ) AliJMCTrack;
+
+ TParticle *partStack = stack->Particle(iTrack);
+ Int_t pdg = partStack->GetPdgCode();
+
+ Char_t ch = (Char_t) partStack->GetPDG()->Charge();
+ Int_t label = track->GetLabel();
+
+ ctrack->SetLabel(label);
+ ctrack->SetPdgCode(pdg);
+ ctrack->SetPxPyPzE( partStack->Px(), partStack->Py(), partStack->Pz(), partStack->Energy());
+ ctrack->SetCharge(ch);
+ ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary);
+
+ ctrack->SetProductionVertex(partStack->Vx(),partStack->Vy(),partStack->Vz());
+ }// loop for al primary tracks
+ }
+}
+
+//--------------------------------------------------------------------
+void AliJFilter::ReadMCTracksFromAOD(){
+ //retreive MC particles from event //FKEFF//
+ if(!AODEvent()) return; TClonesArray *mcArray = (TClonesArray*) AODEvent()->
+ FindListObject(AliAODMCParticle::StdBranchName());
+ if(!mcArray){
+ Printf("No MC particle branch found");
+ return;
+ }
+
+ Long64_t ntrack = 0;
+ Long64_t np = mcArray->GetEntriesFast();
+
+ for(Long64_t it = 0; it < np; it++) {
+ AliAODMCParticle *track = (AliAODMCParticle*) mcArray->At(it);
+ if(!track){
+ Error("ReadEventAODMC", "Could not receive particle %d",(int) it);
+ continue;
+ }
+ bool isPrimary = track->IsPhysicalPrimary();
+ if(isPrimary){
+ //create a new JMCTrack and fill the track info
+ AliJMCTrack *ctrack = new ((*fMCTrackList)[ntrack++]) AliJMCTrack;;
+
+ Int_t pdg = track->GetPdgCode();
+
+ Char_t ch = (Char_t) track->Charge();
+ Int_t label = track->GetLabel();
+
+ ctrack->SetLabel(label);
+ ctrack->SetPdgCode(pdg);
+ ctrack->SetPxPyPzE( track->Px(), track->Py(), track->Pz(), track->E());
+ ctrack->SetCharge(ch);
+ ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary);
+
+ ctrack->SetProductionVertex(track->Xv(),track->Yv(),track->Zv());
+ }
+ }
+
+}
+
+
+//--------------------------------------------------------------------
+void AliJFilter::RemapMCLabels(){
+ // remaps all MC labels to the new arrays
+
+ Int_t i, j, label, mother0, mother1;
+ AliJTrack *track;
+ AliJPhoton *cluster;
+ // BS AliJCaloCell *cell;
+ AliJMCTrack *mctrack;
+
+ // tracks
+ for( i = 0; i < fTrackList->GetEntries(); i++ ){
+ track = (AliJTrack*)fTrackList->At( i );
+
+ track->SetLabel( fMcMap->At( track->GetLabel() ));
+ }
+
+ // clusters
+ if( fAliJRunHeader->GetStoreEMCalInfo() ){
+ for( i = 0; i < fPhotonList->GetEntries(); i++ ){
+ cluster = (AliJPhoton*)fPhotonList->At( i );
+ for( j = 0; j < cluster->GetNEMCLabel(); j++ ){
+ label = cluster->GetEMCLabel( j );
+ // no label clusters protection
+ if( label >= 0 )
+ cluster->SetEMCLabel( j, fMcMap->At( label ));
+ }
+ }
+
+ /* BS
+ // cells
+ for( i = 0; i < fCaloCellList->GetEntries(); i++ ){
+ cell = (AliJCaloCell*)fCaloCellList->At( i );
+ label = cell->GetMcLabel();
+// no label cells protection
+if( label >= 0 )
+cell->SetMcLabel( fMcMap->At( cell->GetMcLabel() ));
+}
+*/
+}
+
+// MC particles
+for( i = 0; i < fMCTrackList->GetEntries(); i++ ){
+ mctrack = (AliJMCTrack*)fMCTrackList->At( i );
+
+ mother0 = mctrack->GetMother( 0 );
+ mother1 = mctrack->GetMother( 1 );
+
+ if( mother0 >= 0 )
+ mother0 = fMcMap->At( mother0 );
+ if( mother1 >= 0 )
+ mother1 = fMcMap->At( mother1 );
+
+ mctrack->SetMother( mother0, mother1 );
+}
+}
+
+//--------------------------------------------------------------------
+
+
+void AliJFilter::PrintOut() const {
+ //AliJRunHeader * RunInfo = fAliJRunHeader;
+}
+
+//********************************************
+// UTILS
+//********************************************
+void AliJFilter::AddList(const char* aname, const char* cname, TClonesArray **obj, int nlist){
+ *obj = new TClonesArray(cname, nlist);
+ (*obj)->SetName(aname);
+ (*obj)->SetOwner();
+}
+
--- /dev/null
+// $Id: AliJFilter.h,v 1.5 2012/04/19 15:19:52 jkral Exp $
+
+//______________________________________________________________________________
+// Analysis task for high pt particle correlations
+// author: R.Diaz, J. Rak, D.J. Kim
+// ALICE Group University of Jyvaskyla
+// Finland
+//
+// Fill the analysis containers for ESD or AOD
+// Note: Adapted for AliAnalysisTaskSE
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef ALIJFILTER_H
+#define ALIJFILTER_H
+
+#include "TNamed.h"
+#include "AliJRunHeader.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
+#include "AliAnalysisTaskSE.h"
+#include <iostream>
+
+#include <AliJConst.h>
+#include <TVectorT.h>
+
+//==============================================================
+
+#ifndef AliJMaxDimBuffer
+#define AliJMaxDimBuffer
+const int kMaxDimBuffer = 300;//max length of a line read to a buffe
+#endif
+
+class AliJEventHeader;
+class AliJRunHeader;
+class AliJTrack;
+class AliAnalysisTaskSE;
+
+class TH1D;
+class TH2D;
+class TNtuple;
+class TList;
+class TTree;
+class TFormula;
+class TRefArray;
+class TArrayI;
+
+class AliMCEvent;
+class AliESDEvent;
+class AliESDtrack;
+class AliAODEvent;
+class AliAODTrack;
+class AliESDtrackCuts;
+class AliESDVZERO;
+class AliESDCentrality;
+class AliVCluster;
+class AliVCaloCells;
+class AliVEvent;
+
+class AliEMCALGeometry;
+class AliEMCALGeoUtils;
+class AliEMCALRecoUtils;
+class AliPHOSGeoUtils;
+
+class AliMCEvent;
+class AliAnalysisFilter;
+
+class AliESDTZERO;
+class AliESDZDC;
+class AliPIDResponse;
+class AliPIDResponse;
+class AliPIDCombined;
+class AliESDTZERO;
+class AliAnalysisUtils;
+
+using namespace std;
+
+class AliJFilter : public TNamed {
+
+ public:
+ AliJFilter();
+ AliJFilter(const char *name, AliAnalysisTaskSE *task);
+ AliJFilter(const AliJFilter& ap);
+ AliJFilter& operator = (const AliJFilter& ap);
+ virtual ~AliJFilter();
+
+ // methods to fill from AliAnalysisTaskSE
+ virtual void UserCreateOutputObjects();
+ virtual void Init();
+ virtual void LocalInit() { Init(); }
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t * opt = "");
+
+
+ void SetTrackFilter( AliAnalysisFilter * filter ){ fESDFilter = filter; }
+ bool GetEventSuccess() const { return fEventSuccess; }
+ //are ESDs from real exp or MonteCarlo
+ // AliEMCALGeoUtils* GetEMCALGeoUtils (bool doDelete=kFALSE);
+ void SetClusterThreshold(double t) { fClusterThreshold = t; }
+ void SetTrackThreshold(double t) { fTrackThreshold = t; }
+ void SetMyTask( AliAnalysisTaskSE *t ) { fMyTask = t; }
+ TClonesArray *GetTrackList() const { return fTrackList; }
+ TClonesArray *GetPhotonList() const { return fPhotonList; }
+ TClonesArray *GetCaloCellList() const { return fCaloCellList; }
+ TClonesArray *GetMCTrackList() const { return fMCTrackList; }
+ TClonesArray *GetHeaderList() const { return fHeaderList; }
+ TList *GetRunInfoList() const { return fRunInfoList; }
+
+ AliESDVZERO *GetESDVZERO() const { return fVZEROData; }
+ AliESDTZERO *GetESDTZERO() const { return fTZEROData; }
+ // AliESDFMD* fFMDData;
+ AliESDZDC* GetESDZDC() const { return fZDCData; }
+
+ TClonesArray **GetTrackListP() { return &fTrackList; }
+ TClonesArray **GetPhotonListP() { return &fPhotonList; }
+ TClonesArray **GetCaloCellListP() { return &fCaloCellList; }
+ TClonesArray **GetMCTrackListP() { return &fMCTrackList; }
+ TClonesArray **GetHeaderListP() { return &fHeaderList; }
+ TList **GetRunInfoListP() { return &fRunInfoList; }
+
+ AliESDVZERO** GetESDVZEROP() { return &fVZEROData; }
+ AliESDTZERO** GetESDTZEROP() { return &fTZEROData; }
+ // AliESDFMD* fFMDData;
+ AliESDZDC** GetESDZDCP() { return &fZDCData; }
+
+ Bool_t GetStoreEventPlaneSource(){ return fAliJRunHeader->GetStoreEventPlaneSource(); }
+ Bool_t GetStoreEMCalInfo(){ return fAliJRunHeader->GetStoreEMCalInfo(); }
+ AliESDEvent * ESDEvent(){ return FromESD()? dynamic_cast<AliESDEvent*>(Event()):NULL;}
+ AliAODEvent * AODEvent(){ return FromAOD()? dynamic_cast<AliAODEvent*>(Event()):NULL;}
+ AliVEvent * Event(){ return fMyTask->InputEvent(); }
+ AliMCEvent * MCEvent(){ return IsMC()?fMyTask->MCEvent():NULL; }
+
+ Bool_t IsMC(){ return fAliJRunHeader->IsMC(); }
+ Bool_t FromESD(){ return fAliJRunHeader->FromESD(); }
+ Bool_t FromAOD(){ return fAliJRunHeader->FromAOD(); }
+
+ AliJRunHeader* GetAliJRunHeader() const { return fAliJRunHeader; }
+ void SetAliJRunHeader( AliJRunHeader* header ){ fAliJRunHeader=header; }
+ private:
+
+ Int_t DebugLevel(){ return fMyTask->DebugLevel(); }
+ inline void DEBUG(int level, int type, TString msg1, TString msg2=""){
+ if(DebugLevel()>level) std::cout<<type<<"\t"<<msg1<<" : "<<msg2<<std::endl;
+ }
+
+ AliJEventHeader* ReadCommonHeader(AliVEvent *event);
+ // methods to read data from ESD
+ void ReadESDTracks(AliESDEvent* esd);
+ void ConvertESDTPCOnlyTracks(AliESDEvent* esd, int iTrack, AliJTrack * ctrack, double ptMin, double ptMax);
+ void ConvertESDGCGTracks(AliESDEvent* esd, int iTrack, AliJTrack * ctrack, double ptMin, double ptMax);
+ void ReadESDCaloClusters(const AliESDEvent* esd);
+ void ReadESDCaloCells(const AliESDEvent* esd);
+ void ReadESDHeader(AliESDEvent* esd);
+ void ReadESDPID(AliESDtrack* track, AliJTrack* ctrack);
+ // methods to read data from AOD
+ Bool_t ReadAODTracks(const AliAODEvent* aod);
+ Bool_t ReadAODCaloClusters(const AliAODEvent* aod);
+ void ReadAODCaloCells(const AliAODEvent* aod);
+ void ReadAODHeader(AliAODEvent* aod);
+ void ReadFilter();
+ void ReadMCTracksFromESD();
+ void ReadMCTracksFromAOD();
+ void RemapMCLabels();
+
+ Int_t GetSuperModuleNumber(bool isemcal, AliVCluster *cluster, AliVCaloCells *cells, Int_t absId);
+ Double_t* GetCellsAmplitude( bool isemcal, AliVCluster *cluster, AliVCaloCells *emCells, AliVCaloCells *phoCells );
+
+ UInt_t ConvertTriggerMask();//Converts alice trigger mask to JCorran trigger mask
+ //functions used for event selction:
+ bool AcceptAODTrack(AliAODTrack* aodTrack);
+ void SetOADBPath(const char* path) {fOADBPath=path;}
+ const char* GetOADBPath() const { return fOADBPath.Data(); }
+
+ // method to fill jcorran
+ void PrintOut() const;
+
+ // UTILS
+ void AddList(const char* aname, const char* cname, TClonesArray **obj, int nlist);
+
+ // d a t a m e m b e r s
+ AliESDtrackCuts* fEsdTrackCuts; // track selection cuts
+ AliAnalysisFilter * fESDFilter; // filter set of track selection BS
+ TVectorT<double> fIsRealOrMC; // flags if the input are real (0) ESDs or MonteCarlo ESDs (1)
+ TString fActiveTriggers[kRangeTriggerTableAlice]; // alice table mapping trigger bit to trigger name
+ TString fTriggerTableJCorran[kRangeTriggerTableJCorran]; // JCorran trigger table TBit 0 =MinBias
+ Bool_t fStoreEventPlaneSource; // store event plane
+ TString fOADBPath; // oadb path
+ TRefArray *fCaloClustersArr; //! calo cluster array
+ Double_t fClusterThreshold; // for event tropping
+ Double_t fTrackThreshold; // for event tropping
+ Bool_t fEventSuccess; //! if filter was successful with current event
+
+ TArrayI *fMcMap; //! mc index map
+
+ // jcorran output objects
+ TClonesArray * fTrackList; //! list of charged track objects
+ TClonesArray * fMCTrackList; //! list of charged track objects
+ TClonesArray * fPhotonList; //! list of photons objects
+ TClonesArray * fCaloCellList; //! list of calo cells
+ TClonesArray * fHeaderList; //! event details
+ TList * fRunInfoList; //! run details
+ AliPIDResponse *fPIDResponse; //! PID response object
+ AliPIDCombined *fPIDCombined; //! PID response object
+
+ AliESDVZERO* fVZEROData; //!
+ AliESDTZERO* fTZEROData; //!
+ // AliESDFMD* fFMDData;
+ AliESDZDC* fZDCData; //!
+
+ vector<Int_t> fEMCLabels; //! EMCal hit labels
+ vector<Int_t> fEMCTreeLabels; //! cascades for EMCal hits
+
+ AliJRunHeader* fAliJRunHeader; //! run details (mg field, trigger mask,etc...)
+ AliEMCALGeometry * fEMCALGeometry; //! emcal geometry
+ AliEMCALRecoUtils * fEMCALRecoUtils; //! reco utils
+ AliPHOSGeoUtils * fPHOSGeom; //! phos geometry matrix
+ AliAnalysisUtils *fAnaUtils; //! analysis utils ALICE
+ AliAnalysisTaskSE *fMyTask; //! task pointer
+
+
+ ClassDef(AliJFilter, 1);
+};
+#endif // AliJFilter_H
--- /dev/null
+#include "AliJHistManager.h"
+using namespace std;
+//////////////////////////////////////////////////////
+// AliJBin
+//////////////////////////////////////////////////////
+
+AliJNamed::AliJNamed(TString name, TString title, TString opt, int mode) :
+ fName(name),
+ fTitle(title),
+ fOption(opt),
+ fMode(mode)
+{
+ // constructor
+}
+
+AliJNamed::~AliJNamed(){
+ // virtual destructor for base class
+}
+
+TString AliJNamed::GetOption(TString key){
+ TPMERegexp a("&"+key+"=?([^&]*)","i");
+ int nMatch = a.Match(fOption);
+ if( nMatch < 2 ) return UndefinedOption();
+ return a[1];
+}
+void AliJNamed::SetOption( TString key, TString value){
+ TPMERegexp a("&"+key+"=?[^&]*","i");
+ int nMatch = a.Match(fOption);
+ TString newOpt = "&"+key +( value.Length()?"="+value:"");
+ if( value == UndefinedOption() ) newOpt = "";
+ if( nMatch < 1 ) fOption += newOpt;
+ else fOption.ReplaceAll( a[0], newOpt );
+}
+void AliJNamed::RemoveOption( TString key ){
+ SetOption( key, UndefinedOption() );
+}
+TString AliJNamed::UndefinedOption(){
+ //static TString undefinedOption = "Undefined";
+ //return undefinedOption;
+ return "Undefined";
+}
+
+//////////////////////////////////////////////////////
+// AliJBin
+//////////////////////////////////////////////////////
+
+//_____________________________________________________
+AliJBin::AliJBin():
+ AliJNamed("AliJBin","%.2f-%2.f", "&Mode=Range", kRange),
+ fBinD(0),
+ fBinStr(0),
+ fIsFixedBin(false),
+ fIndexName("H"),
+ fHMG(NULL)
+{;}
+//_____________________________________________________
+AliJBin::AliJBin(TString config, AliJHistManager * hmg):
+ AliJNamed("AliJBin","%.2f-%2.f", "&Mode=Range", kRange),
+ fBinD(0),
+ fBinStr(0),
+ fIsFixedBin(false),
+ fIndexName("H"),
+ fHMG(NULL)
+{
+ cout<< config<<endl;
+ std::vector<TString> t = Tokenize(config, " \t,");
+ TString type = t[0];
+ SetName( t[1] );
+ fIndexName = t[2] ;
+ SetTitle( t[3] );
+ fTitle.ReplaceAll("\"","" );
+ SetFullOption( t[4] );
+ fMode = GetMode( GetOption("mode") );
+ AddToManager( hmg );
+ TString s;
+ for( int i=5;i<int(t.size());i++ ) s+=" "+t[i];
+ SetBin(s);
+}
+
+//_____________________________________________________
+AliJBin::AliJBin(const AliJBin& obj) :
+ AliJNamed(obj.fName,obj.fTitle,obj.fOption,obj.fMode),
+ fBinD(obj.fBinD),
+ fBinStr(obj.fBinStr),
+ fIsFixedBin(obj.fIsFixedBin),
+ fIndexName(obj.fIndexName),
+ fHMG(obj.fHMG)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJBin& AliJBin::operator=(const AliJBin& obj)
+{
+ // assignment operator
+ if(this != &obj){
+ // TODO: proper implementation
+ }
+ return *this;
+}
+
+//_____________________________________________________
+void AliJBin::FixBin(){
+ if(fIsFixedBin ) return;
+ fIsFixedBin = true;
+ if(!fHMG) AddToManager( AliJHistManager::CurrentManager());
+
+}
+//_____________________________________________________
+void AliJBin::AddToManager( AliJHistManager* hmg ){
+ hmg->Add(this);
+}
+//_____________________________________________________
+AliJBin & AliJBin::Set( TString name, TString iname, TString title, int mode){
+ SetNameTitle( name, title );
+ fIndexName = iname;
+ fMode = mode;
+ SetOption("mode",GetModeString(mode));
+ return *this;
+}
+//_____________________________________________________
+TString AliJBin::GetModeString(int i){
+ static TString mode[] = { "Single","Range","String" };
+ if( i<0 || i>2 ) return "";
+ return mode[i];
+}
+int AliJBin::GetMode( TString mode ){
+ for( int i=0;i<kNMode;i++ ) if( mode == GetModeString(i) ) return i;
+ return -1;
+}
+//_____________________________________________________
+AliJBin & AliJBin::SetBin( const int n, const float * v ){
+ for( int i=0;i<n;i++ ) AddBin( v[i] );FixBin();
+ return *this;
+}
+//_____________________________________________________
+AliJBin & AliJBin::SetBin( const int n, const double * v ){
+ for( int i=0;i<n;i++ ) AddBin( v[i] );FixBin();
+ return *this;
+}
+AliJBin & AliJBin::SetBin( TVector *v ){
+ for( int i=0;i<v->GetNrows();i++ ) AddBin( (v->GetMatrixArray())[i] );FixBin();
+ return *this;
+}
+//_____________________________________________________
+AliJBin& AliJBin::SetBin(const TString v){
+ std::vector<TString> ar = Tokenize( v, "\t ,");
+ for( UInt_t i=0; i<ar.size();i++ ) AddBin( ar[i] );FixBin();
+ return *this;
+}
+
+//_____________________________________________________
+AliJBin& AliJBin::SetBin(const int n){
+ for( UInt_t i=0; i<UInt_t(n);i++ ) AddBin( i );FixBin();
+ return *this;
+}
+//_____________________________________________________
+void AliJBin::AddBin( const TString& v ){
+ if( fIsFixedBin ) { JERROR( "You can't Add Bin"); }
+ fBinStr.push_back( (v=="_")?"":v );
+ fBinD.push_back( v.Atof() );
+}
+//_____________________________________________________
+void AliJBin::AddBin( float v ){
+ if( fIsFixedBin ) { JERROR( "You can't Add Bin"); }
+ fBinD.push_back( v );
+ fBinStr.push_back(Form("%f",v));
+}
+//_____________________________________________________
+TString AliJBin::BuildTitle( int i ){
+ if( i < 0 || i > Size() ) return "";
+ if( fMode == kSingle )
+ return TString(Form(fTitle.Data(), fBinD[i] ));
+ if( fMode == kRange )
+ return TString(Form(fTitle.Data(), fBinD[i], fBinD[i+1]));
+ if( fMode == kString )
+ return TString( Form(fTitle.Data(), fBinStr[i].Data()) );
+ JERROR( TString("Bad Mode of AliJBin type ") + char(fMode) + " in " + fName+ "!!!" );
+ return "";
+}
+//_____________________________________________________
+TString AliJBin::GetString(){
+ SetOption( "mode",GetModeString(fMode) );
+ return "AliJBin\t"+fName+"\t"+fIndexName+"\t\""+fTitle+"\""+"\t"+fOption+"\t"+Join(fBinStr," ");
+
+}
+//_____________________________________________________
+void AliJBin::Print(){
+ std::cout<<"*"+GetString()<<std::endl;
+}
+
+//////////////////////////////////////////////////////
+// AliJArrayBase
+//////////////////////////////////////////////////////
+
+//_____________________________________________________
+AliJArrayBase::AliJArrayBase():
+ AliJNamed("AliJArayBase","","&Dir=default&Lazy",0),
+ //AliJNamed("AliJArayBase","","&Dir=default&LessLazy",0),
+ fDim(0),
+ fIndex(0),
+ fArraySize(0),
+ fNGenerated(0),
+ fIsBinFixed(false),
+ fIsBinLocked(false),
+ fAlg(NULL)
+{
+ // constrctor
+}
+//_____________________________________________________
+AliJArrayBase::~AliJArrayBase(){
+ //destructor
+ if(fAlg) delete fAlg;
+}
+
+//_____________________________________________________
+AliJArrayBase::AliJArrayBase(const AliJArrayBase& obj) :
+ AliJNamed(obj.fName,obj.fTitle,obj.fOption,obj.fMode),
+ fDim(obj.fDim),
+ fIndex(obj.fIndex),
+ fArraySize(obj.fArraySize),
+ fNGenerated(obj.fNGenerated),
+ fIsBinFixed(obj.fIsBinFixed),
+ fIsBinLocked(obj.fIsBinLocked),
+ fAlg(obj.fAlg)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJArrayBase& AliJArrayBase::operator=(const AliJArrayBase& obj)
+{
+ // assignment operator
+ if(this != &obj){
+ // TODO: proper implementation
+ }
+ return *this;
+}
+
+//_____________________________________________________
+void* AliJArrayBase::GetItem(){
+ void * item = fAlg->GetItem();
+ if( !item ){
+ BuildItem() ;
+ item = fAlg->GetItem();
+ }
+ return item;
+}
+//_____________________________________________________
+void* AliJArrayBase::GetSingleItem(){
+ if(fMode == kSingle )return GetItem();
+ JERROR("This is not single array");
+ return NULL;
+}
+//_____________________________________________________
+void AliJArrayBase::FixBin(){
+ if( Dimension() == 0 ){
+ AddDim(1);SetOption("Single");
+ fMode = kSingle;
+ if( HasOption("dir","default")) RemoveOption("dir");
+ }
+ ClearIndex();
+ fAlg = new AliJArrayAlgorithmSimple(this);
+ fArraySize = fAlg->BuildArray();
+}
+//_____________________________________________________
+int AliJArrayBase::Index(int d){
+ if( OutOfDim(d) ) JERROR("Wrong Dim");
+ return fIndex[d];
+}
+void AliJArrayBase::SetIndex(int i, int d ){
+ if( OutOfSize( i, d ) ) JERROR( "Wrong Index" );
+ fIndex[d] = i;
+}
+
+void AliJArrayBase::InitIterator(){ fAlg->InitIterator(); }
+bool AliJArrayBase::Next(void *& item){ return fAlg->Next(item); }
+
+
+//////////////////////////////////////////////////////
+// AliJArrayAlgorithm
+//////////////////////////////////////////////////////
+
+//_____________________________________________________
+AliJArrayAlgorithm::AliJArrayAlgorithm(AliJArrayBase * cmd):
+ fCMD(cmd)
+{
+ // constructor
+}
+//_____________________________________________________
+AliJArrayAlgorithm::~AliJArrayAlgorithm(){
+ // destructor
+}
+
+//_____________________________________________________
+AliJArrayAlgorithm::AliJArrayAlgorithm(const AliJArrayAlgorithm& obj) :
+ fCMD(obj.fCMD)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJArrayAlgorithm& AliJArrayAlgorithm::operator=(const AliJArrayAlgorithm& obj)
+{
+ // assignment operator
+ if(this != &obj){
+ *fCMD = *(obj.fCMD);
+ }
+ return *this;
+}
+
+//////////////////////////////////////////////////////
+// AliJArrayAlgorithmSimple
+//////////////////////////////////////////////////////
+
+//_____________________________________________________
+AliJArrayAlgorithmSimple::AliJArrayAlgorithmSimple(AliJArrayBase * cmd):
+ AliJArrayAlgorithm(cmd),
+ fDimFactor(0),
+ fArray(NULL),
+ fPos(0)
+{
+ // constructor
+}
+//_____________________________________________________
+AliJArrayAlgorithmSimple::~AliJArrayAlgorithmSimple(){
+ // Dimension, GetEntries, SizeOf
+ if( fArray ) delete [] (void**)fArray;
+}
+
+//_____________________________________________________
+AliJArrayAlgorithmSimple::AliJArrayAlgorithmSimple(const AliJArrayAlgorithmSimple& obj) :
+ AliJArrayAlgorithm(obj.fCMD),
+ fDimFactor(obj.fDimFactor),
+ fArray(obj.fArray),
+ fPos(obj.fPos)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJArrayAlgorithmSimple& AliJArrayAlgorithmSimple::operator=(const AliJArrayAlgorithmSimple& obj)
+{
+ // assignment operator TODO: proper implementation
+ if(this != &obj){
+ *fCMD = *(obj.fCMD);
+ }
+ return *this;
+}
+//_____________________________________________________
+int AliJArrayAlgorithmSimple::BuildArray(){
+ fDimFactor.resize( Dimension(), 1 );
+ for( int i=Dimension()-2; i>=0; i-- ){
+ fDimFactor[i] = fDimFactor[i+1] * SizeOf(i+1);
+ } // TODO split to BuildArray and lazyArray in GetItem
+ int arraySize = fDimFactor[0] * SizeOf(0);
+ fArray = new void*[arraySize];
+ for( int i=0;i<arraySize;i++ ) fArray[i] = NULL;
+ return arraySize;
+}
+//_____________________________________________________
+int AliJArrayAlgorithmSimple::GlobalIndex(){
+ int iG = 0;
+ for( int i=0;i<Dimension();i++ ) // Index is checked by fCMD
+ iG+= Index(i)*fDimFactor[i];
+ // TODO check iG
+ return iG;
+
+}
+void AliJArrayAlgorithmSimple::ReverseIndex( int iG ){
+ int n = iG;
+ for( int i=0;i<Dimension();i++ ){
+ int n1 = int(n/fDimFactor[i]);
+ fCMD->SetIndex( n1 , i );
+ n-=n1*fDimFactor[i];
+ }
+}
+void * AliJArrayAlgorithmSimple::GetItem(){
+ return fArray[GlobalIndex()];
+
+}
+void AliJArrayAlgorithmSimple::SetItem(void * item){
+ fArray[GlobalIndex()] = item;
+}
+
+
+//////////////////////////////////////////////////////
+// AliJTH1
+//////////////////////////////////////////////////////
+//_____________________________________________________
+AliJTH1::AliJTH1():
+ fDirectory(NULL),
+ fSubDirectory(NULL),
+ fHMG(NULL),
+ fTemplate(NULL),
+ fBins(0)
+{
+ // default constructor
+ fName="AliJTH1";
+}
+
+//_____________________________________________________
+AliJTH1::AliJTH1(TString config, AliJHistManager * hmg):
+ fDirectory(NULL),
+ fSubDirectory(NULL),
+ fHMG(NULL),
+ fTemplate(NULL),
+ fBins(0)
+{
+ // constructor
+ std::vector<TString> t = Tokenize(config, " \t,");
+ TString type = t[0];
+ SetName( t[1] );
+ SetTitle( t[2] );
+ fTitle.ReplaceAll("\"","");
+ SetFullOption( t[3] );
+ fMode = HasOption("mode","Single")?kSingle:kNormal;
+ AddToManager( hmg );
+ TString s;
+ for( int i=4;i<int(t.size());i++ ) s+=" "+t[i];
+ AddDim( s );
+ FixBin();
+}
+//_____________________________________________________
+AliJTH1::~AliJTH1(){
+ // destructor
+ if( fNGenerated == 0 && fTemplate ) delete fTemplate;
+}
+
+//_____________________________________________________
+AliJTH1::AliJTH1(const AliJTH1& obj) :
+ AliJArrayBase(),
+ fDirectory(obj.fDirectory),
+ fSubDirectory(obj.fSubDirectory),
+ fHMG(obj.fHMG),
+ fTemplate(obj.fTemplate),
+ fBins(obj.fBins)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJTH1& AliJTH1::operator=(const AliJTH1& obj)
+{
+ // assignment operator
+ if(this != &obj){
+ // TODO: proper implementation
+ }
+ return *this;
+}
+
+//_____________________________________________________
+int AliJTH1::AddDim( AliJBin * bin){
+ int ndim = this->AliJArrayBase::AddDim( bin->Size() );
+ fBins.resize( ndim, NULL );
+ fBins[ndim-1] = bin;
+ return ndim;
+}
+
+int AliJTH1::AddDim(TString v) {
+ if( v == "END" ) { FixBin(); }
+ else{
+ std::vector<TString> o= Tokenize(v, "\t ,");
+ for( UInt_t i=0;i<o.size();i++ ){
+ TString & s = o[i];
+ if(s.Length() == 0 ) continue;
+ if( s.IsFloat() ) { // TODO IsInt? IsDigit?
+ AddDim( s.Atoi() );
+ continue;
+ }
+ AliJBin * b = NULL;
+ if( fHMG ) b = fHMG->GetBin(s);
+ if( b ) this->AddDim(b);
+ else {JERROR("Wrong terminator of Array : \"" + s+"\" in " + fName ); }
+ }
+ }
+ return Dimension();
+}
+//_____________________________________________________
+Int_t AliJTH1::Write(){
+ TDirectory *owd = (TDirectory*) gDirectory;
+ InitIterator();
+ void * item;
+ if( fSubDirectory ) fSubDirectory->cd();
+ //else fDirectory->cd();
+ while( Next(item) ){
+ if( !item ) continue;
+ TH1 * obj = static_cast<TH1*>(item);
+ obj->Write( );
+ //obj->Write( 0, TObject::kOverwrite );
+ }
+ if( owd != gDirectory ) owd->cd();
+ return 0;
+}
+//_____________________________________________________
+TString AliJTH1::GetString( ){
+ TString s = Form( "%s\t%s\t\"%s\"\t%s\t",
+ ClassName(), fName.Data(), fTitle.Data(), fOption.Data() );
+ for( int i=0;i<Dimension();i++ ){
+ if( int(fBins.size()) > i && fBins[i] != NULL ){
+ s+= " "+fBins[i]->GetName();
+ }else{
+ s+= TString(" ")+Form("%d", SizeOf(i));
+ }
+ }
+ return s;
+}
+//_____________________________________________________
+void AliJTH1::FixBin(){
+ this->AliJArrayBase::FixBin();
+
+ if(!fHMG) {
+ AddToManager( AliJHistManager::CurrentManager() );
+ }
+ if(!fDirectory) fDirectory = fHMG->GetDirectory();
+}
+
+//_____________________________________________________
+void AliJTH1::AddToManager(AliJHistManager *hmg){
+ if(fHMG) return; // TODO handle error
+ fHMG = hmg;
+ hmg->Add(this);
+}
+//_____________________________________________________
+void AliJTH1::Print(){
+ std::cout<<"*"<<GetString()<<std::endl;
+ // TODO more details.
+}
+//_____________________________________________________
+void AliJTH1::SetTemplate(TH1 *h){
+ if( fTemplate ) return; /// TDOO give error
+ fTemplate = (TH1*)h->Clone();
+ fTemplate->Sumw2();
+ fTemplate->SetDirectory(0);
+ fName = h->GetName();
+ fTitle = h->GetTitle();
+}
+//_____________________________________________________
+TString AliJTH1::BuildName(){
+ TString name = fName;
+ if( !HasOption("Single") )
+ for( int i=0;i<Dimension();i++ ){
+ name+=((int(fBins.size()) > i && fBins[i] != NULL)?fBins[i]->GetIndexName():"H")
+ +Form("%02d",Index(i));
+ }
+ return name;
+}
+//_____________________________________________________
+TString AliJTH1::BuildTitle(){
+ TString title = fTitle;
+ for( int i=0;i<Dimension();i++ )
+ title+=((int(fBins.size()) > i && fBins[i] != NULL)?" "+fBins[i]->BuildTitle(i):"")
+ +Form("%02d",Index(i));
+ return title;
+}
+//_____________________________________________________
+void * AliJTH1::BuildItem(){
+ TDirectory * owd = (TDirectory*) gDirectory;
+ gROOT->cd();
+ TString name = BuildName();
+ TH1 * item = NULL;
+ if( !fSubDirectory ){
+ if( !HasOption("dir") ) {
+ fSubDirectory = fDirectory;
+ }
+ else {
+ fSubDirectory = fDirectory->GetDirectory(fName);
+ if( !fSubDirectory && !IsLoadMode() ){
+ fSubDirectory = fDirectory->mkdir(fName);
+ }
+ }
+ }
+ if( IsLoadMode() ){
+ //if( fSubDirectory ) JDEBUG(2, fSubDirectory->GetName() );
+ if( fSubDirectory )
+ item = dynamic_cast<TH1*>(fSubDirectory->Get( name ));
+ if( !item ){
+ void ** rawItem = fAlg->GetRawItem();
+ InitIterator();
+ void * tmp;
+ while( Next(tmp) ){
+ item = (TH1*)fSubDirectory->Get(BuildName());
+ if(item ) break;
+ }
+ if( item ) {
+ item = dynamic_cast<TH1*>((static_cast<TH1*>(item))->Clone(name));
+ item->Reset();
+ item->SetTitle( BuildTitle() );
+ item->SetDirectory(0);
+ *rawItem = (void*)item;
+ }
+ }
+ if( !item ){ JERROR("Any of "+fName+" doesn't exists. I need at least one");}
+ }
+ else{ // Gen Mode
+ TH1 * titem = NULL;
+ if(fNGenerated == 0 ) {
+ titem = fTemplate;
+ }
+ else titem =(TH1*) fTemplate->Clone();
+ titem->SetDirectory( fSubDirectory );
+ titem->Reset();
+ titem->SetName( BuildName() );
+ titem->SetTitle( BuildTitle() );
+ fNGenerated++;
+ item=titem;
+ }
+ if( item ) fAlg->SetItem(item);
+ owd->cd();
+ return (void*)item;
+}
+//_____________________________________________________
+bool AliJTH1::IsLoadMode(){
+ return fHMG->IsLoadMode();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJTH1Derived //
+// //
+//////////////////////////////////////////////////////////////////////////
+template< typename T>
+AliJTH1Derived<T>::AliJTH1Derived():
+ AliJTH1(), fPlayer(this)
+{
+}
+template< typename T>
+AliJTH1Derived<T>::~AliJTH1Derived(){
+}
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJHistManager //
+// //
+// Array Base Class //
+// //
+//////////////////////////////////////////////////////////////////////////
+AliJHistManager::AliJHistManager(TString name):
+ AliJNamed(name,"","",0),
+ fIsLoadMode(false),
+ fDirectory(gDirectory),
+ fConfigStr(),
+ fBin(0),
+ fHist(0),
+ fManager(0),
+ fBinNames(0),
+ fBinConfigs(0),
+ fHistNames(0),
+ fHistConfigs(0)
+{
+ // constructor
+ //CurrentManager(this);
+ fDirectory = gDirectory;
+}
+
+//_____________________________________________________
+AliJHistManager::AliJHistManager(const AliJHistManager& obj) :
+ AliJNamed(obj.fName,obj.fTitle,obj.fOption,obj.fMode),
+ fIsLoadMode(obj.fIsLoadMode),
+ fDirectory(obj.fDirectory),
+ fConfigStr(obj.fConfigStr),
+ fBin(obj.fBin),
+ fHist(obj.fHist),
+ fManager(obj.fManager),
+ fBinNames(obj.fBinNames),
+ fBinConfigs(obj.fBinConfigs),
+ fHistNames(obj.fHistNames),
+ fHistConfigs(obj.fHistConfigs)
+{
+ // copy constructor TODO: proper handling of pointer data members
+}
+
+//_____________________________________________________
+AliJHistManager& AliJHistManager::operator=(const AliJHistManager& obj)
+{
+ // assignment operator
+ if(this != &obj){
+ // TODO: proper implementation
+ }
+ return *this;
+}
+
+AliJHistManager* AliJHistManager::GlobalManager(){
+ static AliJHistManager* singleton = new AliJHistManager("GlobalHistManager");
+ return singleton;
+}
+
+AliJHistManager* AliJHistManager::CurrentManager( AliJHistManager * hmg){
+ static AliJHistManager* currentManager = AliJHistManager::GlobalManager();
+ if( hmg ) currentManager = hmg;
+ return currentManager;
+}
+
+AliJBin* AliJHistManager::GetBuiltBin(TString s ){
+ for( int i=0;i<int(fBin.size());i++ )
+ if( fBin[i]->GetName() == s ) return fBin[i];
+ return NULL;
+}
+AliJBin* AliJHistManager::GetBin(TString s ){
+ AliJBin* h = GetBuiltBin(s);
+ if(h) return h;
+ for( int i=0;i<GetNBin();i++ )
+ if( fBinNames[i] == s ){
+ return new AliJBin( fBinConfigs[i],this );
+ }
+ return NULL;
+}
+AliJTH1 * AliJHistManager::GetBuiltTH1(TString s ){
+ for( int i=0;i<int(fHist.size());i++ )
+ if( fHist[i]->GetName() == s ) return fHist[i];
+ return NULL;
+}
+AliJTH1 * AliJHistManager::GetTH1(TString s ){
+ AliJTH1 * h = GetBuiltTH1(s);
+ if( h ) return h;
+ for( int i=0;i<GetNHist();i++ )
+ if( fHistNames[i] == s ){
+ if( fHistConfigs[i].BeginsWith("AliJTH1D")) return new AliJTH1D( fHistConfigs[i], this );
+ if( fHistConfigs[i].BeginsWith("AliJTH2D")) return new AliJTH2D( fHistConfigs[i], this );
+ if( fHistConfigs[i].BeginsWith("AliJTProfile")) return new AliJTProfile( fHistConfigs[i], this );
+ }
+ return NULL;
+}
+void AliJHistManager::Add(AliJBin *o ){
+ if( !o ) return;
+ if( GetBuiltBin( o->GetName() ) ) return; // TODO error handle
+ fBin.push_back( o );
+}
+void AliJHistManager::Add(AliJTH1 *o ){
+ if( !o ) return;
+ if( GetBuiltTH1( o->GetName() ) ) return; // TODO error handle
+ fHist.push_back( o );
+}
+void AliJHistManager::Print(){
+ if( IsLoadMode() ) {
+ cout<<fConfigStr<<endl;
+ return;
+ }
+ cout<<"============ AliJHistManager : "<<fName<<" ==================="<<endl;
+ cout<<endl;
+ cout<<"---- AliJBin ----"<<endl;
+ for( int i=0;i<GetNBin();i++ ){
+ fBin[i]->Print();
+ }
+ cout<<endl;
+ cout<<"---- AliJTH1 ----"<<endl;
+ for( int i=0;i<GetNHist();i++ ){
+ fHist[i]->Print();
+ }
+}
+void AliJHistManager::Write(){
+ for( int i=0;i<GetNHist();i++ )
+ fHist[i]->Write();
+}
+
+void AliJHistManager::WriteConfig(){
+ TDirectory *owd = gDirectory;
+ TDirectory * fHistConfigDir = gDirectory->mkdir("HistManager");
+ fHistConfigDir->cd();
+ TObjString * config = new TObjString(GetString().Data());
+ config->Write("Config");
+ owd->cd();
+}
+
+int AliJHistManager::LoadConfig(){
+ SetLoadMode(true);
+ TObjString *strobj = (TObjString*)fDirectory->Get("HistManager/Config");
+ if( !strobj ) return 0; //TODO
+ TString config = strobj->String();
+ fConfigStr = config;
+ vector<TString> lines = Tokenize(config, "\n");
+ cout<< Form("Read Config.%d objects found\n", (int)lines.size() );
+ for( UInt_t i=0;i < lines.size();i++ ){
+ TString line = lines.at(i);
+ std::vector<TString> t = Tokenize(line, " \t,");
+ if(line.BeginsWith("AliJBin")) {
+ fBinNames.push_back( t[1] );
+ fBinConfigs.push_back( line );
+ }else if( line.BeginsWith("AliJ")){
+ fHistNames.push_back( t[1] );
+ fHistConfigs.push_back( line );
+ }
+ }
+ return 1;
+}
+
+
+//////////////////////////////////////////////////////
+// Utils
+//////////////////////////////////////////////////////
+vector<TString> Tokenize( TString s, TString d, int quote ){
+ //int nd = d.Length();
+ bool flagBeforeToken = 0;
+ bool inQuote = 0;
+ TString tok="";
+ vector<TString> toks;
+ s += d[0];
+ for( int i=0;i<s.Length();i++ ){
+ if( quote == 1 && s[i] == '\"' ){ inQuote = ! inQuote; }
+ if( d.First(s[i]) != kNPOS && !inQuote ){
+ if( flagBeforeToken == 0 && tok.Length()>0){
+ toks.push_back(tok);
+ tok.Clear();
+ flagBeforeToken = 1;
+ }
+ }else{
+ tok+=s[i];
+ flagBeforeToken = 0;
+ }
+ }
+ return toks;
+}
+
+
+TString Join( vector<TString>& ss , TString del){
+ if( ss.size() < 1 ) return "";
+ TString s = ss[0];
+ for( UInt_t i=1;i<ss.size();i++ ) s+=del+ss[i];
+ return s;
+}
+
+bool OutOf( int i, int x, int y ){ return ( i<x || i>y ); }
+#include <TFile.h>
+
+void testAliJArray(){
+ cout<<"START"<<endl;
+ AliJHistManager * fHMG;
+ AliJBin fCentBin;
+ AliJBin fVtxBin;
+ AliJBin fPTtBin;
+ AliJBin fPTaBin;
+ AliJBin fXEBin;
+ AliJBin fKLongBin;
+ AliJBin fRGapBin;
+ AliJBin fEtaGapBin;
+ AliJBin fPhiGapBin;
+ AliJBin fMassBin;
+ AliJBin fTypBin;
+ AliJBin fTypBin3;
+ AliJBin fPairPtBin;
+ AliJTH1D fhTriggPtBin;
+ AliJTH1D fhTriggMult;
+ AliJTH1D fhIphiTrigg;
+ AliJTH1D fhIetaTrigg;
+ AliJTH2D test1;
+ AliJTProfile test2;
+
+ TFile * f = new TFile("test.root","RECREATE");
+ fHMG = AliJHistManager::GlobalManager();
+ fCentBin .Set("Cent", "C", "C %2.0f-%2.0f%%" ).SetBin( "0 100");
+ fVtxBin .Set("Vtx", "V", "Vtx %.0f-%.0f" ).SetBin("-10 10");
+ fPTtBin .Set("PTt", "T", "p_{Tt} %.1f-%.1f").SetBin("3 5 8 10 15 20");
+ fPTaBin .Set("PTa", "A", "p_{Tt} %.1f-%.1f").SetBin("3 5 8 10 15 20");
+
+ fhTriggMult
+ << TH1D( "hTriggMult", "", 100, -0.5, 99.5)
+ << fCentBin << fPTtBin << "END";
+ fhIphiTrigg
+ << TH1D( "fhIphiTrigg", "", 3, -0.1, 0.1 )
+ << fCentBin << fPTtBin << "END";
+ fhIetaTrigg
+ << TH1D( "hIetaTrigg", "", 80, -5, 5 )
+ << fCentBin << fPTtBin << "END";// inclusive eta
+ fhTriggPtBin
+ << TH1D( "hTriggPtBin", "", 10,0,10 )
+ << fCentBin << fVtxBin << fPTtBin << "END";
+
+ fhTriggMult[0][0]->Fill(1);
+ fHMG->Print();
+
+ f->Write();
+ fHMG->Write();
+ fHMG->WriteConfig();
+
+}
--- /dev/null
+// @(#)utils:$Id$
+// Author: Beonsu Chang 26/12/94
+#ifndef UTILS_ALIJARRAY_H
+#define UTILS_ALIJARRAY_H
+
+#include <vector>
+#include <map>
+#include <TString.h>
+#include <TDirectory.h>
+#include <TH1D.h>
+#include <TH2D.h>
+#include <TProfile.h>
+#include <TPRegexp.h>
+#include <TVector.h>
+#include <TSystem.h>
+#include <TROOT.h>
+#include <TObjString.h>
+#include <iostream>
+#include <TClass.h>
+
+#define JERROR(x) {std::cout<<"!!! JERROR : "<<x<<" "<<__LINE__<<" "<<__FILE__<<" "<<std::endl , gSystem->Exit(100); }
+#define JDEBUG(x,y) if(x<100){std::cout<<"JDEBUG : "<<#x<<" : "<<(y)<<" "<<__LINE__<<" "<<__FILE__<<" "<<std::endl;}
+
+//class AliJMap;
+class AliJArrayBase;
+class AliJBin;
+class AliJArrayAlgorithm;
+class AliJArrayAlgorithmSimple;
+class AliJTH1;
+class AliJHistManager;
+template<typename t> class AliJTH1Derived;
+template<typename t> class AliJTH1DerivedPlayer;
+
+//////////////////////////////////////////////////////
+// Utils
+//////////////////////////////////////////////////////
+std::vector<TString> Tokenize( TString s, TString d, int quote=1 );
+TString Join( std::vector<TString>& ss , TString del=" ");
+bool OutOf( int, int, int );
+
+typedef std::vector<int> ArrayInt;
+typedef std::vector<double> ArrayDouble;
+//typedef AliJArray<void*> ArrayVoid*;
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJNamed //
+// //
+//
+// //
+//////////////////////////////////////////////////////////////////////////
+//________________________________________________________________________
+class AliJNamed{
+ public:
+ AliJNamed( TString name, TString title, TString opt, int mode );
+ virtual ~AliJNamed();
+ TString GetName(){ return fName; }
+ TString GetTitle(){ return fTitle; }
+ TString GetOption(){ return fOption; }
+ TString GetOption(TString key);
+ bool HasOption(TString key){ return GetOption(key)!=UndefinedOption(); }
+ bool HasOption(TString key, TString val){ return GetOption(key)==val; } // TODO sensitive?
+ void SetName( const char * s ) { fName=s; }
+ void SetTitle( const char * s ) { fTitle=s; }
+ void SetNameTitle( TString n, TString t ){ SetName(n);SetTitle(t); }
+ void SetFullOption( const char * s ) { fOption=s; }
+ void SetOption( TString key, TString value="" );
+ void RemoveOption( TString key ); // TODO
+ //void SetOptionWithString( TString s );// TODO
+ static TString UndefinedOption();
+ protected:
+ TString fName;
+ TString fTitle;
+ TString fOption;
+ int fMode;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJBin //
+// //
+//
+// //
+//////////////////////////////////////////////////////////////////////////
+//________________________________________________________________________
+class AliJBin : public AliJNamed {
+ public:
+ enum { kSingle, kRange, kString , kNMode};
+ AliJBin();
+ AliJBin(TString config, AliJHistManager * hmg);
+ AliJBin(const AliJBin& obj);
+ AliJBin& operator=(const AliJBin& obj);
+ AliJBin & Set( TString name, TString iname, TString Title, int mode=kRange);
+ void AddToManager( AliJHistManager* hmg );
+ AliJBin & SetBin( const int n, const float * v );
+ AliJBin & SetBin( const int n, const double * v );
+ AliJBin & SetBin( TVector * v );
+ AliJBin & SetBin( const TString v );
+ AliJBin & SetBin( const int n );
+
+ double GetMin(){ return fBinD[0]; }
+ double GetMax(){ return fBinD[RawSize()-1]; }
+
+ TString BuildTitle( int i );
+ int RawSize(){ return fBinD.size(); }
+ int Size(){ return fMode==kRange?fBinD.size()-1:fBinD.size(); }
+ double At(int i){ return fBinD[i]; }
+ TString GetIndexName(){ return fIndexName; }
+
+ void Print();
+ TString GetString();
+
+ operator int(){ return Size(); }
+
+ static TString GetModeString(int i);
+ static int GetMode( TString mode );
+ private:
+ void AddBin( const TString & v );
+ void AddBin( float v );
+ virtual void FixBin();
+
+ std::vector<double> fBinD;
+ std::vector<TString> fBinStr;
+ bool fIsFixedBin;
+ TString fIndexName;
+ AliJHistManager * fHMG;
+};
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJArrayBase //
+// //
+// Array Base Class //
+// //
+//////////////////////////////////////////////////////////////////////////
+
+//________________________________________________________________________
+class AliJArrayBase : public AliJNamed{
+ public:
+ enum { kNormal, kSingle };
+ virtual ~AliJArrayBase();
+ AliJArrayBase& operator=(const AliJArrayBase& obj);
+
+ int AddDim( int i){ fDim.push_back(i);return fDim.size();}
+ int Dimension(){ return fDim.size(); }
+ int GetEntries(){ return fArraySize; }
+ int SizeOf(int i) { return fDim.at(i); }
+
+ ArrayInt& Index(){ return fIndex; }
+ int Index( int d );
+ void SetIndex( int i, int d );
+ void ClearIndex(){ fIndex.clear();fIndex.resize( Dimension(), 0 ); }
+
+ void * GetItem();
+ void * GetSingleItem();
+
+ ///void LockBin(bool is=true){}//TODO
+ //bool IsBinLocked(){ return fIsBinLocked; }
+
+ virtual void FixBin();
+ bool IsBinFixed(){ return fIsBinFixed; }
+
+ bool OutOfDim( int d ){ return OutOf( d, 0, Dimension()-1 ); }
+ bool OutOfSize( int i, int d ){ return OutOfDim(d) || OutOf( i, 0, SizeOf(d)-1); }
+
+
+ // Virtual
+ virtual void * BuildItem()=0;
+ virtual TString BuildName()=0;
+ virtual TString BuildTitle()=0;
+ virtual void Print()=0;
+ virtual TString GetString()=0;
+
+ //int Resize( int size, int dim=-1 ); // NextStep
+ void InitIterator();
+ bool Next(void *& item );
+
+ protected:
+ AliJArrayBase(); // Prevent direct creation of AliJArrayBase
+ AliJArrayBase(const AliJArrayBase& obj);
+
+ ArrayInt fDim; // Comment test
+ ArrayInt fIndex; /// Comment test
+ int fArraySize; /// Comment test3
+ int fNGenerated;
+ bool fIsBinFixed;
+ bool fIsBinLocked;
+ AliJArrayAlgorithm * fAlg;
+ friend class AliJArrayAlgorithm;
+};
+
+
+//________________________________________________________________________
+class AliJArrayAlgorithm {
+ public:
+ AliJArrayAlgorithm(AliJArrayBase * cmd); //TODO Move to private
+ AliJArrayAlgorithm(const AliJArrayAlgorithm& obj);
+ AliJArrayAlgorithm& operator=(const AliJArrayAlgorithm& obj);
+ virtual ~AliJArrayAlgorithm();
+ int Dimension(){ return fCMD->Dimension(); }
+ int SizeOf(int i){ return fCMD->SizeOf(i); }
+ int GetEntries(){ return fCMD->GetEntries(); }
+ int Index(int i){ return fCMD->Index(i); }
+ virtual int BuildArray()=0;
+ virtual void * GetItem()=0;
+ virtual void SetItem(void * item)=0;
+ virtual void InitIterator()=0;
+ virtual bool Next(void *& item) = 0;
+ virtual void ** GetRawItem()=0;
+ virtual void * GetPosition()=0;
+ virtual bool IsCurrentPosition(void * pos)=0;
+ virtual void SetPosition(void * pos )=0;
+ virtual void DeletePosition( void * pos ) =0;
+ protected:
+ AliJArrayBase * fCMD;
+};
+
+//________________________________________________________________________
+class AliJArrayAlgorithmSimple : public AliJArrayAlgorithm {
+ public:
+ AliJArrayAlgorithmSimple( AliJArrayBase * cmd);
+ AliJArrayAlgorithmSimple(const AliJArrayAlgorithmSimple& obj);
+ AliJArrayAlgorithmSimple& operator=(const AliJArrayAlgorithmSimple& obj);
+ virtual ~AliJArrayAlgorithmSimple();
+ virtual int BuildArray();
+ int GlobalIndex();
+ void ReverseIndex(int iG );
+ virtual void * GetItem();
+ virtual void SetItem(void * item);
+ virtual void InitIterator(){ fPos = 0; }
+ virtual void ** GetRawItem(){ return &fArray[GlobalIndex()]; }
+ virtual bool Next(void *& item){
+ item = fPos<GetEntries()?(void*)fArray[fPos]:NULL;
+ if( fPos<GetEntries() ) ReverseIndex(fPos);
+ return fPos++<GetEntries();
+ }
+ virtual void * GetPosition(){ return static_cast<void*> (new int( fPos )); }
+ virtual bool IsCurrentPosition(void * pos){ return *static_cast<int*>(pos)==fPos; }
+ virtual void SetPosition(void *pos){ fPos=*static_cast<int*>(pos);ReverseIndex(fPos); }
+ virtual void DeletePosition(void *pos){ delete static_cast<int*>(pos); }
+ private:
+ ArrayInt fDimFactor;
+ void **fArray;
+ int fPos;
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJTH1 //
+// //
+// Array Base Class //
+// //
+//////////////////////////////////////////////////////////////////////////
+//________________________________________________________________________
+class AliJTH1 : public AliJArrayBase{
+ public:
+ AliJTH1();
+ AliJTH1(TString config, AliJHistManager * hmg);
+ AliJTH1(const AliJTH1& obj);
+ AliJTH1& operator=(const AliJTH1& obj);
+ virtual ~AliJTH1();
+
+ int AddDim( int i){ fDim.push_back(i);return fDim.size();}
+ int AddDim( AliJBin * bin );
+ int AddDim( TString v);
+ void AddToManager( AliJHistManager * hmg );
+
+ // Virtual from AliJArrayBase
+ virtual void * BuildItem() ;
+ virtual TString GetString();
+ virtual void Print();
+ virtual void FixBin();
+ // Virtual from this
+ virtual Int_t Write();
+ //virtual Int_t WriteAll();
+ virtual const char * ClassName(){ return "AliJTH1"; }
+
+ // Not Virtual
+ virtual TString BuildName();
+ virtual TString BuildTitle();
+ bool IsLoadMode();
+ void SetTemplate(TH1* h);
+
+
+
+ protected:
+
+ TDirectory *fDirectory;
+ TDirectory *fSubDirectory;
+ AliJHistManager *fHMG;
+ TH1 *fTemplate;
+ std::vector<AliJBin*> fBins;
+};
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJTH1Derived //
+// //
+// Array Base Class //
+// //
+//////////////////////////////////////////////////////////////////////////
+template< typename T >
+class AliJTH1Derived : public AliJTH1 {
+ protected:
+ public:
+ AliJTH1Derived();
+ AliJTH1Derived(TString config, AliJHistManager *hmg):
+ AliJTH1(config, hmg),fPlayer(this){}
+ virtual ~AliJTH1Derived();
+
+ //AliJTH1DerivedPlayer<T> & operator[](int i){ fPlayer.Init();return fPlayer[i]; }
+ // AliJTH1DerivedPlayer<T> & operator[](int i){ fPlayer.Init();fPlayer[i];return fPlayer; }
+ AliJTH1DerivedPlayer<T> & operator[](int i){ fPlayer.Init();fPlayer[i];return fPlayer; }
+ T * operator->(){ return static_cast<T*>(GetSingleItem()); }
+ operator T*(){ return static_cast<T*>(GetSingleItem()); }
+ // Virtual from AliJArrayBase
+
+ // Virtual from AliJTH1
+ virtual const char * ClassName(){ return Form("AliJ%s",T::Class()->GetName()); }
+
+ AliJTH1Derived<T>& operator<<(int i){ AddDim(i);return *this; }
+ AliJTH1Derived<T>& operator<<(AliJBin& v){ AddDim(&v);return *this; }
+ AliJTH1Derived<T>& operator<<(TString v){ AddDim(v);return *this; }
+ AliJTH1Derived<T>& operator<<(T v){ SetTemplate(&v);return *this; }
+ protected:
+ AliJTH1DerivedPlayer<T> fPlayer;
+
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// AliJTH1DerivedPlayer //
+//////////////////////////////////////////////////////////////////////////
+template< typename T>
+class AliJTH1DerivedPlayer {
+ public:
+ AliJTH1DerivedPlayer( AliJTH1Derived<T> * cmd ):fLevel(0),fCMD(cmd){};
+ AliJTH1DerivedPlayer<T>& operator[](int i){
+ if( fLevel > fCMD->Dimension() ) { JERROR("Exceed Dimension"); }
+ if( OutOf( i, 0, fCMD->SizeOf(fLevel)-1) ){ JERROR(Form("wrong Index %d of %dth in ",i, fLevel)+fCMD->GetName()); }
+ fCMD->SetIndex(i, fLevel++);
+ return *this;
+ }
+ void Init(){ fLevel=0;fCMD->ClearIndex(); }
+ T* operator->(){ return static_cast<T*>(fCMD->GetItem()); }
+ operator T*(){ return static_cast<T*>(fCMD->GetItem()); }
+ operator TObject*(){ return static_cast<TObject*>(fCMD->GetItem()); }
+ operator TH1*(){ return static_cast<TH1*>(fCMD->GetItem()); }
+ private:
+ int fLevel;
+ AliJTH1Derived<T> * fCMD;
+};
+
+typedef AliJTH1Derived<TH1D> AliJTH1D;
+typedef AliJTH1Derived<TH2D> AliJTH2D;
+typedef AliJTH1Derived<TProfile> AliJTProfile;
+
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// AliJHistManager //
+// //
+// Array Base Class //
+// //
+//////////////////////////////////////////////////////////////////////////
+class AliJHistManager: public AliJNamed{
+ public:
+ AliJHistManager(TString name );
+ AliJHistManager(const AliJHistManager& obj);
+ AliJHistManager& operator=(const AliJHistManager& obj);
+ void Add( AliJBin * o );
+ void Add( AliJTH1 * o );
+
+ int GetNBin(){ return fBin.size()>fBinNames.size()?fBin.size():fBinNames.size(); } // TODO
+ int GetNHist(){ return fHist.size()>fHistNames.size()?fHist.size():fHistNames.size(); } // TODO
+ void Print();
+ int LoadConfig();
+ TDirectory * GetDirectory(){ return fDirectory;}
+ void SetDirectory(TDirectory* d){ fDirectory = d; }
+ static AliJHistManager* GlobalManager();
+ static AliJHistManager* CurrentManager( AliJHistManager * hmg=NULL);
+ void SetLoadMode(bool b=true){ fIsLoadMode = b; }
+ bool IsLoadMode(){ return fIsLoadMode; }
+ TString GetString(){
+ TString st;
+ for( int i=0;i<GetNBin();i++ ) st+=fBin[i]->GetString()+"\n";
+ for( int i=0;i<GetNHist();i++ ){
+ st+=fHist[i]->GetString()+"\n";
+ }
+ return st;
+ }
+ void Write();
+ void WriteConfig();
+
+ AliJBin * GetBin( TString name);
+ AliJBin * GetBuiltBin( TString name);
+ AliJTH1 * GetTH1( TString name );
+ AliJTH1 * GetBuiltTH1( TString name );
+ AliJTProfile& GetTProfile( TString name){ return dynamic_cast<AliJTProfile&>(*GetTH1(name)); }
+ AliJTH1D& GetTH1D( TString name){ return dynamic_cast<AliJTH1D&>(*GetTH1(name)); }
+ AliJTH2D& GetTH2D( TString name){ return dynamic_cast<AliJTH2D&>(*GetTH1(name)); }
+ bool fIsLoadMode;
+ TDirectory * fDirectory;
+
+ TString GetHistName(int i){ return fHistNames[i]; }
+
+ AliJTH1 * GetAliJTH1(int i){ return GetTH1(fHistNames[i]); }
+ int GetNAliJTH1(){ return fHistNames.size(); }
+
+
+ private:
+ TString fConfigStr;
+ std::vector<AliJBin*> fBin;
+ std::vector<AliJTH1*> fHist;
+ std::vector<AliJHistManager*> fManager;
+ std::vector<TString> fBinNames;
+ std::vector<TString> fBinConfigs;
+ std::vector<TString> fHistNames;
+ std::vector<TString> fHistConfigs;
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJHistos.h"
+#include "AliJCard.h"
+#include "AliJBaseTrack.h"
+#include "AliJPhoton.h"
+#include "AliJTrack.h"
+
+//______________________________________________________________________________
+AliJHistos::AliJHistos(AliJCard* cardP) :
+ fCard(cardP),
+ fHMG(NULL),
+ fCentBin(),
+ fVtxBin(),
+ fPTtBin(),
+ fPTaBin(),
+ fXEBin(),
+ fKLongBin(),
+ fRGapBin(),
+ fEtaGapBin(),
+ fPhiGapBin(),
+ fMassBin(),
+ fTypBin(),
+ fTypBin3(),
+ fPairPtBin(),
+ fhMixStat(),
+ fTestHist(),
+ fhPtNear(),
+ fhPtFar(),
+ fhPhi(),
+ fhDphiAssoc(),
+ fhDphiAssocXEbin(),
+ fhDphiAssoc2DIAA(),
+ fhDphiAssoc2D(),
+ fhDphiDetaKlong(),
+ fhDphiDetaKlongR(),
+ fhDphiDetaXe(),
+ fhDphiDetaXeR(),
+ fhDphiDetaPta(),
+ fhDphiDetaPtaR(),
+ fhBgAssocKlong(),
+ fhBgAssocKlongR(),
+ fhBgAssocXe(),
+ fhBgAssocXeR(),
+ fhBgAssocPta(),
+ fhBgAssocPtaR(),
+ fhDphiAssocIsolTrigg(),
+ fhMeanPtAssoc(),
+ fhMeanZtAssoc(),
+ fhPtAssocUE(),
+ fhPtaEtaGapN(),
+ fhPtaRGapN(),
+ fhPtAssocUEIsolTrigg(),
+ fhPtAssocN(),
+ fhPtAssocF(),
+ fhCosThetaStar(),
+ fhCMSrap(),
+ fpCMSrap(),
+ fhInvMass(),
+ fhPairPtMass(),
+ fhPairDPhi(),
+ fhPairDpT(),
+ fhPairPtDphi(),
+ fhPairPt(),
+ fhDEtaNear(),
+ fhDEtaNearM(),
+ fhDEtaNearXEbin(),
+ fhDEtaNearMXEbin(),
+ fhDRNearPt(),
+ fhDRFarPt(),
+ fhDRNearPtMoon(),
+ fhDRFarPtMoon(),
+ fhDRNearPtMoonM(),
+ fhDRFarPtMoonM(),
+ fhDEtaFar(),
+ fhIphiTrigg(),
+ fhIetaTrigg(),
+ fhIphiAssoc(),
+ fhIetaAssoc(),
+ fhFixPtBin(),
+ fhTriggPtBin(),
+ fhTriggPtBinIsolTrigg(),
+ fhTriggMult(),
+ fhAssocPtBin(),
+ fhxEN(),
+ fhxEF(),
+ fhxEFIsolTrigg(),
+ fhPoutF(),
+ fhxEPtBin(),
+ fhJT(),
+ fhJTBg(),
+ fhJTBgR(),
+ fhJTKlong(),
+ fhJTKlongBg(),
+ fhJTKlongBgR(),
+ fhJTPta(),
+ fhJTPtaBg(),
+ fhJTPtaBgR(),
+ fhLPpt(),
+ fhLPpairPt(),
+ fhChargedPt(),
+ fhChargedPtNoCorr(),
+ fhChargedPtJacek(),
+ fhChargedPtJacekEta(),
+ fhChargedPtFiete(),
+ fhVdelta2(),
+ fhVdelta3(),
+ fhVN(),
+ fhTrackingEfficiency(),
+ fpV2(),
+ fpV3(),
+ fpVdeltaNorm(),
+ fhChargedEta(),
+ fhLPeta(),
+ fhAssocMult(),
+ fhChargedMult(),
+ fhChargedMultCut(),
+ fhChargedMultCent(),
+ fhXt(),
+ fhXtWeighted(),
+ fhXtWeightedHT(),
+ fhPtForXt(),
+ fhConeActivity(),
+ fhConeActivityIsolated(),
+ fhPerpConeActivity(),
+ fhPerpConeActivityIsolated(),
+ fhV0AMult(),
+ fhZVertRaw(),
+ fhZVertRawErr(),
+ fhZVert(),
+ fhCentr(),
+ fhiCentr(),
+ fhEventPerRun(),
+ fhVertexZTriggVtx(),
+ fhIsolatedLPpt(),
+ fhBkgActivity(),
+ fhDphiLPJet(),
+ fhDEtaLPJet(),
+ fhDPtLPJet(),
+ fhLPJetPTt(),
+ fhLPJetPt(),
+ fhLPJetEtaPTt(),
+ fhLPJetRapidityPTt(),
+ fhLPJetMassPTt(),
+ fhLeadingJetWLPPTt(),
+ fhJetPt(),
+ fhLeadingJetPt(),
+ fhLeadingJetWLPPt(),
+ fhJetAssymPTt(),
+ fhJetMassPTt(),
+ fhJetUEPt(),
+ fhJetDphi(),
+ fhJetDeta(),
+ fhJetMultPt(),
+ fhJetRho(),
+ fhJetRhoSigma(),
+ fhJetPartMult(),
+ fhRecoDiJetM(),
+ fhRecoDiJetdPhi(),
+ fhRecoDiJetkT(),
+ fhNParton71(),
+ fhNStringGroup(),
+ fhNStringGroupFrom(),
+ fhNTracksInStringGroupFrom(),
+ fhRapidity71From(),
+ fhPt71From(),
+ fhTrackSelection(),
+ fNJacek(0),
+ fPttJacek(0),
+ fNEta(0),
+ fEta(0),
+ fNJanFiete(0),
+ fJanFiete(0),
+ fhEvents(),
+ fhEventTrigger(),
+ fmaxEtaRange(0),
+ fmaxTriggEtaRange(0),
+ ftriggFiducCut(0),
+ fnUE(0),
+ fnUEfar(0),
+ fLowRange(0),
+ fHighRange(0)
+{ // constructor
+
+ fmaxEtaRange = fCard->Get("EtaRange");
+ ftriggFiducCut = fCard->Get("TriggerFiducialEtaCut"); //FK// Fiduc cut
+ fmaxTriggEtaRange = fmaxEtaRange - ftriggFiducCut; //FK// Trigger range
+
+ fHMG = AliJHistManager::GlobalManager();
+ //for (int hiklong = 0; hiklong < fCard->GetNoOfBins(kLongType); hiklong++)
+ //kRGapType kEtaGapType
+ fCentBin .Set("Cent", "C", "C %2.0f-%2.0f%%" ).SetBin( fCard->GetVector("CentBinBorders"));
+ fVtxBin .Set("Vtx", "V", "" ).SetBin(fCard->GetVector("zVertBins"));
+ fPTtBin .Set("PTt", "T", "").SetBin(fCard->GetVector("TriggPtBorders"));
+ fPTaBin .Set("PTa", "A", "").SetBin(fCard->GetVector("AssocPtBorders"));
+ fXEBin .Set("XE", "X", "x_{E}: %2.1f-%2.1f" ).SetBin(fCard->GetVector("xEBorders"));
+ fKLongBin .Set("KLong", "L", "k_{#parallel}: %2.1f-%2.1f").SetBin(fCard->GetVector("KlongBorders"));
+ fRGapBin .Set("RGap", "R", "").SetBin(fCard->GetVector("RGapThresholds"));
+ fEtaGapBin .Set("EtaGap", "E", "").SetBin(fCard->GetVector("EtaGapThresholds"));
+ fPhiGapBin .Set("PhiGap", "P", "" ).SetBin(fCard->GetVector("EtaGapThresholds"));
+ fMassBin .Set("Mass", "M", "Mass").SetBin(fCard->GetVector("PairInvariantMassBins"));
+ fTypBin .Set("Type", "D", "", AliJBin::kSingle ).SetBin( "0 1" );
+ fTypBin3 .Set("Type3", "D", "", AliJBin::kSingle ).SetBin( "0 1 2 3" );
+ //card->IsLessThanUpperPairPtCut(-ipairpt)
+ fPairPtBin .Set("PairPt", "", AliJBin::kSingle ).SetBin( fCard->GetN("UpperPairPtCut") );
+
+ const int nJacek = 73 ;
+ double pttJacek[nJacek+1] = {0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95,
+ 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.2, 3.4, 3.6, 3.8, 4, 4.5, 5, 5.5, 6, 6.5, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 40, 45, 50, 60, 70, 80, 90, 100};
+
+ //const int nJacek = 59 ;
+ //double pttJacek[nJacek] = { 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.9, 0.95, 1.,
+ // 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3., 3.2, 3.4, 3.6, 3.8, 4., 4.5, 5., 5.5, 6., 6.5, 7., 8., 9., 10,
+ // 11., 12., 13., 14., 15., 16., 18., 20, 22, 24, 26., 28., 30.};
+
+ fNJacek = nJacek; // Number of bins
+ fPttJacek = new double[fNJacek+1];
+ for(int i = 0; i <= fNJacek; i++){
+ fPttJacek[i] = pttJacek[i];
+ }
+
+ const int nEta = 3;
+ double eta[nEta+1] = {-0.8,-0.2,0.3,0.8};// eta bins
+
+ fNEta = nEta; // Number of bins
+ fEta = new double[fNEta+1];
+ for(int i = 0; i <= fNEta; i++){
+ fEta[i] = eta[i];
+ }
+
+ const int nJanFiete=200;
+ double janFiete[nJanFiete+1]={0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3, 3.25, 3.5, 3.75, 4, 4.25, 4.5, 4.75, 5, 5.25, 5.5,
+ 5.75, 6, 6.25, 6.5, 6.75, 7, 7.25, 7.5, 7.75, 8, 8.25, 8.5, 8.75, 9, 9.25, 9.5, 9.75, 10, 10.25, 10.5, 10.75, 11, 11.25, 11.5, 11.75,
+ 12, 12.25, 12.5, 12.75, 13, 13.25, 13.5, 13.75, 14, 14.25, 14.5, 14.75, 15, 15.25, 15.5, 15.75, 16, 16.25, 16.5, 16.75, 17, 17.25, 17.5,
+ 17.75, 18, 18.25, 18.5, 18.75, 19, 19.25, 19.5, 19.75, 20, 20.25, 20.5, 20.75, 21, 21.25, 21.5, 21.75, 22, 22.25, 22.5, 22.75, 23, 23.25,
+ 23.5, 23.75, 24, 24.25, 24.5, 24.75, 25, 25.25, 25.5, 25.75, 26, 26.25, 26.5, 26.75, 27, 27.25, 27.5, 27.75, 28, 28.25, 28.5, 28.75, 29,
+ 29.25, 29.5, 29.75, 30, 30.25, 30.5, 30.75, 31, 31.25, 31.5, 31.75, 32, 32.25, 32.5, 32.75, 33, 33.25, 33.5, 33.75, 34, 34.25, 34.5, 34.75,
+ 35, 35.25, 35.5, 35.75, 36, 36.25, 36.5, 36.75, 37, 37.25, 37.5, 37.75, 38, 38.25, 38.5, 38.75, 39, 39.25, 39.5, 39.75, 40, 40.25, 40.5,
+ 40.75, 41, 41.25, 41.5, 41.75, 42, 42.25, 42.5, 42.75, 43, 43.25, 43.5, 43.75, 44, 44.25, 44.5, 44.75, 45, 45.25, 45.5, 45.75, 46, 46.25,
+ 46.5, 46.75, 47, 47.25, 47.5, 47.75, 48, 48.25, 48.5, 48.75, 49, 49.25, 49.5, 49.75, 50};
+
+ fNJanFiete = nJanFiete; // Number of bins
+ fJanFiete = new double[fNJanFiete+1];
+ for(int i = 0; i <= fNJanFiete; i++){
+ fJanFiete[i] = janFiete[i];
+ }
+
+ //fhtyp[1] = "Real";
+ //fhtyp[2] = "Mixed";
+ //fhtyp[3] = "Rap. Gap";
+}
+
+//______________________________________________________________________________
+AliJHistos::AliJHistos(const AliJHistos& obj) :
+ fCard(obj.fCard),
+ fHMG(obj.fHMG),
+ fCentBin(obj.fCentBin),
+ fVtxBin(obj.fVtxBin),
+ fPTtBin(obj.fPTtBin),
+ fPTaBin(obj.fPTaBin),
+ fXEBin(obj.fXEBin),
+ fKLongBin(obj.fKLongBin),
+ fRGapBin(obj.fRGapBin),
+ fEtaGapBin(obj.fEtaGapBin),
+ fPhiGapBin(obj.fPhiGapBin),
+ fMassBin(obj.fMassBin),
+ fTypBin(obj.fTypBin),
+ fTypBin3(obj.fTypBin3),
+ fPairPtBin(obj.fPairPtBin),
+ fhMixStat(obj.fhMixStat),
+ fTestHist(obj.fTestHist),
+ fhPtNear(obj.fhPtNear),
+ fhPtFar(obj.fhPtFar),
+ fhPhi(obj.fhPhi),
+ fhDphiAssoc(obj.fhDphiAssoc),
+ fhDphiAssocXEbin(obj.fhDphiAssocXEbin),
+ fhDphiAssoc2DIAA(obj.fhDphiAssoc2DIAA),
+ fhDphiAssoc2D(obj.fhDphiAssoc2D),
+ fhDphiDetaKlong(obj.fhDphiDetaKlong),
+ fhDphiDetaKlongR(obj.fhDphiDetaKlongR),
+ fhDphiDetaXe(obj.fhDphiDetaXe),
+ fhDphiDetaXeR(obj.fhDphiDetaXeR),
+ fhDphiDetaPta(obj.fhDphiDetaPta),
+ fhDphiDetaPtaR(obj.fhDphiDetaPtaR),
+ fhBgAssocKlong(obj.fhBgAssocKlong),
+ fhBgAssocKlongR(obj.fhBgAssocKlongR),
+ fhBgAssocXe(obj.fhBgAssocXe),
+ fhBgAssocXeR(obj.fhBgAssocXeR),
+ fhBgAssocPta(obj.fhBgAssocPta),
+ fhBgAssocPtaR(obj.fhBgAssocPtaR),
+ fhDphiAssocIsolTrigg(obj.fhDphiAssocIsolTrigg),
+ fhMeanPtAssoc(obj.fhMeanPtAssoc),
+ fhMeanZtAssoc(obj.fhMeanZtAssoc),
+ fhPtAssocUE(obj.fhPtAssocUE),
+ fhPtaEtaGapN(obj.fhPtaEtaGapN),
+ fhPtaRGapN(obj.fhPtaRGapN),
+ fhPtAssocUEIsolTrigg(obj.fhPtAssocUEIsolTrigg),
+ fhPtAssocN(obj.fhPtAssocN),
+ fhPtAssocF(obj.fhPtAssocF),
+ fhCosThetaStar(obj.fhCosThetaStar),
+ fhCMSrap(obj.fhCMSrap),
+ fpCMSrap(obj.fpCMSrap),
+ fhInvMass(obj.fhInvMass),
+ fhPairPtMass(obj.fhPairPtMass),
+ fhPairDPhi(obj.fhPairDPhi),
+ fhPairDpT(obj.fhPairDpT),
+ fhPairPtDphi(obj.fhPairDPhi),
+ fhPairPt(obj.fhPairPt),
+ fhDEtaNear(obj.fhDEtaNear),
+ fhDEtaNearM(obj.fhDEtaNearM),
+ fhDEtaNearXEbin(obj.fhDEtaNearXEbin),
+ fhDEtaNearMXEbin(obj.fhDEtaNearMXEbin),
+ fhDRNearPt(obj.fhDRNearPt),
+ fhDRFarPt(obj.fhDRFarPt),
+ fhDRNearPtMoon(obj.fhDRNearPtMoon),
+ fhDRFarPtMoon(obj.fhDRFarPtMoon),
+ fhDRNearPtMoonM(obj.fhDRNearPtMoonM),
+ fhDRFarPtMoonM(obj.fhDRFarPtMoonM),
+ fhDEtaFar(obj.fhDEtaFar),
+ fhIphiTrigg(obj.fhIphiTrigg),
+ fhIetaTrigg(obj.fhIetaTrigg),
+ fhIphiAssoc(obj.fhIphiAssoc),
+ fhIetaAssoc(obj.fhIetaAssoc),
+ fhFixPtBin(obj.fhFixPtBin),
+ fhTriggPtBin(obj.fhTriggPtBin),
+ fhTriggPtBinIsolTrigg(obj.fhTriggPtBinIsolTrigg),
+ fhTriggMult(obj.fhTriggMult),
+ fhAssocPtBin(obj.fhAssocPtBin),
+ fhxEN(obj.fhxEN),
+ fhxEF(obj.fhxEF),
+ fhxEFIsolTrigg(obj.fhxEFIsolTrigg),
+ fhPoutF(obj.fhPoutF),
+ fhxEPtBin(obj.fhxEPtBin),
+ fhJT(obj.fhJT),
+ fhJTBg(obj.fhJTBg),
+ fhJTBgR(obj.fhJTBgR),
+ fhJTKlong(obj.fhJTKlong),
+ fhJTKlongBg(obj.fhJTKlongBg),
+ fhJTKlongBgR(obj.fhJTKlongBgR),
+ fhJTPta(obj.fhJTPta),
+ fhJTPtaBg(obj.fhJTPtaBg),
+ fhJTPtaBgR(obj.fhJTPtaBgR),
+ fhLPpt(obj.fhLPpt),
+ fhLPpairPt(obj.fhLPpairPt),
+ fhChargedPt(obj.fhChargedPt),
+ fhChargedPtNoCorr(obj.fhChargedPtNoCorr),
+ fhChargedPtJacek(obj.fhChargedPtJacek),
+ fhChargedPtJacekEta(obj.fhChargedPtJacekEta),
+ fhChargedPtFiete(obj.fhChargedPtFiete),
+ fhVdelta2(obj.fhVdelta2),
+ fhVdelta3(obj.fhVdelta3),
+ fhVN(obj.fhVN),
+ fhTrackingEfficiency(obj.fhTrackingEfficiency),
+ fpV2(obj.fpV2),
+ fpV3(obj.fpV3),
+ fpVdeltaNorm(obj.fpVdeltaNorm),
+ fhChargedEta(obj.fhChargedEta),
+ fhLPeta(obj.fhLPeta),
+ fhAssocMult(obj.fhAssocMult),
+ fhChargedMult(obj.fhChargedMult),
+ fhChargedMultCut(obj.fhChargedMultCut),
+ fhChargedMultCent(obj.fhChargedMultCent),
+ fhXt(obj.fhXt),
+ fhXtWeighted(obj.fhXtWeighted),
+ fhXtWeightedHT(obj.fhXtWeightedHT),
+ fhPtForXt(obj.fhPtForXt),
+ fhConeActivity(obj.fhConeActivity),
+ fhConeActivityIsolated(obj.fhConeActivityIsolated),
+ fhPerpConeActivity(obj.fhPerpConeActivity),
+ fhPerpConeActivityIsolated(obj.fhPerpConeActivityIsolated),
+ fhV0AMult(obj.fhV0AMult),
+ fhZVertRaw(obj.fhZVertRaw),
+ fhZVertRawErr(obj.fhZVertRawErr),
+ fhZVert(obj.fhZVert),
+ fhCentr(obj.fhCentr),
+ fhiCentr(obj.fhiCentr),
+ fhEventPerRun(obj.fhEventPerRun),
+ fhVertexZTriggVtx(obj.fhVertexZTriggVtx),
+ fhIsolatedLPpt(obj.fhIsolatedLPpt),
+ fhBkgActivity(obj.fhBkgActivity),
+ fhDphiLPJet(obj.fhDphiLPJet),
+ fhDEtaLPJet(obj.fhDEtaLPJet),
+ fhDPtLPJet(obj.fhDPtLPJet),
+ fhLPJetPTt(obj.fhLPJetPTt),
+ fhLPJetPt(obj.fhLPJetPt),
+ fhLPJetEtaPTt(obj.fhLPJetEtaPTt),
+ fhLPJetRapidityPTt(obj.fhLPJetRapidityPTt),
+ fhLPJetMassPTt(obj.fhLPJetMassPTt),
+ fhLeadingJetWLPPTt(obj.fhLeadingJetWLPPTt),
+ fhJetPt(obj.fhJetPt),
+ fhLeadingJetPt(obj.fhLeadingJetPt),
+ fhLeadingJetWLPPt(obj.fhLeadingJetWLPPt),
+ fhJetAssymPTt(obj.fhJetAssymPTt),
+ fhJetMassPTt(obj.fhJetMassPTt),
+ fhJetUEPt(obj.fhJetUEPt),
+ fhJetDphi(obj.fhJetDphi),
+ fhJetDeta(obj.fhJetDeta),
+ fhJetMultPt(obj.fhJetMultPt),
+ fhJetRho(obj.fhJetRho),
+ fhJetRhoSigma(obj.fhJetRhoSigma),
+ fhJetPartMult(obj.fhJetPartMult),
+ fhRecoDiJetM(obj.fhRecoDiJetM),
+ fhRecoDiJetdPhi(obj.fhRecoDiJetdPhi),
+ fhRecoDiJetkT(obj.fhRecoDiJetkT),
+ fhNParton71(obj.fhNParton71),
+ fhNStringGroup(obj.fhNStringGroup),
+ fhNStringGroupFrom(obj.fhNStringGroupFrom),
+ fhNTracksInStringGroupFrom(obj.fhNTracksInStringGroupFrom),
+ fhRapidity71From(obj.fhRapidity71From),
+ fhPt71From(obj.fhPt71From),
+ fhTrackSelection(obj.fhTrackSelection),
+ fNJacek(obj.fNJacek),
+ fPttJacek(obj.fPttJacek),
+ fNEta(obj.fNEta),
+ fEta(obj.fEta),
+ fNJanFiete(obj.fNJanFiete),
+ fJanFiete(obj.fJanFiete),
+ fhEvents(obj.fhEvents),
+ fhEventTrigger(obj.fhEventTrigger),
+ fmaxEtaRange(obj.fmaxEtaRange),
+ fmaxTriggEtaRange(obj.fmaxTriggEtaRange),
+ ftriggFiducCut(obj.ftriggFiducCut),
+ fnUE(obj.fnUE),
+ fnUEfar(obj.fnUEfar),
+ fLowRange(obj.fLowRange),
+ fHighRange(obj.fHighRange)
+{
+ // copy constructor
+ JUNUSED(obj);
+}
+
+//______________________________________________________________________________
+AliJHistos& AliJHistos::operator=(const AliJHistos& obj){
+ // copy constructor
+ JUNUSED(obj);
+ return *this;
+}
+
+//______________________________________________________________________________
+void AliJHistos::CreateAzimuthCorrHistos()
+{
+ // Comment needed here!
+
+ int bins = 240; // 240 is divisible by 2,3,4,612*24=280 -1/3 and 0.5 and 5/3 are bin edges
+ //double fLowRange = -1.0/3, fHighRange= 5.0/3;
+ fLowRange = -9./20.; //lower range for dphi histos
+ fHighRange= fLowRange+2; //upper range for dphi histos;
+ double ptbw=10/100.0; //see hPt histo below, let's make 10 bins per 1GeV/c
+
+ fnUE=20;
+ double uEa = fCard->GetBinBorder(kAssocType, 0), uEb = fCard->GetBinBorder(kAssocType, fCard->GetNoOfBins(kAssocType));
+ double logUEbw = (log(uEb)-log(uEa))/fnUE;
+ for(int ij=0;ij<=fnUE;ij++) fUEBinsx[ij]=uEa*exp(ij*logUEbw);
+
+ fnUEfar=10;
+ logUEbw = (log(uEb)-log(uEa))/fnUEfar;
+ for(int ij=0;ij<=fnUE;ij++) fUEBinsxFar[ij]=uEa*exp(ij*logUEbw);
+
+
+ if(fCard->GetNoOfBins(kCentrType) > kMaxNoCentrBin ){
+ cout<<"ERROR: No of Centrality bins exceed max dim in AliJHistos.cxx "<<endl;
+ exit(0);
+ }
+
+ //==================================
+ // trigger pt fhistos
+ //==================================
+ //TODO tmp
+ double pTt1 = fPTtBin.GetMin();
+ double pTt2 = fPTtBin.GetMax();
+ double pTa1 = fPTaBin.GetMin();
+ double pTa2 = fPTaBin.GetMax();
+
+ fhTriggPtBinIsolTrigg
+ << TH1D( "hTriggPtBinIsolTrigg", "", (int)TMath::Ceil((pTt2-pTt1)/ptbw),pTt1, pTt2)
+ << fTypBin << fCentBin << fPTtBin
+ << "END";
+ fhTriggMult
+ << TH1D( "hTriggMult", "", 100, -0.5, 99.5)
+ << fCentBin << fPTtBin << "END";
+ fhIphiTrigg
+ << TH1D( "fhIphiTrigg", "", bins, -kJPi-0.1, kJPi+0.1)
+ << fCentBin << fPTtBin << "END";
+ fhIetaTrigg
+ << TH1D( "hIetaTrigg", "", 80, -fmaxEtaRange, fmaxEtaRange)
+ << fCentBin << fPTtBin << "END";// inclusive eta
+ fhTriggPtBin
+ << TH1D( "hTriggPtBin", "", (int)TMath::Ceil((pTt2-pTt1)/ptbw),pTt1, pTt2)
+ << fCentBin << fVtxBin << fPTtBin << "END";
+
+ //=====================================
+ // associated pt fhistos with etaGaps
+ //=====================================
+
+ fhDphiAssoc
+ << TH1D( "hDphiAssoc", "", bins, fLowRange, fHighRange)
+ << fTypBin << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+
+ fhDEtaNear
+ << TH1D( "hDEtaNear", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange)
+ << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+ fhDEtaNearM
+ << TH1D( "hDEtaNearM", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange)
+ << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+ //=====================================
+ // associated pt fhistos with etaGaps XE bins
+ //=====================================
+ // xe bins
+ fhDphiAssocXEbin
+ << TH1D( "hDphiAssocXEbin", "", bins, fLowRange, fHighRange)
+ << fTypBin << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ fTestHist
+ << TH1D( "testHist","", 5 , 0 ,5 )
+ <<fTypBin << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ for( int ityp=0;ityp<fTypBin.Size();ityp++ ){
+ for( int ic=0;ic<fCentBin.Size();ic++){
+ for( int ie=0;ie<fEtaGapBin.Size();ie++ ){
+ for( int it=0;it<fPTtBin.Size();it++ ){
+ for( int ix=0;ix<fXEBin.Size();ix++ ){
+ fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 1, double(ityp) );
+ fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 2, double(ic) );
+ fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 3, double(ie) );
+ fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 4, double(it) );
+ fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 5, double(ix) );
+ }
+ }
+ }
+ }
+ }
+ fhDEtaNearXEbin
+ << TH1D( "hDEtaNearXEbin", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange)
+ << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ fhDEtaNearMXEbin
+ << TH1D( "hDEtaNearMXEbin", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange)
+ << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ //=======================================
+ // associated fpt fhistos without etaGaps
+ //=======================================
+ fhDphiAssocIsolTrigg
+ << TH1D( "hDphiAssocIsolTrigg", "", bins, fLowRange, fHighRange)
+ << fTypBin << fCentBin << fPTtBin << fPTaBin << "END";//FK//
+ fhMeanPtAssoc
+ << TProfile( "hMeanPtAssoc", "", bins, fLowRange, fHighRange)
+ << fCentBin << fPTtBin << fPTaBin << "END";
+ fhMeanZtAssoc
+ << TProfile( "hMeanZtAssoc", "", bins, fLowRange, fHighRange)
+ << fCentBin << fPTtBin << fPTaBin << "END";
+ fhAssocPtBin
+ << TH1D( "hAssocPtBin", "", (int)TMath::Ceil((pTa2-pTa1)/ptbw), pTa1, pTa2)
+ << fCentBin << fPTtBin << fPTaBin << "END";
+ fhIphiAssoc
+ << TH1D( "fhIphiAssoc", "", bins, -kJPi-0.1, kJPi+0.1)
+ << fCentBin << fPTaBin << "END";
+ fhIetaAssoc
+ << TH1D( "hIetaAssoc", "", 80, -fmaxEtaRange, fmaxEtaRange)
+ << fCentBin << fPTaBin << "END";
+ fhDEtaFar
+ << TH1D( "hDEtaFar", "", 120, -2*fmaxEtaRange, 2*fmaxEtaRange)
+ << fTypBin << fCentBin << fPTtBin << "END";
+
+ //==========================
+ //UE fhistos
+ //==========================
+ fhPtAssocUE
+ << TH1D( "hPtAssocUE", "", fnUE, fUEBinsx)
+ << fCentBin << fEtaGapBin << fPTtBin << "END";
+ fhPtaEtaGapN
+ << TH1D( "hPtaEtaGapN", "", fnUE, fUEBinsx)
+ << fCentBin << fEtaGapBin << fPTtBin << "END";
+ fhPtaRGapN
+ << TH1D( "hPtaRGapN", "", fnUE, fUEBinsx)
+ << fCentBin << fRGapBin << fPTtBin << "END";
+ fhPtAssocUEIsolTrigg
+ << TH1D( "hPtAssocUEIsolTrigg", "", fnUE, fUEBinsx)
+ << fPTtBin << "END";//FK//
+ fhPtAssocN
+ << TH1D( "hPtAssocN", "", fnUE, fUEBinsx)
+ << fPTtBin << "END";
+ fhPtAssocF
+ << TH1D( "hPtAssocF", "", fnUE, fUEBinsx)
+ << fPTtBin << "END";
+
+ //=======================
+ //jT fhistos
+ //=======================
+
+ int nJT = 100;
+ double jtLow = 0.05, jtHigh = 20;
+
+ double logBinsJt[101];
+ double logJt = (log(jtHigh)-log(jtLow))/nJT;
+ for(int ij=0;ij<=nJT;ij++) logBinsJt[ij]=jtLow*exp(ij*logJt);
+
+ fhPoutF
+ << TH1D( "hPoutF", "", 300, 0, 15)
+ << fTypBin << fCentBin << fPTtBin << fPTaBin << "END";//FK//
+ //let's not compute mixed frandom background - takes a lot of time.
+ fhJTKlongBg
+ << TH1D( "hJTKlongBg", "", nJT, logBinsJt)
+ << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END";
+ fhDphiDetaKlong
+ << TH2D( "hDphiDetaKlong", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END";
+ fhBgAssocKlong
+ << TH1D( "hBgAssocKlong", "", fnUE, fUEBinsx)
+ << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END";
+ //let's not compute mixed frandom background - takes a lot of time.
+ fhJTKlongBgR
+ << TH1D( "hJTKlongBgR", "", nJT, logBinsJt)
+ << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END";
+ fhDphiDetaKlongR
+ << TH2D( "hDphiDetaKlongR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END";
+ fhBgAssocKlongR
+ << TH1D( "hBgAssocKlongR", "", fnUE, fUEBinsx)
+ << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END";
+ fhJTKlong
+ << TH1D( "hJTKlong", "", nJT, logBinsJt)
+ << fTypBin << fCentBin << fPTtBin << fKLongBin << "END";
+ // xe bins
+ fhJTBg
+ << TH1D( "hJTBg", "", nJT, logBinsJt)
+ << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ fhDphiDetaXe
+ << TH2D( "hDphiDetaXe", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ fhBgAssocXe
+ << TH1D( "hBgAssocXe", "", fnUE, fUEBinsx)
+ << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END";
+ fhJTBgR
+ << TH1D( "hJTBgR", "", nJT, logBinsJt)
+ << fCentBin << fRGapBin << fPTtBin << fXEBin << "END";
+ fhDphiDetaXeR
+ << TH2D( "hDphiDetaXeR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fRGapBin << fPTtBin << fXEBin << "END";
+ fhBgAssocXeR
+ << TH1D( "hBgAssocXeR", "", fnUE, fUEBinsx)
+ << fCentBin << fRGapBin << fPTtBin << fXEBin << "END";
+ fhJT
+ << TH1D( "hJT", "", nJT, logBinsJt)
+ << fTypBin << fCentBin << fPTtBin << fXEBin << "END";
+ fhJTPtaBg
+ << TH1D( "hJTPtaBg", "", nJT, logBinsJt)
+ << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+ fhDphiDetaPta
+ << TH2D( "hDphiDetaPta", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+ fhBgAssocPta
+ << TH1D( "hBgAssocPta", "", fnUE, fUEBinsx)
+ << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END";
+ fhJTPtaBgR
+ << TH1D( "hJTPtaBgR", "", nJT, logBinsJt)
+ << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END";
+ fhDphiDetaPtaR
+ << TH2D( "hDphiDetaPtaR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2)
+ << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END";
+ fhBgAssocPtaR
+ << TH1D( "hBgAssocPtaR", "", fnUE, fUEBinsx)
+ << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END";
+ fhJTPta
+ << TH1D( "hJTPta", "", nJT, logBinsJt)
+ << fTypBin << fCentBin << fPTtBin << fPTaBin << "END";
+}
+
+
+void AliJHistos::CreateIAAMoons()
+{
+ //--- IAA signal ---
+ fhDRNearPt
+ << TH1D( "hDRNearPt", "", fnUE, fUEBinsx)
+ << fTypBin << fCentBin << fVtxBin << fRGapBin << fPTtBin << "END";
+ fhDRFarPt
+ << TH1D( "hDRFarPt", "", fnUEfar, fUEBinsxFar)
+ << fTypBin << fCentBin << fVtxBin << fRGapBin << fPTtBin << "END";
+
+ // --- Moons ---
+ fhDRNearPtMoon
+ << TH1D( "hDRNearPtMoon", "", fnUE, fUEBinsx)
+ << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END";
+ fhDRNearPtMoonM
+ << TH1D( "hDRNearPtMoonM", "", fnUE, fUEBinsx)
+ << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END";
+
+ fhDRFarPtMoon
+ << TH1D( "hDRFarPtMoon", "", fnUE, fUEBinsx)
+ << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END";
+ fhDRFarPtMoonM
+ << TH1D( "hDRFarPtMoonM", "", fnUE, fUEBinsx)
+ << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END";
+
+ //==========================
+ // 2D fhistos
+ //==========================
+ fhDphiAssoc2DIAA
+ << TH2D( "hDphiAssoc2DIAA", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, fLowRange, fHighRange)
+ << fTypBin << fCentBin << fVtxBin << fPTtBin << fPTaBin << "END";
+ fhDphiAssoc2D
+ << TH2D( "hDphiAssoc2D", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, fLowRange, fHighRange)
+ << fRGapBin << fPhiGapBin << "END";
+}
+
+void AliJHistos::CreateXEHistos(){
+ //==================================
+ // xe slopes
+ //==================================
+ double xel=0.0, xeh=1.2;
+ int nbxE = int((xeh-xel)/0.04);
+
+ fhxEPtBin
+ << TH1D( "hxEPtBin", "", nbxE, xel, xeh)
+ << fTypBin3 << fPTtBin << fPTaBin << "END";
+ fhxEF
+ << TH1D( "hxEF", "", nbxE, xel, xeh)
+ << fTypBin << fPTtBin <<"END";
+ fhxEFIsolTrigg
+ << TH1D( "hxEFIsoTrigg", "", nbxE, xel, xeh)
+ << fTypBin << fPTtBin << "END";
+ fhxEN
+ << TH1D("hxEN", "", nbxE, xel, xeh)
+ << fTypBin << fPTtBin << "END";
+
+}
+
+void AliJHistos::CreatePairPtCosThetaStar(){
+ // pairs
+ int bins = 288; // 12*24 -1/3 and 0.5 and 5/3 are bin edges
+ double lowRange = -1./3, highRange= 5./3;
+ //=================
+ //pairPT
+ //=================
+ fhPairPtDphi
+ << TH1D( "hPairPtDphi", "", bins, lowRange, highRange)
+ << fTypBin << fPTtBin << fPTaBin << "END";
+ fhPairPt
+ << TH1D( "hPairPt", "", 210, 0, 70)
+ << fTypBin << fPTtBin << fPTaBin << "END";
+ //==================================
+ // CosThetaStar fhistos
+ //==================================
+ //cout<<"ippt="<<fPairPtBin<<" "<<fCard->IsLessThanUpperPairPtCut(-fPairPtBin)<<endl;
+ fhCosThetaStar
+ << TH1D( "hCosThetaStar", "", 100, 0, 1)
+ << fTypBin << fPairPtBin << fMassBin << "END";
+ fhCMSrap
+ << TH2D( "hCMSrap", "", 100, 0, 1, 50, -1, 1)
+ << fPairPtBin << fMassBin << "END";
+ fhInvMass
+ << TH1D( "hInvMass", "", 200, 0, 40)
+ << fPairPtBin << "END";
+
+ fhPairPtMass
+ << TH1D( "hPairPtMass", "", 250, 0, 50)
+ << fMassBin << "END";
+ fhPairDPhi
+ << TH1D( "hPairDPhi", "", bins, lowRange, highRange)
+ << fMassBin << "END";
+ fhPairDpT
+ << TH1D( "hPairDpT", "", 150, 0-25./150./2., 25-25./150./2.)
+ << fMassBin << "END";
+ fpCMSrap
+ << TProfile("pCMSrap","no pair pT cut",100,-1,1)
+ << "END";
+}
+
+//______________________________________________________________________________
+void AliJHistos::CreatePtCorrHistos(){
+ // pt corr histos
+ int ptbins=30;
+ double lpt=0,upt=8;
+ fhPtNear
+ << TH1D( "hPtNear", "", ptbins, lpt, upt)
+ << fTypBin << 3 << fCentBin << "END";
+ fhPtFar
+ << TH1D( "hPtFar", "", ptbins, lpt, upt)
+ << fTypBin << 3 << fCentBin << "END";
+}
+
+//______________________________________________________________________________
+void AliJHistos::CreateRunByRunHistos(int runID, int runcounter) const {
+ // Todo
+ JUNUSED(runID);
+ JUNUSED(runcounter);
+} //TODO
+
+
+//______________________________________________________________________________
+void AliJHistos::CreateEventTrackHistos(){
+ // comment needed
+ int nBINS=150;
+ double logBinsX[nBINS+1], limL=0.1, limH=100;
+ double logBW = (log(limH)-log(limL))/nBINS;
+ for(int ij=0;ij<=nBINS;ij++) logBinsX[ij]=limL*exp(ij*logBW);
+
+ fhLPpt << TH1D("hLPpt","LP pt", nBINS, logBinsX ) << "END";
+ fhLPpairPt << TH1D("hLPpairPt","LP pair pt", nBINS, logBinsX )<< "END";
+ fhChargedEta << TH1D("hChargedEta","All eta",100,-1.0,1.0)<< "END";
+ fhLPeta << TH1D("hLPeta","LP eta",100,-1.0,1.0)<< "END";
+ fhIsolatedLPpt << TH1D("hIsolatedLPpt","Isolated LP pt", nBINS, logBinsX )<< "END";
+ fhChargedPtFiete << TH1D("hChargedPtFiete", "Jan Fiete bins", fNJanFiete, fJanFiete )<< "END";
+
+
+ fhAssocMult << TH1D("hAssocMult","Assoc mlt",100,-0.5,99.5)<< "END";
+
+ fhChargedMult
+ << TH1D("hChargedMult","", 300, 0., 3500.)
+ << fCentBin << "END";
+ fhChargedMultCut
+ << TH1D("hChargedMultCut","", 300, 0., 3500.)
+ << fCentBin << "END";
+ fhZVert
+ << TH1D("hZVert", "", 100, -30., 30.)
+ << fCentBin << "END";
+ fhChargedPt
+ << TH1D("hChargedPt","", nBINS, logBinsX )
+ << fCentBin << "END";
+ fhChargedPtNoCorr
+ << TH1D("hChargedPtNoCorr","", nBINS, logBinsX )
+ << fCentBin << "END";
+ fhChargedPtJacek
+ << TH1D("hChargedPtJacek","", fNJacek, fPttJacek )
+ << fCentBin << "END";
+ fhChargedPtJacekEta
+ << TH1D("hChargedPtJacekEta","", fNJacek, fPttJacek )
+ << fCentBin << 3 << "END";
+
+ fhVdelta2 << TH1D("hVdelta2","", 100, -0.2, 5)
+ << fCentBin << "END";
+ fhVdelta3 << TH1D("hVdelta3","", 100, -0.2, 5)
+ << fCentBin << "END";
+ fhVN << TH1D("hVN","", 100, -kJPi, kJPi)
+ << fCentBin << "END";
+ fhTrackingEfficiency << TProfile("hTrackingEff","",fNJacek, fPttJacek)
+ << fCentBin << "END";
+ fhV0AMult << TH1D("hV0Mult","", 2000,0,2000 )
+ << fCentBin << "END";
+ fpV2 << TProfile("pV2", "v2 with cent", 50, 0, 90) << "END";
+ fpV3 << TProfile("pV3", "v3 with cent", 50, 0, 90) << "END";
+ fpVdeltaNorm << TProfile("pVdeltaNorm", "mult with cent", 50, 0, 90) << "END";
+ fhChargedMultCent << TH2D("hChargedMultCent ", "log(fmult) vs cent", 100, 0, 90, 100, 1, 10) << "END";
+ fhZVertRaw << TH1D("hZVertRaw","vertex 0", 120, -30., 30.) << "END";
+ fhZVertRawErr << TH1D("hZVertRawErr","vertex 0 Err", 100, 0, 0.1) << "END";
+ fhCentr << TH1D("hCentr","centrality", 101, -0.5, 100.5) << "END";
+ fhiCentr << TH1D("hiCentr","centrality",10, -0.5, 9.5) << "END";
+ fhEventPerRun << TH1D("hEventPerRun","log(eve)/run",200, 0, 30.0) << "END";
+ fhBkgActivity
+ << TH1D("hBkgActivity", "", 200, 0, 20)
+ << fPTtBin <<"END";
+
+ //------------------ for Abs Norm FK --------------------------------
+ double binsVertexMult[] = {0,1,2,3,4,5,10000};
+ int nbinsVertexMult = sizeof(binsVertexMult)/sizeof(double)-1;
+ //double binsVertexZ[] = {-10,-5,-2,0,2,5,10};
+ 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 << TH2D("hVertexZTriggVtx","Vertex counts", nbinsVertexMult, binsVertexMult, nbinsVertexZ, binsVertexZ) << "END";
+
+ // event counter
+ fhEvents
+ << TH1D("hEvents","events passing cuts", 100, -0.5, 100-0.5 ) << "END";
+ fhEventTrigger
+ << TH1D("hEventTrigger","Trigger count", 50, -0.5, 50.-.5 )
+ << "END";
+ fhTrackSelection
+ << TH1D("hTrackSelection","checking bit convention", 100, -0.5, 100-0.5) << "END";
+ // TODO fhEvents->SetXTitle( "0 - all, 1 - SDD selected, 2 - has vertex, 3 - good vertex, 4 - trigger + MB, 5 - trigger, 6 - BX, 7 - centrality" );
+}
+
+void AliJHistos::CreateJetHistos(){
+ // jet histos
+ int nBINS=200;
+ double logBinsX[nBINS+1], limL=0.1, limH=200;
+ double logBW = (log(limH)-log(limL))/nBINS;
+ for(int ij=0;ij<=nBINS;ij++) logBinsX[ij]=limL*exp(ij*logBW);
+
+ fhLPJetPt
+ << TH1D( "hLPJetPt", "", nBINS, logBinsX)
+ << fCentBin << "END";
+ fhJetPt
+ << TH1D( "hJetPt", "", nBINS, logBinsX)
+ << fCentBin << "END";
+ fhLeadingJetPt
+ << TH1D( "hLeadingJetPt", "", nBINS, logBinsX)
+ << fCentBin << "END";
+ fhLeadingJetWLPPt
+ << TH1D( "hLeadingJetWLPPt", "", nBINS, logBinsX)
+ << fCentBin << "END";
+ fhLPJetPTt
+ << TH1D( "hLPJetPTt", "", nBINS, logBinsX)
+ << fCentBin << fPTtBin << "END";
+ fhLeadingJetWLPPTt
+ << TH1D( "hLeadingJetWLPPTt", "", nBINS, logBinsX)
+ << fCentBin << fPTtBin << "END";
+ fhLPJetEtaPTt
+ << TH1D( "hLPJetEtaPTt", "", 100, -1, 1)
+ << fCentBin << fPTtBin << "END";
+ fhLPJetRapidityPTt
+ << TH1D( "hLPJetRapidityPTt", "", 100, -1, 1)
+ << fCentBin << fPTtBin << "END";
+ fhLPJetMassPTt
+ << TH1D( "hLPJetMassPTt", "", nBINS, logBinsX)
+ << fCentBin << fPTtBin << "END";
+ fhDphiLPJet
+ << TH1D( "hDphiLPJet", "", 160, -kJPi/2., kJPi/2.)
+ << fCentBin << fPTtBin << "END";
+ fhDEtaLPJet
+ << TH1D( "hDEtaLPJet", "", 240, -1.2, 1.2)
+ << fCentBin << fPTtBin << "END";
+ // LP jet vs Leading Jet
+ fhDPtLPJet
+ << TH1D( "hDPtLPJet", "", 100, 0, 10.)
+ << fCentBin << fPTtBin << "END";
+ //==================================
+ fhJetDphi << TH1D( "hJetDphi", "#Delta#phi", 100,-TMath::Pi(), TMath::Pi())
+ << fTypBin << fPTtBin <<"END";
+ fhJetDeta << TH1D("hJetDeta","#Delta#eta ",100,-1, 1)
+ << fTypBin << fPTtBin <<"END";
+ fhJetMultPt << TH1D("hJetMultPt","Jet Multiplicity ",100,0-0.5, 100-0.5)
+ << fPTtBin <<"END";
+ fhJetRho << TH1D("hJetRho","#rho",200,0, 50)
+ << fPTtBin <<"END";
+ fhJetRhoSigma << TH1D("hJetRhoSigma","#sigma",200,0, 50)
+ << fPTtBin <<"END";
+ // How many particles in a jet
+ fhJetPartMult << TH1D("hJetPartMult","Number of consituents",100, 0-0.5, 100-0.5)
+ << fPTtBin <<"END";
+ fhRecoDiJetM
+ << TH1D("hRecoDiJetM", "Invariant Mass", 201,-0.5, 200 )
+ << "END";
+ fhJetUEPt
+ << TH1D("hJetUEPt","UE particles p_{T} by Jet substract",nBINS,logBinsX)
+ << "END";
+ // pytfPTaBin
+ fhNParton71
+ << TH1D("hNParton71", "hNParton71", 100, -0.5, 100-0.5)
+ <<"END";
+ fhNStringGroup
+ << TH1D("hNStringGroup", "hNStringGroup", 100, -0.5, 100-0.5)
+ <<"END";
+ fhNStringGroupFrom << TH1D("hNStringGroupFrom", "hNStringGroupFrom", 100, -0.5, 100-0.5) << 2 <<"END";
+ fhNTracksInStringGroupFrom << TH1D("hNTracksInStringGroupFrom", "hNTracksInStringGroupFrom", 100, -0.5, 100-0.5) << 2 << "END";
+ fhRapidity71From << TH1D("hRapidity71From", "hRapidity71From", 100, -8, 8 ) << 2 << "END";
+ fhPt71From
+ << TH1D("hPt71From", "hPt71From", 1000, 0, 100)
+ << 2 << "END";
+
+}
+
+//______________________________________________________________________________
+void AliJHistos::CreateXtHistos() {
+
+ // TODO MakeDirectory("xT");
+ // Esko
+ TH1::SetDefaultSumw2(kTRUE);
+ cout << "GetDefaultSumw2() = " << TH1::GetDefaultSumw2() << endl;
+
+ // 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);
+
+
+ // pT binning
+ int nBinsPt=200;
+ double logBinsPt[nBinsPt+1];
+ double pTLimL=0.1, pTLimH=200 , pTlogBW = (log(pTLimH)-log(pTLimL))/nBinsPt;
+ for(int ij=0;ij<=nBinsPt;ij++) logBinsPt[ij]=pTLimL*exp(ij*pTlogBW);
+
+ fhConeActivity << TProfile("hActivity", "Mean activity inside cone", nBinsPt, logBinsPt );
+ fhPerpConeActivity << TProfile("hPerpActivity", "Mean activity inside perpendicular cone", nBinsPt, logBinsPt );
+ fhConeActivityIsolated << TProfile("hActivityIsolated", "Mean pion activity inside cone isolated", nBinsPt, logBinsPt );
+
+ fhPerpConeActivityIsolated << TProfile("hPerpActivityIsolated", "Mean activity inside perpendicular cone", nBinsPt, logBinsPt );
+ fhPtForXt
+ << TH1D("hPtForXt","", fNJacek, fPttJacek )
+ << 3 << fCentBin <<"END";
+
+ fhXt
+ << TH1D("hXt", "Charged xT", nBinsXt, logBinsXt )
+ << 3 << fCentBin <<"END";
+
+ fhXtWeighted
+ << TH1D("hXtWeighted", "Charged xT", nBinsXt, logBinsXt )
+ << 3 << fCentBin <<"END";
+
+ fhXtWeightedHT
+ << TH1D("hXtWeightedHT", "", nBinsXt, logBinsXt )
+ << 3 << fCentBin <<"END";
+}
+
+//______________________________________________________________________________
+//void AliJHistos::ReadInclusiveHistos(TFile *inFile){
+void AliJHistos::ReadInclusiveHistos(const char *inclusFileName){
+ // read inclusive histos
+ TFile *inclusFile = new TFile(inclusFileName, "READ");
+
+ //inFile->ls();
+ //cout<<((TH1D*) inclusFile->Get(Form("hIetaTrigg%02d%02d", 0, 0)))->GetEntries() <<endl;
+ //abort();
+
+ for (int hic = 0;hic < fCard->GetNoOfBins(kCentrType);hic++) {
+ for (int hit = 0; hit < fCard->GetNoOfBins(kTriggType);hit++){
+ fhIetaTriggFromFile[hic][hit] = (TH1D*) inclusFile->Get(Form("hIetaTrigg%02d%02d", hic, hit));//FK//mix2
+ //fhistoList->Add(fhIetaTriggFromFile[hic][hit]);
+ fhIphiTriggFromFile[hic][hit] = (TH1D*) inclusFile->Get(Form("hIphiTrigg%02d%02d", hic, hit));//FK//mix2
+ //fhistoList->Add(fhIphiTriggFromFile[hic][hit]);
+ cout<<"c=" << hic <<" tr="<< hit <<" "<<fhIetaTriggFromFile[hic][hit]<<flush;
+ cout<<" entries="<<fhIetaTriggFromFile[hic][hit]->GetEntries() << endl;
+ }
+ }
+
+ for (int hic = 0;hic < fCard->GetNoOfBins(kCentrType);hic++) {
+ for (int hia = 0; hia < fCard->GetNoOfBins(kAssocType); hia++){
+ fhIetaAssocFromFile[hic][hia] = (TH1D*) inclusFile->Get(Form("hIetaAssoc%02d%02d", hic, hia));//FK//mix2
+ //fhistoList->Add(fhIetaAssocFromFile[hic][hia]);
+ fhIphiAssocFromFile[hic][hia] = (TH1D*) inclusFile->Get(Form("hIphiAssoc%02d%02d", hic, hia));//FK//mix2
+ //fhistoList->Add(fhIphiAssocFromFile[hic][hia]);
+ cout<<"c=" << hic <<" as="<< hia <<" entries="<< fhIetaAssocFromFile[hic][hia]->GetEntries() <<endl;
+ }
+ }
+
+ int numCent = fCard->GetNoOfBins(kCentrType);
+ int numPtt = fCard->GetNoOfBins(kTriggType);
+ int numPta = fCard->GetNoOfBins(kAssocType);
+ int numEtaGaps = fCard->GetNoOfBins(kEtaGapType);
+ int numZvtx = fCard->GetNoOfBins(kZVertType);
+
+ //------------ R e a d mixed D a t a ------------
+ const int zFirstBin = 0 ;
+ const int etaGapFirstBin = 0 ;
+ for (int hic = 0;hic < numCent; hic++) {
+ for (int hit = 0; hit < numPtt;hit++){
+ for (int hia = 0; hia < numPta; hia++){
+ fhDEtaNearMixFromFile[hic][hit][hia]= (TH1D*) inclusFile->Get(Form("hDEtaNear/hDEtaNear%02d%02d%02d%02d%02d%02d", 1, hic, zFirstBin, etaGapFirstBin, hit, hia));
+ for (int iEtaGap=0; iEtaGap < numEtaGaps; iEtaGap++){//fdphi slices
+ for (int hiz = 0; hiz < numZvtx; hiz++) {
+ if( iEtaGap==etaGapFirstBin && hiz==zFirstBin ) continue;
+ TH1D *hid = (TH1D*) inclusFile->Get(Form("hDEtaNear/hDEtaNear%02d%02d%02d%02d%02d%02d", 1, hic, hiz, iEtaGap, hit, hia));
+ fhDEtaNearMixFromFile[hic][hit][hia]->Add(hid);
+ }
+ }
+ //normalize to traingle
+ double counts = fhDEtaNearMixFromFile[hic][hit][hia]->Integral();
+ double bw = fhDEtaNearMixFromFile[hic][hit][hia]->GetBinWidth(1);
+ int rebin = 4;
+ if(counts<5000) rebin=8;
+ if(counts<3000) rebin=10;
+ if(counts<1000) rebin=16;
+ fhDEtaNearMixFromFile[hic][hit][hia]->Rebin(rebin);
+ if(counts>0) fhDEtaNearMixFromFile[hic][hit][hia]->Scale(2.*fmaxEtaRange/counts/bw/rebin);//triangle f(0)=1, f(1.6)=0
+ //if(counts>0) fhDEtaNearMixFromFile[hic][hit][hia]->Scale(2.*fmaxEtaRange/counts/bw);
+ //cout<<"c=" << hic <<" as="<< hia <<" entries="<< fhDEtaNearMixFromFile[hic][hit][hia]->GetEntries() <<endl;
+
+ }
+ }
+ }
+
+
+ //for (int hic = 0;hic < fCard->GetNoOfBins(kCentrType);hic++) {
+ // for (int hit = 0; hit < fCard->GetNoOfBins(kTriggType);hit++){
+ // for (int hia = 0; hia < fCard->GetNoOfBins(kAssocType); hia++){
+ // hDphiAssocMixSpectraFile[hic][hit][hia]= (TH1D*) inclusFile->Get(Form("xhDphiAssoc%02dC%02dE00T%02dA%02d",1, hic, hit, hia));//FK//mix2
+ // }
+ // }
+ //}
+}
--- /dev/null
+/* 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!
+
+//===========================================================
+// AliJHistos.h
+//
+// J
+//===========================================================
+
+#ifndef ALIJHISTOS_H
+#define ALIJHISTOS_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>
+#include <TLorentzVector.h>
+
+#include "AliJConst.h"
+#include "AliJHistManager.h"
+
+class AliJCard;
+class AliJBaseTrack;
+class AliJPhoton;
+class AliJTrack;
+
+using namespace std;
+
+inline ostream &operator << (ostream &out_file, const TLorentzVector &Vec)
+{
+ out_file<<"Px="<<Vec.Px()<<" Py="<<Vec.Py()<<" Pz="<<Vec.Pz()<<" E="<<Vec.E()<<" M="<<Vec.M()<<endl;
+ out_file<<"Theta="<<Vec.Theta()<<" Phi="<<Vec.Phi()<<" p="<<Vec.Rho()<<endl;
+ return(out_file);
+}
+
+class AliJHistos {
+
+public:
+ AliJHistos(AliJCard* cardP); //constructor
+ virtual ~AliJHistos(){;} //destructor
+ AliJHistos(const AliJHistos& obj);
+ AliJHistos& operator=(const AliJHistos& obj);
+
+ // create histograms
+ void CreateAzimuthCorrHistos();
+ void CreateIAAMoons();
+ void CreateXEHistos();
+ void CreateXtHistos();
+
+ void CreateEventTrackHistos();
+ void CreateJetHistos();
+
+ void CreatePairPtCosThetaStar();
+ void CreatePtCorrHistos();
+ void CreateRunByRunHistos(int runID, int runcounter) const;
+
+ void ReadInclusiveHistos(const char *inclusFileName);
+
+public:
+ AliJCard *fCard; // card
+
+ AliJHistManager * fHMG; // Histogram manager
+ AliJBin fCentBin; // Bin of Centrality
+ AliJBin fVtxBin; // Bin of Z-vertex Bin
+ AliJBin fPTtBin; // Bin of pT Trigged
+ AliJBin fPTaBin; // Bin of pT Associated
+ AliJBin fXEBin; // Bin of XE
+ AliJBin fKLongBin; // Bin of Klong
+ AliJBin fRGapBin; // Bin of R-gap
+ AliJBin fEtaGapBin; // Bin of Eta-gap
+ AliJBin fPhiGapBin; // Bin of Phi-gap
+ AliJBin fMassBin; // Bin of Mass
+ AliJBin fTypBin; // Bin of type ( data, mixed ), but is being used for any 2 dimension
+ AliJBin fTypBin3; // Bin of type3, is being used for any 3 dimension
+ AliJBin fPairPtBin; // Bin of pT pair
+
+ AliJTProfile fhMixStat; // comment me
+
+ //==Pt stat. fcorrelations ===============================================
+ AliJTH1D fTestHist; // test only, remove it not needed
+ AliJTH1D fhPtNear; // comment me
+ AliJTH1D fhPtFar ; // comment me
+
+ //assorted
+ AliJTH1D fhPhi; // comment me
+ AliJTH1D fhDphiAssoc; // comment me
+ AliJTH1D fhDphiAssocXEbin; // comment me
+ //2D
+ AliJTH2D fhDphiAssoc2DIAA; // comment me
+ AliJTH2D fhDphiAssoc2D; // comment me
+
+ // JV // 2D dphi deta histos to study better the background
+ AliJTH2D fhDphiDetaKlong; // 2D histogram from deltaPhi-deltaEta plane in klong and eta gap bins
+ AliJTH2D fhDphiDetaKlongR; // 2D histogram from deltaPhi-deltaEta plane in klong and R gap bins
+ AliJTH2D fhDphiDetaXe; // 2D histogram from deltaPhi-deltaEta plane in xlong and eta gap bins
+ AliJTH2D fhDphiDetaXeR; // 2D histogram from deltaPhi-deltaEta plane in xlong and R gap bins
+ AliJTH2D fhDphiDetaPta; // 2D histogram from deltaPhi-deltaEta plane in pta and eta gap bins
+ AliJTH2D fhDphiDetaPtaR; // 2D histogram from deltaPhi-deltaEta plane in pta and R gap bins
+
+ // JV // pTa distributions in background bins
+ AliJTH1D fhBgAssocKlong; // background pta distribution in klong and eta gap bins
+ AliJTH1D fhBgAssocKlongR; // background pta distribution in klong and R gap bins
+ AliJTH1D fhBgAssocXe; // background pta distribution in xlong and eta gap bins
+ AliJTH1D fhBgAssocXeR; // background pta distribution in xlong and R gap bins
+ AliJTH1D fhBgAssocPta; // background pta distribution in pta and eta gap bins
+ AliJTH1D fhBgAssocPtaR; // background pta distribution in pta and R gap bins
+
+ AliJTH1D fhDphiAssocIsolTrigg ; // comment me
+ AliJTProfile fhMeanPtAssoc ; // comment me
+ AliJTProfile fhMeanZtAssoc ; // comment me
+ AliJTH1D fhPtAssocUE; //FK// Eta Gap dependent UE
+ AliJTH1D fhPtaEtaGapN; //FK// pta spectrum with Eta Gap
+ AliJTH1D fhPtaRGapN; //FK// pta spectrum with Eta Gap
+ AliJTH1D fhPtAssocUEIsolTrigg; //FK// trigger isolated hadron
+ AliJTH1D fhPtAssocN, fhPtAssocF; // comment needed
+
+ //cosThetaStar
+ AliJTH1D fhCosThetaStar; // comment me
+ AliJTH2D fhCMSrap; // comment me
+ AliJTProfile fpCMSrap; // comment me
+ AliJTH1D fhInvMass, fhPairPtMass, fhPairDPhi, fhPairDpT; // comment me
+ AliJTH1D fhPairPtDphi, fhPairPt; // comment me
+
+ AliJTH1D fhDEtaNear; // comment me
+ AliJTH1D fhDEtaNearM; // comment me
+ AliJTH1D fhDEtaNearXEbin; // comment me
+ AliJTH1D fhDEtaNearMXEbin; // comment me
+
+ AliJTH1D fhDRNearPt; // comment me
+ AliJTH1D fhDRFarPt; // comment me
+ AliJTH1D fhDRNearPtMoon; // comment me
+ AliJTH1D fhDRFarPtMoon; // comment me
+ AliJTH1D fhDRNearPtMoonM; // comment me
+ AliJTH1D fhDRFarPtMoonM ; // comment me
+
+ //AliJTH1D *hDEtaUE;
+ AliJTH1D fhDEtaFar; // comment me
+ AliJTH1D fhIphiTrigg; // comment me
+ AliJTH1D fhIetaTrigg; // comment me
+ AliJTH1D fhIphiAssoc; // comment me
+ AliJTH1D fhIetaAssoc; // comment me
+ AliJTH1D fhFixPtBin; // comment me
+ AliJTH1D fhTriggPtBin; // comment me
+ AliJTH1D fhTriggPtBinIsolTrigg; //FK// trigger isolated hadron
+ AliJTH1D fhTriggMult; // comment me
+ AliJTH1D fhAssocPtBin; // comment me
+ //TH1D *hInvMassLike[2][kMaxNoCentrBin][kPtDim], *hInvMassUnLike[2][kMaxNoCentrBin][kPtDim];
+
+ //==================================================
+ // xe slopes - done manually for the pp purpose only
+ // you have to determine 7 trigger bins
+ //==================================================
+ AliJTH1D fhxEN, fhxEF, fhxEFIsolTrigg; // comment me
+ AliJTH1D fhPoutF; // comment me
+ AliJTH1D fhxEPtBin; // all=0,near=1,far=2
+ // xe bins
+ AliJTH1D fhJT; // comment me
+ AliJTH1D fhJTBg; // comment me
+ AliJTH1D fhJTBgR; // comment me
+ // klong bins
+ AliJTH1D fhJTKlong; // comment me
+ AliJTH1D fhJTKlongBg; // comment me
+ AliJTH1D fhJTKlongBgR; // comment me
+ // pta bins
+ AliJTH1D fhJTPta; // comment me
+ AliJTH1D fhJTPtaBg; // comment me
+ AliJTH1D fhJTPtaBgR; // comment me
+
+ //FK//mix2 inclusve spectra
+ TH1D *fhIetaTriggFromFile [kMaxNoCentrBin][kPtDim];//FK//mix2
+ TH1D *fhIetaAssocFromFile [kMaxNoCentrBin][kPtDim];//FK//mix2
+ TH1D *fhIphiTriggFromFile [kMaxNoCentrBin][kPtDim];//FK//mix2
+ TH1D *fhIphiAssocFromFile [kMaxNoCentrBin][kPtDim];//FK//mix2
+ TH1D *fhDphiAssocMixFromFile [kMaxNoCentrBin][kPtDim][kPtDim];//FK//mix2
+
+ TH1D *fhDEtaNearMixFromFile[kMaxNoCentrBin][kPtDim][kPtDim]; // comment me
+
+ //===================================================
+ // Event/Track histograms
+ //===================================================
+ AliJTH1D fhLPpt; // comment me
+ AliJTH1D fhLPpairPt; // comment me
+ AliJTH1D fhChargedPt, fhChargedPtNoCorr; // comment me
+ AliJTH1D fhChargedPtJacek; // comment me
+ AliJTH1D fhChargedPtJacekEta; // 3 bins in eta
+ AliJTH1D fhChargedPtFiete; // comment me
+ AliJTH1D fhVdelta2,fhVdelta3, fhVN; // comment me
+ AliJTProfile fhTrackingEfficiency; // comment needed
+ AliJTProfile fpV2, fpV3, fpVdeltaNorm; // comment me
+ AliJTH1D fhChargedEta; // comment me
+ AliJTH1D fhLPeta; // comment me
+ AliJTH1D fhAssocMult; // comment me
+ AliJTH1D fhChargedMult, fhChargedMultCut; // comment me
+ AliJTH2D fhChargedMultCent; // comment me
+
+ // XAliJT histogrmas
+ AliJTH1D fhXt; // comment needed
+ AliJTH1D fhXtWeighted; // comment needed
+ AliJTH1D fhXtWeightedHT; // HT pions
+ AliJTH1D fhPtForXt; // comment me
+ AliJTProfile fhConeActivity; // pT sum in cone, to be compared to the ALICE UE results
+ AliJTProfile fhConeActivityIsolated; // activity for isolated triggers
+ AliJTProfile fhPerpConeActivity; // pT sum in cone perpendicular to the leading particle
+ AliJTProfile fhPerpConeActivityIsolated; // same as above but for isolated leading particle
+
+ AliJTH1D fhV0AMult; // comment needed
+
+ AliJTH1D fhZVertRaw; // comment me
+ AliJTH1D fhZVertRawErr; // comment me
+ AliJTH1D fhZVert; // comment me
+ AliJTH1D fhCentr; // comment me
+ AliJTH1D fhiCentr; // comment me
+ AliJTH1D fhEventPerRun; // comment me
+ AliJTH2D fhVertexZTriggVtx; // comment me
+
+ AliJTH1D fhIsolatedLPpt; // comment me
+ AliJTH1D fhBkgActivity; // comment me
+
+ // D.J
+ //===================================================
+ // Jet with LP Histograms
+ //===================================================
+ AliJTH1D fhDphiLPJet; // comment me
+ AliJTH1D fhDEtaLPJet; // comment me
+ AliJTH1D fhDPtLPJet; // comment me
+ AliJTH1D fhLPJetPTt; // comment me
+ AliJTH1D fhLPJetPt; // comment me
+ AliJTH1D fhLPJetEtaPTt; // comment me
+ AliJTH1D fhLPJetRapidityPTt; // comment me
+ AliJTH1D fhLPJetMassPTt; // comment me
+
+ AliJTH1D fhLeadingJetWLPPTt; // comment me
+
+ AliJTH1D fhJetPt; // comment me
+ AliJTH1D fhLeadingJetPt; // comment me
+ AliJTH1D fhLeadingJetWLPPt; // comment me
+
+ AliJTH1D fhJetAssymPTt; // comment me
+ AliJTH1D fhJetMassPTt; // comment me
+ AliJTH1D fhJetUEPt; // comment me
+
+ //===================================================
+ // Jet Histograms
+ //===================================================
+ AliJTH1D fhJetDphi; // comment me
+ AliJTH1D fhJetDeta; // comment me
+ AliJTH1D fhJetMultPt; // comment me
+
+ //==================================================
+ // Background study
+ //==================================================
+ AliJTH1D fhJetRho; // comment me
+ AliJTH1D fhJetRhoSigma; // comment me
+
+ AliJTH1D fhJetPartMult; // comment me
+
+ AliJTH1D fhRecoDiJetM; // comment me
+ AliJTH1D fhRecoDiJetdPhi; // comment me
+ AliJTH1D fhRecoDiJetkT; // comment me
+
+ //===================================================
+ // parton 71 Histogram
+ //===================================================
+ AliJTH1D fhNParton71 ; // comment me
+ AliJTH1D fhNStringGroup; // comment me
+ AliJTH1D fhNStringGroupFrom; // comment me
+ AliJTH1D fhNTracksInStringGroupFrom; // comment me
+ AliJTH1D fhRapidity71From; // comment me
+ AliJTH1D fhPt71From; // comment me
+
+ //===================================================
+ // PHENIX histograms
+ //===================================================
+ //==Run-by-Run calib ================================
+ TH1D *fTofPbSc[kMaxNoRuns]; TH1D *fTofPbGl[kMaxNoRuns]; // comment me
+ //==Pt and FlipSlide Spectra=============================================
+ TH1D *fhCglPt3PC[kMaxNoCentrBin], *fhCglPtFlip3PC[kMaxNoCentrBin]; // comment me
+ TH1D *fhCglPt32PC[kMaxNoCentrBin], *fhCglPtFlip32PC[kMaxNoCentrBin]; // comment me
+
+
+ AliJTH1D fhTrackSelection; // checking bit convention
+
+ // Manual bin definitions
+ int fNJacek; // Number of bins in Jacek binning
+ double *fPttJacek; // Bin borders in Jacek binning
+ int fNEta; // Number of bins in eta binning
+ double *fEta; // Bin borders in eta binning
+ int fNJanFiete; // Number of bins in JanFiete binning
+ double *fJanFiete; // Bin borders in JanFiete binning
+
+ // additional histos
+ AliJTH1D fhEvents; // comment needed
+ AliJTH1D fhEventTrigger; // comment needed
+
+protected:
+ double fmaxEtaRange; // maximum eta range
+ double fmaxTriggEtaRange; // should be the same as above. Use for GeoAccCorr
+ double ftriggFiducCut; // fiducial cut for the trigger part in eta. Not in use I think (Jan)
+ int fnUE, fnUEfar; // logarithmic binning for some pT and UE histos
+ double fUEBinsx[101], fUEBinsxFar[101]; // logarithmic bins for the underlaying event
+ double fLowRange, fHighRange; // lower and upper range for dphi histos
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJJet.h"
+
+AliJJet::AliJJet():
+ AliJBaseTrack(),
+ fArea(0),
+ fConstituents()
+{;}
+
+
+AliJJet::AliJJet(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge):
+ AliJBaseTrack( px, py, pz, e, id, ptype, charge ),
+ fArea(0),
+ fConstituents()
+{;}
+
+AliJJet::AliJJet(const AliJJet& a):
+ AliJBaseTrack( a ),
+ fArea( a.fArea ),
+ fConstituents( a.fConstituents )
+{;}
+
+AliJJet::AliJJet(const TLorentzVector & a):
+ AliJBaseTrack( a ),
+ fArea(0),
+ fConstituents()
+{;}
+
+
+AliJJet& AliJJet::operator=(const AliJJet& trk){
+ //operator =
+ if(this != &trk){
+ AliJBaseTrack::operator=(trk);
+ fArea = trk.fArea;
+ fConstituents = trk.fConstituents;
+ }
+ return *this;
+}
+
+ClassImp(AliJJet)
--- /dev/null
+/* 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 ALIJJET_H
+#define ALIJJET_H
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+#include <iostream>
+#include <TLorentzVector.h>
+#include <TObjArray.h>
+#include "AliJConst.h"
+#include "AliJBaseTrack.h"
+
+using namespace std;
+
+class AliJJet : public AliJBaseTrack {
+public:
+ AliJJet();
+ AliJJet(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge); // constructor
+ AliJJet(const AliJJet& a);
+ AliJJet(const TLorentzVector & a);
+ virtual ~AliJJet(){; } //destructor
+ AliJJet& operator=(const AliJJet& trk);
+
+ void SetArea(double a){ fArea = a; }
+ Double_t GetArea() const{ return fArea; }
+ Double_t Area() const{ return fArea; }
+ void AddConstituent(TObject* t){ fConstituents.Add(t); }
+ TObjArray* GetConstituents(){ return &fConstituents; }
+ AliJBaseTrack * GetConstituent(int i) const{ return (AliJBaseTrack*)fConstituents[i]; }
+
+private:
+ Double_t fArea; // Area of the jet
+ TObjArray fConstituents; // Constituent tracks of the jets
+
+ ClassDef(AliJJet,1)
+};
+#endif
/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * 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 notifce *
+ * 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: AliJMCTrack.cxx,v 1.2 2008/05/08 13:44:45 djkim Exp $
////////////////////////////////////////////////////
fVz(0)
{
// default constructor
- fMother[0] = fMother[1] = 0;
- fDaughter[0] = fDaughter[1] = 0;
+ fMother[0] = fMother[1] = -1;
+ fDaughter[0] = fDaughter[1] = -1;
}
// Set PDG code, charge, recalculate E
if( TMath::Abs(icode) > 32767 ) icode = 0; // Short_t
fPdgCode=icode;
- SetVectM(Vect(), GetPDGData().Mass());
- SetCharge( TMath::Nint(GetPDGData().Charge()) ); // is this right?
+// SetVectM(Vect(), GetPDGData().Mass());
+// SetCharge( TMath::Nint(GetPDGData().Charge()) ); // is this right?
}
+/* 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: AliJMCTrack.h,v 1.3 2008/05/08 15:19:52 djkim Exp $
////////////////////////////////////////////////////
class AliJMCTrack : public AliJBaseTrack {
public:
- enum { kPrimary=AliJBaseTrack::kNFlag, kPHOS, kEMCAL, kTPC, kNFlag };//For ALICE
+ enum { kPrimary=AliJBaseTrack::kNFlag, kPHOS, kEMCAL, kTPC, kInjected, kNFlag };//For ALICE
enum { kFinal=AliJBaseTrack::kNFlag };// for MC
//usage : this->SetFlag( kPrimary, kTRUE );
//usage : this->IsTrue( kFinal );
- AliJMCTrack(); //default constructor
- AliJMCTrack(const AliJMCTrack& a); //copy constructor
+ AliJMCTrack(); //default constructor
+ AliJMCTrack(const AliJMCTrack& a); //copy constructor
- ~AliJMCTrack(){;} //destructor
+ ~AliJMCTrack(){;} //destructor
Int_t GetPdgCode() const {return fPdgCode;}
Int_t GetMother (Int_t i) const {return fMother[i];}
//TODO
Bool_t IsHadron() const;
Bool_t IsCharged() const { return GetCharge(); }
- Bool_t IsParton() const {return ( fPdgCode < -7 && fPdgCode < 7 && fPdgCode !=0 );}
+ Bool_t IsParton() const {return ( fPdgCode > -7 && fPdgCode < 7 && fPdgCode !=0 );}
private:
+/**************************************************************************
+ * 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: AliJPhoton.cxx,v 1.4 2008/05/08 13:44:45 djkim Exp $
////////////////////////////////////////////////////
#include "AliJBaseTrack.h"
#include "AliJPhoton.h"
-#include "TF1.h"
+#include <TF1.h>
ClassImp(AliJPhoton);
//______________________________________________________________________________
fM20(-999),
fM02(-999),
fEmcCpvDist(-999),
- fNCells(0),
+ fNCells(-999),
+ fNTracksMatched(-999),
fSuperModuleId(-999),
fCellsAbsId(0x0),
- fCellsAmpFraction(0x0)
+ fCellsAmpFraction(0x0),
+ fNEMCLabel(0),
+ fEMCLabel(0x0),
+ fEMax(-999),
+ fECross(-999),
+ fECore(-999),
+ fNLM(-999),
+ fCellsIndex(0x0)
+// fCellsAmp(0x0)
{
// default constructor
fM02(a.fM02),
fEmcCpvDist(a.fEmcCpvDist),
fNCells(a.fNCells),
+ fNTracksMatched(a.fNTracksMatched),
fSuperModuleId(a.fSuperModuleId),
fCellsAbsId(NULL),
- fCellsAmpFraction(NULL)
+ fCellsAmpFraction(NULL),
+ fNEMCLabel(a.fNEMCLabel),
+ fEMCLabel(NULL),
+ fEMax(a.fEMax),
+ fECross(a.fECross),
+ fECore(a.fECore),
+ fNLM(a.fNLM),
+ fCellsIndex(NULL)
+// fCellsAmp(NULL)
{
//copy constructor
for(Int_t i=0;i<kUnknownAli+1;i++) fCaloPID[i] = a.fCaloPID[i];
SetCellsAbsId( a.fCellsAbsId );
SetCellsAmplitudeFraction( a.fCellsAmpFraction );
+ SetCellsIndex( a.fCellsIndex );
+ SetEMCLabel( a.fEMCLabel );
+// SetCellsAmplitude( a.fCellsAmp );
+}
+
+
+//_____________________________________________________________________________
+AliJPhoton::~AliJPhoton(){
+ // destructor
+ Clear("");
+}
+
+//_____________________________________________________________________________
+void AliJPhoton::Clear( Option_t * /* option */ ){
+ // cleaner
+ if(fCellsAbsId) delete [] fCellsAbsId;
+ if(fCellsAmpFraction) delete [] fCellsAmpFraction;
+ if( fEMCLabel ) delete [] fEMCLabel;
+ if( fCellsIndex ) delete [] fCellsIndex;
+ fCellsAbsId = 0;
+ fCellsAmpFraction = 0;
+ fEMCLabel = 0;
+ fCellsIndex = 0;
+// if(fCellsAmp) delete [] fCellsAmp;
}
//_____________________________________________________________________________
fM02 = photon.fM02;
fEmcCpvDist = photon.fEmcCpvDist;
fNCells = photon.fNCells;
+ fNTracksMatched = photon.fNTracksMatched;
fSuperModuleId = photon.fSuperModuleId;
SetCellsAbsId( photon.fCellsAbsId );
SetCellsAmplitudeFraction( photon.fCellsAmpFraction );
+ SetEMCLabel( photon.fEMCLabel );
+// SetCellsAmplitude( photon.fCellsAmp );
+ fEMax = photon.fEMax;
+ fECross = photon.fECross;
+ fECore = photon.fECore;
+ fNLM = photon.fNLM;
+ SetCellsIndex( photon.fCellsIndex );
}
// Set the array of cell absId numbers
if (fNCells) {
if(fCellsAbsId){ delete [] fCellsAbsId; fCellsAbsId = NULL; }
- fCellsAbsId = new UShort_t[fNCells];
- for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
+ fCellsAbsId = new UShort_t[fNCells];
+ for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
}
}
{
// Set the array of cell amplitude fraction
if (fNCells) {
- if(fCellsAmpFraction){ delete [] fCellsAmpFraction; fCellsAmpFraction = NULL;}
- fCellsAmpFraction = new Double32_t[fNCells];
- for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
+ if(fCellsAmpFraction){ delete [] fCellsAmpFraction; fCellsAmpFraction = NULL;}
+ fCellsAmpFraction = new Double32_t[fNCells];
+ for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
+ }
+}
+
+//______________________________________________________________________________
+void AliJPhoton::SetEMCLabel(const Int_t *array)
+{
+ // Set the array of cell absId numbers
+ if (fNEMCLabel) {
+ if(fEMCLabel){ delete [] fEMCLabel; fEMCLabel = NULL; }
+ fEMCLabel = new Int_t[fNEMCLabel];
+ for (Int_t i = 0; i < fNEMCLabel; i++) fEMCLabel[i] = array[i];
+ }
+}
+
+//______________________________________________________________________________
+void AliJPhoton::SetCellsIndex(const Int_t *array)
+{
+ // Set the array of cell absId numbers
+ if( !array ){
+ if( fCellsIndex ){
+ delete [] fCellsIndex;
+ fCellsIndex = NULL;
+ }
+ }
+ else if (fNCells) {
+ if( fCellsIndex ){
+ delete [] fCellsIndex;
+ fCellsIndex = NULL;
}
+
+ fCellsIndex = new Int_t[fNCells];
+ for (Int_t i = 0; i < fNCells; i++)
+ fCellsIndex[i] = array[i];
+ }
}
//______________________________________________________________________________
-void AliJPhoton::SetPID(const Double_t *pid) {
+void AliJPhoton::SetCellIndex(const Int_t pos, const Int_t ind)
+{
+ // Set the array of cell absId numbers
+
+ Int_t i;
+ if (fNCells) {
+ if( ! fCellsIndex ){
+ fCellsIndex = new Int_t[fNCells];
+ for( i = 0; i < fNCells; i++ )
+ fCellsIndex[i] = -1;
+ }
+ }
+
+ fCellsIndex[pos] = ind;
+}
+
+//______________________________________________________________________________
+void AliJPhoton::ClearCellsIndex()
+{
+ // Clears the array of cell absId numbers
+ if(fCellsIndex){
+ delete [] fCellsIndex;
+ fCellsIndex = NULL;
+ }
+}
+
+// //_______________________________________________________________________
+// void AliJPhoton::SetCellsAmplitude(const Double32_t *array)
+// {
+// // Set the array of cell amplitude fraction
+// if (fNCells) {
+// if(fCellsAmp){ delete [] fCellsAmp; fCellsAmp = NULL;}
+// fCellsAmp = new Double_t[fNCells];
+// for (Int_t i = 0; i < fNCells; i++) fCellsAmp[i] = array[i];
+// }
+// }
+
+//______________________________________________________________________________
+void AliJPhoton::SetPID(const Double32_t *pid) {
//set pid
if(pid){
- for(Int_t i=0; i<kUnknownAli+1; ++i) fCaloPID[i]=pid[i];
+ for(Int_t i=0; i<kUnknownAli; ++i) fCaloPID[i]=pid[i];
SetProbPhot(fCaloPID[kPhotonAli]);
}else{
- for(Int_t i=0; i<kUnknownAli+1; fCaloPID[i++]=0.){}
+ for(Int_t i=0; i<kUnknownAli; fCaloPID[i++]=0.){}
fCaloPID[kUnknownAli]=1.;
}
}
//______________________________________________________________________________
-AliJConst::particleType AliJPhoton::GetParticleType() {
+particleType AliJPhoton::GetParticleType() {
// return the most problable particle type
// Note: following the AliCaloPID implementation
}
- AliJConst::particleType pdg = AliJConst::kHadron;
+ particleType pdg = kHadron;
//Select most probable ID
if(fCaloType == kPHOSCalo){
- if(fCaloPID[kPhotonAli] > wPhoton) pdg = AliJConst::kPhoton ;
- else if(fCaloPID[kPi0Ali] > wPi0) pdg = AliJConst::kPizero ;
+ if(fCaloPID[kPhotonAli] > wPhoton) pdg = kPhoton ;
+ else if(fCaloPID[kPi0Ali] > wPi0) pdg = kPizero ;
//else if(fCaloPID[kElectronAli] > wElectron) pdg = electron ;
//else if(fCaloPID[kEleConAli] > wElectron) pdg = electronCon ;
//else if(chargedHadronWeight > wCharged) pdg = chargedHadron ;
}
else{//EMCAL
//Temporal solution, electrons and photons not differenciated
- if(fCaloPID[kPhotonAli] + fCaloPID[kElectronAli] > wPhoton) pdg = AliJConst::kPhoton ;
- else if(fCaloPID[kPi0Ali] > wPi0) pdg = AliJConst::kPizero ;
+ if(fCaloPID[kPhotonAli] + fCaloPID[kElectronAli] > wPhoton) pdg = kPhoton ;
+ else if(fCaloPID[kPi0Ali] > wPi0) pdg = kPizero ;
//else if(chargedHadronWeight + neutralHadronWeight > wCharged) pdg = chargedHadron ;
//else if(neutralHadronWeight + chargedHadronWeight > wNeutral) pdg = neutralHadron ;
//else pdg = neutralUnknown ;
+/* 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: AliJPhoton.h,v 1.5 2008/05/08 15:19:52 djkim Exp $
////////////////////////////////////////////////////
public:
enum AliJCaloType {
kUndef = -1,
- kPHOSCalo,
- kEMCALCalo
+ kPHOSCalo,
+ kEMCALCalo
};
enum AliJCaloPID{
kPionAli = 2,
kKaonAli = 3,
kProtonAli = 4,
- kPhotonAli = 5,
- kPi0Ali = 6,
- kNeutronAli = 7,
- kKaon0Ali = 8,
- kEleConAli = 9,
- kUnknownAli = 10
+ kDeuteronAli = 5,
+ kTritonAli = 6,
+ kHe3Ali = 7,
+ kAlpha = 8,
+ kPhotonAli = 9,
+ kPi0Ali = 10,
+ kNeutronAli = 11,
+ kKaon0Ali = 12,
+ kEleConAli = 13,
+ kUnknownAli = 14
};
+ enum { kIsConversion=AliJBaseTrack::kNFlag, kNFlag };
- AliJPhoton(); //default constructor
+ AliJPhoton(); //default constructor
AliJPhoton(const AliJPhoton& a); //copy constructor
- virtual ~AliJPhoton(){ //destructor
- if(fCellsAbsId) delete [] fCellsAbsId;
- if(fCellsAmpFraction) delete [] fCellsAmpFraction;
- }
+ virtual ~AliJPhoton(); //destructor
+
+ void Clear( Option_t * /* option */ ); // cleaner
- float GetChi2() const {return fChi2;}
- float GetTof() const {return fTof;}
- float GetX() const {return fX;}
- float GetY() const {return fY;}
- float GetZ() const {return fZ;}
- float GetProbPhot() const {return fProbPhot;}
+ Double32_t GetChi2() const {return fChi2;}
+ Double32_t GetTof() const {return fTof;}
+ Double32_t GetX() const {return fX;}
+ Double32_t GetY() const {return fY;}
+ Double32_t GetZ() const {return fZ;}
+ Double32_t GetProbPhot() const {return fProbPhot;}
- void SetChi2(float chi2) {fChi2=chi2;}
- void SetTof(float tof) {fTof=tof;}
- void SetPositionX(float x) {fX=x;}
- void SetPositionY(float y) {fY=y;}
- void SetPositionZ(float z) {fZ=z;}
- void SetProbPhot(float prob) {fProbPhot=prob;}
+ void SetChi2(Double32_t chi2) {fChi2=chi2;}
+ void SetTof(Double32_t tof) {fTof=tof;}
+ void SetPositionX(Double32_t x) {fX=x;}
+ void SetPositionY(Double32_t y) {fY=y;}
+ void SetPositionZ(Double32_t z) {fZ=z;}
+ void SetProbPhot(Double32_t prob) {fProbPhot=prob;}
AliJPhoton& operator=(const AliJPhoton& photon);
//TODO
- Bool_t InPHOS() const {return fCaloType==kPHOSCalo ? kTRUE:kFALSE ;}
- Bool_t InEMCAL() const {return fCaloType==kEMCALCalo ? kTRUE:kFALSE ;}
+ Bool_t IsPHOS() const {return fCaloType==kPHOSCalo ? kTRUE:kFALSE ;}
+ Bool_t IsEMCAL() const {return fCaloType==kEMCALCalo ? kTRUE:kFALSE ;}
// getters
void GetPID(Double_t *pid) const {
for(Int_t i=0; i<kUnknownAli+1; ++i) pid[i]=fCaloPID[i];
}
- Double_t GetDistToBadChannel() const {return fDistToBadChannel;}
- Double_t GetDispersion() const {return fDispersion;}
- Double_t GetM20() const {return fM20;}
- Double_t GetM02() const {return fM02;}
- Double_t GetEmcCpvDist() const {return fEmcCpvDist;}
- Double_t GetNCells() const { return fNCells;}
+ Double32_t GetDistToBadChannel() const {return fDistToBadChannel;}
+ Double32_t GetDispersion() const {return fDispersion;}
+ Double32_t GetM20() const {return fM20;}
+ Double32_t GetM02() const {return fM02;}
+ Double32_t GetEmcCpvDist() const {return fEmcCpvDist;}
+ Int_t GetNCells() const { return fNCells;}
+ Int_t GetNTracksMatched() const { return fNTracksMatched;}
UShort_t *GetCellsAbsId() const {return fCellsAbsId;}
- Int_t GetCellAbsId(Int_t i) const {
+ UShort_t GetCellAbsId(Int_t i) const {
if (fCellsAbsId && i >=0 && i < fNCells ) return fCellsAbsId[i];
else return -1;}
Double32_t *GetCellsAmplitudeFraction() const {return fCellsAmpFraction;}
- Double_t GetCellAmplitudeFraction(Int_t i) const {
+ Double32_t GetCellAmplitudeFraction(Int_t i) const {
if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i];
else return -1;}
- AliJConst::particleType GetParticleType();
+ Int_t GetNEMCLabel() const {return fNEMCLabel;}
+ Int_t GetEMCLabel( Int_t pos = 0 ) const {
+ if( fEMCLabel && pos >= 0 && pos < fNEMCLabel ) return fEMCLabel[pos];
+ else return -1;}
+// Double32_t *GetCellsAmplitude() const {return fCellsAmp;}
+// Double32_t GetCellAmplitude(Int_t i) const {
+// if (fCellsAmp && i >=0 && i < fNCells ) return fCellsAmp[i];
+// else return -1;}
+ particleType GetParticleType();
Int_t GetSuperModuleID() const { return fSuperModuleId; }
void SetSuperModuleID(Int_t id) { fSuperModuleId = id; }
Double32_t GetTrackDx() const {return fTrackDx;}
Double32_t GetTrackDz() const {return fTrackDz;}
+ Double32_t GetEMax() const {return fEMax;}
+ Double32_t GetECross() const {return fECross;}
+ Double32_t GetECore() const {return fECore;}
+ Int_t GetNLM() const {return fNLM;}
+ Int_t *GetCellsIndex() const {return fCellsIndex; }
+ Int_t GetCellIndex(Int_t i) const {
+ if (fCellsIndex && i >=0 && i < fNCells ) return fCellsIndex[i];
+ else return -1;}
//setters
void SetCaloType(AliJCaloType calo) {fCaloType = calo;}
- void SetDistToBadChannel(Double_t dist) {fDistToBadChannel = dist;}
- void SetDispersion(Double_t disp) {fDispersion = disp;}
- void SetM20(Double_t m20) {fM20 = m20;}
- void SetM02(Double_t m02) {fM02 = m02;}
- void SetEmcCpvDist(Double_t dist) {fEmcCpvDist = dist;}
- void SetPID(const Double_t *pid);
+ void SetDistToBadChannel(Double32_t dist) {fDistToBadChannel = dist;}
+ void SetDispersion(Double32_t disp) {fDispersion = disp;}
+ void SetM20(Double32_t m20) {fM20 = m20;}
+ void SetM02(Double32_t m02) {fM02 = m02;}
+ void SetEmcCpvDist(Double32_t dist) {fEmcCpvDist = dist;}
+ void SetPID(const Double32_t *pid);
void SetNCells(Int_t n) { fNCells = n;}
+ void SetNTracksMatched( Int_t n ) { fNTracksMatched = n;}
void SetCellsAbsId(const UShort_t *array);
void SetCellsAmplitudeFraction(const Double32_t *array);
- void SetTrackDx(Double_t trackDx) {fTrackDx = trackDx;}
- void SetTrackDz(Double_t trackDz) {fTrackDz = trackDz;}
+ void SetNEMCLabel(Int_t n) { fNEMCLabel = n;}
+ void SetEMCLabel(const Int_t *array);
+ void SetEMCLabel(const Int_t pos, const Int_t lab) {
+ if( fEMCLabel && pos >= 0 && pos < fNEMCLabel )
+ fEMCLabel[pos] = lab; }
+// void SetCellsAmplitude(const Double32_t *array);
+ void SetTrackDx(Double32_t trackDx) {fTrackDx = trackDx;}
+ void SetTrackDz(Double32_t trackDz) {fTrackDz = trackDz;}
+ void SetEMax(Double32_t e) {fEMax = e; }
+ void SetECross(Double32_t e) {fECross = e; }
+ void SetECore(Double32_t e) {fECore = e; }
+ void SetNLM( Int_t n ) {fNLM = n;}
+ void SetCellIndex( const Int_t pos, const Int_t ind );
+ void SetCellsIndex(const Int_t *array);
+
+ void ClearCellsIndex();
private:
//TODO
AliJCaloType fCaloType; // PHOS or EMCAL photon
- Double_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object
- Double_t fDistToBadChannel; // Distance to nearest bad channel
- Double_t fDispersion; // cluster dispersion, for shape analysis
- Double_t fM20; // 2-nd moment along the main eigen axis
- Double_t fM02; // 2-nd moment along the second eigen axis
- Double_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point
+ Double32_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object
+ Double32_t fDistToBadChannel; // Distance to nearest bad channel
+ Double32_t fDispersion; // cluster dispersion, for shape analysis
+ Double32_t fM20; // 2-nd moment along the main eigen axis
+ Double32_t fM02; // 2-nd moment along the second eigen axis
+ Double32_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point
Int_t fNCells ; //number of cells
+ Int_t fNTracksMatched; // number of tracks matched
Int_t fSuperModuleId ; //super module id
UShort_t *fCellsAbsId; //[fNCells] array of cell absId numbers
- Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction.
-
- ClassDef(AliJPhoton,1)
+ Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction (elements are 0 if unfolding off)
+// Double32_t *fCellsAmp; //[fNCells] array amplitudes of cluster cellsz
+ Int_t fNEMCLabel; // number of MC labels
+ Int_t *fEMCLabel; //[fNEMCLabel] MC labels
+
+ // analysis time variables
+ Double32_t fEMax; //! maximum cell energy
+ Double32_t fECross; //! energy of cells in cross around max
+ Double32_t fECore; //! central cells energies
+ Int_t fNLM; //! number of local maxima
+ Int_t *fCellsIndex; //! cell indices in cell list
+
+ ClassDef(AliJPhoton,2)
};
--- /dev/null
+/**************************************************************************
+ * 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: AliJPiZero.cxx,v 1.3 2008/05/08 13:44:45 djkim Exp $
+
+////////////////////////////////////////////////////
+/*!
+ \file AliJPiZero.cxx
+ \brief
+ \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla)
+ \email: djkim@jyu.fi
+ \version $Revision: 1.3 $
+ \date $Date: 2008/05/08 13:44:45 $
+*/
+////////////////////////////////////////////////////
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <TVector3.h>
+#include <TLorentzVector.h>
+
+#include "AliJBaseTrack.h"
+#include "AliJPhoton.h"
+
+#include "AliJPiZero.h"
+
+
+
+AliJPiZero::AliJPiZero():
+ AliJBaseTrack(),
+ fAsymm(-999),
+ fMassBin(-999),
+ fIsGood(kFALSE),
+ fConvPlaneDelta(-999),
+ fPtBin(-1)
+{
+ //constructor
+ fPhoton[0] = 0;
+ fPhoton[1] = 0;
+}
+//______________________________________________________________________________
+AliJPiZero::AliJPiZero(const AliJPiZero& a):
+ AliJBaseTrack(a),
+ fAsymm(a.fAsymm),
+ fMassBin(a.fMassBin),
+ fIsGood(a.fIsGood),
+ fConvPlaneDelta(a.fConvPlaneDelta),
+ fPtBin(a.fPtBin)
+{
+ //copy constructor
+ fPhoton[0] = a.fPhoton[0];
+ fPhoton[1] = a.fPhoton[1];
+}
+
+AliJPiZero& AliJPiZero::operator=(const AliJPiZero& pizero){
+ //copy constructor
+ AliJBaseTrack::operator=(pizero);
+ fAsymm = pizero.fAsymm;
+ fMassBin = pizero.fMassBin;
+ fIsGood = pizero.fIsGood;
+ fPhoton[0] = pizero.fPhoton[0];
+ fPhoton[1] = pizero.fPhoton[1];
+ fConvPlaneDelta = pizero.fConvPlaneDelta;
+ fPtBin = pizero.fPtBin;
+
+ return *this;
+}
+
+
+//______________________________________________________________________________
+
+bool AliJPiZero::SetMass(AliJPhoton *g1, AliJPhoton *g2){
+ //set pi0 four-momentum, assddymetry, inv. mass, pT, phi, theta, energy
+
+ fAsymm = TMath::Abs((g1->E()-g2->E())/(g1->E()+g2->E()));
+ *(TLorentzVector*)this = *(TLorentzVector*)g1 + *(TLorentzVector*)g2;
+
+ fPhoton[0] = g1;
+ fPhoton[1] = g2;
+
+// Double_t pimass;
+// pimass = TMath::Sqrt( 2. * g1->E() * g2->E() *
+// ( 1. - TMath::Cos( g1->Angle( g2->Vect() ))));
+
+ return true;
+}
+
+double AliJPiZero::DeltaConversion(){
+ // check pair plane vector delta from expected conversion pair plain
+
+ TVector3 pplain, phot1, phot2, pplaint, cplain, zplain, convplane;
+
+ // pair vector in the pair plane
+ pplain = Vect();
+// cout << "-------------------" << endl;
+// pplain.Print();
+
+ // perpendicular to the plane
+ phot1 = fPhoton[0]->Vect();
+ phot2 = fPhoton[1]->Vect();
+ pplaint = phot1.Cross( phot2 );
+// pplaint.Print();
+
+ // get the pair plane vector
+ cplain = pplain.Cross( pplaint ).Unit();
+// cplain.Print();
+
+ // z plane vector
+ zplain.SetXYZ( 0, 0, 1 );
+// zplain.Print();
+
+ // expected conversion plane vector
+ convplane = pplain.Cross( zplain ).Unit();
+// convplane.Print();
+
+ // get the plane vector cosine similarity
+ // both vectors must be unit for this to work
+ fConvPlaneDelta = TMath::Abs( TMath::ACos( cplain.Dot( convplane )));
+// cout << fConvPlaneDelta << endl;
+
+ // the result comes out in 0,pi range. Depending on how the z plane vector
+ // was chosen (2 options). Merge the results into 0,1/2pi range
+ if( fConvPlaneDelta > TMath::Pi() / 2. )
+ fConvPlaneDelta = TMath::Pi() - fConvPlaneDelta;
+
+ return fConvPlaneDelta;
+}
+
+
+
+//______________________________________________________________________________
+
+// double AliJPiZero::operator- (const AliJPiZero &pi0){
+//
+// //========================================
+// // retruns the closest distance between
+// // photon hits bolonging to two pi0
+// //========================================
+//
+// TLorentzVector v;
+// double d = 1e3;
+// v = fPhoton1 - pi0.fPhoton1;
+// if(v.M() < d) d = v.M();
+// v = fPhoton2 - pi0.fPhoton2;
+// if(v.M() < d) d = v.M();
+// v = fPhoton1 - pi0.fPhoton2;
+// if(v.M() < d) d = v.M();
+// v = fPhoton2 - pi0.fPhoton2;
+// if(v.M() < d) d = v.M();
+// return d;
+// }
+//
+// //______________________________________________________________________________
+// AliJPiZero& AliJPiZero::operator= (const AliJPiZero& piz){
+// //operator=
+// if(this != &piz){
+// AliJBaseTrack::operator=(piz);
+// fPhoton1 = piz.fPhoton1;
+// fPhoton2 = piz.fPhoton2;
+// PhotSum = fPhoton1 + fPhoton2;
+// fAsymm = piz.fAsymm;
+// fMassBin = piz.fMassBin;
+// }
+//
+// return *this;
+// }
+
+
+
+ClassImp(AliJPiZero)
--- /dev/null
+/* 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: AliJPiZero.h,v 1.4 2008/05/08 15:19:52 djkim Exp $
+
+////////////////////////////////////////////////////
+/*!
+ \file AliJPiZero.h
+ \brief
+ \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla)
+ \email: djkim@jyu.fi
+ \version $Revision: 1.4 $
+ \date $Date: 2008/05/08 15:19:52 $
+ */
+////////////////////////////////////////////////////
+
+#ifndef ALIJPIZERO_H
+#define ALIJPIZERO_H
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+#include <TVector3.h>
+#include <TLorentzVector.h>
+
+class AliJBaseTrack;
+class AliJPhoton;
+// #include "AliJBaseTrack.h"
+// #include "AliJPhoton.h"
+
+//class AliJPhoton;
+//class TObject;
+
+class AliJPiZero : public AliJBaseTrack {
+
+ public:
+ AliJPiZero();
+ virtual ~AliJPiZero(){;} //destructor
+ AliJPiZero(const AliJPiZero& a);//{PhotSum.SetPxPyPzE(0,0,0,0);} //constructor
+ AliJPiZero& operator=(const AliJPiZero& pizero);
+
+ bool SetMass(AliJPhoton* g1, AliJPhoton* g2);
+
+ float GetInvMass() const {return M();}
+ float GetAsymm() const {return fAsymm;}
+
+ int GetMassBin() const {return fMassBin;}
+ void SetMassBin(int im) {fMassBin=im;}
+ void ResetToZero() {SetPxPyPzE(0, 0, 0, 0);fAsymm=0; fMassBin=-1; fIsGood=kFALSE; fConvPlaneDelta=-999; fPtBin=-1;}
+ AliJPhoton *GetPhoton( Int_t i ) const { return fPhoton[i]; }
+ void SetGood( Bool_t b ) { fIsGood = b;}
+ Bool_t GetGood() const { return fIsGood; }
+ void SetConvPlaneDelta( Double_t d ) {fConvPlaneDelta = d; }
+ Double_t GetConvPlaneDelta() const { return fConvPlaneDelta; }
+ void SetPtBin( Int_t b ) { fPtBin = b; }
+ Int_t GetPtBin() const { return fPtBin; }
+
+ Double_t Theta() { return fPhoton[0]->Angle( fPhoton[1]->Vect() ); }
+ Double_t DPhi() { return TMath::Abs( fPhoton[0]->Phi() - fPhoton[1]->Phi() ); }
+ Double_t DZ() { return TMath::Abs( fPhoton[0]->GetZ() - fPhoton[1]->GetZ() ); }
+
+ TVector3 GetP() const {return Vect();}
+ TLorentzVector GetSum() const {return *(TLorentzVector*)this;}
+
+ double DeltaConversion();
+
+// double operator- (const AliJPiZero &pi0);
+// AliJPiZero& operator= (const AliJPiZero& piz);
+
+ protected:
+ float fAsymm; //assymtery and inv. mass
+ int fMassBin; //mass bin
+ Bool_t fIsGood; //!
+ AliJPhoton *fPhoton[2]; //!
+ Double_t fConvPlaneDelta; //! plane delta form conversion plane
+ Int_t fPtBin; //! pt bin
+
+ ClassDef(AliJPiZero,1)
+};
+
+#endif
+
/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * 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 notifce *
+ * 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: AliJRunHeader.cxx,v 1.1 2008/02/04 13:28:47 rak Exp $
////////////////////////////////////////////////////
//
-// \file AliJRunHeader.cxx
-// \brief
-// \author J. Rak, D.J.Kim, F.Krizek(University of Jyvaskyla)
-// \email: djkim@cc.jyu.fi
-// \version $Revision: 1.1 $
-// \date $Date: 2008/02/04 13:28:47 $
+// \file AliJRunHeader.cxx
+// \brief
+// \author J. Rak, D.J.Kim, F.Krizek(University of Jyvaskyla)
+// \email: djkim@cc.jyu.fi
+// \version $Revision: 1.1 $
+// \date $Date: 2008/02/04 13:28:47 $
//
// Class encapsulation aliroot run header information
////////////////////////////////////////////////////
//----------------------------
AliJRunHeader::AliJRunHeader():
- TNamed("AliJRunHeader", ""),
- fRunNumber(-1),
- fRunType(""),
- fESDInfo(""),
- fL3MagnetPolarity(0),
- fMagneticFieldL3(0),
- fActiveTriggersAlice(),
- fSizeOfTableJCorran(0),
-// fAliceTriggerDef(),
- fActiveTriggersJCorran(),
- fAliceTriggerDef(),
- fAliceFilterMapDef()
+TNamed("AliJRunHeader", ""),
+//==== General Info ====//
+fRunNumber(0),
+fRunType(""),
+fBeamType(""),
+fBeamTypeI(-1),
+fBeamEnergy(0),
+fIsMC(kFALSE),
+//==== Production Info ====//
+fInputFormat(-1),
+fWithoutSDD(kFALSE),
+fStoreEventPlaneSource(kFALSE),
+fStoreEMCalInfo(kFALSE),
+fStoreTPCTrackBitMask(0),
+fStoreGCGTrackBitMask(0),
+fESDInfo(""),
+fRefitESDVertexTracks(false),
+//==== Detector Status ====//
+fL3MagnetPolarity(0),
+fMagneticFieldL3(0),
+fCurrentL3(0),
+fCurrentDip(0),
+fUniformBMap(kFALSE),
+//==== Trigger Information ====//
+fFiredTriggers(0),
+fTriggerMask(0),
+fTriggerCluster(0),
+fSizeOfTableJCorran(0),
+fActiveTriggersJCorran(kRangeTriggerTableJCorran,""),
+fActiveTriggersAlice(kRangeTriggerTableAlice,"")
{ //constructor
-
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableAlice;i++){
- fActiveTriggersAlice.Add(new TObjString("EMPTY"));
- fActiveTriggersJCorran.Add(new TObjString("EMPTY"));
- }
-
- fActiveTriggersAlice.SetOwner(kTRUE);
- fActiveTriggersJCorran.SetOwner(kTRUE);
-
- SetName("AliRunHeader");
- SetTitle("AliRunHeader");
-
-}
-//________________________________________________________________________
-
-AliJRunHeader::AliJRunHeader(const AliJRunHeader& ap):
- TNamed(ap),
- fRunNumber(ap.fRunNumber),
- fRunType(ap.fRunType),
- fESDInfo(ap.fESDInfo),
- fL3MagnetPolarity(ap.fL3MagnetPolarity),
- fMagneticFieldL3(ap.fMagneticFieldL3),
- fActiveTriggersAlice(ap.fActiveTriggersAlice),
- fSizeOfTableJCorran(ap.fSizeOfTableJCorran),
-// fAliceTriggerDef(ap.fAliceTriggerDef),
- fActiveTriggersJCorran(ap.fActiveTriggersJCorran),
- fAliceTriggerDef(ap.fAliceTriggerDef),
- fAliceFilterMapDef(ap.fAliceFilterMapDef)
-{
- //cpy ctor
-}
-//________________________________________________________________________
-
-void AliJRunHeader::SetActiveTriggersAlice(const TString *triggers){
- // fill aliroot trigger table
- for(Int_t t=0;t<AliJConst::kRangeTriggerTableAlice;t++){
- ((TObjString*) (fActiveTriggersAlice.At(t)))->SetString(triggers[t].Data());
- }
-
- fActiveTriggersAlice.SetOwner(kTRUE);
-}
-//________________________________________________________________________
-
-void AliJRunHeader::SetActiveTriggersJCorran(const TString *triggers, Int_t range){
- //fill jcorran trigger table
- for(Int_t t=0;t<range;t++){
- ((TObjString*) (fActiveTriggersJCorran.At(t)))->SetString(triggers[t].Data());
- }
- fActiveTriggersJCorran.SetOwner(kTRUE);
- fSizeOfTableJCorran = range;
}
-//________________________________________________________________________
Int_t AliJRunHeader::GetActiveTriggerBitAlice(TString TriggerName){
//get trigger bit corresponding to trigger name
- Int_t tbit=-1;
- for(Int_t t=0;t<AliJConst::kRangeTriggerTableAlice;t++){
- if(TriggerName.Contains(((TObjString*)(fActiveTriggersAlice.At(t)))->GetString())){
- tbit = t;
- break;
+ for(UInt_t t=0;t<GetActiveTriggersAlice().size();t++){
+ if(TriggerName.Contains( GetActiveTriggersAlice(t) )){ // TODO : not equal?
+ return t;
}
}
- return tbit;
+ return -1;
}
+
//________________________________________________________________________
void AliJRunHeader::PrintOut(){
//print object
- std::cout<<"RUN "<<fRunNumber<<std::endl;
+ std::cout<<"RUN = "<<fRunNumber<<std::endl;
+ std::cout<<"RunType = "<<fRunType<<std::endl;
+ std::cout<<"BeamType = "<<fBeamType<<" => "<<fBeamTypeI<<std::endl;
+ std::cout<<"BeamEnergy = "<<fBeamEnergy<<std::endl;
+ std::cout<<"IsMC = "<<fIsMC<<std::endl;
+ std::cout<<"ImputFormat = "<<fInputFormat<<std::endl;
std::cout<<"Alice trigger table:"<<std::endl;
- for(Int_t i=0;i<AliJConst::kRangeTriggerTableAlice;i++){
- std::cout<<i<<" "<<GetActiveTriggerAlice(i)<<std::endl;
+ for(Int_t i=0;i<kRangeTriggerTableAlice;i++){
+ std::cout<<i<<" "<<GetActiveTriggersAlice(i)<<std::endl;
}
std::cout<<"============================="<<std::endl;
std::cout<<"JCorran trigger table:"<<std::endl;
- for(Int_t i=0;i<fSizeOfTableJCorran;i++){
- std::cout<<i<<" "<<GetActiveTriggerJCorran(i)<<std::endl;
+ for(Int_t i=0;i<kRangeTriggerTableJCorran;i++){
+ std::cout<<i<<" "<<GetActiveTriggersJCorran(i)<<std::endl;
}
std::cout<<"============================="<<std::endl;
std::cout<<"Magnet polarity "<<fL3MagnetPolarity<<std::endl;
std::cout<<"============================="<<std::endl;
}
-//_______________________________________________________________________
-AliJRunHeader& AliJRunHeader::operator=(const AliJRunHeader& header){
- //operator =
- if(this != &header) {
- TNamed::operator=(header);
- fRunNumber = header.fRunNumber;
- fRunType = header.fRunType;
- fESDInfo = header.fESDInfo;
- fL3MagnetPolarity = header.fL3MagnetPolarity;
- fMagneticFieldL3 = header.fMagneticFieldL3;
- fActiveTriggersAlice = header.fActiveTriggersAlice;
- fSizeOfTableJCorran = header.fSizeOfTableJCorran;
- fActiveTriggersJCorran = header.fActiveTriggersJCorran;
- fAliceTriggerDef = header.fAliceTriggerDef;
- fAliceFilterMapDef = header.fAliceFilterMapDef;
- }
- return *this;
-}
-
-
+/* 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: AliJRunHeader.h,v 1.1 2008/02/04 13:28:47 rak Exp $
////////////////////////////////////////////////////
/*!
//#pragma link C++ class AliJRunHeader+;
public:
+ enum { kJPP, kJPbPb, kPPb };
+ enum { kJESD, kJAOD };
AliJRunHeader();//constructor
- AliJRunHeader(const AliJRunHeader& ap);
+ ~AliJRunHeader(){;} //destructor
+
+ //==== General Information ====//
+ Int_t GetRunNumber() const {return fRunNumber;}
+ void SetRunNumber(Int_t runN) { fRunNumber = runN;}
+
+ TString GetRunType() const { return fRunType;}
+ void SetRunType( const TString type ){ fRunType = type; }
+
+ TString GetBeamType()const{ return fBeamType; }
+ void SetBeamType(TString t){ fBeamType = t; }
+
+ Int_t GetBeamTypeI()const{ return fBeamTypeI; }
+ void SetBeamTypeI(int t){ fBeamTypeI = t; }
+
+ Bool_t IsPP() const { return fBeamTypeI==kJPP; }
+ Bool_t IsPbPb() const { return fBeamTypeI==kJPbPb; }
- virtual ~AliJRunHeader(){;} //destructor
+ Float_t GetBeamEnergy() const { return fBeamEnergy; }
+ void SetBeamEnergy( Float_t e ){ fBeamEnergy = e; }
- virtual Int_t GetRunNumber() const {return fRunNumber;}
- virtual void SetRunNumber(Int_t runN) { fRunNumber = runN;}
+ Bool_t IsMC()const{ return fIsMC; }
+ void SetIsMC(Bool_t b){ fIsMC=b; }
- void SetRunType(const TString info ) { fRunType = info; }
- TString GetRunType() const { return fRunType; }
+ //==== Production Info ====//
+ Int_t GetInputFormat() const { return fInputFormat; }
+ void SetInputFormat( Int_t v ){ fInputFormat = v; }
+ Bool_t FromESD() const { return fInputFormat==kJESD; }
+ Bool_t FromAOD() const { return fInputFormat==kJAOD; }
- void SetESDInfo(const TString info ) { fESDInfo = info; }
+ Bool_t GetWithoutSDD()const{ return fWithoutSDD; }
+ void SetWithoutSDD( bool b ){ fWithoutSDD = b; }
+
+ void SetStoreEventPlaneSource(Bool_t dostore ){ fStoreEventPlaneSource = dostore; }
+ Bool_t GetStoreEventPlaneSource() const { return fStoreEventPlaneSource; };
+
+ void SetStoreEMCalInfo(Bool_t dostore ){ fStoreEMCalInfo = dostore; }
+ Bool_t GetStoreEMCalInfo() const { return fStoreEMCalInfo; };
+
+ UInt_t GetStoreTPCTrackBitMask()const{ return fStoreTPCTrackBitMask; }
+ void SetStoreTPCTrackBitMask( UInt_t mask ){ fStoreTPCTrackBitMask = mask; }
+
+ UInt_t GetStoreGCGTrackBitMask()const{ return fStoreGCGTrackBitMask; }
+ void SetStoreGCGTrackBitMask( UInt_t mask ){ fStoreGCGTrackBitMask = mask; }
+
+ void SetESDInfo(const TString info ) { fESDInfo = info; }
TString GetESDInfo() const { return fESDInfo; }
-// void SetESDInfo(const char* info ) { fESDInfo = info; }
-// char* GetESDInfo() const { return fESDInfo; }
-
- // s e t t e r s a n d g e t t e r s
- void SetL3Field(Short_t polarity,Double_t MagnetFieldInL3){
- fL3MagnetPolarity = polarity;
- fMagneticFieldL3 = MagnetFieldInL3;
- }
-
- Short_t GetL3MagnetFieldPolarity() const { return fL3MagnetPolarity;}
- Double_t GetL3MagnetFieldIntensity() const { return fMagneticFieldL3;}
-
- //--- Alice event trigger definition by BS like "kMB", "kHighMulti"
- const std::map<TString, ULong64_t>& GetAliceTriggerDef() const { return fAliceTriggerDef; }
- ULong64_t GetAliceTriggerDef( const TString name ) const { return GetBitMaskDef( fAliceTriggerDef, name); }
- void AddAliceTriggerDef( const TString name, const ULong64_t mask){ fAliceTriggerDef[name]=mask; }
- void RemoveAliceTriggerDef( const TString name){ fAliceTriggerDef.erase(name); }
-
- //--- Alice track FilterMap by BS like "kEsdTrackCutsL"
- const std::map<TString, ULong64_t>& GetAliceFilterMapDef() const { return fAliceFilterMapDef; }
- ULong64_t GetAliceFilterMapDef( const TString name ) const { return GetBitMaskDef( fAliceFilterMapDef, name); }
- void AddAliceFilterMapDef( const TString name, const ULong64_t mask){ fAliceFilterMapDef[name]=mask; }
- void RemoveAliceFilterMapDef( const TString name){ fAliceFilterMapDef.erase(name); }
-
- //--- Common Method to handle BitMask Definition ( map<TString, ULong64_t> )
- ULong64_t GetBitMaskDef( std::map<TString, ULong64_t> def, const TString name ) const{
- std::map<TString, ULong64_t>::iterator _iter = def.find(name);
- //iter = def.find(name);
- if( _iter == def.end() ){ return 0; }
- else{ return _iter->second; }
- }
-
- //-- Alice trigger table -- by Filip. "Trigger Class" like "+CMBACS2-B-NOPF-ALL"
- void SetActiveTriggersAlice( const TString *triggers);
- Int_t GetActiveTriggerBitAlice(TString TriggerName);
- TString GetActiveTriggerAlice(Int_t TriggerBit) const {
- return ((TObjString*) (fActiveTriggersAlice.At(TriggerBit)))->GetString();
- }
-
- //-- JCorran trigger table -- by Filip
- void SetActiveTriggersJCorran(const TString *triggers, Int_t range);
- TString GetActiveTriggerJCorran(Int_t TriggerBit) const {
- return ((TObjString*) (fActiveTriggersJCorran.At(TriggerBit)))->GetString();
- }
-
- AliJRunHeader& operator=(const AliJRunHeader& header);
+ Bool_t GetRefitESDVertexTracks() const { return fRefitESDVertexTracks; }
+ void SetRefitESDVertexTracks( Bool_t refit ){ fRefitESDVertexTracks=refit; }
+
+ //==== Detector Status ====//
+ Short_t GetL3MagnetFieldPolarity() const { return fL3MagnetPolarity; }
+ void SetL3MagnetFieldPolarity(Short_t p){ fL3MagnetPolarity=p; }
+
+ Double_t GetL3MagnetFieldIntensity() const { return fMagneticFieldL3; }
+ void SetL3MagnetFieldIntensity(Double_t i) { fMagneticFieldL3=i; }
+
+ Float_t GetCurrentL3() const { return fCurrentL3; }
+ void SetCurrentL3(Float_t current){ fCurrentL3 = current; }
+
+ Float_t GetCurrentDip() const { return fCurrentDip; }
+ void SetCurrentDip(Float_t dip){ fCurrentDip=dip; }
+
+ Bool_t IsUniformBMap() const { return fUniformBMap; }
+ void SetUniformBMap(Bool_t uniform){ fUniformBMap=uniform; }
+
+ //==== Trigger Information ====//
+ TString GetFiredTriggers()const{ return fFiredTriggers; }
+ void SetFiredTriggers( TString trgs ){ fFiredTriggers=trgs; }
+
+ ULong64_t GetTriggerMask()const{ return fTriggerMask; }
+ void SetTriggerMask( ULong64_t mask ){ fTriggerMask=mask; }
+
+ UChar_t GetTriggerCluster() const { return fTriggerCluster; }
+ void SetTriggerCluster( UChar_t cluster ){ fTriggerCluster=cluster; }
+
+ Int_t GetSizeOfTableJCorran() const { return fSizeOfTableJCorran; }
+ void SetSizeOfTableJCorran( Int_t size ){ fSizeOfTableJCorran=size; }
+
+ std::vector<TString> GetActiveTriggersJCorran() const { return fActiveTriggersJCorran; }
+ void SetActiveTriggersJCorran( std::vector<TString> strs ){ fActiveTriggersJCorran=strs; }
+ TString GetActiveTriggersJCorran(int i) const { return fActiveTriggersJCorran[i]; }
+ void SetActiveTriggersJCorran(int i, TString str){ fActiveTriggersJCorran[i]=str; }
+
+ std::vector<TString> GetActiveTriggersAlice() const { return fActiveTriggersAlice; }
+ void SetActiveTriggersAlice( std::vector<TString> strs ){ fActiveTriggersAlice=strs; }
+ TString GetActiveTriggersAlice(int i) const { return fActiveTriggersAlice[i]; }
+ void SetActiveTriggersAlice(int i, TString str){ fActiveTriggersAlice[i]=str; }
+ Int_t GetActiveTriggerBitAlice(TString TriggerName);
+
+ //==== GENERAL STUFF for Class ====//
void PrintOut();
protected:
+ //==== General Info ====//
Int_t fRunNumber; //run number
TString fRunType; // ex) LHC10h
+ TString fBeamType; // beam type kJPP, kJPbPb, kJPPb
+ Int_t fBeamTypeI; // beam type kJPP, kJPbPb, kJPPb
+ Float_t fBeamEnergy; // beam energy
+ Bool_t fIsMC; // MC data or real data
+
+ //==== Production Info ====//
+ Int_t fInputFormat; // specify the input data format (kJESD or kJAOD)
+ Bool_t fWithoutSDD; // is SDD detector used or not
+ Bool_t fStoreEventPlaneSource; // store event plane
+ Bool_t fStoreEMCalInfo; // store event plane
+ UInt_t fStoreTPCTrackBitMask; // TPC bit mask
+ UInt_t fStoreGCGTrackBitMask; // GCG bit maks
TString fESDInfo; // information of aliroot, root version while esd production
-// Char_t* fESDInfo; // information of aliroot, root version while esd production
+ Bool_t fRefitESDVertexTracks; // refit to ESD vertex tracks
+
+ //==== Detector Status ====//
Short_t fL3MagnetPolarity; //Polarity of magnetic filed in L3 magnet (LHC convention: + -> +Bz)
Double32_t fMagneticFieldL3; //Solenoid Magnetic Field in kG
- TObjArray fActiveTriggersAlice; //array maping between trigger bit and trigger names
-
- Int_t fSizeOfTableJCorran; //size of jcorran table
-// std::map<TString,ULong64_t> fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti"
-// std::map<TString,ULong64_t> fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL"
-
- TObjArray fActiveTriggersJCorran; //array maping between trigger bit and trigger names
+ Float_t fCurrentL3; // L3 current
+ Float_t fCurrentDip; // dipole current
+ Bool_t fUniformBMap; // beam uniformity
+
+ //==== Trigger Information ====//
+ TString fFiredTriggers; // String with fired triggers
+ ULong64_t fTriggerMask; // Trigger Type (mask)
+ UChar_t fTriggerCluster; // Trigger cluster (mask)
+ Int_t fSizeOfTableJCorran; //size of jcorran table
+ std::vector<TString> fActiveTriggersJCorran; //array maping between trigger bit and trigger names
+ std::vector<TString> fActiveTriggersAlice; //array maping between trigger bit and trigger names
//TBit 0 = MB
- std::map<TString,ULong64_t> fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti"
- std::map<TString,ULong64_t> fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL"
- //std::map<TString, ULong64_t>::iterator iter;
- ClassDef(AliJRunHeader,2)
+ ClassDef(AliJRunHeader,3)
};
#endif
+
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJRunTable.h"
+
+#include <iostream>
+#include <cstdlib>
+#include <TSystem.h>
+#include <TPRegexp.h>
+using namespace std;
+
+AliJRunTable::AliJRunTable() :
+ fCPeriod(0),
+ fCRunNumber(0),
+ fCPeriodMCName("undefined")
+{
+ Init();
+}
+
+void AliJRunTable::Init(){
+ // comment needed
+ SetPeriodInformation( kUnknownPeriod, "UnknownPeriod", kPP, kRE, 0, -1, -1, "UnKnownPeriod" );
+ SetPeriodInformation( kLHC10b, "LHC10b", kPP, kRE, 7000, 114737, 117223, "LHC10d1" );
+ SetPeriodInformation( kLHC10c, "LHC10c", kPP, kRE, 7000, 118503, 121040, "LHC10d4" );
+ SetPeriodInformation( kLHC10d, "LHC10d", kPP, kRE, 7000, 122195, 126437, "LHC10f6a" );
+ SetPeriodInformation( kLHC10e, "LHC10e", kPP, kRE, 7000, 127712, 130850, "LHC10e20" );
+ SetPeriodInformation( kLHC10h, "LHC10h", kPbPb, kRE, 2760, 136851, 139517, "LHC11a10a_bis" );
+ SetPeriodInformation( kLHC11h, "LHC11h", kPbPb, kRE, 2760, 167813, 170309, "LHC12a17d_fix" );
+
+ //LHC11a
+ SetPeriodInformation(kLHC11a, "LHC11a", kPP, kRE, 2760, 144871, 146860, "LHC11b10a" );
+
+ // pp 7TeV LHC11bcde
+ SetPeriodInformation( kLHC11b, "LHC11b", kPP, kRE, 7000, 0, 0, "LHC12d2_plus" );
+ SetPeriodInformation( kLHC11c, "LHC11c", kPP, kRE, 7000, 153533, 154789, "LHC12d2_plus" );
+ SetPeriodInformation( kLHC11d, "LHC11d", kPP, kRE, 7000, 156620, 159580, "LHC12d2_plus" );
+ SetPeriodInformation( kLHC11e, "LHC11e", kPP, kRE, 7000, 0, 0, "LHC12d2_plus" );
+
+ // LHC12g - TODO
+ SetPeriodInformation( kLHC12g, "LHC12g",kPA, kRE, 5020, 188356,188503, "LHC13b2" );
+ SetPeriodInformation( kLHC12h, "LHC12h",kPA, kRE, 5020, 189122,192732, "LHC13b2" );
+ SetPeriodInformation( kLHC13b, "LHC13b",kPA, kRE, 5020, 195344,195483, "LHC13b2-efix_p1" );
+ SetPeriodInformation( kLHC13c, "LHC13c",kPA, kRE, 5020, 195529,195677, "LHC13b2-efix_p1" );
+ SetPeriodInformation( kLHC13d, "LHC13d",kPA, kRE, 5020, 195724,195872, "LHC13b2-efix_p1" );
+ SetPeriodInformation( kLHC13e, "LHC13e",kPA, kRE, 5020, 195955,196310, "LHC13b2-efix_p1" );
+ SetPeriodInformation( kLHC13g, "LHC13g",kPA, kRE, 5020, 197669,200000, "LHC13b2-efix_p1" );
+}
+
+
+TString AliJRunTable::GetPeriodName( int period ) const {
+ // TODO
+ if( period < 0 ) period = fCPeriod;
+ return fPeriodName[period];
+}
+
+int AliJRunTable::GetRunNumberToPeriod( int runnumber ){
+ // comment needed
+ int period = -1;
+ for( int ip=0;ip<kJNPeriod;ip++ ){
+ if(fDataType[ip] == kMC ) continue;
+ if( runnumber >= fRunRange[ip][0] && runnumber <= fRunRange[ip][1] ){
+ cout<< fPeriodName[ip] <<"\t"<<fRunRange[ip][0]<<"~"<<fRunRange[ip][1]<<endl;
+ period = ip;
+ break;
+ }
+ }
+ if( period < 0 ){
+ cout<<"J_ERROR : no period for runnumber "<<runnumber<<endl;
+ gSystem->Exit(1);
+ }
+ return period;
+}
+
+void AliJRunTable::SetPeriodInformation(int period, TString name, int beamtype, int datatype, int energy, int run0, int run1, TString MCPeriod){
+ // comment needed
+ fPeriodName[period] = name;
+ fBeamType[period] = beamtype;
+ fDataType[period] = datatype;
+ fEnergy[period] = energy;
+ fRunRange[period][0] = run0;
+ fRunRange[period][1] = run1;
+ fMCPeriod[period] = MCPeriod;
+}
+
+
+int AliJRunTable::GetPeriodCode( TString perstr ) const{
+ // comment needed
+ int period = kUnknownPeriod;
+ for( int ip=0;ip<kJNPeriod;ip++ ){
+ if( perstr == GetPeriodName(ip) ){
+ period = ip;
+ break;
+ }
+ }
+ if( period <0 ){
+ cout<<"J_ERROR : no period for "<<perstr<<endl;
+ }
+ return period;
+
+}
+
+int AliJRunTable::GetRunNumberFromString(const char * tstr ){
+ // comment needed
+ TPMERegexp rexRunNumber( "1\\d{5}" );
+ rexRunNumber.Match(tstr);
+ return TString(rexRunNumber[0]).Atoi();
+}
+
+TString AliJRunTable::GetPeriodFromString(const char * tstr ) const{
+ // comment needed
+ TPMERegexp rexPeriod( "LHC1\\d[a-zA-Z]" );
+ rexPeriod.Match(tstr);
+ return rexPeriod[0];
+}
+
+TString AliJRunTable::GetMCPeriodFromString(const char * tstr ) const{
+ // comment needed
+ TPMERegexp rexPeriod( "LHC1\\d[a-zA-Z0-9]{2,}(\\w+)?" );
+ rexPeriod.Match(tstr);
+ return rexPeriod[0];
+}
+
+int AliJRunTable::GetPeriodFromMCPeriod( const char * tstr ){
+ // comment needed
+ int period = -1;
+ for( int ip=0;ip<kJNPeriod;ip++ ){
+ if(fDataType[ip] == kMC ) continue;
+ if( fMCPeriod[ip] == TString(tstr) ){
+ period = ip;
+ break;
+ }
+ }
+ if( period < 0 ){
+ cout<<"J_ERROR : no period for MCPeriod "<<tstr<<endl;
+ exit(1);
+ }
+ return period;
+}
+
+bool AliJRunTable::ParseString( const char * tstr ){
+ // comment needed
+ fCRunNumber = GetRunNumberFromString(tstr);
+ fCPeriodMCName = GetMCPeriodFromString(tstr);
+ if( fCRunNumber > 0 ){
+ fCPeriod = GetRunNumberToPeriod( fCRunNumber );
+ }else
+ if( fCPeriodMCName.Length() > 0 ){
+ fCPeriod = GetPeriodFromMCPeriod( fCPeriodMCName );
+ }else{
+ fCPeriod = kUnknownPeriod;
+ }
+ return true;
+}
+
+// GetBeamStr is never used anywhere. Should it be removed altogether?
+const char * AliJRunTable::GetBeamStr( int ib ) const {
+ // comment needed
+ if( ib < 0 ) ib = fBeamType[fCPeriod];
+ switch (ib){
+ case kPP : return "pp";
+ case kPbPb: return "PbPb";
+ case kPA: return "PA";
+ }
+ return NULL;
+}
+
+const char * AliJRunTable::GetDataStr( int ib ) const {
+ // comment needed
+ if( ib < 0 ) ib = fDataType[fCPeriod];
+ switch (ib){
+ case kRE: return "REAL";
+ case kMC: return "MC";
+ }
+ return NULL;
+}
+AliJRunTable& AliJRunTable::GetSpecialInstance(){
+ // comment needed
+ static AliJRunTable instance;
+ return instance;
+}
+
+// GetEnergyStr is never used anywhere. Should it be removed altogether?
+const char * AliJRunTable::GetEnergyStr( int ib ) const {
+ // comment needed
+ if( ib < 0 ) ib = fEnergy[fCPeriod];
+ if( ib < 1000 ) return Form("%dGeV",ib);
+ if( ib == 2760 ) return "2.76TeV";
+ return Form("%dTeV",ib/1000);
+}
+
+const AliJRunTable& AliJRunTable::GetInstance(){
+ // comment needed
+ return GetSpecialInstance();
+}
--- /dev/null
+/* 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!
+
+#ifndef ALIJRUNTABLE_H
+#define ALIJRUNTABLE_H
+
+#include <TString.h>
+#include <vector>
+class AliJRunTable {
+public:
+ enum { kUnknownPeriod, kLHC10b, kLHC10c, kLHC10d, kLHC10e,
+ kLHC10h, kLHC11a,kLHC11b , kLHC11c , kLHC11d, kLHC11e, kLHC11h, kLHC12g,kLHC12h,
+ kLHC13b, kLHC13c, kLHC13d, kLHC13e, kLHC13g,
+ kJNPeriod};
+ enum { kRE, kMC };
+ enum { kPP, kPbPb, kPA };
+ AliJRunTable();
+ void Init();
+ void AddGoodRun(int period, int runnumber){ fGoodRun[period].push_back(runnumber); }
+ TString GetPeriodName( int period=-1 ) const;
+ int GetBeamType( int period ) const { return fBeamType[period]; }
+ TString GetMCPeriod( int period ) const { return fMCPeriod[period]; }
+ int GetPeriodCode(TString perstr) const;
+ int GetRunNumberToPeriod( int runnumber );
+ void SetPeriodInformation(int period, TString name, int beamtype, int datatype, int energy, int run0, int run1, TString MCPeriod);
+ int GetBeamEnergy(int period) const { return fEnergy[period]; }
+
+ int GetRunNumberFromString( const char * tstr );
+ TString GetPeriodFromString( const char * tstr ) const;
+ TString GetMCPeriodFromString( const char * tstr) const;
+ int GetPeriodFromMCPeriod( const char * tstr );
+ const char * GetBeamStr( int ib=-1 ) const; // Never used anywhere, should it be removed?
+ const char * GetDataStr( int ib=-1 ) const; // Never used anywhere, should it be removed?
+ const char * GetEnergyStr( int ib=-1 ) const; // Never used anywhere, should it be removed?
+ bool ParseString( const char * tstr );
+
+ int GetPeriod() const { return fCPeriod; }
+ TString GetPeriodMCName() const { return fCPeriodMCName; }
+ int GetBeamType() const { return fBeamType[fCPeriod]; }
+ TString GetBeamTypeStr() const { return IsPP()?"pp":IsPA()?"pA":IsHeavyIon()?"PbPb":""; }
+ void SetRunNumber( int run ){ fCRunNumber=run;fCPeriod=GetRunNumberToPeriod(run); }
+ int GetRunNumber() const { return fCRunNumber; }
+
+ bool IsHeavyIon() const { return fBeamType[fCPeriod]==kPbPb; }
+ bool IsPA() const { return fBeamType[fCPeriod]==kPA; }
+ bool IsPP() const { return fBeamType[fCPeriod]==kPP; }
+
+ AliJRunTable * operator()( int run ){ SetRunNumber(run);return this; }
+ static AliJRunTable& GetSpecialInstance();
+ static const AliJRunTable& GetInstance();
+
+private:
+ int fBeamType[kJNPeriod]; // comment needed
+ int fDataType[kJNPeriod]; // comment needed
+ int fEnergy[kJNPeriod]; // comment needed
+ long fRunRange[kJNPeriod][2]; // comment needed
+ TString fMCPeriod[kJNPeriod]; // comment needed
+ TString fPeriodName[kJNPeriod]; // comment needed
+ std::vector<int> fGoodRun[kJNPeriod]; // comment needed
+
+ int fCPeriod; // comment needed
+ int fCRunNumber; // comment needed
+ TString fCPeriodMCName; // comment needed
+};
+
+#endif
/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * 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 notifce *
+ * 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: AliJTrack.cxx,v 1.2 2008/01/21 11:56:39 djkim Exp $
////////////////////////////////////////////////////
fFilterMap(0),
fTPCnClust(-1),
fTPCdEdx(-1),
- fTOFbeta(0)
+ fTOFsignal(9999),
+ fTPCmom(0)
{
// default constructor
- for( int i=0;i<kNAliJTrkPID;i++ ) SetPID( AliJTrkPID(i), 0, kTOF);
- for( int i=0;i<kNAliJTrkPID;i++ ) SetPID( AliJTrkPID(i), 0, kTPC);
- for( int i=0;i<kNAliJTrkPID;i++ ) SetPID( AliJTrkPID(i), 0, kTPCTOF);
- for( int i=0;i<kNAliJTrkPID;i++) fExpTOFbeta[i]= 0;
- for( int i=0;i<kNAliJTrkPID;i++) fExpTPCdEdx[i]= 0;
- for( int i=0;i<kNAliJTrkPID;i++) fTPCsigma[i]= 0;
- for( int i=0;i<kNAliJTrkPID;i++) fTOFsigma[i]= 0;
+ for( int i=0;i<kNAliJTrkPID;i++) fExpTOFsignal[i]= 9999;
for( int i=0;i<3;i++) fTPCTrack[i] = 0;
+ for( int i=0;i<3;i++) fGCGTrack[i] = 0;
+ for( int i=0;i<3;i++) fTrackPos[i] = 0;
}
fFilterMap( a.fFilterMap ),
fTPCnClust(a.fTPCnClust),
fTPCdEdx(a.fTPCdEdx),
- fTOFbeta( a.fTOFbeta )
+ fTOFsignal(a.fTOFsignal),
+ fTPCmom(a.fTPCmom)
{
//copy constructor
- for(Int_t i=0;i<kNAliJTrkPID;i++) fTrkPID[i][kTOF] = a.fTrkPID[i][kTOF];
- for(Int_t i=0;i<kNAliJTrkPID;i++) fTrkPID[i][kTPC] = a.fTrkPID[i][kTPC];
- for(Int_t i=0;i<kNAliJTrkPID;i++) fTrkPID[i][kTPCTOF] = a.fTrkPID[i][kTPCTOF];
- for(Int_t i=0;i<kNAliJTrkPID;i++) fExpTOFbeta[i]= a.fExpTOFbeta[i];
- for( int i=0;i<kNAliJTrkPID;i++) fExpTPCdEdx[i]= a.fExpTPCdEdx[i];
- for( int i=0;i<kNAliJTrkPID;i++) fTPCsigma[i]= a.fTPCsigma[i];
- for( int i=0;i<kNAliJTrkPID;i++) fTOFsigma[i]= a.fTOFsigma[i];
+ for(Int_t i=0;i<kNAliJTrkPID;i++) fExpTOFsignal[i]= a.fExpTOFsignal[i];
for( int i=0;i<3;i++) fTPCTrack[i] = a.fTPCTrack[i];
+ for( int i=0;i<3;i++) fGCGTrack[i] = a.fGCGTrack[i];
+ for( int i=0;i<3;i++) fTrackPos[i] = a.fTrackPos[i];
}
if(this != &trk){
AliJBaseTrack::operator=(trk);
for(Int_t i=0;i<kNAliJTrkPID;i++){
- fTrkPID[i][kTOF] = trk.fTrkPID[i][kTOF];
- fTrkPID[i][kTPC] = trk.fTrkPID[i][kTPC];
- fTrkPID[i][kTPCTOF] = trk.fTrkPID[i][kTPCTOF];
- fExpTOFbeta[i]= trk.fExpTOFbeta[i];
- fExpTPCdEdx[i] = trk.fExpTPCdEdx[i];
- fTPCsigma[i] = trk.fTPCsigma[i];
- fTOFsigma[i] = trk.fTOFsigma[i];
+ fExpTOFsignal[i]= trk.fExpTOFsignal[i];
}
for( int i=0;i<3;i++) fTPCTrack[i] = trk.fTPCTrack[i];
+ for( int i=0;i<3;i++) fGCGTrack[i] = trk.fGCGTrack[i];
+ for( int i=0;i<3;i++) fTrackPos[i] = trk.fTrackPos[i];
fFilterMap = trk.fFilterMap;
fTPCnClust = trk.fTPCnClust;
fTPCdEdx = trk.fTPCdEdx;
- fTOFbeta = trk.fTOFbeta;
+ fTOFsignal = trk.fTOFsignal;
}
return *this;
}
+/* 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: AliJTrack.h,v 1.3 2008/01/21 11:56:39 djkim Exp $
////////////////////////////////////////////////////
/*!
};
enum AliJTrkPIDmethod {
- kTOF=0, kTPC=1, kTPCTOF=2, kNAliJTrkPIDmethod
+ //kTOF=0, kTPC=1, kTPCTOF=2, kNAliJTrkPIDmethod
+ kTOF=0, kNAliJTrkPIDmethod
};
- AliJTrack(); // default constructor
+ AliJTrack(); // default constructor
AliJTrack(const AliJTrack& a); // copy constructor
- ~AliJTrack(){;} //destructor
+ ~AliJTrack(){;} //destructor
Double32_t GetPID(AliJTrkPID p, AliJTrkPIDmethod m) const { return fTrkPID[p][m]; }
UInt_t GetFilterMap() const { return fFilterMap; }
Bool_t IsFiltered( int i ) const { return TESTBIT( fFilterMap, i); }
Bool_t IsFilteredMask( UInt_t mask ) const { return ((Bool_t)(((fFilterMap) & mask) != 0)); };
int GetTPCnClust() const {return fTPCnClust;}
- Float_t GetTPCdEdx() const {return fTPCdEdx; }
- Float_t GetTOFbeta() const {return fTOFbeta;}
- Float_t GetExpectedTOFbeta( AliJTrkPID p ) const {return fExpTOFbeta[p];}
- Double_t GetExpectedTPCdEdx( AliJTrkPID p ) const {return fExpTPCdEdx[p];}
- Double_t GetTPCsigma( AliJTrkPID p) const {return fTPCsigma[p];}
- Double_t GetTOFsigma( AliJTrkPID p) const {return fTOFsigma[p];}
+ Double32_t GetTPCdEdx() const {return fTPCdEdx; }
+ Double32_t GetTOFsignal() const {return fTOFsignal;}
+ Double32_t GetExpectedTOFsignal( AliJTrkPID p ) const {return fExpTOFsignal[p];}
+ Double32_t GetTPCmomentum() const {return fTPCmom;}
+ void GetTrackPos( Double32_t *p ) const { p[0] = fTrackPos[0]; p[1] = fTrackPos[1]; p[2] = fTrackPos[2]; }
void SetPID(AliJTrkPID p, double pro, AliJTrkPIDmethod m){ fTrkPID[p][m] = pro; }
void SetFilterMap( UInt_t map ){ fFilterMap = map; }
void SetFilterMap( int i, bool t ){ t?SETBIT(fFilterMap,i):CLRBIT(fFilterMap,i); }
void SetTPCnClust(int ival) {fTPCnClust = ival;}
- void SetTPCdEdx( Float_t dedx ){ fTPCdEdx = dedx; }
- void SetTOFbeta(Float_t beta) {fTOFbeta = beta;}
- void SetExpectedTOFbeta(AliJTrkPID p, float exbeta) {fExpTOFbeta[p] = exbeta;}
- void SetExpectedTPCdEdx(AliJTrkPID p, Double_t exdEdx) {fExpTPCdEdx[p] = exdEdx;}
- void SetTPCsigma(AliJTrkPID p, Double_t TPCsigma) {fTPCsigma[p] = TPCsigma;}
- void SetTOFsigma(AliJTrkPID p, Double_t TOFsigma) {fTOFsigma[p] = TOFsigma;} // Return the expected sigma of the PID signal for the specified particle type.
-
- void SetTPCTrack( Float_t px, Float_t py, Float_t pz ){ fTPCTrack[0]=px;fTPCTrack[1]=py;fTPCTrack[2]=pz;}
+ void SetTPCdEdx(Double32_t dedx ){ fTPCdEdx = dedx; }
+ void SetTOFsignal(Double_t tofsig) {fTOFsignal = tofsig;}
+ void SetExpectedTOFsignal(AliJTrkPID p, double extime) {fExpTOFsignal[p] = extime;}
+ void SetTPCmomentum(Double_t momTPC) {fTPCmom = momTPC;}
+ void SetTPCTrack( Double32_t px, Double32_t py, Double32_t pz ){ fTPCTrack[0]=px;fTPCTrack[1]=py;fTPCTrack[2]=pz;}
+ void SetGCGTrack( Double32_t px, Double32_t py, Double32_t pz ){ fGCGTrack[0]=px;fGCGTrack[1]=py;fGCGTrack[2]=pz;}
+ void SetTrackPos( Double32_t *p ){ fTrackPos[0]=p[0];fTrackPos[1]=p[1];fTrackPos[2]=p[2];}
void SetUseTPCTrack(){ SetPxPyPzE( fTPCTrack[0], fTPCTrack[1], fTPCTrack[2], 0 ); }
- Float_t* GetTPCTrack(){ return fTPCTrack; }
+ void SetUseGCGTrack(){ SetPxPyPzE( fGCGTrack[0], fGCGTrack[1], fGCGTrack[2], 0 ); }
+ Double32_t * GetTPCTrack(){ return fTPCTrack; }
+ Double32_t * GetGCGTrack(){ return fGCGTrack; }
+
+ Double32_t PtTPC(){ return TMath::Sqrt( fTPCTrack[0]*fTPCTrack[0] + fTPCTrack[1]*fTPCTrack[1] ); }
+ Double32_t PtGCG(){ return TMath::Sqrt( fGCGTrack[0]*fGCGTrack[0] + fGCGTrack[1]*fGCGTrack[1] ); }
+
AliJTrack& operator=(const AliJTrack& trk);
+ //Double32_t GetDCAtoVertexXY(){ return fDCAtoVertexXY; }
+ //void SetDCAtoVertexXY( double dxy ){ fDCAtoVertexXY = dxy; }
+ //Double32_t GetDCAtoVertexZ(){ return fDCAtoVertexZ; }
+ //void SetDCAtoVertexZ( double dxy ){ fDCAtoVertexZ = dxy; }
+
private:
- Double32_t fTrkPID[kNAliJTrkPID][kNAliJTrkPIDmethod]; //[0.,1.,8] Array for PID.
- UInt_t fFilterMap; // bit serious of cuts
- Short_t fTPCnClust; // track TPC nclusters
- Float_t fTPCdEdx;
- Float_t fTOFbeta; //!
- Float_t fExpTOFbeta[kNAliJTrkPID]; //!
- Double_t fExpTPCdEdx[kNAliJTrkPID]; //!
- Double_t fTPCsigma[kNAliJTrkPID]; //!
- Double_t fTOFsigma[kNAliJTrkPID]; //!
- Float_t fTPCTrack[3]; // px, py, pz for TPCTrack;
+ Double32_t fTrkPID[kNAliJTrkPID][kNAliJTrkPIDmethod]; //[0.,1.,8] Array for PID.
+ UInt_t fFilterMap; // bit serious of cuts
+ Short_t fTPCnClust; // track TPC nclusters
+ Double32_t fTPCdEdx; // TPC dEdx
+ Double32_t fTOFsignal; // TOF time
+ Double32_t fExpTOFsignal[kNAliJTrkPID]; // expected TOF time
+ Double32_t fTPCmom; // TPC momentum to calculate expected TPC dEdx
+ Double32_t fTPCTrack[3]; // px, py, pz for TPCTrack;
+ Double32_t fGCGTrack[3]; // px, py, pz for GCGTrack;
+ Double32_t fTrackPos[3]; // track position
+
+ //Double32_t fDCAtoVertexXY; //!
+ //Double32_t fDCAtoVertexZ; //!
ClassDef(AliJTrack,1)
};
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJTrackCounter.h"
+
+// track counter
+// blah
+// blah
+// blah
+// blah
+
+ClassImp(AliJTrackCounter)
+
+ AliJTrackCounter::AliJTrackCounter() :
+ findex(-1),
+ fptBin(-1),
+ fpt(-1),
+ fdphi(-1)
+ {
+ Reset();
+ }
+
+
+ AliJTrackCounter::AliJTrackCounter(int inind0, int inind1, int inlist0, int inlist1, double indphi) :
+ findex(-1),
+ fptBin(-1),
+ fpt(-1),
+ fdphi(indphi)
+ {
+ // constructor
+ Reset();
+ fpairTrackID[0]=inind0;
+ fpairTrackID[1]=inind1;
+ fpairListID[0]=inlist0;
+ fpairListID[1]=inlist1;
+ fdphi = indphi;
+ } //constructor
+
+
+
+ void AliJTrackCounter::Reset(){
+ // reset
+ findex=-1;
+ fpairTrackID[0]=-1; fpairTrackID[1]=-1;
+ fpairListID[0]=-1; fpairListID[1]=-1;
+ fpt=-1; fptBin=-1; fdphi=-1;
+ }
+
+
+
+ AliJTrackCounter& AliJTrackCounter::operator=(const AliJTrackCounter& counter){
+ // copy constructor
+ fpairTrackID[0] = counter.fpairTrackID[0];
+ fpairTrackID[1] = counter.fpairTrackID[1];
+ fpairListID[0] = counter.fpairListID[0];
+ fpairListID[1] = counter.fpairListID[1];
+ fdphi = counter.fdphi;
+ return *this;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/* 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!
+
+//===========================================================
+// AliJTrackCounter.h
+// Created Fri Mar 11 15:24:11 EET 2011 by classmaker
+// Jan Rak
+//===========================================================
+
+#ifndef ALIJTRACKCOUNTER_H
+#define ALIJTRACKCOUNTER_H
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace std;
+
+class AliJTrackCounter : public TObject {
+
+ public:
+ AliJTrackCounter(); //constructor
+
+ AliJTrackCounter(int inind0, int inind1, int inlist0, int inlist1, double indphi);
+
+ virtual ~AliJTrackCounter(){;} //destructor
+
+
+ void Reset();
+ bool Exists() const {return fpt>=0 ? true : false;}
+ void Store(int inind, double inpt, int inBin){findex=inind; fpt=inpt; fptBin=inBin;}
+ int GetIndex() const {return findex;}
+ void SetIndex(int inIdx) {findex=inIdx;}
+ double Pt() const {return fpt;} // BS to compatible with AliJBaseTrack
+ double GetPt() const {return fpt;}
+ int GetPtBin() const {return fptBin;}
+
+ int GetPairTrackID(int ip ) const {return (ip==0||ip==1) ? fpairTrackID[ip] : -1; }
+ int GetPairListID(int ip ) const {return (ip==0||ip==1) ? fpairListID[ip] : -1; }
+ double GetPairDPhi() const {return fdphi;}
+
+ void Print(Option_t* option = "") const{
+ // We must have option here because Print overrides the same function from TObject
+ // TODO: make some sensible use of option
+ cout<<"LPindex="<<findex << option <<" LPpt="<<fpt <<" bin= "<<fptBin
+ <<" fpairTrackID[0]="<<fpairTrackID[0] <<" fpairTrackID[1]="<<fpairTrackID[1] <<" pairDPHI="<< fdphi<< endl;
+ }
+
+ AliJTrackCounter& operator=(const AliJTrackCounter& counter);
+
+ protected:
+
+ int findex; // comment me
+
+ int fpairTrackID[2]; // comment me
+ int fpairListID[2]; // comment me
+ int fptBin; // comment me
+ double fpt; // comment me
+ double fdphi; // comment me
+
+ ClassDef(AliJTrackCounter,1)
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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!
+
+#include "AliJTrackCut.h"
+#include "AliJTrack.h"
+#include <TMath.h>
+
+AliJTrackCut::AliJTrackCut()
+{
+}
+
+/* FOR ESD
+bool AliJTrackCut::IsSelected ( AliJTrack *track, int icut )const{
+ // Comment needed
+ if( ! track ) return false;
+ if( 1 ) {// TODO fProdVersion == 10 )
+ switch ( icut ){
+
+ case AliJTrackCut::kJTPCOnly :
+ return track->IsFiltered( 7 );
+
+ case AliJTrackCut::kJRaa :
+ return track->IsFiltered( 10 ); //TODO
+
+ case AliJTrackCut::kJTPCplus :
+ return track->IsFiltered( 12 );
+
+ case AliJTrackCut::kJHybridA :
+ return track->IsFiltered( 14 );
+
+ case AliJTrackCut::kJHybridB :
+ return ( !track->IsFiltered( 14 ) && track->IsFiltered(15) );
+
+ case AliJTrackCut::kJHybrid :
+ return ( IsSelected(track,kJHybridA) || IsSelected(track, kJHybridB ) );
+
+ case AliJTrackCut::kJTPC2A :
+ return track->IsFiltered(11);
+ case AliJTrackCut::kJRaa2011 :
+ return track->IsFiltered(13);
+ case AliJTrackCut::kJH22011 :
+ return track->IsFiltered(16);
+ case AliJTrackCut::kJH32011 :
+ return track->IsFiltered(17);
+
+ }
+ }
+ return false;
+}
+ */
+
+//==== FOR AOD
+bool AliJTrackCut::IsSelected ( AliJTrack *track, int icut )const{
+ // comment needed
+ if( ! track ) return false;
+ if( 1 ) {// TODO fProdVersion == 10 )
+ switch ( icut ){
+
+ case AliJTrackCut::kJTPCOnly :
+ return track->IsFiltered( 7 );
+
+ case AliJTrackCut::kJRaa :
+ return track->IsFiltered( 10 ); //TODO
+
+ case AliJTrackCut::kJHybrid :
+ return track->IsFiltered(8) || track->IsFiltered(9) ;
+ case AliJTrackCut::kJGlobalTightDCA :
+ return track->IsFiltered( 5 ); // 32
+ case AliJTrackCut::kJGlobalDCA :
+ return track->IsFiltered( 4 ); // 32
+ case AliJTrackCut::kJGlobalSDD :
+ return track->IsFiltered( 5 ) || track->IsFiltered( 6 );
+ }
+ }
+ return false;
+}
+
+bool AliJTrackCut::SetMomentum( AliJTrack *track, int icut ) const {
+ // comment needed
+ if( ! track ) return false;
+ if( 1 ) {// TODO fProdVersion == 10 )
+
+ switch ( icut ){
+ /*
+ case AliJTrackCut::kJTPCOnly :
+ if( track->PtTPC() > 1e-9 ){
+ track->SetUseTPCTrack();
+ }
+ break;
+ case AliJTrackCut::kJTPCplus :
+ if( track->PtTPC() > 1e-9 ){
+ track->SetUseTPCTrack();
+ }
+ break;
+ case AliJTrackCut::kJHybrid :
+ if( (!IsSelected( track, kJHybridA )) && track->PtGCG() > 1e-9 )
+ track->SetUseGCGTrack();
+ break;
+ */
+ default:
+ break;
+ }
+
+ }
+ return true;
+}
+
+AliJTrackCut& AliJTrackCut::GetSpecialInstance(){
+ // comment needed
+ static AliJTrackCut instance;
+ return instance;
+}
+const AliJTrackCut& AliJTrackCut::GetInstance(){
+ // comment needed
+ return GetSpecialInstance();
+}
--- /dev/null
+/* 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!
+
+#ifndef ALIJTRACKCUT_H
+#define ALIJTRACKCUT_H
+
+class AliJTrack;
+
+class AliJTrackCut {
+ public:
+ enum { kJTPCOnly, kJRaa, kJGlobalTightDCA, kJGlobalDCA, kJGlobalSDD , kJHybrid, kJNTrackCuts };
+
+ AliJTrackCut();
+ ~AliJTrackCut(){;}
+ bool IsSelected ( AliJTrack *track, int icut ) const;
+ bool SetMomentum( AliJTrack *track, int icut ) const;
+ int GetNCut() const { return kJNTrackCuts; } //TODO
+ static AliJTrackCut& GetSpecialInstance();
+ static const AliJTrackCut& GetInstance();
+ private:
+
+};
+
+#endif
--- /dev/null
+const Bool_t IsMC = kFALSE; //With real data kMC = kFALSE
+const TString kInputData = "AOD";
+const TString kJCORRANInputFormat = "AOD"; // ESD, AODout, AODin
+const Bool_t kDoStoreJOD = kTRUE;
+
+//_____________________________________________________________________
+AliAnalysisTask *AddTaskJCORRANFilter(){
+ // Load Custom Configuration and parameters
+ // override values with parameters
+ UInt_t triggerSelection;
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+
+ // AOD handler
+ AliAODInputHandler *aodHandler = new AliAODInputHandler();
+ mgr->SetInputEventHandler(aodHandler);
+
+ //================================================
+ // TASKS
+ //================================================
+
+ // set the trigger selection
+ triggerSelection = AliVEvent::kAny;
+ // | AliVEvent::kHighMult
+ // | AliVEvent::kEMCEGA;
+ // | AliVEvent::kEMCEJE
+ // | AliVEvent::kEMC1
+ // | AliVEvent::kEMC7
+ // | AliVEvent::kCentral
+ // | AliVEvent::kSemiCentral;
+ //============================
+ // JCORRANTask
+ //===========================
+
+ //==== JCORRAN TASK
+ AliJCORRANTask *jctask = new AliJCORRANTask("PWGCFJCORRANTask",kJCORRANInputFormat);
+ jctask->SetOutputAODName("jcorran.root");
+ jctask->SetDebugLevel(0);
+ jctask->SetDoStoreJOD( kDoStoreJOD );
+ cout<<"DEBUG 4"<< jctask->GetDoStoreJOD() <<"\t"<<kDoStoreJOD<<endl;
+
+ AliJRunHeader * hdr = new AliJRunHeader;
+ hdr->SetIsMC( IsMC );
+ hdr->SetBeamTypeI( 0 ); // 0:pp 1:PbPb
+ hdr->SetWithoutSDD(false);
+ hdr->SetRunType("LHC13c");
+ hdr->SetInputFormat( 1 ); // 0: ESD;
+ hdr->SetRefitESDVertexTracks(kFALSE);
+ hdr->SetStoreEventPlaneSource(kFALSE);
+ hdr->SetStoreTPCTrackBitMask( 1<<7 ); // TODO : For what?
+ hdr->SetStoreGCGTrackBitMask( 2^30-1 );
+ hdr->SetStoreEMCalInfo( kFALSE ); // error with lego now.
+
+
+ jctask->SetJRunHeader( hdr );
+
+ AliJFilter *jfilter = jctask->GetFilter();
+ jfilter->SetAliJRunHeader( hdr );
+ jfilter->SetClusterThreshold( 0 );
+ jfilter->SetTrackThreshold( 0 );
+
+ //==event selection
+ jctask->SelectCollisionCandidates( triggerSelection ); //Apply offline trigger selection by AliPhysicsSelectionTask
+
+ mgr->AddTask((AliAnalysisTask*) jctask);
+
+ //==== Create containers for input/output
+ AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
+ AliAODHandler* aodoutHandler = new AliAODHandler();
+ aodoutHandler->SetCreateNonStandardAOD();
+ mgr->SetOutputEventHandler(aodoutHandler);
+
+// Connect input/output
+ mgr->ConnectInput(jctask, 0, cinput);
+ if( kDoStoreJOD ){
+ AliAnalysisDataContainer *runinfoOutput = mgr->CreateContainer("RunInfo", TList::Class(), AliAnalysisManager::kOutputContainer, "jcorran.root");
+ AliAnalysisDataContainer *treeOutput = mgr->CreateContainer("JODTree", TTree::Class(), AliAnalysisManager::kOutputContainer, "jcorran.root");
+ mgr->ConnectOutput(jctask, 1, treeOutput );
+ mgr->ConnectOutput(jctask, 2, runinfoOutput );
+ }
+
+ return jctask;
+}
+
--- /dev/null
+//_____________________________________________________________________
+AliAnalysisTask *AddTaskJDiHadronCorr(TString cardName, TString jtrigg, TString jassoc, TString inclusFileName=""){
+ // Load Custom Configuration and parameters
+ // override values with parameters
+
+ cout<<"### DEGUG Input is "<< cardName <<"\t"<<jtrigg<<"\t"<<jassoc<<"\t"<<inclusFileName<<"\t"<<"#########"<<endl;
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+
+ //==== JCORRAN Efficiency TASK
+ AliJDiHadronCorrTask *jdihadtask = new AliJDiHadronCorrTask("JDiHadronCorrTask","JOD");
+ jdihadtask->SetDebugLevel(5);
+ jdihadtask->SetFilterTaskName("PWGCFJCORRANTask");
+
+
+ // === Create AliJCORRAN ====
+ AliJCard *card = new AliJCard(cardName.Data());
+ card->PrintOut();
+
+ AliJCORRAN *fJCORRAN;
+ fJCORRAN = new AliJCORRAN( kFALSE );
+
+ fJCORRAN->SetCard( card );
+ fJCORRAN->SetTrigger( jtrigg.Data() );
+ fJCORRAN->SetAssoc( jassoc.Data() );
+ if( inclusFileName ) fJCORRAN->SetInclusiveFile(inclusFileName.Data());
+
+ jdihadtask->SetJCORRAN( fJCORRAN );
+
+ mgr->AddTask((AliAnalysisTask*) jdihadtask);
+
+ // Create containers for input/output
+ AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
+
+
+ // Connect input/output
+ mgr->ConnectInput(jdihadtask, 0, cinput);
+ AliAnalysisDataContainer *jHist = mgr->CreateContainer("JDiHadronCorr", TDirectory::Class(), AliAnalysisManager::kOutputContainer, Form("%s:JDiHadronCorr",AliAnalysisManager::GetCommonFileName()));
+ mgr->ConnectOutput(jdihadtask, 1, jHist );
+
+ return jdihadtask;
+}
+
--- /dev/null
+TriggerMask 256 # 62 masking on see bottom 0011:1110 -1 no check
+Helicity 0 # +1 same, -1 opposite, and 0 no helicity check
+EfficiencyMode 1 # 0:NoEff 1:Period 2:RunbyRun 3:Auto
+
+#events=========
+#CentBinBorders 0 10 20 40 60 90
+CentBinBorders 0 100
+CentMultCutHigh 0.63, 99, 2.1 # hyperbola high cent x mult cut
+CentMultCutLow 0.71, 75, 1.0 # hyperbola low cent x mult cut
+
+Jet:PtBins 0, 5, 10, 15, 20, 40, 60, 80, 110
+
+zVertBins -10 10
+#maxAbsZVert 8 #(used to be 10)
+#maxMixDZ 1.0 # cm, allowed maximum ZVert distance for mix (5 for QM)/ neg -> no test
+
+#mixing=========
+maxDCent 5 # check the mix if cent bin too wide
+maxMixDMult 100 # assoc mult so far. Later ITS tracklets
+EventPoolDepth 500 # one pool for cent
+
+#====================
+#==== binning =======
+#====================
+CorrelationType 1 # 0=all x all 1=trig LP 2=trigg Pair
+sumTriggerAndAssoc 0 # 0 trigger LP 1 trigger+assoc
+
+#--- ours ---
+TriggPtBorders 3 4 5 6 8 10 12 15 18 25
+#AssocPtBorders 3 4 5 6 8 10 12 15 18 25
+#TriggPtBorders 3 4 5 6 8 10 12 15 18 25
+AssocPtBorders 0.3 1 2 3 4 5 6 8 10 15
+KlongBorders 1 2 3 4 6 8 12
+xEBorders 0.0 0.2 0.4 0.6 1.0
+#KlongBorders 8 12
+#xEBorders 0.6 1.0
+
+
+#--- JFG ---
+#TriggPtBorders 2 3 4 8 15
+#AssocPtBorders 0.5 1 2 3 4 6 8
+#KlongBorders 1 2
+
+#--- UE paper ---
+#TriggPtBorders 0.5 1.5 2 4 6 10
+#AssocPtBorders 0.5 1 10
+#KlongBorders 1 2
+
+PairInvariantMassBins 20 30
+UpperPairPtCut 1.5 15
+EtaRange 0.8
+EtaGapThresholds 0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6
+RGapThresholds 0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 2.3
+EtaGapSignalBin 2 #signal histos to R<0.6
+EtaBoost -0.465 0
+
+DPhiUERegion 0.325 0.475
+
+#======= Isolation tracks =============
+IsolationR 0.4 #isolation radius for higher twist
+CutOnBkgActivity 0.10 #cut on activity around leading particle sum of assoc pt / LP pt
+LowerPtCut 1.0 #for isolation
+
+#======= ALICE JYFL Track selection =============
+HadronSelectionCut 5 # enum { kJTPCOnly, kJRaa, kJGlobalTightDCA, kJGlobalDCA, kJGlobalSDD , kJHybrid, kJNTrackCuts };
+
+TriggerFiducialEtaCut 0.4 #
+
+#======= From Jiri's EMCAL analysis but still in AliJCORRAN.cxx, around line 300
+eventBC -1 # select only events in BC modulo 4; -1 to disable
+
+DoResonancePythia 0