changed behavior cut on integer values

[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommon / AliFlowTrackSimple.cxx

diff --git a/PWG2/FLOW/AliFlowCommon/AliFlowTrackSimple.cxx b/PWG2/FLOW/AliFlowCommon/AliFlowTrackSimple.cxx
index 528ff59814fa09b4c5fa6c8145abd94123a2246a..0a3598f93980103b9c7d6bd8a9022dd364ad922f 100644 (file)
--- a/PWG2/FLOW/AliFlowCommon/AliFlowTrackSimple.cxx
+++ b/PWG2/FLOW/AliFlowCommon/AliFlowTrackSimple.cxx
@@ -22,18 +22,37 @@
 // author: N. van der Kolk (kolk@nikhef.nl)
 // mods: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch)
 
-#include "TNamed.h"
+#include "TObject.h"
 #include "TParticle.h"
+#include "TParticlePDG.h"
 #include "AliFlowTrackSimple.h"
+#include "TRandom.h"
+#include "TMath.h"
 
 ClassImp(AliFlowTrackSimple)
 
 //-----------------------------------------------------------------------
-
 AliFlowTrackSimple::AliFlowTrackSimple():
+  TObject(),
   fEta(0),
   fPt(0),
   fPhi(0),
+  fTrackWeight(1.),
+  fCharge(0),
+  fFlowBits(0),
+  fSubEventBits(0)
+{
+  //constructor 
+}
+
+//-----------------------------------------------------------------------
+AliFlowTrackSimple::AliFlowTrackSimple(Double_t phi, Double_t eta, Double_t pt, Double_t weight, Int_t charge):
+  TObject(),
+  fEta(eta),
+  fPt(pt),
+  fPhi(phi),
+  fTrackWeight(weight),
+  fCharge(charge),
   fFlowBits(0),
   fSubEventBits(0)
 {
@@ -41,48 +60,204 @@ AliFlowTrackSimple::AliFlowTrackSimple():
 }
 
 //-----------------------------------------------------------------------
-AliFlowTrackSimple::AliFlowTrackSimple(const TParticle* p):
+AliFlowTrackSimple::AliFlowTrackSimple( TParticle* p ):
+  TObject(),
   fEta(p->Eta()),
   fPt(p->Pt()),
   fPhi(p->Phi()),
+  fTrackWeight(1.),
+  fCharge(0),
   fFlowBits(0),
   fSubEventBits(0)
 {
   //ctor
+  TParticlePDG* ppdg = p->GetPDG();
+  fCharge = TMath::Nint(ppdg->Charge()/3.0);
 }
 
 //-----------------------------------------------------------------------
-
 AliFlowTrackSimple::AliFlowTrackSimple(const AliFlowTrackSimple& aTrack):
-  TNamed(),
+  TObject(aTrack),
   fEta(aTrack.fEta),
   fPt(aTrack.fPt),
   fPhi(aTrack.fPhi),
+  fTrackWeight(aTrack.fTrackWeight),
+  fCharge(aTrack.fCharge),
   fFlowBits(aTrack.fFlowBits),
   fSubEventBits(aTrack.fSubEventBits)
 {
   //copy constructor 
 }
+
 //-----------------------------------------------------------------------
+AliFlowTrackSimple* AliFlowTrackSimple::Clone(const char* /*option*/) const
+{
+  //clone "constructor"
+  return new AliFlowTrackSimple(*this);
+}
 
+//-----------------------------------------------------------------------
 AliFlowTrackSimple& AliFlowTrackSimple::operator=(const AliFlowTrackSimple& aTrack)
 {
   fEta = aTrack.fEta;
   fPt = aTrack.fPt;
   fPhi = aTrack.fPhi;
+  fTrackWeight = aTrack.fTrackWeight;
+  fCharge = aTrack.fCharge;
   fFlowBits = aTrack.fFlowBits;
   fSubEventBits = aTrack.fSubEventBits;
 
   return *this;
-
 }
 
-
 //----------------------------------------------------------------------- 
-
 AliFlowTrackSimple::~AliFlowTrackSimple()
 {
   //destructor
   
 }
 
+//----------------------------------------------------------------------- 
+void AliFlowTrackSimple::ResolutionPt(Double_t res)
+{
+  //smear the pt by a gaussian with sigma=res
+  fPt += gRandom->Gaus(0.,res);
+}
+
+//----------------------------------------------------------------------- 
+void AliFlowTrackSimple::AddV1( Double_t v1,
+                                Double_t reactionPlaneAngle,
+                                Double_t precisionPhi,
+                                Int_t maxNumberOfIterations )
+{
+  //afterburner, adds v1, uses Newton-Raphson iteration
+  Double_t phi0=fPhi;
+  Double_t f=0.;
+  Double_t fp=0.;
+  Double_t phiprev=0.;
+
+  for (Int_t i=0; i<maxNumberOfIterations; i++)
+  {
+    phiprev=fPhi; //store last value for comparison
+    f =  fPhi-phi0+2.0*v1*TMath::Sin(fPhi-reactionPlaneAngle);
+    fp = 1.0+2.0*v1*TMath::Cos(fPhi-reactionPlaneAngle); //first derivative
+    fPhi -= f/fp;
+    if (TMath::AreEqualAbs(phiprev,fPhi,precisionPhi)) break;
+  }
+}
+
+//----------------------------------------------------------------------- 
+void AliFlowTrackSimple::AddV2( Double_t v2,
+                                Double_t reactionPlaneAngle,
+                                Double_t precisionPhi,
+                                Int_t maxNumberOfIterations )
+{
+  //afterburner, adds v2, uses Newton-Raphson iteration
+  Double_t phi0=fPhi;
+  Double_t f=0.;
+  Double_t fp=0.;
+  Double_t phiprev=0.;
+
+  for (Int_t i=0; i<maxNumberOfIterations; i++)
+  {
+    phiprev=fPhi; //store last value for comparison
+    f =  fPhi-phi0+v2*TMath::Sin(2.*(fPhi-reactionPlaneAngle));
+    fp = 1.0+2.0*v2*TMath::Cos(2.*(fPhi-reactionPlaneAngle)); //first derivative
+    fPhi -= f/fp;
+    if (TMath::AreEqualAbs(phiprev,fPhi,precisionPhi)) break;
+  }
+}
+
+//----------------------------------------------------------------------- 
+void AliFlowTrackSimple::AddV3( Double_t v3,
+                                Double_t reactionPlaneAngle,
+                                Double_t precisionPhi,
+                                Int_t maxNumberOfIterations )
+{
+  //afterburner, adds v3, uses Newton-Raphson iteration
+  Double_t phi0=fPhi;
+  Double_t f=0.;
+  Double_t fp=0.;
+  Double_t phiprev=0.;
+
+  for (Int_t i=0; i<maxNumberOfIterations; i++)
+  {
+    phiprev=fPhi; //store last value for comparison
+    f =  fPhi-phi0+2./3.*v3*TMath::Sin(3.*(fPhi-reactionPlaneAngle));
+    fp = 1.0+2.0*v3*TMath::Cos(3.*(fPhi-reactionPlaneAngle)); //first derivative
+    fPhi -= f/fp;
+    if (TMath::AreEqualAbs(phiprev,fPhi,precisionPhi)) break;
+  }
+}
+
+//----------------------------------------------------------------------- 
+void AliFlowTrackSimple::AddV4( Double_t v4,
+                                Double_t reactionPlaneAngle,
+                                Double_t precisionPhi,
+                                Int_t maxNumberOfIterations )
+{
+  //afterburner, adds v4, uses Newton-Raphson iteration
+  Double_t phi0=fPhi;
+  Double_t f=0.;
+  Double_t fp=0.;
+  Double_t phiprev=0.;
+
+  for (Int_t i=0; i<maxNumberOfIterations; i++)
+  {
+    phiprev=fPhi; //store last value for comparison
+    f =  fPhi-phi0+0.5*v4*TMath::Sin(4.*(fPhi-reactionPlaneAngle));
+    fp = 1.0+2.0*v4*TMath::Cos(4.*(fPhi-reactionPlaneAngle)); //first derivative
+    fPhi -= f/fp;
+    if (TMath::AreEqualAbs(phiprev,fPhi,precisionPhi)) break;
+  }
+}
+
+//______________________________________________________________________________
+void AliFlowTrackSimple::AddFlow( Double_t v1,
+                                  Double_t v2,
+                                  Double_t v3,
+                                  Double_t v4,
+                                  Double_t reactionPlaneAngle,
+                                  Double_t precisionPhi,
+                                  Int_t maxNumberOfIterations )
+{
+  //afterburner, adds v1,v2,v4 uses Newton-Raphson iteration
+  Double_t phi0=fPhi;
+  Double_t f=0.;
+  Double_t fp=0.;
+  Double_t phiprev=0.;
+
+  for (Int_t i=0; i<maxNumberOfIterations; i++)
+  {
+    phiprev=fPhi; //store last value for comparison
+    f =  fPhi-phi0
+        +2.0*  v1*TMath::Sin(    fPhi-reactionPlaneAngle)
+        +      v2*TMath::Sin(2.*(fPhi-reactionPlaneAngle))
+        +2./3.*v3*TMath::Sin(3.*(fPhi-reactionPlaneAngle))
+        +0.5*  v4*TMath::Sin(4.*(fPhi-reactionPlaneAngle))
+        ;
+    fp =  1.0
+         +2.0*(
+           +v1*TMath::Cos(    fPhi-reactionPlaneAngle)
+           +v2*TMath::Cos(2.*(fPhi-reactionPlaneAngle))
+           +v3*TMath::Cos(3.*(fPhi-reactionPlaneAngle))
+           +v4*TMath::Cos(4.*(fPhi-reactionPlaneAngle))
+         ); //first derivative
+    fPhi -= f/fp;
+    if (TMath::AreEqualAbs(phiprev,fPhi,precisionPhi)) break;
+  }
+}
+
+//______________________________________________________________________________
+void AliFlowTrackSimple::Print( Option_t* /*option*/ ) const
+{
+  //print stuff
+  printf("Phi: %.3f, Eta: %+.3f, Pt: %.3f, weight: %.3f",fPhi,fEta,fPt,fTrackWeight);
+  if (InRPSelection()) printf(", RP");
+  if (InPOISelection()) printf(", POI");
+  for (Int_t i=0; i<2; i++)
+  {
+    if (InSubevent(i)) printf(", subevent %i",i);
+  }
+  printf("\n");
+}