Coding rule violations corrected.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Apr 2006 08:42:35 +0000 (08:42 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 27 Apr 2006 08:42:35 +0000 (08:42 +0000)
15 files changed:
FASTSIM/AliFastDetector.cxx
FASTSIM/AliFastDetector.h
FASTSIM/AliFastGlauber.cxx
FASTSIM/AliFastGlauber.h
FASTSIM/AliFastMuonTrackingAcc.cxx
FASTSIM/AliFastMuonTrackingAcc.h
FASTSIM/AliFastMuonTrackingEff.cxx
FASTSIM/AliFastMuonTrackingEff.h
FASTSIM/AliFastMuonTrackingRes.cxx
FASTSIM/AliFastMuonTrackingRes.h
FASTSIM/AliFastMuonTriggerEff.cxx
FASTSIM/AliFastMuonTriggerEff.h
FASTSIM/AliFastResponse.cxx
FASTSIM/AliFastResponse.h
FASTSIM/AliQuenchingWeights.cxx

index 57fb72e..1654092 100644 (file)
  **************************************************************************/
 
 /* $Id$ */
+//
+// Base class for fast simulation of a detctor
+// or a system of subdetectors.
+// The detector response is described by resolution and efficiency.
+// Author:
+// Andreas Morsch
+// andreas.morsch@cern.ch
 
 #include "AliFastDetector.h"
 #include "AliFastResponse.h"
@@ -44,6 +51,13 @@ AliFastDetector::AliFastDetector(char* Name, char* Title):
     fResponses    = new TList();
 }
 
+AliFastDetector::AliFastDetector(const AliFastDetector & det)
+    :TNamed(det)
+{
+// Copy constructor
+    det.Copy(*this);
+}
+
 AliFastDetector::~AliFastDetector()
 {
 // Destructor
@@ -93,6 +107,9 @@ void AliFastDetector::Init()
 
 Float_t AliFastDetector::EvaluateEfficiency(AliFastParticle* part)
 {
+//
+//  Evaluate the efficiency for detecting particle part
+//
     TIter nextDet(fSubdetectors);
     AliFastDetector *det;
     //
@@ -194,3 +211,18 @@ AliFastResponse*  AliFastDetector::NextResponse()
 }
 
 
+AliFastDetector& AliFastDetector::operator=(const  AliFastDetector& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
+
+void AliFastDetector::Copy(TObject&) const
+{
+    //
+    // Copy 
+    //
+    Fatal("Copy","Not implemented!\n");
+}
+
index 2ee1186..82c646f 100644 (file)
@@ -5,6 +5,14 @@
 
 /* $Id$ */
 
+//
+// Base class for fast simulation of a detctor
+// or a system of subdetectors.
+// The detector response is described by resolution and efficiency.
+// Author:
+// Andreas Morsch
+// andreas.morsch@cern.ch
+
 #include <TNamed.h>
 class TList;
 class TObjLink;
@@ -16,7 +24,8 @@ class AliFastDetector : public TNamed {
     
  public:
     AliFastDetector();
-    AliFastDetector(char* Name, char* Title);    
+    AliFastDetector(char* Name, char* Title);
+    AliFastDetector(const AliFastDetector& det);    
     virtual ~AliFastDetector();
     virtual void Init();
     virtual void SetGeometry(AliGeometry* geom) 
@@ -41,6 +50,9 @@ class AliFastDetector : public TNamed {
     AliFastDetector*  NextSubdetector();
     AliFastResponse*  FirstResponse();
     AliFastResponse*  NextResponse();
+    // Copy
+    AliFastDetector& operator=(const AliFastDetector & rhs);
+    void Copy(TObject&) const;
  protected:
     TList            *fSubdetectors;      // List of Subdetectors
     TList            *fResponses;         // Responses
index 7e74953..f9f52b4 100644 (file)
@@ -16,7 +16,7 @@
 /* $Id$ */
 //
 // Utility class to make simple Glauber type calculations 
-//           for SYMMTRIC collision geometries (AA):
+//           for SYMMETRIC collision geometries (AA):
 // Impact parameter, production points, reaction plane dependence
 //
 // The SimulateTrigger method can be used for simple MB and hard-process
@@ -88,8 +88,7 @@ Int_t AliFastGlauber::fgCounter = 0;
 
 AliFastGlauber::AliFastGlauber() : fName()
 {
-  //  Default Constructor
-  //
+  //  Default Constructor 
   fgCounter++;
   if(fgCounter>1)
     Error("AliFastGlauber","More than more instance (%d) is not supported, check your code!",fgCounter);
@@ -100,11 +99,18 @@ AliFastGlauber::AliFastGlauber() : fName()
   SetPbPbLHC();
 }
 
+AliFastGlauber::AliFastGlauber(const AliFastGlauber & gl)
+    :TObject(gl)
+{
+// Copy constructor
+    gl.Copy(*this);
+}
+
 AliFastGlauber::~AliFastGlauber()
 {
+// Destructor
   fgCounter--;
   for(Int_t k=0; k<40; k++) delete fgWAlmondFixedB[k];
-  //if(fgCounter==0) Reset();
 }
 
 void AliFastGlauber::SetAuAuRhic()
@@ -269,7 +275,7 @@ void AliFastGlauber::Init(Int_t mode)
   fgWPathLength->SetParameter(2, 0);     //Pathlength definition
 }
 
-void AliFastGlauber::Reset()
+void AliFastGlauber::Reset() const
 {
   //
   // Reset dynamic allocated formulas
@@ -332,7 +338,7 @@ void AliFastGlauber::DrawOverlap() const
   TCanvas *c2 = new TCanvas("c2","Overlap",400,10,600,700);
   c2->cd();
   Double_t max=fgWStaa->GetMaximum(0,fgBMax)*1.01;
-  TH2F *h2f=new TH2F("h2ftaa","Overlap function: T_{AB} [mbarn^{-1}]",2,0,fgBMax,2,0,max);
+  TH2F *h2f=new TH2F("h2ftaa","Overlap function: T_{AB} [mbarn^{-1}]",2,0,fgBMax,2,0, max);
   h2f->SetStats(0);
   h2f->GetXaxis()->SetTitle("b [fm]");
   h2f->GetYaxis()->SetTitle("T_{AB} [mbarn^{-1}]");
@@ -682,8 +688,11 @@ Double_t AliFastGlauber::WStaa(Double_t* x, Double_t* par)
   //  MC Integration
   //
   Double_t y = 0;
+  
+
   for (Int_t i = 0; i < fgkMCInts; i++)
     {
+       
       const Double_t kphi = TMath::Pi() * gRandom->Rndm();
       const Double_t kb1  = fgBMax      * gRandom->Rndm();     
       y += fgWStarfi->Eval(kb1, kphi);
@@ -1000,6 +1009,44 @@ Double_t AliFastGlauber::Binaries(Double_t b) const
   return fgWSN->Eval(b)/fgWSN->Eval(1e-4);
 }
 
+Double_t AliFastGlauber::MeanOverlap(Double_t b1, Double_t b2)
+{
+//
+// Calculate the mean overlap for impact parameter range b1 .. b2
+//
+    Double_t sum  = 0.;
+    Double_t sumc = 0.;
+    Double_t b    = b1;
+    
+    while (b < b2-0.005) {
+       Double_t  nc = GetNumberOfCollisions(b);
+       sum  += 10. * fgWStaa->Eval(b) * fgWSgeo->Eval(b) * 0.01 / (1. - TMath::Exp(-nc));
+       sumc += 10. * fgWSgeo->Eval(b) * 0.01;
+       b += 0.01;
+    }
+    return (sum / CrossSection(b1, b2));
+}
+
+
+Double_t AliFastGlauber::MeanNumberOfCollisionsPerEvent(Double_t b1, Double_t b2)
+{
+//
+// Calculate the mean number of collisions per event for impact parameter range b1 .. b2
+//
+    Double_t sum  = 0.;
+    Double_t sumc = 0.;
+    Double_t b    = b1;
+    
+    while (b < b2-0.005) {
+       Double_t  nc = GetNumberOfCollisions(b);
+       sum  += nc / (1. - TMath::Exp(-nc)) * 10. * fgWSgeo->Eval(b) * 0.01;
+       sumc += 10. * fgWSgeo->Eval(b) * 0.01;
+       b += 0.01;
+    }
+    return (sum / CrossSection(b1, b2));
+}
+
+
 Double_t AliFastGlauber::GetNumberOfBinaries(Double_t b) const
 {
   //
@@ -1764,3 +1811,18 @@ void AliFastGlauber::PlotI0I1B2BDistr(Int_t n,Double_t ellCut,
   return;
 }
 
+AliFastGlauber& AliFastGlauber::operator=(const  AliFastGlauber& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
+
+void AliFastGlauber::Copy(TObject&) const
+{
+    //
+    // Copy 
+    //
+    Fatal("Copy","Not implemented!\n");
+}
+
index 6cfe4cb..0036b27 100644 (file)
@@ -4,20 +4,22 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
-//
+
 // Utility class to make simple Glauber type calculations for collision geometries:
 // Impact parameter, production points, reaction plane dependence
-//
-// Author: andreas.morsch@cern.ch
+// Author: Andreas Morsch
+// andreas.morsch@cern.ch
 
 #include <TObject.h>
 #include <TString.h>
-#include <TF2.h>
 class TF1;
+class TF2;
+
 
 class AliFastGlauber : public TObject {
  public:
     AliFastGlauber();
+    AliFastGlauber(const AliFastGlauber& glauber);
     virtual ~AliFastGlauber();
     void Init(Int_t mode = 0);
 
@@ -26,7 +28,7 @@ class AliFastGlauber : public TObject {
     void SetWoodSaxonParametersAu()
        {fWSr0 = 6.38; fWSd = 0.535; fWSw = 0.; fWSn = 8.59e-4;}
     void SetWoodSaxonParametersPb()
-       {fWSr0 = 6.624; fWSd = 0.549; fWSw = 0.; fWSn = 7.69e-4;}
+       {fWSr0 = 6.78; fWSd = 0.54; fWSw = 0.; fWSn = 7.14e-4;}
     void SetMaxImpact(Float_t bmax = 20.) {fgBMax = bmax;};
     void SetHardCrossSection(Float_t xs = 1.0) {fSigmaHard = xs;}
     void SetNNCrossSection  (Float_t xs = 55.6) {fSigmaNN = xs;}
@@ -91,6 +93,8 @@ class AliFastGlauber : public TObject {
     Double_t GetNumberOfParticipants(Double_t  b) const;
     Double_t GetNumberOfCollisions(Double_t  b)   const;
     Double_t GetNumberOfCollisionsPerEvent(Double_t  b) const;
+    Double_t MeanOverlap(Double_t b1, Double_t b2);
+    Double_t MeanNumberOfCollisionsPerEvent(Double_t b1, Double_t b2);
     void SimulateTrigger(Int_t n);
     void GetRandom(Float_t& b, Float_t& p, Float_t& mult);
     void GetRandom(Int_t& bin, Bool_t& hard);
@@ -152,6 +156,9 @@ class AliFastGlauber : public TObject {
     void PlotI0I1B2BDistr(Int_t n=1000,Double_t ellCut=20.,Bool_t save=kFALSE,
                          const char *fname="i0i1B2B.root");
     void PlotAlmonds() const;
+    // Copy
+    AliFastGlauber& operator=(const AliFastGlauber & rhs);
+    void Copy(TObject&) const;
  protected:
     static Double_t WSb            (Double_t *xx, Double_t *par);
     static Double_t WSbz           (Double_t *xx, Double_t *par);
@@ -170,7 +177,7 @@ class AliFastGlauber : public TObject {
     static Double_t WIntRadius     (Double_t *xx, Double_t *par);
     static Double_t WEnergyDensity (Double_t *xx, Double_t *par);
 
-    void Reset();
+    void Reset() const;
 
     static Float_t fgBMax;           // Maximum Impact Parameter
     static Int_t fgCounter;          // Counter to protect double instantiation
index 7bad84e..5452347 100644 (file)
 
 /* $Id$ */
 
+// Realisation of AliFastResponse for the
+// fast simulation of the muon spectrometer acceptance.
+// The acceptance depends on the muon 3-vector which can be passed as (pt, theta, phi), 
+// where pt is the transverse momentum, theta the polar angle and phi the azimuthal angle.
+// Author: Andreas Morsch
+// andreas.morsch@cern.ch 
+
 #include "AliFastMuonTrackingAcc.h"
 #include "AliMUONFastTracking.h"
 
@@ -27,6 +34,13 @@ AliFastMuonTrackingAcc::AliFastMuonTrackingAcc() :
     SetBackground();
 }
 
+AliFastMuonTrackingAcc::AliFastMuonTrackingAcc(const AliFastMuonTrackingAcc & acc)
+    :AliFastResponse(acc)
+{
+// Copy constructor
+    acc.Copy(*this);
+}
+
 void AliFastMuonTrackingAcc::Init()
 {
     fFastTracking = AliMUONFastTracking::Instance();
@@ -37,7 +51,15 @@ void AliFastMuonTrackingAcc::Init()
 
 Float_t AliFastMuonTrackingAcc::Evaluate(Float_t pt, Float_t theta, Float_t phi)
 {
+// Evaluate the tracking acceptance for 3-vector pt, theta, phi
     Float_t p = pt / TMath::Sin(theta*TMath::Pi()/180.);
     Float_t eff =  fFastTracking->Acceptance(p, theta, phi, Int_t(fCharge));
     return eff;
 }
+
+AliFastMuonTrackingAcc& AliFastMuonTrackingAcc::operator=(const  AliFastMuonTrackingAcc& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
index c0bda33..9d8f012 100644 (file)
@@ -1,17 +1,25 @@
-#ifndef ALIFASTMUONTRACKINGACC
-#define ALIFASTMUONTRACKINGACC
+#ifndef ALIFASTMUONTRACKINGACC_H
+#define ALIFASTMUONTRACKINGACC_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
 
+// Realisation of AliFastResponse for the
+// fast simulation of the muon spectrometer acceptance.
+// The acceptance depends on the muon 3-vector which can be passed as (pt, theta, phi), 
+// where pt is the transverse momentum, theta the polar angle and phi the azimuthal angle.
+// Author: Andreas Morsch
+// andreas.morsch@cern.ch 
+
 #include "AliFastResponse.h"
 class AliMUONFastTracking;
 
 class AliFastMuonTrackingAcc :  public AliFastResponse {
  public:
     AliFastMuonTrackingAcc();
-    ~AliFastMuonTrackingAcc(){;}
+    AliFastMuonTrackingAcc(const AliFastMuonTrackingAcc& acc);
+    virtual ~AliFastMuonTrackingAcc(){;}
     void SetBackground(Float_t bg = 1.) {fBackground = bg;}
     void SetCharge(Float_t charge = 1.) {fCharge     = charge;}
     virtual void Init();
@@ -23,6 +31,8 @@ class AliFastMuonTrackingAcc :  public AliFastResponse {
     virtual Float_t Evaluate(AliFastParticle* part) {
       return AliFastResponse::Evaluate(part);
     }
+     // Copy
+    AliFastMuonTrackingAcc& operator=(const AliFastMuonTrackingAcc& rhs);
  protected:
     Float_t              fBackground;   // Background level
     Float_t              fCharge;       // Current charge
index 4aa0419..053bcac 100644 (file)
  **************************************************************************/
 
 /* $Id$ */
-
+//
+// Class for fast simulation of the ALICE Muon Spectrometer
+// Tracking Efficiency.
+// The efficiency depends on trasverse momentum pt, polar angle theta and azimuthal angle phi.
+//
+// Author: Alessandro de Falco 
+// alessandro.de.falco@ca.infn.it
+// 
 #include "AliFastMuonTrackingEff.h"
 #include "AliMUONFastTracking.h"
 
@@ -24,11 +31,22 @@ ClassImp(AliFastMuonTrackingEff)
 AliFastMuonTrackingEff::AliFastMuonTrackingEff() :
     AliFastResponse("Efficiency", "Muon Tracking Efficiency")
 {
+//
+// Constructor
     SetBackground();
 }
 
+AliFastMuonTrackingEff::AliFastMuonTrackingEff(const AliFastMuonTrackingEff& eff)
+    :AliFastResponse(eff)
+{
+// Copy constructor
+    eff.Copy(*this);
+}
+
 void AliFastMuonTrackingEff::Init()
 {
+//
+// Initialization
     fFastTracking = AliMUONFastTracking::Instance();
     fFastTracking->Init(fBackground);
 }
@@ -37,7 +55,17 @@ void AliFastMuonTrackingEff::Init()
 
 Float_t AliFastMuonTrackingEff::Evaluate(Float_t pt, Float_t theta, Float_t phi)
 {
+//
+// Evaluate the efficience for muon with 3-vector (pt, theta, phi)
     Float_t p = pt / TMath::Sin(theta*TMath::Pi()/180.);
     Float_t eff =  fFastTracking->Efficiency(p, theta, phi, Int_t(fCharge));
     return eff;
 }
+
+AliFastMuonTrackingEff& AliFastMuonTrackingEff::operator=(const  AliFastMuonTrackingEff& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
+
index d6dcaad..087ce8b 100644 (file)
@@ -1,9 +1,16 @@
-#ifndef ALIFASTMUONTRACKINGEFF
-#define ALIFASTMUONTRACKINGEFF
+#ifndef ALIFASTMUONTRACKINGEFF_H
+#define ALIFASTMUONTRACKINGEFF_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+//
+// Class for fast simulation of the ALICE Muon Spectrometer
+// Tracking Efficiency.
+// The efficiency depends on trasverse momentum pt, polar angle theta and azimuthal angle phi.
+//
+// Author: Alessandro de Falco 
+// alessandro.de.falco@ca.infn.it
 
 #include "AliFastResponse.h"
 class AliMUONFastTracking;
@@ -11,7 +18,8 @@ class AliMUONFastTracking;
 class AliFastMuonTrackingEff :  public AliFastResponse {
  public:
     AliFastMuonTrackingEff();
-    ~AliFastMuonTrackingEff(){;}
+    virtual ~AliFastMuonTrackingEff(){;}
+    AliFastMuonTrackingEff(const AliFastMuonTrackingEff& eff);
     void SetBackground(Float_t bg = 1.) {fBackground = bg;}
     void SetCharge(Float_t charge = 1.) {fCharge     = charge;}
     virtual void Init();
@@ -23,6 +31,8 @@ class AliFastMuonTrackingEff :  public AliFastResponse {
     virtual Float_t Evaluate(AliFastParticle* part) {
       return AliFastResponse::Evaluate(part);
     }
+     // Copy
+    AliFastMuonTrackingEff& operator=(const AliFastMuonTrackingEff& rhs);
  protected:
     Float_t              fBackground;   // Background level
     Float_t              fCharge;       // Current charge
index c86a4ed..8748f6d 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.6  2003/11/13 14:21:57  morsch
-Coding Rule violation corrections.
-
-Revision 1.5  2003/08/13 17:37:29  hristov
-Bug fix (Alpha)
-
-Revision 1.4  2003/08/05 16:14:20  morsch
-Some problems with too big fluctuations corrected. (A. de Falco)
-
-Revision 1.1  2003/01/06 10:13:09  morsch
-First commit.
-
-*/
+/* $Id: */
 
 // Implementation of AliFastResponse for the Muon Spectrometer resolution.
 // The response depends on the charge of the muon and
@@ -51,6 +37,13 @@ AliFastMuonTrackingRes::AliFastMuonTrackingRes() :
     SetBackground();
 }
 
+AliFastMuonTrackingRes::AliFastMuonTrackingRes(const AliFastMuonTrackingRes & res)
+    :AliFastResponse(res)
+{
+// Copy constructor
+    res.Copy(*this);
+}
+
 void AliFastMuonTrackingRes::Init()
 {
 // Initialisation
@@ -131,7 +124,12 @@ void AliFastMuonTrackingRes::Evaluate(Float_t   p,  Float_t  theta , Float_t   p
     thetaS = theta + gRandom->Gaus(meantheta,sigmatheta);
 }
 
-
+AliFastMuonTrackingRes& AliFastMuonTrackingRes::operator=(const  AliFastMuonTrackingRes& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
 
 
 
index 64426b7..5f7ff8e 100644 (file)
@@ -6,14 +6,19 @@
 /* $Id$ */
 
 // Implementation of AliFastResponse for the Muon Spectrometer resolution.
+// The response depends on the charge of the muon and
+// the background level.
+// The class uses the instance of an object of type AliMUONFastTracking to 
+// obtain the smearing parameters.
 // Author: andreas.morsch@cern.ch
-//
+
 #include "AliFastResponse.h"
 class AliMUONFastTracking;
 
 class AliFastMuonTrackingRes :  public AliFastResponse {
  public:
     AliFastMuonTrackingRes();
+    AliFastMuonTrackingRes(const AliFastMuonTrackingRes& glauber);
     virtual ~AliFastMuonTrackingRes(){;}
     void SetBackground(Float_t bg = 1.) {fBackground = bg;}
     void SetCharge(Float_t charge = 1.) {fCharge     = charge;}
@@ -26,6 +31,9 @@ class AliFastMuonTrackingRes :  public AliFastResponse {
     virtual Float_t Evaluate(Float_t  pt,  Float_t  theta , Float_t   phi) {
       return AliFastResponse::Evaluate(pt,theta,phi);
     }
+      // Copy
+    AliFastMuonTrackingRes& operator=(const AliFastMuonTrackingRes & rhs);
+
  protected:
     Float_t              fBackground;   // Background level
     Float_t              fCharge;       // Current charge
index b4371ff..8940c91 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-The trigger parametrization is computed for background levels 0., 0.5 and 1.
-In order to set a background level different from 0 it is necessary to 
-explicitly force it with:
-ForceBkgLevel(BkgLevel).
+/* $Id$ */
+// The trigger parametrization is computed for background levels 0., 0.5 and 1.
+// In order to set a background level different from 0 it is necessary to 
+// explicitly force it with:
+// ForceBkgLevel(BkgLevel).
+// For intermediate background levels, the trigger response is linearly 
+// interpolated between these values.
+// There is increased granularity in the pT region below 3 GeV. Although
+// it does not seem to be necessary it is also possible to interpolate
+// between pT bins using SetInt().
 
-For intermediate background levels, the trigger response is linearly 
-interpolated between these values.
-
-There is increased granularity in the pT region below 3 GeV. Although
-it does not seem to be necessary it is also possible to interpolate
-between pT bins using SetInt().
-
-$Log$
-Revision 1.10  2006/04/19 21:58:28  morsch
-Coding rule violations corrected
-
-Revision 1.9  2005/09/24 03:51:43  hristov
-Removing extra semicolon (Fedora Core 4)
-
-Revision 1.8  2005/09/22 11:31:42  morsch
-Completely revised version. (P. Cortese)
-
-*/
 
 #include "AliFastMuonTriggerEff.h"
 #include "TROOT.h"
@@ -61,6 +48,13 @@ AliFastMuonTriggerEff::AliFastMuonTriggerEff():
     UnsetInt();
 }
 
+AliFastMuonTriggerEff::AliFastMuonTriggerEff(const AliFastMuonTriggerEff& eff)
+    :AliFastResponse(eff)
+{
+// Copy constructor
+    eff.Copy(*this);
+}
+
 void AliFastMuonTriggerEff::SetCut(Int_t cut) 
 {  
   //
@@ -458,3 +452,11 @@ Float_t AliFastMuonTriggerEff::Evaluate(Float_t charge, Float_t pt,
 
     return eff;
 }
+
+AliFastMuonTriggerEff& AliFastMuonTriggerEff::operator=(const  AliFastMuonTriggerEff& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
+
index b0a03f1..5365122 100644 (file)
@@ -4,6 +4,16 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Class for the fast simulation of the muon trigger efficiency
+// The trigger parametrization is computed for background levels 0., 0.5 and 1.
+// In order to set a background level different from 0 it is necessary to 
+// explicitly force it with:
+// ForceBkgLevel(BkgLevel).
+// For intermediate background levels, the trigger response is linearly 
+// interpolated between these values.
+// There is increased granularity in the pT region below 3 GeV. Although
+// it does not seem to be necessary it is also possible to interpolate
+// between pT bins using SetInt().
 
 #include <AliFastResponse.h>
 #include <TString.h>
@@ -21,20 +31,23 @@ class AliFastMuonTriggerEff : public AliFastResponse {
  public:
     AliFastMuonTriggerEff();
     AliFastMuonTriggerEff(const char* /*Name*/, const char* /*Title*/) {;}
+    AliFastMuonTriggerEff(const AliFastMuonTriggerEff& eff);
     virtual ~AliFastMuonTriggerEff(){;}
     virtual void    Init();
     virtual void    Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi,
                             Float_t& effLow, Float_t& effHigh, Float_t& effAny);
     virtual Float_t Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi);
     virtual void    SetCut(Int_t cut = kLow);
-    virtual Float_t Cut() {return fCut;}
+    virtual Float_t Cut() const {return fCut;}
     virtual Int_t   SetBkgLevel(Float_t Bkg=0.);
     virtual Int_t   ForceBkgLevel(Float_t Bkg=0.);
-    virtual Float_t GetBkgLevel() {return fBkg;}
+    virtual Float_t GetBkgLevel() const {return fBkg;}
     Int_t LoadTables(Char_t *namet);  // Load trigger response tables
     void SetInt() {fInt=1;}
     void UnsetInt() {fInt=0;}
-    Int_t GetInt() {return fInt;}
+    Int_t GetInt() const {return fInt;}
+    // Copy
+    AliFastMuonTriggerEff& operator=(const AliFastMuonTriggerEff& rhs);
   protected:
     Double_t fPtMin;               // Minimun pt
     Double_t fPtMax;               // Maximum pt
index fef1a69..60331e1 100644 (file)
 
 /* $Id$ */
 
+// Basic implementation of a fast detector response. 
+// The 3-vector of the particle can be passes as
+// a TParticle or as
+// transverse momentum pt, polar angle theta and azimuthal angle phi
+// Author: Andreas Morsch
+// andreas.morsch@cern.ch
+//
 #include "AliFastResponse.h"
 #include "AliFastParticle.h"
 
@@ -44,3 +51,11 @@ void AliFastResponse::Evaluate(Float_t   p,  Float_t  theta , Float_t   phi,
     phiS   = phi;
 }
 
+void AliFastResponse::Copy(TObject&) const
+{
+    //
+    // Copy 
+    //
+    Fatal("Copy","Not implemented!\n");
+}
+
index 0f90474..f2eed04 100644 (file)
@@ -5,6 +5,13 @@
 
 /* $Id$ */
 
+// Base class for fast detector response simulation. 
+// The 3-vector of the particle can be passes as
+// a TParticle or as
+// transverse momentum pt, polar angle theta and azimuthal angle phi
+// Author: Andreas Morsch
+// andreas.morsch@cern.ch
+
 #include <TNamed.h>
 class AliFastParticle;
 
@@ -20,6 +27,7 @@ class AliFastResponse : public TNamed {
     virtual void    Evaluate(Float_t   p,  Float_t  theta , Float_t   phi,
                             Float_t& pS,  Float_t& thetaS, Float_t&  phiS);
     virtual Float_t Evaluate(AliFastParticle* part);
+    void Copy(TObject&) const;
  protected:
     ClassDef(AliFastResponse,1)    // Base class for fast response
 };
index 5728582..0805294 100644 (file)
 
 /* $Id$ */
 
-//----------------------------------------------------------------------------
-//     Implementation of the class to calculate the parton energy loss
-//  Based on the "BDMPS" quenching weights by C.A.Salgado and U.A.Wiedemann
-//
-//  References:
-//   C.A.Salgado and U.A.Wiedemann, Phys.Rev.D68 (2003) 014008 [hep-ph/0302184]
-//   A.Dainese, Eur.Phys.J.C, in press, [nucl-ex/0312005]             
+
+// Implementation of the class to calculate the parton energy loss
+// Based on the "BDMPS" quenching weights by C.A.Salgado and U.A.Wiedemann
+// References:
+// C.A.Salgado and U.A.Wiedemann, Phys.Rev.D68 (2003) 014008 [hep-ph/0302184]
+// A.Dainese, Eur.Phys.J.C, in press, [nucl-ex/0312005]             
 //
 //
 //            Origin:  C. Loizides   constantinos.loizides@cern.ch
@@ -29,8 +28,8 @@
 //
 //=================== Added by C. Loizides 27/03/04 ===========================
 //
-//  Added support for k-Quenching, where wc=I1*k and R=2I1^2/I0*k
-//  (see the AliFastGlauber class for definition of I0/I1)
+// Added support for k-Quenching, where wc=I1*k and R=2I1^2/I0*k
+// (see the AliFastGlauber class for definition of I0/I1)
 //-----------------------------------------------------------------------------
 
 #include <Riostream.h>
@@ -816,15 +815,15 @@ Int_t AliQuenchingWeights::CalcSingleHard(Int_t ipart,
 
 Double_t AliQuenchingWeights::CalcR(Double_t wc, Double_t l) const 
 { 
-  //calculate R value and 
+  //calculate r value and 
   //check if it is less then maximum
 
-  Double_t R = wc*l*fgkConvFmToInvGeV;
-  if(R>=fgkRMax) {
-    Warning("CalcR","Value of R = %.2f; should be less than %.2f",R,fgkRMax);
+  Double_t r = wc*l*fgkConvFmToInvGeV;
+  if(r >= fgkRMax) {
+    Warning("CalcR","Value of r = %.2f; should be less than %.2f", r, fgkRMax);
     return fgkRMax-1;
   }  
-  return R;
+  return r;
 }
 
 Double_t AliQuenchingWeights::CalcRk(Double_t k, Double_t I0, Double_t I1) const
@@ -832,14 +831,14 @@ Double_t AliQuenchingWeights::CalcRk(Double_t k, Double_t I0, Double_t I1) const
   //calculate R value and 
   //check if it is less then maximum
 
-  Double_t R = fgkRMax-1;
+  Double_t r = fgkRMax-1;
   if(I0>0)
-    R = 2*I1*I1/I0*k;
-  if(R>=fgkRMax) {
-    Warning("CalcRk","Value of R = %.2f; should be less than %.2f",R,fgkRMax);
+    r = 2*I1*I1/I0*k;
+  if(r>=fgkRMax) {
+    Warning("CalcRk","Value of r = %.2f; should be less than %.2f",r,fgkRMax);
     return fgkRMax-1;
   }  
-  return R;
+  return r;
 }
 
 Double_t AliQuenchingWeights::GetELossRandom(Int_t ipart, Double_t length, Double_t e) const