LHC related code. First commit.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Jul 2001 17:28:32 +0000 (17:28 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Jul 2001 17:28:32 +0000 (17:28 +0000)
18 files changed:
LHC/AliLHC.cxx [new file with mode: 0644]
LHC/AliLHC.h [new file with mode: 0644]
LHC/AliLhcBeam.cxx [new file with mode: 0644]
LHC/AliLhcBeam.h [new file with mode: 0644]
LHC/AliLhcIRegion.cxx [new file with mode: 0644]
LHC/AliLhcIRegion.h [new file with mode: 0644]
LHC/AliLhcMonitor.cxx [new file with mode: 0644]
LHC/AliLhcMonitor.h [new file with mode: 0644]
LHC/AliLhcProcess.cxx [new file with mode: 0644]
LHC/AliLhcProcess.h [new file with mode: 0644]
LHC/AliLhcProcessBB.cxx [new file with mode: 0644]
LHC/AliLhcProcessBB.h [new file with mode: 0644]
LHC/AliLhcProcessBT.cxx [new file with mode: 0644]
LHC/AliLhcProcessBT.h [new file with mode: 0644]
LHC/AliLhcProcessIBS.cxx [new file with mode: 0644]
LHC/AliLhcProcessIBS.h [new file with mode: 0644]
LHC/LHCLinkDef.h [new file with mode: 0644]
LHC/Makefile [new file with mode: 0644]

diff --git a/LHC/AliLHC.cxx b/LHC/AliLHC.cxx
new file mode 100644 (file)
index 0000000..9430f69
--- /dev/null
@@ -0,0 +1,176 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+#include "AliLHC.h"
+#include "AliLhcIRegion.h"
+#include "AliLhcProcess.h"
+#include "AliLhcBeam.h"
+
+ClassImp(AliLHC)
+
+AliLHC::AliLHC()
+{
+// Constructor
+    fIRegions   = new TList;
+    fProcesses  = new TList;
+    fNRegions   = 0;
+    fNProcesses = 0;
+    fBeams = new TObjArray(2);
+    (*fBeams)[0] = 0;
+    (*fBeams)[1] = 0;    
+    fTime = 0;
+    fTimeMax = 0;
+}
+
+AliLHC::AliLHC(const AliLHC& lhc)
+{
+// copy constructor
+}
+
+AliLHC::~AliLHC()
+{
+// Destructor
+    delete fIRegions;
+    delete fProcesses;
+    delete fBeams;
+}
+
+void AliLHC::AddIRegion(AliLhcIRegion *region)
+{
+//
+//  Add region to list   
+     fIRegions->Add(region);
+     fNRegions++;
+ }
+
+void AliLHC::AddProcess(AliLhcProcess *process)
+{
+//
+//  Add process to list   
+     fProcesses->Add(process);
+     fNProcesses++;
+ }
+
+void AliLHC::SetBeams(AliLhcBeam *beam1, AliLhcBeam *beam2 )
+{
+
+//
+//  Set the beams   
+
+    (*fBeams)[0] = beam1;
+    (*fBeams)[1] = beam2;
+}
+
+  void AliLHC::Init()
+{
+// Initialisation
+    fNt    = 0;
+    fNmax  = Int_t(fTimeMax/fTimeStep); 
+    fTimeA = new Float_t[fNmax];
+    //
+    Beam(0)->Init();
+    Beam(1)->Init();
+  
+    TIter next(fIRegions);
+    AliLhcIRegion *region;
+    //
+    // Loop over generators and initialize
+    while((region = (AliLhcIRegion*)next())) {
+       region->Init();
+       region->SetMonitor(fNmax);
+    }
+    
+    Beam(0)->SetMonitor(fNmax);
+    Beam(1)->SetMonitor(fNmax);
+
+    TIter nextp(fProcesses);
+    AliLhcProcess *process;
+    //
+    // Loop over generators and initialize
+    while((process = (AliLhcProcess*)nextp())) {
+       process->Init();
+       process->SetMonitor(fNmax);
+    }  
+}
+
+ void AliLHC::EvolveTime()
+{
+//
+// Simulate Time Evolution
+//
+    while (fTime <= fTimeMax) {
+       printf("\n Time: %f %f", fTime, fTimeStep);
+       //
+        //  Processes
+        //     
+       TIter next(fProcesses);
+       AliLhcProcess *process;
+       //
+       // Evolve for each process
+       while((process = (AliLhcProcess*)next())) {
+           process->Evolve(fTimeStep);
+           process->Record();
+       }  
+       //
+       // Update and Monitoring
+       //
+       TIter nextregion(fIRegions);
+       AliLhcIRegion *region;
+       //
+       while((region = (AliLhcIRegion*)nextregion())) {
+         printf("\n Region: %s, Luminosity %10.3e", 
+                region->GetName(), region->Luminosity());
+         region->Update();
+         region->Record();
+       }
+       Beam(0)->Record();
+       fTimeA[fNt] = fTime/3600.;
+       fTime+=fTimeStep;
+       fNt++;
+    }
+}
+
+void AliLHC::Evaluate()
+{
+  // Evaluation of the results
+  TIter nextregion(fIRegions);
+  AliLhcIRegion *region;
+  //
+  // Loop over generators and initialize
+  while((region = (AliLhcIRegion*)nextregion())) {
+    region->Draw();
+  }
+  
+  TIter next(fProcesses);
+  AliLhcProcess *process;
+  //
+  // Evolve for each process
+  while((process = (AliLhcProcess*)next())) {
+    process->Draw();
+  }
+  
+  Beam(0)->Draw();
+}
+   
+AliLHC& AliLHC::operator=(const  AliLHC & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+
diff --git a/LHC/AliLHC.h b/LHC/AliLHC.h
new file mode 100644 (file)
index 0000000..83786b6
--- /dev/null
@@ -0,0 +1,88 @@
+#ifndef ALILHC_H
+#define ALILHC_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include <TObject.h>
+#include <TList.h>
+#include <TObjArray.h>
+
+class AliLhcIRegion;
+class AliLhcProcess;
+class AliLhcBeam;
+
+
+class AliLHC : public TObject
+{
+ public:
+    AliLHC();
+    AliLHC(const AliLHC &lhc);
+    virtual ~AliLHC();
+
+    virtual void AddIRegion(AliLhcIRegion *region);
+    virtual void AddProcess(AliLhcProcess *process);
+    virtual void SetBeams(AliLhcBeam* beam1, AliLhcBeam* beam2);
+    virtual void SetTime(Float_t dt, Float_t tmax) 
+       {fTimeStep = dt; fTimeMax = tmax;}
+    virtual void SetFillingTime(Float_t t) {fFillingTime = t;}
+    virtual void SetSetUpTime(Float_t t)   {fSetUpTime = t;}
+
+    virtual void SetRadius(Float_t r) {fRadius = r;}
+    virtual void SetAverageBeta(Float_t b) {fAverageBeta = b;}
+    virtual void SetAverageDisp(Float_t b) {fAverageDisp = b;}
+    
+    virtual Float_t Radius() {return fRadius;}
+    virtual Float_t AverageBeta() {return fAverageBeta;}
+    virtual Float_t AverageDisp() {return fAverageDisp;}
+    virtual Float_t SetUpTime()   {return fSetUpTime;}
+    virtual Float_t FillingTime() {return fFillingTime;}
+
+
+    virtual AliLhcBeam* Beam(Int_t i) 
+      {return (AliLhcBeam*) (*fBeams)[i];}
+    virtual TList* IRegions(){return fIRegions;}
+    virtual void Init();
+    virtual void EvolveTime();
+    virtual void Evaluate();
+    virtual Float_t  Time()     {return fTime;}
+    virtual Float_t  TimeStep() {return fTimeStep;}
+    virtual Float_t* TimeA()    {return fTimeA;}
+    virtual Int_t    Nt()       {return fNt;}
+    
+    AliLHC & operator=(const AliLHC & rhs);
+    
+ protected:
+    Int_t           fNRegions;              // Number of IR
+    Int_t           fNProcesses;            // Number of processes
+    TList*          fIRegions;              // List of intercation regions
+    TList*          fProcesses;             // Beam processes
+    TObjArray*      fBeams;                 // Lhc beams
+    Float_t         fRadius;                // Radius (cm)
+    Float_t         fAverageBeta;           // Average beta (cm)
+    Float_t         fAverageDisp;           // Average dispersion (cm)
+
+    Int_t    fNt;                  // Number of time steps
+    Int_t  fNmax;                  // Max. Number of time steps
+
+    Float_t  fTime;                // Current time
+    Float_t* fTimeA;               // [fNmax] Current time
+    Float_t  fTimeStep;            // Current time step
+    Float_t  fTimeMax;             // Maximal time 
+    //
+    Float_t  fFillingTime;         // Filling Time
+    Float_t  fSetUpTime;           // Set-up time
+//
+    ClassDef(AliLHC,1) // LHC manager class
+};
+
+#endif
+
+
+
+
+
+
+
+
+
diff --git a/LHC/AliLhcBeam.cxx b/LHC/AliLhcBeam.cxx
new file mode 100644 (file)
index 0000000..c5bcffb
--- /dev/null
@@ -0,0 +1,140 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcBeam.h"
+#include "AliLHC.h"
+#include <TMath.h>
+#include <TCanvas.h>
+#include <TGraph.h>
+#include <TMultiGraph.h>
+
+ClassImp(AliLhcBeam)
+
+AliLhcBeam::AliLhcBeam(AliLHC* lhc)
+{
+// Constructor
+  fAccelerator = lhc;
+}
+
+AliLhcBeam::AliLhcBeam(const AliLhcBeam& beam)
+{
+// copy constructor
+}
+
+AliLhcBeam::~AliLhcBeam()
+{
+// Destructor
+
+}
+
+void AliLhcBeam::Init()
+{
+  // Initialization
+  printf("\n Initializing Beam");
+  printf("\n ^^^^^^^^^^^^^^^^^");
+  // Scale energy with regidity 
+  fEnergy     *= fZ/fA;
+  fGamma       = fEnergy/0.938272;
+  fEmittance   = fNEmittance/fGamma;
+  fEmittance0  = fEmittance;
+  fEmittanceL *= fZ;
+  fEmittanceL0 = fEmittanceL; 
+  fN0=fN;
+
+  printf("\n Beam Energy                :%10.3e GeV", fEnergy);
+  printf("\n Beam Normalized Emittance  :%10.3e cm ", fNEmittance);
+  printf("\n Beam Particles per Bunch   :%10.3e    ", fN);
+}
+
+void AliLhcBeam::RemoveParticles(Float_t loss)
+{
+  fN-=loss;
+}
+
+void AliLhcBeam::IncreaseEmittance(Float_t de, Float_t del)
+{
+  fEmittance    *= (1.+de);
+  fEmittanceL   *= (1.+del);
+  fEnergySpread *= (1.+del);
+}
+
+AliLhcBeam& AliLhcBeam::operator=(const  AliLhcBeam & rhs)
+{
+// Assignment operator
+    return *this;
+}
+void AliLhcBeam::SetMonitor(Int_t n)
+{
+  fNmax = n;
+  if (fEmittanceArray)  delete fEmittanceArray;
+  if (fEmittanceLArray) delete fEmittanceLArray;
+
+
+  fEmittanceArray  = new Float_t[n];
+  fEmittanceLArray = new Float_t[n];
+}
+
+void AliLhcBeam::Record()
+{
+    fEmittanceArray [fAccelerator->Nt()] = fEmittance/fEmittance0;
+    fEmittanceLArray[fAccelerator->Nt()] = fEmittanceL/fEmittanceL0;
+}
+
+
+void AliLhcBeam::DrawPlots()
+{
+  // Draw monitor plots
+  Float_t* t =  fAccelerator->TimeA();
+  
+  TH1 *e1 = new TH1F("e1","Hor. Emittance",fNmax,0,t[fNmax]);
+  e1->SetMinimum(1);
+  e1->SetMaximum(fEmittanceArray[fNmax]*1.1);
+  e1->SetStats(0);
+  e1->GetXaxis()->SetTitle("t (h)");
+  e1->GetYaxis()->SetTitle("rel. Emittance (t)");
+
+  TH1 *e2 = new TH1F("e2","Long. Emittance",fNmax,0,t[fNmax]);
+  e2->SetMinimum(1);
+  e2->SetMaximum(fEmittanceLArray[fNmax]*1.1);
+  e2->SetStats(0);
+  e2->GetXaxis()->SetTitle("t (h)");
+  e2->GetYaxis()->SetTitle("rel. Emittance (t)");
+
+
+  TGraph* grE  = new TGraph(fNmax, t, fEmittanceArray);
+  grE->SetHistogram(e1);
+  TGraph* grEl = new TGraph(fNmax, t, fEmittanceLArray);
+  grEl->SetHistogram(e2);
+  grEl->SetLineStyle(2);
+  TMultiGraph* mg = new TMultiGraph();
+  mg->Add(grE);
+  mg->Add(grEl);
+
+  TCanvas *c2 = new TCanvas("c2","Emittance Increase", 200, 10, 700, 500);
+  c2->SetGrid();
+  mg->Draw("AC");  
+  mg->GetXaxis()->SetTitle("t (h)");
+  mg->GetYaxis()->SetTitle("rel. Emittance(t)");
+  mg->Draw("AC");
+}
+
+
+
+
diff --git a/LHC/AliLhcBeam.h b/LHC/AliLhcBeam.h
new file mode 100644 (file)
index 0000000..c6f187f
--- /dev/null
@@ -0,0 +1,75 @@
+#ifndef ALILHCBEAM_H
+#define ALILHCBAEM_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include <TNamed.h>
+#include "AliLhcMonitor.h"
+
+class AliLHC;
+
+class AliLhcBeam : public TNamed, public AliLhcMonitor
+{
+ public:
+    AliLhcBeam(AliLHC* lhc);
+    AliLhcBeam(const AliLhcBeam &beam);
+    virtual ~AliLhcBeam();
+    
+    virtual void Init();
+    
+    virtual Float_t N() {return fN;}
+    virtual Float_t A() {return fA;}
+    virtual Float_t Z() {return fZ;}
+    virtual Float_t Emittance()   {return fEmittance;}
+    virtual Float_t Energy()      {return fEnergy;}
+    virtual Float_t Gamma()       {return fGamma;}
+    virtual Float_t LongEmittance() {return fEmittanceL;}
+    virtual Float_t EnergySpread() {return fEnergySpread;}
+
+    virtual void  SetParticle(Float_t a, Float_t z) {fA = a; fZ = z;}
+    virtual void  SetN(Float_t n) {fN = n;}        
+    virtual void  SetAccelerator(AliLHC* acc) {fAccelerator = acc;}
+    virtual void  SetEnergy(Float_t  e) {fEnergy = e;}
+    virtual void  SetNEmittance(Float_t  e) {fNEmittance = e;}
+    virtual void  SetLongEmittance(Float_t  e) {fEmittanceL = e;}
+    virtual void  SetEnergySpread(Float_t b) {fEnergySpread = b;}    
+    
+    virtual void  RemoveParticles(Float_t loss);
+    virtual void  IncreaseEmittance(Float_t de, Float_t del);
+    virtual void  SetMonitor(Int_t n);
+    virtual void  Record();
+    virtual void  DrawPlots();
+
+
+    AliLhcBeam & operator=(const AliLhcBeam & rhs);
+    
+ protected:
+    AliLHC* fAccelerator;         // Accelerator
+    Float_t fN;                   // Number of Particles
+    Float_t fN0;                  // Initial Number of Particles
+    Float_t fNEmittance;          // Normalized Emittance
+    Float_t fEmittance;           // Emittance
+    Float_t fEmittance0;          // Initial Emittance
+    Float_t fEmittanceL;          // Longitudinal Emittance
+    Float_t fEmittanceL0;         // Longitudinal Emittance
+    Float_t fEnergySpread;        // Energy Spread
+
+    Float_t fA;                   // Atomic Number
+    Float_t fZ;                   // Charge Number 
+    Float_t fEnergy;              // Energy   
+    Float_t fGamma;               // relativistic gamma 
+    //
+    Float_t* fTimeArray;          // [fNmax] Time array
+    Float_t* fEmittanceArray;     // [fNmax] Emittance array
+    Float_t* fEmittanceLArray;    // [fNmax] Long. Emittance array      
+//
+    ClassDef(AliLhcBeam,1) // LHC Beam
+};
+
+#endif
+
+
+
+
+
diff --git a/LHC/AliLhcIRegion.cxx b/LHC/AliLhcIRegion.cxx
new file mode 100644 (file)
index 0000000..4d521dd
--- /dev/null
@@ -0,0 +1,219 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcIRegion.h"
+#include "AliLhcBeam.h"
+#include "AliLHC.h"
+
+#include <TMath.h>
+#include <TCanvas.h>
+#include <TPad.h>
+#include <TGraph.h>
+#include <TMultiGraph.h>
+#include <TH1.h>
+
+ClassImp(AliLhcIRegion)
+
+AliLhcIRegion::AliLhcIRegion(AliLHC* lhc, const char* name, const char* title)
+    :TNamed(name,title)
+{
+// Constructor
+    fAccelerator=lhc;   
+    fLumiArray        = 0;  
+    fAverageLumiArray = 0;
+    fBetaStarArray = 0;
+}
+
+AliLhcIRegion::AliLhcIRegion(const AliLhcIRegion& region)
+{
+// copy constructor
+}
+
+AliLhcIRegion::~AliLhcIRegion()
+{
+// Destructor
+
+  if (fLumiArray)        delete fLumiArray;
+  if (fAverageLumiArray) delete fAverageLumiArray;
+  if (fBetaStarArray)    delete fBetaStarArray;
+}
+
+
+AliLhcIRegion& AliLhcIRegion::operator=(const  AliLhcIRegion & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+void AliLhcIRegion::Init()
+{
+  // Initialization
+  printf("\n Initializing Interaction Region %s", GetName());
+  printf("\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+  // Initial Luminosity
+  fBeam1 = fAccelerator->Beam(0);
+  fBeam2 = fAccelerator->Beam(1);
+  fFrequency = 3.e10/(2.*TMath::Pi()*fAccelerator->Radius());
+
+  Luminosity();
+
+  fLuminosity0 = fLuminosity;  
+  fAverageLumi=0.;
+  fBetaStar0   = fBetaStar;
+  printf("\n IR Beta*                 :%10.3e cm        ", fBetaStar);
+  printf("\n IR Initial Luminosity    :%10.3e cm^-2s^-1 ", fLuminosity);
+}
+
+Float_t AliLhcIRegion::Luminosity()
+{
+  Float_t sigma1 = TMath::Sqrt(fBeam1->Emittance()*fBetaStar);
+  Float_t sigma2 = TMath::Sqrt(fBeam2->Emittance()*fBetaStar);
+  fLuminosity = fFrequency * 
+    fBeam1->N()*fBeam2->N()/(2.*TMath::Pi()*(sigma1*sigma1+sigma2*sigma2));
+  return fLuminosity;
+}
+
+void AliLhcIRegion::Update()
+{
+  Luminosity();
+}
+
+void AliLhcIRegion::SetMonitor(Int_t n)
+{
+  // Initialize monitors
+
+  if (fLumiArray)        delete fLumiArray;
+  if (fAverageLumiArray) delete fAverageLumiArray;
+  if (fBetaStarArray)    delete fBetaStarArray;
+
+  fLumiArray        = new Float_t[n];
+  fAverageLumiArray = new Float_t[n];
+  fBetaStarArray    = new Float_t[n];
+
+  fAverageLumiArray[0] = 0.;
+  fNmax = n;
+}
+
+void AliLhcIRegion::Record()
+{
+  // Record some time dependent quantities
+  //
+  Int_t n = fAccelerator->Nt();
+  // Luminosity
+  
+  fLumiArray[n] = fLuminosity;
+  
+  // Average Luminosity respecting set-up and filling time
+  if (fAccelerator->Time() > fAccelerator->SetUpTime())
+    fAverageLumi+=fLuminosity*fAccelerator->TimeStep();
+  
+  fAverageLumiArray[n] = fAverageLumi/
+    (Float_t(n+1)*fAccelerator->TimeStep()+fAccelerator->FillingTime())/
+    fLuminosity0;
+  
+  // Beta* 
+  fBetaStarArray[n] = fBetaStar;
+}
+
+
+void AliLhcIRegion::DrawPlots()
+{
+  //
+  // Draw the monitor plots
+  //
+  Float_t* t = fAccelerator->TimeA();
+  //
+  char name1[20], name2[20], hname[20];
+  sprintf(name1,"c%s",GetName());
+  sprintf(name2,"b%s",GetName());
+  char title[30];
+  sprintf(title,"Luminosity Lifetime for %s",GetName());
+  
+  //
+  sprintf(hname,"%s%d",name1,0);
+  TH1 *g1 = new TH1F(hname,"Luminosity",fNmax,0,t[fNmax]);
+  g1->SetMinimum(0);
+  g1->SetMaximum(fLumiArray[0]*1.1);
+  g1->SetStats(0);
+  g1->GetXaxis()->SetTitle("t (h)");
+  g1->GetYaxis()->SetTitle("L(t) (cm**-2 s**-1)");
+  sprintf(hname,"%s%d",name1,1);
+  TH1 *g2 = new TH1F(hname,"Luminosity",fNmax,0,t[fNmax]);
+  g2->SetMinimum(0);
+  g2->SetMaximum(1.1);
+  g2->SetStats(0);
+  g2->GetXaxis()->SetTitle("t (h)");
+  g2->GetYaxis()->SetTitle("L(t)/L0");
+  sprintf(hname,"%s%d",name1,3);
+
+  TH1 *g3 = new TH1F(hname,"Average Luminosity",fNmax,0,t[fNmax]);
+  g3->SetMinimum(0);
+  g3->SetMaximum(1.1);
+  g3->SetStats(0);
+  
+  g3->GetXaxis()->SetTitle("t (h)");
+  g3->GetYaxis()->SetTitle("L(t)/L0");
+  sprintf(hname,"%s%d",name1,3);
+
+  TH1 *g4 = new TH1F(hname,"Beta*",fNmax,0,t[fNmax]);
+  g4->SetMinimum(0);
+  g4->SetMaximum(fBetaStarArray[0]*1.1);
+  g4->SetStats(0);
+  g4->GetXaxis()->SetTitle("t (h)");
+  g4->GetYaxis()->SetTitle("beta* (cm)");
+
+  TGraph* grLumi = new TGraph(fNmax, t, fLumiArray);
+  grLumi->SetHistogram(g1);
+
+  for (Int_t i=0; i<fNmax; i++) {
+    fLumiArray[i]=fLumiArray[i]/fLuminosity0;
+  }
+  TGraph* grLumiN = new TGraph(fNmax, t, fLumiArray);
+  grLumiN->SetHistogram(g2);
+
+  TGraph* grLumiA = new TGraph(fNmax, t, fAverageLumiArray);
+  grLumiA->SetHistogram(g3);
+  grLumiA->SetLineStyle(2);
+
+  TGraph* grLumiB = new TGraph(fNmax, t, fBetaStarArray);
+  grLumiB->SetHistogram(g4);
+
+  TMultiGraph* mg = new TMultiGraph();
+  mg->Add(grLumiN);
+  mg->Add(grLumiA);
+
+
+  TCanvas *c1 = new TCanvas(name1,title, 200, 10, 700, 500);
+  
+  c1->SetGrid();
+  mg->Draw("AC");
+  mg->GetXaxis()->SetTitle("t (h)");
+  mg->GetYaxis()->SetTitle("L(t)/L0 and <L>/L0");
+  mg->Draw("AC");
+
+  TCanvas *c2 = new TCanvas(name2,title, 200, 10, 700, 500);
+  c1->SetGrid();
+  grLumiB->Draw("AC");
+
+}
+
+
+
+
diff --git a/LHC/AliLhcIRegion.h b/LHC/AliLhcIRegion.h
new file mode 100644 (file)
index 0000000..3e27f2e
--- /dev/null
@@ -0,0 +1,56 @@
+#ifndef ALILHCIREGION_H
+#define ALILHCIREGION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include <TNamed.h>
+#include "AliLhcMonitor.h"
+
+class AliLHC;
+class AliLhcBeam;
+
+class AliLhcIRegion : public TNamed, public AliLhcMonitor
+{
+ public:
+    AliLhcIRegion(AliLHC* lhc, const char* name, const char* tile);
+    AliLhcIRegion(const AliLhcIRegion &region);
+    virtual ~AliLhcIRegion();
+    AliLhcIRegion & operator=(const AliLhcIRegion & rhs);
+    
+    virtual void Init();
+    virtual Float_t Luminosity();
+    virtual Float_t InitialLumi()   {return fLuminosity0;}
+    virtual Float_t BetaStar()   {return fBetaStar;}
+    virtual void  SetBetaStar(Float_t beta) {fBetaStar = beta;}
+    virtual void  SetCrossingAngle(Float_t angle) {fCrossingAngle = angle;}        
+    virtual void  SetAccelerator(AliLHC* acc) {fAccelerator = acc;}
+    virtual void  Update();
+    virtual void  SetMonitor(Int_t n);
+    virtual void  Record();
+    virtual void  DrawPlots();
+
+ protected:
+    AliLHC*     fAccelerator;         // Accelerator
+    AliLhcBeam* fBeam1;               // Beam1
+    AliLhcBeam* fBeam2;               // Beam2       
+    Float_t     fLuminosity;          // Luminosity
+    Float_t     fLuminosity0;         // Initial Luminosity
+    Float_t     fAverageLumi;         // Average Initial Luminosity
+    Float_t     fBetaStar;            // Beta*
+    Float_t     fBetaStar0;           // Initial Beta*
+    Float_t     fCrossingAngle;       // Crossing Angle
+    Float_t     fFrequency;           // Frequency
+    Float_t*    fLumiArray;           // [fNmax] Luminosity(t)
+    Float_t*    fAverageLumiArray;    // [fNmax] Average Luminosity(t)
+    Float_t*    fBetaStarArray;       // [fNmax] Beta*(t)
+//
+    ClassDef(AliLhcIRegion,1) // LHC Interaction Region
+};
+
+#endif
+
+
+
+
+
diff --git a/LHC/AliLhcMonitor.cxx b/LHC/AliLhcMonitor.cxx
new file mode 100644 (file)
index 0000000..03950bc
--- /dev/null
@@ -0,0 +1,32 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcMonitor.h"
+#include "AliLHC.h"
+#include <TMath.h>
+#include <TCanvas.h>
+#include <TGraph.h>
+
+ClassImp(AliLhcMonitor)
+
+
+
+
+
+
diff --git a/LHC/AliLhcMonitor.h b/LHC/AliLhcMonitor.h
new file mode 100644 (file)
index 0000000..d0bcdbe
--- /dev/null
@@ -0,0 +1,22 @@
+#ifndef ALILHCMONITOR_H
+#define ALILHCMONITOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include <TObject.h>
+class AliLhcMonitor
+{
+ public:
+    AliLhcMonitor(){;}
+    virtual ~AliLhcMonitor(){;}
+    virtual void  SetMonitor(Int_t n) = 0;
+    virtual void  Record()            = 0;
+    virtual void  DrawPlots()         = 0;
+
+ protected:
+    int fNmax;
+    ClassDef(AliLhcMonitor,1) // LHC Monitor Base Class
+};
+
+#endif
diff --git a/LHC/AliLhcProcess.cxx b/LHC/AliLhcProcess.cxx
new file mode 100644 (file)
index 0000000..0f2f946
--- /dev/null
@@ -0,0 +1,54 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcProcess.h"
+#include "AliLHC.h"
+
+ClassImp(AliLhcProcess)
+
+AliLhcProcess::AliLhcProcess(AliLHC *lhc, const char* name, const char* title)
+    :TNamed(name,title)
+{
+// Constructor
+  fAccelerator = lhc;
+}
+
+AliLhcProcess::AliLhcProcess(const AliLhcProcess& process)
+{
+// copy constructor
+}
+
+AliLhcProcess::~AliLhcProcess()
+{
+// Destructor
+
+}
+
+void AliLhcProcess::Evolve(Float_t dt)
+{
+    printf("\n Here process %s %f:", GetName(), dt);
+}
+
+AliLhcProcess& AliLhcProcess::operator=(const  AliLhcProcess & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+
diff --git a/LHC/AliLhcProcess.h b/LHC/AliLhcProcess.h
new file mode 100644 (file)
index 0000000..8433b9f
--- /dev/null
@@ -0,0 +1,32 @@
+#ifndef ALILHCPROCESS_H
+#define ALILHCPROCESS_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include "AliLhcMonitor.h"
+#include <TNamed.h>
+
+class AliLHC;
+
+class AliLhcProcess : public TNamed, public AliLhcMonitor
+{
+ public:
+  AliLhcProcess(AliLHC* lhc, const char* name, const char* title);
+  virtual void  SetAccelerator(AliLHC* acc) {fAccelerator = acc;}
+  AliLhcProcess(const AliLhcProcess &process);
+  virtual ~AliLhcProcess();
+  virtual void Init(){;}
+  virtual void Evolve(Float_t dt);
+  virtual void  SetMonitor(Int_t n){;}
+  virtual void  Record(){;}
+  virtual void  DrawPlots(){;}
+  AliLhcProcess & operator=(const AliLhcProcess & rhs);
+  
+ protected:
+  AliLHC* fAccelerator;         // Accelerator
+  //
+  ClassDef(AliLhcProcess,1) // LHC Process Base Class
+};
+
+#endif
diff --git a/LHC/AliLhcProcessBB.cxx b/LHC/AliLhcProcessBB.cxx
new file mode 100644 (file)
index 0000000..90f2654
--- /dev/null
@@ -0,0 +1,72 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcProcessBB.h"
+#include "AliLHC.h"
+#include "AliLhcIRegion.h"
+#include "AliLhcBeam.h"
+
+ClassImp(AliLhcProcessBB)
+
+AliLhcProcessBB::AliLhcProcessBB(AliLHC* lhc, const char* name, const char* title)
+    :AliLhcProcess(lhc,name,title)
+{
+// Constructor
+}
+
+
+AliLhcProcessBB::~AliLhcProcessBB()
+{
+// Destructor
+
+}
+
+void AliLhcProcessBB::Init()
+{
+  // Initialization
+   printf("\n Initializing Process %s", GetName());
+   printf("\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+   fIRegions = fAccelerator->IRegions();
+   fBeam1 = fAccelerator->Beam(0);
+   fBeam2 = fAccelerator->Beam(1);
+}
+
+void AliLhcProcessBB::Evolve(Float_t dt)
+{
+  printf("\n Here process %s %f:", GetName(), dt);
+  TIter next(fIRegions);
+  AliLhcIRegion *region;
+  //
+  // Loop over generators and initialize
+  while((region = (AliLhcIRegion*)next())) {
+      Float_t rate = region->Luminosity()*fCrossSection;
+      Float_t loss = rate*dt;
+      fBeam1->RemoveParticles(loss);
+      fBeam2->RemoveParticles(loss);
+  }  
+}
+
+
+AliLhcProcessBB& AliLhcProcessBB::operator=(const  AliLhcProcessBB & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+
diff --git a/LHC/AliLhcProcessBB.h b/LHC/AliLhcProcessBB.h
new file mode 100644 (file)
index 0000000..09fa4eb
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef ALILHCPROCESSBB_H
+#define ALILHCPROCESSBB_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include "AliLhcProcess.h"
+class TList;
+class AliLhcBeam;
+
+class AliLhcProcessBB : public AliLhcProcess
+{
+ public:
+    AliLhcProcessBB(AliLHC* lhc, const char* name, const char* title);
+    virtual ~AliLhcProcessBB();
+    virtual void SetCrossSection(Float_t sig) {fCrossSection = sig*1.e-24;}
+    virtual void Init();
+    virtual void Evolve(Float_t dt);
+    
+    AliLhcProcessBB & operator=(const AliLhcProcessBB & rhs);
+ protected:
+    Float_t fCrossSection; // Interaction cross section 
+    TList * fIRegions;     // Interaction Regions
+    AliLhcBeam* fBeam1;    // Beam1
+    AliLhcBeam* fBeam2;    // Beam2    
+
+//
+    ClassDef(AliLhcProcessBB,1) // LHC Process: Beam-Beam 
+};
+
+#endif
diff --git a/LHC/AliLhcProcessBT.cxx b/LHC/AliLhcProcessBT.cxx
new file mode 100644 (file)
index 0000000..88f756a
--- /dev/null
@@ -0,0 +1,68 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcProcessBT.h"
+#include "AliLHC.h"
+#include "AliLhcIRegion.h"
+#include "AliLhcBeam.h"
+
+ClassImp(AliLhcProcessBT)
+
+AliLhcProcessBT::AliLhcProcessBT(AliLHC* lhc, const char* name, const char* title)
+    :AliLhcProcess(lhc,name,title)
+{
+// Constructor
+}
+
+
+AliLhcProcessBT::~AliLhcProcessBT()
+{
+// Destructor
+}
+
+void AliLhcProcessBT::Init()
+{
+  // Initialization
+   printf("\n Initializing Process %s", GetName());
+   printf("\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+   fIRegions = fAccelerator->IRegions();
+}
+
+void AliLhcProcessBT::Evolve(Float_t dt)
+{
+  printf("\n Here process %s %f:", GetName(), dt);
+  TIter next(fIRegions);
+  AliLhcIRegion *region;
+  //
+  // Loop over generators and initialize
+  while((region = (AliLhcIRegion*)next())) {
+    Float_t betanew = 
+      region->Luminosity()/region->InitialLumi()*region->BetaStar();
+    if (betanew > fBetaMin) region->SetBetaStar(betanew);
+  }  
+}
+
+
+AliLhcProcessBT& AliLhcProcessBT::operator=(const  AliLhcProcessBT & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+
diff --git a/LHC/AliLhcProcessBT.h b/LHC/AliLhcProcessBT.h
new file mode 100644 (file)
index 0000000..5f66bf5
--- /dev/null
@@ -0,0 +1,30 @@
+#ifndef ALILHCPROCESSBT_H
+#define ALILHCPROCESSBT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include "AliLhcProcess.h"
+class TList;
+class AliLhcBeam;
+
+class AliLhcProcessBT : public AliLhcProcess
+{
+ public:
+    AliLhcProcessBT(AliLHC* lhc, const char* name, const char* title);
+    virtual ~AliLhcProcessBT();
+    virtual void SetCrossSection(Float_t sig) {fCrossSection = sig*1.e-24;}
+    virtual void Init();
+    virtual void Evolve(Float_t dt);
+    virtual void SetBetaMin(Float_t b) {fBetaMin = b;}
+    
+    AliLhcProcessBT & operator=(const AliLhcProcessBT & rhs);
+ protected:
+    Float_t fCrossSection; // Interaction cross section 
+    TList * fIRegions;     // Interaction Regions
+    Float_t fBetaMin;      // Minimal allowed beta*
+//
+    ClassDef(AliLhcProcessBT,1) // LHC Process: Beta Tuning 
+};
+
+#endif
diff --git a/LHC/AliLhcProcessIBS.cxx b/LHC/AliLhcProcessIBS.cxx
new file mode 100644 (file)
index 0000000..06d3581
--- /dev/null
@@ -0,0 +1,192 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+$Log$
+*/
+
+#include "AliLhcProcessIBS.h"
+#include "AliLHC.h"
+#include "AliLhcIRegion.h"
+#include "AliLhcBeam.h"
+
+#include <TF1.h>
+#include <TMath.h>
+#include <TCanvas.h>
+#include <TGraph.h>
+#include <TMultiGraph.h>
+
+ClassImp(AliLhcProcessIBS)
+
+  Double_t func(Double_t *x, Double_t *par);
+
+AliLhcProcessIBS::AliLhcProcessIBS(AliLHC* lhc, const char* name, const char* title)
+    :AliLhcProcess(lhc,name,title)
+{
+// Constructor
+}
+
+
+AliLhcProcessIBS::~AliLhcProcessIBS()
+{
+// Destructor
+
+}
+
+void AliLhcProcessIBS::Init()
+{
+  // Initialization
+   const Float_t r0=1.535e-16;
+
+   printf("\n Initializing Process %s", GetName());
+   printf("\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+
+   fIRegions = fAccelerator->IRegions();
+
+   for (Int_t i = 0; i < 2; i++) {
+     fBeam[i] = fAccelerator->Beam(i);
+     fR[i]    = r0*fBeam[i]->Z()*fBeam[i]->Z()/fBeam[i]->A();
+     fE[i]    = 0.938*fBeam[i]->A();
+   }
+}
+
+void AliLhcProcessIBS::Evolve(Float_t dt)
+{
+  printf("\n Here process %s %f:", GetName(), dt);
+   for (Int_t i=0; i<2; i++) {
+     // Density
+     Float_t sige    = fBeam[i]->EnergySpread();
+     Float_t avbeta  = fAccelerator->AverageBeta();
+     Float_t avd     = fAccelerator->AverageDisp();
+
+     Float_t gamma   = fBeam[i]->Gamma();
+     Float_t epsx    = fBeam[i]->Emittance()*gamma;
+     Float_t epsy    = epsx;
+     Float_t epse    = fBeam[i]->LongEmittance();
+     Float_t sigxb   = TMath::Sqrt(epsx/gamma*avbeta);
+     Float_t sigx    = TMath::Sqrt(sigxb*sigxb+(avd*avd*sige*sige));
+     Float_t ssigx   = TMath::Sqrt(epsx/gamma/avbeta);
+     Float_t sigy    = sigx;
+     Float_t ssigy   = ssigx;
+
+     Float_t asd = fBeam[i]->N()*fR[i]*fR[i]*fE[i]/
+       (16.*TMath::Pi()*gamma*epsx*epsy*epse);
+     
+     // impact parameter
+     Float_t d    = sige*avd/sigx;
+     // 
+     Float_t at = sige*TMath::Sqrt(1.-d*d)/(gamma*ssigx);
+     Float_t bt = sige*TMath::Sqrt(1.-d*d)/(gamma*ssigy);
+     Float_t ct = sige*TMath::Sqrt(1.-d*d)*TMath::Sqrt(4.*sigy/fR[i]);
+     //
+     Double_t par[3];
+     par[0] = at;
+     par[1] = bt;
+     par[2] = ct;
+     TF1 *fct = new TF1("func",func, 0., 1., 3);
+     
+     Float_t f = (Float_t) 8.0*TMath::Pi()*
+        fct->Integral(0., 1., par, 1.e-5);
+     //
+     fTaux =  1./(asd*f*(d*d-at*at/2.));
+     fTaue =  1./(asd*f*(1.-d*d));
+     //     printf("\n taux, taue %f %f", taux, taue);
+     //     Float_t tauy = -2./at*at/asd/f;
+     fBeam[i]->IncreaseEmittance(dt/fTaux, dt/fTaue);
+   }
+
+}
+
+void AliLhcProcessIBS::SetMonitor(Int_t n)
+{
+  // Initialize Monitor
+  if (fTauxArray) delete fTauxArray;
+  if (fTaueArray) delete fTaueArray;
+  fTauxArray = new Float_t[n];
+  fTaueArray = new Float_t[n];
+  fNmax = n;
+}
+
+void AliLhcProcessIBS::Record()
+{
+  // Record monitor quantities
+    fTauxArray[fAccelerator->Nt()] = fTaux/3600.;
+    fTaueArray[fAccelerator->Nt()] = fTaue/3600.;
+}
+
+
+void AliLhcProcessIBS::DrawPlots()
+{
+  // Draw monitor plots
+  Float_t* t =  fAccelerator->TimeA();
+  
+  TH1 *t1 = new TH1F("t1","Hor. IBS growth time",fNmax,0,t[fNmax]);
+  t1->SetMinimum(0);
+  t1->SetMaximum(fTauxArray[fNmax]*1.1);
+  t1->SetStats(0);
+  t1->GetXaxis()->SetTitle("t (h)");
+  t1->GetYaxis()->SetTitle("tau_x (t)");
+
+  TH1 *t2 = new TH1F("t2","Long. IBS growth time",fNmax,0,t[fNmax]);
+  t2->SetMinimum(0);
+  t2->SetMaximum(fTaueArray[fNmax]*1.1);
+  t2->SetStats(0);
+  t2->GetXaxis()->SetTitle("t (h)");
+  t2->GetYaxis()->SetTitle("tau_l (t)");
+
+  TGraph* grTaux = new TGraph(fNmax, fAccelerator->TimeA(), fTauxArray);
+  grTaux->SetHistogram(t1);
+
+  TGraph* grTaue = new TGraph(fNmax, fAccelerator->TimeA(), fTaueArray);
+  grTaue->SetHistogram(t2);
+  grTaue->SetLineStyle(2);
+
+  TMultiGraph* mg = new TMultiGraph();
+  mg->Add(grTaux);
+  mg->Add(grTaue);
+
+  TCanvas *c3 = new TCanvas("c3","IBS", 200, 10, 700, 500);
+  c3->SetGrid();
+  mg->Draw("AC");  
+  mg->GetXaxis()->SetTitle("t (h)");
+  mg->GetYaxis()->SetTitle("IBS Growth Time (h)");
+  mg->Draw("AC");
+}
+
+
+
+
+
+AliLhcProcessIBS& AliLhcProcessIBS::operator=(const  AliLhcProcessIBS & rhs)
+{
+// Assignment operator
+    return *this;
+}
+
+Double_t func(Double_t *x, Double_t *par)
+{
+  Double_t a  = par[0];
+  Double_t b  = par[1];
+  Double_t cc = par[2];
+
+  const Double_t bc = 0.5772;
+  Double_t xx = x[0];
+  Double_t x2=xx*xx;
+  Double_t x1=1.0-x2;
+  Double_t p=1.0/TMath::Sqrt(x2+a*a*x1);
+  Double_t q=1.0/TMath::Sqrt(x2+b*b*x1);
+  return (1.0-3.0*x2)*p*q*(2.0*TMath::Log(0.5*cc*(p+q))-bc);
+}
+
diff --git a/LHC/AliLhcProcessIBS.h b/LHC/AliLhcProcessIBS.h
new file mode 100644 (file)
index 0000000..f534fe9
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALILHCPROCESSIBS_H
+#define ALILHCPROCESSIBS_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+#include "AliLhcProcess.h"
+class TList;
+class AliLhcBeam;
+
+class AliLhcProcessIBS : public AliLhcProcess
+{
+ public:
+    AliLhcProcessIBS(AliLHC* lhc, const char* name, const char* title);
+    virtual ~AliLhcProcessIBS();
+    virtual void SetCrossSection(Float_t sig) {fCrossSection = sig*1.e-24;}
+    virtual void Init();
+    virtual void Evolve(Float_t dt);
+    virtual void  SetMonitor(Int_t n);
+    virtual void  Record();
+    virtual void  DrawPlots();
+    AliLhcProcessIBS & operator=(const AliLhcProcessIBS & rhs);
+ protected:
+    Float_t fCrossSection; // Interaction cross section 
+    TList * fIRegions;     // Interaction Regions
+    AliLhcBeam* fBeam[2];  // Beams
+    Float_t fR[2];           // elem. ion radius
+    Float_t fE[2];           // ion radius
+    Float_t fTaux;  
+    Float_t fTaue;
+    Float_t* fTauxArray;     // [fNmax]
+    Float_t* fTaueArray;     // [fNmax]
+    
+//
+    ClassDef(AliLhcProcessIBS,1) // LHC Process: Intra Beam Scattering
+};
+
+#endif
diff --git a/LHC/LHCLinkDef.h b/LHC/LHCLinkDef.h
new file mode 100644 (file)
index 0000000..581ccc2
--- /dev/null
@@ -0,0 +1,25 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class  AliGenLHC+;
+#pragma link C++ class  AliLhcIRegion+;
+#pragma link C++ class  AliLhcBeam+;
+#pragma link C++ class  AliLhcProcess+;
+#pragma link C++ class  AliLhcProcessBB+;
+#pragma link C++ class  AliLhcProcessIBS+;
+#pragma link C++ class  AliLhcProcessBT+;
+#pragma link C++ class  AliLhcMonitor+;
+#endif
+
+
+
+
+
+
diff --git a/LHC/Makefile b/LHC/Makefile
new file mode 100644 (file)
index 0000000..1d48a96
--- /dev/null
@@ -0,0 +1,79 @@
+############################### LHC Makefile ################################
+
+# Include machine specific definitions
+
+include $(ALICE_ROOT)/conf/GeneralDef
+include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET)
+
+PACKAGE = LHC
+
+# C++ sources
+
+SRCS          = AliLHC.cxx AliLhcIRegion.cxx AliLhcBeam.cxx AliLhcProcess.cxx \
+               AliLhcProcessBB.cxx AliLhcProcessIBS.cxx AliLhcMonitor.cxx \
+               AliLhcProcessBT.cxx
+
+# C++ Headers
+
+HDRS          = $(SRCS:.cxx=.h) 
+
+# Library dictionary
+
+DICT          = LHCCint.cxx
+DICTH         = $(DICT:.cxx=.h) 
+DICTO         = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DICT))
+
+# FORTRAN Objectrs
+
+FOBJS         = $(patsubst %.F,tgt_$(ALICE_TARGET)/%.o,$(FSRCS))
+
+# C Objects
+
+COBJS         = $(patsubst %.c,tgt_$(ALICE_TARGET)/%.o,$(CSRCS))
+
+# C++ Objects
+
+OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO)
+
+# C++ compilation flags
+
+CXXFLAGS      = $(CXXOPTS) -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/
+# FORTRAN compilation flags
+
+FFLAGS      = $(FOPT)
+
+##### TARGETS #####
+# Target
+
+SLIBRARY       = $(LIBDIR)/libLHC.$(SL)
+ALIBRARY       = $(LIBDIR)/libLHC.a
+
+default:       $(SLIBRARY)
+
+$(LIBDIR)/libLHC.$(SL):                $(OBJS)
+
+$(DICT):                               $(HDRS)
+
+depend:                                        $(SRCS)
+
+
+TOCLEAN                = $(OBJS) *Cint.cxx *Cint.h
+
+CHECKS        = $(patsubst %.cxx,check/%.viol,$(SRCS))
+
+############################### General Macros ################################
+
+include $(ALICE_ROOT)/conf/GeneralMacros
+
+############################ Dependencies #####################################
+
+-include tgt_$(ALICE_TARGET)/Make-depend 
+
+
+
+
+
+
+