global variables removed
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerCircuit.cxx
CommitLineData
a9e2aefa 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
17
18*/
19#include "AliRun.h"
20#include "AliMUON.h"
21#include "AliMUONPoints.h"
22#include "AliMUONTriggerCircuit.h"
23#include "AliMUONSegmentation.h"
24#include "AliMUONResponse.h"
25#include "AliMUONChamber.h"
26#include "TMath.h"
27#include "iostream.h"
28
29ClassImp(AliMUONTriggerCircuit)
30
31static Int_t circuitId[234]=
32{111, 121, 131, 141, 151, 161, 171,
33 211, 212, 221, 222, 231, 232, 241, 242, 251, 252, 261, 262, 271,
34 311, 312, 321, 322, 331, 332, 341, 342, 351, 352, 361, 362, 371,
35 411, 412, 413, 421, 422, 423, 424, 431, 432, 433, 434, 441, 442,
36 451, 452, 461, 462, 471,
37 521, 522, 523, 524, 531, 532, 533, 534, 541, 542, 551, 552, 561, 562, 571,
38 611, 612, 613, 621, 622, 623, 624, 631, 632, 633, 634, 641, 642,
39 651, 652, 661, 662, 671,
40 711, 712, 721, 722, 731, 732, 741, 742, 751, 752, 761, 762, 771,
41 811, 812, 821, 822, 831, 832, 841, 842, 851, 852, 861, 862, 871,
42 911, 921, 931, 941, 951, 961, 971,
43 -111, -121, -131, -141, -151, -161, -171,
44 -211, -212, -221, -222, -231, -232, -241, -242, -251, -252, -261, -262, -271,
45 -311, -312, -321, -322, -331, -332, -341, -342, -351, -352, -361, -362, -371,
46 -411, -412, -413, -421, -422, -423, -424, -431, -432, -433, -434, -441, -442,
47 -451, -452, -461, -462, -471,
48 -521, -522, -523, -524, -531, -532, -533, -534, -541, -542, -551, -552, -561, -562, -571,
49 -611, -612, -613, -621, -622, -623, -624, -631, -632, -633, -634, -641, -642,
50 -651, -652, -661, -662, -671,
51 -711, -712, -721, -722, -731, -732, -741, -742, -751, -752, -761, -762, -771,
52 -811, -812, -821, -822, -831, -832, -841, -842, -851, -852, -861, -862, -871,
53 -911, -921, -931, -941, -951, -961, -971};
54
55static Int_t moduleId[63]=
56{11,12,13,14,15,16,17,
57 21,22,23,24,25,26,27,
58 31,32,33,34,35,36,37,
59 41,42,43,44,45,46,47,
60 51,52,53,54,55,56,57,
61 61,62,63,64,65,66,67,
62 71,72,73,74,75,76,77,
63 81,82,83,84,85,86,87,
64 91,92,93,94,95,96,97};
65
66static Int_t nStripX[63]=
67{16,16,16,16,16,16,16,
68 32,32,32,32,32,32,16,
69 32,32,32,32,32,32,16,
70 48,64,64,32,32,32,16,
71 0,64,64,32,32,32,16,
72 48,64,64,32,32,32,16,
73 32,32,32,32,32,32,16,
74 32,32,32,32,32,32,16,
75 16,16,16,16,16,16,16};
76
77static Int_t nStripY[63]=
78{8,8,8,8,8,8,16,
79 8,8,8,8,8,8,16,
80 16,16,16,16,16,8,16,
81 16,16,16,16,16,8,16,
82 0,8,16,16,16,8,16,
83 16,16,16,16,16,8,16,
84 16,16,16,16,16,8,16,
85 8,8,8,8,8,8,16,
86 8,8,8,8,8,8,16};
87
88//----------------------------------------------------------------------
89AliMUONTriggerCircuit::AliMUONTriggerCircuit()
90{
91// Constructor
92 fidCircuit=0;
93 fx2m=0;
94 fx2ud=0;
95 fOrMud[0]=fOrMud[1]=0;
96 for (Int_t i=0; i<4; i++) {
97 for (Int_t j=0; j<32; j++) {
98 fXcode[i][j]=0;
99 fYcode[i][j]=0;
100 }
101 }
102 for (Int_t i=0; i<16; i++) { fXpos11[i]=0.; }
103 for (Int_t i=0; i<31; i++) { fYpos11[i]=0.; }
104 for (Int_t i=0; i<63; i++) { fYpos21[i]=0.; }
105}
106
107//----------------------------------------------------------------------
108AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& MUONTriggerCircuit)
109{
110// Dummy copy constructor
111}
112
113//----------------------------------------------------------------------
114AliMUONTriggerCircuit & AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& MUONTriggerCircuit)
115{
116// Dummy assignment operator
117 return *this;
118}
119
120//----------------------------------------------------------------------
121void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
122// initialize circuit characteristics
123 fidCircuit=circuitId[iCircuit];
124 LoadX2();
125 LoadXCode();
126 LoadYCode();
127 LoadXPos();
128 LoadYPos();
129}
130
131//----------------------------------------------------------------------
132Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit){
133// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
134 Int_t iCircuit=0;
135 for (Int_t i=0; i<234; i++) {
136 if (circuitId[i]==idCircuit) {
137 iCircuit=i;
138 break;
139 }
140 }
141 return iCircuit;
142}
143//----------------------------------------------------------------------
144Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule){
145// returns module number imod (from 0 to 63) corresponding to module idmodule
146 Int_t absidModule=TMath::Abs(idModule);
147 Int_t iModule=0;
148 for (Int_t i=0; i<63; i++) {
149 if (moduleId[i]==absidModule) {
150 iModule=i;
151 break;
152 }
153 }
154 return iModule;
155}
156
157//----------------------------------------------------------------------
158Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) {
159// returns ModuleId where Circuit idCircuit is sitting
160 return Int_t(idCircuit/10);
161}
162//----------------------------------------------------------------------
163Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) {
164// returns position of idCircuit in correcponding Module
165 return TMath::Abs(idCircuit)-TMath::Abs(Module(idCircuit))*10;
166}
167
168//----------------------------------------------------------------------
169void AliMUONTriggerCircuit::LoadX2() {
170// initialize fx2m, fx2ud and fOrMud
171
172 Int_t idModule=Module(fidCircuit); // corresponding module Id.
173 Int_t nStrX=nStripX[ModuleNumber(idModule)]; // and its number of X strips
174 Int_t nStrY=nStripY[ModuleNumber(idModule)]; // and its number of Y strips
175 Int_t iPosCircuit=Position(fidCircuit); // position of circuit in module
176
177// first step : look at lower part
178 if (iPosCircuit==1) { // need to scan lower module
179 if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) {
180 fOrMud[0]=1;
181 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
182 Int_t nStrD=nStripY[ModuleNumber(idModuleD)];
183
184 if (nStrY!=nStrD
185 &&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {
186 if (nStrY==8) fx2m=1;
187 if (nStrD==8) fx2ud=1;
188 }
189 }
190
191 } else { // lower strips within same module
192 fOrMud[0]=0;
193 }
194
195// second step : look at upper part
196 if ((iPosCircuit==1&&nStrX==16)||(iPosCircuit==2&&nStrX==32)||
197 (iPosCircuit==3&&nStrX==48)||(iPosCircuit==4&&nStrX==64)) {
198 if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
199 fOrMud[1]=1;
200 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
201 Int_t nStrU=nStripY[ModuleNumber(idModuleU)];
202
203 if (nStrY!=nStrU
204 &&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {
205 if (nStrY==8) fx2m=1;
206 if (nStrU==8) fx2ud=1;
207 }
208 }
209
210 } else { // upper strips within same module
211 fOrMud[1]=0;
212 }
213}
214
215//----------------------------------------------------------------------
216void AliMUONTriggerCircuit::LoadXCode(){
217// assign a Id. number to each X strip of current circuit
218// Id.=(corresponding module Id.)*100+(Id. strip of module)
219
220// first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
221 Int_t iStripCircMT1=0, iStripCircMT2=8;
222 Int_t idModule=Module(fidCircuit); // corresponding module Id.
223 Int_t nStrX=nStripX[ModuleNumber(idModule)]; // and its number of strips
224 Int_t iPosCircuit=Position(fidCircuit); // position of circuit in module
225 Int_t sign=TMath::Abs(idModule)/idModule; // left or right
226
227 for (Int_t istrip=(iPosCircuit-1)*16;
228 istrip<(iPosCircuit-1)*16+16; istrip++) {
229
230 fXcode[0][iStripCircMT1]=sign*(TMath::Abs(idModule)*100+istrip);
231 fXcode[1][iStripCircMT1]=sign*(TMath::Abs(idModule)*100+istrip);
232 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
233 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
234 iStripCircMT1++;
235 iStripCircMT2++;
236 }
237
238// second part
239// XMC21 XMC22 strips 0 to 7 and 24 to 31
240 Int_t idModuleD, idModuleU;
241 Int_t nStrD, nStrU;
242
243 idModule=Module(fidCircuit); // corresponding module Id.
244 nStrX=nStripX[ModuleNumber(idModule)]; // number of X strips
245 sign=TMath::Abs(idModule)/idModule;
246
247// fill lower part (0 to 7)
248 if (iPosCircuit==1) { // need to scan lower module
249 if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) { // non-existing
250 idModuleD=sign*(TMath::Abs(idModule)+10); // lower module Id
251 nStrD=nStripX[ModuleNumber(idModuleD)]; // and its number of strips
252
253 iStripCircMT2=0;
254 for (Int_t istrip=nStrD-8; istrip<nStrD; istrip++) {
255 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
256 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleD)*100+istrip);
257 iStripCircMT2++;
258 }
259 }
260
261 } else { // lower strips within same module
262
263 iStripCircMT2=0;
264 for (Int_t istrip=(iPosCircuit-1)*16-8;
265 istrip<(iPosCircuit-1)*16; istrip++) {
266 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
267 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
268 iStripCircMT2++;
269 }
270 }
271
272// fill upper part (24 to 31)
273 if ((iPosCircuit==1&&nStrX==16)||(iPosCircuit==2&&nStrX==32)||
274 (iPosCircuit==3&&nStrX==48)||(iPosCircuit==4&&nStrX==64)) {
275 if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
276 idModuleU=sign*(TMath::Abs(idModule)-10); // upper module Id
277 nStrU=nStripX[ModuleNumber(idModuleU)]; // and its number of strips
278
279 iStripCircMT2=24;
280 for (Int_t istrip=0; istrip<8; istrip++) {
281 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
282 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModuleU)*100+istrip);
283 iStripCircMT2++;
284 }
285 }
286
287 } else if ((iPosCircuit==1&&nStrX>16)||(iPosCircuit==2&&nStrX>32)||
288 (iPosCircuit==3&&nStrX>48)) { // upper strips within same mod.
289
290 iStripCircMT2=24;
291 for (Int_t istrip=(iPosCircuit-1)*16+16;
292 istrip<(iPosCircuit-1)*16+24; istrip++) {
293 fXcode[2][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
294 fXcode[3][iStripCircMT2]=sign*(TMath::Abs(idModule)*100+istrip);
295 iStripCircMT2++;
296 }
297 }
298}
299
300//----------------------------------------------------------------------
301void AliMUONTriggerCircuit::LoadYCode(){
302// assign a Id. number to each Y strip of current circuit
303// Id.=(corresponding module Id.)*100+(Id. strip of module)
304// note : for Y plane fill only "central part" of circuit
305// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
306
307 Int_t idModule=Module(fidCircuit); // corresponding module Id.
308 Int_t nStrY=nStripY[ModuleNumber(idModule)]; // its number of Y strips
309 Int_t sign=TMath::Abs(idModule)/idModule; // left or right
310
311 for (Int_t istrip=0; istrip<nStrY; istrip++) {
312 fYcode[0][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
313 fYcode[1][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
314 fYcode[2][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
315 fYcode[3][istrip]=sign*(TMath::Abs(idModule)*100+istrip);
316 }
317}
318
319//----------------------------------------------------------------------
320void AliMUONTriggerCircuit::LoadYPos(){
321// fill fYpos11 and fYpos21 -> y position of X declusterized strips
322
323 Int_t chamber, cathode;
324 Int_t code, idModule, idStrip, idSector;
325 Float_t x, y, width;
326
327 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
328 AliMUONChamber* iChamber;
329 AliMUONSegmentation* segmentation;
330
331// first plane (11)
332 chamber=11;
333 cathode=1;
334 iChamber = &(pMUON->Chamber(chamber-1));
335 segmentation=iChamber->SegmentationModel(cathode);
336
337 for (Int_t istrip=0; istrip<16; istrip++) {
338 code=fXcode[0][istrip]; // decode current strip
339 idModule=Int_t(code/100); // corresponding module Id.
340 idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
341 idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
342 width=segmentation->Dpy(idSector); // corresponding strip width
343 segmentation->GetPadCxy(idModule,idStrip,x,y); // get strip real position
344
345 fYpos11[2*istrip]=y;
346 if (istrip!=15) fYpos11[2*istrip+1]=y+width/2.;
347 }
348
349// second plane (21)
350 chamber=13;
351 cathode=1;
352 iChamber = &(pMUON->Chamber(chamber-1));
353 segmentation=iChamber->SegmentationModel(cathode);
354
355 for (Int_t istrip=0; istrip<32; istrip++) {
356 code=fXcode[2][istrip]; // decode current strip
357 idModule=Int_t(code/100); // corresponding module Id.
358 idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
359 idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
360 width=segmentation->Dpy(idSector); // corresponding strip width
361 segmentation->GetPadCxy(idModule,idStrip,x,y); // get strip real position
362
363// using idModule!=0 prevents to fill garbage in case of circuits
364// in the first and last rows
365 if (idModule!=0) {
366 fYpos21[2*istrip]=y;
367 if (istrip!=31) fYpos21[2*istrip+1]=y+width/2.;
368 }
369 }
370}
371
372//----------------------------------------------------------------------
373void AliMUONTriggerCircuit::LoadXPos(){
374// fill fXpos11 -> x position of Y strips for the first plane only
375// fXpos11 contains the x position of Y strip for the current circuit
376// taking into account whether or nor not part(s) of the circuit
377// (middle, up or down) has(have) 16 strips
378
379 Float_t x, y;
380
381 Int_t chamber=11;
382 Int_t cathode=2;
383 AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
384 AliMUONChamber* iChamber;
385 AliMUONSegmentation* segmentation;
386 iChamber = &(pMUON->Chamber(chamber-1));
387 segmentation=iChamber->SegmentationModel(cathode);
388
389 Int_t idModule=Module(fidCircuit); // corresponding module Id.
390 Int_t nStrY=nStripY[ModuleNumber(idModule)]; // number of Y strips
391 Int_t idSector=segmentation->Sector(idModule,0); // corresp. sector
392 Float_t width=segmentation->Dpx(idSector); // corresponding strip width
393
394// first case : up middle and down parts have all 8 or 16 strip
395 if ((nStrY==16)||(nStrY==8&&fx2m==0&&fx2ud==0)) {
396 for (Int_t istrip=0; istrip<nStrY; istrip++) {
397 segmentation->GetPadCxy(idModule,istrip,x,y);
398 fXpos11[istrip]=x;
399 }
400// second case : mixing 8 and 16 strips within same circuit
401 } else {
402 for (Int_t istrip=0; istrip<nStrY; istrip++) {
403 if (nStrY!=8) { cout << " bug in LoadXpos " << "\n";}
404 segmentation->GetPadCxy(idModule,istrip,x,y);
405 fXpos11[2*istrip]=x-width/4.;
406 fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
407 }
408 }
409}
410
411//----------------------------------------------------------------------
412Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
413// returns calculated pt for circuit/istripX/idev/istripY according
414// to the formula of the TRD. Note : idev (input) is in [0+30]
415
416 // Int_t jdev = idev - 15; // jdev in [-15+15]
417 Int_t istripX2=istripX+idev+1; // find istripX2 using istripX and idev
418
419 Float_t yPosX1=fYpos11[istripX];
420 Float_t yPosX2=fYpos21[istripX2];
421 Float_t xPosY1=fXpos11[istripY];
422
423 Float_t zf=975., z1=1603.5, z2=1703.5;
424 Float_t thetaDev=(1./zf)*(yPosX1*z2-yPosX2*z1)/(z2-z1);
425 Float_t xf=xPosY1*zf/z1;
426 Float_t yf=yPosX2-((yPosX2-yPosX1)*(z2-zf))/(z2-z1);
427 return (3.*0.3/TMath::Abs(thetaDev)) * TMath::Sqrt(xf*xf+yf*yf)/zf;
428}
429
430//----------------------------------------------------------------------
431//--- methods which return member data related info
432//----------------------------------------------------------------------
433Int_t AliMUONTriggerCircuit::GetIdCircuit(){
434// returns circuit Id
435 return fidCircuit;
436}
437//----------------------------------------------------------------------
438Int_t AliMUONTriggerCircuit::GetIdModule(){
439// returns module Id
440 return Module(fidCircuit);
441}
442//----------------------------------------------------------------------
443Int_t AliMUONTriggerCircuit::GetNstripX() {
444// returns the number of X strips in the module where the circuit is sitting
445 return nStripX[ModuleNumber(Module(fidCircuit))];
446}
447//----------------------------------------------------------------------
448Int_t AliMUONTriggerCircuit::GetNstripY() {
449// returns the number of Y strips in the module where the circuit is sitting
450 return nStripY[ModuleNumber(Module(fidCircuit))];
451}
452//----------------------------------------------------------------------
453Int_t AliMUONTriggerCircuit::GetPosCircuit() {
454// returns the position of the circuit in its module
455 return Position(fidCircuit);
456}
457//----------------------------------------------------------------------
458Int_t AliMUONTriggerCircuit::GetIdCircuitD(){
459// returns the Id of the circuit down
460 Int_t idModule=Module(fidCircuit);
461 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
462 return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
463}
464//----------------------------------------------------------------------
465Int_t AliMUONTriggerCircuit::GetICircuitD(){
466// returns the number of the circuit down
467 Int_t idModule=Module(fidCircuit);
468 Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
469 Int_t idCircuitD=
470 (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
471 return CircuitNumber(idCircuitD);
472}
473//----------------------------------------------------------------------
474Int_t AliMUONTriggerCircuit::GetIdCircuitU(){
475// returns the Id of the circuit up
476 Int_t idModule=Module(fidCircuit);
477 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
478 return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
479}
480//----------------------------------------------------------------------
481Int_t AliMUONTriggerCircuit::GetICircuitU(){
482// returns the number of the circuit up
483 Int_t idModule=Module(fidCircuit);
484 Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
485 Int_t idCircuitU=
486 (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
487 return CircuitNumber(idCircuitU);
488}
489//----------------------------------------------------------------------
490Int_t AliMUONTriggerCircuit::GetX2m(){
491// returns fx2m
492 return fx2m;
493}
494//----------------------------------------------------------------------
495Int_t AliMUONTriggerCircuit::GetX2ud(){
496// returns fx2ud
497 return fx2ud;
498}
499//----------------------------------------------------------------------
500void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){
501// returns fOrMud
502 orMud[0]=fOrMud[0];
503 orMud[1]=fOrMud[1];
504}
505//----------------------------------------------------------------------
506Int_t AliMUONTriggerCircuit::GetXcode(Int_t chamber, Int_t istrip){
507// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
508 return fXcode[chamber][istrip];
509}
510//----------------------------------------------------------------------
511Int_t AliMUONTriggerCircuit::GetYcode(Int_t chamber, Int_t istrip){
512// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
513 return fYcode[chamber][istrip];
514}
515//----------------------------------------------------------------------
516Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip){
517// returns Y position of X strip istrip in MC11
518 return fYpos11[istrip];
519}
520//----------------------------------------------------------------------
521Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip){
522// returns Y position of X strip istrip in MC21
523 return fYpos21[istrip];
524}
525//----------------------------------------------------------------------
526Float_t AliMUONTriggerCircuit::GetX11Pos(Int_t istrip){
527// returns X position of Y strip istrip in MC11
528 return fXpos11[istrip];
529}
530//----------------------------------------------------------------------
531//--- end of methods which return member data related info
532//----------------------------------------------------------------------
533
534
535
536
537
538
539