[u/mrichter/AliRoot.git] / LHC / AliLHC.h

#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$ */

//
// Class for a simple description of the LHC.
// The LHC is described by two beams,
// the interaction regions and the
// beam loss processes.
// Run paramters can be set in order to simulate the time evolution
// of emittance, number of particles per bunch and luminosity.
// Author: Andreas Morsch
// andreas.morsch@cern.ch

#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()      const {return fRadius;}
    virtual Float_t AverageBeta() const {return fAverageBeta;}
    virtual Float_t AverageDisp() const {return fAverageDisp;}
    virtual Float_t SetUpTime()   const {return fSetUpTime;}
    virtual Float_t FillingTime() const {return fFillingTime;}


    virtual AliLhcBeam* Beam(Int_t i) 
      {return (AliLhcBeam*) (*fBeams)[i];}
    virtual TList* IRegions()   const {return fIRegions;}
    virtual void Init();
    virtual void EvolveTime();
    virtual void Evaluate();
    virtual Float_t  Time()     const {return fTime;}
    virtual Float_t  TimeStep() const {return fTimeStep;}
    virtual Float_t* TimeA()    const {return fTimeA;}
    virtual Int_t    Nt()       const {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
Commit	Line	Data
11141716	1	#ifndef ALILHC_H
	2	#define ALILHC_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
21aa51f2	7
	8	//
	9	// Class for a simple description of the LHC.
	10	// The LHC is described by two beams,
	11	// the interaction regions and the
	12	// beam loss processes.
	13	// Run paramters can be set in order to simulate the time evolution
	14	// of emittance, number of particles per bunch and luminosity.
	15	// Author: Andreas Morsch
	16	// andreas.morsch@cern.ch
	17
11141716	18	#include <TObject.h>
	19	#include <TList.h>
	20	#include <TObjArray.h>
	21
	22	class AliLhcIRegion;
	23	class AliLhcProcess;
	24	class AliLhcBeam;
	25
	26
	27	class AliLHC : public TObject
	28	{
	29	public:
	30	AliLHC();
	31	AliLHC(const AliLHC &lhc);
	32	virtual ~AliLHC();
	33
	34	virtual void AddIRegion(AliLhcIRegion *region);
	35	virtual void AddProcess(AliLhcProcess *process);
	36	virtual void SetBeams(AliLhcBeam* beam1, AliLhcBeam* beam2);
	37	virtual void SetTime(Float_t dt, Float_t tmax)
	38	{fTimeStep = dt; fTimeMax = tmax;}
	39	virtual void SetFillingTime(Float_t t) {fFillingTime = t;}
	40	virtual void SetSetUpTime(Float_t t) {fSetUpTime = t;}
	41
	42	virtual void SetRadius(Float_t r) {fRadius = r;}
	43	virtual void SetAverageBeta(Float_t b) {fAverageBeta = b;}
	44	virtual void SetAverageDisp(Float_t b) {fAverageDisp = b;}
	45
21aa51f2	46	virtual Float_t Radius() const {return fRadius;}
	47	virtual Float_t AverageBeta() const {return fAverageBeta;}
	48	virtual Float_t AverageDisp() const {return fAverageDisp;}
	49	virtual Float_t SetUpTime() const {return fSetUpTime;}
	50	virtual Float_t FillingTime() const {return fFillingTime;}
11141716	51
	52
	53	virtual AliLhcBeam* Beam(Int_t i)
	54	{return (AliLhcBeam) (fBeams)[i];}
21aa51f2	55	virtual TList* IRegions() const {return fIRegions;}
11141716	56	virtual void Init();
	57	virtual void EvolveTime();
	58	virtual void Evaluate();
21aa51f2	59	virtual Float_t Time() const {return fTime;}
	60	virtual Float_t TimeStep() const {return fTimeStep;}
	61	virtual Float_t* TimeA() const {return fTimeA;}
	62	virtual Int_t Nt() const {return fNt;}
11141716	63
	64	AliLHC & operator=(const AliLHC & rhs);
	65
	66	protected:
	67	Int_t fNRegions; // Number of IR
	68	Int_t fNProcesses; // Number of processes
	69	TList* fIRegions; // List of intercation regions
	70	TList* fProcesses; // Beam processes
	71	TObjArray* fBeams; // Lhc beams
	72	Float_t fRadius; // Radius (cm)
	73	Float_t fAverageBeta; // Average beta (cm)
	74	Float_t fAverageDisp; // Average dispersion (cm)
	75
	76	Int_t fNt; // Number of time steps
	77	Int_t fNmax; // Max. Number of time steps
	78
	79	Float_t fTime; // Current time
	80	Float_t* fTimeA; // [fNmax] Current time
	81	Float_t fTimeStep; // Current time step
	82	Float_t fTimeMax; // Maximal time
	83	//
	84	Float_t fFillingTime; // Filling Time
	85	Float_t fSetUpTime; // Set-up time
	86	//
	87	ClassDef(AliLHC,1) // LHC manager class
	88	};
	89
	90	#endif
	91
	92
	93
	94
	95
	96
	97
	98
	99