[u/mrichter/AliRoot.git] / PWG2 / FEMTOSCOPY / AliFemto / AliFemtoAnalysisAzimuthal.cxx

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// AliFemtoAnalysisReactionPlane - Femtoscopic analysis which mixes event //
// with respect to the z position of the primary vertex and event total   //
// multiplicity and uses only events in certain reaction plane angle bin  //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "AliFemtoAnalysisAzimuthal.h"
#include <TMath.h>
#include <string>
#include <cstdio>
#include "AliFemtoParticleCollection.h"
#include "AliFemtoTrackCut.h"
#include "AliFemtoV0Cut.h"
#include "AliFemtoPairCut.h"
#include "TVector2.h"
#include "AliFemtoKinkCut.h"
#include "AliFemtoPicoEventCollectionVector.h"
#include "AliFemtoPicoEventCollectionVectorHideAway.h"

#ifdef __ROOT__ 
ClassImp(AliFemtoAnalysisAzimuthal)
#endif

extern void FillHbtParticleCollection(AliFemtoParticleCut*         partCut,
				      AliFemtoEvent*               hbtEvent,
				      AliFemtoParticleCollection*  partCollection);


//____________________________
AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(unsigned int binsVertex, double minVertex, double maxVertex,
						       unsigned int binsMult, double minMult, double maxMult, unsigned short binsRP) 
  : 
  fFemtoParticleCut(0),
  fFlowParticleCut(0),
  fPairCut(0),
  fEventCut(0),
  fVertexZBins(binsVertex), 
  fOverFlowVertexZ(0), 
  fUnderFlowVertexZ(0),
  fMultBins(binsMult) ,
  fOverFlowMult(0),    
  fUnderFlowMult(0),
  fRPBins(binsRP),
  fPsi(0)
{
  //  mControlSwitch     = 0;
  fCorrFctnCollection= 0;
  fCorrFctnCollection = new AliFemtoCorrFctnCollection;
  fVertexZ[0] = minVertex;
  fVertexZ[1] = maxVertex;
  fMult[0] = minMult;
  fMult[1] = maxMult;
  if (fMixingBuffer) delete fMixingBuffer;
  fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
										     fMultBins,fMult[0],fMult[1],
										     fRPBins,0.0,TMath::Pi());
}

//____________________________

AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) : 
  AliFemtoSimpleAnalysis(),
  fFemtoParticleCut(0),
  fFlowParticleCut(0),
  fPairCut(0),
  fEventCut(0),
  fVertexZBins(a.fVertexZBins), 
  fOverFlowVertexZ(0), 
  fUnderFlowVertexZ(0),
  fMultBins(a.fMultBins) ,
  fOverFlowMult(0),    
  fUnderFlowMult(0),
  fRPBins(a.fRPBins),
  fPsi(0)

{
  fCorrFctnCollection= 0;
  fCorrFctnCollection = new AliFemtoCorrFctnCollection;
  fVertexZ[0] = a.fVertexZ[0]; 
  fVertexZ[1] = a.fVertexZ[1];
  fMult[0] = a.fMult[0]; 
  fMult[1] = a.fMult[1];
  if (fMixingBuffer) delete fMixingBuffer;
  fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
										     fMultBins,fMult[0],fMult[1],
										     fRPBins,0.0,TMath::Pi());
  // find the right event cut
  fEventCut = a.fEventCut->Clone();
  // find the right femto particle cut
  fFemtoParticleCut = a.fFemtoParticleCut->Clone();
  // find the right flow particle cut
  fFlowParticleCut = a.fFlowParticleCut->Clone();
  // find the right pair cut
  fPairCut = a.fPairCut->Clone();
  
  if ( fEventCut ) {
      SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - event cut set " << endl;
  }
  if ( fFemtoParticleCut ) {
      SetFirstParticleCut(fFemtoParticleCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - femto particle cut set " << endl;
  }
  if ( fFlowParticleCut ) {
      SetSecondParticleCut(fFlowParticleCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - flow particle cut set " << endl;
  }
  if ( fPairCut ) {
      SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - pair cut set " << endl;
  }

  AliFemtoCorrFctnIterator iter;
  for (iter=a.fCorrFctnCollection->begin(); iter!=a.fCorrFctnCollection->end();iter++){
    cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - looking for correlation functions " << endl;
    AliFemtoCorrFctn* fctn = (*iter)->Clone();
    if (fctn) AddCorrFctn(fctn);
    else cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - correlation function not found " << endl;
  }
  fNumEventsToMix = a.fNumEventsToMix;
  cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - analysis copied " << endl;
}

AliFemtoAnalysisAzimuthal& AliFemtoAnalysisAzimuthal::operator=(const AliFemtoAnalysisAzimuthal& a)
{
  // Assignment operator
  if (this == &a)
    return *this;

  fCorrFctnCollection= 0;
  fCorrFctnCollection = new AliFemtoCorrFctnCollection;
  fVertexZ[0] = a.fVertexZ[0]; 
  fVertexZ[1] = a.fVertexZ[1];
  fMult[0] = a.fMult[0]; 
  fMult[1] = a.fMult[1];
  if (fMixingBuffer) delete fMixingBuffer;
  fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
										     fMultBins,fMult[0],fMult[1],
										     fRPBins,0.0,TMath::Pi());
  // find the right event cut
  fEventCut = a.fEventCut->Clone();
  // find the right femto particle cut
  fFemtoParticleCut = a.fFemtoParticleCut->Clone();
  // find the right flow particle cut
  fFlowParticleCut = a.fFlowParticleCut->Clone();
  // find the right pair cut
  fPairCut = a.fPairCut->Clone();
  
  if ( fEventCut ) {
      SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - event cut set " << endl;
  }
  if ( fFemtoParticleCut ) {
      SetFirstParticleCut(fFemtoParticleCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - femto particle cut set " << endl;
  }
  if ( fFlowParticleCut ) {
      SetSecondParticleCut(fFlowParticleCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - flow particle cut set " << endl;
  }
  if ( fPairCut ) {
      SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
      cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - pair cut set " << endl;
  }

  AliFemtoCorrFctnIterator iter;
  for (iter=a.fCorrFctnCollection->begin(); iter!=a.fCorrFctnCollection->end();iter++){
    cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - looking for correlation functions " << endl;
    AliFemtoCorrFctn* fctn = (*iter)->Clone();
    if (fctn) AddCorrFctn(fctn);
    else cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - correlation function not found " << endl;
  }
  fNumEventsToMix = a.fNumEventsToMix;
  cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - analysis copied " << endl;

  return *this;
  
}

//____________________________
AliFemtoAnalysisAzimuthal::~AliFemtoAnalysisAzimuthal(){
  // now delete every PicoEvent in the EventMixingBuffer and then the Buffer itself
  delete fPicoEventCollectionVectorHideAway;
}

//_________________________
void AliFemtoAnalysisAzimuthal::ProcessEvent(const AliFemtoEvent* hbtEvent) {
  // Perform event processing in bins of z vertex, multiplicity and Reaction Plane angle
  // cout << " AliFemtoAnalysisAzimuthal::ProcessEvent(const AliFemtoEvent* hbtEvent) " << endl;

  // get right mixing buffer
  double vertexZ = hbtEvent->PrimVertPos().z();
  double mult = hbtEvent->UncorrectedNumberOfPrimaries();
  //double rpangle = GetQVector() // Not possible at the moment to get rpangle for mixing wrt RP
  
  fMixingBuffer = fPicoEventCollectionVectorHideAway->PicoEventCollection(vertexZ,mult,fPsi); 
  if (!fMixingBuffer) {
    if ( vertexZ < fVertexZ[0] ) fUnderFlowVertexZ++;
    if ( vertexZ > fVertexZ[1] ) fOverFlowVertexZ++;
    if ( mult < fMult[0] ) fUnderFlowMult++;
    if ( mult > fMult[1] ) fOverFlowMult++;
    return;
  }

  //****from AliFemtoSimpleAnalysis****

  fPicoEvent=0; // we will get a new pico event, if not prevent corr. fctn to access old pico event
  fNeventsProcessed++;

  // startup for EbyE 
  fFemtoParticleCut->EventBegin(hbtEvent);
  fFlowParticleCut->EventBegin(hbtEvent);
  fPairCut->EventBegin(hbtEvent);

  for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
    (*iter)->EventBegin(hbtEvent);
  }

  // event cut and event cut monitor
  bool tmpPassEvent = fEventCut->Pass(hbtEvent);
  if (!tmpPassEvent) 
    fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
  if (tmpPassEvent) {
    fPicoEvent = new AliFemtoPicoEvent; // this is what we will make pairs from and put in Mixing Buffer, no memory leak. we will delete picoevents when they come out of the mixing buffer
    FillHbtParticleCollection(fFemtoParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->FirstParticleCollection());
    FillHbtParticleCollection(fFlowParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->SecondParticleCollection());

    cout << "#particles in Collection: " << fPicoEvent->FirstParticleCollection()->size() << endl;
    
    //switch which allows only using events with ParticleCollections containing a minimum number of entries
    if (fPicoEvent->FirstParticleCollection()->size() >= fMinSizePartCollection ) {
      fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
    }

      //------ Make real pairs (assume identical) ------//
      MakePairs("real", fPicoEvent->FirstParticleCollection() );
      cout << "AliFemtoAnalysisAzimuthal::ProcessEvent() - reals done ";

      //---- Make pairs for mixed events, looping over events in mixingBuffer ----//
      AliFemtoPicoEvent* storedEvent;
      AliFemtoPicoEventIterator fPicoEventIter;
      for (fPicoEventIter=MixingBuffer()->begin();fPicoEventIter!=MixingBuffer()->end();fPicoEventIter++){
        storedEvent = *fPicoEventIter;
        MakePairs("mixed",fPicoEvent->FirstParticleCollection(),
                            storedEvent->FirstParticleCollection() );
      }
      cout << " - mixed done   " << endl;

      //--------- If mixing buffer is full, delete oldest event ---------//
      if ( MixingBufferFull() ) {
        delete MixingBuffer()->back();
        MixingBuffer()->pop_back();
      }

      //-------- Add current event (fPicoEvent) to mixing buffer --------//
      MixingBuffer()->push_front(fPicoEvent);

    }  // if ParticleCollections are big enough (mal jun2002)
    else{
      fEventCut->FillCutMonitor(hbtEvent, !tmpPassEvent);
      delete fPicoEvent;
    }

  // if currentEvent is accepted by currentAnalysis cleanup for EbyE 
  fFemtoParticleCut->EventEnd(hbtEvent);
  fFlowParticleCut->EventEnd(hbtEvent);
  fPairCut->EventEnd(hbtEvent);
  for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
    (*iter)->EventEnd(hbtEvent);
  } 
}

//_______________________________________________________________________________
void AliFemtoAnalysisAzimuthal::MakePairs(const char* typeIn, AliFemtoParticleCollection *partCollection1,
				       AliFemtoParticleCollection *partCollection2){
// Build pairs, check pair cuts, and call CFs' AddRealPair() or AddMixedPair() methods. 
// If no second particle collection is specfied, make pairs within first particle collection.

  string type = typeIn;

  //  int swpart = ((long int) partCollection1) % 2;
  int swpart = fNeventsProcessed % 2;

  AliFemtoPair* tPair = new AliFemtoPair;
  AliFemtoCorrFctnIterator tCorrFctnIter;
  AliFemtoParticleIterator tPartIter1, tPartIter2;

  AliFemtoParticleIterator tStartOuterLoop = partCollection1->begin();  // always
  AliFemtoParticleIterator tEndOuterLoop   = partCollection1->end();    // will be one less if identical
  AliFemtoParticleIterator tStartInnerLoop;
  AliFemtoParticleIterator tEndInnerLoop;
  if (partCollection2) {                         //   Two collections:
    tStartInnerLoop = partCollection2->begin();  //   Full inner & outer loops
    tEndInnerLoop   = partCollection2->end();    
  }
  else {                                         //   One collection:
    tEndOuterLoop--;                             //   Outer loop goes to next-to-last particle
    tEndInnerLoop = partCollection1->end() ;     //   Inner loop goes to last particle
  }
  for (tPartIter1=tStartOuterLoop;tPartIter1!=tEndOuterLoop;tPartIter1++) {
    if (!partCollection2){
      tStartInnerLoop = tPartIter1;
      tStartInnerLoop++;
    }
    tPair->SetTrack1(*tPartIter1);
    for (tPartIter2 = tStartInnerLoop; tPartIter2!=tEndInnerLoop;tPartIter2++) {
      tPair->SetTrack2(*tPartIter2);

//For getting the pair angle wrt EP
  if (type == "real"){
	TVector2 Q, QVector;
	float Psi=0, mQx=0, mQy=0, PairAngleEP=0;
	Q = GetQVector(partCollection1);

	mQx = Q.X() - cos(2*(tPair->Track1()->FourMomentum().Phi()))*(tPair->Track1()->Track()->Pt()) - cos(2*(tPair->Track2()->FourMomentum().Phi()))*(tPair->Track2()->Track()->Pt());
	mQy = Q.Y() - sin(2*(tPair->Track1()->FourMomentum().Phi()))*(tPair->Track1()->Track()->Pt()) - sin(2*(tPair->Track2()->FourMomentum().Phi()))*(tPair->Track2()->Track()->Pt());
  
	QVector.Set(mQx,mQy);

	Psi=QVector.Phi()/2.;
	if (Psi > TMath::Pi()) Psi -= TMath::Pi();

	PairAngleEP = (tPair->EmissionAngle() - Psi);
	tPair->SetPairAngleEP(PairAngleEP);
  }

  if (type == "mixed"){
	float Psi1=0, Psi2=0, mQx1=0, mQx2=0,mQy1=0, mQy2=0, px1=0, px2=0, py1=0, py2=0, PairAngleEP=0;
	TVector2 Q1, Q2, QVector1, QVector2, P;

	Q1 = GetQVector(partCollection1);
	Q2 = GetQVector(partCollection2);

	mQx1 = Q1.X() - cos(2*(tPair->Track1()->FourMomentum().Phi()))*(tPair->Track1()->Track()->Pt());
	mQx2 = Q2.X() - cos(2*(tPair->Track2()->FourMomentum().Phi()))*(tPair->Track2()->Track()->Pt());
	mQy1 = Q1.Y() - sin(2*(tPair->Track1()->FourMomentum().Phi()))*(tPair->Track1()->Track()->Pt());
	mQy2 = Q2.Y() - sin(2*(tPair->Track2()->FourMomentum().Phi()))*(tPair->Track2()->Track()->Pt());
  
	QVector1.Set(mQx1,mQy1);
	QVector2.Set(mQx2,mQy2);

	Psi1=QVector1.Phi()/2.;
	if (Psi1 > TMath::Pi()) Psi1 -= TMath::Pi();

	Psi2=QVector2.Phi()/2.;
	if (Psi2 > TMath::Pi()) Psi2 -= TMath::Pi();

	px1 = (tPair->Track1()->Track()->Pt())*cos(tPair->Track1()->FourMomentum().Phi() - Psi1);
	px2 = (tPair->Track2()->Track()->Pt())*cos(tPair->Track2()->FourMomentum().Phi() - Psi2);
	py1 = (tPair->Track1()->Track()->Pt())*sin(tPair->Track1()->FourMomentum().Phi() - Psi1);
	py2 = (tPair->Track2()->Track()->Pt())*sin(tPair->Track2()->FourMomentum().Phi() - Psi2);

	P.Set(px1+px2, py1+py2);
	PairAngleEP = P.Phi();

	tPair->SetPairAngleEP(PairAngleEP);
  }

      // The following lines have to be uncommented if you want pairCutMonitors
      // they are not in for speed reasons
      // bool tmpPassPair = fPairCut->Pass(tPair);
      // fPairCut->FillCutMonitor(tPair, tmpPassPair);
      // if ( tmpPassPair )

      //---- If pair passes cut, loop over CF's and add pair to real/mixed ----//

      if (!partCollection2) {
	if (swpart) {
 	  tPair->SetTrack1(*tPartIter2);
 	  tPair->SetTrack2(*tPartIter1);
 	  swpart = 0;
 	}
 	else {
 	  tPair->SetTrack1(*tPartIter1);
 	  tPair->SetTrack2(*tPartIter2);
 	  swpart = 1;
	}
      }


      if (fPairCut->Pass(tPair)){
        for (tCorrFctnIter=fCorrFctnCollection->begin();
             tCorrFctnIter!=fCorrFctnCollection->end();tCorrFctnIter++){
          AliFemtoCorrFctn* tCorrFctn = *tCorrFctnIter;
          if(type == "real")
            tCorrFctn->AddRealPair(tPair);
	  else if(type == "mixed")
            tCorrFctn->AddMixedPair(tPair);
          else
            cout << "Problem with pair type, type = " << type.c_str() << endl;
        }
      }
    }    // loop over second particle
  }      // loop over first particle

  delete tPair;
}

//_____________________________________________
TVector2 AliFemtoAnalysisAzimuthal::GetQVector(AliFemtoParticleCollection* particlecollection){
  
  TVector2 mQ;
  float mQx=0, mQy=0;

      AliFemtoParticle* flowparticle;
      AliFemtoParticleIterator pIter;
      AliFemtoParticleIterator startLoop = particlecollection->begin();
      AliFemtoParticleIterator endLoop   = particlecollection->end();
      for (pIter=startLoop;pIter!=endLoop;pIter++){
	flowparticle = *pIter;
	mQx += (cos(2*flowparticle->FourMomentum().Phi()))*(flowparticle->Track()->Pt());
	mQy += (sin(2*flowparticle->FourMomentum().Phi()))*(flowparticle->Track()->Pt());
      }

  mQ.Set(mQx,mQy);
  return mQ;
}

//__________________________________________________
double AliFemtoAnalysisAzimuthal::GetCurrentReactionPlane()
{
  return fPsi;
}

//_________________________
TList* AliFemtoAnalysisAzimuthal::GetOutputList()
{
  // Collect the list of output objects to be written

  TList *tOutputList = new TList();
  TList *p1Cut = fFemtoParticleCut->GetOutputList();

  TListIter nextp1(p1Cut);
  while (TObject *obj = nextp1.Next()) {
    tOutputList->Add(obj);
  }

  TList *pairCut = fPairCut->GetOutputList();

  TIter nextpair(pairCut);
  while (TObject *obj = nextpair()) {
    tOutputList->Add(obj);
  }

  TList *eventCut = fEventCut->GetOutputList();

  TIter nextevent(eventCut);
  while (TObject *obj = nextevent()) {
    tOutputList->Add(obj);
  }

  AliFemtoCorrFctnIterator iter;
  for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
    TList *tListCf = (*iter)->GetOutputList();
    
    TIter nextListCf(tListCf);
    while (TObject *obj = nextListCf()) {
      tOutputList->Add(obj);
    }
  }

  return tOutputList;
  
}
Commit	Line	Data
71f28971	1	////////////////////////////////////////////////////////////////////////////
	2	// //
	3	// AliFemtoAnalysisReactionPlane - Femtoscopic analysis which mixes event //
	4	// with respect to the z position of the primary vertex and event total //
	5	// multiplicity and uses only events in certain reaction plane angle bin //
	6	// //
	7	////////////////////////////////////////////////////////////////////////////
	8
	9	#include "AliFemtoAnalysisAzimuthal.h"
	10	#include <TMath.h>
	11	#include <string>
	12	#include <cstdio>
	13	#include "AliFemtoParticleCollection.h"
	14	#include "AliFemtoTrackCut.h"
	15	#include "AliFemtoV0Cut.h"
	16	#include "AliFemtoPairCut.h"
	17	#include "TVector2.h"
	18	#include "AliFemtoKinkCut.h"
	19	#include "AliFemtoPicoEventCollectionVector.h"
	20	#include "AliFemtoPicoEventCollectionVectorHideAway.h"
	21
	22	#ifdef __ROOT__
	23	ClassImp(AliFemtoAnalysisAzimuthal)
	24	#endif
	25
	26	extern void FillHbtParticleCollection(AliFemtoParticleCut* partCut,
	27	AliFemtoEvent* hbtEvent,
	28	AliFemtoParticleCollection* partCollection);
	29
	30
	31	//____________________________
	32	AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(unsigned int binsVertex, double minVertex, double maxVertex,
	33	unsigned int binsMult, double minMult, double maxMult, unsigned short binsRP)
	34	:
	35	fFemtoParticleCut(0),
	36	fFlowParticleCut(0),
	37	fPairCut(0),
	38	fEventCut(0),
	39	fVertexZBins(binsVertex),
	40	fOverFlowVertexZ(0),
	41	fUnderFlowVertexZ(0),
	42	fMultBins(binsMult) ,
	43	fOverFlowMult(0),
	44	fUnderFlowMult(0),
	45	fRPBins(binsRP),
	46	fPsi(0)
	47	{
	48	// mControlSwitch = 0;
	49	fCorrFctnCollection= 0;
	50	fCorrFctnCollection = new AliFemtoCorrFctnCollection;
	51	fVertexZ[0] = minVertex;
	52	fVertexZ[1] = maxVertex;
	53	fMult[0] = minMult;
	54	fMult[1] = maxMult;
	55	if (fMixingBuffer) delete fMixingBuffer;
	56	fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
	57	fMultBins,fMult[0],fMult[1],
	58	fRPBins,0.0,TMath::Pi());
	59	}
	60
	61	//____________________________
	62
	63	AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) :
	64	AliFemtoSimpleAnalysis(),
65	fFemtoParticleCut(0),
66	fFlowParticleCut(0),
67	fPairCut(0),
68	fEventCut(0),
69	fVertexZBins(a.fVertexZBins),
70	fOverFlowVertexZ(0),
71	fUnderFlowVertexZ(0),
72	fMultBins(a.fMultBins) ,
73	fOverFlowMult(0),
74	fUnderFlowMult(0),
75	fRPBins(a.fRPBins),
76	fPsi(0)
77
78	{
79	fCorrFctnCollection= 0;
80	fCorrFctnCollection = new AliFemtoCorrFctnCollection;
81	fVertexZ[0] = a.fVertexZ[0];
82	fVertexZ[1] = a.fVertexZ[1];
83	fMult[0] = a.fMult[0];
84	fMult[1] = a.fMult[1];
85	if (fMixingBuffer) delete fMixingBuffer;
86	fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
87	fMultBins,fMult[0],fMult[1],
88	fRPBins,0.0,TMath::Pi());
89	// find the right event cut
90	fEventCut = a.fEventCut->Clone();
91	// find the right femto particle cut
92	fFemtoParticleCut = a.fFemtoParticleCut->Clone();
93	// find the right flow particle cut
94	fFlowParticleCut = a.fFlowParticleCut->Clone();
95	// find the right pair cut
96	fPairCut = a.fPairCut->Clone();
97
98	if ( fEventCut ) {
99	SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
100	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - event cut set " << endl;
101	}
102	if ( fFemtoParticleCut ) {
103	SetFirstParticleCut(fFemtoParticleCut); // this will set the myAnalysis pointer inside the cut
104	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - femto particle cut set " << endl;
105	}
106	if ( fFlowParticleCut ) {
107	SetSecondParticleCut(fFlowParticleCut); // this will set the myAnalysis pointer inside the cut
108	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - flow particle cut set " << endl;
109	}
110	if ( fPairCut ) {
111	SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
112	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - pair cut set " << endl;
113	}
114
115	AliFemtoCorrFctnIterator iter;
116	for (iter=a.fCorrFctnCollection->begin(); iter!=a.fCorrFctnCollection->end();iter++){
117	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - looking for correlation functions " << endl;
118	AliFemtoCorrFctn* fctn = (*iter)->Clone();
119	if (fctn) AddCorrFctn(fctn);
120	else cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - correlation function not found " << endl;
121	}
122	fNumEventsToMix = a.fNumEventsToMix;
123	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - analysis copied " << endl;
124	}
125
04c4e5e1	126	AliFemtoAnalysisAzimuthal& AliFemtoAnalysisAzimuthal::operator=(const AliFemtoAnalysisAzimuthal& a)
	127	{
	128	// Assignment operator
	129	if (this == &a)
	130	return *this;
	131
	132	fCorrFctnCollection= 0;
	133	fCorrFctnCollection = new AliFemtoCorrFctnCollection;
	134	fVertexZ[0] = a.fVertexZ[0];
	135	fVertexZ[1] = a.fVertexZ[1];
	136	fMult[0] = a.fMult[0];
	137	fMult[1] = a.fMult[1];
	138	if (fMixingBuffer) delete fMixingBuffer;
	139	fPicoEventCollectionVectorHideAway = new AliFemtoPicoEventCollectionVectorHideAway(fVertexZBins,fVertexZ[0],fVertexZ[1],
	140	fMultBins,fMult[0],fMult[1],
	141	fRPBins,0.0,TMath::Pi());
	142	// find the right event cut
	143	fEventCut = a.fEventCut->Clone();
	144	// find the right femto particle cut
	145	fFemtoParticleCut = a.fFemtoParticleCut->Clone();
	146	// find the right flow particle cut
	147	fFlowParticleCut = a.fFlowParticleCut->Clone();
	148	// find the right pair cut
	149	fPairCut = a.fPairCut->Clone();
	150
	151	if ( fEventCut ) {
	152	SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
	153	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - event cut set " << endl;
	154	}
	155	if ( fFemtoParticleCut ) {
	156	SetFirstParticleCut(fFemtoParticleCut); // this will set the myAnalysis pointer inside the cut
	157	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - femto particle cut set " << endl;
	158	}
	159	if ( fFlowParticleCut ) {
	160	SetSecondParticleCut(fFlowParticleCut); // this will set the myAnalysis pointer inside the cut
	161	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - flow particle cut set " << endl;
	162	}
	163	if ( fPairCut ) {
	164	SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
	165	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - pair cut set " << endl;
	166	}
	167
	168	AliFemtoCorrFctnIterator iter;
	169	for (iter=a.fCorrFctnCollection->begin(); iter!=a.fCorrFctnCollection->end();iter++){
	170	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - looking for correlation functions " << endl;
	171	AliFemtoCorrFctn* fctn = (*iter)->Clone();
	172	if (fctn) AddCorrFctn(fctn);
	173	else cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - correlation function not found " << endl;
	174	}
	175	fNumEventsToMix = a.fNumEventsToMix;
	176	cout << " AliFemtoAnalysisAzimuthal::AliFemtoAnalysisAzimuthal(const AliFemtoAnalysisAzimuthal& a) - analysis copied " << endl;
	177
	178	return *this;
	179
	180	}
	181
71f28971	182	//____________________________
	183	AliFemtoAnalysisAzimuthal::~AliFemtoAnalysisAzimuthal(){
	184	// now delete every PicoEvent in the EventMixingBuffer and then the Buffer itself
	185	delete fPicoEventCollectionVectorHideAway;
	186	}
	187
	188	//_________________________
	189	void AliFemtoAnalysisAzimuthal::ProcessEvent(const AliFemtoEvent* hbtEvent) {
	190	// Perform event processing in bins of z vertex, multiplicity and Reaction Plane angle
	191	// cout << " AliFemtoAnalysisAzimuthal::ProcessEvent(const AliFemtoEvent* hbtEvent) " << endl;
	192
	193	// get right mixing buffer
	194	double vertexZ = hbtEvent->PrimVertPos().z();
	195	double mult = hbtEvent->UncorrectedNumberOfPrimaries();
	196	//double rpangle = GetQVector() // Not possible at the moment to get rpangle for mixing wrt RP
	197
	198	fMixingBuffer = fPicoEventCollectionVectorHideAway->PicoEventCollection(vertexZ,mult,fPsi);
	199	if (!fMixingBuffer) {
	200	if ( vertexZ < fVertexZ[0] ) fUnderFlowVertexZ++;
	201	if ( vertexZ > fVertexZ[1] ) fOverFlowVertexZ++;
	202	if ( mult < fMult[0] ) fUnderFlowMult++;
	203	if ( mult > fMult[1] ) fOverFlowMult++;
	204	return;
	205	}
	206
	207	//**from AliFemtoSimpleAnalysis**
	208
	209	fPicoEvent=0; // we will get a new pico event, if not prevent corr. fctn to access old pico event
	210	fNeventsProcessed++;
	211
	212	// startup for EbyE
	213	fFemtoParticleCut->EventBegin(hbtEvent);
	214	fFlowParticleCut->EventBegin(hbtEvent);
	215	fPairCut->EventBegin(hbtEvent);
	216
	217	for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
	218	(*iter)->EventBegin(hbtEvent);
	219	}
	220
	221	// event cut and event cut monitor
	222	bool tmpPassEvent = fEventCut->Pass(hbtEvent);
	223	if (!tmpPassEvent)
	224	fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
	225	if (tmpPassEvent) {
	226	fPicoEvent = new AliFemtoPicoEvent; // this is what we will make pairs from and put in Mixing Buffer, no memory leak. we will delete picoevents when they come out of the mixing buffer
	227	FillHbtParticleCollection(fFemtoParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->FirstParticleCollection());
	228	FillHbtParticleCollection(fFlowParticleCut,(AliFemtoEvent*)hbtEvent,fPicoEvent->SecondParticleCollection());
	229
	230	cout << "#particles in Collection: " << fPicoEvent->FirstParticleCollection()->size() << endl;
	231
	232	//switch which allows only using events with ParticleCollections containing a minimum number of entries
	233	if (fPicoEvent->FirstParticleCollection()->size() >= fMinSizePartCollection ) {
	234	fEventCut->FillCutMonitor(hbtEvent, tmpPassEvent);
	235	}
	236
	237	//------ Make real pairs (assume identical) ------//
	238	MakePairs("real", fPicoEvent->FirstParticleCollection() );
	239	cout << "AliFemtoAnalysisAzimuthal::ProcessEvent() - reals done ";
	240
	241	//---- Make pairs for mixed events, looping over events in mixingBuffer ----//
	242	AliFemtoPicoEvent* storedEvent;
	243	AliFemtoPicoEventIterator fPicoEventIter;
	244	for (fPicoEventIter=MixingBuffer()->begin();fPicoEventIter!=MixingBuffer()->end();fPicoEventIter++){
	245	storedEvent = *fPicoEventIter;
246	MakePairs("mixed",fPicoEvent->FirstParticleCollection(),
247	storedEvent->FirstParticleCollection() );
248	}
249	cout << " - mixed done " << endl;
250
251	//--------- If mixing buffer is full, delete oldest event ---------//
252	if ( MixingBufferFull() ) {
253	delete MixingBuffer()->back();
254	MixingBuffer()->pop_back();
255	}
256
257	//-------- Add current event (fPicoEvent) to mixing buffer --------//
258	MixingBuffer()->push_front(fPicoEvent);
259
260	} // if ParticleCollections are big enough (mal jun2002)
261	else{
262	fEventCut->FillCutMonitor(hbtEvent, !tmpPassEvent);
263	delete fPicoEvent;
264	}
265
266	// if currentEvent is accepted by currentAnalysis cleanup for EbyE
267	fFemtoParticleCut->EventEnd(hbtEvent);
268	fFlowParticleCut->EventEnd(hbtEvent);
269	fPairCut->EventEnd(hbtEvent);
270	for (AliFemtoCorrFctnIterator iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
271	(*iter)->EventEnd(hbtEvent);
272	}
273	}
274
275	//_______________________________________________________________________________
276	void AliFemtoAnalysisAzimuthal::MakePairs(const char* typeIn, AliFemtoParticleCollection *partCollection1,
277	AliFemtoParticleCollection *partCollection2){
278	// Build pairs, check pair cuts, and call CFs' AddRealPair() or AddMixedPair() methods.
279	// If no second particle collection is specfied, make pairs within first particle collection.
280
281	string type = typeIn;
282
283	// int swpart = ((long int) partCollection1) % 2;
284	int swpart = fNeventsProcessed % 2;
285
286	AliFemtoPair* tPair = new AliFemtoPair;
287	AliFemtoCorrFctnIterator tCorrFctnIter;
288	AliFemtoParticleIterator tPartIter1, tPartIter2;
289
290	AliFemtoParticleIterator tStartOuterLoop = partCollection1->begin(); // always
291	AliFemtoParticleIterator tEndOuterLoop = partCollection1->end(); // will be one less if identical
292	AliFemtoParticleIterator tStartInnerLoop;
293	AliFemtoParticleIterator tEndInnerLoop;
294	if (partCollection2) { // Two collections:
295	tStartInnerLoop = partCollection2->begin(); // Full inner & outer loops
296	tEndInnerLoop = partCollection2->end();
297	}
298	else { // One collection:
299	tEndOuterLoop--; // Outer loop goes to next-to-last particle
300	tEndInnerLoop = partCollection1->end() ; // Inner loop goes to last particle
301	}
302	for (tPartIter1=tStartOuterLoop;tPartIter1!=tEndOuterLoop;tPartIter1++) {
303	if (!partCollection2){
304	tStartInnerLoop = tPartIter1;
305	tStartInnerLoop++;
306	}
307	tPair->SetTrack1(*tPartIter1);
308	for (tPartIter2 = tStartInnerLoop; tPartIter2!=tEndInnerLoop;tPartIter2++) {
309	tPair->SetTrack2(*tPartIter2);
310
311	//For getting the pair angle wrt EP
312	if (type == "real"){
313	TVector2 Q, QVector;
314	float Psi=0, mQx=0, mQy=0, PairAngleEP=0;
315	Q = GetQVector(partCollection1);
316
317	mQx = Q.X() - cos(2(tPair->Track1()->FourMomentum().Phi()))(tPair->Track1()->Track()->Pt()) - cos(2(tPair->Track2()->FourMomentum().Phi()))(tPair->Track2()->Track()->Pt());
318	mQy = Q.Y() - sin(2(tPair->Track1()->FourMomentum().Phi()))(tPair->Track1()->Track()->Pt()) - sin(2(tPair->Track2()->FourMomentum().Phi()))(tPair->Track2()->Track()->Pt());
319
320	QVector.Set(mQx,mQy);
321
322	Psi=QVector.Phi()/2.;
323	if (Psi > TMath::Pi()) Psi -= TMath::Pi();
324
325	PairAngleEP = (tPair->EmissionAngle() - Psi);
326	tPair->SetPairAngleEP(PairAngleEP);
327	}
328
329	if (type == "mixed"){
330	float Psi1=0, Psi2=0, mQx1=0, mQx2=0,mQy1=0, mQy2=0, px1=0, px2=0, py1=0, py2=0, PairAngleEP=0;
331	TVector2 Q1, Q2, QVector1, QVector2, P;
332
333	Q1 = GetQVector(partCollection1);
334	Q2 = GetQVector(partCollection2);
335
336	mQx1 = Q1.X() - cos(2(tPair->Track1()->FourMomentum().Phi()))(tPair->Track1()->Track()->Pt());
337	mQx2 = Q2.X() - cos(2(tPair->Track2()->FourMomentum().Phi()))(tPair->Track2()->Track()->Pt());
338	mQy1 = Q1.Y() - sin(2(tPair->Track1()->FourMomentum().Phi()))(tPair->Track1()->Track()->Pt());
339	mQy2 = Q2.Y() - sin(2(tPair->Track2()->FourMomentum().Phi()))(tPair->Track2()->Track()->Pt());
340
341	QVector1.Set(mQx1,mQy1);
342	QVector2.Set(mQx2,mQy2);
343
344	Psi1=QVector1.Phi()/2.;
345	if (Psi1 > TMath::Pi()) Psi1 -= TMath::Pi();
346
347	Psi2=QVector2.Phi()/2.;
348	if (Psi2 > TMath::Pi()) Psi2 -= TMath::Pi();
349
350	px1 = (tPair->Track1()->Track()->Pt())*cos(tPair->Track1()->FourMomentum().Phi() - Psi1);
351	px2 = (tPair->Track2()->Track()->Pt())*cos(tPair->Track2()->FourMomentum().Phi() - Psi2);
352	py1 = (tPair->Track1()->Track()->Pt())*sin(tPair->Track1()->FourMomentum().Phi() - Psi1);
353	py2 = (tPair->Track2()->Track()->Pt())*sin(tPair->Track2()->FourMomentum().Phi() - Psi2);
354
355	P.Set(px1+px2, py1+py2);
356	PairAngleEP = P.Phi();
357
358	tPair->SetPairAngleEP(PairAngleEP);
359	}
360
361	// The following lines have to be uncommented if you want pairCutMonitors
362	// they are not in for speed reasons
363	// bool tmpPassPair = fPairCut->Pass(tPair);
364	// fPairCut->FillCutMonitor(tPair, tmpPassPair);
365	// if ( tmpPassPair )
366
367	//---- If pair passes cut, loop over CF's and add pair to real/mixed ----//
368
369	if (!partCollection2) {
370	if (swpart) {
371	tPair->SetTrack1(*tPartIter2);
372	tPair->SetTrack2(*tPartIter1);
373	swpart = 0;
374	}
375	else {
376	tPair->SetTrack1(*tPartIter1);
377	tPair->SetTrack2(*tPartIter2);
378	swpart = 1;
379	}
380	}
381
382
383	if (fPairCut->Pass(tPair)){
384	for (tCorrFctnIter=fCorrFctnCollection->begin();
385	tCorrFctnIter!=fCorrFctnCollection->end();tCorrFctnIter++){
386	AliFemtoCorrFctn* tCorrFctn = *tCorrFctnIter;
387	if(type == "real")
388	tCorrFctn->AddRealPair(tPair);
389	else if(type == "mixed")
390	tCorrFctn->AddMixedPair(tPair);
391	else
392	cout << "Problem with pair type, type = " << type.c_str() << endl;
393	}
394	}
395	} // loop over second particle
396	} // loop over first particle
397
398	delete tPair;
399	}
400
401	//_____________________________________________
402	TVector2 AliFemtoAnalysisAzimuthal::GetQVector(AliFemtoParticleCollection* particlecollection){
403
404	TVector2 mQ;
405	float mQx=0, mQy=0;
406
407	AliFemtoParticle* flowparticle;
408	AliFemtoParticleIterator pIter;
409	AliFemtoParticleIterator startLoop = particlecollection->begin();
410	AliFemtoParticleIterator endLoop = particlecollection->end();
411	for (pIter=startLoop;pIter!=endLoop;pIter++){
412	flowparticle = *pIter;
413	mQx += (cos(2flowparticle->FourMomentum().Phi()))(flowparticle->Track()->Pt());
414	mQy += (sin(2flowparticle->FourMomentum().Phi()))(flowparticle->Track()->Pt());
415	}
416
417	mQ.Set(mQx,mQy);
418	return mQ;
419	}
420
421	//__________________________________________________
422	double AliFemtoAnalysisAzimuthal::GetCurrentReactionPlane()
423	{
424	return fPsi;
425	}
426
427	//_________________________
428	TList* AliFemtoAnalysisAzimuthal::GetOutputList()
429	{
430	// Collect the list of output objects to be written
431
432	TList *tOutputList = new TList();
433	TList *p1Cut = fFemtoParticleCut->GetOutputList();
434
435	TListIter nextp1(p1Cut);
436	while (TObject *obj = nextp1.Next()) {
437	tOutputList->Add(obj);
438	}
439
440	TList *pairCut = fPairCut->GetOutputList();
441
442	TIter nextpair(pairCut);
443	while (TObject *obj = nextpair()) {
444	tOutputList->Add(obj);
445	}
446
447	TList *eventCut = fEventCut->GetOutputList();
448
449	TIter nextevent(eventCut);
450	while (TObject *obj = nextevent()) {
451	tOutputList->Add(obj);
452	}
453
454	AliFemtoCorrFctnIterator iter;
455	for (iter=fCorrFctnCollection->begin(); iter!=fCorrFctnCollection->end();iter++){
456	TList tListCf = (iter)->GetOutputList();
457
458	TIter nextListCf(tListCf);
459	while (TObject *obj = nextListCf()) {
460	tOutputList->Add(obj);
461	}
462	}
463
464	return tOutputList;
465
466	}