[u/mrichter/AliRoot.git] / FMD / AliFMDInput.cxx

/**************************************************************************
 * Copyright(c) 2004, 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.                  *
 **************************************************************************/

/* $Id$ */

//___________________________________________________________________
//
// The classes defined here, are utility classes for reading in data
// for the FMD.  They are  put in a seperate library to not polute the
// normal libraries.  The classes are intended to be used as base
// classes for customized class that do some sort of analysis on the
// various types of data produced by the FMD. 
//
// Latest changes by Christian Holm Christensen
//
#include "AliFMDInput.h"	// ALIFMDHIT_H
#include "AliLog.h"		// ALILOG_H
#include "Riostream.h"		// ROOT_Riostream
#include <TDatabasePDG.h>
#include <TMath.h>
#include <TString.h>
#include <TParticle.h>
#include "AliFMDHit.h"		// ALIFMDHIT_H
#include "AliFMDDigit.h"		// ALIFMDDigit_H
#include "AliFMDMultStrip.h"		// ALIFMDMultStrip_H
#include "AliFMDMultRegion.h"		// ALIFMDMultRegion_H

//____________________________________________________________________
ClassImp(AliFMDInput)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif


//____________________________________________________________________
AliFMDInput::AliFMDInput()
  : fGAliceFile(""), 
    fLoader(0),
    fRun(0), 
    fStack(0),
    fFMDLoader(0), 
    fFMD(0),
    fTreeE(0),
    fTreeH(0),
    fTreeD(0),
    fTreeS(0),
    fTreeR(0), 
    fArrayE(0),
    fArrayH(0),
    fArrayD(0),
    fArrayS(0), 
    fArrayN(0), 
    fArrayP(0), 
    fTreeMask(0), 
    fIsInit(kFALSE)
{
  // Constructor of an FMD input object.  Specify what data to read in
  // using the AddLoad member function.   Sub-classes should at a
  // minimum overload the member function Event.   A full job can be
  // executed using the member function Run. 
}

  
//____________________________________________________________________
AliFMDInput::AliFMDInput(const char* gAliceFile)
  : fGAliceFile(gAliceFile),
    fLoader(0),
    fRun(0), 
    fStack(0),
    fFMDLoader(0), 
    fFMD(0),
    fTreeE(0),
    fTreeH(0),
    fTreeD(0),
    fTreeS(0),
    fTreeR(0), 
    fArrayE(0),
    fArrayH(0),
    fArrayD(0),
    fArrayS(0), 
    fArrayN(0), 
    fArrayP(0), 
    fTreeMask(0), 
    fIsInit(kFALSE)
{
  // Constructor of an FMD input object.  Specify what data to read in
  // using the AddLoad member function.   Sub-classes should at a
  // minimum overload the member function Event.   A full job can be
  // executed using the member function Run. 
}

//____________________________________________________________________
Int_t
AliFMDInput::NEvents() const 
{
  // Get number of events
  if (fTreeE) return fTreeE->GetEntries();
  return -1;
}

//____________________________________________________________________
Bool_t
AliFMDInput::Init()
{
  // Initialize the object.  Get the needed loaders, and such. 

  // Check if we have been initialized
  if (fIsInit) { 
    AliWarning("Already initialized");
    return fIsInit;
  }
  if (fGAliceFile.IsNull()) fGAliceFile = "galice.root";
  // Get the loader
  fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
  if (!fLoader) {
    AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
    return kFALSE;
  }
  
  // Get the run 
  if  (fLoader->LoadgAlice()) return kFALSE;
  fRun = fLoader->GetAliRun();
  
  // Get the FMD 
  fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
  if (!fFMD) {
    AliError("Failed to get detector FMD from loader");
    return kFALSE;
  }
  
  // Get the FMD loader
  fFMDLoader = fLoader->GetLoader("FMDLoader");
  if (!fFMDLoader) {
    AliError("Failed to get detector FMD loader from loader");
    return kFALSE;
  }
  if (fLoader->LoadHeader()) { 
    AliError("Failed to get event header information from loader");
    return kFALSE;
  }
  fTreeE = fLoader->TreeE();
  
  fIsInit = kTRUE;
  return fIsInit;
}

//____________________________________________________________________
Bool_t
AliFMDInput::Begin(Int_t event)
{
  // Called at the begining of each event.  Per default, it gets the
  // data trees and gets pointers to the output arrays.   Users can
  // overload this, but should call this member function in the
  // overloaded member function of the derived class. 

  // Check if we have been initialized
  if (!fIsInit) { 
    AliError("Not initialized");
    return fIsInit;
  }
  // Get the event 
  if (fLoader->GetEvent(event)) return kFALSE;
  AliInfo(Form("Now in event %d/%d", event, NEvents()));

  // Possibly load global kinematics information 
  if (TESTBIT(fTreeMask, kKinematics)) {
    AliInfo("Getting kinematics");
    if (fLoader->LoadKinematics()) return kFALSE;
    fStack = fLoader->Stack();
  }
  // Possibly load FMD Hit information 
  if (TESTBIT(fTreeMask, kHits)) {
    AliInfo("Getting FMD hits");
    if (fFMDLoader->LoadHits()) return kFALSE;
    fTreeH = fFMDLoader->TreeH();
    if (!fArrayH) fArrayH = fFMD->Hits(); 
  }
  // Possibly load FMD Digit information 
  if (TESTBIT(fTreeMask, kDigits)) {
    AliInfo("Getting FMD digits");
    if (fFMDLoader->LoadDigits()) return kFALSE;
    fTreeD = fFMDLoader->TreeD();
    if (!fArrayD) fArrayD = fFMD->Digits();
  }
  // Possibly load FMD Sdigit information 
  if (TESTBIT(fTreeMask, kSDigits)) {
    AliInfo("Getting FMD summable digits");
    if (fFMDLoader->LoadSDigits()) return kFALSE;
    fTreeS = fFMDLoader->TreeS();
    if (!fArrayS) fArrayS = fFMD->SDigits();
  }
  // Possibly load FMD RecPoints information 
  if (TESTBIT(fTreeMask, kRecPoints)) {
    AliInfo("Getting FMD reconstructed points");
    if (fFMDLoader->LoadRecPoints()) return kFALSE;
    fTreeR = fFMDLoader->TreeR();
    if (!fArrayN) fArrayN = new TClonesArray("AliFMDMultStrip");
    if (!fArrayP) fArrayP = new TClonesArray("AliFMDMultRegion");
    fTreeR->SetBranchAddress("FMDNaiive",  &fArrayN);
    fTreeR->SetBranchAddress("FMDPoisson", &fArrayP);
  }
  return kTRUE;
}

//____________________________________________________________________
Bool_t
AliFMDInput::End()
{
  // Called at the end of each event.  Per default, it unloads the
  // data trees and resets the pointers to the output arrays.   Users
  // can overload this, but should call this member function in the
  // overloaded member function of the derived class. 

  // Check if we have been initialized
  if (!fIsInit) { 
    AliError("Not initialized");
    return fIsInit;
  }
  // Possibly unload global kinematics information 
  if (TESTBIT(fTreeMask, kKinematics)) {
    fLoader->UnloadKinematics();
    // fTreeK = 0;
    fStack = 0;
  }
  // Possibly unload FMD Hit information 
  if (TESTBIT(fTreeMask, kHits)) {
    fFMDLoader->UnloadHits();
    fTreeH = 0;
  }
  // Possibly unload FMD Digit information 
  if (TESTBIT(fTreeMask, kDigits)) {
    fFMDLoader->UnloadDigits();
    fTreeD = 0;
  }
  // Possibly unload FMD Sdigit information 
  if (TESTBIT(fTreeMask, kSDigits)) {
    fFMDLoader->UnloadSDigits();
    fTreeS = 0;
  }
  // Possibly unload FMD RecPoints information 
  if (TESTBIT(fTreeMask, kRecPoints)) {
    fFMDLoader->UnloadRecPoints();
    fTreeR = 0;
  }
  AliInfo("Now out event");
  return kTRUE;
}

//____________________________________________________________________
Bool_t
AliFMDInput::Run()
{
  // Run over all events and files references in galice.root 

  Bool_t retval;
  if (!(retval = Init())) return retval;

  Int_t nEvents = NEvents();
  for (Int_t event = 0; event < nEvents; event++) {
    if (!(retval = Begin(event))) break;
    if (!(retval = Event())) break;
    if (!(retval = End())) break;
  }
  if (!retval) return retval;
  retval = Finish();
  return retval;
}

//====================================================================
ClassImp(AliFMDInputHits)
#if 0
  ;
#endif

Bool_t
AliFMDInputHits::Event()
{
  // Read the hit tree, and pass each hit to the member function
  // ProcessHit.  Optionally, if the user said `AddLoad(kKinematics)'
  // the track corresponding to the hit will also be passed to the
  // ProcessHit member function of the derived class.
  if (!fTreeH) {
    AliError("No hit tree defined");
    return kFALSE;
  }
  Int_t nTracks = fTreeH->GetEntries();
  for (Int_t i = 0; i < nTracks; i++) {
    Int_t hitRead  = fTreeH->GetEntry(i);
    if (hitRead <= 0) continue;
    if (!fArrayH) {
      AliError("No hit array defined");
      return kFALSE;
    }
    Int_t nHit = fArrayH->GetEntries();
    if (nHit <= 0) continue;
    for (Int_t j = 0; j < nHit; j++) {
      AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
      if (!hit) continue;
      TParticle* track = 0;
      if (TESTBIT(fTreeMask, kKinematics) && fStack) {
	Int_t trackno = hit->Track();
	track = fStack->Particle(trackno);
      }
      if (!ProcessHit(hit, track)) return kFALSE;
    }    
  }
  return kTRUE;
}

//====================================================================
ClassImp(AliFMDInputDigits)
#if 0
  ;
#endif

Bool_t
AliFMDInputDigits::Event()
{
  // Read the digit tree, and pass each digit to the member function
  // ProcessDigit.
  Int_t nEv = fTreeD->GetEntries();
  for (Int_t i = 0; i < nEv; i++) {
    Int_t digitRead  = fTreeD->GetEntry(i);
    if (digitRead <= 0) continue;
    Int_t nDigit = fArrayD->GetEntries();
    if (nDigit <= 0) continue;
    for (Int_t j = 0; j < nDigit; j++) {
      AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayD->At(j));
      if (!digit) continue;
      if (!ProcessDigit(digit)) return kFALSE;
    }    
  }
  return kTRUE;
}

//====================================================================
ClassImp(AliFMDInputSDigits)
#if 0
  ;
#endif

Bool_t
AliFMDInputSDigits::Event()
{
  // Read the summable digit tree, and pass each sumable digit to the
  // member function ProcessSdigit.
  Int_t nEv = fTreeD->GetEntries();
  for (Int_t i = 0; i < nEv; i++) {
    Int_t sdigitRead  = fTreeS->GetEntry(i);
    if (sdigitRead <= 0) continue;
    Int_t nSdigit = fArrayS->GetEntries();
    if (nSdigit <= 0) continue;
    for (Int_t j = 0; j < nSdigit; j++) {
      AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fArrayS->At(j));
      if (!sdigit) continue;
      if (!ProcessSDigit(sdigit)) return kFALSE;
    }    
  }
  return kTRUE;
}

//====================================================================
ClassImp(AliFMDInputRecPoints)
#if 0
  ;
#endif

Bool_t
AliFMDInputRecPoints::Event()
{
  // Read the reconstrcted points tree, and pass each reconstruction
  // object to either ProcessStrip (for AliFMDMultStrip objects), or 
  // ProcessRegion (for AliFMDMultRegion objects).
  Int_t nEv = fTreeR->GetEntries();
  for (Int_t i = 0; i < nEv; i++) {
    Int_t recRead  = fTreeR->GetEntry(i);
    if (recRead <= 0) continue;
    Int_t nRecStrip = fArrayN->GetEntries();
    for (Int_t j = 0; j < nRecStrip; j++) {
      AliFMDMultStrip* strip = static_cast<AliFMDMultStrip*>(fArrayN->At(j));
      if (!strip) continue;
      if (!ProcessStrip(strip)) return kFALSE;
    }    
    Int_t nRecRegion = fArrayP->GetEntries();
    for (Int_t j = 0; j < nRecRegion; j++) {
      AliFMDMultRegion* region =static_cast<AliFMDMultRegion*>(fArrayP->At(j));
      if (!region) continue;
      if (!ProcessRegion(region)) return kFALSE;
    }    
  }
  return kTRUE;
}

    
//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
a1f80595	1	/**************************************************************************
	2	* Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	//___________________________________________________________________
	19	//
	20	// The classes defined here, are utility classes for reading in data
	21	// for the FMD. They are put in a seperate library to not polute the
	22	// normal libraries. The classes are intended to be used as base
	23	// classes for customized class that do some sort of analysis on the
	24	// various types of data produced by the FMD.
	25	//
	26	// Latest changes by Christian Holm Christensen
	27	//
	28	#include "AliFMDInput.h" // ALIFMDHIT_H
	29	#include "AliLog.h" // ALILOG_H
	30	#include "Riostream.h" // ROOT_Riostream
	31	#include <TDatabasePDG.h>
	32	#include <TMath.h>
	33	#include <TString.h>
	34	#include <TParticle.h>
	35	#include "AliFMDHit.h" // ALIFMDHIT_H
	36	#include "AliFMDDigit.h" // ALIFMDDigit_H
	37	#include "AliFMDMultStrip.h" // ALIFMDMultStrip_H
	38	#include "AliFMDMultRegion.h" // ALIFMDMultRegion_H
	39
	40	//____________________________________________________________________
	41	ClassImp(AliFMDInput)
	42	#if 0
	43	; // This is here to keep Emacs for indenting the next line
	44	#endif
	45
	46
	47	//____________________________________________________________________
	48	AliFMDInput::AliFMDInput()
	49	: fGAliceFile(""),
	50	fLoader(0),
	51	fRun(0),
	52	fStack(0),
	53	fFMDLoader(0),
	54	fFMD(0),
	55	fTreeE(0),
	56	fTreeH(0),
	57	fTreeD(0),
	58	fTreeS(0),
	59	fTreeR(0),
	60	fArrayE(0),
	61	fArrayH(0),
	62	fArrayD(0),
	63	fArrayS(0),
	64	fArrayN(0),
65	fArrayP(0),
66	fTreeMask(0),
67	fIsInit(kFALSE)
68	{
69	// Constructor of an FMD input object. Specify what data to read in
70	// using the AddLoad member function. Sub-classes should at a
71	// minimum overload the member function Event. A full job can be
72	// executed using the member function Run.
73	}
74
75
76
77	//____________________________________________________________________
78	AliFMDInput::AliFMDInput(const char* gAliceFile)
79	: fGAliceFile(gAliceFile),
80	fLoader(0),
81	fRun(0),
82	fStack(0),
83	fFMDLoader(0),
84	fFMD(0),
85	fTreeE(0),
86	fTreeH(0),
87	fTreeD(0),
88	fTreeS(0),
89	fTreeR(0),
90	fArrayE(0),
91	fArrayH(0),
92	fArrayD(0),
93	fArrayS(0),
94	fArrayN(0),
95	fArrayP(0),
96	fTreeMask(0),
97	fIsInit(kFALSE)
98	{
99	// Constructor of an FMD input object. Specify what data to read in
100	// using the AddLoad member function. Sub-classes should at a
101	// minimum overload the member function Event. A full job can be
102	// executed using the member function Run.
103	}
104
105	//____________________________________________________________________
106	Int_t
107	AliFMDInput::NEvents() const
108	{
109	// Get number of events
110	if (fTreeE) return fTreeE->GetEntries();
111	return -1;
112	}
113
114	//____________________________________________________________________
115	Bool_t
116	AliFMDInput::Init()
117	{
118	// Initialize the object. Get the needed loaders, and such.
119
120	// Check if we have been initialized
121	if (fIsInit) {
122	AliWarning("Already initialized");
123	return fIsInit;
124	}
125	if (fGAliceFile.IsNull()) fGAliceFile = "galice.root";
126	// Get the loader
127	fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
128	if (!fLoader) {
129	AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
130	return kFALSE;
131	}
132
133	// Get the run
134	if (fLoader->LoadgAlice()) return kFALSE;
135	fRun = fLoader->GetAliRun();
136
137	// Get the FMD
138	fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
139	if (!fFMD) {
140	AliError("Failed to get detector FMD from loader");
141	return kFALSE;
142	}
143
144	// Get the FMD loader
145	fFMDLoader = fLoader->GetLoader("FMDLoader");
146	if (!fFMDLoader) {
147	AliError("Failed to get detector FMD loader from loader");
148	return kFALSE;
149	}
150	if (fLoader->LoadHeader()) {
151	AliError("Failed to get event header information from loader");
152	return kFALSE;
153	}
154	fTreeE = fLoader->TreeE();
155
156	fIsInit = kTRUE;
157	return fIsInit;
158	}
159
160	//____________________________________________________________________
161	Bool_t
162	AliFMDInput::Begin(Int_t event)
163	{
164	// Called at the begining of each event. Per default, it gets the
165	// data trees and gets pointers to the output arrays. Users can
166	// overload this, but should call this member function in the
167	// overloaded member function of the derived class.
168
169	// Check if we have been initialized
170	if (!fIsInit) {
171	AliError("Not initialized");
172	return fIsInit;
173	}
174	// Get the event
175	if (fLoader->GetEvent(event)) return kFALSE;
176	AliInfo(Form("Now in event %d/%d", event, NEvents()));
177
178	// Possibly load global kinematics information
179	if (TESTBIT(fTreeMask, kKinematics)) {
180	AliInfo("Getting kinematics");
181	if (fLoader->LoadKinematics()) return kFALSE;
182	fStack = fLoader->Stack();
183	}
184	// Possibly load FMD Hit information
185	if (TESTBIT(fTreeMask, kHits)) {
186	AliInfo("Getting FMD hits");
187	if (fFMDLoader->LoadHits()) return kFALSE;
188	fTreeH = fFMDLoader->TreeH();
189	if (!fArrayH) fArrayH = fFMD->Hits();
190	}
191	// Possibly load FMD Digit information
192	if (TESTBIT(fTreeMask, kDigits)) {
193	AliInfo("Getting FMD digits");
194	if (fFMDLoader->LoadDigits()) return kFALSE;
195	fTreeD = fFMDLoader->TreeD();
196	if (!fArrayD) fArrayD = fFMD->Digits();
197	}
198	// Possibly load FMD Sdigit information
199	if (TESTBIT(fTreeMask, kSDigits)) {
200	AliInfo("Getting FMD summable digits");
201	if (fFMDLoader->LoadSDigits()) return kFALSE;
202	fTreeS = fFMDLoader->TreeS();
203	if (!fArrayS) fArrayS = fFMD->SDigits();
204	}
205	// Possibly load FMD RecPoints information
206	if (TESTBIT(fTreeMask, kRecPoints)) {
207	AliInfo("Getting FMD reconstructed points");
208	if (fFMDLoader->LoadRecPoints()) return kFALSE;
209	fTreeR = fFMDLoader->TreeR();
210	if (!fArrayN) fArrayN = new TClonesArray("AliFMDMultStrip");
211	if (!fArrayP) fArrayP = new TClonesArray("AliFMDMultRegion");
212	fTreeR->SetBranchAddress("FMDNaiive", &fArrayN);
213	fTreeR->SetBranchAddress("FMDPoisson", &fArrayP);
214	}
215	return kTRUE;
216	}
217
218	//____________________________________________________________________
219	Bool_t
220	AliFMDInput::End()
221	{
222	// Called at the end of each event. Per default, it unloads the
223	// data trees and resets the pointers to the output arrays. Users
224	// can overload this, but should call this member function in the
225	// overloaded member function of the derived class.
226
227	// Check if we have been initialized
228	if (!fIsInit) {
229	AliError("Not initialized");
230	return fIsInit;
231	}
232	// Possibly unload global kinematics information
233	if (TESTBIT(fTreeMask, kKinematics)) {
234	fLoader->UnloadKinematics();
235	// fTreeK = 0;
236	fStack = 0;
237	}
238	// Possibly unload FMD Hit information
239	if (TESTBIT(fTreeMask, kHits)) {
240	fFMDLoader->UnloadHits();
241	fTreeH = 0;
242	}
243	// Possibly unload FMD Digit information
244	if (TESTBIT(fTreeMask, kDigits)) {
245	fFMDLoader->UnloadDigits();
246	fTreeD = 0;
247	}
248	// Possibly unload FMD Sdigit information
249	if (TESTBIT(fTreeMask, kSDigits)) {
250	fFMDLoader->UnloadSDigits();
251	fTreeS = 0;
252	}
253	// Possibly unload FMD RecPoints information
254	if (TESTBIT(fTreeMask, kRecPoints)) {
255	fFMDLoader->UnloadRecPoints();
256	fTreeR = 0;
257	}
258	AliInfo("Now out event");
259	return kTRUE;
260	}
261
262	//____________________________________________________________________
263	Bool_t
264	AliFMDInput::Run()
265	{
266	// Run over all events and files references in galice.root
267
268	Bool_t retval;
269	if (!(retval = Init())) return retval;
270
271	Int_t nEvents = NEvents();
272	for (Int_t event = 0; event < nEvents; event++) {
273	if (!(retval = Begin(event))) break;
274	if (!(retval = Event())) break;
275	if (!(retval = End())) break;
276	}
277	if (!retval) return retval;
278	retval = Finish();
279	return retval;
280	}
281
282	//====================================================================
283	ClassImp(AliFMDInputHits)
284	#if 0
285	;
286	#endif
287
288	Bool_t
289	AliFMDInputHits::Event()
290	{
291	// Read the hit tree, and pass each hit to the member function
292	// ProcessHit. Optionally, if the user said `AddLoad(kKinematics)'
293	// the track corresponding to the hit will also be passed to the
294	// ProcessHit member function of the derived class.
295	if (!fTreeH) {
296	AliError("No hit tree defined");
297	return kFALSE;
298	}
299	Int_t nTracks = fTreeH->GetEntries();
300	for (Int_t i = 0; i < nTracks; i++) {
301	Int_t hitRead = fTreeH->GetEntry(i);
302	if (hitRead <= 0) continue;
303	if (!fArrayH) {
304	AliError("No hit array defined");
305	return kFALSE;
306	}
307	Int_t nHit = fArrayH->GetEntries();
308	if (nHit <= 0) continue;
309	for (Int_t j = 0; j < nHit; j++) {
310	AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
311	if (!hit) continue;
312	TParticle* track = 0;
313	if (TESTBIT(fTreeMask, kKinematics) && fStack) {
314	Int_t trackno = hit->Track();
315	track = fStack->Particle(trackno);
316	}
317	if (!ProcessHit(hit, track)) return kFALSE;
318	}
319	}
320	return kTRUE;
321	}
322
323	//====================================================================
324	ClassImp(AliFMDInputDigits)
325	#if 0
326	;
327	#endif
328
329	Bool_t
330	AliFMDInputDigits::Event()
331	{
332	// Read the digit tree, and pass each digit to the member function
333	// ProcessDigit.
334	Int_t nEv = fTreeD->GetEntries();
335	for (Int_t i = 0; i < nEv; i++) {
336	Int_t digitRead = fTreeD->GetEntry(i);
337	if (digitRead <= 0) continue;
338	Int_t nDigit = fArrayD->GetEntries();
339	if (nDigit <= 0) continue;
340	for (Int_t j = 0; j < nDigit; j++) {
341	AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayD->At(j));
342	if (!digit) continue;
343	if (!ProcessDigit(digit)) return kFALSE;
344	}
345	}
346	return kTRUE;
347	}
348
349	//====================================================================
350	ClassImp(AliFMDInputSDigits)
351	#if 0
352	;
353	#endif
354
355	Bool_t
356	AliFMDInputSDigits::Event()
357	{
358	// Read the summable digit tree, and pass each sumable digit to the
359	// member function ProcessSdigit.
360	Int_t nEv = fTreeD->GetEntries();
361	for (Int_t i = 0; i < nEv; i++) {
362	Int_t sdigitRead = fTreeS->GetEntry(i);
363	if (sdigitRead <= 0) continue;
364	Int_t nSdigit = fArrayS->GetEntries();
365	if (nSdigit <= 0) continue;
366	for (Int_t j = 0; j < nSdigit; j++) {
367	AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fArrayS->At(j));
368	if (!sdigit) continue;
369	if (!ProcessSDigit(sdigit)) return kFALSE;
370	}
371	}
372	return kTRUE;
373	}
374
375	//====================================================================
376	ClassImp(AliFMDInputRecPoints)
377	#if 0
378	;
379	#endif
380
381	Bool_t
382	AliFMDInputRecPoints::Event()
383	{
384	// Read the reconstrcted points tree, and pass each reconstruction
385	// object to either ProcessStrip (for AliFMDMultStrip objects), or
386	// ProcessRegion (for AliFMDMultRegion objects).
387	Int_t nEv = fTreeR->GetEntries();
388	for (Int_t i = 0; i < nEv; i++) {
389	Int_t recRead = fTreeR->GetEntry(i);
390	if (recRead <= 0) continue;
391	Int_t nRecStrip = fArrayN->GetEntries();
392	for (Int_t j = 0; j < nRecStrip; j++) {
393	AliFMDMultStrip* strip = static_cast<AliFMDMultStrip*>(fArrayN->At(j));
394	if (!strip) continue;
395	if (!ProcessStrip(strip)) return kFALSE;
396	}
397	Int_t nRecRegion = fArrayP->GetEntries();
398	for (Int_t j = 0; j < nRecRegion; j++) {
399	AliFMDMultRegion* region =static_cast<AliFMDMultRegion*>(fArrayP->At(j));
400	if (!region) continue;
401	if (!ProcessRegion(region)) return kFALSE;
402	}
403	}
404	return kTRUE;
405	}
406
407
408
409	//____________________________________________________________________
410	//
411	// EOF
412	//