[u/mrichter/AliRoot.git] / ALIFAST / AliFast.cxx


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// AliFast                                                              //
//                                                                      //
// Main class to control the AliFast program.                           //
//                                                                      //
// This class is a general framework for programs that needs to:        //
//    - Initialise some parameters                                      //
//    - Loop on events                                                  //
//    - Print results and save histograms, etc                          //
//                                                                      //
// The event processor AliFast::Make loops on a list of Makers          //
// where each maker performs some task on the event data and generates  //
// results.                                                             //
// New Makers can be inserted by a user without modifying this class.   //
// Note that the order in which the Makers are called is the order      //
// of insertion in the list of Makers.                                  //
// Each Maker is responsible for creating its branch of the Tree.       //
// The following table shows the list of makers currently implemented   //
// The default option to Save the Maker info in the Tree is mentioned.  //
//                                                                      //
//    Maker name        Save in Tree                                    //
//    ==========        ============                                    //
//    MCMaker             NO                                            //
//    TrackMaker          NO                                            //
//                                                                      //
// Makers must derive from the base class AliFMaker.                    //
// AliFMaker provides a common interface to all Makers.                 //
// Each Maker is responsible for defining its own parameters and        //
// histograms.                                                          //
// Each Maker has its own list of histograms.                           //
// Each Maker has an associated companion class corresponding to the    //
// type of physics object reconstructed by the Maker.                   //
// For example, AliFClusterMaker creates AliFCluster objects.           //
//              AliFTriggerMaker creates one single AliFTrigger object. //
// The pointer supporting the created object(s) is defined in AliFMaker //
//   fFruits may point to a single object (eg. AliFTrigger) or to a    //
//           TClonesArray of objects (eg. AliFCluster).                 //
//                                                                      //
// The function AliFast::Maketree must be called after the creation     //
// of the AliFast object to create a Root Tree.                         //
//                                                                      //
// An example of main program/macro to use AliFast is given below:      //
//========================================================================
//void umain(Int_t nevents=100)
//{
//   gROOT->Reset();
//   gSystem->Load("libalifast.so");  // dynamically link the compiled shared library
//
//   // Open the root output file
//   TFile file("alifast.root","recreate","AliFast root file",2);
//   
//   AliFast alifast("alifast");     // create main object to run alifast
//
//   User user;           // create an object of the User class defined in user.C
//
//   alifast.Init();      // Initialise event (maker histograms,etc)
//   alifast.MakeTree();  // Create the Root tree
//
//   gROOT->LoadMacro("user.C");  // compile/interpret user file
//
//   for (Int_t i=0; i<nevents; i++) {
//      if (i%100 == 0) printf("In loop:%d\n",i);
//      alifast.Make(i);       // Generate and reconstruct event
//      user.FillHistograms(); // User has possibility to decide if store event here!
//      alifast.FillTree();
//      alifast.Clear();       // Clear all event lists
//   }
//   alifast.Finish();
//
//   // save objects in Root file
//   alifast.Write();  //save main alifast object (and run parameters)
//}
//========================================================================
//                                                                      //
// This example illustrates how to:                                     //
//    - Load a shared library                                           //
//    - Open a Root file                                                //
//    - Initialise AliFast                                              //
//    - Load some user code (interpreted)                               //
//      This user code may redefine some Maker parameters               //
//    - Make a loop on events                                           //
//    - Save histograms and the main AliFast object and its Makers      //
//                                                                      //
//========================================================================
//  An example of a User class is given below:                          //
//========================================================================
//
//#ifndef user_H
//#define user_H
//
//////////////////////////////////////////////////////////////////////////
//                                                                      //
// User                                                                 //
//                                                                      //
// Example of a user class to perform user specific tasks when running  //
// the ALIfast program.                                                 //
//                                                                      //
// This class illustrates:                                              //
//   - How to set run parameters                                        //
//   - How to create and fill histograms                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
//
//class TH1F;
//class AliFast;
//class AliFClusterMaker;
//class AliFPhotonMaker;
//
//class User {
//
//private:
//   TH1F             *fhist1;       //pointer to histogram
//   TH1F             *fhist2;       //pointer to histogram
//   TH1F             *fhist3;       //pointer to histogram
//public:
//               User();
//   void        FillHistograms();
//   void        SetRunParameters();
//
//#endif
//};
//
//_________________________________________________________________________
//User::User() 
//{
//   SetRunParameters();  //change default parameters
//
//         Create a few histograms
//   fhist1 = new TH1F("hist1","Number of tracks per event",100,0,100);
//   fhist2 = new TH1F("hist2","Number of clusters",100,0,100);
//   fhist3 = new TH1F("hist3","Number of isolated muons",20,0,20);
//}
//
//_________________________________________________________________________
//void User::FillHistograms()
//{
////   fhist1.Fill(event->GetNtracks());
////   fhist2.Fill(event->GetNclusters));
////   fhist3.Fill(event->GetNIsoMuons());
//}
//
//_________________________________________________________________________
//void User::SetRunParameters()
//{
//  // change Alifast default parameters
//
//   gAliFast->SetSmearMuonOpt(0);
//   gAliFast->ClusterMaker()->SetGranBarrelEta(0.12);
//   gAliFast->PhotonMaker()->SetMinPT(6.);
//   gAliFast->TriggerMaker()->SetMuoEtaCoverage(2.8);
//
//}
//======================end of User class=================================
//
//////////////////////////////////////////////////////////////////////////

//class TChain;

#include <TBrowser.h>
#include <TChain.h>
#include <TROOT.h>
#include <TTree.h>

#include "AliFast.h"
#include "AliFTrackMaker.h"


R__EXTERN AliRun * gAlice;

AliFast *gAliFast;

ClassImp(AliFast)


//_____________________________________________________________________________
AliFast::AliFast(): 
  AliRun("alifast","The ALICE fast simulation"),
  fVersion(0),
  fVersionDate(0),
  fMode(0),
  fTestTrack(0),
  fTree(0),
  fMakers(0),
  fMCMaker(0),
  fTrackMaker(0),
  fDet(new AliFDet("Detector","Make AliFast detector")),
  fLuminosity(0),
  fBfield(0),
  fSmearing(0),
  fSUSYcodeLSP(0),
  fTrackFinding(0),
  fFDisplay(0)
{
  //
  // Default constructor
  //

   gAliFast     = this;
   gAlice       = (AliRun*)this;
}

//_____________________________________________________________________________
AliFast::AliFast(const char *name, const char *title): 
  AliRun(name,title),
  fVersion(1), //AliFAST version number and release date
  fVersionDate(150399),
  fMode(0),
  fTestTrack(0),
  fTree(0),
  fMakers(new TList()), // support list for the lists of AliFast objects
  fMCMaker(0),
  fTrackMaker(new AliFTrackMaker("TrackMaker","Make AliFast tracks")),
  fDet(new AliFDet("Detector","Make AliFast detector")), // create detectors
  fLuminosity(0),
  fBfield(0),
  fSmearing(0),
  fSUSYcodeLSP(0),
  fTrackFinding(0),
  fFDisplay(0)
{
  //
  // Standard constructor
  //

   gAliFast      = this;
   
   SetDefaultParameters();

   gROOT->GetListOfBrowsables()->Add(this,"AliFast");

   // create "standard" makers and add them to the list of makers 
   // (in AliFMaker constructor)
   // Note that the order in which makers are added to the list of makers 
   // is important makers will be processed in this order !!

   //fMCMaker       = new AliFMCMaker("MCMaker","Make MC events");

}

//_______________________________________________________________________
AliFast::AliFast(const AliFast& afast):
  AliRun(afast),
  fVersion(0),
  fVersionDate(0),
  fMode(0),
  fTestTrack(0),
  fTree(0),
  fMakers(0),
  fMCMaker(0),
  fTrackMaker(0),
  fDet(0),
  fLuminosity(0),
  fBfield(0),
  fSmearing(0),
  fSUSYcodeLSP(0),
  fTrackFinding(0),
  fFDisplay(0)
{
  //
  // Copy constructor for AliRun
  //
  afast.Copy(*this);
}

//_____________________________________________________________________________
AliFast::~AliFast()
{
  //
  // Destructor
  //
//   fMakers->Delete();
//   delete fMakers;
}


//______________________________________________________________________________
void AliFast::Browse(TBrowser *b)
{
  //
  // To allow browsing of the class
  //

  if( b == 0) return;

  if (fTree) b->Add(fTree,fTree->GetName());
  // fca
  b->Add(&fHistBrowser, "Histograms");
  b->Add(&fBigBang, "BigBang");
  // fca

  TIter next(fMakers);
  AliFMaker *maker;
  while ((maker = (AliFMaker*)next())) {
     b->Add(maker,maker->GetName());
   }
}

//_____________________________________________________________________________
void AliFast::Clear(Option_t *option)
{
  //
  //    Reset lists of event objects
  //
   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->Clear(option);
   }
}

//_____________________________________________________________________________
void AliFast::Draw(Option_t */*option*/) const
{
  //
  //    Insert current event in graphics pad list
  // Check if the Event Display object has been created
  //
   if (!fFDisplay) {
      Error("Draw","You must create an AliFDisplay object first");
      return;
   }
}

//_____________________________________________________________________________
void  AliFast::GetTreeEvent(Int_t event)
{
  //
  //    Read event from Tree
  //
   if (fTree) fTree->GetEvent(event);
   fEvent = event;  
}

//_____________________________________________________________________________
void AliFast::Init()
{
  //
  //  Initialise detector
  //
   AliFDet *detector=gAliFast->Detector();  
   detector->InitDetParam(); 

//    Initialise makers
   TIter next(fMakers);
   AliFMaker *maker;
   TObject *objfirst, *objlast;
   while ((maker = (AliFMaker*)next())) {
     // save last created histogram in current Root directory
      objlast = gDirectory->GetList()->Last();

     // Initialise maker
      maker->Init();

     // Add Maker histograms in Maker list of histograms
      if (objlast) objfirst = gDirectory->GetList()->After(objlast);
      else         objfirst = gDirectory->GetList()->First();
      while (objfirst) {
         maker->Histograms()->Add(objfirst);
         objfirst = gDirectory->GetList()->After(objfirst);
      }
   }

}

//_____________________________________________________________________________
void AliFast::Paint(Option_t */*option*/)
{
  //
  //    Paint AliFast objects
  //
}

//_____________________________________________________________________________
void AliFast::PrintInfo()
{
  //
  //     Gives information about versions etc.
  //
   printf("\n\n");
   printf("**************************************************************\n");
   printf("*             AliFast version:00%1d     last update  %6d    *\n",
                                                       fVersion, fVersionDate);
   printf("**************************************************************\n");
   printf("*                                                            *\n");
   printf("*     Simulates and reconstructs  events on particle level   *\n");
   printf("*     Package by: Yiota Foka and Elzbieta Richter-Was        *\n");
   printf("*           Design based on ATLFast++                        *\n");
   printf("*         by R. Brun and E. Richter-Was                      *\n");
   printf("**************************************************************\n");
   printf("\n\n");

//     Print info for detector geometry
   AliFDet *detector=gAliFast->Detector();
   detector->PrintDetInfo(); 

//     Print info for all defined Makers
   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->PrintInfo();
   }
}

//_____________________________________________________________________________
void AliFast::FillTree()
{
  //
  //  Fill the ROOT tree, looping on all active branches
  //
  // Clean generated particles (depending on option Save)
  // MCMaker()->CleanParticles();
  //

  // Now ready to fill the Root Tree
   if(fTree) fTree->Fill();
}

//_____________________________________________________________________________
void AliFast::InitChain(TChain *chain)
{
  //
  //  Initialize branch addresses for all makers in a TChain
  //

   if (chain == 0) return;

   fTree = chain;

   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->SetChainAddress(chain);
   }
}

//_____________________________________________________________________________
void AliFast::MakeTree(const char* name, const char*title)
{
  //
  //  Create a ROOT tree
  //  Loop on all makers to create the Root branch (if any)
  //

   if (fTree) return;

   fTree = new TTree(name,title);

   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->MakeBranch();
   }
}

//_____________________________________________________________________________
void AliFast::SetDefaultParameters()
{
  //
  //    Setters for flags and switches
  //
   SetLuminosity();
   SetBfield();
   SetSmearing();
   SetSUSYcodeLSP();
   SetTrackFinding();
}

//_____________________________________________________________________________
void AliFast::Make(Int_t i)
{
  //
  // Main maker method
  //
   fEvent = i;

//   Loop on all makers
   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->Make();
   }

}

//_____________________________________________________________________________
void AliFast::FillClone()
{
  //
  // Fill Makers fruits clones
  //
   
   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->FillClone();
   }
}

//_____________________________________________________________________________
void AliFast::Finish()
{
  //
  //    Terminate a run
  //   place to make operations on histograms, normalization,etc.
  //

   TIter next(fMakers);
   AliFMaker *maker;
   while ((maker = (AliFMaker*)next())) {
      maker->Finish();
   }
}

//_____________________________________________________________________________
void AliFast::SortDown(Int_t n1, Float_t *a, Int_t *index, Bool_t down) const
{
//  sort the n1 elements of array a.
//  In output the array index contains the indices of the sorted array.
//  if down is false sort in increasing order (default is decreasing order)
//   This is a translation of the CERNLIB routine sortzv (M101)
//   based on the quicksort algorithm

   Int_t i,i1,n,i2,i3,i33,i222,iswap,n2;
   Int_t i22 = 0;
   Float_t ai;
   n = n1;
   if (n <= 0) return;
   if (n == 1) {index[0] = 0; return;}
   for (i=0;i<n;i++) index[i] = i+1;
   for (i1=2;i1<=n;i1++) {
      i3 = i1;
      i33 = index[i3-1];
      ai  = a[i33-1];
      while(1) {
         i2 = i3/2;
         if (i2 <= 0) break;
         i22 = index[i2-1];
         if (ai <= a[i22-1]) break;
         index[i3-1] = i22;
         i3 = i2;
      }
      index[i3-1] = i33;
   }

   while(1) {
      i3 = index[n-1];
      index[n-1] = index[0];
      ai = a[i3-1];
      n--;
      if(n-1 < 0) {index[0] = i3; break;}
      i1 = 1;
      while(2) {
         i2 = i1+i1;
         if (i2 <= n) i22 = index[i2-1];
         if (i2-n > 0) {index[i1-1] = i3; break;}
         if (i2-n < 0) {
            i222 = index[i2];
            if (a[i22-1] - a[i222-1] < 0) {
                i2++;
                i22 = i222;
            }
         }
         if (ai - a[i22-1] > 0) {index[i1-1] = i3; break;}
         index[i1-1] = i22;
         i1 = i2;
      }
   }
   if (!down) return;
   n2 = n1/2;
   for (i=0;i<n1;i++) index[i]--;
   for (i=0;i<n2;i++) {
      iswap         = index[i];
      index[i]      = index[n1-i-1];
      index[n1-i-1] = iswap;
   }
}
//______________________________________________________________________________
void AliFast::Streamer(TBuffer &R__b)
{
  //
  // Stream an object of class AliFast.
  //
   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      if (!gAliFast) gAliFast = this;
      gROOT->GetListOfBrowsables()->Add(this,"AliFast");
      
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      
      AliFast::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);

      fTree = (TTree*)gDirectory->Get("T");
   } else {
       AliFast::Class()->WriteBuffer(R__b,this);
   }
}
Commit	Line	Data
65a39007	1
	2	//////////////////////////////////////////////////////////////////////////
	3	// //
	4	// AliFast //
	5	// //
	6	// Main class to control the AliFast program. //
	7	// //
	8	// This class is a general framework for programs that needs to: //
	9	// - Initialise some parameters //
	10	// - Loop on events //
	11	// - Print results and save histograms, etc //
	12	// //
	13	// The event processor AliFast::Make loops on a list of Makers //
	14	// where each maker performs some task on the event data and generates //
	15	// results. //
	16	// New Makers can be inserted by a user without modifying this class. //
	17	// Note that the order in which the Makers are called is the order //
	18	// of insertion in the list of Makers. //
	19	// Each Maker is responsible for creating its branch of the Tree. //
	20	// The following table shows the list of makers currently implemented //
	21	// The default option to Save the Maker info in the Tree is mentioned. //
	22	// //
	23	// Maker name Save in Tree //
	24	// ========== ============ //
	25	// MCMaker NO //
	26	// TrackMaker NO //
	27	// //
	28	// Makers must derive from the base class AliFMaker. //
	29	// AliFMaker provides a common interface to all Makers. //
	30	// Each Maker is responsible for defining its own parameters and //
	31	// histograms. //
	32	// Each Maker has its own list of histograms. //
	33	// Each Maker has an associated companion class corresponding to the //
	34	// type of physics object reconstructed by the Maker. //
	35	// For example, AliFClusterMaker creates AliFCluster objects. //
	36	// AliFTriggerMaker creates one single AliFTrigger object. //
	37	// The pointer supporting the created object(s) is defined in AliFMaker //
	38	// fFruits may point to a single object (eg. AliFTrigger) or to a //
	39	// TClonesArray of objects (eg. AliFCluster). //
	40	// //
	41	// The function AliFast::Maketree must be called after the creation //
	42	// of the AliFast object to create a Root Tree. //
	43	// //
	44	// An example of main program/macro to use AliFast is given below: //
	45	//========================================================================
	46	//void umain(Int_t nevents=100)
	47	//{
	48	// gROOT->Reset();
	49	// gSystem->Load("libalifast.so"); // dynamically link the compiled shared library
	50	//
	51	// // Open the root output file
	52	// TFile file("alifast.root","recreate","AliFast root file",2);
	53	//
	54	// AliFast alifast("alifast"); // create main object to run alifast
	55	//
	56	// User user; // create an object of the User class defined in user.C
	57	//
	58	// alifast.Init(); // Initialise event (maker histograms,etc)
	59	// alifast.MakeTree(); // Create the Root tree
	60	//
	61	// gROOT->LoadMacro("user.C"); // compile/interpret user file
	62	//
	63	// for (Int_t i=0; i<nevents; i++) {
	64	// if (i%100 == 0) printf("In loop:%d\n",i);
65	// alifast.Make(i); // Generate and reconstruct event
66	// user.FillHistograms(); // User has possibility to decide if store event here!
67	// alifast.FillTree();
68	// alifast.Clear(); // Clear all event lists
69	// }
70	// alifast.Finish();
71	//
72	// // save objects in Root file
73	// alifast.Write(); //save main alifast object (and run parameters)
74	//}
75	//========================================================================
76	// //
77	// This example illustrates how to: //
78	// - Load a shared library //
79	// - Open a Root file //
80	// - Initialise AliFast //
81	// - Load some user code (interpreted) //
82	// This user code may redefine some Maker parameters //
83	// - Make a loop on events //
84	// - Save histograms and the main AliFast object and its Makers //
85	// //
86	//========================================================================
87	// An example of a User class is given below: //
88	//========================================================================
89	//
90	//#ifndef user_H
91	//#define user_H
92	//
93	//////////////////////////////////////////////////////////////////////////
94	// //
95	// User //
96	// //
97	// Example of a user class to perform user specific tasks when running //
98	// the ALIfast program. //
99	// //
100	// This class illustrates: //
101	// - How to set run parameters //
102	// - How to create and fill histograms //
103	// //
104	//////////////////////////////////////////////////////////////////////////
105	//
106	//class TH1F;
107	//class AliFast;
108	//class AliFClusterMaker;
109	//class AliFPhotonMaker;
110	//
111	//class User {
112	//
113	//private:
114	// TH1F *fhist1; //pointer to histogram
115	// TH1F *fhist2; //pointer to histogram
116	// TH1F *fhist3; //pointer to histogram
117	//public:
118	// User();
119	// void FillHistograms();
120	// void SetRunParameters();
121	//
122	//#endif
123	//};
124	//
125	//_________________________________________________________________________
126	//User::User()
127	//{
128	// SetRunParameters(); //change default parameters
129	//
130	// Create a few histograms
131	// fhist1 = new TH1F("hist1","Number of tracks per event",100,0,100);
132	// fhist2 = new TH1F("hist2","Number of clusters",100,0,100);
133	// fhist3 = new TH1F("hist3","Number of isolated muons",20,0,20);
134	//}
135	//
136	//_________________________________________________________________________
137	//void User::FillHistograms()
138	//{
139	//// fhist1.Fill(event->GetNtracks());
140	//// fhist2.Fill(event->GetNclusters));
141	//// fhist3.Fill(event->GetNIsoMuons());
142	//}
143	//
144	//_________________________________________________________________________
145	//void User::SetRunParameters()
146	//{
147	// // change Alifast default parameters
148	//
149	// gAliFast->SetSmearMuonOpt(0);
150	// gAliFast->ClusterMaker()->SetGranBarrelEta(0.12);
151	// gAliFast->PhotonMaker()->SetMinPT(6.);
152	// gAliFast->TriggerMaker()->SetMuoEtaCoverage(2.8);
153	//
154	//}
155	//======================end of User class=================================
156	//
157	//////////////////////////////////////////////////////////////////////////
158
4c155701	159	//class TChain;
	160
	161	#include <TBrowser.h>
65a39007	162	#include <TChain.h>
4c155701	163	#include <TROOT.h>
65a39007	164	#include <TTree.h>
4c155701	165
65a39007	166	#include "AliFast.h"
65a39007	167	#include "AliFTrackMaker.h"
65a39007	168
	169
	170	R__EXTERN AliRun * gAlice;
4c155701	171
65a39007	172	AliFast *gAliFast;
	173
	174	ClassImp(AliFast)
	175
	176
	177	//_____________________________________________________________________________
4c155701	178	AliFast::AliFast():
	179	AliRun("alifast","The ALICE fast simulation"),
	180	fVersion(0),
	181	fVersionDate(0),
	182	fMode(0),
	183	fTestTrack(0),
	184	fTree(0),
	185	fMakers(0),
	186	fMCMaker(0),
	187	fTrackMaker(0),
	188	fDet(new AliFDet("Detector","Make AliFast detector")),
	189	fLuminosity(0),
	190	fBfield(0),
	191	fSmearing(0),
	192	fSUSYcodeLSP(0),
	193	fTrackFinding(0),
	194	fFDisplay(0)
65a39007	195	{
4c155701	196	//
	197	// Default constructor
	198	//
65a39007	199
65a39007	200	gAliFast = this;
	201	gAlice = (AliRun*)this;
	202	}
	203
	204	//_____________________________________________________________________________
4c155701	205	AliFast::AliFast(const char name, const char title):
	206	AliRun(name,title),
	207	fVersion(1), //AliFAST version number and release date
	208	fVersionDate(150399),
	209	fMode(0),
	210	fTestTrack(0),
	211	fTree(0),
	212	fMakers(new TList()), // support list for the lists of AliFast objects
	213	fMCMaker(0),
	214	fTrackMaker(new AliFTrackMaker("TrackMaker","Make AliFast tracks")),
	215	fDet(new AliFDet("Detector","Make AliFast detector")), // create detectors
	216	fLuminosity(0),
	217	fBfield(0),
	218	fSmearing(0),
	219	fSUSYcodeLSP(0),
	220	fTrackFinding(0),
	221	fFDisplay(0)
65a39007	222	{
4c155701	223	//
	224	// Standard constructor
	225	//
65a39007	226
65a39007	227	gAliFast = this;
65a39007	228
	229	SetDefaultParameters();
	230
	231	gROOT->GetListOfBrowsables()->Add(this,"AliFast");
	232
4c155701	233	// create "standard" makers and add them to the list of makers
	234	// (in AliFMaker constructor)
	235	// Note that the order in which makers are added to the list of makers
	236	// is important makers will be processed in this order !!
65a39007	237
65a39007	238	//fMCMaker = new AliFMCMaker("MCMaker","Make MC events");
4c155701	239
	240	}
	241
	242	//_______________________________________________________________________
	243	AliFast::AliFast(const AliFast& afast):
	244	AliRun(afast),
	245	fVersion(0),
	246	fVersionDate(0),
	247	fMode(0),
	248	fTestTrack(0),
	249	fTree(0),
	250	fMakers(0),
	251	fMCMaker(0),
	252	fTrackMaker(0),
	253	fDet(0),
	254	fLuminosity(0),
	255	fBfield(0),
	256	fSmearing(0),
	257	fSUSYcodeLSP(0),
	258	fTrackFinding(0),
	259	fFDisplay(0)
	260	{
	261	//
	262	// Copy constructor for AliRun
	263	//
	264	afast.Copy(*this);
65a39007	265	}
	266
	267	//_____________________________________________________________________________
	268	AliFast::~AliFast()
	269	{
4c155701	270	//
	271	// Destructor
	272	//
65a39007	273	// fMakers->Delete();
	274	// delete fMakers;
	275	}
	276
	277
	278	//______________________________________________________________________________
	279	void AliFast::Browse(TBrowser *b)
	280	{
4c155701	281	//
	282	// To allow browsing of the class
	283	//
65a39007	284
	285	if( b == 0) return;
	286
	287	if (fTree) b->Add(fTree,fTree->GetName());
	288	// fca
	289	b->Add(&fHistBrowser, "Histograms");
	290	b->Add(&fBigBang, "BigBang");
	291	// fca
	292
	293	TIter next(fMakers);
	294	AliFMaker *maker;
	295	while ((maker = (AliFMaker*)next())) {
	296	b->Add(maker,maker->GetName());
	297	}
	298	}
	299
	300	//_____________________________________________________________________________
	301	void AliFast::Clear(Option_t *option)
	302	{
4c155701	303	//
	304	// Reset lists of event objects
	305	//
65a39007	306	TIter next(fMakers);
	307	AliFMaker *maker;
	308	while ((maker = (AliFMaker*)next())) {
	309	maker->Clear(option);
	310	}
65a39007	311	}
	312
	313	//_____________________________________________________________________________
4c155701	314	void AliFast::Draw(Option_t /option*/) const
65a39007	315	{
4c155701	316	//
	317	// Insert current event in graphics pad list
	318	// Check if the Event Display object has been created
	319	//
	320	if (!fFDisplay) {
65a39007	321	Error("Draw","You must create an AliFDisplay object first");
	322	return;
	323	}
65a39007	324	}
	325
	326	//_____________________________________________________________________________
	327	void AliFast::GetTreeEvent(Int_t event)
	328	{
4c155701	329	//
	330	// Read event from Tree
	331	//
65a39007	332	if (fTree) fTree->GetEvent(event);
	333	fEvent = event;
	334	}
	335
	336	//_____________________________________________________________________________
	337	void AliFast::Init()
	338	{
4c155701	339	//
	340	// Initialise detector
	341	//
65a39007	342	AliFDet *detector=gAliFast->Detector();
	343	detector->InitDetParam();
	344
	345	// Initialise makers
	346	TIter next(fMakers);
	347	AliFMaker *maker;
	348	TObject objfirst, objlast;
	349	while ((maker = (AliFMaker*)next())) {
	350	// save last created histogram in current Root directory
	351	objlast = gDirectory->GetList()->Last();
	352
	353	// Initialise maker
	354	maker->Init();
	355
	356	// Add Maker histograms in Maker list of histograms
	357	if (objlast) objfirst = gDirectory->GetList()->After(objlast);
	358	else objfirst = gDirectory->GetList()->First();
	359	while (objfirst) {
	360	maker->Histograms()->Add(objfirst);
	361	objfirst = gDirectory->GetList()->After(objfirst);
	362	}
	363	}
	364
	365	}
	366
	367	//_____________________________________________________________________________
8c907c33	368	void AliFast::Paint(Option_t /option*/)
65a39007	369	{
4c155701	370	//
	371	// Paint AliFast objects
	372	//
65a39007	373	}
	374
	375	//_____________________________________________________________________________
	376	void AliFast::PrintInfo()
	377	{
4c155701	378	//
	379	// Gives information about versions etc.
	380	//
65a39007	381	printf("\n\n");
	382	printf("**************************************************************\n");
	383	printf("* AliFast version:00%1d last update %6d *\n",
	384	fVersion, fVersionDate);
	385	printf("**************************************************************\n");
	386	printf("* *\n");
	387	printf("* Simulates and reconstructs events on particle level *\n");
	388	printf("* Package by: Yiota Foka and Elzbieta Richter-Was *\n");
	389	printf("* Design based on ATLFast++ *\n");
	390	printf("* by R. Brun and E. Richter-Was *\n");
	391	printf("**************************************************************\n");
	392	printf("\n\n");
	393
	394	// Print info for detector geometry
	395	AliFDet *detector=gAliFast->Detector();
	396	detector->PrintDetInfo();
	397
	398	// Print info for all defined Makers
	399	TIter next(fMakers);
	400	AliFMaker *maker;
	401	while ((maker = (AliFMaker*)next())) {
	402	maker->PrintInfo();
	403	}
	404	}
	405
	406	//_____________________________________________________________________________
	407	void AliFast::FillTree()
	408	{
4c155701	409	//
	410	// Fill the ROOT tree, looping on all active branches
	411	//
65a39007	412	// Clean generated particles (depending on option Save)
4c155701	413	// MCMaker()->CleanParticles();
4c155701	414	//
65a39007	415
	416	// Now ready to fill the Root Tree
	417	if(fTree) fTree->Fill();
	418	}
	419
	420	//_____________________________________________________________________________
	421	void AliFast::InitChain(TChain *chain)
	422	{
4c155701	423	//
	424	// Initialize branch addresses for all makers in a TChain
	425	//
65a39007	426
	427	if (chain == 0) return;
	428
	429	fTree = chain;
	430
	431	TIter next(fMakers);
	432	AliFMaker *maker;
	433	while ((maker = (AliFMaker*)next())) {
	434	maker->SetChainAddress(chain);
	435	}
	436	}
	437
	438	//_____________________________________________________________________________
	439	void AliFast::MakeTree(const char* name, const char*title)
	440	{
4c155701	441	//
	442	// Create a ROOT tree
	443	// Loop on all makers to create the Root branch (if any)
	444	//
65a39007	445
	446	if (fTree) return;
	447
	448	fTree = new TTree(name,title);
	449
	450	TIter next(fMakers);
	451	AliFMaker *maker;
	452	while ((maker = (AliFMaker*)next())) {
	453	maker->MakeBranch();
	454	}
	455	}
	456
	457	//_____________________________________________________________________________
	458	void AliFast::SetDefaultParameters()
	459	{
4c155701	460	//
	461	// Setters for flags and switches
	462	//
65a39007	463	SetLuminosity();
	464	SetBfield();
	465	SetSmearing();
	466	SetSUSYcodeLSP();
	467	SetTrackFinding();
	468	}
	469
	470	//_____________________________________________________________________________
	471	void AliFast::Make(Int_t i)
	472	{
4c155701	473	//
	474	// Main maker method
	475	//
65a39007	476	fEvent = i;
	477
	478	// Loop on all makers
	479	TIter next(fMakers);
	480	AliFMaker *maker;
	481	while ((maker = (AliFMaker*)next())) {
	482	maker->Make();
	483	}
	484
	485	}
	486
	487	//_____________________________________________________________________________
	488	void AliFast::FillClone()
	489	{
4c155701	490	//
	491	// Fill Makers fruits clones
	492	//
65a39007	493
	494	TIter next(fMakers);
	495	AliFMaker *maker;
	496	while ((maker = (AliFMaker*)next())) {
	497	maker->FillClone();
	498	}
	499	}
	500
	501	//_____________________________________________________________________________
	502	void AliFast::Finish()
	503	{
4c155701	504	//
	505	// Terminate a run
	506	// place to make operations on histograms, normalization,etc.
	507	//
65a39007	508
	509	TIter next(fMakers);
	510	AliFMaker *maker;
	511	while ((maker = (AliFMaker*)next())) {
	512	maker->Finish();
	513	}
	514	}
	515
	516	//_____________________________________________________________________________
4c155701	517	void AliFast::SortDown(Int_t n1, Float_t a, Int_t index, Bool_t down) const
65a39007	518	{
	519	// sort the n1 elements of array a.
	520	// In output the array index contains the indices of the sorted array.
	521	// if down is false sort in increasing order (default is decreasing order)
	522	// This is a translation of the CERNLIB routine sortzv (M101)
	523	// based on the quicksort algorithm
	524
	525	Int_t i,i1,n,i2,i3,i33,i222,iswap,n2;
	526	Int_t i22 = 0;
	527	Float_t ai;
	528	n = n1;
	529	if (n <= 0) return;
	530	if (n == 1) {index[0] = 0; return;}
	531	for (i=0;i<n;i++) index[i] = i+1;
	532	for (i1=2;i1<=n;i1++) {
	533	i3 = i1;
	534	i33 = index[i3-1];
	535	ai = a[i33-1];
	536	while(1) {
	537	i2 = i3/2;
	538	if (i2 <= 0) break;
	539	i22 = index[i2-1];
	540	if (ai <= a[i22-1]) break;
	541	index[i3-1] = i22;
	542	i3 = i2;
	543	}
	544	index[i3-1] = i33;
	545	}
	546
	547	while(1) {
	548	i3 = index[n-1];
	549	index[n-1] = index[0];
	550	ai = a[i3-1];
	551	n--;
	552	if(n-1 < 0) {index[0] = i3; break;}
	553	i1 = 1;
	554	while(2) {
	555	i2 = i1+i1;
	556	if (i2 <= n) i22 = index[i2-1];
	557	if (i2-n > 0) {index[i1-1] = i3; break;}
	558	if (i2-n < 0) {
	559	i222 = index[i2];
	560	if (a[i22-1] - a[i222-1] < 0) {
	561	i2++;
	562	i22 = i222;
	563	}
	564	}
	565	if (ai - a[i22-1] > 0) {index[i1-1] = i3; break;}
	566	index[i1-1] = i22;
	567	i1 = i2;
	568	}
	569	}
	570	if (!down) return;
	571	n2 = n1/2;
	572	for (i=0;i<n1;i++) index[i]--;
	573	for (i=0;i<n2;i++) {
	574	iswap = index[i];
	575	index[i] = index[n1-i-1];
	576	index[n1-i-1] = iswap;
	577	}
	578	}
	579	//______________________________________________________________________________
	580	void AliFast::Streamer(TBuffer &R__b)
	581	{
4c155701	582	//
	583	// Stream an object of class AliFast.
	584	//
65a39007	585	if (R__b.IsReading()) {
a8a6107b	586	UInt_t R__s, R__c;
65a39007	587	if (!gAliFast) gAliFast = this;
65a39007	588	gROOT->GetListOfBrowsables()->Add(this,"AliFast");
a8a6107b	589
	590	Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
	591
	592	AliFast::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
	593
65a39007	594	fTree = (TTree*)gDirectory->Get("T");
65a39007	595	} else {
a8a6107b	596	AliFast::Class()->WriteBuffer(R__b,this);
65a39007	597	}
	598	}
	599
	600
	601
	602
	603