[u/mrichter/AliRoot.git] / TRD / AliTRDptrgTLMU.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  Pre-Trigger simulation                                                //
//                                                                        //
//  Authors: F. Reidt (Felix.Reidt@cern.ch)                               //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "TFile.h"
#include "TROOT.h"

#include "TClonesArray.h"

#include "AliRun.h"
#include "AliRunLoader.h"

#include "../TOF/AliTOFdigit.h"
#include "../RAW/AliRawReader.h" // needed for AliTOFTrigger's raw digit support
#include "../TOF/AliTOFTrigger.h"

#include "AliTRDptrgParam.h"

#include "AliTRDptrgTLMU.h"

ClassImp(AliTRDptrgTLMU)

//______________________________________________________________________________
AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl) 
  : TObject(),
  fRunLoader(rl),
  fParam(0x0),
  fOperatingMode(kDigits),
  fInputMask(0x0),
  fCMatrices(0x0),
  fMultiplicity(0x0),
  fOutput(0x0) 
{
  // default ctor
 
  for (Int_t i = 0; i < 18; i++) {
    this->fInputTOFinputBits[i] = 0;
  }
}

//______________________________________________________________________________
AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl,  AliTRDptrgParam *param,
                               AliTRDptrgOperatingMode_t operatingMode)
  : TObject(),
  fRunLoader(rl),
  fParam(param),
  fOperatingMode(operatingMode),
  fInputMask(0x0),
  fCMatrices(0x0),
  fMultiplicity(0x0),
  fOutput(0x0) 
{
  // recommended ctor
  
  for (Int_t i = 0; i < 18; i++) {
    this->fInputTOFinputBits[i] = 0;
  }
 
  this->LoadParams();
}

//______________________________________________________________________________
AliTRDptrgTLMU::~AliTRDptrgTLMU() 
{
  // destructor
  
  this->fCMatrices = 0x0;
  this->fMultiplicity = 0x0;
  this->fOutput = 0x0;
}

//______________________________________________________________________________
Int_t* AliTRDptrgTLMU::Simulate() 
{
  // starts a simulation
	
  if (this->fOperatingMode == kDigits) {
    this->LoadDigits();
  }	
  else if (this->fOperatingMode == kHits) {
    return 0x0; // TODO
  }

  // which super modules are active? - needed for fast coincidence processing:  
  // M(sm | coincidence condition)>=2
  UInt_t temp = 0x1;
  UInt_t sm = 0x0; 
  for (Int_t iSM = 0; iSM < 18; iSM++) {
    if (this->Or(iSM)) {
      sm |= temp;
    }
    temp <<= 1;
  }
  AliDebug(4, Form("Active supermodules: 0x%x", sm));

  // get multiplicity
  UInt_t multiplicity = this->GetMultiplicitySum();
  AliDebug(4, Form("TOF/TLMU multiplicity: %d", multiplicity)); 	

  Int_t* result = new Int_t[9]; 
  result[0] = 8;
  for (Int_t iResult = 0; iResult < 8; iResult++) {
    result[iResult + 1] = 0;

    // coincidence matrix
    if (this->fOutput[iResult][0] != -1) {
      for (Int_t iLine = 0; iLine < 18; iLine++) {
        if (this->GetBitVectorMultiplicity(
	     sm | this->fCMatrices[this->fOutput[iResult][0]][iLine]) > 1) {
	  result[iResult + 1] = 1;
          break;
	}        
      }
    }
    
    // multiplicity conditions
    if (this->fOutput[iResult][1] != -1) {
      AliDebug(5, Form("Entry %d, slice: %d", iResult, 
                       this->fOutput[iResult][1]));
      if ((this->fMultiplicity[this->fOutput[iResult][1]][0] < multiplicity) &&
          (this->fMultiplicity[this->fOutput[iResult][1]][1] >= multiplicity)) {
        result[iResult + 1] = 1;
      } 
    }
    AliDebug(4, Form("TLMU result[%d] = %d", iResult, result[iResult + 1]));
  }

  return result;
}

//______________________________________________________________________________
Int_t AliTRDptrgTLMU::LoadDigits()
{
  // loads Digits (for usage with aquired data)
  this->GetInputBits(); // get bits from AliTOFTrigger
  return 0;
}


//______________________________________________________________________________
Bool_t AliTRDptrgTLMU::LoadParams()
{
  // load AliTRDprtgParam content
	
  if (this->fParam == 0x0) {
    // no parameter object assigned
    AliWarning("no parameter object assigned - using default settings!");

    AliError("no default settings available!");
    // TODO
  }
  else {
    // parameter object assigned
    
    this->fInputMask = this->fParam->GetTLMUInputMask(); 
    // input mask for TOF-bits (18x32=576)
    
    this->fCMatrices = this->fParam->GetTLMUcmatrices();
    // get coincidence matrices
 
    this->fMultiplicity = this->fParam->GetTLMUmultiplicity();
    // get multiplicity slices
  
    this->fOutput = this->fParam->GetTLMUoutput();
    // get output signal assignment
  }

  return false;
}

//______________________________________________________________________________
void AliTRDptrgTLMU::GetInputBits() {
  // Gets TOF-to-TRD input bits from AliTOFTrigger as Bool_t array

  AliTOFTrigger *toftrig = new AliTOFTrigger(); // create AliTOFTrigger 
  toftrig->CreateLTMMatrixFromDigits(); // Generate LTMMatrix from AliTOFdigits
  
  // prepare map  
  Bool_t** map = 0x0;
  map = new Bool_t*[72];
  for (Int_t i=0; i < 72; i++) 
    map[i] = new Bool_t[8];
  
  // initialise map
  for (Int_t i=0; i < 72; i++)
    for (Int_t j=0; j < 8; j++)
      map[i][j] = 0;

  // get 576 TOF-to-TRD bits
  toftrig->GetTRDmap(map);

  /* DEBUG output 
  // used to determine the correct bit assignment
  for (Int_t i=0; i < 72; i++) {
    AliDebug(5, Form("%d ", i));
    for (Int_t j=7; j >= 0; j--) {
      AliDebug(5, Form("%d", map[i][j])); 
    }
  }
  //*/ // end of DEBUG output
  
 
  // transform Bool_t array to UInt_t bitvectors according to
  // http://www.physi.uni-heidelberg.de/~schicker/cbtof/cbtof_docu.pdf
  // chapter 1.4 and 2.1 to a supermodule based structured 
  // integer (bit) array
  Int_t supermodule = -1;
  UInt_t tempA = 0x00000001;
  UInt_t tempC = 0x00010000;
  for (Int_t iLTM = 0; iLTM < (kNLTM / 2); iLTM++) {
    if (!(iLTM % 2)) { // renew temp vectors, update supermodule
      tempA = 0x00000001;
      tempC = 0x00010000;
      supermodule++;
    }
    AliDebug(5, Form("(%2d,0x%8x,0x%8x)", iLTM, tempA, tempC));
    for (Int_t iLTMchan = 0; iLTMchan < 8; iLTMchan++) {
      // A-side
      if (map[iLTM][iLTMchan]) {
        this->fInputTOFinputBits[supermodule] |= tempA;        
      }
      // C-side
      if (map[iLTM + 36][iLTMchan]) {
        this->fInputTOFinputBits[supermodule] |= tempC;
      }
      // change temp vectors
      tempA <<= 1;
      tempC <<= 1;
    }
  }

  // handle input mask
  for (Int_t iSM = 0; iSM < 18; iSM++) {
    AliDebug(5, Form("fInputTOFinputBits[%d]=0x%x", iSM, 
             this->fInputTOFinputBits[iSM]));
    this->fInputTOFinputBits[iSM] &= this->fInputMask[iSM];
  }
}


//______________________________________________________________________________
Int_t AliTRDptrgTLMU::BackToBack(Int_t iSM, Int_t range) {
  // Check whether there is an back-to-back particle trace

  // get the counterpart of supermodule iSM
  Int_t counterPart = -1;
  if (iSM >= 9) { 
    counterPart = iSM - 9;
  }
  else  {
    counterPart = iSM + 9;
  }

  if (this->Or(iSM)) { // is there are active bits in supermodule iSM
    Int_t result = 0;
    for (Int_t i = counterPart - range; i <= counterPart + range; i++) {
      // TODO WARNING: There are possible Errors with sm0 +-range!
      // check whether there are active bits in supermodule i (counterParts)
      if ((i >= 0) && (i < 18)) {
        if (Or(i)) {
          result++;
        }
      }
      else {
	if (i < 0) {
          if (Or(17 - i)) {
            result++;
          }
        }
        if (i > 17) {
          if (Or(i - 18)) {
            result++;
          }
        }
      }
    }
    AliDebug(5, Form("BackToBack of %d and %d+-%d\n: %d", iSM, counterPart, 
                     range, result));
    return result; // return whether there was a possible back-to-back trace
  }    
  else {
    AliDebug(5, Form("BackToBack unsuccessful, not hit in sm%d", iSM));
    return 0; // iSM did not recognize anything
  }
}

//______________________________________________________________________________
Int_t AliTRDptrgTLMU::Coincidence(Int_t iSM1, Int_t iSM2) {
  // checks whether there is an coincidence in iSM1 and iSM2

  if (this->Or(iSM1) && this->Or(iSM2)) {
    return 1;
  }
  else
    return 0;
}

//______________________________________________________________________________
inline Int_t AliTRDptrgTLMU::Or(Int_t  iSM) {
  // returns 1 if one or more bits are active in supermodule iSM
 
  if ((iSM >= 0) && (iSM < 18)) {
    if (this->fInputTOFinputBits[iSM] > 0)
      return 1;
    else
      return 0; 
  }
  else {
    return -1;
  }
}

//______________________________________________________________________________
Int_t AliTRDptrgTLMU::GetMultiplicity(Int_t iSM) {
  // counts how many bits equal one are in class member fInputTOFinputBits[iSM]
  // (32bits from TOF to TRD of supermodule iSM)

  UInt_t temp = this->fInputTOFinputBits[iSM];
  UInt_t mask = 0x01;
  Int_t multiplicity = 0;  
	
  // TODO maybe there is a more efficient way to do that?
  for (int iBit = 0; iBit < 32; iBit++) {
    if ((mask & temp) != 0x0) { // is the bit equal one?
      multiplicity++;
    }
    mask <<= 1; // rotate mask to the left after each iteration
  }
  AliDebug(5, Form("Multiplicity of supermodule %d: %d", iSM, multiplicity));
  return multiplicity;
}

//______________________________________________________________________________
Int_t AliTRDptrgTLMU::GetMultiplicitySum() {
  // returns the multiplicity of the whole detector (all 576bit TOF to TRD bits)
  Int_t sum = 0;
  
  for (Int_t i = 0; i < 18; i++) {
    sum += this->GetMultiplicity(i);
  }
  AliDebug(5, Form("Whole multiplicity: %d", sum));
  return sum;
}

//______________________________________________________________________________
UInt_t AliTRDptrgTLMU::GetBitVectorMultiplicity(UInt_t BitVector) {
  // returns the multiplicity of a given bit vector
  
  UInt_t result = 0;
  UInt_t temp = 0x01;
  for (UInt_t iBit = 0; iBit < 32; iBit++) {
    if (BitVector & temp) {
      result++;
    }
    temp <<= 1;
  }

  return result;
}
Commit	Line	Data
f9720615	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	// Pre-Trigger simulation //
	21	// //
	22	// Authors: F. Reidt (Felix.Reidt@cern.ch) //
	23	// //
	24	////////////////////////////////////////////////////////////////////////////
	25
	26	#include "TFile.h"
	27	#include "TROOT.h"
	28
	29	#include "TClonesArray.h"
	30
	31	#include "AliRun.h"
	32	#include "AliRunLoader.h"
	33
	34	#include "../TOF/AliTOFdigit.h"
	35	#include "../RAW/AliRawReader.h" // needed for AliTOFTrigger's raw digit support
	36	#include "../TOF/AliTOFTrigger.h"
	37
	38	#include "AliTRDptrgParam.h"
	39
	40	#include "AliTRDptrgTLMU.h"
	41
	42	ClassImp(AliTRDptrgTLMU)
	43
	44	//______________________________________________________________________________
	45	AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl)
	46	: TObject(),
	47	fRunLoader(rl),
	48	fParam(0x0),
	49	fOperatingMode(kDigits),
	50	fInputMask(0x0),
	51	fCMatrices(0x0),
	52	fMultiplicity(0x0),
	53	fOutput(0x0)
	54	{
	55	// default ctor
	56
	57	for (Int_t i = 0; i < 18; i++) {
	58	this->fInputTOFinputBits[i] = 0;
	59	}
	60	}
	61
	62	//______________________________________________________________________________
	63	AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader rl, AliTRDptrgParam param,
	64	AliTRDptrgOperatingMode_t operatingMode)
65	: TObject(),
66	fRunLoader(rl),
67	fParam(param),
68	fOperatingMode(operatingMode),
69	fInputMask(0x0),
70	fCMatrices(0x0),
71	fMultiplicity(0x0),
72	fOutput(0x0)
73	{
74	// recommended ctor
75
76	for (Int_t i = 0; i < 18; i++) {
77	this->fInputTOFinputBits[i] = 0;
78	}
79
80	this->LoadParams();
81	}
82
83	//______________________________________________________________________________
84	AliTRDptrgTLMU::~AliTRDptrgTLMU()
85	{
86	// destructor
87
88	this->fCMatrices = 0x0;
89	this->fMultiplicity = 0x0;
90	this->fOutput = 0x0;
91	}
92
93	//______________________________________________________________________________
94	Int_t* AliTRDptrgTLMU::Simulate()
95	{
96	// starts a simulation
97
98	if (this->fOperatingMode == kDigits) {
99	this->LoadDigits();
100	}
101	else if (this->fOperatingMode == kHits) {
102	return 0x0; // TODO
103	}
104
105	// which super modules are active? - needed for fast coincidence processing:
106	// M(sm \| coincidence condition)>=2
107	UInt_t temp = 0x1;
108	UInt_t sm = 0x0;
109	for (Int_t iSM = 0; iSM < 18; iSM++) {
110	if (this->Or(iSM)) {
111	sm \|= temp;
112	}
113	temp <<= 1;
114	}
115	AliDebug(4, Form("Active supermodules: 0x%x", sm));
116
117	// get multiplicity
118	UInt_t multiplicity = this->GetMultiplicitySum();
119	AliDebug(4, Form("TOF/TLMU multiplicity: %d", multiplicity));
120
121	Int_t* result = new Int_t[9];
122	result[0] = 8;
123	for (Int_t iResult = 0; iResult < 8; iResult++) {
124	result[iResult + 1] = 0;
125
126	// coincidence matrix
127	if (this->fOutput[iResult][0] != -1) {
128	for (Int_t iLine = 0; iLine < 18; iLine++) {
129	if (this->GetBitVectorMultiplicity(
130	sm \| this->fCMatrices[this->fOutput[iResult][0]][iLine]) > 1) {
131	result[iResult + 1] = 1;
132	break;
133	}
134	}
135	}
136
137	// multiplicity conditions
138	if (this->fOutput[iResult][1] != -1) {
139	AliDebug(5, Form("Entry %d, slice: %d", iResult,
140	this->fOutput[iResult][1]));
141	if ((this->fMultiplicity[this->fOutput[iResult][1]][0] < multiplicity) &&
142	(this->fMultiplicity[this->fOutput[iResult][1]][1] >= multiplicity)) {
143	result[iResult + 1] = 1;
144	}
145	}
146	AliDebug(4, Form("TLMU result[%d] = %d", iResult, result[iResult + 1]));
147	}
148
149	return result;
150	}
151
152	//______________________________________________________________________________
153	Int_t AliTRDptrgTLMU::LoadDigits()
154	{
155	// loads Digits (for usage with aquired data)
156	this->GetInputBits(); // get bits from AliTOFTrigger
157	return 0;
158	}
159
160
161	//______________________________________________________________________________
162	Bool_t AliTRDptrgTLMU::LoadParams()
163	{
164	// load AliTRDprtgParam content
165
166	if (this->fParam == 0x0) {
167	// no parameter object assigned
168	AliWarning("no parameter object assigned - using default settings!");
169
170	AliError("no default settings available!");
171	// TODO
172	}
173	else {
174	// parameter object assigned
175
176	this->fInputMask = this->fParam->GetTLMUInputMask();
177	// input mask for TOF-bits (18x32=576)
178
179	this->fCMatrices = this->fParam->GetTLMUcmatrices();
180	// get coincidence matrices
181
182	this->fMultiplicity = this->fParam->GetTLMUmultiplicity();
183	// get multiplicity slices
184
185	this->fOutput = this->fParam->GetTLMUoutput();
186	// get output signal assignment
187	}
188
189	return false;
190	}
191
192	//______________________________________________________________________________
193	void AliTRDptrgTLMU::GetInputBits() {
194	// Gets TOF-to-TRD input bits from AliTOFTrigger as Bool_t array
195
196	AliTOFTrigger *toftrig = new AliTOFTrigger(); // create AliTOFTrigger
197	toftrig->CreateLTMMatrixFromDigits(); // Generate LTMMatrix from AliTOFdigits
198
199	// prepare map
200	Bool_t** map = 0x0;
201	map = new Bool_t*[72];
202	for (Int_t i=0; i < 72; i++)
203	map[i] = new Bool_t[8];
204
205	// initialise map
206	for (Int_t i=0; i < 72; i++)
207	for (Int_t j=0; j < 8; j++)
208	map[i][j] = 0;
209
210	// get 576 TOF-to-TRD bits
211	toftrig->GetTRDmap(map);
212
213	/* DEBUG output
214	// used to determine the correct bit assignment
215	for (Int_t i=0; i < 72; i++) {
216	AliDebug(5, Form("%d ", i));
217	for (Int_t j=7; j >= 0; j--) {
218	AliDebug(5, Form("%d", map[i][j]));
219	}
220	}
221	//*/ // end of DEBUG output
222
223
224	// transform Bool_t array to UInt_t bitvectors according to
225	// http://www.physi.uni-heidelberg.de/~schicker/cbtof/cbtof_docu.pdf
226	// chapter 1.4 and 2.1 to a supermodule based structured
227	// integer (bit) array
228	Int_t supermodule = -1;
229	UInt_t tempA = 0x00000001;
230	UInt_t tempC = 0x00010000;
231	for (Int_t iLTM = 0; iLTM < (kNLTM / 2); iLTM++) {
232	if (!(iLTM % 2)) { // renew temp vectors, update supermodule
233	tempA = 0x00000001;
234	tempC = 0x00010000;
235	supermodule++;
236	}
237	AliDebug(5, Form("(%2d,0x%8x,0x%8x)", iLTM, tempA, tempC));
238	for (Int_t iLTMchan = 0; iLTMchan < 8; iLTMchan++) {
239	// A-side
240	if (map[iLTM][iLTMchan]) {
241	this->fInputTOFinputBits[supermodule] \|= tempA;
242	}
243	// C-side
244	if (map[iLTM + 36][iLTMchan]) {
245	this->fInputTOFinputBits[supermodule] \|= tempC;
246	}
247	// change temp vectors
248	tempA <<= 1;
249	tempC <<= 1;
250	}
251	}
252
253	// handle input mask
254	for (Int_t iSM = 0; iSM < 18; iSM++) {
255	AliDebug(5, Form("fInputTOFinputBits[%d]=0x%x", iSM,
256	this->fInputTOFinputBits[iSM]));
257	this->fInputTOFinputBits[iSM] &= this->fInputMask[iSM];
258	}
259	}
260
261
262	//______________________________________________________________________________
263	Int_t AliTRDptrgTLMU::BackToBack(Int_t iSM, Int_t range) {
264	// Check whether there is an back-to-back particle trace
265
266	// get the counterpart of supermodule iSM
267	Int_t counterPart = -1;
268	if (iSM >= 9) {
269	counterPart = iSM - 9;
270	}
271	else {
272	counterPart = iSM + 9;
273	}
274
275	if (this->Or(iSM)) { // is there are active bits in supermodule iSM
276	Int_t result = 0;
277	for (Int_t i = counterPart - range; i <= counterPart + range; i++) {
278	// TODO WARNING: There are possible Errors with sm0 +-range!
279	// check whether there are active bits in supermodule i (counterParts)
280	if ((i >= 0) && (i < 18)) {
281	if (Or(i)) {
282	result++;
283	}
284	}
285	else {
286	if (i < 0) {
287	if (Or(17 - i)) {
288	result++;
289	}
290	}
291	if (i > 17) {
292	if (Or(i - 18)) {
293	result++;
294	}
295	}
296	}
297	}
298	AliDebug(5, Form("BackToBack of %d and %d+-%d\n: %d", iSM, counterPart,
299	range, result));
300	return result; // return whether there was a possible back-to-back trace
301	}
302	else {
303	AliDebug(5, Form("BackToBack unsuccessful, not hit in sm%d", iSM));
304	return 0; // iSM did not recognize anything
305	}
306	}
307
308	//______________________________________________________________________________
309	Int_t AliTRDptrgTLMU::Coincidence(Int_t iSM1, Int_t iSM2) {
310	// checks whether there is an coincidence in iSM1 and iSM2
311
312	if (this->Or(iSM1) && this->Or(iSM2)) {
313	return 1;
314	}
315	else
316	return 0;
317	}
318
319	//______________________________________________________________________________
320	inline Int_t AliTRDptrgTLMU::Or(Int_t iSM) {
321	// returns 1 if one or more bits are active in supermodule iSM
322
323	if ((iSM >= 0) && (iSM < 18)) {
324	if (this->fInputTOFinputBits[iSM] > 0)
325	return 1;
326	else
327	return 0;
328	}
329	else {
330	return -1;
331	}
332	}
333
334	//______________________________________________________________________________
335	Int_t AliTRDptrgTLMU::GetMultiplicity(Int_t iSM) {
336	// counts how many bits equal one are in class member fInputTOFinputBits[iSM]
337	// (32bits from TOF to TRD of supermodule iSM)
338
339	UInt_t temp = this->fInputTOFinputBits[iSM];
340	UInt_t mask = 0x01;
341	Int_t multiplicity = 0;
342
343	// TODO maybe there is a more efficient way to do that?
344	for (int iBit = 0; iBit < 32; iBit++) {
345	if ((mask & temp) != 0x0) { // is the bit equal one?
346	multiplicity++;
347	}
348	mask <<= 1; // rotate mask to the left after each iteration
349	}
350	AliDebug(5, Form("Multiplicity of supermodule %d: %d", iSM, multiplicity));
351	return multiplicity;
352	}
353
354	//______________________________________________________________________________
355	Int_t AliTRDptrgTLMU::GetMultiplicitySum() {
356	// returns the multiplicity of the whole detector (all 576bit TOF to TRD bits)
357	Int_t sum = 0;
358
359	for (Int_t i = 0; i < 18; i++) {
360	sum += this->GetMultiplicity(i);
361	}
362	AliDebug(5, Form("Whole multiplicity: %d", sum));
363	return sum;
364	}
365
366	//______________________________________________________________________________
367	UInt_t AliTRDptrgTLMU::GetBitVectorMultiplicity(UInt_t BitVector) {
368	// returns the multiplicity of a given bit vector
369
370	UInt_t result = 0;
371	UInt_t temp = 0x01;
372	for (UInt_t iBit = 0; iBit < 32; iBit++) {
373	if (BitVector & temp) {
374	result++;
375	}
376	temp <<= 1;
377	}
378
379	return result;
380	}