BOSS 7.0.4
BESIII Offline Software System
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx
Go to the documentation of this file.
1//
2// File generated by /cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/SLC6/ExternalLib/external/ROOT/5.34.09/x86_64-slc6-gcc46-opt/root/bin/rootcint at Wed Nov 7 09:24:21 2018
3
4// Do NOT change. Changes will be lost next time file is generated
5//
6
7#define R__DICTIONARY_FILENAME dOdOdIBesVisLibdIBesVisLib_rootcint
8#include "RConfig.h" //rootcint 4834
9#if !defined(R__ACCESS_IN_SYMBOL)
10//Break the privacy of classes -- Disabled for the moment
11#define private public
12#define protected public
13#endif
14
15// Since CINT ignores the std namespace, we need to do so in this file.
16namespace std {} using namespace std;
17#include "BesVisLib_rootcint.h"
18
19#include "TCollectionProxyInfo.h"
20#include "TClass.h"
21#include "TBuffer.h"
22#include "TMemberInspector.h"
23#include "TError.h"
24
25#ifndef G__ROOT
26#define G__ROOT
27#endif
28
29#include "RtypesImp.h"
30#include "TIsAProxy.h"
31#include "TFileMergeInfo.h"
32
33// START OF SHADOWS
34
35namespace ROOT {
36 namespace Shadow {
37 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
38 typedef ::SubDetectorROOTGeo SubDetectorROOTGeo;
39 #else
40 class SubDetectorROOTGeo {
41 public:
42 //friend XX;
43 // To force the creation of a virtual table, throw just in case.
44 virtual ~SubDetectorROOTGeo() throw() {};
45 ::SAXProcessor m_sxp; //
46 ::ProcessingConfigurator m_config; //
47 int m_ROOTGeoInit; //
48 int m_childNo; //child no of this subdetector in bes.
49 int m_2DGeoInit; //
50 ::TGeoVolume* m_TopVolume; //
51 ::TObjArray* m_DetectorsArray; //
52 ::TObjArray* m_HitsArray; //
53 ::TObjArray* m_2DHitsArray; //
54 };
55 #endif
56
57 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
58 typedef ::MdcROOTGeo MdcROOTGeo;
59 #else
60 class MdcROOTGeo : public ::SubDetectorROOTGeo {
61 public:
62 //friend XX;
63 typedef ::std::map<int,int, ::less<int>, ::allocator< ::pair<const int,int> > > intMap;
64 // To force the creation of a virtual table, throw just in case.
65 virtual ~MdcROOTGeo() throw() {};
66 bool k_TFire; //
67 bool k_QFire; //
68 bool k_QNotOverflow; //
69 bool k_ColorfulWire; //
70 bool k_MdcTimeSubEvTime; //
71 int m_StartLayer; //0 - No CGEM; 8 - Contains CGEM
72 int m_MdcColor; //
73 int m_segmentColor; //
74 int m_hypeColor; //
75 int m_tubeColor; //
76 int m_twistedTubsColor; //
77 int m_replicaColor; //
78 map< int, int > m_CorrectMap; //
79 ::TGeoVolume* m_Mdc; //
80 ::TGeoNode* m_NodeLayer[50]; //
81 ::TGeoNode* m_NodeReplica[50][288]; //
82 ::TGeoPhysicalNode* m_PhysicalSegment[132]; //
83 ::TGeoPhysicalNode* m_PhysicalReplica[50][288]; //
84 :: TObjArray* m_MdcDigiCol; //
85 ::BesCircle2D* m_MdcXY; //
86 ::BesCircle2D* m_MdcXYSuper[4]; //
87 ::Mdc2DWire* m_Mdc2DWire[43][288]; //
88 ::BesPolygon2D* m_MdcZR[2]; //
89 };
90 #endif
91
92 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
93 typedef ::TofROOTGeo TofROOTGeo;
94 #else
95 class TofROOTGeo : public ::SubDetectorROOTGeo {
96 public:
97 //friend XX;
98 // To force the creation of a virtual table, throw just in case.
99 virtual ~TofROOTGeo() throw() {};
100 bool k_TMatch; //
101 bool k_QMatch; //
102 int m_TofColor; //
103 int m_BucketColor; //
104 int m_ScinColor; //
105 ::TGeoVolume* m_Tof; //
106 ::TGeoNode* m_NodePVF[3][2][88]; //
107 ::TGeoNode* m_NodeAl[3][2]; //
108 ::TGeoNode* m_NodeScin[3][2]; //
109 ::TGeoPhysicalNode* m_PhysicalScin[3][36][88]; //Huang Shuhui's update: m_kLayerBr -> m_kModuleEc
110 ::TGeoNode* m_NodeModule[3][36]; //
111 ::TGeoNode* m_NodegasContainer[3][36]; //
112 ::TGeoNode* m_NodebareChamber[3][36]; //
113 ::TGeoNode* m_NodepcbBoard1[3][36]; //
114 ::TGeoNode* m_NodeStrip[3][36][12]; //
115 :: TObjArray* m_TofDigiCol; //
116 bool fTofMrpc; //
117 ::Tof2DScin* m_Tof2DScin[3][36][88]; //Huang Shuhui's update: m_kLayerBr -> m_kModuleEc
118 };
119 #endif
120
121 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
122 typedef ::EmcROOTGeo EmcROOTGeo;
123 #else
124 class EmcROOTGeo : public ::SubDetectorROOTGeo {
125 public:
126 //friend XX;
127 // To force the creation of a virtual table, throw just in case.
128 virtual ~EmcROOTGeo() throw() {};
129 int m_kPhiEc; //
130 int m_kThetaEc; //
131 int m_kSectorEc; //
132 int m_kNbEc; //
133 int m_kRealNbEc; //
134 int m_EmcColor; //
135 int m_partColor; //
136 int m_phiColor; //
137 int m_thetaColor; //
138 int m_brCrystalColor; //
139 int m_ecCrystalColor; //
140 ::TGeoVolume* m_Emc; //
141 ::TGeoNode* m_NodePart[3]; //
142 ::TGeoNode* m_NodePhi[3][120]; //
143 ::TGeoNode* m_NodeTheta[3][120][44]; //m_kPhiBr > m_kPhiEc, m_kThetaBr > m_kThetaEc
144 ::TGeoNode* m_NodeTheta2[3][120][44]; //contains theta phi has tow nodes
145 ::TGeoPhysicalNode* m_PhysicalCrystal[3][120][44]; //
146 ::TGeoPhysicalNode* m_PhysicalCrystal2[3][120][44]; //
147 ::TObjArray* m_PhyNodeOrgArray; //
148 :: TObjArray* m_EmcDigiCol; //
149 ::Emc2DCrystal* m_Emc2DCrystal[3][120][44]; //
150 };
151 #endif
152
153 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
154 typedef ::MucROOTGeo MucROOTGeo;
155 #else
156 class MucROOTGeo : public ::SubDetectorROOTGeo {
157 public:
158 //friend XX;
159 // To force the creation of a virtual table, throw just in case.
160 virtual ~MucROOTGeo() throw() {};
161 int m_StripNum[3][8][9]; //
162 int m_MucColor; //
163 int m_absorberColor; //
164 int m_gapColor; //
165 int m_gasChamberColor; //
166 int m_bakeliteColor; //
167 int m_stripColor; //
168 ::TGeoVolume* m_Muc; //
169 ::TGeoNode* m_NodeAbsorber[3][8][9]; //
170 ::TGeoNode* m_NodeAbsorberPanel[3][8][9][4]; //
171 ::TGeoNode* m_NodeGap[3][8][9]; //
172 ::TGeoNode* m_NodeStripPlane[3][8][9]; //
173 ::TGeoNode* m_NodeStrip[3][8][9][112]; //
174 ::TGeoPhysicalNode* m_PhysicalAbsorber[3][8][9][4]; //
175 ::TGeoPhysicalNode* m_PhysicalGap[3][8][9]; //
176 ::TGeoPhysicalNode* m_PhysicalStrip[3][8][9][112]; //
177 :: TObjArray* m_MucDigiCol; //
178 ::BesPolygon2D* m_MucXY[3][8]; //
179 ::BesPolygon2D* m_MucZR[3][8]; //
180 ::BesPolygon2D* m_MucXYGap[3][8][9]; //
181 ::BesPolygon2D* m_MucZRGap[3][8][9]; //
182 ::Muc2DStrip* m_Muc2DStrip[3][8][9][112]; //
183 };
184 #endif
185
186 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
187 typedef vector3 vector3;
188 #else
189 class vector3 {
190 public:
191 //friend XX;
192 float x; //
193 float y; //
194 float z; //
195 };
196 #endif
197
198 } // of namespace Shadow
199} // of namespace ROOT
200// END OF SHADOWS
201
202namespace ROOT {
203 void BesStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
204 static void *new_BesStatus(void *p = 0);
205 static void *newArray_BesStatus(Long_t size, void *p);
206 static void delete_BesStatus(void *p);
207 static void deleteArray_BesStatus(void *p);
208 static void destruct_BesStatus(void *p);
209
210 // Function generating the singleton type initializer
211 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesStatus*)
212 {
213 ::BesStatus *ptr = 0;
214 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesStatus >(0);
215 static ::ROOT::TGenericClassInfo
216 instance("BesStatus", ::BesStatus::Class_Version(), "./../BesVisLib/BesStatus.h", 24,
217 typeid(::BesStatus), DefineBehavior(ptr, ptr),
218 &::BesStatus::Dictionary, isa_proxy, 4,
219 sizeof(::BesStatus) );
220 instance.SetNew(&new_BesStatus);
221 instance.SetNewArray(&newArray_BesStatus);
222 instance.SetDelete(&delete_BesStatus);
223 instance.SetDeleteArray(&deleteArray_BesStatus);
224 instance.SetDestructor(&destruct_BesStatus);
225 return &instance;
226 }
227 TGenericClassInfo *GenerateInitInstance(const ::BesStatus*)
228 {
229 return GenerateInitInstanceLocal((::BesStatus*)0);
230 }
231 // Static variable to force the class initialization
232 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
233} // end of namespace ROOT
234
235namespace ROOT {
236 void BesTView_ShowMembers(void *obj, TMemberInspector &R__insp);
237 static void *new_BesTView(void *p = 0);
238 static void *newArray_BesTView(Long_t size, void *p);
239 static void delete_BesTView(void *p);
240 static void deleteArray_BesTView(void *p);
241 static void destruct_BesTView(void *p);
242 static void streamer_BesTView(TBuffer &buf, void *obj);
243
244 // Function generating the singleton type initializer
245 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesTView*)
246 {
247 ::BesTView *ptr = 0;
248 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesTView >(0);
249 static ::ROOT::TGenericClassInfo
250 instance("BesTView", ::BesTView::Class_Version(), "./../BesVisLib/BesTView.h", 31,
251 typeid(::BesTView), DefineBehavior(ptr, ptr),
252 &::BesTView::Dictionary, isa_proxy, 1,
253 sizeof(::BesTView) );
254 instance.SetNew(&new_BesTView);
255 instance.SetNewArray(&newArray_BesTView);
256 instance.SetDelete(&delete_BesTView);
257 instance.SetDeleteArray(&deleteArray_BesTView);
258 instance.SetDestructor(&destruct_BesTView);
259 instance.SetStreamerFunc(&streamer_BesTView);
260 return &instance;
261 }
262 TGenericClassInfo *GenerateInitInstance(const ::BesTView*)
263 {
264 return GenerateInitInstanceLocal((::BesTView*)0);
265 }
266 // Static variable to force the class initialization
267 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesTView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
268} // end of namespace ROOT
269
270namespace ROOT {
271 void Bes2DView_ShowMembers(void *obj, TMemberInspector &R__insp);
272 static void *new_Bes2DView(void *p = 0);
273 static void *newArray_Bes2DView(Long_t size, void *p);
274 static void delete_Bes2DView(void *p);
275 static void deleteArray_Bes2DView(void *p);
276 static void destruct_Bes2DView(void *p);
277
278 // Function generating the singleton type initializer
279 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Bes2DView*)
280 {
281 ::Bes2DView *ptr = 0;
282 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Bes2DView >(0);
283 static ::ROOT::TGenericClassInfo
284 instance("Bes2DView", ::Bes2DView::Class_Version(), "./../BesVisLib/Bes2DView.h", 25,
285 typeid(::Bes2DView), DefineBehavior(ptr, ptr),
286 &::Bes2DView::Dictionary, isa_proxy, 4,
287 sizeof(::Bes2DView) );
288 instance.SetNew(&new_Bes2DView);
289 instance.SetNewArray(&newArray_Bes2DView);
290 instance.SetDelete(&delete_Bes2DView);
291 instance.SetDeleteArray(&deleteArray_Bes2DView);
292 instance.SetDestructor(&destruct_Bes2DView);
293 return &instance;
294 }
295 TGenericClassInfo *GenerateInitInstance(const ::Bes2DView*)
296 {
297 return GenerateInitInstanceLocal((::Bes2DView*)0);
298 }
299 // Static variable to force the class initialization
300 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Bes2DView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
301} // end of namespace ROOT
302
303namespace ROOT {
304 void BesCircle2D_ShowMembers(void *obj, TMemberInspector &R__insp);
305 static void *new_BesCircle2D(void *p = 0);
306 static void *newArray_BesCircle2D(Long_t size, void *p);
307 static void delete_BesCircle2D(void *p);
308 static void deleteArray_BesCircle2D(void *p);
309 static void destruct_BesCircle2D(void *p);
310
311 // Function generating the singleton type initializer
312 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCircle2D*)
313 {
314 ::BesCircle2D *ptr = 0;
315 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCircle2D >(0);
316 static ::ROOT::TGenericClassInfo
317 instance("BesCircle2D", ::BesCircle2D::Class_Version(), "./../BesVisLib/BesCircle2D.h", 25,
318 typeid(::BesCircle2D), DefineBehavior(ptr, ptr),
319 &::BesCircle2D::Dictionary, isa_proxy, 4,
320 sizeof(::BesCircle2D) );
321 instance.SetNew(&new_BesCircle2D);
322 instance.SetNewArray(&newArray_BesCircle2D);
323 instance.SetDelete(&delete_BesCircle2D);
324 instance.SetDeleteArray(&deleteArray_BesCircle2D);
325 instance.SetDestructor(&destruct_BesCircle2D);
326 return &instance;
327 }
328 TGenericClassInfo *GenerateInitInstance(const ::BesCircle2D*)
329 {
330 return GenerateInitInstanceLocal((::BesCircle2D*)0);
331 }
332 // Static variable to force the class initialization
333 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesCircle2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
334} // end of namespace ROOT
335
336namespace ROOT {
337 void BesCursor_ShowMembers(void *obj, TMemberInspector &R__insp);
338 static void *new_BesCursor(void *p = 0);
339 static void *newArray_BesCursor(Long_t size, void *p);
340 static void delete_BesCursor(void *p);
341 static void deleteArray_BesCursor(void *p);
342 static void destruct_BesCursor(void *p);
343
344 // Function generating the singleton type initializer
345 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCursor*)
346 {
347 ::BesCursor *ptr = 0;
348 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCursor >(0);
349 static ::ROOT::TGenericClassInfo
350 instance("BesCursor", ::BesCursor::Class_Version(), "./../BesVisLib/BesCursor.h", 19,
351 typeid(::BesCursor), DefineBehavior(ptr, ptr),
352 &::BesCursor::Dictionary, isa_proxy, 4,
353 sizeof(::BesCursor) );
354 instance.SetNew(&new_BesCursor);
355 instance.SetNewArray(&newArray_BesCursor);
356 instance.SetDelete(&delete_BesCursor);
357 instance.SetDeleteArray(&deleteArray_BesCursor);
358 instance.SetDestructor(&destruct_BesCursor);
359 return &instance;
360 }
361 TGenericClassInfo *GenerateInitInstance(const ::BesCursor*)
362 {
363 return GenerateInitInstanceLocal((::BesCursor*)0);
364 }
365 // Static variable to force the class initialization
366 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesCursor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
367} // end of namespace ROOT
368
369namespace ROOT {
370 void BesEventHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
371 static void *new_BesEventHeader(void *p = 0);
372 static void *newArray_BesEventHeader(Long_t size, void *p);
373 static void delete_BesEventHeader(void *p);
374 static void deleteArray_BesEventHeader(void *p);
375 static void destruct_BesEventHeader(void *p);
376
377 // Function generating the singleton type initializer
378 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEventHeader*)
379 {
380 ::BesEventHeader *ptr = 0;
381 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEventHeader >(0);
382 static ::ROOT::TGenericClassInfo
383 instance("BesEventHeader", ::BesEventHeader::Class_Version(), "./../BesVisLib/BesEventHeader.h", 14,
384 typeid(::BesEventHeader), DefineBehavior(ptr, ptr),
385 &::BesEventHeader::Dictionary, isa_proxy, 4,
386 sizeof(::BesEventHeader) );
387 instance.SetNew(&new_BesEventHeader);
388 instance.SetNewArray(&newArray_BesEventHeader);
389 instance.SetDelete(&delete_BesEventHeader);
390 instance.SetDeleteArray(&deleteArray_BesEventHeader);
391 instance.SetDestructor(&destruct_BesEventHeader);
392 return &instance;
393 }
394 TGenericClassInfo *GenerateInitInstance(const ::BesEventHeader*)
395 {
396 return GenerateInitInstanceLocal((::BesEventHeader*)0);
397 }
398 // Static variable to force the class initialization
399 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesEventHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
400} // end of namespace ROOT
401
402namespace ROOT {
403 void BesView_ShowMembers(void *obj, TMemberInspector &R__insp);
404 static void *new_BesView(void *p = 0);
405 static void *newArray_BesView(Long_t size, void *p);
406 static void delete_BesView(void *p);
407 static void deleteArray_BesView(void *p);
408 static void destruct_BesView(void *p);
409
410 // Function generating the singleton type initializer
411 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesView*)
412 {
413 ::BesView *ptr = 0;
414 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesView >(0);
415 static ::ROOT::TGenericClassInfo
416 instance("BesView", ::BesView::Class_Version(), "./../BesVisLib/BesView.h", 30,
417 typeid(::BesView), DefineBehavior(ptr, ptr),
418 &::BesView::Dictionary, isa_proxy, 4,
419 sizeof(::BesView) );
420 instance.SetNew(&new_BesView);
421 instance.SetNewArray(&newArray_BesView);
422 instance.SetDelete(&delete_BesView);
423 instance.SetDeleteArray(&deleteArray_BesView);
424 instance.SetDestructor(&destruct_BesView);
425 return &instance;
426 }
427 TGenericClassInfo *GenerateInitInstance(const ::BesView*)
428 {
429 return GenerateInitInstanceLocal((::BesView*)0);
430 }
431 // Static variable to force the class initialization
432 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
433} // end of namespace ROOT
434
435namespace ROOT {
436 void BesMarker2D_ShowMembers(void *obj, TMemberInspector &R__insp);
437 static void *new_BesMarker2D(void *p = 0);
438 static void *newArray_BesMarker2D(Long_t size, void *p);
439 static void delete_BesMarker2D(void *p);
440 static void deleteArray_BesMarker2D(void *p);
441 static void destruct_BesMarker2D(void *p);
442
443 // Function generating the singleton type initializer
444 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesMarker2D*)
445 {
446 ::BesMarker2D *ptr = 0;
447 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesMarker2D >(0);
448 static ::ROOT::TGenericClassInfo
449 instance("BesMarker2D", ::BesMarker2D::Class_Version(), "./../BesVisLib/BesMarker2D.h", 13,
450 typeid(::BesMarker2D), DefineBehavior(ptr, ptr),
451 &::BesMarker2D::Dictionary, isa_proxy, 4,
452 sizeof(::BesMarker2D) );
453 instance.SetNew(&new_BesMarker2D);
454 instance.SetNewArray(&newArray_BesMarker2D);
455 instance.SetDelete(&delete_BesMarker2D);
456 instance.SetDeleteArray(&deleteArray_BesMarker2D);
457 instance.SetDestructor(&destruct_BesMarker2D);
458 return &instance;
459 }
460 TGenericClassInfo *GenerateInitInstance(const ::BesMarker2D*)
461 {
462 return GenerateInitInstanceLocal((::BesMarker2D*)0);
463 }
464 // Static variable to force the class initialization
465 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesMarker2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
466} // end of namespace ROOT
467
468namespace ROOT {
469 void BesPaveText_ShowMembers(void *obj, TMemberInspector &R__insp);
470 static void *new_BesPaveText(void *p = 0);
471 static void *newArray_BesPaveText(Long_t size, void *p);
472 static void delete_BesPaveText(void *p);
473 static void deleteArray_BesPaveText(void *p);
474 static void destruct_BesPaveText(void *p);
475
476 // Function generating the singleton type initializer
477 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPaveText*)
478 {
479 ::BesPaveText *ptr = 0;
480 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPaveText >(0);
481 static ::ROOT::TGenericClassInfo
482 instance("BesPaveText", ::BesPaveText::Class_Version(), "./../BesVisLib/BesPaveText.h", 11,
483 typeid(::BesPaveText), DefineBehavior(ptr, ptr),
484 &::BesPaveText::Dictionary, isa_proxy, 4,
485 sizeof(::BesPaveText) );
486 instance.SetNew(&new_BesPaveText);
487 instance.SetNewArray(&newArray_BesPaveText);
488 instance.SetDelete(&delete_BesPaveText);
489 instance.SetDeleteArray(&deleteArray_BesPaveText);
490 instance.SetDestructor(&destruct_BesPaveText);
491 return &instance;
492 }
493 TGenericClassInfo *GenerateInitInstance(const ::BesPaveText*)
494 {
495 return GenerateInitInstanceLocal((::BesPaveText*)0);
496 }
497 // Static variable to force the class initialization
498 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesPaveText*)0x0); R__UseDummy(_R__UNIQUE_(Init));
499} // end of namespace ROOT
500
501namespace ROOT {
502 void BesGeoTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
503 static void *new_BesGeoTrack(void *p = 0);
504 static void *newArray_BesGeoTrack(Long_t size, void *p);
505 static void delete_BesGeoTrack(void *p);
506 static void deleteArray_BesGeoTrack(void *p);
507 static void destruct_BesGeoTrack(void *p);
508
509 // Function generating the singleton type initializer
510 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeoTrack*)
511 {
512 ::BesGeoTrack *ptr = 0;
513 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeoTrack >(0);
514 static ::ROOT::TGenericClassInfo
515 instance("BesGeoTrack", ::BesGeoTrack::Class_Version(), "./../BesVisLib/BesGeoTrack.h", 12,
516 typeid(::BesGeoTrack), DefineBehavior(ptr, ptr),
517 &::BesGeoTrack::Dictionary, isa_proxy, 4,
518 sizeof(::BesGeoTrack) );
519 instance.SetNew(&new_BesGeoTrack);
520 instance.SetNewArray(&newArray_BesGeoTrack);
521 instance.SetDelete(&delete_BesGeoTrack);
522 instance.SetDeleteArray(&deleteArray_BesGeoTrack);
523 instance.SetDestructor(&destruct_BesGeoTrack);
524 return &instance;
525 }
526 TGenericClassInfo *GenerateInitInstance(const ::BesGeoTrack*)
527 {
528 return GenerateInitInstanceLocal((::BesGeoTrack*)0);
529 }
530 // Static variable to force the class initialization
531 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
532} // end of namespace ROOT
533
534namespace ROOT {
535 void BesEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
536 static void *new_BesEvent(void *p = 0);
537 static void *newArray_BesEvent(Long_t size, void *p);
538 static void delete_BesEvent(void *p);
539 static void deleteArray_BesEvent(void *p);
540 static void destruct_BesEvent(void *p);
541
542 // Function generating the singleton type initializer
543 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEvent*)
544 {
545 ::BesEvent *ptr = 0;
546 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEvent >(0);
547 static ::ROOT::TGenericClassInfo
548 instance("BesEvent", ::BesEvent::Class_Version(), "./../BesVisLib/BesEvent.h", 23,
549 typeid(::BesEvent), DefineBehavior(ptr, ptr),
550 &::BesEvent::Dictionary, isa_proxy, 4,
551 sizeof(::BesEvent) );
552 instance.SetNew(&new_BesEvent);
553 instance.SetNewArray(&newArray_BesEvent);
554 instance.SetDelete(&delete_BesEvent);
555 instance.SetDeleteArray(&deleteArray_BesEvent);
556 instance.SetDestructor(&destruct_BesEvent);
557 return &instance;
558 }
559 TGenericClassInfo *GenerateInitInstance(const ::BesEvent*)
560 {
561 return GenerateInitInstanceLocal((::BesEvent*)0);
562 }
563 // Static variable to force the class initialization
564 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
565} // end of namespace ROOT
566
567namespace ROOT {
568 void SubDetectorROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
569 static void SubDetectorROOTGeo_Dictionary();
570 static void *new_SubDetectorROOTGeo(void *p = 0);
571 static void *newArray_SubDetectorROOTGeo(Long_t size, void *p);
572 static void delete_SubDetectorROOTGeo(void *p);
573 static void deleteArray_SubDetectorROOTGeo(void *p);
574 static void destruct_SubDetectorROOTGeo(void *p);
575
576 // Function generating the singleton type initializer
577 static TGenericClassInfo *GenerateInitInstanceLocal(const ::SubDetectorROOTGeo*)
578 {
579 // Make sure the shadow class has the right sizeof
580 R__ASSERT(sizeof(::SubDetectorROOTGeo) == sizeof(::ROOT::Shadow::SubDetectorROOTGeo));
581 ::SubDetectorROOTGeo *ptr = 0;
582 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SubDetectorROOTGeo),0);
583 static ::ROOT::TGenericClassInfo
584 instance("SubDetectorROOTGeo", "./../BesVisLib/SubDetectorROOTGeo.h", 30,
585 typeid(::SubDetectorROOTGeo), DefineBehavior(ptr, ptr),
586 &SubDetectorROOTGeo_ShowMembers, &SubDetectorROOTGeo_Dictionary, isa_proxy, 4,
587 sizeof(::SubDetectorROOTGeo) );
588 instance.SetNew(&new_SubDetectorROOTGeo);
589 instance.SetNewArray(&newArray_SubDetectorROOTGeo);
590 instance.SetDelete(&delete_SubDetectorROOTGeo);
591 instance.SetDeleteArray(&deleteArray_SubDetectorROOTGeo);
592 instance.SetDestructor(&destruct_SubDetectorROOTGeo);
593 return &instance;
594 }
595 TGenericClassInfo *GenerateInitInstance(const ::SubDetectorROOTGeo*)
596 {
597 return GenerateInitInstanceLocal((::SubDetectorROOTGeo*)0);
598 }
599 // Static variable to force the class initialization
600 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
601
602 // Dictionary for non-ClassDef classes
603 static void SubDetectorROOTGeo_Dictionary() {
604 ::ROOT::GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0)->GetClass();
605 }
606
607} // end of namespace ROOT
608
609namespace ROOT {
610 void BesPolygon2D_ShowMembers(void *obj, TMemberInspector &R__insp);
611 static void *new_BesPolygon2D(void *p = 0);
612 static void *newArray_BesPolygon2D(Long_t size, void *p);
613 static void delete_BesPolygon2D(void *p);
614 static void deleteArray_BesPolygon2D(void *p);
615 static void destruct_BesPolygon2D(void *p);
616
617 // Function generating the singleton type initializer
618 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPolygon2D*)
619 {
620 ::BesPolygon2D *ptr = 0;
621 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPolygon2D >(0);
622 static ::ROOT::TGenericClassInfo
623 instance("BesPolygon2D", ::BesPolygon2D::Class_Version(), "./../BesVisLib/BesPolygon2D.h", 27,
624 typeid(::BesPolygon2D), DefineBehavior(ptr, ptr),
625 &::BesPolygon2D::Dictionary, isa_proxy, 4,
626 sizeof(::BesPolygon2D) );
627 instance.SetNew(&new_BesPolygon2D);
628 instance.SetNewArray(&newArray_BesPolygon2D);
629 instance.SetDelete(&delete_BesPolygon2D);
630 instance.SetDeleteArray(&deleteArray_BesPolygon2D);
631 instance.SetDestructor(&destruct_BesPolygon2D);
632 return &instance;
633 }
634 TGenericClassInfo *GenerateInitInstance(const ::BesPolygon2D*)
635 {
636 return GenerateInitInstanceLocal((::BesPolygon2D*)0);
637 }
638 // Static variable to force the class initialization
639 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
640} // end of namespace ROOT
641
642namespace ROOT {
643 void Mdc2DWire_ShowMembers(void *obj, TMemberInspector &R__insp);
644 static void *new_Mdc2DWire(void *p = 0);
645 static void *newArray_Mdc2DWire(Long_t size, void *p);
646 static void delete_Mdc2DWire(void *p);
647 static void deleteArray_Mdc2DWire(void *p);
648 static void destruct_Mdc2DWire(void *p);
649
650 // Function generating the singleton type initializer
651 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Mdc2DWire*)
652 {
653 ::Mdc2DWire *ptr = 0;
654 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Mdc2DWire >(0);
655 static ::ROOT::TGenericClassInfo
656 instance("Mdc2DWire", ::Mdc2DWire::Class_Version(), "./../BesVisLib/Mdc2DWire.h", 18,
657 typeid(::Mdc2DWire), DefineBehavior(ptr, ptr),
658 &::Mdc2DWire::Dictionary, isa_proxy, 4,
659 sizeof(::Mdc2DWire) );
660 instance.SetNew(&new_Mdc2DWire);
661 instance.SetNewArray(&newArray_Mdc2DWire);
662 instance.SetDelete(&delete_Mdc2DWire);
663 instance.SetDeleteArray(&deleteArray_Mdc2DWire);
664 instance.SetDestructor(&destruct_Mdc2DWire);
665 return &instance;
666 }
667 TGenericClassInfo *GenerateInitInstance(const ::Mdc2DWire*)
668 {
669 return GenerateInitInstanceLocal((::Mdc2DWire*)0);
670 }
671 // Static variable to force the class initialization
672 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0); R__UseDummy(_R__UNIQUE_(Init));
673} // end of namespace ROOT
674
675namespace ROOT {
676 void MdcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
677 static void MdcROOTGeo_Dictionary();
678 static void *new_MdcROOTGeo(void *p = 0);
679 static void *newArray_MdcROOTGeo(Long_t size, void *p);
680 static void delete_MdcROOTGeo(void *p);
681 static void deleteArray_MdcROOTGeo(void *p);
682 static void destruct_MdcROOTGeo(void *p);
683
684 // Function generating the singleton type initializer
685 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MdcROOTGeo*)
686 {
687 // Make sure the shadow class has the right sizeof
688 R__ASSERT(sizeof(::MdcROOTGeo) == sizeof(::ROOT::Shadow::MdcROOTGeo));
689 ::MdcROOTGeo *ptr = 0;
690 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MdcROOTGeo),0);
691 static ::ROOT::TGenericClassInfo
692 instance("MdcROOTGeo", "./../BesVisLib/MdcROOTGeo.h", 32,
693 typeid(::MdcROOTGeo), DefineBehavior(ptr, ptr),
694 &MdcROOTGeo_ShowMembers, &MdcROOTGeo_Dictionary, isa_proxy, 4,
695 sizeof(::MdcROOTGeo) );
696 instance.SetNew(&new_MdcROOTGeo);
697 instance.SetNewArray(&newArray_MdcROOTGeo);
698 instance.SetDelete(&delete_MdcROOTGeo);
699 instance.SetDeleteArray(&deleteArray_MdcROOTGeo);
700 instance.SetDestructor(&destruct_MdcROOTGeo);
701 return &instance;
702 }
703 TGenericClassInfo *GenerateInitInstance(const ::MdcROOTGeo*)
704 {
705 return GenerateInitInstanceLocal((::MdcROOTGeo*)0);
706 }
707 // Static variable to force the class initialization
708 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
709
710 // Dictionary for non-ClassDef classes
711 static void MdcROOTGeo_Dictionary() {
712 ::ROOT::GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0)->GetClass();
713 }
714
715} // end of namespace ROOT
716
717namespace ROOT {
718 void Tof2DScin_ShowMembers(void *obj, TMemberInspector &R__insp);
719 static void *new_Tof2DScin(void *p = 0);
720 static void *newArray_Tof2DScin(Long_t size, void *p);
721 static void delete_Tof2DScin(void *p);
722 static void deleteArray_Tof2DScin(void *p);
723 static void destruct_Tof2DScin(void *p);
724
725 // Function generating the singleton type initializer
726 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Tof2DScin*)
727 {
728 ::Tof2DScin *ptr = 0;
729 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Tof2DScin >(0);
730 static ::ROOT::TGenericClassInfo
731 instance("Tof2DScin", ::Tof2DScin::Class_Version(), "./../BesVisLib/Tof2DScin.h", 19,
732 typeid(::Tof2DScin), DefineBehavior(ptr, ptr),
733 &::Tof2DScin::Dictionary, isa_proxy, 4,
734 sizeof(::Tof2DScin) );
735 instance.SetNew(&new_Tof2DScin);
736 instance.SetNewArray(&newArray_Tof2DScin);
737 instance.SetDelete(&delete_Tof2DScin);
738 instance.SetDeleteArray(&deleteArray_Tof2DScin);
739 instance.SetDestructor(&destruct_Tof2DScin);
740 return &instance;
741 }
742 TGenericClassInfo *GenerateInitInstance(const ::Tof2DScin*)
743 {
744 return GenerateInitInstanceLocal((::Tof2DScin*)0);
745 }
746 // Static variable to force the class initialization
747 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Tof2DScin*)0x0); R__UseDummy(_R__UNIQUE_(Init));
748} // end of namespace ROOT
749
750namespace ROOT {
751 void TofROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
752 static void TofROOTGeo_Dictionary();
753 static void *new_TofROOTGeo(void *p = 0);
754 static void *newArray_TofROOTGeo(Long_t size, void *p);
755 static void delete_TofROOTGeo(void *p);
756 static void deleteArray_TofROOTGeo(void *p);
757 static void destruct_TofROOTGeo(void *p);
758
759 // Function generating the singleton type initializer
760 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TofROOTGeo*)
761 {
762 // Make sure the shadow class has the right sizeof
763 R__ASSERT(sizeof(::TofROOTGeo) == sizeof(::ROOT::Shadow::TofROOTGeo));
764 ::TofROOTGeo *ptr = 0;
765 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TofROOTGeo),0);
766 static ::ROOT::TGenericClassInfo
767 instance("TofROOTGeo", "./../BesVisLib/TofROOTGeo.h", 30,
768 typeid(::TofROOTGeo), DefineBehavior(ptr, ptr),
769 &TofROOTGeo_ShowMembers, &TofROOTGeo_Dictionary, isa_proxy, 4,
770 sizeof(::TofROOTGeo) );
771 instance.SetNew(&new_TofROOTGeo);
772 instance.SetNewArray(&newArray_TofROOTGeo);
773 instance.SetDelete(&delete_TofROOTGeo);
774 instance.SetDeleteArray(&deleteArray_TofROOTGeo);
775 instance.SetDestructor(&destruct_TofROOTGeo);
776 return &instance;
777 }
778 TGenericClassInfo *GenerateInitInstance(const ::TofROOTGeo*)
779 {
780 return GenerateInitInstanceLocal((::TofROOTGeo*)0);
781 }
782 // Static variable to force the class initialization
783 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
784
785 // Dictionary for non-ClassDef classes
786 static void TofROOTGeo_Dictionary() {
787 ::ROOT::GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0)->GetClass();
788 }
789
790} // end of namespace ROOT
791
792namespace ROOT {
793 void Emc2DCrystal_ShowMembers(void *obj, TMemberInspector &R__insp);
794 static void *new_Emc2DCrystal(void *p = 0);
795 static void *newArray_Emc2DCrystal(Long_t size, void *p);
796 static void delete_Emc2DCrystal(void *p);
797 static void deleteArray_Emc2DCrystal(void *p);
798 static void destruct_Emc2DCrystal(void *p);
799
800 // Function generating the singleton type initializer
801 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Emc2DCrystal*)
802 {
803 ::Emc2DCrystal *ptr = 0;
804 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Emc2DCrystal >(0);
805 static ::ROOT::TGenericClassInfo
806 instance("Emc2DCrystal", ::Emc2DCrystal::Class_Version(), "./../BesVisLib/Emc2DCrystal.h", 19,
807 typeid(::Emc2DCrystal), DefineBehavior(ptr, ptr),
808 &::Emc2DCrystal::Dictionary, isa_proxy, 4,
809 sizeof(::Emc2DCrystal) );
810 instance.SetNew(&new_Emc2DCrystal);
811 instance.SetNewArray(&newArray_Emc2DCrystal);
812 instance.SetDelete(&delete_Emc2DCrystal);
813 instance.SetDeleteArray(&deleteArray_Emc2DCrystal);
814 instance.SetDestructor(&destruct_Emc2DCrystal);
815 return &instance;
816 }
817 TGenericClassInfo *GenerateInitInstance(const ::Emc2DCrystal*)
818 {
819 return GenerateInitInstanceLocal((::Emc2DCrystal*)0);
820 }
821 // Static variable to force the class initialization
822 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
823} // end of namespace ROOT
824
825namespace ROOT {
826 void EmcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
827 static void EmcROOTGeo_Dictionary();
828 static void *new_EmcROOTGeo(void *p = 0);
829 static void *newArray_EmcROOTGeo(Long_t size, void *p);
830 static void delete_EmcROOTGeo(void *p);
831 static void deleteArray_EmcROOTGeo(void *p);
832 static void destruct_EmcROOTGeo(void *p);
833
834 // Function generating the singleton type initializer
835 static TGenericClassInfo *GenerateInitInstanceLocal(const ::EmcROOTGeo*)
836 {
837 // Make sure the shadow class has the right sizeof
838 R__ASSERT(sizeof(::EmcROOTGeo) == sizeof(::ROOT::Shadow::EmcROOTGeo));
839 ::EmcROOTGeo *ptr = 0;
840 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EmcROOTGeo),0);
841 static ::ROOT::TGenericClassInfo
842 instance("EmcROOTGeo", "./../BesVisLib/EmcROOTGeo.h", 33,
843 typeid(::EmcROOTGeo), DefineBehavior(ptr, ptr),
844 &EmcROOTGeo_ShowMembers, &EmcROOTGeo_Dictionary, isa_proxy, 4,
845 sizeof(::EmcROOTGeo) );
846 instance.SetNew(&new_EmcROOTGeo);
847 instance.SetNewArray(&newArray_EmcROOTGeo);
848 instance.SetDelete(&delete_EmcROOTGeo);
849 instance.SetDeleteArray(&deleteArray_EmcROOTGeo);
850 instance.SetDestructor(&destruct_EmcROOTGeo);
851 return &instance;
852 }
853 TGenericClassInfo *GenerateInitInstance(const ::EmcROOTGeo*)
854 {
855 return GenerateInitInstanceLocal((::EmcROOTGeo*)0);
856 }
857 // Static variable to force the class initialization
858 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
859
860 // Dictionary for non-ClassDef classes
861 static void EmcROOTGeo_Dictionary() {
862 ::ROOT::GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0)->GetClass();
863 }
864
865} // end of namespace ROOT
866
867namespace ROOT {
868 void Muc2DStrip_ShowMembers(void *obj, TMemberInspector &R__insp);
869 static void *new_Muc2DStrip(void *p = 0);
870 static void *newArray_Muc2DStrip(Long_t size, void *p);
871 static void delete_Muc2DStrip(void *p);
872 static void deleteArray_Muc2DStrip(void *p);
873 static void destruct_Muc2DStrip(void *p);
874
875 // Function generating the singleton type initializer
876 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Muc2DStrip*)
877 {
878 ::Muc2DStrip *ptr = 0;
879 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Muc2DStrip >(0);
880 static ::ROOT::TGenericClassInfo
881 instance("Muc2DStrip", ::Muc2DStrip::Class_Version(), "./../BesVisLib/Muc2DStrip.h", 19,
882 typeid(::Muc2DStrip), DefineBehavior(ptr, ptr),
883 &::Muc2DStrip::Dictionary, isa_proxy, 4,
884 sizeof(::Muc2DStrip) );
885 instance.SetNew(&new_Muc2DStrip);
886 instance.SetNewArray(&newArray_Muc2DStrip);
887 instance.SetDelete(&delete_Muc2DStrip);
888 instance.SetDeleteArray(&deleteArray_Muc2DStrip);
889 instance.SetDestructor(&destruct_Muc2DStrip);
890 return &instance;
891 }
892 TGenericClassInfo *GenerateInitInstance(const ::Muc2DStrip*)
893 {
894 return GenerateInitInstanceLocal((::Muc2DStrip*)0);
895 }
896 // Static variable to force the class initialization
897 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0); R__UseDummy(_R__UNIQUE_(Init));
898} // end of namespace ROOT
899
900namespace ROOT {
901 void MucROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
902 static void MucROOTGeo_Dictionary();
903 static void *new_MucROOTGeo(void *p = 0);
904 static void *newArray_MucROOTGeo(Long_t size, void *p);
905 static void delete_MucROOTGeo(void *p);
906 static void deleteArray_MucROOTGeo(void *p);
907 static void destruct_MucROOTGeo(void *p);
908
909 // Function generating the singleton type initializer
910 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MucROOTGeo*)
911 {
912 // Make sure the shadow class has the right sizeof
913 R__ASSERT(sizeof(::MucROOTGeo) == sizeof(::ROOT::Shadow::MucROOTGeo));
914 ::MucROOTGeo *ptr = 0;
915 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MucROOTGeo),0);
916 static ::ROOT::TGenericClassInfo
917 instance("MucROOTGeo", "./../BesVisLib/MucROOTGeo.h", 31,
918 typeid(::MucROOTGeo), DefineBehavior(ptr, ptr),
919 &MucROOTGeo_ShowMembers, &MucROOTGeo_Dictionary, isa_proxy, 4,
920 sizeof(::MucROOTGeo) );
921 instance.SetNew(&new_MucROOTGeo);
922 instance.SetNewArray(&newArray_MucROOTGeo);
923 instance.SetDelete(&delete_MucROOTGeo);
924 instance.SetDeleteArray(&deleteArray_MucROOTGeo);
925 instance.SetDestructor(&destruct_MucROOTGeo);
926 return &instance;
927 }
928 TGenericClassInfo *GenerateInitInstance(const ::MucROOTGeo*)
929 {
930 return GenerateInitInstanceLocal((::MucROOTGeo*)0);
931 }
932 // Static variable to force the class initialization
933 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
934
935 // Dictionary for non-ClassDef classes
936 static void MucROOTGeo_Dictionary() {
937 ::ROOT::GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0)->GetClass();
938 }
939
940} // end of namespace ROOT
941
942namespace ROOT {
943 void BesGeometry_ShowMembers(void *obj, TMemberInspector &R__insp);
944 static void *new_BesGeometry(void *p = 0);
945 static void *newArray_BesGeometry(Long_t size, void *p);
946 static void delete_BesGeometry(void *p);
947 static void deleteArray_BesGeometry(void *p);
948 static void destruct_BesGeometry(void *p);
949
950 // Function generating the singleton type initializer
951 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeometry*)
952 {
953 ::BesGeometry *ptr = 0;
954 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeometry >(0);
955 static ::ROOT::TGenericClassInfo
956 instance("BesGeometry", ::BesGeometry::Class_Version(), "./../BesVisLib/BesGeometry.h", 18,
957 typeid(::BesGeometry), DefineBehavior(ptr, ptr),
958 &::BesGeometry::Dictionary, isa_proxy, 4,
959 sizeof(::BesGeometry) );
960 instance.SetNew(&new_BesGeometry);
961 instance.SetNewArray(&newArray_BesGeometry);
962 instance.SetDelete(&delete_BesGeometry);
963 instance.SetDeleteArray(&deleteArray_BesGeometry);
964 instance.SetDestructor(&destruct_BesGeometry);
965 return &instance;
966 }
967 TGenericClassInfo *GenerateInitInstance(const ::BesGeometry*)
968 {
969 return GenerateInitInstanceLocal((::BesGeometry*)0);
970 }
971 // Static variable to force the class initialization
972 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGeometry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
973} // end of namespace ROOT
974
975namespace ROOT {
976 void BesGMenuTitle_ShowMembers(void *obj, TMemberInspector &R__insp);
977 static void *new_BesGMenuTitle(void *p = 0);
978 static void *newArray_BesGMenuTitle(Long_t size, void *p);
979 static void delete_BesGMenuTitle(void *p);
980 static void deleteArray_BesGMenuTitle(void *p);
981 static void destruct_BesGMenuTitle(void *p);
982
983 // Function generating the singleton type initializer
984 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuTitle*)
985 {
986 ::BesGMenuTitle *ptr = 0;
987 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuTitle >(0);
988 static ::ROOT::TGenericClassInfo
989 instance("BesGMenuTitle", ::BesGMenuTitle::Class_Version(), "./../BesVisLib/BesGMenuTitle.h", 12,
990 typeid(::BesGMenuTitle), DefineBehavior(ptr, ptr),
991 &::BesGMenuTitle::Dictionary, isa_proxy, 4,
992 sizeof(::BesGMenuTitle) );
993 instance.SetNew(&new_BesGMenuTitle);
994 instance.SetNewArray(&newArray_BesGMenuTitle);
995 instance.SetDelete(&delete_BesGMenuTitle);
996 instance.SetDeleteArray(&deleteArray_BesGMenuTitle);
997 instance.SetDestructor(&destruct_BesGMenuTitle);
998 return &instance;
999 }
1000 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuTitle*)
1001 {
1002 return GenerateInitInstanceLocal((::BesGMenuTitle*)0);
1003 }
1004 // Static variable to force the class initialization
1005 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1006} // end of namespace ROOT
1007
1008namespace ROOT {
1009 void BesGMenuBar_ShowMembers(void *obj, TMemberInspector &R__insp);
1010 static void *new_BesGMenuBar(void *p = 0);
1011 static void *newArray_BesGMenuBar(Long_t size, void *p);
1012 static void delete_BesGMenuBar(void *p);
1013 static void deleteArray_BesGMenuBar(void *p);
1014 static void destruct_BesGMenuBar(void *p);
1015
1016 // Function generating the singleton type initializer
1017 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuBar*)
1018 {
1019 ::BesGMenuBar *ptr = 0;
1020 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuBar >(0);
1021 static ::ROOT::TGenericClassInfo
1022 instance("BesGMenuBar", ::BesGMenuBar::Class_Version(), "./../BesVisLib/BesGMenuBar.h", 8,
1023 typeid(::BesGMenuBar), DefineBehavior(ptr, ptr),
1024 &::BesGMenuBar::Dictionary, isa_proxy, 4,
1025 sizeof(::BesGMenuBar) );
1026 instance.SetNew(&new_BesGMenuBar);
1027 instance.SetNewArray(&newArray_BesGMenuBar);
1028 instance.SetDelete(&delete_BesGMenuBar);
1029 instance.SetDeleteArray(&deleteArray_BesGMenuBar);
1030 instance.SetDestructor(&destruct_BesGMenuBar);
1031 return &instance;
1032 }
1033 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuBar*)
1034 {
1035 return GenerateInitInstanceLocal((::BesGMenuBar*)0);
1036 }
1037 // Static variable to force the class initialization
1038 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1039} // end of namespace ROOT
1040
1041namespace ROOT {
1042 void BesGPictureButton_ShowMembers(void *obj, TMemberInspector &R__insp);
1043 static void *new_BesGPictureButton(void *p = 0);
1044 static void *newArray_BesGPictureButton(Long_t size, void *p);
1045 static void delete_BesGPictureButton(void *p);
1046 static void deleteArray_BesGPictureButton(void *p);
1047 static void destruct_BesGPictureButton(void *p);
1048
1049 // Function generating the singleton type initializer
1050 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGPictureButton*)
1051 {
1052 ::BesGPictureButton *ptr = 0;
1053 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGPictureButton >(0);
1054 static ::ROOT::TGenericClassInfo
1055 instance("BesGPictureButton", ::BesGPictureButton::Class_Version(), "./../BesVisLib/BesGPictureButton.h", 7,
1056 typeid(::BesGPictureButton), DefineBehavior(ptr, ptr),
1057 &::BesGPictureButton::Dictionary, isa_proxy, 4,
1058 sizeof(::BesGPictureButton) );
1059 instance.SetNew(&new_BesGPictureButton);
1060 instance.SetNewArray(&newArray_BesGPictureButton);
1061 instance.SetDelete(&delete_BesGPictureButton);
1062 instance.SetDeleteArray(&deleteArray_BesGPictureButton);
1063 instance.SetDestructor(&destruct_BesGPictureButton);
1064 return &instance;
1065 }
1066 TGenericClassInfo *GenerateInitInstance(const ::BesGPictureButton*)
1067 {
1068 return GenerateInitInstanceLocal((::BesGPictureButton*)0);
1069 }
1070 // Static variable to force the class initialization
1071 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1072} // end of namespace ROOT
1073
1074namespace ROOT {
1075 void BesHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
1076 static void *new_BesHeader(void *p = 0);
1077 static void *newArray_BesHeader(Long_t size, void *p);
1078 static void delete_BesHeader(void *p);
1079 static void deleteArray_BesHeader(void *p);
1080 static void destruct_BesHeader(void *p);
1081
1082 // Function generating the singleton type initializer
1083 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesHeader*)
1084 {
1085 ::BesHeader *ptr = 0;
1086 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesHeader >(0);
1087 static ::ROOT::TGenericClassInfo
1088 instance("BesHeader", ::BesHeader::Class_Version(), "./../BesVisLib/BesHeader.h", 12,
1089 typeid(::BesHeader), DefineBehavior(ptr, ptr),
1090 &::BesHeader::Dictionary, isa_proxy, 4,
1091 sizeof(::BesHeader) );
1092 instance.SetNew(&new_BesHeader);
1093 instance.SetNewArray(&newArray_BesHeader);
1094 instance.SetDelete(&delete_BesHeader);
1095 instance.SetDeleteArray(&deleteArray_BesHeader);
1096 instance.SetDestructor(&destruct_BesHeader);
1097 return &instance;
1098 }
1099 TGenericClassInfo *GenerateInitInstance(const ::BesHeader*)
1100 {
1101 return GenerateInitInstanceLocal((::BesHeader*)0);
1102 }
1103 // Static variable to force the class initialization
1104 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1105} // end of namespace ROOT
1106
1107namespace ROOT {
1108 void BesVisDisplay_ShowMembers(void *obj, TMemberInspector &R__insp);
1109 static void *new_BesVisDisplay(void *p = 0);
1110 static void *newArray_BesVisDisplay(Long_t size, void *p);
1111 static void delete_BesVisDisplay(void *p);
1112 static void deleteArray_BesVisDisplay(void *p);
1113 static void destruct_BesVisDisplay(void *p);
1114
1115 // Function generating the singleton type initializer
1116 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesVisDisplay*)
1117 {
1118 ::BesVisDisplay *ptr = 0;
1119 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesVisDisplay >(0);
1120 static ::ROOT::TGenericClassInfo
1121 instance("BesVisDisplay", ::BesVisDisplay::Class_Version(), "./../BesVisLib/BesVisDisplay.h", 37,
1122 typeid(::BesVisDisplay), DefineBehavior(ptr, ptr),
1123 &::BesVisDisplay::Dictionary, isa_proxy, 4,
1124 sizeof(::BesVisDisplay) );
1125 instance.SetNew(&new_BesVisDisplay);
1126 instance.SetNewArray(&newArray_BesVisDisplay);
1127 instance.SetDelete(&delete_BesVisDisplay);
1128 instance.SetDeleteArray(&deleteArray_BesVisDisplay);
1129 instance.SetDestructor(&destruct_BesVisDisplay);
1130 return &instance;
1131 }
1132 TGenericClassInfo *GenerateInitInstance(const ::BesVisDisplay*)
1133 {
1134 return GenerateInitInstanceLocal((::BesVisDisplay*)0);
1135 }
1136 // Static variable to force the class initialization
1137 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1138} // end of namespace ROOT
1139
1140namespace ROOT {
1141 void ZHelix_ShowMembers(void *obj, TMemberInspector &R__insp);
1142 static void *new_ZHelix(void *p = 0);
1143 static void *newArray_ZHelix(Long_t size, void *p);
1144 static void delete_ZHelix(void *p);
1145 static void deleteArray_ZHelix(void *p);
1146 static void destruct_ZHelix(void *p);
1147 static Long64_t merge_ZHelix(void *obj, TCollection *coll,TFileMergeInfo *info);
1148
1149 // Function generating the singleton type initializer
1150 static TGenericClassInfo *GenerateInitInstanceLocal(const ::ZHelix*)
1151 {
1152 ::ZHelix *ptr = 0;
1153 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ZHelix >(0);
1154 static ::ROOT::TGenericClassInfo
1155 instance("ZHelix", ::ZHelix::Class_Version(), "./../BesVisLib/ZHelix.h", 42,
1156 typeid(::ZHelix), DefineBehavior(ptr, ptr),
1157 &::ZHelix::Dictionary, isa_proxy, 4,
1158 sizeof(::ZHelix) );
1159 instance.SetNew(&new_ZHelix);
1160 instance.SetNewArray(&newArray_ZHelix);
1161 instance.SetDelete(&delete_ZHelix);
1162 instance.SetDeleteArray(&deleteArray_ZHelix);
1163 instance.SetDestructor(&destruct_ZHelix);
1164 instance.SetMerge(&merge_ZHelix);
1165 return &instance;
1166 }
1167 TGenericClassInfo *GenerateInitInstance(const ::ZHelix*)
1168 {
1169 return GenerateInitInstanceLocal((::ZHelix*)0);
1170 }
1171 // Static variable to force the class initialization
1172 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ZHelix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1173} // end of namespace ROOT
1174
1175namespace ROOT {
1176 void vector3_ShowMembers(void *obj, TMemberInspector &R__insp);
1177 static void vector3_Dictionary();
1178 static void *new_vector3(void *p = 0);
1179 static void *newArray_vector3(Long_t size, void *p);
1180 static void delete_vector3(void *p);
1181 static void deleteArray_vector3(void *p);
1182 static void destruct_vector3(void *p);
1183
1184 // Function generating the singleton type initializer
1185 static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector3*)
1186 {
1187 // Make sure the shadow class has the right sizeof
1188 R__ASSERT(sizeof(::vector3) == sizeof(::ROOT::Shadow::vector3));
1189 ::vector3 *ptr = 0;
1190 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector3),0);
1191 static ::ROOT::TGenericClassInfo
1192 instance("vector3", "./../BesVisLib/vector3.h", 5,
1193 typeid(::vector3), DefineBehavior(ptr, ptr),
1194 &vector3_ShowMembers, &vector3_Dictionary, isa_proxy, 4,
1195 sizeof(::vector3) );
1196 instance.SetNew(&new_vector3);
1197 instance.SetNewArray(&newArray_vector3);
1198 instance.SetDelete(&delete_vector3);
1199 instance.SetDeleteArray(&deleteArray_vector3);
1200 instance.SetDestructor(&destruct_vector3);
1201 return &instance;
1202 }
1203 TGenericClassInfo *GenerateInitInstance(const ::vector3*)
1204 {
1205 return GenerateInitInstanceLocal((::vector3*)0);
1206 }
1207 // Static variable to force the class initialization
1208 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1209
1210 // Dictionary for non-ClassDef classes
1211 static void vector3_Dictionary() {
1212 ::ROOT::GenerateInitInstanceLocal((const ::vector3*)0x0)->GetClass();
1213 }
1214
1215} // end of namespace ROOT
1216
1217//______________________________________________________________________________
1218TClass *BesStatus::fgIsA = 0; // static to hold class pointer
1219
1220//______________________________________________________________________________
1221const char *BesStatus::Class_Name()
1222{
1223 return "BesStatus";
1224}
1225
1226//______________________________________________________________________________
1227const char *BesStatus::ImplFileName()
1228{
1229 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileName();
1230}
1231
1232//______________________________________________________________________________
1233int BesStatus::ImplFileLine()
1234{
1235 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileLine();
1236}
1237
1238//______________________________________________________________________________
1239void BesStatus::Dictionary()
1240{
1241 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass();
1242}
1243
1244//______________________________________________________________________________
1245TClass *BesStatus::Class()
1246{
1247 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass();
1248 return fgIsA;
1249}
1250
1251//______________________________________________________________________________
1252TClass *BesTView::fgIsA = 0; // static to hold class pointer
1253
1254//______________________________________________________________________________
1255const char *BesTView::Class_Name()
1256{
1257 return "BesTView";
1258}
1259
1260//______________________________________________________________________________
1261const char *BesTView::ImplFileName()
1262{
1263 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileName();
1264}
1265
1266//______________________________________________________________________________
1267int BesTView::ImplFileLine()
1268{
1269 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileLine();
1270}
1271
1272//______________________________________________________________________________
1273void BesTView::Dictionary()
1274{
1275 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass();
1276}
1277
1278//______________________________________________________________________________
1279TClass *BesTView::Class()
1280{
1281 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass();
1282 return fgIsA;
1283}
1284
1285//______________________________________________________________________________
1286TClass *Bes2DView::fgIsA = 0; // static to hold class pointer
1287
1288//______________________________________________________________________________
1289const char *Bes2DView::Class_Name()
1290{
1291 return "Bes2DView";
1292}
1293
1294//______________________________________________________________________________
1295const char *Bes2DView::ImplFileName()
1296{
1297 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileName();
1298}
1299
1300//______________________________________________________________________________
1301int Bes2DView::ImplFileLine()
1302{
1303 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileLine();
1304}
1305
1306//______________________________________________________________________________
1307void Bes2DView::Dictionary()
1308{
1309 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass();
1310}
1311
1312//______________________________________________________________________________
1313TClass *Bes2DView::Class()
1314{
1315 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass();
1316 return fgIsA;
1317}
1318
1319//______________________________________________________________________________
1320TClass *BesCircle2D::fgIsA = 0; // static to hold class pointer
1321
1322//______________________________________________________________________________
1323const char *BesCircle2D::Class_Name()
1324{
1325 return "BesCircle2D";
1326}
1327
1328//______________________________________________________________________________
1329const char *BesCircle2D::ImplFileName()
1330{
1331 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileName();
1332}
1333
1334//______________________________________________________________________________
1335int BesCircle2D::ImplFileLine()
1336{
1337 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileLine();
1338}
1339
1340//______________________________________________________________________________
1341void BesCircle2D::Dictionary()
1342{
1343 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass();
1344}
1345
1346//______________________________________________________________________________
1347TClass *BesCircle2D::Class()
1348{
1349 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass();
1350 return fgIsA;
1351}
1352
1353//______________________________________________________________________________
1354TClass *BesCursor::fgIsA = 0; // static to hold class pointer
1355
1356//______________________________________________________________________________
1357const char *BesCursor::Class_Name()
1358{
1359 return "BesCursor";
1360}
1361
1362//______________________________________________________________________________
1363const char *BesCursor::ImplFileName()
1364{
1365 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileName();
1366}
1367
1368//______________________________________________________________________________
1369int BesCursor::ImplFileLine()
1370{
1371 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileLine();
1372}
1373
1374//______________________________________________________________________________
1375void BesCursor::Dictionary()
1376{
1377 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass();
1378}
1379
1380//______________________________________________________________________________
1381TClass *BesCursor::Class()
1382{
1383 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass();
1384 return fgIsA;
1385}
1386
1387//______________________________________________________________________________
1388TClass *BesEventHeader::fgIsA = 0; // static to hold class pointer
1389
1390//______________________________________________________________________________
1391const char *BesEventHeader::Class_Name()
1392{
1393 return "BesEventHeader";
1394}
1395
1396//______________________________________________________________________________
1397const char *BesEventHeader::ImplFileName()
1398{
1399 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileName();
1400}
1401
1402//______________________________________________________________________________
1403int BesEventHeader::ImplFileLine()
1404{
1405 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileLine();
1406}
1407
1408//______________________________________________________________________________
1409void BesEventHeader::Dictionary()
1410{
1411 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass();
1412}
1413
1414//______________________________________________________________________________
1415TClass *BesEventHeader::Class()
1416{
1417 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass();
1418 return fgIsA;
1419}
1420
1421//______________________________________________________________________________
1422TClass *BesView::fgIsA = 0; // static to hold class pointer
1423
1424//______________________________________________________________________________
1425const char *BesView::Class_Name()
1426{
1427 return "BesView";
1428}
1429
1430//______________________________________________________________________________
1431const char *BesView::ImplFileName()
1432{
1433 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileName();
1434}
1435
1436//______________________________________________________________________________
1437int BesView::ImplFileLine()
1438{
1439 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileLine();
1440}
1441
1442//______________________________________________________________________________
1443void BesView::Dictionary()
1444{
1445 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass();
1446}
1447
1448//______________________________________________________________________________
1449TClass *BesView::Class()
1450{
1451 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass();
1452 return fgIsA;
1453}
1454
1455//______________________________________________________________________________
1456TClass *BesMarker2D::fgIsA = 0; // static to hold class pointer
1457
1458//______________________________________________________________________________
1459const char *BesMarker2D::Class_Name()
1460{
1461 return "BesMarker2D";
1462}
1463
1464//______________________________________________________________________________
1465const char *BesMarker2D::ImplFileName()
1466{
1467 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileName();
1468}
1469
1470//______________________________________________________________________________
1471int BesMarker2D::ImplFileLine()
1472{
1473 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileLine();
1474}
1475
1476//______________________________________________________________________________
1477void BesMarker2D::Dictionary()
1478{
1479 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass();
1480}
1481
1482//______________________________________________________________________________
1483TClass *BesMarker2D::Class()
1484{
1485 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass();
1486 return fgIsA;
1487}
1488
1489//______________________________________________________________________________
1490TClass *BesPaveText::fgIsA = 0; // static to hold class pointer
1491
1492//______________________________________________________________________________
1493const char *BesPaveText::Class_Name()
1494{
1495 return "BesPaveText";
1496}
1497
1498//______________________________________________________________________________
1499const char *BesPaveText::ImplFileName()
1500{
1501 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileName();
1502}
1503
1504//______________________________________________________________________________
1505int BesPaveText::ImplFileLine()
1506{
1507 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileLine();
1508}
1509
1510//______________________________________________________________________________
1511void BesPaveText::Dictionary()
1512{
1513 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass();
1514}
1515
1516//______________________________________________________________________________
1517TClass *BesPaveText::Class()
1518{
1519 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass();
1520 return fgIsA;
1521}
1522
1523//______________________________________________________________________________
1524TClass *BesGeoTrack::fgIsA = 0; // static to hold class pointer
1525
1526//______________________________________________________________________________
1527const char *BesGeoTrack::Class_Name()
1528{
1529 return "BesGeoTrack";
1530}
1531
1532//______________________________________________________________________________
1533const char *BesGeoTrack::ImplFileName()
1534{
1535 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileName();
1536}
1537
1538//______________________________________________________________________________
1539int BesGeoTrack::ImplFileLine()
1540{
1541 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileLine();
1542}
1543
1544//______________________________________________________________________________
1545void BesGeoTrack::Dictionary()
1546{
1547 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass();
1548}
1549
1550//______________________________________________________________________________
1551TClass *BesGeoTrack::Class()
1552{
1553 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass();
1554 return fgIsA;
1555}
1556
1557//______________________________________________________________________________
1558TClass *BesEvent::fgIsA = 0; // static to hold class pointer
1559
1560//______________________________________________________________________________
1561const char *BesEvent::Class_Name()
1562{
1563 return "BesEvent";
1564}
1565
1566//______________________________________________________________________________
1567const char *BesEvent::ImplFileName()
1568{
1569 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileName();
1570}
1571
1572//______________________________________________________________________________
1573int BesEvent::ImplFileLine()
1574{
1575 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileLine();
1576}
1577
1578//______________________________________________________________________________
1579void BesEvent::Dictionary()
1580{
1581 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass();
1582}
1583
1584//______________________________________________________________________________
1585TClass *BesEvent::Class()
1586{
1587 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass();
1588 return fgIsA;
1589}
1590
1591//______________________________________________________________________________
1592TClass *BesPolygon2D::fgIsA = 0; // static to hold class pointer
1593
1594//______________________________________________________________________________
1595const char *BesPolygon2D::Class_Name()
1596{
1597 return "BesPolygon2D";
1598}
1599
1600//______________________________________________________________________________
1601const char *BesPolygon2D::ImplFileName()
1602{
1603 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileName();
1604}
1605
1606//______________________________________________________________________________
1607int BesPolygon2D::ImplFileLine()
1608{
1609 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileLine();
1610}
1611
1612//______________________________________________________________________________
1613void BesPolygon2D::Dictionary()
1614{
1615 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass();
1616}
1617
1618//______________________________________________________________________________
1619TClass *BesPolygon2D::Class()
1620{
1621 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass();
1622 return fgIsA;
1623}
1624
1625//______________________________________________________________________________
1626TClass *Mdc2DWire::fgIsA = 0; // static to hold class pointer
1627
1628//______________________________________________________________________________
1629const char *Mdc2DWire::Class_Name()
1630{
1631 return "Mdc2DWire";
1632}
1633
1634//______________________________________________________________________________
1635const char *Mdc2DWire::ImplFileName()
1636{
1637 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileName();
1638}
1639
1640//______________________________________________________________________________
1641int Mdc2DWire::ImplFileLine()
1642{
1643 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileLine();
1644}
1645
1646//______________________________________________________________________________
1647void Mdc2DWire::Dictionary()
1648{
1649 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass();
1650}
1651
1652//______________________________________________________________________________
1653TClass *Mdc2DWire::Class()
1654{
1655 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass();
1656 return fgIsA;
1657}
1658
1659//______________________________________________________________________________
1660TClass *Tof2DScin::fgIsA = 0; // static to hold class pointer
1661
1662//______________________________________________________________________________
1663const char *Tof2DScin::Class_Name()
1664{
1665 return "Tof2DScin";
1666}
1667
1668//______________________________________________________________________________
1669const char *Tof2DScin::ImplFileName()
1670{
1671 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileName();
1672}
1673
1674//______________________________________________________________________________
1675int Tof2DScin::ImplFileLine()
1676{
1677 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileLine();
1678}
1679
1680//______________________________________________________________________________
1681void Tof2DScin::Dictionary()
1682{
1683 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass();
1684}
1685
1686//______________________________________________________________________________
1687TClass *Tof2DScin::Class()
1688{
1689 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass();
1690 return fgIsA;
1691}
1692
1693//______________________________________________________________________________
1694TClass *Emc2DCrystal::fgIsA = 0; // static to hold class pointer
1695
1696//______________________________________________________________________________
1697const char *Emc2DCrystal::Class_Name()
1698{
1699 return "Emc2DCrystal";
1700}
1701
1702//______________________________________________________________________________
1703const char *Emc2DCrystal::ImplFileName()
1704{
1705 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileName();
1706}
1707
1708//______________________________________________________________________________
1709int Emc2DCrystal::ImplFileLine()
1710{
1711 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileLine();
1712}
1713
1714//______________________________________________________________________________
1715void Emc2DCrystal::Dictionary()
1716{
1717 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass();
1718}
1719
1720//______________________________________________________________________________
1721TClass *Emc2DCrystal::Class()
1722{
1723 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass();
1724 return fgIsA;
1725}
1726
1727//______________________________________________________________________________
1728TClass *Muc2DStrip::fgIsA = 0; // static to hold class pointer
1729
1730//______________________________________________________________________________
1731const char *Muc2DStrip::Class_Name()
1732{
1733 return "Muc2DStrip";
1734}
1735
1736//______________________________________________________________________________
1737const char *Muc2DStrip::ImplFileName()
1738{
1739 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileName();
1740}
1741
1742//______________________________________________________________________________
1743int Muc2DStrip::ImplFileLine()
1744{
1745 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileLine();
1746}
1747
1748//______________________________________________________________________________
1749void Muc2DStrip::Dictionary()
1750{
1751 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass();
1752}
1753
1754//______________________________________________________________________________
1755TClass *Muc2DStrip::Class()
1756{
1757 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass();
1758 return fgIsA;
1759}
1760
1761//______________________________________________________________________________
1762TClass *BesGeometry::fgIsA = 0; // static to hold class pointer
1763
1764//______________________________________________________________________________
1765const char *BesGeometry::Class_Name()
1766{
1767 return "BesGeometry";
1768}
1769
1770//______________________________________________________________________________
1771const char *BesGeometry::ImplFileName()
1772{
1773 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileName();
1774}
1775
1776//______________________________________________________________________________
1777int BesGeometry::ImplFileLine()
1778{
1779 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileLine();
1780}
1781
1782//______________________________________________________________________________
1783void BesGeometry::Dictionary()
1784{
1785 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass();
1786}
1787
1788//______________________________________________________________________________
1789TClass *BesGeometry::Class()
1790{
1791 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass();
1792 return fgIsA;
1793}
1794
1795//______________________________________________________________________________
1796TClass *BesGMenuTitle::fgIsA = 0; // static to hold class pointer
1797
1798//______________________________________________________________________________
1799const char *BesGMenuTitle::Class_Name()
1800{
1801 return "BesGMenuTitle";
1802}
1803
1804//______________________________________________________________________________
1805const char *BesGMenuTitle::ImplFileName()
1806{
1807 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileName();
1808}
1809
1810//______________________________________________________________________________
1811int BesGMenuTitle::ImplFileLine()
1812{
1813 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileLine();
1814}
1815
1816//______________________________________________________________________________
1817void BesGMenuTitle::Dictionary()
1818{
1819 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass();
1820}
1821
1822//______________________________________________________________________________
1823TClass *BesGMenuTitle::Class()
1824{
1825 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass();
1826 return fgIsA;
1827}
1828
1829//______________________________________________________________________________
1830TClass *BesGMenuBar::fgIsA = 0; // static to hold class pointer
1831
1832//______________________________________________________________________________
1833const char *BesGMenuBar::Class_Name()
1834{
1835 return "BesGMenuBar";
1836}
1837
1838//______________________________________________________________________________
1839const char *BesGMenuBar::ImplFileName()
1840{
1841 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileName();
1842}
1843
1844//______________________________________________________________________________
1845int BesGMenuBar::ImplFileLine()
1846{
1847 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileLine();
1848}
1849
1850//______________________________________________________________________________
1851void BesGMenuBar::Dictionary()
1852{
1853 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass();
1854}
1855
1856//______________________________________________________________________________
1857TClass *BesGMenuBar::Class()
1858{
1859 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass();
1860 return fgIsA;
1861}
1862
1863//______________________________________________________________________________
1864TClass *BesGPictureButton::fgIsA = 0; // static to hold class pointer
1865
1866//______________________________________________________________________________
1867const char *BesGPictureButton::Class_Name()
1868{
1869 return "BesGPictureButton";
1870}
1871
1872//______________________________________________________________________________
1873const char *BesGPictureButton::ImplFileName()
1874{
1875 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileName();
1876}
1877
1878//______________________________________________________________________________
1879int BesGPictureButton::ImplFileLine()
1880{
1881 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileLine();
1882}
1883
1884//______________________________________________________________________________
1885void BesGPictureButton::Dictionary()
1886{
1887 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass();
1888}
1889
1890//______________________________________________________________________________
1891TClass *BesGPictureButton::Class()
1892{
1893 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass();
1894 return fgIsA;
1895}
1896
1897//______________________________________________________________________________
1898TClass *BesHeader::fgIsA = 0; // static to hold class pointer
1899
1900//______________________________________________________________________________
1901const char *BesHeader::Class_Name()
1902{
1903 return "BesHeader";
1904}
1905
1906//______________________________________________________________________________
1907const char *BesHeader::ImplFileName()
1908{
1909 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileName();
1910}
1911
1912//______________________________________________________________________________
1913int BesHeader::ImplFileLine()
1914{
1915 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileLine();
1916}
1917
1918//______________________________________________________________________________
1919void BesHeader::Dictionary()
1920{
1921 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass();
1922}
1923
1924//______________________________________________________________________________
1925TClass *BesHeader::Class()
1926{
1927 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass();
1928 return fgIsA;
1929}
1930
1931//______________________________________________________________________________
1932TClass *BesVisDisplay::fgIsA = 0; // static to hold class pointer
1933
1934//______________________________________________________________________________
1935const char *BesVisDisplay::Class_Name()
1936{
1937 return "BesVisDisplay";
1938}
1939
1940//______________________________________________________________________________
1941const char *BesVisDisplay::ImplFileName()
1942{
1943 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileName();
1944}
1945
1946//______________________________________________________________________________
1947int BesVisDisplay::ImplFileLine()
1948{
1949 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileLine();
1950}
1951
1952//______________________________________________________________________________
1953void BesVisDisplay::Dictionary()
1954{
1955 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass();
1956}
1957
1958//______________________________________________________________________________
1959TClass *BesVisDisplay::Class()
1960{
1961 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass();
1962 return fgIsA;
1963}
1964
1965//______________________________________________________________________________
1966TClass *ZHelix::fgIsA = 0; // static to hold class pointer
1967
1968//______________________________________________________________________________
1969const char *ZHelix::Class_Name()
1970{
1971 return "ZHelix";
1972}
1973
1974//______________________________________________________________________________
1975const char *ZHelix::ImplFileName()
1976{
1977 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileName();
1978}
1979
1980//______________________________________________________________________________
1981int ZHelix::ImplFileLine()
1982{
1983 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileLine();
1984}
1985
1986//______________________________________________________________________________
1987void ZHelix::Dictionary()
1988{
1989 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass();
1990}
1991
1992//______________________________________________________________________________
1993TClass *ZHelix::Class()
1994{
1995 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass();
1996 return fgIsA;
1997}
1998
1999//______________________________________________________________________________
2000void BesTView::ShowMembers(TMemberInspector &R__insp)
2001{
2002 // Inspect the data members of an object of class BesTView.
2003 TClass *R__cl = ::BesTView::IsA();
2004 if (R__cl || R__insp.IsA()) { }
2005 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatitude", &fLatitude);
2006 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLongitude", &fLongitude);
2007 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsi", &fPsi);
2008 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDview", &fDview);
2009 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDproj", &fDproj);
2010 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpix", &fUpix);
2011 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVpix", &fVpix);
2012 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTN[16]", fTN);
2013 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTB[16]", fTB);
2014 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax[3]", fRmax);
2015 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin[3]", fRmin);
2016 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUVcoord[4]", fUVcoord);
2017 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTnorm[16]", fTnorm);
2018 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTback[16]", fTback);
2019 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1[3]", fX1);
2020 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2[3]", fX2);
2021 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1[3]", fY1);
2022 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2[3]", fY2);
2023 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ1[3]", fZ1);
2024 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ2[3]", fZ2);
2025 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSystem", &fSystem);
2026 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutline", &fOutline);
2027 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultOutline", &fDefaultOutline);
2028 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoRange", &fAutoRange);
2029 R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
2030 TView::ShowMembers(R__insp);
2031}
2032
2033namespace ROOT {
2034 // Wrappers around operator new
2035 static void *new_BesTView(void *p) {
2036 return p ? new(p) ::BesTView : new ::BesTView;
2037 }
2038 static void *newArray_BesTView(Long_t nElements, void *p) {
2039 return p ? new(p) ::BesTView[nElements] : new ::BesTView[nElements];
2040 }
2041 // Wrapper around operator delete
2042 static void delete_BesTView(void *p) {
2043 delete ((::BesTView*)p);
2044 }
2045 static void deleteArray_BesTView(void *p) {
2046 delete [] ((::BesTView*)p);
2047 }
2048 static void destruct_BesTView(void *p) {
2049 typedef ::BesTView current_t;
2050 ((current_t*)p)->~current_t();
2051 }
2052 // Wrapper around a custom streamer member function.
2053 static void streamer_BesTView(TBuffer &buf, void *obj) {
2054 ((::BesTView*)obj)->::BesTView::Streamer(buf);
2055 }
2056} // end of namespace ROOT for class ::BesTView
2057
2058//______________________________________________________________________________
2059void Bes2DView::Streamer(TBuffer &R__b)
2060{
2061 // Stream an object of class Bes2DView.
2062
2063 if (R__b.IsReading()) {
2064 R__b.ReadClassBuffer(Bes2DView::Class(),this);
2065 } else {
2066 R__b.WriteClassBuffer(Bes2DView::Class(),this);
2067 }
2068}
2069
2070//______________________________________________________________________________
2071void Bes2DView::ShowMembers(TMemberInspector &R__insp)
2072{
2073 // Inspect the data members of an object of class Bes2DView.
2074 TClass *R__cl = ::Bes2DView::IsA();
2075 if (R__cl || R__insp.IsA()) { }
2076 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
2077 R__insp.Inspect(R__cl, R__insp.GetParent(), "f2DViewType", &f2DViewType);
2078 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
2079 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
2080 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
2081 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerSize", &fMarkerSize);
2082 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus3D", &fStatus3D);
2083 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusXY", &fStatusXY);
2084 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusZR", &fStatusZR);
2085 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusCurrent", &fStatusCurrent);
2086 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomFactor", &fZoomFactor);
2087 BesTView::ShowMembers(R__insp);
2088}
2089
2090namespace ROOT {
2091 // Wrappers around operator new
2092 static void *new_Bes2DView(void *p) {
2093 return p ? new(p) ::Bes2DView : new ::Bes2DView;
2094 }
2095 static void *newArray_Bes2DView(Long_t nElements, void *p) {
2096 return p ? new(p) ::Bes2DView[nElements] : new ::Bes2DView[nElements];
2097 }
2098 // Wrapper around operator delete
2099 static void delete_Bes2DView(void *p) {
2100 delete ((::Bes2DView*)p);
2101 }
2102 static void deleteArray_Bes2DView(void *p) {
2103 delete [] ((::Bes2DView*)p);
2104 }
2105 static void destruct_Bes2DView(void *p) {
2106 typedef ::Bes2DView current_t;
2107 ((current_t*)p)->~current_t();
2108 }
2109} // end of namespace ROOT for class ::Bes2DView
2110
2111//______________________________________________________________________________
2112void BesCircle2D::Streamer(TBuffer &R__b)
2113{
2114 // Stream an object of class BesCircle2D.
2115
2116 if (R__b.IsReading()) {
2117 R__b.ReadClassBuffer(BesCircle2D::Class(),this);
2118 } else {
2119 R__b.WriteClassBuffer(BesCircle2D::Class(),this);
2120 }
2121}
2122
2123//______________________________________________________________________________
2124void BesCircle2D::ShowMembers(TMemberInspector &R__insp)
2125{
2126 // Inspect the data members of an object of class BesCircle2D.
2127 TClass *R__cl = ::BesCircle2D::IsA();
2128 if (R__cl || R__insp.IsA()) { }
2129 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_innerCircleX", &f_innerCircleX);
2130 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_innerCircleY", &f_innerCircleY);
2131 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_outerCircleX", &f_outerCircleX);
2132 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_outerCircleY", &f_outerCircleY);
2133 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_areaX", &f_areaX);
2134 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_areaY", &f_areaY);
2135 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerRadius", &fInnerRadius);
2136 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOuterRadius", &fOuterRadius);
2137 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenter", &fCenter);
2138 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSegment", &fNSegment);
2139 TNamed::ShowMembers(R__insp);
2140 TAttLine::ShowMembers(R__insp);
2141 TAttFill::ShowMembers(R__insp);
2142}
2143
2144namespace ROOT {
2145 // Wrappers around operator new
2146 static void *new_BesCircle2D(void *p) {
2147 return p ? new(p) ::BesCircle2D : new ::BesCircle2D;
2148 }
2149 static void *newArray_BesCircle2D(Long_t nElements, void *p) {
2150 return p ? new(p) ::BesCircle2D[nElements] : new ::BesCircle2D[nElements];
2151 }
2152 // Wrapper around operator delete
2153 static void delete_BesCircle2D(void *p) {
2154 delete ((::BesCircle2D*)p);
2155 }
2156 static void deleteArray_BesCircle2D(void *p) {
2157 delete [] ((::BesCircle2D*)p);
2158 }
2159 static void destruct_BesCircle2D(void *p) {
2160 typedef ::BesCircle2D current_t;
2161 ((current_t*)p)->~current_t();
2162 }
2163} // end of namespace ROOT for class ::BesCircle2D
2164
2165//______________________________________________________________________________
2166void BesCursor::Streamer(TBuffer &R__b)
2167{
2168 // Stream an object of class BesCursor.
2169
2170 if (R__b.IsReading()) {
2171 R__b.ReadClassBuffer(BesCursor::Class(),this);
2172 } else {
2173 R__b.WriteClassBuffer(BesCursor::Class(),this);
2174 }
2175}
2176
2177//______________________________________________________________________________
2178void BesCursor::ShowMembers(TMemberInspector &R__insp)
2179{
2180 // Inspect the data members of an object of class BesCursor.
2181 TClass *R__cl = ::BesCursor::IsA();
2182 if (R__cl || R__insp.IsA()) { }
2183 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorType", &fCursorType);
2184 R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowInfo", &fShowInfo);
2185 TObject::ShowMembers(R__insp);
2186}
2187
2188namespace ROOT {
2189 // Wrappers around operator new
2190 static void *new_BesCursor(void *p) {
2191 return p ? new(p) ::BesCursor : new ::BesCursor;
2192 }
2193 static void *newArray_BesCursor(Long_t nElements, void *p) {
2194 return p ? new(p) ::BesCursor[nElements] : new ::BesCursor[nElements];
2195 }
2196 // Wrapper around operator delete
2197 static void delete_BesCursor(void *p) {
2198 delete ((::BesCursor*)p);
2199 }
2200 static void deleteArray_BesCursor(void *p) {
2201 delete [] ((::BesCursor*)p);
2202 }
2203 static void destruct_BesCursor(void *p) {
2204 typedef ::BesCursor current_t;
2205 ((current_t*)p)->~current_t();
2206 }
2207} // end of namespace ROOT for class ::BesCursor
2208
2209//______________________________________________________________________________
2210void BesEvent::Streamer(TBuffer &R__b)
2211{
2212 // Stream an object of class BesEvent.
2213
2214 if (R__b.IsReading()) {
2215 R__b.ReadClassBuffer(BesEvent::Class(),this);
2216 } else {
2217 R__b.WriteClassBuffer(BesEvent::Class(),this);
2218 }
2219}
2220
2221//______________________________________________________________________________
2222void BesEvent::ShowMembers(TMemberInspector &R__insp)
2223{
2224 // Inspect the data members of an object of class BesEvent.
2225 TClass *R__cl = ::BesEvent::IsA();
2226 if (R__cl || R__insp.IsA()) { }
2227 R__insp.Inspect(R__cl, R__insp.GetParent(), "f_Magnetic", &f_Magnetic);
2228 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventHeader", &fEventHeader);
2229 R__insp.InspectMember(fEventHeader, "fEventHeader.");
2230 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDigiEvent", &fDigiEvent);
2231 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvtHeader", &fEvtHeader);
2232 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrigEvent", &fTrigEvent);
2233 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRecEvTime", &fRecEvTime);
2234 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdcTrackCol", &fMdcTrackCol);
2235 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTofTrackCol", &fTofTrackCol);
2236 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmcTrackCol", &fEmcTrackCol);
2237 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMucTrackCol", &fMucTrackCol);
2238 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtTrackCol", &fExtTrackCol);
2239 TObject::ShowMembers(R__insp);
2240}
2241
2242namespace ROOT {
2243 // Wrappers around operator new
2244 static void *new_BesEvent(void *p) {
2245 return p ? new(p) ::BesEvent : new ::BesEvent;
2246 }
2247 static void *newArray_BesEvent(Long_t nElements, void *p) {
2248 return p ? new(p) ::BesEvent[nElements] : new ::BesEvent[nElements];
2249 }
2250 // Wrapper around operator delete
2251 static void delete_BesEvent(void *p) {
2252 delete ((::BesEvent*)p);
2253 }
2254 static void deleteArray_BesEvent(void *p) {
2255 delete [] ((::BesEvent*)p);
2256 }
2257 static void destruct_BesEvent(void *p) {
2258 typedef ::BesEvent current_t;
2259 ((current_t*)p)->~current_t();
2260 }
2261} // end of namespace ROOT for class ::BesEvent
2262
2263//______________________________________________________________________________
2264void BesEventHeader::Streamer(TBuffer &R__b)
2265{
2266 // Stream an object of class BesEventHeader.
2267
2268 if (R__b.IsReading()) {
2269 R__b.ReadClassBuffer(BesEventHeader::Class(),this);
2270 } else {
2271 R__b.WriteClassBuffer(BesEventHeader::Class(),this);
2272 }
2273}
2274
2275//______________________________________________________________________________
2276void BesEventHeader::ShowMembers(TMemberInspector &R__insp)
2277{
2278 // Inspect the data members of an object of class BesEventHeader.
2279 TClass *R__cl = ::BesEventHeader::IsA();
2280 if (R__cl || R__insp.IsA()) { }
2281 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRun", &fRun);
2282 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvent", &fEvent);
2283 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMC", &fMC);
2284 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDay", &fDay);
2285 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonth", &fMonth);
2286 R__insp.Inspect(R__cl, R__insp.GetParent(), "fYear", &fYear);
2287 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHour", &fHour);
2288 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
2289 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSec", &fSec);
2290 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRec", &fRec);
2291 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTime", &fEvTime);
2292 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTimeStatus", &fEvTimeStatus);
2293 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTimeQuality", &fEvTimeQuality);
2294 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", &fP);
2295 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPt", &fPt);
2296 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx", &fPx);
2297 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy", &fPy);
2298 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPz", &fPz);
2299 R__insp.Inspect(R__cl, R__insp.GetParent(), "fT", &fT);
2300 R__insp.Inspect(R__cl, R__insp.GetParent(), "fE", &fE);
2301 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeType", &fTimeType);
2302 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrigChannelVector", (void*)&fTrigChannelVector);
2303 R__insp.InspectMember("vector<Int_t>", (void*)&fTrigChannelVector, "fTrigChannelVector.", false);
2304 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrigConditionVector", (void*)&fTrigConditionVector);
2305 R__insp.InspectMember("vector<Int_t>", (void*)&fTrigConditionVector, "fTrigConditionVector.", false);
2306 TObject::ShowMembers(R__insp);
2307}
2308
2309namespace ROOT {
2310 // Wrappers around operator new
2311 static void *new_BesEventHeader(void *p) {
2312 return p ? new(p) ::BesEventHeader : new ::BesEventHeader;
2313 }
2314 static void *newArray_BesEventHeader(Long_t nElements, void *p) {
2315 return p ? new(p) ::BesEventHeader[nElements] : new ::BesEventHeader[nElements];
2316 }
2317 // Wrapper around operator delete
2318 static void delete_BesEventHeader(void *p) {
2319 delete ((::BesEventHeader*)p);
2320 }
2321 static void deleteArray_BesEventHeader(void *p) {
2322 delete [] ((::BesEventHeader*)p);
2323 }
2324 static void destruct_BesEventHeader(void *p) {
2325 typedef ::BesEventHeader current_t;
2326 ((current_t*)p)->~current_t();
2327 }
2328} // end of namespace ROOT for class ::BesEventHeader
2329
2330//______________________________________________________________________________
2331void BesGeometry::Streamer(TBuffer &R__b)
2332{
2333 // Stream an object of class BesGeometry.
2334
2335 if (R__b.IsReading()) {
2336 R__b.ReadClassBuffer(BesGeometry::Class(),this);
2337 } else {
2338 R__b.WriteClassBuffer(BesGeometry::Class(),this);
2339 }
2340}
2341
2342//______________________________________________________________________________
2343void BesGeometry::ShowMembers(TMemberInspector &R__insp)
2344{
2345 // Inspect the data members of an object of class BesGeometry.
2346 TClass *R__cl = ::BesGeometry::IsA();
2347 if (R__cl || R__insp.IsA()) { }
2348 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesR", &m_BesR);
2349 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesZ", &m_BesZ);
2350 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeRMin", &m_BeamPipeRMin);
2351 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeRMax", &m_BeamPipeRMax);
2352 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeZ", &m_BeamPipeZ);
2353 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Bes", &m_Bes);
2354 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipe", &m_BeamPipe);
2355 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc", &m_Mdc);
2356 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof", &m_Tof);
2357 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc", &m_Emc);
2358 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc", &m_Muc);
2359 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_phyBeamPipe", &m_phyBeamPipe);
2360 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcROOTGeo", &m_MdcROOTGeo);
2361 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TofROOTGeo", &m_TofROOTGeo);
2362 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EmcROOTGeo", &m_EmcROOTGeo);
2363 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucROOTGeo", &m_MucROOTGeo);
2364 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipeXY", &m_BeamPipeXY);
2365 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipeZR", &m_BeamPipeZR);
2366 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_ZRPlaneOnXY", &m_ZRPlaneOnXY);
2367 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeColor", &m_BeamPipeColor);
2368 TObject::ShowMembers(R__insp);
2369}
2370
2371namespace ROOT {
2372 // Wrappers around operator new
2373 static void *new_BesGeometry(void *p) {
2374 return p ? new(p) ::BesGeometry : new ::BesGeometry;
2375 }
2376 static void *newArray_BesGeometry(Long_t nElements, void *p) {
2377 return p ? new(p) ::BesGeometry[nElements] : new ::BesGeometry[nElements];
2378 }
2379 // Wrapper around operator delete
2380 static void delete_BesGeometry(void *p) {
2381 delete ((::BesGeometry*)p);
2382 }
2383 static void deleteArray_BesGeometry(void *p) {
2384 delete [] ((::BesGeometry*)p);
2385 }
2386 static void destruct_BesGeometry(void *p) {
2387 typedef ::BesGeometry current_t;
2388 ((current_t*)p)->~current_t();
2389 }
2390} // end of namespace ROOT for class ::BesGeometry
2391
2392//______________________________________________________________________________
2393void BesGeoTrack::Streamer(TBuffer &R__b)
2394{
2395 // Stream an object of class BesGeoTrack.
2396
2397 if (R__b.IsReading()) {
2398 R__b.ReadClassBuffer(BesGeoTrack::Class(),this);
2399 } else {
2400 R__b.WriteClassBuffer(BesGeoTrack::Class(),this);
2401 }
2402}
2403
2404//______________________________________________________________________________
2405void BesGeoTrack::ShowMembers(TMemberInspector &R__insp)
2406{
2407 // Inspect the data members of an object of class BesGeoTrack.
2408 TClass *R__cl = ::BesGeoTrack::IsA();
2409 if (R__cl || R__insp.IsA()) { }
2410 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHits", &fHits);
2411 R__insp.InspectMember(fHits, "fHits.");
2412 R__insp.Inspect(R__cl, R__insp.GetParent(), "f3DHits", &f3DHits);
2413 R__insp.InspectMember(f3DHits, "f3DHits.");
2414 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
2415 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
2416 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
2417 R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
2418 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
2419 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPolyLine3D", &fPolyLine3D);
2420 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarker", &fMarker);
2421 TGeoTrack::ShowMembers(R__insp);
2422}
2423
2424namespace ROOT {
2425 // Wrappers around operator new
2426 static void *new_BesGeoTrack(void *p) {
2427 return p ? new(p) ::BesGeoTrack : new ::BesGeoTrack;
2428 }
2429 static void *newArray_BesGeoTrack(Long_t nElements, void *p) {
2430 return p ? new(p) ::BesGeoTrack[nElements] : new ::BesGeoTrack[nElements];
2431 }
2432 // Wrapper around operator delete
2433 static void delete_BesGeoTrack(void *p) {
2434 delete ((::BesGeoTrack*)p);
2435 }
2436 static void deleteArray_BesGeoTrack(void *p) {
2437 delete [] ((::BesGeoTrack*)p);
2438 }
2439 static void destruct_BesGeoTrack(void *p) {
2440 typedef ::BesGeoTrack current_t;
2441 ((current_t*)p)->~current_t();
2442 }
2443} // end of namespace ROOT for class ::BesGeoTrack
2444
2445//______________________________________________________________________________
2446void BesGMenuBar::Streamer(TBuffer &R__b)
2447{
2448 // Stream an object of class BesGMenuBar.
2449
2450 if (R__b.IsReading()) {
2451 R__b.ReadClassBuffer(BesGMenuBar::Class(),this);
2452 } else {
2453 R__b.WriteClassBuffer(BesGMenuBar::Class(),this);
2454 }
2455}
2456
2457//______________________________________________________________________________
2458void BesGMenuBar::ShowMembers(TMemberInspector &R__insp)
2459{
2460 // Inspect the data members of an object of class BesGMenuBar.
2461 TClass *R__cl = ::BesGMenuBar::IsA();
2462 if (R__cl || R__insp.IsA()) { }
2463 TGMenuBar::ShowMembers(R__insp);
2464}
2465
2466namespace ROOT {
2467 // Wrappers around operator new
2468 static void *new_BesGMenuBar(void *p) {
2469 return p ? new(p) ::BesGMenuBar : new ::BesGMenuBar;
2470 }
2471 static void *newArray_BesGMenuBar(Long_t nElements, void *p) {
2472 return p ? new(p) ::BesGMenuBar[nElements] : new ::BesGMenuBar[nElements];
2473 }
2474 // Wrapper around operator delete
2475 static void delete_BesGMenuBar(void *p) {
2476 delete ((::BesGMenuBar*)p);
2477 }
2478 static void deleteArray_BesGMenuBar(void *p) {
2479 delete [] ((::BesGMenuBar*)p);
2480 }
2481 static void destruct_BesGMenuBar(void *p) {
2482 typedef ::BesGMenuBar current_t;
2483 ((current_t*)p)->~current_t();
2484 }
2485} // end of namespace ROOT for class ::BesGMenuBar
2486
2487//______________________________________________________________________________
2488void BesGMenuTitle::Streamer(TBuffer &R__b)
2489{
2490 // Stream an object of class BesGMenuTitle.
2491
2492 if (R__b.IsReading()) {
2493 R__b.ReadClassBuffer(BesGMenuTitle::Class(),this);
2494 } else {
2495 R__b.WriteClassBuffer(BesGMenuTitle::Class(),this);
2496 }
2497}
2498
2499//______________________________________________________________________________
2500void BesGMenuTitle::ShowMembers(TMemberInspector &R__insp)
2501{
2502 // Inspect the data members of an object of class BesGMenuTitle.
2503 TClass *R__cl = ::BesGMenuTitle::IsA();
2504 if (R__cl || R__insp.IsA()) { }
2505 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPic", &fPic);
2506 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPicHL", &fPicHL);
2507 TGMenuTitle::ShowMembers(R__insp);
2508}
2509
2510namespace ROOT {
2511 // Wrappers around operator new
2512 static void *new_BesGMenuTitle(void *p) {
2513 return p ? new(p) ::BesGMenuTitle : new ::BesGMenuTitle;
2514 }
2515 static void *newArray_BesGMenuTitle(Long_t nElements, void *p) {
2516 return p ? new(p) ::BesGMenuTitle[nElements] : new ::BesGMenuTitle[nElements];
2517 }
2518 // Wrapper around operator delete
2519 static void delete_BesGMenuTitle(void *p) {
2520 delete ((::BesGMenuTitle*)p);
2521 }
2522 static void deleteArray_BesGMenuTitle(void *p) {
2523 delete [] ((::BesGMenuTitle*)p);
2524 }
2525 static void destruct_BesGMenuTitle(void *p) {
2526 typedef ::BesGMenuTitle current_t;
2527 ((current_t*)p)->~current_t();
2528 }
2529} // end of namespace ROOT for class ::BesGMenuTitle
2530
2531//______________________________________________________________________________
2532void BesGPictureButton::Streamer(TBuffer &R__b)
2533{
2534 // Stream an object of class BesGPictureButton.
2535
2536 if (R__b.IsReading()) {
2537 R__b.ReadClassBuffer(BesGPictureButton::Class(),this);
2538 } else {
2539 R__b.WriteClassBuffer(BesGPictureButton::Class(),this);
2540 }
2541}
2542
2543//______________________________________________________________________________
2544void BesGPictureButton::ShowMembers(TMemberInspector &R__insp)
2545{
2546 // Inspect the data members of an object of class BesGPictureButton.
2547 TClass *R__cl = ::BesGPictureButton::IsA();
2548 if (R__cl || R__insp.IsA()) { }
2549 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicHL", &fPicHL);
2550 R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
2551 TGPictureButton::ShowMembers(R__insp);
2552}
2553
2554namespace ROOT {
2555 // Wrappers around operator new
2556 static void *new_BesGPictureButton(void *p) {
2557 return p ? new(p) ::BesGPictureButton : new ::BesGPictureButton;
2558 }
2559 static void *newArray_BesGPictureButton(Long_t nElements, void *p) {
2560 return p ? new(p) ::BesGPictureButton[nElements] : new ::BesGPictureButton[nElements];
2561 }
2562 // Wrapper around operator delete
2563 static void delete_BesGPictureButton(void *p) {
2564 delete ((::BesGPictureButton*)p);
2565 }
2566 static void deleteArray_BesGPictureButton(void *p) {
2567 delete [] ((::BesGPictureButton*)p);
2568 }
2569 static void destruct_BesGPictureButton(void *p) {
2570 typedef ::BesGPictureButton current_t;
2571 ((current_t*)p)->~current_t();
2572 }
2573} // end of namespace ROOT for class ::BesGPictureButton
2574
2575//______________________________________________________________________________
2576void BesHeader::Streamer(TBuffer &R__b)
2577{
2578 // Stream an object of class BesHeader.
2579
2580 if (R__b.IsReading()) {
2581 R__b.ReadClassBuffer(BesHeader::Class(),this);
2582 } else {
2583 R__b.WriteClassBuffer(BesHeader::Class(),this);
2584 }
2585}
2586
2587//______________________________________________________________________________
2588void BesHeader::ShowMembers(TMemberInspector &R__insp)
2589{
2590 // Inspect the data members of an object of class BesHeader.
2591 TClass *R__cl = ::BesHeader::IsA();
2592 if (R__cl || R__insp.IsA()) { }
2593 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcOn", &fMdcOn);
2594 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofOn", &fTofOn);
2595 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcOn", &fEmcOn);
2596 TPaveText::ShowMembers(R__insp);
2597 TQObject::ShowMembers(R__insp);
2598}
2599
2600namespace ROOT {
2601 // Wrappers around operator new
2602 static void *new_BesHeader(void *p) {
2603 return p ? new(p) ::BesHeader : new ::BesHeader;
2604 }
2605 static void *newArray_BesHeader(Long_t nElements, void *p) {
2606 return p ? new(p) ::BesHeader[nElements] : new ::BesHeader[nElements];
2607 }
2608 // Wrapper around operator delete
2609 static void delete_BesHeader(void *p) {
2610 delete ((::BesHeader*)p);
2611 }
2612 static void deleteArray_BesHeader(void *p) {
2613 delete [] ((::BesHeader*)p);
2614 }
2615 static void destruct_BesHeader(void *p) {
2616 typedef ::BesHeader current_t;
2617 ((current_t*)p)->~current_t();
2618 }
2619} // end of namespace ROOT for class ::BesHeader
2620
2621//______________________________________________________________________________
2622void BesMarker2D::Streamer(TBuffer &R__b)
2623{
2624 // Stream an object of class BesMarker2D.
2625
2626 if (R__b.IsReading()) {
2627 R__b.ReadClassBuffer(BesMarker2D::Class(),this);
2628 } else {
2629 R__b.WriteClassBuffer(BesMarker2D::Class(),this);
2630 }
2631}
2632
2633//______________________________________________________________________________
2634void BesMarker2D::ShowMembers(TMemberInspector &R__insp)
2635{
2636 // Inspect the data members of an object of class BesMarker2D.
2637 TClass *R__cl = ::BesMarker2D::IsA();
2638 if (R__cl || R__insp.IsA()) { }
2639 R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
2640 R__insp.InspectMember(fName, "fName.");
2641 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
2642 R__insp.InspectMember(fTitle, "fTitle.");
2643 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCX", &fWCX);
2644 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCY", &fWCY);
2645 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCZ", &fWCZ);
2646 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizeMultiple", &fSizeMultiple);
2647 TMarker::ShowMembers(R__insp);
2648}
2649
2650namespace ROOT {
2651 // Wrappers around operator new
2652 static void *new_BesMarker2D(void *p) {
2653 return p ? new(p) ::BesMarker2D : new ::BesMarker2D;
2654 }
2655 static void *newArray_BesMarker2D(Long_t nElements, void *p) {
2656 return p ? new(p) ::BesMarker2D[nElements] : new ::BesMarker2D[nElements];
2657 }
2658 // Wrapper around operator delete
2659 static void delete_BesMarker2D(void *p) {
2660 delete ((::BesMarker2D*)p);
2661 }
2662 static void deleteArray_BesMarker2D(void *p) {
2663 delete [] ((::BesMarker2D*)p);
2664 }
2665 static void destruct_BesMarker2D(void *p) {
2666 typedef ::BesMarker2D current_t;
2667 ((current_t*)p)->~current_t();
2668 }
2669} // end of namespace ROOT for class ::BesMarker2D
2670
2671//______________________________________________________________________________
2672void BesPaveText::Streamer(TBuffer &R__b)
2673{
2674 // Stream an object of class BesPaveText.
2675
2676 if (R__b.IsReading()) {
2677 R__b.ReadClassBuffer(BesPaveText::Class(),this);
2678 } else {
2679 R__b.WriteClassBuffer(BesPaveText::Class(),this);
2680 }
2681}
2682
2683//______________________________________________________________________________
2684void BesPaveText::ShowMembers(TMemberInspector &R__insp)
2685{
2686 // Inspect the data members of an object of class BesPaveText.
2687 TClass *R__cl = ::BesPaveText::IsA();
2688 if (R__cl || R__insp.IsA()) { }
2689 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSize", &fTextSize);
2690 R__insp.Inspect(R__cl, R__insp.GetParent(), "fdxNDC", &fdxNDC);
2691 R__insp.Inspect(R__cl, R__insp.GetParent(), "fdyNDC", &fdyNDC);
2692 TPaveText::ShowMembers(R__insp);
2693}
2694
2695namespace ROOT {
2696 // Wrappers around operator new
2697 static void *new_BesPaveText(void *p) {
2698 return p ? new(p) ::BesPaveText : new ::BesPaveText;
2699 }
2700 static void *newArray_BesPaveText(Long_t nElements, void *p) {
2701 return p ? new(p) ::BesPaveText[nElements] : new ::BesPaveText[nElements];
2702 }
2703 // Wrapper around operator delete
2704 static void delete_BesPaveText(void *p) {
2705 delete ((::BesPaveText*)p);
2706 }
2707 static void deleteArray_BesPaveText(void *p) {
2708 delete [] ((::BesPaveText*)p);
2709 }
2710 static void destruct_BesPaveText(void *p) {
2711 typedef ::BesPaveText current_t;
2712 ((current_t*)p)->~current_t();
2713 }
2714} // end of namespace ROOT for class ::BesPaveText
2715
2716//______________________________________________________________________________
2717void BesPolygon2D::Streamer(TBuffer &R__b)
2718{
2719 // Stream an object of class BesPolygon2D.
2720
2721 if (R__b.IsReading()) {
2722 R__b.ReadClassBuffer(BesPolygon2D::Class(),this);
2723 } else {
2724 R__b.WriteClassBuffer(BesPolygon2D::Class(),this);
2725 }
2726}
2727
2728//______________________________________________________________________________
2729void BesPolygon2D::ShowMembers(TMemberInspector &R__insp)
2730{
2731 // Inspect the data members of an object of class BesPolygon2D.
2732 TClass *R__cl = ::BesPolygon2D::IsA();
2733 if (R__cl || R__insp.IsA()) { }
2734 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_xx", &f_xx);
2735 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_yy", &f_yy);
2736 R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
2737 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fP", &fP);
2738 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPBackUp", &fPBackUp);
2739 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter[3]", fCenter);
2740 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRotatable", &fRotatable);
2741 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfoBox", &fInfoBox);
2742 TNamed::ShowMembers(R__insp);
2743 TAttLine::ShowMembers(R__insp);
2744 TAttFill::ShowMembers(R__insp);
2745}
2746
2747namespace ROOT {
2748 // Wrappers around operator new
2749 static void *new_BesPolygon2D(void *p) {
2750 return p ? new(p) ::BesPolygon2D : new ::BesPolygon2D;
2751 }
2752 static void *newArray_BesPolygon2D(Long_t nElements, void *p) {
2753 return p ? new(p) ::BesPolygon2D[nElements] : new ::BesPolygon2D[nElements];
2754 }
2755 // Wrapper around operator delete
2756 static void delete_BesPolygon2D(void *p) {
2757 delete ((::BesPolygon2D*)p);
2758 }
2759 static void deleteArray_BesPolygon2D(void *p) {
2760 delete [] ((::BesPolygon2D*)p);
2761 }
2762 static void destruct_BesPolygon2D(void *p) {
2763 typedef ::BesPolygon2D current_t;
2764 ((current_t*)p)->~current_t();
2765 }
2766} // end of namespace ROOT for class ::BesPolygon2D
2767
2768//______________________________________________________________________________
2769void BesStatus::Streamer(TBuffer &R__b)
2770{
2771 // Stream an object of class BesStatus.
2772
2773 if (R__b.IsReading()) {
2774 R__b.ReadClassBuffer(BesStatus::Class(),this);
2775 } else {
2776 R__b.WriteClassBuffer(BesStatus::Class(),this);
2777 }
2778}
2779
2780//______________________________________________________________________________
2781void BesStatus::ShowMembers(TMemberInspector &R__insp)
2782{
2783 // Inspect the data members of an object of class BesStatus.
2784 TClass *R__cl = ::BesStatus::IsA();
2785 if (R__cl || R__insp.IsA()) { }
2786 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemGlobal", &fCgemGlobal);
2787 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemLayers", &fCgemLayers);
2788 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemXStrips", &fCgemXStrips);
2789 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemVStrips", &fCgemVStrips);
2790 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcGlobal", &fMdcGlobal);
2791 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcTubes", &fMdcTubes);
2792 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcWires", &fMdcWires);
2793 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofGlobal", &fTofGlobal);
2794 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofEast", &fTofEast);
2795 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofBarrel", &fTofBarrel);
2796 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofWest", &fTofWest);
2797 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcGlobal", &fEmcGlobal);
2798 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcEast", &fEmcEast);
2799 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcBarrel", &fEmcBarrel);
2800 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcWest", &fEmcWest);
2801 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcSide", &fEmcSide);
2802 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucGlobal", &fMucGlobal);
2803 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucEast", &fMucEast);
2804 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucBarrel", &fMucBarrel);
2805 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucWest", &fMucWest);
2806 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucStrips", &fMucStrips);
2807 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DCgem", &fFull3DCgem);
2808 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DMdc", &fFull3DMdc);
2809 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DTof", &fFull3DTof);
2810 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DEmc", &fFull3DEmc);
2811 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DMuc", &fFull3DMuc);
2812 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeamPipe", &fBeamPipe);
2813 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRPlaneOnXY", &fZRPlaneOnXY);
2814 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis", &fAxis);
2815 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemHitsGlobal", &fCgemHitsGlobal);
2816 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemHitsXStrip", &fCgemHitsXStrip);
2817 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemHitsVStrip", &fCgemHitsVStrip);
2818 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemHitsClusters", &fCgemHitsClusters);
2819 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCgemHitsFiredHL", &fCgemHitsFiredHL);
2820 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcHitsGlobal", &fMdcHitsGlobal);
2821 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcHits", &fMdcHits);
2822 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsGlobal", &fTofHitsGlobal);
2823 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsEast", &fTofHitsEast);
2824 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsBarrel", &fTofHitsBarrel);
2825 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsWest", &fTofHitsWest);
2826 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsGlobal", &fEmcHitsGlobal);
2827 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsEast", &fEmcHitsEast);
2828 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsBarrel", &fEmcHitsBarrel);
2829 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsWest", &fEmcHitsWest);
2830 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsSide", &fEmcHitsSide);
2831 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsGlobal", &fMucHitsGlobal);
2832 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsEast", &fMucHitsEast);
2833 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsBarrel", &fMucHitsBarrel);
2834 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsWest", &fMucHitsWest);
2835 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksGlobal", &fTracksGlobal);
2836 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksMdc", &fTracksMdc);
2837 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksTof", &fTracksTof);
2838 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksEmc", &fTracksEmc);
2839 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksMuc", &fTracksMuc);
2840 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksExt", &fTracksExt);
2841 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
2842 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
2843 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
2844 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoom", &fZoom);
2845 TObject::ShowMembers(R__insp);
2846}
2847
2848namespace ROOT {
2849 // Wrappers around operator new
2850 static void *new_BesStatus(void *p) {
2851 return p ? new(p) ::BesStatus : new ::BesStatus;
2852 }
2853 static void *newArray_BesStatus(Long_t nElements, void *p) {
2854 return p ? new(p) ::BesStatus[nElements] : new ::BesStatus[nElements];
2855 }
2856 // Wrapper around operator delete
2857 static void delete_BesStatus(void *p) {
2858 delete ((::BesStatus*)p);
2859 }
2860 static void deleteArray_BesStatus(void *p) {
2861 delete [] ((::BesStatus*)p);
2862 }
2863 static void destruct_BesStatus(void *p) {
2864 typedef ::BesStatus current_t;
2865 ((current_t*)p)->~current_t();
2866 }
2867} // end of namespace ROOT for class ::BesStatus
2868
2869//______________________________________________________________________________
2870void BesView::Streamer(TBuffer &R__b)
2871{
2872 // Stream an object of class BesView.
2873
2874 if (R__b.IsReading()) {
2875 R__b.ReadClassBuffer(BesView::Class(),this);
2876 } else {
2877 R__b.WriteClassBuffer(BesView::Class(),this);
2878 }
2879}
2880
2881//______________________________________________________________________________
2882void BesView::ShowMembers(TMemberInspector &R__insp)
2883{
2884 // Inspect the data members of an object of class BesView.
2885 TClass *R__cl = ::BesView::IsA();
2886 if (R__cl || R__insp.IsA()) { }
2887 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
2888 R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewType", &fViewType);
2889 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
2890 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
2891 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
2892 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerSize", &fMarkerSize);
2893 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus3D", &fStatus3D);
2894 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusXY", &fStatusXY);
2895 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusZR", &fStatusZR);
2896 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusCurrent", &fStatusCurrent);
2897 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomFactor", &fZoomFactor);
2898 R__insp.Inspect(R__cl, R__insp.GetParent(), "fExtentDefault", &fExtentDefault);
2899 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesR", &m_BesR);
2900 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesZ", &m_BesZ);
2901 R__insp.Inspect(R__cl, R__insp.GetParent(), "ViewCenter[2]", ViewCenter);
2902 BesTView::ShowMembers(R__insp);
2903}
2904
2905namespace ROOT {
2906 // Wrappers around operator new
2907 static void *new_BesView(void *p) {
2908 return p ? new(p) ::BesView : new ::BesView;
2909 }
2910 static void *newArray_BesView(Long_t nElements, void *p) {
2911 return p ? new(p) ::BesView[nElements] : new ::BesView[nElements];
2912 }
2913 // Wrapper around operator delete
2914 static void delete_BesView(void *p) {
2915 delete ((::BesView*)p);
2916 }
2917 static void deleteArray_BesView(void *p) {
2918 delete [] ((::BesView*)p);
2919 }
2920 static void destruct_BesView(void *p) {
2921 typedef ::BesView current_t;
2922 ((current_t*)p)->~current_t();
2923 }
2924} // end of namespace ROOT for class ::BesView
2925
2926//______________________________________________________________________________
2927void BesVisDisplay::Streamer(TBuffer &R__b)
2928{
2929 // Stream an object of class BesVisDisplay.
2930
2931 if (R__b.IsReading()) {
2932 R__b.ReadClassBuffer(BesVisDisplay::Class(),this);
2933 } else {
2934 R__b.WriteClassBuffer(BesVisDisplay::Class(),this);
2935 }
2936}
2937
2938//______________________________________________________________________________
2939void BesVisDisplay::ShowMembers(TMemberInspector &R__insp)
2940{
2941 // Inspect the data members of an object of class BesVisDisplay.
2942 TClass *R__cl = ::BesVisDisplay::IsA();
2943 if (R__cl || R__insp.IsA()) { }
2944 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplayMode", &fDisplayMode);
2945 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadHeader", &fPadHeader);
2946 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadXY", &fPadXY);
2947 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadZR", &fPadZR);
2948 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad3D", &fPad3D);
2949 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBesHeader", &fBesHeader);
2950 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderImage", &fHeaderImage);
2951 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderHImage", &fHeaderHImage);
2952 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderVImage", &fHeaderVImage);
2953 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatticeWidth", &fLatticeWidth);
2954 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeTitle", &fTextSizeTitle);
2955 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeTime", &fTextSizeTime);
2956 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeData", &fTextSizeData);
2957 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeFlt", &fTextSizeFlt);
2958 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordx", &fCoordx);
2959 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordy", &fCoordy);
2960 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistanceOfRows", &fDistanceOfRows);
2961 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcOn", &fMdcOn);
2962 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofOn", &fTofOn);
2963 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcOn", &fEmcOn);
2964 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBesGeometry", &fBesGeometry);
2965 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawAllViews", &fDrawAllViews);
2966 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawParticles", &fDrawParticles);
2967 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawParticles2", &fDrawParticles2);
2968 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisHeader", &fVisHeader);
2969 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawClusters", &fDrawClusters);
2970 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPTcut", &fPTcut);
2971 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPTcutEGMUNU", &fPTcutEGMUNU);
2972 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRin", &fRin);
2973 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRout", &fRout);
2974 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZin", &fZin);
2975 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZout", &fZout);
2976 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
2977 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
2978 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBesR", &fBesR);
2979 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBesZ", &fBesZ);
2980 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
2981 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrigPad", &fTrigPad);
2982 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtons", &fButtons);
2983 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
2984 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEM1", &fEM1);
2985 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPH1", &fPH1);
2986 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEM2", &fEM2);
2987 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMU1", &fMU1);
2988 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMU2", &fMU2);
2989 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEMU", &fEMU);
2990 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT1", &fJT1);
2991 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT3", &fJT3);
2992 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT4", &fJT4);
2993 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fALL", &fALL);
2994 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBes", &fBes);
2995 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRayPicCount", &fRayPicCount);
2996 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdcROOTGeo", &fMdcROOTGeo);
2997 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTofROOTGeo", &fTofROOTGeo);
2998 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmcROOTGeo", &fEmcROOTGeo);
2999 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMucROOTGeo", &fMucROOTGeo);
3000 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcCon", &fMdcCon);
3001 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofCon", &fTofCon);
3002 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcCon", &fEmcCon);
3003 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucCon", &fMucCon);
3004 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllVis", &fAllVis);
3005 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuarterVis", &fQuarterVis);
3006 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHalfVis", &fHalfVis);
3007 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoEndVis", &fNoEndVis);
3008 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fxyView", &fxyView);
3009 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fzrView", &fzrView);
3010 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DView", &f3DView);
3011 TQObject::ShowMembers(R__insp);
3012}
3013
3014namespace ROOT {
3015 // Wrappers around operator new
3016 static void *new_BesVisDisplay(void *p) {
3017 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BesVisDisplay : new ::BesVisDisplay;
3018 }
3019 static void *newArray_BesVisDisplay(Long_t nElements, void *p) {
3020 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BesVisDisplay[nElements] : new ::BesVisDisplay[nElements];
3021 }
3022 // Wrapper around operator delete
3023 static void delete_BesVisDisplay(void *p) {
3024 delete ((::BesVisDisplay*)p);
3025 }
3026 static void deleteArray_BesVisDisplay(void *p) {
3027 delete [] ((::BesVisDisplay*)p);
3028 }
3029 static void destruct_BesVisDisplay(void *p) {
3030 typedef ::BesVisDisplay current_t;
3031 ((current_t*)p)->~current_t();
3032 }
3033} // end of namespace ROOT for class ::BesVisDisplay
3034
3035//______________________________________________________________________________
3036void Emc2DCrystal::Streamer(TBuffer &R__b)
3037{
3038 // Stream an object of class Emc2DCrystal.
3039
3040 if (R__b.IsReading()) {
3041 R__b.ReadClassBuffer(Emc2DCrystal::Class(),this);
3042 } else {
3043 R__b.WriteClassBuffer(Emc2DCrystal::Class(),this);
3044 }
3045}
3046
3047//______________________________________________________________________________
3048void Emc2DCrystal::ShowMembers(TMemberInspector &R__insp)
3049{
3050 // Inspect the data members of an object of class Emc2DCrystal.
3051 TClass *R__cl = ::Emc2DCrystal::IsA();
3052 if (R__cl || R__insp.IsA()) { }
3053 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
3054 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
3055 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalXY", &fCrystalXY);
3056 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalZR", &fCrystalZR);
3057 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalSide", &fCrystalSide);
3058 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalXYFired", &fCrystalXYFired);
3059 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalZRFired", &fCrystalZRFired);
3060 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalSideFired", &fCrystalSideFired);
3061 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
3062 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
3063 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionTolerance[3]", fZRSectionTolerance);
3064 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMin", &fPhiMin);
3065 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMax", &fPhiMax);
3066 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
3067 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
3068 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
3069 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
3070 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
3071 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystal", &lcCrystal);
3072 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystal", &lwCrystal);
3073 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystal", &fcCrystal);
3074 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystal", &fsCrystal);
3075 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalTrans", &fsCrystalTrans);
3076 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalFired", &lcCrystalFired);
3077 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalFired", &lwCrystalFired);
3078 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalFired", &fcCrystalFired);
3079 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalFired", &fsCrystalFired);
3080 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalHL", &lcCrystalHL);
3081 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalHL", &lwCrystalHL);
3082 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalHL", &fcCrystalHL);
3083 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalHL", &fsCrystalHL);
3084 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalFiredHL", &lcCrystalFiredHL);
3085 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalFiredHL", &lwCrystalFiredHL);
3086 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalFiredHL", &fcCrystalFiredHL);
3087 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalFiredHL", &fsCrystalFiredHL);
3088 TNamed::ShowMembers(R__insp);
3089 TAttLine::ShowMembers(R__insp);
3090 TAttFill::ShowMembers(R__insp);
3091}
3092
3093namespace ROOT {
3094 // Wrappers around operator new
3095 static void *new_Emc2DCrystal(void *p) {
3096 return p ? new(p) ::Emc2DCrystal : new ::Emc2DCrystal;
3097 }
3098 static void *newArray_Emc2DCrystal(Long_t nElements, void *p) {
3099 return p ? new(p) ::Emc2DCrystal[nElements] : new ::Emc2DCrystal[nElements];
3100 }
3101 // Wrapper around operator delete
3102 static void delete_Emc2DCrystal(void *p) {
3103 delete ((::Emc2DCrystal*)p);
3104 }
3105 static void deleteArray_Emc2DCrystal(void *p) {
3106 delete [] ((::Emc2DCrystal*)p);
3107 }
3108 static void destruct_Emc2DCrystal(void *p) {
3109 typedef ::Emc2DCrystal current_t;
3110 ((current_t*)p)->~current_t();
3111 }
3112} // end of namespace ROOT for class ::Emc2DCrystal
3113
3114//______________________________________________________________________________
3115namespace ROOT {
3116 void EmcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
3117 {
3118 // Inspect the data members of an object of class EmcROOTGeo.
3119 typedef ::ROOT::Shadow::EmcROOTGeo ShadowClass;
3120 ShadowClass *sobj = (ShadowClass*)obj;
3121 if (sobj) { } // Dummy usage just in case there is no datamember.
3122
3123 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0)->GetClass();
3124 if (R__cl || R__insp.IsA()) { }
3125 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kPhiEc", &sobj->m_kPhiEc);
3126 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kThetaEc", &sobj->m_kThetaEc);
3127 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kSectorEc", &sobj->m_kSectorEc);
3128 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kNbEc", &sobj->m_kNbEc);
3129 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kRealNbEc", &sobj->m_kRealNbEc);
3130 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_EmcColor", &sobj->m_EmcColor);
3131 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partColor", &sobj->m_partColor);
3132 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phiColor", &sobj->m_phiColor);
3133 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_thetaColor", &sobj->m_thetaColor);
3134 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brCrystalColor", &sobj->m_brCrystalColor);
3135 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecCrystalColor", &sobj->m_ecCrystalColor);
3136 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc", &sobj->m_Emc);
3137 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePart[3]", &sobj->m_NodePart);
3138 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePhi[3][120]", &sobj->m_NodePhi);
3139 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeTheta[3][120][44]", &sobj->m_NodeTheta);
3140 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeTheta2[3][120][44]", &sobj->m_NodeTheta2);
3141 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalCrystal[3][120][44]", &sobj->m_PhysicalCrystal);
3142 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalCrystal2[3][120][44]", &sobj->m_PhysicalCrystal2);
3143 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhyNodeOrgArray", &sobj->m_PhyNodeOrgArray);
3144 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EmcDigiCol", &sobj->m_EmcDigiCol);
3145 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc2DCrystal[3][120][44]", &sobj->m_Emc2DCrystal);
3146 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::EmcROOTGeo*) obj ), false);
3147 }
3148
3149}
3150
3151namespace ROOT {
3152 // Wrappers around operator new
3153 static void *new_EmcROOTGeo(void *p) {
3154 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EmcROOTGeo : new ::EmcROOTGeo;
3155 }
3156 static void *newArray_EmcROOTGeo(Long_t nElements, void *p) {
3157 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EmcROOTGeo[nElements] : new ::EmcROOTGeo[nElements];
3158 }
3159 // Wrapper around operator delete
3160 static void delete_EmcROOTGeo(void *p) {
3161 delete ((::EmcROOTGeo*)p);
3162 }
3163 static void deleteArray_EmcROOTGeo(void *p) {
3164 delete [] ((::EmcROOTGeo*)p);
3165 }
3166 static void destruct_EmcROOTGeo(void *p) {
3167 typedef ::EmcROOTGeo current_t;
3168 ((current_t*)p)->~current_t();
3169 }
3170} // end of namespace ROOT for class ::EmcROOTGeo
3171
3172//______________________________________________________________________________
3173void Mdc2DWire::Streamer(TBuffer &R__b)
3174{
3175 // Stream an object of class Mdc2DWire.
3176
3177 if (R__b.IsReading()) {
3178 R__b.ReadClassBuffer(Mdc2DWire::Class(),this);
3179 } else {
3180 R__b.WriteClassBuffer(Mdc2DWire::Class(),this);
3181 }
3182}
3183
3184//______________________________________________________________________________
3185void Mdc2DWire::ShowMembers(TMemberInspector &R__insp)
3186{
3187 // Inspect the data members of an object of class Mdc2DWire.
3188 TClass *R__cl = ::Mdc2DWire::IsA();
3189 if (R__cl || R__insp.IsA()) { }
3190 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWireType", &fWireType);
3191 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTube", &fTube);
3192 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWireCircle", &fWireCircle);
3193 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWireCone", &fWireCone);
3194 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZRPosMarker2D", &fZRPosMarker2D);
3195 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWestHole[3]", fWestHole);
3196 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEastHole[3]", fEastHole);
3197 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWestPhi", &fWestPhi);
3198 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEastPhi", &fEastPhi);
3199 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionPos[3]", fZRSectionPos);
3200 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionFlag", &fZRSectionFlag);
3201 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
3202 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
3203 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
3204 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
3205 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
3206 R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorfulWire", &fColorfulWire);
3207 R__insp.Inspect(R__cl, R__insp.GetParent(), "qOverflow", &qOverflow);
3208 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcTube", &lcTube);
3209 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwTube", &lwTube);
3210 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcTube", &fcTube);
3211 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsTube", &fsTube);
3212 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWire", &lcWire);
3213 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircle", &lwCircle);
3214 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCone", &lwCone);
3215 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircle", &fcCircle);
3216 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCone", &fcCone);
3217 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircle", &fsCircle);
3218 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCone", &fsCone);
3219 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWireFired", &lcWireFired);
3220 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircleFired", &lwCircleFired);
3221 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwConeFired", &lwConeFired);
3222 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircleFired", &fcCircleFired);
3223 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcConeFired", &fcConeFired);
3224 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircleFired", &fsCircleFired);
3225 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsConeFired", &fsConeFired);
3226 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWireHL", &lcWireHL);
3227 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircleHL", &lwCircleHL);
3228 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwConeHL", &lwConeHL);
3229 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircleHL", &fcCircleHL);
3230 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcConeHL", &fcConeHL);
3231 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircleHL", &fsCircleHL);
3232 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsConeHL", &fsConeHL);
3233 R__insp.Inspect(R__cl, R__insp.GetParent(), "sizeMarker", &sizeMarker);
3234 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarker", &cMarker);
3235 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarkerFired", &cMarkerFired);
3236 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarkerHL", &cMarkerHL);
3237 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarker", &sMarker);
3238 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarkerFired", &sMarkerFired);
3239 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarkerHL", &sMarkerHL);
3240 R__insp.Inspect(R__cl, R__insp.GetParent(), "mdcTime", &mdcTime);
3241 R__insp.Inspect(R__cl, R__insp.GetParent(), "mdcCharge", &mdcCharge);
3242 R__insp.Inspect(R__cl, R__insp.GetParent(), "evTime", &evTime);
3243 R__insp.Inspect(R__cl, R__insp.GetParent(), "timeChannel", &timeChannel);
3244 R__insp.Inspect(R__cl, R__insp.GetParent(), "chargeChannel", &chargeChannel);
3245 TNamed::ShowMembers(R__insp);
3246 TAttLine::ShowMembers(R__insp);
3247 TAttFill::ShowMembers(R__insp);
3248}
3249
3250namespace ROOT {
3251 // Wrappers around operator new
3252 static void *new_Mdc2DWire(void *p) {
3253 return p ? new(p) ::Mdc2DWire : new ::Mdc2DWire;
3254 }
3255 static void *newArray_Mdc2DWire(Long_t nElements, void *p) {
3256 return p ? new(p) ::Mdc2DWire[nElements] : new ::Mdc2DWire[nElements];
3257 }
3258 // Wrapper around operator delete
3259 static void delete_Mdc2DWire(void *p) {
3260 delete ((::Mdc2DWire*)p);
3261 }
3262 static void deleteArray_Mdc2DWire(void *p) {
3263 delete [] ((::Mdc2DWire*)p);
3264 }
3265 static void destruct_Mdc2DWire(void *p) {
3266 typedef ::Mdc2DWire current_t;
3267 ((current_t*)p)->~current_t();
3268 }
3269} // end of namespace ROOT for class ::Mdc2DWire
3270
3271//______________________________________________________________________________
3272namespace ROOT {
3273 void MdcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
3274 {
3275 // Inspect the data members of an object of class MdcROOTGeo.
3276 typedef ::ROOT::Shadow::MdcROOTGeo ShadowClass;
3277 ShadowClass *sobj = (ShadowClass*)obj;
3278 if (sobj) { } // Dummy usage just in case there is no datamember.
3279
3280 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0)->GetClass();
3281 if (R__cl || R__insp.IsA()) { }
3282 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_TFire", &sobj->k_TFire);
3283 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QFire", &sobj->k_QFire);
3284 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QNotOverflow", &sobj->k_QNotOverflow);
3285 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_ColorfulWire", &sobj->k_ColorfulWire);
3286 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_MdcTimeSubEvTime", &sobj->k_MdcTimeSubEvTime);
3287 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_StartLayer", &sobj->m_StartLayer);
3288 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_MdcColor", &sobj->m_MdcColor);
3289 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_segmentColor", &sobj->m_segmentColor);
3290 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hypeColor", &sobj->m_hypeColor);
3291 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tubeColor", &sobj->m_tubeColor);
3292 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twistedTubsColor", &sobj->m_twistedTubsColor);
3293 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_replicaColor", &sobj->m_replicaColor);
3294 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_CorrectMap", (void*)&sobj->m_CorrectMap);
3295 R__insp.InspectMember("map<int,int>", (void*)&sobj->m_CorrectMap, "m_CorrectMap.", false);
3296 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc", &sobj->m_Mdc);
3297 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeLayer[50]", &sobj->m_NodeLayer);
3298 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeReplica[50][288]", &sobj->m_NodeReplica);
3299 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalSegment[132]", &sobj->m_PhysicalSegment);
3300 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalReplica[50][288]", &sobj->m_PhysicalReplica);
3301 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcDigiCol", &sobj->m_MdcDigiCol);
3302 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcXY", &sobj->m_MdcXY);
3303 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcXYSuper[4]", &sobj->m_MdcXYSuper);
3304 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc2DWire[43][288]", &sobj->m_Mdc2DWire);
3305 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcZR[2]", &sobj->m_MdcZR);
3306 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::MdcROOTGeo*) obj ), false);
3307 }
3308
3309}
3310
3311namespace ROOT {
3312 // Wrappers around operator new
3313 static void *new_MdcROOTGeo(void *p) {
3314 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MdcROOTGeo : new ::MdcROOTGeo;
3315 }
3316 static void *newArray_MdcROOTGeo(Long_t nElements, void *p) {
3317 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MdcROOTGeo[nElements] : new ::MdcROOTGeo[nElements];
3318 }
3319 // Wrapper around operator delete
3320 static void delete_MdcROOTGeo(void *p) {
3321 delete ((::MdcROOTGeo*)p);
3322 }
3323 static void deleteArray_MdcROOTGeo(void *p) {
3324 delete [] ((::MdcROOTGeo*)p);
3325 }
3326 static void destruct_MdcROOTGeo(void *p) {
3327 typedef ::MdcROOTGeo current_t;
3328 ((current_t*)p)->~current_t();
3329 }
3330} // end of namespace ROOT for class ::MdcROOTGeo
3331
3332//______________________________________________________________________________
3333void Muc2DStrip::Streamer(TBuffer &R__b)
3334{
3335 // Stream an object of class Muc2DStrip.
3336
3337 if (R__b.IsReading()) {
3338 R__b.ReadClassBuffer(Muc2DStrip::Class(),this);
3339 } else {
3340 R__b.WriteClassBuffer(Muc2DStrip::Class(),this);
3341 }
3342}
3343
3344//______________________________________________________________________________
3345void Muc2DStrip::ShowMembers(TMemberInspector &R__insp)
3346{
3347 // Inspect the data members of an object of class Muc2DStrip.
3348 TClass *R__cl = ::Muc2DStrip::IsA();
3349 if (R__cl || R__insp.IsA()) { }
3350 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
3351 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeg", &fSeg);
3352 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGap", &fGap);
3353 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrip", &fStrip);
3354 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripXY", &fStripXY);
3355 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripZR", &fStripZR);
3356 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
3357 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
3358 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
3359 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
3360 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
3361 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStrip", &lcStrip);
3362 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStrip", &lwStrip);
3363 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStrip", &lsStrip);
3364 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStrip", &fcStrip);
3365 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStrip", &fsStrip);
3366 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStripFired", &lcStripFired);
3367 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStripFired", &lwStripFired);
3368 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStripFired", &lsStripFired);
3369 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStripFired", &fcStripFired);
3370 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStripFired", &fsStripFired);
3371 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStripHL", &lcStripHL);
3372 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStripHL", &lwStripHL);
3373 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStripHL", &lsStripHL);
3374 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStripHL", &fcStripHL);
3375 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStripHL", &fsStripHL);
3376 TNamed::ShowMembers(R__insp);
3377 TAttLine::ShowMembers(R__insp);
3378 TAttFill::ShowMembers(R__insp);
3379}
3380
3381namespace ROOT {
3382 // Wrappers around operator new
3383 static void *new_Muc2DStrip(void *p) {
3384 return p ? new(p) ::Muc2DStrip : new ::Muc2DStrip;
3385 }
3386 static void *newArray_Muc2DStrip(Long_t nElements, void *p) {
3387 return p ? new(p) ::Muc2DStrip[nElements] : new ::Muc2DStrip[nElements];
3388 }
3389 // Wrapper around operator delete
3390 static void delete_Muc2DStrip(void *p) {
3391 delete ((::Muc2DStrip*)p);
3392 }
3393 static void deleteArray_Muc2DStrip(void *p) {
3394 delete [] ((::Muc2DStrip*)p);
3395 }
3396 static void destruct_Muc2DStrip(void *p) {
3397 typedef ::Muc2DStrip current_t;
3398 ((current_t*)p)->~current_t();
3399 }
3400} // end of namespace ROOT for class ::Muc2DStrip
3401
3402//______________________________________________________________________________
3403namespace ROOT {
3404 void MucROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
3405 {
3406 // Inspect the data members of an object of class MucROOTGeo.
3407 typedef ::ROOT::Shadow::MucROOTGeo ShadowClass;
3408 ShadowClass *sobj = (ShadowClass*)obj;
3409 if (sobj) { } // Dummy usage just in case there is no datamember.
3410
3411 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0)->GetClass();
3412 if (R__cl || R__insp.IsA()) { }
3413 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_StripNum[3][8][9]", sobj->m_StripNum);
3414 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_MucColor", &sobj->m_MucColor);
3415 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_absorberColor", &sobj->m_absorberColor);
3416 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_gapColor", &sobj->m_gapColor);
3417 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_gasChamberColor", &sobj->m_gasChamberColor);
3418 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_bakeliteColor", &sobj->m_bakeliteColor);
3419 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stripColor", &sobj->m_stripColor);
3420 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc", &sobj->m_Muc);
3421 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAbsorber[3][8][9]", &sobj->m_NodeAbsorber);
3422 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAbsorberPanel[3][8][9][4]", &sobj->m_NodeAbsorberPanel);
3423 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeGap[3][8][9]", &sobj->m_NodeGap);
3424 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeStripPlane[3][8][9]", &sobj->m_NodeStripPlane);
3425 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeStrip[3][8][9][112]", &sobj->m_NodeStrip);
3426 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalAbsorber[3][8][9][4]", &sobj->m_PhysicalAbsorber);
3427 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalGap[3][8][9]", &sobj->m_PhysicalGap);
3428 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalStrip[3][8][9][112]", &sobj->m_PhysicalStrip);
3429 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucDigiCol", &sobj->m_MucDigiCol);
3430 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucXY[3][8]", &sobj->m_MucXY);
3431 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucZR[3][8]", &sobj->m_MucZR);
3432 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucXYGap[3][8][9]", &sobj->m_MucXYGap);
3433 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucZRGap[3][8][9]", &sobj->m_MucZRGap);
3434 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc2DStrip[3][8][9][112]", &sobj->m_Muc2DStrip);
3435 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::MucROOTGeo*) obj ), false);
3436 }
3437
3438}
3439
3440namespace ROOT {
3441 // Wrappers around operator new
3442 static void *new_MucROOTGeo(void *p) {
3443 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MucROOTGeo : new ::MucROOTGeo;
3444 }
3445 static void *newArray_MucROOTGeo(Long_t nElements, void *p) {
3446 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MucROOTGeo[nElements] : new ::MucROOTGeo[nElements];
3447 }
3448 // Wrapper around operator delete
3449 static void delete_MucROOTGeo(void *p) {
3450 delete ((::MucROOTGeo*)p);
3451 }
3452 static void deleteArray_MucROOTGeo(void *p) {
3453 delete [] ((::MucROOTGeo*)p);
3454 }
3455 static void destruct_MucROOTGeo(void *p) {
3456 typedef ::MucROOTGeo current_t;
3457 ((current_t*)p)->~current_t();
3458 }
3459} // end of namespace ROOT for class ::MucROOTGeo
3460
3461//______________________________________________________________________________
3462namespace ROOT {
3463 void SubDetectorROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
3464 {
3465 // Inspect the data members of an object of class SubDetectorROOTGeo.
3466 typedef ::ROOT::Shadow::SubDetectorROOTGeo ShadowClass;
3467 ShadowClass *sobj = (ShadowClass*)obj;
3468 if (sobj) { } // Dummy usage just in case there is no datamember.
3469
3470 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0)->GetClass();
3471 if (R__cl || R__insp.IsA()) { }
3472 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sxp", (void*)&sobj->m_sxp);
3473 R__insp.InspectMember("SAXProcessor", (void*)&sobj->m_sxp, "m_sxp.", false);
3474 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_config", (void*)&sobj->m_config);
3475 R__insp.InspectMember("ProcessingConfigurator", (void*)&sobj->m_config, "m_config.", false);
3476 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ROOTGeoInit", &sobj->m_ROOTGeoInit);
3477 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_childNo", &sobj->m_childNo);
3478 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_2DGeoInit", &sobj->m_2DGeoInit);
3479 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TopVolume", &sobj->m_TopVolume);
3480 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_DetectorsArray", &sobj->m_DetectorsArray);
3481 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_HitsArray", &sobj->m_HitsArray);
3482 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_2DHitsArray", &sobj->m_2DHitsArray);
3483 }
3484
3485}
3486
3487namespace ROOT {
3488 // Wrappers around operator new
3489 static void *new_SubDetectorROOTGeo(void *p) {
3490 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SubDetectorROOTGeo : new ::SubDetectorROOTGeo;
3491 }
3492 static void *newArray_SubDetectorROOTGeo(Long_t nElements, void *p) {
3493 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SubDetectorROOTGeo[nElements] : new ::SubDetectorROOTGeo[nElements];
3494 }
3495 // Wrapper around operator delete
3496 static void delete_SubDetectorROOTGeo(void *p) {
3497 delete ((::SubDetectorROOTGeo*)p);
3498 }
3499 static void deleteArray_SubDetectorROOTGeo(void *p) {
3500 delete [] ((::SubDetectorROOTGeo*)p);
3501 }
3502 static void destruct_SubDetectorROOTGeo(void *p) {
3503 typedef ::SubDetectorROOTGeo current_t;
3504 ((current_t*)p)->~current_t();
3505 }
3506} // end of namespace ROOT for class ::SubDetectorROOTGeo
3507
3508//______________________________________________________________________________
3509void Tof2DScin::Streamer(TBuffer &R__b)
3510{
3511 // Stream an object of class Tof2DScin.
3512
3513 if (R__b.IsReading()) {
3514 R__b.ReadClassBuffer(Tof2DScin::Class(),this);
3515 } else {
3516 R__b.WriteClassBuffer(Tof2DScin::Class(),this);
3517 }
3518}
3519
3520//______________________________________________________________________________
3521void Tof2DScin::ShowMembers(TMemberInspector &R__insp)
3522{
3523 // Inspect the data members of an object of class Tof2DScin.
3524 TClass *R__cl = ::Tof2DScin::IsA();
3525 if (R__cl || R__insp.IsA()) { }
3526 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
3527 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinXY", &fScinXY);
3528 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinZR", &fScinZR);
3529 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinXYFired", &fScinXYFired);
3530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinZRFired", &fScinZRFired);
3531 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
3532 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
3533 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionTolerance[3]", fZRSectionTolerance);
3534 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMin", &fPhiMin);
3535 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMax", &fPhiMax);
3536 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
3537 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
3538 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
3539 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
3540 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
3541 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScin", &lcScin);
3542 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScin", &lwScin);
3543 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScin", &fcScin);
3544 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScin", &fsScin);
3545 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinFired", &lcScinFired);
3546 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinFired", &lwScinFired);
3547 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinFired", &fcScinFired);
3548 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinFired", &fsScinFired);
3549 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinHL", &lcScinHL);
3550 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinHL", &lwScinHL);
3551 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinHL", &fcScinHL);
3552 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinHL", &fsScinHL);
3553 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinFiredHL", &lcScinFiredHL);
3554 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinFiredHL", &lwScinFiredHL);
3555 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinFiredHL", &fcScinFiredHL);
3556 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinFiredHL", &fsScinFiredHL);
3557 R__insp.Inspect(R__cl, R__insp.GetParent(), "timeChannel", &timeChannel);
3558 R__insp.Inspect(R__cl, R__insp.GetParent(), "chargeChannel", &chargeChannel);
3559 TNamed::ShowMembers(R__insp);
3560 TAttLine::ShowMembers(R__insp);
3561 TAttFill::ShowMembers(R__insp);
3562}
3563
3564namespace ROOT {
3565 // Wrappers around operator new
3566 static void *new_Tof2DScin(void *p) {
3567 return p ? new(p) ::Tof2DScin : new ::Tof2DScin;
3568 }
3569 static void *newArray_Tof2DScin(Long_t nElements, void *p) {
3570 return p ? new(p) ::Tof2DScin[nElements] : new ::Tof2DScin[nElements];
3571 }
3572 // Wrapper around operator delete
3573 static void delete_Tof2DScin(void *p) {
3574 delete ((::Tof2DScin*)p);
3575 }
3576 static void deleteArray_Tof2DScin(void *p) {
3577 delete [] ((::Tof2DScin*)p);
3578 }
3579 static void destruct_Tof2DScin(void *p) {
3580 typedef ::Tof2DScin current_t;
3581 ((current_t*)p)->~current_t();
3582 }
3583} // end of namespace ROOT for class ::Tof2DScin
3584
3585//______________________________________________________________________________
3586namespace ROOT {
3587 void TofROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
3588 {
3589 // Inspect the data members of an object of class TofROOTGeo.
3590 typedef ::ROOT::Shadow::TofROOTGeo ShadowClass;
3591 ShadowClass *sobj = (ShadowClass*)obj;
3592 if (sobj) { } // Dummy usage just in case there is no datamember.
3593
3594 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0)->GetClass();
3595 if (R__cl || R__insp.IsA()) { }
3596 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_TMatch", &sobj->k_TMatch);
3597 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QMatch", &sobj->k_QMatch);
3598 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_TofColor", &sobj->m_TofColor);
3599 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BucketColor", &sobj->m_BucketColor);
3600 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ScinColor", &sobj->m_ScinColor);
3601 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof", &sobj->m_Tof);
3602 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePVF[3][2][88]", &sobj->m_NodePVF);
3603 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAl[3][2]", &sobj->m_NodeAl);
3604 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeScin[3][2]", &sobj->m_NodeScin);
3605 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalScin[3][36][88]", &sobj->m_PhysicalScin);
3606 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeModule[3][36]", &sobj->m_NodeModule);
3607 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodegasContainer[3][36]", &sobj->m_NodegasContainer);
3608 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodebareChamber[3][36]", &sobj->m_NodebareChamber);
3609 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodepcbBoard1[3][36]", &sobj->m_NodepcbBoard1);
3610 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeStrip[3][36][12]", &sobj->m_NodeStrip);
3611 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TofDigiCol", &sobj->m_TofDigiCol);
3612 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofMrpc", &sobj->fTofMrpc);
3613 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof2DScin[3][36][88]", &sobj->m_Tof2DScin);
3614 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::TofROOTGeo*) obj ), false);
3615 }
3616
3617}
3618
3619namespace ROOT {
3620 // Wrappers around operator new
3621 static void *new_TofROOTGeo(void *p) {
3622 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TofROOTGeo : new ::TofROOTGeo;
3623 }
3624 static void *newArray_TofROOTGeo(Long_t nElements, void *p) {
3625 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TofROOTGeo[nElements] : new ::TofROOTGeo[nElements];
3626 }
3627 // Wrapper around operator delete
3628 static void delete_TofROOTGeo(void *p) {
3629 delete ((::TofROOTGeo*)p);
3630 }
3631 static void deleteArray_TofROOTGeo(void *p) {
3632 delete [] ((::TofROOTGeo*)p);
3633 }
3634 static void destruct_TofROOTGeo(void *p) {
3635 typedef ::TofROOTGeo current_t;
3636 ((current_t*)p)->~current_t();
3637 }
3638} // end of namespace ROOT for class ::TofROOTGeo
3639
3640//______________________________________________________________________________
3641namespace ROOT {
3642 void vector3_ShowMembers(void *obj, TMemberInspector &R__insp)
3643 {
3644 // Inspect the data members of an object of class vector3.
3645 typedef ::ROOT::Shadow::vector3 ShadowClass;
3646 ShadowClass *sobj = (ShadowClass*)obj;
3647 if (sobj) { } // Dummy usage just in case there is no datamember.
3648
3649 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::vector3*)0x0)->GetClass();
3650 if (R__cl || R__insp.IsA()) { }
3651 R__insp.Inspect(R__cl, R__insp.GetParent(), "x", &sobj->x);
3652 R__insp.Inspect(R__cl, R__insp.GetParent(), "y", &sobj->y);
3653 R__insp.Inspect(R__cl, R__insp.GetParent(), "z", &sobj->z);
3654 }
3655
3656}
3657
3658namespace ROOT {
3659 // Wrappers around operator new
3660 static void *new_vector3(void *p) {
3661 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector3 : new ::vector3;
3662 }
3663 static void *newArray_vector3(Long_t nElements, void *p) {
3664 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector3[nElements] : new ::vector3[nElements];
3665 }
3666 // Wrapper around operator delete
3667 static void delete_vector3(void *p) {
3668 delete ((::vector3*)p);
3669 }
3670 static void deleteArray_vector3(void *p) {
3671 delete [] ((::vector3*)p);
3672 }
3673 static void destruct_vector3(void *p) {
3674 typedef ::vector3 current_t;
3675 ((current_t*)p)->~current_t();
3676 }
3677} // end of namespace ROOT for class ::vector3
3678
3679//______________________________________________________________________________
3680void ZHelix::Streamer(TBuffer &R__b)
3681{
3682 // Stream an object of class ZHelix.
3683
3684 if (R__b.IsReading()) {
3685 R__b.ReadClassBuffer(ZHelix::Class(),this);
3686 } else {
3687 R__b.WriteClassBuffer(ZHelix::Class(),this);
3688 }
3689}
3690
3691//______________________________________________________________________________
3692void ZHelix::ShowMembers(TMemberInspector &R__insp)
3693{
3694 // Inspect the data members of an object of class ZHelix.
3695 TClass *R__cl = ::ZHelix::IsA();
3696 if (R__cl || R__insp.IsA()) { }
3697 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrackType", &fTrackType);
3698 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAzim", &fAzim);
3699 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQovR", &fQovR);
3700 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQxDh", &fQxDh);
3701 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTDip", &fTDip);
3702 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefX", &fRefX);
3703 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefY", &fRefY);
3704 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefZ", &fRefZ);
3705 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange[2]", fRange);
3706 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRType", &fRType);
3707 R__insp.Inspect(R__cl, R__insp.GetParent(), "fChi2", &fChi2);
3708 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDoF", &fNDoF);
3709 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSinAzim", &fSinAzim);
3710 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosAzim", &fCosAzim);
3711 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRSign", &fRSign);
3712 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiI", &fPhiI);
3713 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiO", &fPhiO);
3714 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnable", &fEnable);
3715 TPolyLine3D::ShowMembers(R__insp);
3716}
3717
3718namespace ROOT {
3719 // Wrappers around operator new
3720 static void *new_ZHelix(void *p) {
3721 return p ? new(p) ::ZHelix : new ::ZHelix;
3722 }
3723 static void *newArray_ZHelix(Long_t nElements, void *p) {
3724 return p ? new(p) ::ZHelix[nElements] : new ::ZHelix[nElements];
3725 }
3726 // Wrapper around operator delete
3727 static void delete_ZHelix(void *p) {
3728 delete ((::ZHelix*)p);
3729 }
3730 static void deleteArray_ZHelix(void *p) {
3731 delete [] ((::ZHelix*)p);
3732 }
3733 static void destruct_ZHelix(void *p) {
3734 typedef ::ZHelix current_t;
3735 ((current_t*)p)->~current_t();
3736 }
3737 // Wrapper around the merge function.
3738 static Long64_t merge_ZHelix(void *obj,TCollection *coll,TFileMergeInfo *) {
3739 return ((::ZHelix*)obj)->Merge(coll);
3740 }
3741} // end of namespace ROOT for class ::ZHelix
3742
3743namespace ROOT {
3744 void maplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
3745 static void maplEintcOintgR_Dictionary();
3746 static void *new_maplEintcOintgR(void *p = 0);
3747 static void *newArray_maplEintcOintgR(Long_t size, void *p);
3748 static void delete_maplEintcOintgR(void *p);
3749 static void deleteArray_maplEintcOintgR(void *p);
3750 static void destruct_maplEintcOintgR(void *p);
3751
3752 // Function generating the singleton type initializer
3753 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,int>*)
3754 {
3755 map<int,int> *ptr = 0;
3756 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,int>),0);
3757 static ::ROOT::TGenericClassInfo
3758 instance("map<int,int>", -2, "map2.dll", 0,
3759 typeid(map<int,int>), DefineBehavior(ptr, ptr),
3760 0, &maplEintcOintgR_Dictionary, isa_proxy, 0,
3761 sizeof(map<int,int>) );
3762 instance.SetNew(&new_maplEintcOintgR);
3763 instance.SetNewArray(&newArray_maplEintcOintgR);
3764 instance.SetDelete(&delete_maplEintcOintgR);
3765 instance.SetDeleteArray(&deleteArray_maplEintcOintgR);
3766 instance.SetDestructor(&destruct_maplEintcOintgR);
3767 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,int> >()));
3768 return &instance;
3769 }
3770 // Static variable to force the class initialization
3771 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
3772
3773 // Dictionary for non-ClassDef classes
3774 static void maplEintcOintgR_Dictionary() {
3775 ::ROOT::GenerateInitInstanceLocal((const map<int,int>*)0x0)->GetClass();
3776 }
3777
3778} // end of namespace ROOT
3779
3780namespace ROOT {
3781 // Wrappers around operator new
3782 static void *new_maplEintcOintgR(void *p) {
3783 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,int> : new map<int,int>;
3784 }
3785 static void *newArray_maplEintcOintgR(Long_t nElements, void *p) {
3786 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,int>[nElements] : new map<int,int>[nElements];
3787 }
3788 // Wrapper around operator delete
3789 static void delete_maplEintcOintgR(void *p) {
3790 delete ((map<int,int>*)p);
3791 }
3792 static void deleteArray_maplEintcOintgR(void *p) {
3793 delete [] ((map<int,int>*)p);
3794 }
3795 static void destruct_maplEintcOintgR(void *p) {
3796 typedef map<int,int> current_t;
3797 ((current_t*)p)->~current_t();
3798 }
3799} // end of namespace ROOT for class map<int,int>
3800
3801namespace ROOT {
3802 void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
3803 static void vectorlETStringgR_Dictionary();
3804 static void *new_vectorlETStringgR(void *p = 0);
3805 static void *newArray_vectorlETStringgR(Long_t size, void *p);
3806 static void delete_vectorlETStringgR(void *p);
3807 static void deleteArray_vectorlETStringgR(void *p);
3808 static void destruct_vectorlETStringgR(void *p);
3809
3810 // Function generating the singleton type initializer
3811 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
3812 {
3813 vector<TString> *ptr = 0;
3814 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
3815 static ::ROOT::TGenericClassInfo
3816 instance("vector<TString>", -2, "prec_stl/vector", 49,
3817 typeid(vector<TString>), DefineBehavior(ptr, ptr),
3818 0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
3819 sizeof(vector<TString>) );
3820 instance.SetNew(&new_vectorlETStringgR);
3821 instance.SetNewArray(&newArray_vectorlETStringgR);
3822 instance.SetDelete(&delete_vectorlETStringgR);
3823 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
3824 instance.SetDestructor(&destruct_vectorlETStringgR);
3825 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
3826 return &instance;
3827 }
3828 // Static variable to force the class initialization
3829 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
3830
3831 // Dictionary for non-ClassDef classes
3832 static void vectorlETStringgR_Dictionary() {
3833 ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
3834 }
3835
3836} // end of namespace ROOT
3837
3838namespace ROOT {
3839 // Wrappers around operator new
3840 static void *new_vectorlETStringgR(void *p) {
3841 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
3842 }
3843 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
3844 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
3845 }
3846 // Wrapper around operator delete
3847 static void delete_vectorlETStringgR(void *p) {
3848 delete ((vector<TString>*)p);
3849 }
3850 static void deleteArray_vectorlETStringgR(void *p) {
3851 delete [] ((vector<TString>*)p);
3852 }
3853 static void destruct_vectorlETStringgR(void *p) {
3854 typedef vector<TString> current_t;
3855 ((current_t*)p)->~current_t();
3856 }
3857} // end of namespace ROOT for class vector<TString>
3858
3859/********************************************************
3860* ../BesVisLib/BesVisLib_rootcint.cxx
3861* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
3862* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
3863* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
3864********************************************************/
3865
3866#ifdef G__MEMTEST
3867#undef malloc
3868#undef free
3869#endif
3870
3871#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
3872#pragma GCC diagnostic ignored "-Wstrict-aliasing"
3873#endif
3874
3875extern "C" void G__cpp_reset_tagtableBesVisLib_rootcint();
3876
3877extern "C" void G__set_cpp_environmentBesVisLib_rootcint() {
3878 G__add_compiledheader("TObject.h");
3879 G__add_compiledheader("TMemberInspector.h");
3880 G__add_compiledheader("../BesVisLib/Bes2DView.h");
3881 G__add_compiledheader("../BesVisLib/BesCircle2D.h");
3882 G__add_compiledheader("../BesVisLib/BesCursor.h");
3883 G__add_compiledheader("../BesVisLib/BesEvent.h");
3884 G__add_compiledheader("../BesVisLib/BesEventHeader.h");
3885 G__add_compiledheader("../BesVisLib/BesGeometry.h");
3886 G__add_compiledheader("../BesVisLib/BesGeoTrack.h");
3887 G__add_compiledheader("../BesVisLib/BesGMenuBar.h");
3888 G__add_compiledheader("../BesVisLib/BesGMenuTitle.h");
3889 G__add_compiledheader("../BesVisLib/BesGPictureButton.h");
3890 G__add_compiledheader("../BesVisLib/BesHeader.h");
3891 G__add_compiledheader("../BesVisLib/BesMarker2D.h");
3892 G__add_compiledheader("../BesVisLib/BesPaveText.h");
3893 G__add_compiledheader("../BesVisLib/BesPolygon2D.h");
3894 G__add_compiledheader("../BesVisLib/BesStatus.h");
3895 G__add_compiledheader("../BesVisLib/BesView.h");
3896 G__add_compiledheader("../BesVisLib/BesVisDisplay.h");
3897 G__add_compiledheader("../BesVisLib/Emc2DCrystal.h");
3898 G__add_compiledheader("../BesVisLib/EmcROOTGeo.h");
3899 G__add_compiledheader("../BesVisLib/Mdc2DWire.h");
3900 G__add_compiledheader("../BesVisLib/BesTView.h");
3901 G__add_compiledheader("../BesVisLib/MdcROOTGeo.h");
3902 G__add_compiledheader("../BesVisLib/Muc2DStrip.h");
3903 G__add_compiledheader("../BesVisLib/MucROOTGeo.h");
3904 G__add_compiledheader("../BesVisLib/SubDetectorROOTGeo.h");
3905 G__add_compiledheader("../BesVisLib/Tof2DScin.h");
3906 G__add_compiledheader("../BesVisLib/TofROOTGeo.h");
3907 G__add_compiledheader("../BesVisLib/ZHelix.h");
3908 G__add_compiledheader("../BesVisLib/vector3.h");
3909 G__add_compiledheader("../BesVisLib/DstConvert.h");
3910 G__cpp_reset_tagtableBesVisLib_rootcint();
3911}
3912#include <new>
3913extern "C" int G__cpp_dllrevBesVisLib_rootcint() { return(30051515); }
3914
3915/*********************************************************
3916* Member function Interface Method
3917*********************************************************/
3918
3919/* BesStatus */
3920static int G__BesVisLib_rootcint_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3921{
3922 BesStatus* p = NULL;
3923 char* gvp = (char*) G__getgvp();
3924 int n = G__getaryconstruct();
3925 if (n) {
3926 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
3927 p = new BesStatus[n];
3928 } else {
3929 p = new((void*) gvp) BesStatus[n];
3930 }
3931 } else {
3932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
3933 p = new BesStatus;
3934 } else {
3935 p = new((void*) gvp) BesStatus;
3936 }
3937 }
3938 result7->obj.i = (long) p;
3939 result7->ref = (long) p;
3940 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
3941 return(1 || funcname || hash || result7 || libp) ;
3942}
3943
3944static int G__BesVisLib_rootcint_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3945{
3946 ((BesStatus*) G__getstructoffset())->Transfer((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3947 G__setnull(result7);
3948 return(1 || funcname || hash || result7 || libp) ;
3949}
3950
3951static int G__BesVisLib_rootcint_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3952{
3953 ((BesStatus*) G__getstructoffset())->TransferGeometryCgem((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3954 G__setnull(result7);
3955 return(1 || funcname || hash || result7 || libp) ;
3956}
3957
3958static int G__BesVisLib_rootcint_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3959{
3960 ((BesStatus*) G__getstructoffset())->TransferGeometryMdc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3961 G__setnull(result7);
3962 return(1 || funcname || hash || result7 || libp) ;
3963}
3964
3965static int G__BesVisLib_rootcint_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3966{
3967 ((BesStatus*) G__getstructoffset())->TransferGeometryTof((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3968 G__setnull(result7);
3969 return(1 || funcname || hash || result7 || libp) ;
3970}
3971
3972static int G__BesVisLib_rootcint_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3973{
3974 ((BesStatus*) G__getstructoffset())->TransferGeometryEmc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3975 G__setnull(result7);
3976 return(1 || funcname || hash || result7 || libp) ;
3977}
3978
3979static int G__BesVisLib_rootcint_169_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3980{
3981 ((BesStatus*) G__getstructoffset())->TransferGeometryMuc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3982 G__setnull(result7);
3983 return(1 || funcname || hash || result7 || libp) ;
3984}
3985
3986static int G__BesVisLib_rootcint_169_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3987{
3988 ((BesStatus*) G__getstructoffset())->TransferGeometryFull3D((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3989 G__setnull(result7);
3990 return(1 || funcname || hash || result7 || libp) ;
3991}
3992
3993static int G__BesVisLib_rootcint_169_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
3994{
3995 ((BesStatus*) G__getstructoffset())->TransferGeometryOtherParts((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
3996 G__setnull(result7);
3997 return(1 || funcname || hash || result7 || libp) ;
3998}
3999
4000static int G__BesVisLib_rootcint_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4001{
4002 ((BesStatus*) G__getstructoffset())->TransferHitsCgem((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4003 G__setnull(result7);
4004 return(1 || funcname || hash || result7 || libp) ;
4005}
4006
4007static int G__BesVisLib_rootcint_169_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4008{
4009 ((BesStatus*) G__getstructoffset())->TransferHitsMdc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4010 G__setnull(result7);
4011 return(1 || funcname || hash || result7 || libp) ;
4012}
4013
4014static int G__BesVisLib_rootcint_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4015{
4016 ((BesStatus*) G__getstructoffset())->TransferHitsTof((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4017 G__setnull(result7);
4018 return(1 || funcname || hash || result7 || libp) ;
4019}
4020
4021static int G__BesVisLib_rootcint_169_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4022{
4023 ((BesStatus*) G__getstructoffset())->TransferHitsEmc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4024 G__setnull(result7);
4025 return(1 || funcname || hash || result7 || libp) ;
4026}
4027
4028static int G__BesVisLib_rootcint_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4029{
4030 ((BesStatus*) G__getstructoffset())->TransferHitsMuc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4031 G__setnull(result7);
4032 return(1 || funcname || hash || result7 || libp) ;
4033}
4034
4035static int G__BesVisLib_rootcint_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4036{
4037 ((BesStatus*) G__getstructoffset())->TransferTracks((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4038 G__setnull(result7);
4039 return(1 || funcname || hash || result7 || libp) ;
4040}
4041
4042static int G__BesVisLib_rootcint_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4043{
4044 ((BesStatus*) G__getstructoffset())->TransferFishEye((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4045 G__setnull(result7);
4046 return(1 || funcname || hash || result7 || libp) ;
4047}
4048
4049static int G__BesVisLib_rootcint_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4050{
4051 ((BesStatus*) G__getstructoffset())->TransferPhiRange((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4052 G__setnull(result7);
4053 return(1 || funcname || hash || result7 || libp) ;
4054}
4055
4056static int G__BesVisLib_rootcint_169_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4057{
4058 ((BesStatus*) G__getstructoffset())->TransferZoom((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
4059 G__setnull(result7);
4060 return(1 || funcname || hash || result7 || libp) ;
4061}
4062
4063static int G__BesVisLib_rootcint_169_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4064{
4065 ((BesStatus*) G__getstructoffset())->Default((EBESViewType) G__int(libp->para[0]));
4066 G__setnull(result7);
4067 return(1 || funcname || hash || result7 || libp) ;
4068}
4069
4070static int G__BesVisLib_rootcint_169_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4071{
4072 G__letint(result7, 85, (long) BesStatus::Class());
4073 return(1 || funcname || hash || result7 || libp) ;
4074}
4075
4076static int G__BesVisLib_rootcint_169_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4077{
4078 G__letint(result7, 67, (long) BesStatus::Class_Name());
4079 return(1 || funcname || hash || result7 || libp) ;
4080}
4081
4082static int G__BesVisLib_rootcint_169_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4083{
4084 G__letint(result7, 115, (long) BesStatus::Class_Version());
4085 return(1 || funcname || hash || result7 || libp) ;
4086}
4087
4088static int G__BesVisLib_rootcint_169_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4089{
4090 BesStatus::Dictionary();
4091 G__setnull(result7);
4092 return(1 || funcname || hash || result7 || libp) ;
4093}
4094
4095static int G__BesVisLib_rootcint_169_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4096{
4097 ((BesStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
4098 G__setnull(result7);
4099 return(1 || funcname || hash || result7 || libp) ;
4100}
4101
4102static int G__BesVisLib_rootcint_169_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4103{
4104 G__letint(result7, 67, (long) BesStatus::DeclFileName());
4105 return(1 || funcname || hash || result7 || libp) ;
4106}
4107
4108static int G__BesVisLib_rootcint_169_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4109{
4110 G__letint(result7, 105, (long) BesStatus::ImplFileLine());
4111 return(1 || funcname || hash || result7 || libp) ;
4112}
4113
4114static int G__BesVisLib_rootcint_169_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4115{
4116 G__letint(result7, 67, (long) BesStatus::ImplFileName());
4117 return(1 || funcname || hash || result7 || libp) ;
4118}
4119
4120static int G__BesVisLib_rootcint_169_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4121{
4122 G__letint(result7, 105, (long) BesStatus::DeclFileLine());
4123 return(1 || funcname || hash || result7 || libp) ;
4124}
4125
4126// automatic copy constructor
4127static int G__BesVisLib_rootcint_169_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4128
4129{
4130 BesStatus* p;
4131 void* tmp = (void*) G__int(libp->para[0]);
4132 p = new BesStatus(*(BesStatus*) tmp);
4133 result7->obj.i = (long) p;
4134 result7->ref = (long) p;
4135 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
4136 return(1 || funcname || hash || result7 || libp) ;
4137}
4138
4139// automatic destructor
4140typedef BesStatus G__TBesStatus;
4141static int G__BesVisLib_rootcint_169_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4142{
4143 char* gvp = (char*) G__getgvp();
4144 long soff = G__getstructoffset();
4145 int n = G__getaryconstruct();
4146 //
4147 //has_a_delete: 1
4148 //has_own_delete1arg: 0
4149 //has_own_delete2arg: 0
4150 //
4151 if (!soff) {
4152 return(1);
4153 }
4154 if (n) {
4155 if (gvp == (char*)G__PVOID) {
4156 delete[] (BesStatus*) soff;
4157 } else {
4158 G__setgvp((long) G__PVOID);
4159 for (int i = n - 1; i >= 0; --i) {
4160 ((BesStatus*) (soff+(sizeof(BesStatus)*i)))->~G__TBesStatus();
4161 }
4162 G__setgvp((long)gvp);
4163 }
4164 } else {
4165 if (gvp == (char*)G__PVOID) {
4166 delete (BesStatus*) soff;
4167 } else {
4168 G__setgvp((long) G__PVOID);
4169 ((BesStatus*) (soff))->~G__TBesStatus();
4170 G__setgvp((long)gvp);
4171 }
4172 }
4173 G__setnull(result7);
4174 return(1 || funcname || hash || result7 || libp) ;
4175}
4176
4177// automatic assignment operator
4178static int G__BesVisLib_rootcint_169_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4179{
4180 BesStatus* dest = (BesStatus*) G__getstructoffset();
4181 *dest = *(BesStatus*) libp->para[0].ref;
4182 const BesStatus& obj = *dest;
4183 result7->ref = (long) (&obj);
4184 result7->obj.i = (long) (&obj);
4185 return(1 || funcname || hash || result7 || libp) ;
4186}
4187
4188
4189/* BesTView */
4190static int G__BesVisLib_rootcint_175_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4191{
4192 BesTView* p = NULL;
4193 char* gvp = (char*) G__getgvp();
4194 int n = G__getaryconstruct();
4195 if (n) {
4196 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4197 p = new BesTView[n];
4198 } else {
4199 p = new((void*) gvp) BesTView[n];
4200 }
4201 } else {
4202 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4203 p = new BesTView;
4204 } else {
4205 p = new((void*) gvp) BesTView;
4206 }
4207 }
4208 result7->obj.i = (long) p;
4209 result7->ref = (long) p;
4210 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
4211 return(1 || funcname || hash || result7 || libp) ;
4212}
4213
4214static int G__BesVisLib_rootcint_175_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4215{
4216 BesTView* p = NULL;
4217 char* gvp = (char*) G__getgvp();
4218 //m: 1
4219 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4220 p = new BesTView((Int_t) G__int(libp->para[0]));
4221 } else {
4222 p = new((void*) gvp) BesTView((Int_t) G__int(libp->para[0]));
4223 }
4224 result7->obj.i = (long) p;
4225 result7->ref = (long) p;
4226 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
4227 return(1 || funcname || hash || result7 || libp) ;
4228}
4229
4230static int G__BesVisLib_rootcint_175_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4231{
4232 BesTView* p = NULL;
4233 char* gvp = (char*) G__getgvp();
4234 switch (libp->paran) {
4235 case 3:
4236 //m: 3
4237 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4238 p = new BesTView(
4239(Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
4240, (Int_t) G__int(libp->para[2]));
4241 } else {
4242 p = new((void*) gvp) BesTView(
4243(Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
4244, (Int_t) G__int(libp->para[2]));
4245 }
4246 break;
4247 case 2:
4248 //m: 2
4249 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4250 p = new BesTView((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
4251 } else {
4252 p = new((void*) gvp) BesTView((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
4253 }
4254 break;
4255 }
4256 result7->obj.i = (long) p;
4257 result7->ref = (long) p;
4258 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
4259 return(1 || funcname || hash || result7 || libp) ;
4260}
4261
4262static int G__BesVisLib_rootcint_175_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4263{
4264 BesTView* p = NULL;
4265 char* gvp = (char*) G__getgvp();
4266 switch (libp->paran) {
4267 case 3:
4268 //m: 3
4269 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4270 p = new BesTView(
4271(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
4272, (Int_t) G__int(libp->para[2]));
4273 } else {
4274 p = new((void*) gvp) BesTView(
4275(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
4276, (Int_t) G__int(libp->para[2]));
4277 }
4278 break;
4279 case 2:
4280 //m: 2
4281 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4282 p = new BesTView((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
4283 } else {
4284 p = new((void*) gvp) BesTView((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
4285 }
4286 break;
4287 }
4288 result7->obj.i = (long) p;
4289 result7->ref = (long) p;
4290 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
4291 return(1 || funcname || hash || result7 || libp) ;
4292}
4293
4294static int G__BesVisLib_rootcint_175_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4295{
4296 switch (libp->paran) {
4297 case 1:
4298 BesTView::AdjustPad((TVirtualPad*) G__int(libp->para[0]));
4299 G__setnull(result7);
4300 break;
4301 case 0:
4302 BesTView::AdjustPad();
4303 G__setnull(result7);
4304 break;
4305 }
4306 return(1 || funcname || hash || result7 || libp) ;
4307}
4308
4309static int G__BesVisLib_rootcint_175_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4310{
4311 G__letint(result7, 85, (long) BesTView::Class());
4312 return(1 || funcname || hash || result7 || libp) ;
4313}
4314
4315static int G__BesVisLib_rootcint_175_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4316{
4317 G__letint(result7, 67, (long) BesTView::Class_Name());
4318 return(1 || funcname || hash || result7 || libp) ;
4319}
4320
4321static int G__BesVisLib_rootcint_175_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4322{
4323 G__letint(result7, 115, (long) BesTView::Class_Version());
4324 return(1 || funcname || hash || result7 || libp) ;
4325}
4326
4327static int G__BesVisLib_rootcint_175_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4328{
4329 BesTView::Dictionary();
4330 G__setnull(result7);
4331 return(1 || funcname || hash || result7 || libp) ;
4332}
4333
4334static int G__BesVisLib_rootcint_175_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4335{
4336 ((BesTView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
4337 G__setnull(result7);
4338 return(1 || funcname || hash || result7 || libp) ;
4339}
4340
4341static int G__BesVisLib_rootcint_175_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4342{
4343 G__letint(result7, 67, (long) BesTView::DeclFileName());
4344 return(1 || funcname || hash || result7 || libp) ;
4345}
4346
4347static int G__BesVisLib_rootcint_175_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4348{
4349 G__letint(result7, 105, (long) BesTView::ImplFileLine());
4350 return(1 || funcname || hash || result7 || libp) ;
4351}
4352
4353static int G__BesVisLib_rootcint_175_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4354{
4355 G__letint(result7, 67, (long) BesTView::ImplFileName());
4356 return(1 || funcname || hash || result7 || libp) ;
4357}
4358
4359static int G__BesVisLib_rootcint_175_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4360{
4361 G__letint(result7, 105, (long) BesTView::DeclFileLine());
4362 return(1 || funcname || hash || result7 || libp) ;
4363}
4364
4365// automatic destructor
4366typedef BesTView G__TBesTView;
4367static int G__BesVisLib_rootcint_175_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4368{
4369 char* gvp = (char*) G__getgvp();
4370 long soff = G__getstructoffset();
4371 int n = G__getaryconstruct();
4372 //
4373 //has_a_delete: 1
4374 //has_own_delete1arg: 0
4375 //has_own_delete2arg: 0
4376 //
4377 if (!soff) {
4378 return(1);
4379 }
4380 if (n) {
4381 if (gvp == (char*)G__PVOID) {
4382 delete[] (BesTView*) soff;
4383 } else {
4384 G__setgvp((long) G__PVOID);
4385 for (int i = n - 1; i >= 0; --i) {
4386 ((BesTView*) (soff+(sizeof(BesTView)*i)))->~G__TBesTView();
4387 }
4388 G__setgvp((long)gvp);
4389 }
4390 } else {
4391 if (gvp == (char*)G__PVOID) {
4392 delete (BesTView*) soff;
4393 } else {
4394 G__setgvp((long) G__PVOID);
4395 ((BesTView*) (soff))->~G__TBesTView();
4396 G__setgvp((long)gvp);
4397 }
4398 }
4399 G__setnull(result7);
4400 return(1 || funcname || hash || result7 || libp) ;
4401}
4402
4403
4404/* Bes2DView */
4405static int G__BesVisLib_rootcint_182_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4406{
4407 Bes2DView* p = NULL;
4408 char* gvp = (char*) G__getgvp();
4409 int n = G__getaryconstruct();
4410 if (n) {
4411 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4412 p = new Bes2DView[n];
4413 } else {
4414 p = new((void*) gvp) Bes2DView[n];
4415 }
4416 } else {
4417 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4418 p = new Bes2DView;
4419 } else {
4420 p = new((void*) gvp) Bes2DView;
4421 }
4422 }
4423 result7->obj.i = (long) p;
4424 result7->ref = (long) p;
4425 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
4426 return(1 || funcname || hash || result7 || libp) ;
4427}
4428
4429static int G__BesVisLib_rootcint_182_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4430{
4431 ((Bes2DView*) G__getstructoffset())->ClearPad();
4432 G__setnull(result7);
4433 return(1 || funcname || hash || result7 || libp) ;
4434}
4435
4436static int G__BesVisLib_rootcint_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4437{
4438 ((Bes2DView*) G__getstructoffset())->DrawLabel();
4439 G__setnull(result7);
4440 return(1 || funcname || hash || result7 || libp) ;
4441}
4442
4443static int G__BesVisLib_rootcint_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4444{
4445 G__letint(result7, 105, (long) ((Bes2DView*) G__getstructoffset())->GetRSign((Float_t) G__double(libp->para[0])));
4446 return(1 || funcname || hash || result7 || libp) ;
4447}
4448
4449static int G__BesVisLib_rootcint_182_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4450{
4451 switch (libp->paran) {
4452 case 1:
4453 ((Bes2DView*) G__getstructoffset())->UpdateView((Bool_t) G__int(libp->para[0]));
4454 G__setnull(result7);
4455 break;
4456 case 0:
4457 ((Bes2DView*) G__getstructoffset())->UpdateView();
4458 G__setnull(result7);
4459 break;
4460 }
4461 return(1 || funcname || hash || result7 || libp) ;
4462}
4463
4464static int G__BesVisLib_rootcint_182_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4465{
4466 ((Bes2DView*) G__getstructoffset())->Set2DViewType((Int_t) G__int(libp->para[0]));
4467 G__setnull(result7);
4468 return(1 || funcname || hash || result7 || libp) ;
4469}
4470
4471static int G__BesVisLib_rootcint_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4472{
4473 G__letint(result7, 105, (long) ((Bes2DView*) G__getstructoffset())->Get2DViewType());
4474 return(1 || funcname || hash || result7 || libp) ;
4475}
4476
4477static int G__BesVisLib_rootcint_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4478{
4479 G__letdouble(result7, 102, (double) ((Bes2DView*) G__getstructoffset())->GetMarkerSize());
4480 return(1 || funcname || hash || result7 || libp) ;
4481}
4482
4483static int G__BesVisLib_rootcint_182_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4484{
4485 ((Bes2DView*) G__getstructoffset())->Center();
4486 G__setnull(result7);
4487 return(1 || funcname || hash || result7 || libp) ;
4488}
4489
4490static int G__BesVisLib_rootcint_182_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4491{
4492 ((Bes2DView*) G__getstructoffset())->Move((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
4493 G__setnull(result7);
4494 return(1 || funcname || hash || result7 || libp) ;
4495}
4496
4497static int G__BesVisLib_rootcint_182_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4498{
4499 ((Bes2DView*) G__getstructoffset())->Reset();
4500 G__setnull(result7);
4501 return(1 || funcname || hash || result7 || libp) ;
4502}
4503
4504static int G__BesVisLib_rootcint_182_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4505{
4506 ((Bes2DView*) G__getstructoffset())->SetMarkerSize((Float_t) G__double(libp->para[0]));
4507 G__setnull(result7);
4508 return(1 || funcname || hash || result7 || libp) ;
4509}
4510
4511static int G__BesVisLib_rootcint_182_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4512{
4513 G__letint(result7, 103, (long) ((Bes2DView*) G__getstructoffset())->GetFishEyeStatus());
4514 return(1 || funcname || hash || result7 || libp) ;
4515}
4516
4517static int G__BesVisLib_rootcint_182_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4518{
4519 G__letint(result7, 103, (long) ((Bes2DView*) G__getstructoffset())->GetFishEye());
4520 return(1 || funcname || hash || result7 || libp) ;
4521}
4522
4523static int G__BesVisLib_rootcint_182_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4524{
4525 switch (libp->paran) {
4526 case 1:
4527 ((Bes2DView*) G__getstructoffset())->SetFishEye((Bool_t) G__int(libp->para[0]));
4528 G__setnull(result7);
4529 break;
4530 case 0:
4531 ((Bes2DView*) G__getstructoffset())->SetFishEye();
4532 G__setnull(result7);
4533 break;
4534 }
4535 return(1 || funcname || hash || result7 || libp) ;
4536}
4537
4538static int G__BesVisLib_rootcint_182_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4539{
4540 ((Bes2DView*) G__getstructoffset())->PrintCurrent();
4541 G__setnull(result7);
4542 return(1 || funcname || hash || result7 || libp) ;
4543}
4544
4545static int G__BesVisLib_rootcint_182_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4546{
4547 ((Bes2DView*) G__getstructoffset())->DrawClass();
4548 G__setnull(result7);
4549 return(1 || funcname || hash || result7 || libp) ;
4550}
4551
4552static int G__BesVisLib_rootcint_182_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4553{
4554 G__letint(result7, 85, (long) ((Bes2DView*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
4555 return(1 || funcname || hash || result7 || libp) ;
4556}
4557
4558static int G__BesVisLib_rootcint_182_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4559{
4560 ((Bes2DView*) G__getstructoffset())->Dump();
4561 G__setnull(result7);
4562 return(1 || funcname || hash || result7 || libp) ;
4563}
4564
4565static int G__BesVisLib_rootcint_182_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4566{
4567 ((Bes2DView*) G__getstructoffset())->Inspect();
4568 G__setnull(result7);
4569 return(1 || funcname || hash || result7 || libp) ;
4570}
4571
4572static int G__BesVisLib_rootcint_182_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4573{
4574 ((Bes2DView*) G__getstructoffset())->SetZoomFactor((Double_t) G__double(libp->para[0]));
4575 G__setnull(result7);
4576 return(1 || funcname || hash || result7 || libp) ;
4577}
4578
4579static int G__BesVisLib_rootcint_182_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4580{
4581 G__letdouble(result7, 100, (double) ((Bes2DView*) G__getstructoffset())->GetZoomFactor());
4582 return(1 || funcname || hash || result7 || libp) ;
4583}
4584
4585static int G__BesVisLib_rootcint_182_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4586{
4587 G__letint(result7, 85, (long) ((Bes2DView*) G__getstructoffset())->GetStatusCurrent());
4588 return(1 || funcname || hash || result7 || libp) ;
4589}
4590
4591static int G__BesVisLib_rootcint_182_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4592{
4593 G__letint(result7, 85, (long) Bes2DView::Class());
4594 return(1 || funcname || hash || result7 || libp) ;
4595}
4596
4597static int G__BesVisLib_rootcint_182_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4598{
4599 G__letint(result7, 67, (long) Bes2DView::Class_Name());
4600 return(1 || funcname || hash || result7 || libp) ;
4601}
4602
4603static int G__BesVisLib_rootcint_182_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4604{
4605 G__letint(result7, 115, (long) Bes2DView::Class_Version());
4606 return(1 || funcname || hash || result7 || libp) ;
4607}
4608
4609static int G__BesVisLib_rootcint_182_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4610{
4611 Bes2DView::Dictionary();
4612 G__setnull(result7);
4613 return(1 || funcname || hash || result7 || libp) ;
4614}
4615
4616static int G__BesVisLib_rootcint_182_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4617{
4618 ((Bes2DView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
4619 G__setnull(result7);
4620 return(1 || funcname || hash || result7 || libp) ;
4621}
4622
4623static int G__BesVisLib_rootcint_182_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4624{
4625 G__letint(result7, 67, (long) Bes2DView::DeclFileName());
4626 return(1 || funcname || hash || result7 || libp) ;
4627}
4628
4629static int G__BesVisLib_rootcint_182_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4630{
4631 G__letint(result7, 105, (long) Bes2DView::ImplFileLine());
4632 return(1 || funcname || hash || result7 || libp) ;
4633}
4634
4635static int G__BesVisLib_rootcint_182_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4636{
4637 G__letint(result7, 67, (long) Bes2DView::ImplFileName());
4638 return(1 || funcname || hash || result7 || libp) ;
4639}
4640
4641static int G__BesVisLib_rootcint_182_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4642{
4643 G__letint(result7, 105, (long) Bes2DView::DeclFileLine());
4644 return(1 || funcname || hash || result7 || libp) ;
4645}
4646
4647// automatic copy constructor
4648static int G__BesVisLib_rootcint_182_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4649
4650{
4651 Bes2DView* p;
4652 void* tmp = (void*) G__int(libp->para[0]);
4653 p = new Bes2DView(*(Bes2DView*) tmp);
4654 result7->obj.i = (long) p;
4655 result7->ref = (long) p;
4656 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
4657 return(1 || funcname || hash || result7 || libp) ;
4658}
4659
4660// automatic destructor
4661typedef Bes2DView G__TBes2DView;
4662static int G__BesVisLib_rootcint_182_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4663{
4664 char* gvp = (char*) G__getgvp();
4665 long soff = G__getstructoffset();
4666 int n = G__getaryconstruct();
4667 //
4668 //has_a_delete: 1
4669 //has_own_delete1arg: 0
4670 //has_own_delete2arg: 0
4671 //
4672 if (!soff) {
4673 return(1);
4674 }
4675 if (n) {
4676 if (gvp == (char*)G__PVOID) {
4677 delete[] (Bes2DView*) soff;
4678 } else {
4679 G__setgvp((long) G__PVOID);
4680 for (int i = n - 1; i >= 0; --i) {
4681 ((Bes2DView*) (soff+(sizeof(Bes2DView)*i)))->~G__TBes2DView();
4682 }
4683 G__setgvp((long)gvp);
4684 }
4685 } else {
4686 if (gvp == (char*)G__PVOID) {
4687 delete (Bes2DView*) soff;
4688 } else {
4689 G__setgvp((long) G__PVOID);
4690 ((Bes2DView*) (soff))->~G__TBes2DView();
4691 G__setgvp((long)gvp);
4692 }
4693 }
4694 G__setnull(result7);
4695 return(1 || funcname || hash || result7 || libp) ;
4696}
4697
4698
4699/* BesCircle2D */
4700static int G__BesVisLib_rootcint_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4701{
4702 BesCircle2D* p = NULL;
4703 char* gvp = (char*) G__getgvp();
4704 int n = G__getaryconstruct();
4705 if (n) {
4706 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4707 p = new BesCircle2D[n];
4708 } else {
4709 p = new((void*) gvp) BesCircle2D[n];
4710 }
4711 } else {
4712 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4713 p = new BesCircle2D;
4714 } else {
4715 p = new((void*) gvp) BesCircle2D;
4716 }
4717 }
4718 result7->obj.i = (long) p;
4719 result7->ref = (long) p;
4720 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
4721 return(1 || funcname || hash || result7 || libp) ;
4722}
4723
4724static int G__BesVisLib_rootcint_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4725{
4726 BesCircle2D* p = NULL;
4727 char* gvp = (char*) G__getgvp();
4728 //m: 5
4729 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4730 p = new BesCircle2D(
4731(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
4732, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
4733, (Double_t*) G__int(libp->para[4]));
4734 } else {
4735 p = new((void*) gvp) BesCircle2D(
4736(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
4737, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
4738, (Double_t*) G__int(libp->para[4]));
4739 }
4740 result7->obj.i = (long) p;
4741 result7->ref = (long) p;
4742 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
4743 return(1 || funcname || hash || result7 || libp) ;
4744}
4745
4746static int G__BesVisLib_rootcint_199_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4747{
4748 ((BesCircle2D*) G__getstructoffset())->SetCenter((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
4749, (Double_t) G__double(libp->para[2]));
4750 G__setnull(result7);
4751 return(1 || funcname || hash || result7 || libp) ;
4752}
4753
4754static int G__BesVisLib_rootcint_199_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4755{
4756 ((BesCircle2D*) G__getstructoffset())->GetCenter((Double_t*) G__int(libp->para[0]));
4757 G__setnull(result7);
4758 return(1 || funcname || hash || result7 || libp) ;
4759}
4760
4761static int G__BesVisLib_rootcint_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4762{
4763 ((BesCircle2D*) G__getstructoffset())->SetNSegment((Int_t) G__int(libp->para[0]));
4764 G__setnull(result7);
4765 return(1 || funcname || hash || result7 || libp) ;
4766}
4767
4768static int G__BesVisLib_rootcint_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4769{
4770 G__letint(result7, 85, (long) BesCircle2D::Class());
4771 return(1 || funcname || hash || result7 || libp) ;
4772}
4773
4774static int G__BesVisLib_rootcint_199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4775{
4776 G__letint(result7, 67, (long) BesCircle2D::Class_Name());
4777 return(1 || funcname || hash || result7 || libp) ;
4778}
4779
4780static int G__BesVisLib_rootcint_199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4781{
4782 G__letint(result7, 115, (long) BesCircle2D::Class_Version());
4783 return(1 || funcname || hash || result7 || libp) ;
4784}
4785
4786static int G__BesVisLib_rootcint_199_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4787{
4788 BesCircle2D::Dictionary();
4789 G__setnull(result7);
4790 return(1 || funcname || hash || result7 || libp) ;
4791}
4792
4793static int G__BesVisLib_rootcint_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4794{
4795 ((BesCircle2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
4796 G__setnull(result7);
4797 return(1 || funcname || hash || result7 || libp) ;
4798}
4799
4800static int G__BesVisLib_rootcint_199_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4801{
4802 G__letint(result7, 67, (long) BesCircle2D::DeclFileName());
4803 return(1 || funcname || hash || result7 || libp) ;
4804}
4805
4806static int G__BesVisLib_rootcint_199_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4807{
4808 G__letint(result7, 105, (long) BesCircle2D::ImplFileLine());
4809 return(1 || funcname || hash || result7 || libp) ;
4810}
4811
4812static int G__BesVisLib_rootcint_199_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4813{
4814 G__letint(result7, 67, (long) BesCircle2D::ImplFileName());
4815 return(1 || funcname || hash || result7 || libp) ;
4816}
4817
4818static int G__BesVisLib_rootcint_199_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4819{
4820 G__letint(result7, 105, (long) BesCircle2D::DeclFileLine());
4821 return(1 || funcname || hash || result7 || libp) ;
4822}
4823
4824// automatic copy constructor
4825static int G__BesVisLib_rootcint_199_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4826
4827{
4828 BesCircle2D* p;
4829 void* tmp = (void*) G__int(libp->para[0]);
4830 p = new BesCircle2D(*(BesCircle2D*) tmp);
4831 result7->obj.i = (long) p;
4832 result7->ref = (long) p;
4833 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
4834 return(1 || funcname || hash || result7 || libp) ;
4835}
4836
4837// automatic destructor
4838typedef BesCircle2D G__TBesCircle2D;
4839static int G__BesVisLib_rootcint_199_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4840{
4841 char* gvp = (char*) G__getgvp();
4842 long soff = G__getstructoffset();
4843 int n = G__getaryconstruct();
4844 //
4845 //has_a_delete: 1
4846 //has_own_delete1arg: 0
4847 //has_own_delete2arg: 0
4848 //
4849 if (!soff) {
4850 return(1);
4851 }
4852 if (n) {
4853 if (gvp == (char*)G__PVOID) {
4854 delete[] (BesCircle2D*) soff;
4855 } else {
4856 G__setgvp((long) G__PVOID);
4857 for (int i = n - 1; i >= 0; --i) {
4858 ((BesCircle2D*) (soff+(sizeof(BesCircle2D)*i)))->~G__TBesCircle2D();
4859 }
4860 G__setgvp((long)gvp);
4861 }
4862 } else {
4863 if (gvp == (char*)G__PVOID) {
4864 delete (BesCircle2D*) soff;
4865 } else {
4866 G__setgvp((long) G__PVOID);
4867 ((BesCircle2D*) (soff))->~G__TBesCircle2D();
4868 G__setgvp((long)gvp);
4869 }
4870 }
4871 G__setnull(result7);
4872 return(1 || funcname || hash || result7 || libp) ;
4873}
4874
4875// automatic assignment operator
4876static int G__BesVisLib_rootcint_199_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4877{
4878 BesCircle2D* dest = (BesCircle2D*) G__getstructoffset();
4879 *dest = *(BesCircle2D*) libp->para[0].ref;
4880 const BesCircle2D& obj = *dest;
4881 result7->ref = (long) (&obj);
4882 result7->obj.i = (long) (&obj);
4883 return(1 || funcname || hash || result7 || libp) ;
4884}
4885
4886
4887/* BesCursor */
4888static int G__BesVisLib_rootcint_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4889{
4890 BesCursor* p = NULL;
4891 char* gvp = (char*) G__getgvp();
4892 int n = G__getaryconstruct();
4893 if (n) {
4894 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4895 p = new BesCursor[n];
4896 } else {
4897 p = new((void*) gvp) BesCursor[n];
4898 }
4899 } else {
4900 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
4901 p = new BesCursor;
4902 } else {
4903 p = new((void*) gvp) BesCursor;
4904 }
4905 }
4906 result7->obj.i = (long) p;
4907 result7->ref = (long) p;
4908 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
4909 return(1 || funcname || hash || result7 || libp) ;
4910}
4911
4912static int G__BesVisLib_rootcint_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4913{
4914 ((BesCursor*) G__getstructoffset())->SetType((EBESCursorType) G__int(libp->para[0]));
4915 G__setnull(result7);
4916 return(1 || funcname || hash || result7 || libp) ;
4917}
4918
4919static int G__BesVisLib_rootcint_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4920{
4921 G__letint(result7, 105, (long) ((BesCursor*) G__getstructoffset())->GetType());
4922 return(1 || funcname || hash || result7 || libp) ;
4923}
4924
4925static int G__BesVisLib_rootcint_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4926{
4927 ((BesCursor*) G__getstructoffset())->SetShowInfo((Bool_t) G__int(libp->para[0]));
4928 G__setnull(result7);
4929 return(1 || funcname || hash || result7 || libp) ;
4930}
4931
4932static int G__BesVisLib_rootcint_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4933{
4934 G__letint(result7, 103, (long) ((BesCursor*) G__getstructoffset())->GetShowInfo());
4935 return(1 || funcname || hash || result7 || libp) ;
4936}
4937
4938static int G__BesVisLib_rootcint_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4939{
4940 G__letint(result7, 85, (long) BesCursor::Class());
4941 return(1 || funcname || hash || result7 || libp) ;
4942}
4943
4944static int G__BesVisLib_rootcint_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4945{
4946 G__letint(result7, 67, (long) BesCursor::Class_Name());
4947 return(1 || funcname || hash || result7 || libp) ;
4948}
4949
4950static int G__BesVisLib_rootcint_201_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4951{
4952 G__letint(result7, 115, (long) BesCursor::Class_Version());
4953 return(1 || funcname || hash || result7 || libp) ;
4954}
4955
4956static int G__BesVisLib_rootcint_201_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4957{
4958 BesCursor::Dictionary();
4959 G__setnull(result7);
4960 return(1 || funcname || hash || result7 || libp) ;
4961}
4962
4963static int G__BesVisLib_rootcint_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4964{
4965 ((BesCursor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
4966 G__setnull(result7);
4967 return(1 || funcname || hash || result7 || libp) ;
4968}
4969
4970static int G__BesVisLib_rootcint_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4971{
4972 G__letint(result7, 67, (long) BesCursor::DeclFileName());
4973 return(1 || funcname || hash || result7 || libp) ;
4974}
4975
4976static int G__BesVisLib_rootcint_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4977{
4978 G__letint(result7, 105, (long) BesCursor::ImplFileLine());
4979 return(1 || funcname || hash || result7 || libp) ;
4980}
4981
4982static int G__BesVisLib_rootcint_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4983{
4984 G__letint(result7, 67, (long) BesCursor::ImplFileName());
4985 return(1 || funcname || hash || result7 || libp) ;
4986}
4987
4988static int G__BesVisLib_rootcint_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4989{
4990 G__letint(result7, 105, (long) BesCursor::DeclFileLine());
4991 return(1 || funcname || hash || result7 || libp) ;
4992}
4993
4994// automatic copy constructor
4995static int G__BesVisLib_rootcint_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
4996
4997{
4998 BesCursor* p;
4999 void* tmp = (void*) G__int(libp->para[0]);
5000 p = new BesCursor(*(BesCursor*) tmp);
5001 result7->obj.i = (long) p;
5002 result7->ref = (long) p;
5003 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
5004 return(1 || funcname || hash || result7 || libp) ;
5005}
5006
5007// automatic destructor
5008typedef BesCursor G__TBesCursor;
5009static int G__BesVisLib_rootcint_201_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5010{
5011 char* gvp = (char*) G__getgvp();
5012 long soff = G__getstructoffset();
5013 int n = G__getaryconstruct();
5014 //
5015 //has_a_delete: 1
5016 //has_own_delete1arg: 0
5017 //has_own_delete2arg: 0
5018 //
5019 if (!soff) {
5020 return(1);
5021 }
5022 if (n) {
5023 if (gvp == (char*)G__PVOID) {
5024 delete[] (BesCursor*) soff;
5025 } else {
5026 G__setgvp((long) G__PVOID);
5027 for (int i = n - 1; i >= 0; --i) {
5028 ((BesCursor*) (soff+(sizeof(BesCursor)*i)))->~G__TBesCursor();
5029 }
5030 G__setgvp((long)gvp);
5031 }
5032 } else {
5033 if (gvp == (char*)G__PVOID) {
5034 delete (BesCursor*) soff;
5035 } else {
5036 G__setgvp((long) G__PVOID);
5037 ((BesCursor*) (soff))->~G__TBesCursor();
5038 G__setgvp((long)gvp);
5039 }
5040 }
5041 G__setnull(result7);
5042 return(1 || funcname || hash || result7 || libp) ;
5043}
5044
5045// automatic assignment operator
5046static int G__BesVisLib_rootcint_201_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5047{
5048 BesCursor* dest = (BesCursor*) G__getstructoffset();
5049 *dest = *(BesCursor*) libp->para[0].ref;
5050 const BesCursor& obj = *dest;
5051 result7->ref = (long) (&obj);
5052 result7->obj.i = (long) (&obj);
5053 return(1 || funcname || hash || result7 || libp) ;
5054}
5055
5056
5057/* BesEventHeader */
5058static int G__BesVisLib_rootcint_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5059{
5060 BesEventHeader* p = NULL;
5061 char* gvp = (char*) G__getgvp();
5062 int n = G__getaryconstruct();
5063 if (n) {
5064 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
5065 p = new BesEventHeader[n];
5066 } else {
5067 p = new((void*) gvp) BesEventHeader[n];
5068 }
5069 } else {
5070 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
5071 p = new BesEventHeader;
5072 } else {
5073 p = new((void*) gvp) BesEventHeader;
5074 }
5075 }
5076 result7->obj.i = (long) p;
5077 result7->ref = (long) p;
5078 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
5079 return(1 || funcname || hash || result7 || libp) ;
5080}
5081
5082static int G__BesVisLib_rootcint_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5083{
5084 ((BesEventHeader*) G__getstructoffset())->SetEventHeaderGeneral((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
5085, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
5086 G__setnull(result7);
5087 return(1 || funcname || hash || result7 || libp) ;
5088}
5089
5090static int G__BesVisLib_rootcint_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5091{
5092 ((BesEventHeader*) G__getstructoffset())->SetEventTrig((Int_t) G__int(libp->para[0]), *(vector<Int_t>*) libp->para[1].ref
5093, *(vector<Int_t>*) libp->para[2].ref);
5094 G__setnull(result7);
5095 return(1 || funcname || hash || result7 || libp) ;
5096}
5097
5098static int G__BesVisLib_rootcint_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5099{
5100 ((BesEventHeader*) G__getstructoffset())->SetEventMC((Bool_t) G__int(libp->para[0]));
5101 G__setnull(result7);
5102 return(1 || funcname || hash || result7 || libp) ;
5103}
5104
5105static int G__BesVisLib_rootcint_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5106{
5107 ((BesEventHeader*) G__getstructoffset())->SetEventRec((Bool_t) G__int(libp->para[0]));
5108 G__setnull(result7);
5109 return(1 || funcname || hash || result7 || libp) ;
5110}
5111
5112static int G__BesVisLib_rootcint_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5113{
5114 ((BesEventHeader*) G__getstructoffset())->SetEventEvTime((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
5115, (Double_t) G__double(libp->para[2]));
5116 G__setnull(result7);
5117 return(1 || funcname || hash || result7 || libp) ;
5118}
5119
5120static int G__BesVisLib_rootcint_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5121{
5122 ((BesEventHeader*) G__getstructoffset())->SetEventMdc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
5123, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
5124, (Double_t) G__double(libp->para[4]));
5125 G__setnull(result7);
5126 return(1 || funcname || hash || result7 || libp) ;
5127}
5128
5129static int G__BesVisLib_rootcint_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5130{
5131 ((BesEventHeader*) G__getstructoffset())->SetEventTof((Double_t) G__double(libp->para[0]));
5132 G__setnull(result7);
5133 return(1 || funcname || hash || result7 || libp) ;
5134}
5135
5136static int G__BesVisLib_rootcint_202_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5137{
5138 ((BesEventHeader*) G__getstructoffset())->SetEventEmc((Double_t) G__double(libp->para[0]));
5139 G__setnull(result7);
5140 return(1 || funcname || hash || result7 || libp) ;
5141}
5142
5143static int G__BesVisLib_rootcint_202_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5144{
5145 switch (libp->paran) {
5146 case 4:
5147 ((const BesEventHeader*) G__getstructoffset())->PrintWord(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
5148, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
5149 G__setnull(result7);
5150 break;
5151 case 3:
5152 ((const BesEventHeader*) G__getstructoffset())->PrintWord(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
5153, (Int_t) G__int(libp->para[2]));
5154 G__setnull(result7);
5155 break;
5156 }
5157 return(1 || funcname || hash || result7 || libp) ;
5158}
5159
5160static int G__BesVisLib_rootcint_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5161{
5162 G__letLonglong(result7, 110, (G__int64) ((BesEventHeader*) G__getstructoffset())->GetRunNumber());
5163 return(1 || funcname || hash || result7 || libp) ;
5164}
5165
5166static int G__BesVisLib_rootcint_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5167{
5168 G__letLonglong(result7, 110, (G__int64) ((BesEventHeader*) G__getstructoffset())->GetEventNumber());
5169 return(1 || funcname || hash || result7 || libp) ;
5170}
5171
5172static int G__BesVisLib_rootcint_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5173{
5174 G__letint(result7, 103, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMC());
5175 return(1 || funcname || hash || result7 || libp) ;
5176}
5177
5178static int G__BesVisLib_rootcint_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5179{
5180 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetTimeType());
5181 return(1 || funcname || hash || result7 || libp) ;
5182}
5183
5184static int G__BesVisLib_rootcint_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5185{
5186 {
5187 const vector<Int_t>& obj = ((BesEventHeader*) G__getstructoffset())->GetTrigChannelVector();
5188 result7->ref = (long) (&obj);
5189 result7->obj.i = (long) (&obj);
5190 }
5191 return(1 || funcname || hash || result7 || libp) ;
5192}
5193
5194static int G__BesVisLib_rootcint_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5195{
5196 {
5197 const vector<Int_t>& obj = ((BesEventHeader*) G__getstructoffset())->GetTrigConditionVector();
5198 result7->ref = (long) (&obj);
5199 result7->obj.i = (long) (&obj);
5200 }
5201 return(1 || funcname || hash || result7 || libp) ;
5202}
5203
5204static int G__BesVisLib_rootcint_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5205{
5206 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventYear());
5207 return(1 || funcname || hash || result7 || libp) ;
5208}
5209
5210static int G__BesVisLib_rootcint_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5211{
5212 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMonth());
5213 return(1 || funcname || hash || result7 || libp) ;
5214}
5215
5216static int G__BesVisLib_rootcint_202_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5217{
5218 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventDay());
5219 return(1 || funcname || hash || result7 || libp) ;
5220}
5221
5222static int G__BesVisLib_rootcint_202_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5223{
5224 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventHour());
5225 return(1 || funcname || hash || result7 || libp) ;
5226}
5227
5228static int G__BesVisLib_rootcint_202_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5229{
5230 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMin());
5231 return(1 || funcname || hash || result7 || libp) ;
5232}
5233
5234static int G__BesVisLib_rootcint_202_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5235{
5236 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventSec());
5237 return(1 || funcname || hash || result7 || libp) ;
5238}
5239
5240static int G__BesVisLib_rootcint_202_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5241{
5242 G__letint(result7, 103, (long) ((BesEventHeader*) G__getstructoffset())->GetEventRec());
5243 return(1 || funcname || hash || result7 || libp) ;
5244}
5245
5246static int G__BesVisLib_rootcint_202_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5247{
5248 G__letdouble(result7, 100, (double) ((BesEventHeader*) G__getstructoffset())->GetEvTime());
5249 return(1 || funcname || hash || result7 || libp) ;
5250}
5251
5252static int G__BesVisLib_rootcint_202_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5253{
5254 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEvTimeStatus());
5255 return(1 || funcname || hash || result7 || libp) ;
5256}
5257
5258static int G__BesVisLib_rootcint_202_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5259{
5260 G__letdouble(result7, 100, (double) ((BesEventHeader*) G__getstructoffset())->GetEvTimeQuality());
5261 return(1 || funcname || hash || result7 || libp) ;
5262}
5263
5264static int G__BesVisLib_rootcint_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5265{
5266 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetP());
5267 return(1 || funcname || hash || result7 || libp) ;
5268}
5269
5270static int G__BesVisLib_rootcint_202_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5271{
5272 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPt());
5273 return(1 || funcname || hash || result7 || libp) ;
5274}
5275
5276static int G__BesVisLib_rootcint_202_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5277{
5278 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPx());
5279 return(1 || funcname || hash || result7 || libp) ;
5280}
5281
5282static int G__BesVisLib_rootcint_202_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5283{
5284 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPy());
5285 return(1 || funcname || hash || result7 || libp) ;
5286}
5287
5288static int G__BesVisLib_rootcint_202_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5289{
5290 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPz());
5291 return(1 || funcname || hash || result7 || libp) ;
5292}
5293
5294static int G__BesVisLib_rootcint_202_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5295{
5296 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetT());
5297 return(1 || funcname || hash || result7 || libp) ;
5298}
5299
5300static int G__BesVisLib_rootcint_202_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5301{
5302 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetE());
5303 return(1 || funcname || hash || result7 || libp) ;
5304}
5305
5306static int G__BesVisLib_rootcint_202_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5307{
5308 G__letint(result7, 85, (long) BesEventHeader::Class());
5309 return(1 || funcname || hash || result7 || libp) ;
5310}
5311
5312static int G__BesVisLib_rootcint_202_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5313{
5314 G__letint(result7, 67, (long) BesEventHeader::Class_Name());
5315 return(1 || funcname || hash || result7 || libp) ;
5316}
5317
5318static int G__BesVisLib_rootcint_202_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5319{
5320 G__letint(result7, 115, (long) BesEventHeader::Class_Version());
5321 return(1 || funcname || hash || result7 || libp) ;
5322}
5323
5324static int G__BesVisLib_rootcint_202_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5325{
5326 BesEventHeader::Dictionary();
5327 G__setnull(result7);
5328 return(1 || funcname || hash || result7 || libp) ;
5329}
5330
5331static int G__BesVisLib_rootcint_202_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5332{
5333 ((BesEventHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
5334 G__setnull(result7);
5335 return(1 || funcname || hash || result7 || libp) ;
5336}
5337
5338static int G__BesVisLib_rootcint_202_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5339{
5340 G__letint(result7, 67, (long) BesEventHeader::DeclFileName());
5341 return(1 || funcname || hash || result7 || libp) ;
5342}
5343
5344static int G__BesVisLib_rootcint_202_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5345{
5346 G__letint(result7, 105, (long) BesEventHeader::ImplFileLine());
5347 return(1 || funcname || hash || result7 || libp) ;
5348}
5349
5350static int G__BesVisLib_rootcint_202_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5351{
5352 G__letint(result7, 67, (long) BesEventHeader::ImplFileName());
5353 return(1 || funcname || hash || result7 || libp) ;
5354}
5355
5356static int G__BesVisLib_rootcint_202_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5357{
5358 G__letint(result7, 105, (long) BesEventHeader::DeclFileLine());
5359 return(1 || funcname || hash || result7 || libp) ;
5360}
5361
5362// automatic copy constructor
5363static int G__BesVisLib_rootcint_202_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5364
5365{
5366 BesEventHeader* p;
5367 void* tmp = (void*) G__int(libp->para[0]);
5368 p = new BesEventHeader(*(BesEventHeader*) tmp);
5369 result7->obj.i = (long) p;
5370 result7->ref = (long) p;
5371 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
5372 return(1 || funcname || hash || result7 || libp) ;
5373}
5374
5375// automatic destructor
5376typedef BesEventHeader G__TBesEventHeader;
5377static int G__BesVisLib_rootcint_202_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5378{
5379 char* gvp = (char*) G__getgvp();
5380 long soff = G__getstructoffset();
5381 int n = G__getaryconstruct();
5382 //
5383 //has_a_delete: 1
5384 //has_own_delete1arg: 0
5385 //has_own_delete2arg: 0
5386 //
5387 if (!soff) {
5388 return(1);
5389 }
5390 if (n) {
5391 if (gvp == (char*)G__PVOID) {
5392 delete[] (BesEventHeader*) soff;
5393 } else {
5394 G__setgvp((long) G__PVOID);
5395 for (int i = n - 1; i >= 0; --i) {
5396 ((BesEventHeader*) (soff+(sizeof(BesEventHeader)*i)))->~G__TBesEventHeader();
5397 }
5398 G__setgvp((long)gvp);
5399 }
5400 } else {
5401 if (gvp == (char*)G__PVOID) {
5402 delete (BesEventHeader*) soff;
5403 } else {
5404 G__setgvp((long) G__PVOID);
5405 ((BesEventHeader*) (soff))->~G__TBesEventHeader();
5406 G__setgvp((long)gvp);
5407 }
5408 }
5409 G__setnull(result7);
5410 return(1 || funcname || hash || result7 || libp) ;
5411}
5412
5413// automatic assignment operator
5414static int G__BesVisLib_rootcint_202_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5415{
5416 BesEventHeader* dest = (BesEventHeader*) G__getstructoffset();
5417 *dest = *(BesEventHeader*) libp->para[0].ref;
5418 const BesEventHeader& obj = *dest;
5419 result7->ref = (long) (&obj);
5420 result7->obj.i = (long) (&obj);
5421 return(1 || funcname || hash || result7 || libp) ;
5422}
5423
5424
5425/* BesView */
5426static int G__BesVisLib_rootcint_242_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5427{
5428 BesView* p = NULL;
5429 char* gvp = (char*) G__getgvp();
5430 int n = G__getaryconstruct();
5431 if (n) {
5432 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
5433 p = new BesView[n];
5434 } else {
5435 p = new((void*) gvp) BesView[n];
5436 }
5437 } else {
5438 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
5439 p = new BesView;
5440 } else {
5441 p = new((void*) gvp) BesView;
5442 }
5443 }
5444 result7->obj.i = (long) p;
5445 result7->ref = (long) p;
5446 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
5447 return(1 || funcname || hash || result7 || libp) ;
5448}
5449
5450static int G__BesVisLib_rootcint_242_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5451{
5452 switch (libp->paran) {
5453 case 2:
5454 ((BesView*) G__getstructoffset())->SetViewType((EBESViewType) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
5455 G__setnull(result7);
5456 break;
5457 case 1:
5458 ((BesView*) G__getstructoffset())->SetViewType((EBESViewType) G__int(libp->para[0]));
5459 G__setnull(result7);
5460 break;
5461 }
5462 return(1 || funcname || hash || result7 || libp) ;
5463}
5464
5465static int G__BesVisLib_rootcint_242_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5466{
5467 switch (libp->paran) {
5468 case 2:
5469 ((BesView*) G__getstructoffset())->SetViewTypeBare((EBESViewType) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
5470 G__setnull(result7);
5471 break;
5472 case 1:
5473 ((BesView*) G__getstructoffset())->SetViewTypeBare((EBESViewType) G__int(libp->para[0]));
5474 G__setnull(result7);
5475 break;
5476 }
5477 return(1 || funcname || hash || result7 || libp) ;
5478}
5479
5480static int G__BesVisLib_rootcint_242_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5481{
5482 ((BesView*) G__getstructoffset())->DefaultRange();
5483 G__setnull(result7);
5484 return(1 || funcname || hash || result7 || libp) ;
5485}
5486
5487static int G__BesVisLib_rootcint_242_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5488{
5489 ((BesView*) G__getstructoffset())->ClearPad();
5490 G__setnull(result7);
5491 return(1 || funcname || hash || result7 || libp) ;
5492}
5493
5494static int G__BesVisLib_rootcint_242_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5495{
5496 ((BesView*) G__getstructoffset())->DrawLabel();
5497 G__setnull(result7);
5498 return(1 || funcname || hash || result7 || libp) ;
5499}
5500
5501static int G__BesVisLib_rootcint_242_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5502{
5503 G__letint(result7, 105, (long) ((BesView*) G__getstructoffset())->GetRSign((Float_t) G__double(libp->para[0])));
5504 return(1 || funcname || hash || result7 || libp) ;
5505}
5506
5507static int G__BesVisLib_rootcint_242_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5508{
5509 switch (libp->paran) {
5510 case 1:
5511 ((BesView*) G__getstructoffset())->UpdateView((Bool_t) G__int(libp->para[0]));
5512 G__setnull(result7);
5513 break;
5514 case 0:
5515 ((BesView*) G__getstructoffset())->UpdateView();
5516 G__setnull(result7);
5517 break;
5518 }
5519 return(1 || funcname || hash || result7 || libp) ;
5520}
5521
5522static int G__BesVisLib_rootcint_242_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5523{
5524 ((BesView*) G__getstructoffset())->SetZoomRatio((Double_t) G__double(libp->para[0]));
5525 G__setnull(result7);
5526 return(1 || funcname || hash || result7 || libp) ;
5527}
5528
5529static int G__BesVisLib_rootcint_242_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5530{
5531 G__letdouble(result7, 100, (double) ((BesView*) G__getstructoffset())->GetZoomRatio());
5532 return(1 || funcname || hash || result7 || libp) ;
5533}
5534
5535static int G__BesVisLib_rootcint_242_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5536{
5537 G__letint(result7, 105, (long) ((BesView*) G__getstructoffset())->GetViewType());
5538 return(1 || funcname || hash || result7 || libp) ;
5539}
5540
5541static int G__BesVisLib_rootcint_242_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5542{
5543 G__letdouble(result7, 102, (double) ((BesView*) G__getstructoffset())->GetMarkerSize());
5544 return(1 || funcname || hash || result7 || libp) ;
5545}
5546
5547static int G__BesVisLib_rootcint_242_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5548{
5549 ((BesView*) G__getstructoffset())->View3D();
5550 G__setnull(result7);
5551 return(1 || funcname || hash || result7 || libp) ;
5552}
5553
5554static int G__BesVisLib_rootcint_242_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5555{
5556 ((BesView*) G__getstructoffset())->ViewXY();
5557 G__setnull(result7);
5558 return(1 || funcname || hash || result7 || libp) ;
5559}
5560
5561static int G__BesVisLib_rootcint_242_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5562{
5563 ((BesView*) G__getstructoffset())->ViewZR();
5564 G__setnull(result7);
5565 return(1 || funcname || hash || result7 || libp) ;
5566}
5567
5568static int G__BesVisLib_rootcint_242_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5569{
5570 ((BesView*) G__getstructoffset())->Center();
5571 G__setnull(result7);
5572 return(1 || funcname || hash || result7 || libp) ;
5573}
5574
5575static int G__BesVisLib_rootcint_242_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5576{
5577 ((BesView*) G__getstructoffset())->Move((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
5578 G__setnull(result7);
5579 return(1 || funcname || hash || result7 || libp) ;
5580}
5581
5582static int G__BesVisLib_rootcint_242_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5583{
5584 ((BesView*) G__getstructoffset())->Front3D();
5585 G__setnull(result7);
5586 return(1 || funcname || hash || result7 || libp) ;
5587}
5588
5589static int G__BesVisLib_rootcint_242_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5590{
5591 ((BesView*) G__getstructoffset())->Side3D();
5592 G__setnull(result7);
5593 return(1 || funcname || hash || result7 || libp) ;
5594}
5595
5596static int G__BesVisLib_rootcint_242_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5597{
5598 ((BesView*) G__getstructoffset())->Top3D();
5599 G__setnull(result7);
5600 return(1 || funcname || hash || result7 || libp) ;
5601}
5602
5603static int G__BesVisLib_rootcint_242_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5604{
5605 switch (libp->paran) {
5606 case 2:
5607 ((BesView*) G__getstructoffset())->SetPhiRange((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
5608 G__setnull(result7);
5609 break;
5610 case 1:
5611 ((BesView*) G__getstructoffset())->SetPhiRange((Float_t) G__double(libp->para[0]));
5612 G__setnull(result7);
5613 break;
5614 case 0:
5615 ((BesView*) G__getstructoffset())->SetPhiRange();
5616 G__setnull(result7);
5617 break;
5618 }
5619 return(1 || funcname || hash || result7 || libp) ;
5620}
5621
5622static int G__BesVisLib_rootcint_242_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5623{
5624 ((BesView*) G__getstructoffset())->Reset();
5625 G__setnull(result7);
5626 return(1 || funcname || hash || result7 || libp) ;
5627}
5628
5629static int G__BesVisLib_rootcint_242_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5630{
5631 ((BesView*) G__getstructoffset())->Refresh();
5632 G__setnull(result7);
5633 return(1 || funcname || hash || result7 || libp) ;
5634}
5635
5636static int G__BesVisLib_rootcint_242_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5637{
5638 ((BesView*) G__getstructoffset())->SetMarkerSize((Float_t) G__double(libp->para[0]));
5639 G__setnull(result7);
5640 return(1 || funcname || hash || result7 || libp) ;
5641}
5642
5643static int G__BesVisLib_rootcint_242_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5644{
5645 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemGlobal());
5646 return(1 || funcname || hash || result7 || libp) ;
5647}
5648
5649static int G__BesVisLib_rootcint_242_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5650{
5651 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemLayers());
5652 return(1 || funcname || hash || result7 || libp) ;
5653}
5654
5655static int G__BesVisLib_rootcint_242_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5656{
5657 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemXStrips());
5658 return(1 || funcname || hash || result7 || libp) ;
5659}
5660
5661static int G__BesVisLib_rootcint_242_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5662{
5663 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemVStrips());
5664 return(1 || funcname || hash || result7 || libp) ;
5665}
5666
5667static int G__BesVisLib_rootcint_242_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5668{
5669 ((BesView*) G__getstructoffset())->SetVisCgemGlobal((Bool_t) G__int(libp->para[0]));
5670 G__setnull(result7);
5671 return(1 || funcname || hash || result7 || libp) ;
5672}
5673
5674static int G__BesVisLib_rootcint_242_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5675{
5676 ((BesView*) G__getstructoffset())->SetVisCgemLayers((Bool_t) G__int(libp->para[0]));
5677 G__setnull(result7);
5678 return(1 || funcname || hash || result7 || libp) ;
5679}
5680
5681static int G__BesVisLib_rootcint_242_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5682{
5683 ((BesView*) G__getstructoffset())->SetVisCgemXStrips((Bool_t) G__int(libp->para[0]));
5684 G__setnull(result7);
5685 return(1 || funcname || hash || result7 || libp) ;
5686}
5687
5688static int G__BesVisLib_rootcint_242_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5689{
5690 ((BesView*) G__getstructoffset())->SetVisCgemVStrips((Bool_t) G__int(libp->para[0]));
5691 G__setnull(result7);
5692 return(1 || funcname || hash || result7 || libp) ;
5693}
5694
5695static int G__BesVisLib_rootcint_242_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5696{
5697 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcGlobal());
5698 return(1 || funcname || hash || result7 || libp) ;
5699}
5700
5701static int G__BesVisLib_rootcint_242_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5702{
5703 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcTubes());
5704 return(1 || funcname || hash || result7 || libp) ;
5705}
5706
5707static int G__BesVisLib_rootcint_242_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5708{
5709 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcWires());
5710 return(1 || funcname || hash || result7 || libp) ;
5711}
5712
5713static int G__BesVisLib_rootcint_242_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5714{
5715 ((BesView*) G__getstructoffset())->SetVisMdcGlobal((Bool_t) G__int(libp->para[0]));
5716 G__setnull(result7);
5717 return(1 || funcname || hash || result7 || libp) ;
5718}
5719
5720static int G__BesVisLib_rootcint_242_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5721{
5722 ((BesView*) G__getstructoffset())->SetVisMdcTubes((Bool_t) G__int(libp->para[0]));
5723 G__setnull(result7);
5724 return(1 || funcname || hash || result7 || libp) ;
5725}
5726
5727static int G__BesVisLib_rootcint_242_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5728{
5729 ((BesView*) G__getstructoffset())->SetVisMdcWires((Bool_t) G__int(libp->para[0]));
5730 G__setnull(result7);
5731 return(1 || funcname || hash || result7 || libp) ;
5732}
5733
5734static int G__BesVisLib_rootcint_242_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5735{
5736 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofGlobal());
5737 return(1 || funcname || hash || result7 || libp) ;
5738}
5739
5740static int G__BesVisLib_rootcint_242_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5741{
5742 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofEast());
5743 return(1 || funcname || hash || result7 || libp) ;
5744}
5745
5746static int G__BesVisLib_rootcint_242_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5747{
5748 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofBarrel());
5749 return(1 || funcname || hash || result7 || libp) ;
5750}
5751
5752static int G__BesVisLib_rootcint_242_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5753{
5754 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofWest());
5755 return(1 || funcname || hash || result7 || libp) ;
5756}
5757
5758static int G__BesVisLib_rootcint_242_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5759{
5760 G__letdouble(result7, 102, (double) ((BesView*) G__getstructoffset())->GetVisZoom());
5761 return(1 || funcname || hash || result7 || libp) ;
5762}
5763
5764static int G__BesVisLib_rootcint_242_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5765{
5766 ((BesView*) G__getstructoffset())->SetVisTofGlobal((Bool_t) G__int(libp->para[0]));
5767 G__setnull(result7);
5768 return(1 || funcname || hash || result7 || libp) ;
5769}
5770
5771static int G__BesVisLib_rootcint_242_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5772{
5773 ((BesView*) G__getstructoffset())->SetVisTofEast((Bool_t) G__int(libp->para[0]));
5774 G__setnull(result7);
5775 return(1 || funcname || hash || result7 || libp) ;
5776}
5777
5778static int G__BesVisLib_rootcint_242_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5779{
5780 ((BesView*) G__getstructoffset())->SetVisTofBarrel((Bool_t) G__int(libp->para[0]));
5781 G__setnull(result7);
5782 return(1 || funcname || hash || result7 || libp) ;
5783}
5784
5785static int G__BesVisLib_rootcint_242_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5786{
5787 ((BesView*) G__getstructoffset())->SetVisTofWest((Bool_t) G__int(libp->para[0]));
5788 G__setnull(result7);
5789 return(1 || funcname || hash || result7 || libp) ;
5790}
5791
5792static int G__BesVisLib_rootcint_242_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5793{
5794 ((BesView*) G__getstructoffset())->SetVisZoom((Float_t) G__double(libp->para[0]));
5795 G__setnull(result7);
5796 return(1 || funcname || hash || result7 || libp) ;
5797}
5798
5799static int G__BesVisLib_rootcint_242_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5800{
5801 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcGlobal());
5802 return(1 || funcname || hash || result7 || libp) ;
5803}
5804
5805static int G__BesVisLib_rootcint_242_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5806{
5807 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcEast());
5808 return(1 || funcname || hash || result7 || libp) ;
5809}
5810
5811static int G__BesVisLib_rootcint_242_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5812{
5813 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcBarrel());
5814 return(1 || funcname || hash || result7 || libp) ;
5815}
5816
5817static int G__BesVisLib_rootcint_242_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5818{
5819 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcWest());
5820 return(1 || funcname || hash || result7 || libp) ;
5821}
5822
5823static int G__BesVisLib_rootcint_242_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5824{
5825 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcSide());
5826 return(1 || funcname || hash || result7 || libp) ;
5827}
5828
5829static int G__BesVisLib_rootcint_242_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5830{
5831 ((BesView*) G__getstructoffset())->SetVisEmcGlobal((Bool_t) G__int(libp->para[0]));
5832 G__setnull(result7);
5833 return(1 || funcname || hash || result7 || libp) ;
5834}
5835
5836static int G__BesVisLib_rootcint_242_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5837{
5838 ((BesView*) G__getstructoffset())->SetVisEmcEast((Bool_t) G__int(libp->para[0]));
5839 G__setnull(result7);
5840 return(1 || funcname || hash || result7 || libp) ;
5841}
5842
5843static int G__BesVisLib_rootcint_242_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5844{
5845 ((BesView*) G__getstructoffset())->SetVisEmcBarrel((Bool_t) G__int(libp->para[0]));
5846 G__setnull(result7);
5847 return(1 || funcname || hash || result7 || libp) ;
5848}
5849
5850static int G__BesVisLib_rootcint_242_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5851{
5852 ((BesView*) G__getstructoffset())->SetVisEmcWest((Bool_t) G__int(libp->para[0]));
5853 G__setnull(result7);
5854 return(1 || funcname || hash || result7 || libp) ;
5855}
5856
5857static int G__BesVisLib_rootcint_242_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5858{
5859 ((BesView*) G__getstructoffset())->SetVisEmcSide((Bool_t) G__int(libp->para[0]));
5860 G__setnull(result7);
5861 return(1 || funcname || hash || result7 || libp) ;
5862}
5863
5864static int G__BesVisLib_rootcint_242_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5865{
5866 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucGlobal());
5867 return(1 || funcname || hash || result7 || libp) ;
5868}
5869
5870static int G__BesVisLib_rootcint_242_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5871{
5872 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucEast());
5873 return(1 || funcname || hash || result7 || libp) ;
5874}
5875
5876static int G__BesVisLib_rootcint_242_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5877{
5878 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucBarrel());
5879 return(1 || funcname || hash || result7 || libp) ;
5880}
5881
5882static int G__BesVisLib_rootcint_242_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5883{
5884 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucWest());
5885 return(1 || funcname || hash || result7 || libp) ;
5886}
5887
5888static int G__BesVisLib_rootcint_242_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5889{
5890 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucStrips());
5891 return(1 || funcname || hash || result7 || libp) ;
5892}
5893
5894static int G__BesVisLib_rootcint_242_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5895{
5896 ((BesView*) G__getstructoffset())->SetVisMucGlobal((Bool_t) G__int(libp->para[0]));
5897 G__setnull(result7);
5898 return(1 || funcname || hash || result7 || libp) ;
5899}
5900
5901static int G__BesVisLib_rootcint_242_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5902{
5903 ((BesView*) G__getstructoffset())->SetVisMucEast((Bool_t) G__int(libp->para[0]));
5904 G__setnull(result7);
5905 return(1 || funcname || hash || result7 || libp) ;
5906}
5907
5908static int G__BesVisLib_rootcint_242_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5909{
5910 ((BesView*) G__getstructoffset())->SetVisMucBarrel((Bool_t) G__int(libp->para[0]));
5911 G__setnull(result7);
5912 return(1 || funcname || hash || result7 || libp) ;
5913}
5914
5915static int G__BesVisLib_rootcint_242_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5916{
5917 ((BesView*) G__getstructoffset())->SetVisMucWest((Bool_t) G__int(libp->para[0]));
5918 G__setnull(result7);
5919 return(1 || funcname || hash || result7 || libp) ;
5920}
5921
5922static int G__BesVisLib_rootcint_242_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5923{
5924 ((BesView*) G__getstructoffset())->SetVisMucStrips((Bool_t) G__int(libp->para[0]));
5925 G__setnull(result7);
5926 return(1 || funcname || hash || result7 || libp) ;
5927}
5928
5929static int G__BesVisLib_rootcint_242_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5930{
5931 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DCgem());
5932 return(1 || funcname || hash || result7 || libp) ;
5933}
5934
5935static int G__BesVisLib_rootcint_242_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5936{
5937 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DMdc());
5938 return(1 || funcname || hash || result7 || libp) ;
5939}
5940
5941static int G__BesVisLib_rootcint_242_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5942{
5943 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DTof());
5944 return(1 || funcname || hash || result7 || libp) ;
5945}
5946
5947static int G__BesVisLib_rootcint_242_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5948{
5949 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DEmc());
5950 return(1 || funcname || hash || result7 || libp) ;
5951}
5952
5953static int G__BesVisLib_rootcint_242_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5954{
5955 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DMuc());
5956 return(1 || funcname || hash || result7 || libp) ;
5957}
5958
5959static int G__BesVisLib_rootcint_242_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5960{
5961 ((BesView*) G__getstructoffset())->SetVisFull3DCgem((Bool_t) G__int(libp->para[0]));
5962 G__setnull(result7);
5963 return(1 || funcname || hash || result7 || libp) ;
5964}
5965
5966static int G__BesVisLib_rootcint_242_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5967{
5968 ((BesView*) G__getstructoffset())->SetVisFull3DMdc((Bool_t) G__int(libp->para[0]));
5969 G__setnull(result7);
5970 return(1 || funcname || hash || result7 || libp) ;
5971}
5972
5973static int G__BesVisLib_rootcint_242_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5974{
5975 ((BesView*) G__getstructoffset())->SetVisFull3DTof((Bool_t) G__int(libp->para[0]));
5976 G__setnull(result7);
5977 return(1 || funcname || hash || result7 || libp) ;
5978}
5979
5980static int G__BesVisLib_rootcint_242_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5981{
5982 ((BesView*) G__getstructoffset())->SetVisFull3DEmc((Bool_t) G__int(libp->para[0]));
5983 G__setnull(result7);
5984 return(1 || funcname || hash || result7 || libp) ;
5985}
5986
5987static int G__BesVisLib_rootcint_242_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5988{
5989 ((BesView*) G__getstructoffset())->SetVisFull3DMuc((Bool_t) G__int(libp->para[0]));
5990 G__setnull(result7);
5991 return(1 || funcname || hash || result7 || libp) ;
5992}
5993
5994static int G__BesVisLib_rootcint_242_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
5995{
5996 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisBeamPipe());
5997 return(1 || funcname || hash || result7 || libp) ;
5998}
5999
6000static int G__BesVisLib_rootcint_242_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6001{
6002 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisZRPlaneOnXY());
6003 return(1 || funcname || hash || result7 || libp) ;
6004}
6005
6006static int G__BesVisLib_rootcint_242_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6007{
6008 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisAxis());
6009 return(1 || funcname || hash || result7 || libp) ;
6010}
6011
6012static int G__BesVisLib_rootcint_242_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6013{
6014 ((BesView*) G__getstructoffset())->SetVisBeamPipe((Bool_t) G__int(libp->para[0]));
6015 G__setnull(result7);
6016 return(1 || funcname || hash || result7 || libp) ;
6017}
6018
6019static int G__BesVisLib_rootcint_242_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6020{
6021 ((BesView*) G__getstructoffset())->SetVisZRPlaneOnXY((Bool_t) G__int(libp->para[0]));
6022 G__setnull(result7);
6023 return(1 || funcname || hash || result7 || libp) ;
6024}
6025
6026static int G__BesVisLib_rootcint_242_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6027{
6028 ((BesView*) G__getstructoffset())->SetVisAxis((Bool_t) G__int(libp->para[0]));
6029 G__setnull(result7);
6030 return(1 || funcname || hash || result7 || libp) ;
6031}
6032
6033static int G__BesVisLib_rootcint_242_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6034{
6035 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemHitsGlobal());
6036 return(1 || funcname || hash || result7 || libp) ;
6037}
6038
6039static int G__BesVisLib_rootcint_242_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6040{
6041 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemHitsXStrip());
6042 return(1 || funcname || hash || result7 || libp) ;
6043}
6044
6045static int G__BesVisLib_rootcint_242_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6046{
6047 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemHitsVStrip());
6048 return(1 || funcname || hash || result7 || libp) ;
6049}
6050
6051static int G__BesVisLib_rootcint_242_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6052{
6053 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisCgemHitsClusters());
6054 return(1 || funcname || hash || result7 || libp) ;
6055}
6056
6057static int G__BesVisLib_rootcint_242_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6058{
6059 ((BesView*) G__getstructoffset())->SetVisCgemHitsGlobal((Bool_t) G__int(libp->para[0]));
6060 G__setnull(result7);
6061 return(1 || funcname || hash || result7 || libp) ;
6062}
6063
6064static int G__BesVisLib_rootcint_242_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6065{
6066 ((BesView*) G__getstructoffset())->SetVisCgemHitsXStrip((Bool_t) G__int(libp->para[0]));
6067 G__setnull(result7);
6068 return(1 || funcname || hash || result7 || libp) ;
6069}
6070
6071static int G__BesVisLib_rootcint_242_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6072{
6073 ((BesView*) G__getstructoffset())->SetVisCgemHitsVStrip((Bool_t) G__int(libp->para[0]));
6074 G__setnull(result7);
6075 return(1 || funcname || hash || result7 || libp) ;
6076}
6077
6078static int G__BesVisLib_rootcint_242_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6079{
6080 ((BesView*) G__getstructoffset())->SetVisCgemHitsClusters((Bool_t) G__int(libp->para[0]));
6081 G__setnull(result7);
6082 return(1 || funcname || hash || result7 || libp) ;
6083}
6084
6085static int G__BesVisLib_rootcint_242_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6086{
6087 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcHitsGlobal());
6088 return(1 || funcname || hash || result7 || libp) ;
6089}
6090
6091static int G__BesVisLib_rootcint_242_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6092{
6093 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcHits());
6094 return(1 || funcname || hash || result7 || libp) ;
6095}
6096
6097static int G__BesVisLib_rootcint_242_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6098{
6099 ((BesView*) G__getstructoffset())->SetVisMdcHitsGlobal((Bool_t) G__int(libp->para[0]));
6100 G__setnull(result7);
6101 return(1 || funcname || hash || result7 || libp) ;
6102}
6103
6104static int G__BesVisLib_rootcint_242_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6105{
6106 ((BesView*) G__getstructoffset())->SetVisMdcHits((Bool_t) G__int(libp->para[0]));
6107 G__setnull(result7);
6108 return(1 || funcname || hash || result7 || libp) ;
6109}
6110
6111static int G__BesVisLib_rootcint_242_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6112{
6113 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsGlobal());
6114 return(1 || funcname || hash || result7 || libp) ;
6115}
6116
6117static int G__BesVisLib_rootcint_242_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6118{
6119 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsEast());
6120 return(1 || funcname || hash || result7 || libp) ;
6121}
6122
6123static int G__BesVisLib_rootcint_242_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6124{
6125 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsBarrel());
6126 return(1 || funcname || hash || result7 || libp) ;
6127}
6128
6129static int G__BesVisLib_rootcint_242_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6130{
6131 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsWest());
6132 return(1 || funcname || hash || result7 || libp) ;
6133}
6134
6135static int G__BesVisLib_rootcint_242_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6136{
6137 ((BesView*) G__getstructoffset())->SetVisTofHitsGlobal((Bool_t) G__int(libp->para[0]));
6138 G__setnull(result7);
6139 return(1 || funcname || hash || result7 || libp) ;
6140}
6141
6142static int G__BesVisLib_rootcint_242_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6143{
6144 ((BesView*) G__getstructoffset())->SetVisTofHitsEast((Bool_t) G__int(libp->para[0]));
6145 G__setnull(result7);
6146 return(1 || funcname || hash || result7 || libp) ;
6147}
6148
6149static int G__BesVisLib_rootcint_242_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6150{
6151 ((BesView*) G__getstructoffset())->SetVisTofHitsBarrel((Bool_t) G__int(libp->para[0]));
6152 G__setnull(result7);
6153 return(1 || funcname || hash || result7 || libp) ;
6154}
6155
6156static int G__BesVisLib_rootcint_242_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6157{
6158 ((BesView*) G__getstructoffset())->SetVisTofHitsWest((Bool_t) G__int(libp->para[0]));
6159 G__setnull(result7);
6160 return(1 || funcname || hash || result7 || libp) ;
6161}
6162
6163static int G__BesVisLib_rootcint_242_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6164{
6165 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsGlobal());
6166 return(1 || funcname || hash || result7 || libp) ;
6167}
6168
6169static int G__BesVisLib_rootcint_242_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6170{
6171 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsEast());
6172 return(1 || funcname || hash || result7 || libp) ;
6173}
6174
6175static int G__BesVisLib_rootcint_242_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6176{
6177 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsBarrel());
6178 return(1 || funcname || hash || result7 || libp) ;
6179}
6180
6181static int G__BesVisLib_rootcint_242_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6182{
6183 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsWest());
6184 return(1 || funcname || hash || result7 || libp) ;
6185}
6186
6187static int G__BesVisLib_rootcint_242_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6188{
6189 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsSide());
6190 return(1 || funcname || hash || result7 || libp) ;
6191}
6192
6193static int G__BesVisLib_rootcint_242_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6194{
6195 ((BesView*) G__getstructoffset())->SetVisEmcHitsGlobal((Bool_t) G__int(libp->para[0]));
6196 G__setnull(result7);
6197 return(1 || funcname || hash || result7 || libp) ;
6198}
6199
6200static int G__BesVisLib_rootcint_242_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6201{
6202 ((BesView*) G__getstructoffset())->SetVisEmcHitsEast((Bool_t) G__int(libp->para[0]));
6203 G__setnull(result7);
6204 return(1 || funcname || hash || result7 || libp) ;
6205}
6206
6207static int G__BesVisLib_rootcint_242_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6208{
6209 ((BesView*) G__getstructoffset())->SetVisEmcHitsBarrel((Bool_t) G__int(libp->para[0]));
6210 G__setnull(result7);
6211 return(1 || funcname || hash || result7 || libp) ;
6212}
6213
6214static int G__BesVisLib_rootcint_242_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6215{
6216 ((BesView*) G__getstructoffset())->SetVisEmcHitsWest((Bool_t) G__int(libp->para[0]));
6217 G__setnull(result7);
6218 return(1 || funcname || hash || result7 || libp) ;
6219}
6220
6221static int G__BesVisLib_rootcint_242_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6222{
6223 ((BesView*) G__getstructoffset())->SetVisEmcHitsSide((Bool_t) G__int(libp->para[0]));
6224 G__setnull(result7);
6225 return(1 || funcname || hash || result7 || libp) ;
6226}
6227
6228static int G__BesVisLib_rootcint_242_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6229{
6230 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsGlobal());
6231 return(1 || funcname || hash || result7 || libp) ;
6232}
6233
6234static int G__BesVisLib_rootcint_242_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6235{
6236 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsEast());
6237 return(1 || funcname || hash || result7 || libp) ;
6238}
6239
6240static int G__BesVisLib_rootcint_242_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6241{
6242 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsBarrel());
6243 return(1 || funcname || hash || result7 || libp) ;
6244}
6245
6246static int G__BesVisLib_rootcint_242_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6247{
6248 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsWest());
6249 return(1 || funcname || hash || result7 || libp) ;
6250}
6251
6252static int G__BesVisLib_rootcint_242_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6253{
6254 ((BesView*) G__getstructoffset())->SetVisMucHitsGlobal((Bool_t) G__int(libp->para[0]));
6255 G__setnull(result7);
6256 return(1 || funcname || hash || result7 || libp) ;
6257}
6258
6259static int G__BesVisLib_rootcint_242_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6260{
6261 ((BesView*) G__getstructoffset())->SetVisMucHitsEast((Bool_t) G__int(libp->para[0]));
6262 G__setnull(result7);
6263 return(1 || funcname || hash || result7 || libp) ;
6264}
6265
6266static int G__BesVisLib_rootcint_242_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6267{
6268 ((BesView*) G__getstructoffset())->SetVisMucHitsBarrel((Bool_t) G__int(libp->para[0]));
6269 G__setnull(result7);
6270 return(1 || funcname || hash || result7 || libp) ;
6271}
6272
6273static int G__BesVisLib_rootcint_242_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6274{
6275 ((BesView*) G__getstructoffset())->SetVisMucHitsWest((Bool_t) G__int(libp->para[0]));
6276 G__setnull(result7);
6277 return(1 || funcname || hash || result7 || libp) ;
6278}
6279
6280static int G__BesVisLib_rootcint_242_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6281{
6282 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksGlobal());
6283 return(1 || funcname || hash || result7 || libp) ;
6284}
6285
6286static int G__BesVisLib_rootcint_242_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6287{
6288 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksMdc());
6289 return(1 || funcname || hash || result7 || libp) ;
6290}
6291
6292static int G__BesVisLib_rootcint_242_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6293{
6294 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksTof());
6295 return(1 || funcname || hash || result7 || libp) ;
6296}
6297
6298static int G__BesVisLib_rootcint_242_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6299{
6300 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksEmc());
6301 return(1 || funcname || hash || result7 || libp) ;
6302}
6303
6304static int G__BesVisLib_rootcint_242_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6305{
6306 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksMuc());
6307 return(1 || funcname || hash || result7 || libp) ;
6308}
6309
6310static int G__BesVisLib_rootcint_242_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6311{
6312 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksExt());
6313 return(1 || funcname || hash || result7 || libp) ;
6314}
6315
6316static int G__BesVisLib_rootcint_242_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6317{
6318 ((BesView*) G__getstructoffset())->SetVisTracksGlobal((Bool_t) G__int(libp->para[0]));
6319 G__setnull(result7);
6320 return(1 || funcname || hash || result7 || libp) ;
6321}
6322
6323static int G__BesVisLib_rootcint_242_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6324{
6325 ((BesView*) G__getstructoffset())->SetVisTracksMdc((Bool_t) G__int(libp->para[0]));
6326 G__setnull(result7);
6327 return(1 || funcname || hash || result7 || libp) ;
6328}
6329
6330static int G__BesVisLib_rootcint_242_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6331{
6332 ((BesView*) G__getstructoffset())->SetVisTracksTof((Bool_t) G__int(libp->para[0]));
6333 G__setnull(result7);
6334 return(1 || funcname || hash || result7 || libp) ;
6335}
6336
6337static int G__BesVisLib_rootcint_242_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6338{
6339 ((BesView*) G__getstructoffset())->SetVisTracksEmc((Bool_t) G__int(libp->para[0]));
6340 G__setnull(result7);
6341 return(1 || funcname || hash || result7 || libp) ;
6342}
6343
6344static int G__BesVisLib_rootcint_242_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6345{
6346 ((BesView*) G__getstructoffset())->SetVisTracksMuc((Bool_t) G__int(libp->para[0]));
6347 G__setnull(result7);
6348 return(1 || funcname || hash || result7 || libp) ;
6349}
6350
6351static int G__BesVisLib_rootcint_242_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6352{
6353 ((BesView*) G__getstructoffset())->SetVisTracksExt((Bool_t) G__int(libp->para[0]));
6354 G__setnull(result7);
6355 return(1 || funcname || hash || result7 || libp) ;
6356}
6357
6358static int G__BesVisLib_rootcint_242_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6359{
6360 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetFishEyeStatus());
6361 return(1 || funcname || hash || result7 || libp) ;
6362}
6363
6364static int G__BesVisLib_rootcint_242_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6365{
6366 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetFishEye());
6367 return(1 || funcname || hash || result7 || libp) ;
6368}
6369
6370static int G__BesVisLib_rootcint_242_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6371{
6372 switch (libp->paran) {
6373 case 1:
6374 ((BesView*) G__getstructoffset())->SetFishEye((Bool_t) G__int(libp->para[0]));
6375 G__setnull(result7);
6376 break;
6377 case 0:
6378 ((BesView*) G__getstructoffset())->SetFishEye();
6379 G__setnull(result7);
6380 break;
6381 }
6382 return(1 || funcname || hash || result7 || libp) ;
6383}
6384
6385static int G__BesVisLib_rootcint_242_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6386{
6387 ((BesView*) G__getstructoffset())->PrintCurrent();
6388 G__setnull(result7);
6389 return(1 || funcname || hash || result7 || libp) ;
6390}
6391
6392static int G__BesVisLib_rootcint_242_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6393{
6394 ((BesView*) G__getstructoffset())->DrawClass();
6395 G__setnull(result7);
6396 return(1 || funcname || hash || result7 || libp) ;
6397}
6398
6399static int G__BesVisLib_rootcint_242_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6400{
6401 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
6402 return(1 || funcname || hash || result7 || libp) ;
6403}
6404
6405static int G__BesVisLib_rootcint_242_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6406{
6407 ((BesView*) G__getstructoffset())->Dump();
6408 G__setnull(result7);
6409 return(1 || funcname || hash || result7 || libp) ;
6410}
6411
6412static int G__BesVisLib_rootcint_242_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6413{
6414 ((BesView*) G__getstructoffset())->Inspect();
6415 G__setnull(result7);
6416 return(1 || funcname || hash || result7 || libp) ;
6417}
6418
6419static int G__BesVisLib_rootcint_242_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6420{
6421 ((BesView*) G__getstructoffset())->SetZoomFactor((Double_t) G__double(libp->para[0]));
6422 G__setnull(result7);
6423 return(1 || funcname || hash || result7 || libp) ;
6424}
6425
6426static int G__BesVisLib_rootcint_242_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6427{
6428 G__letdouble(result7, 100, (double) ((BesView*) G__getstructoffset())->GetZoomFactor());
6429 return(1 || funcname || hash || result7 || libp) ;
6430}
6431
6432static int G__BesVisLib_rootcint_242_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6433{
6434 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusCurrent());
6435 return(1 || funcname || hash || result7 || libp) ;
6436}
6437
6438static int G__BesVisLib_rootcint_242_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6439{
6440 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatus3D());
6441 return(1 || funcname || hash || result7 || libp) ;
6442}
6443
6444static int G__BesVisLib_rootcint_242_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6445{
6446 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusXY());
6447 return(1 || funcname || hash || result7 || libp) ;
6448}
6449
6450static int G__BesVisLib_rootcint_242_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6451{
6452 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusZR());
6453 return(1 || funcname || hash || result7 || libp) ;
6454}
6455
6456static int G__BesVisLib_rootcint_242_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6457{
6458 G__letint(result7, 85, (long) BesView::Class());
6459 return(1 || funcname || hash || result7 || libp) ;
6460}
6461
6462static int G__BesVisLib_rootcint_242_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6463{
6464 G__letint(result7, 67, (long) BesView::Class_Name());
6465 return(1 || funcname || hash || result7 || libp) ;
6466}
6467
6468static int G__BesVisLib_rootcint_242_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6469{
6470 G__letint(result7, 115, (long) BesView::Class_Version());
6471 return(1 || funcname || hash || result7 || libp) ;
6472}
6473
6474static int G__BesVisLib_rootcint_242_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6475{
6476 BesView::Dictionary();
6477 G__setnull(result7);
6478 return(1 || funcname || hash || result7 || libp) ;
6479}
6480
6481static int G__BesVisLib_rootcint_242_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6482{
6483 ((BesView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
6484 G__setnull(result7);
6485 return(1 || funcname || hash || result7 || libp) ;
6486}
6487
6488static int G__BesVisLib_rootcint_242_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6489{
6490 G__letint(result7, 67, (long) BesView::DeclFileName());
6491 return(1 || funcname || hash || result7 || libp) ;
6492}
6493
6494static int G__BesVisLib_rootcint_242_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6495{
6496 G__letint(result7, 105, (long) BesView::ImplFileLine());
6497 return(1 || funcname || hash || result7 || libp) ;
6498}
6499
6500static int G__BesVisLib_rootcint_242_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6501{
6502 G__letint(result7, 67, (long) BesView::ImplFileName());
6503 return(1 || funcname || hash || result7 || libp) ;
6504}
6505
6506static int G__BesVisLib_rootcint_242_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6507{
6508 G__letint(result7, 105, (long) BesView::DeclFileLine());
6509 return(1 || funcname || hash || result7 || libp) ;
6510}
6511
6512// automatic copy constructor
6513static int G__BesVisLib_rootcint_242_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6514
6515{
6516 BesView* p;
6517 void* tmp = (void*) G__int(libp->para[0]);
6518 p = new BesView(*(BesView*) tmp);
6519 result7->obj.i = (long) p;
6520 result7->ref = (long) p;
6521 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
6522 return(1 || funcname || hash || result7 || libp) ;
6523}
6524
6525// automatic destructor
6526typedef BesView G__TBesView;
6527static int G__BesVisLib_rootcint_242_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6528{
6529 char* gvp = (char*) G__getgvp();
6530 long soff = G__getstructoffset();
6531 int n = G__getaryconstruct();
6532 //
6533 //has_a_delete: 1
6534 //has_own_delete1arg: 0
6535 //has_own_delete2arg: 0
6536 //
6537 if (!soff) {
6538 return(1);
6539 }
6540 if (n) {
6541 if (gvp == (char*)G__PVOID) {
6542 delete[] (BesView*) soff;
6543 } else {
6544 G__setgvp((long) G__PVOID);
6545 for (int i = n - 1; i >= 0; --i) {
6546 ((BesView*) (soff+(sizeof(BesView)*i)))->~G__TBesView();
6547 }
6548 G__setgvp((long)gvp);
6549 }
6550 } else {
6551 if (gvp == (char*)G__PVOID) {
6552 delete (BesView*) soff;
6553 } else {
6554 G__setgvp((long) G__PVOID);
6555 ((BesView*) (soff))->~G__TBesView();
6556 G__setgvp((long)gvp);
6557 }
6558 }
6559 G__setnull(result7);
6560 return(1 || funcname || hash || result7 || libp) ;
6561}
6562
6563
6564/* BesMarker2D */
6565static int G__BesVisLib_rootcint_243_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6566{
6567 BesMarker2D* p = NULL;
6568 char* gvp = (char*) G__getgvp();
6569 int n = G__getaryconstruct();
6570 if (n) {
6571 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6572 p = new BesMarker2D[n];
6573 } else {
6574 p = new((void*) gvp) BesMarker2D[n];
6575 }
6576 } else {
6577 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6578 p = new BesMarker2D;
6579 } else {
6580 p = new((void*) gvp) BesMarker2D;
6581 }
6582 }
6583 result7->obj.i = (long) p;
6584 result7->ref = (long) p;
6585 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
6586 return(1 || funcname || hash || result7 || libp) ;
6587}
6588
6589static int G__BesVisLib_rootcint_243_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6590{
6591 BesMarker2D* p = NULL;
6592 char* gvp = (char*) G__getgvp();
6593 //m: 5
6594 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6595 p = new BesMarker2D(
6596(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
6597, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
6598, (Float_t) G__double(libp->para[4]));
6599 } else {
6600 p = new((void*) gvp) BesMarker2D(
6601(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
6602, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
6603, (Float_t) G__double(libp->para[4]));
6604 }
6605 result7->obj.i = (long) p;
6606 result7->ref = (long) p;
6607 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
6608 return(1 || funcname || hash || result7 || libp) ;
6609}
6610
6611static int G__BesVisLib_rootcint_243_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6612{
6613 BesMarker2D* p = NULL;
6614 char* gvp = (char*) G__getgvp();
6615 //m: 5
6616 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6617 p = new BesMarker2D(
6618(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
6619, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
6620, (Double_t) G__double(libp->para[4]));
6621 } else {
6622 p = new((void*) gvp) BesMarker2D(
6623(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
6624, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
6625, (Double_t) G__double(libp->para[4]));
6626 }
6627 result7->obj.i = (long) p;
6628 result7->ref = (long) p;
6629 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
6630 return(1 || funcname || hash || result7 || libp) ;
6631}
6632
6633static int G__BesVisLib_rootcint_243_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6634{
6635 ((BesMarker2D*) G__getstructoffset())->GetCenterPixel(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
6636 G__setnull(result7);
6637 return(1 || funcname || hash || result7 || libp) ;
6638}
6639
6640static int G__BesVisLib_rootcint_243_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6641{
6642 ((BesMarker2D*) G__getstructoffset())->SetMarkerSizeMultiple((Int_t) G__int(libp->para[0]));
6643 G__setnull(result7);
6644 return(1 || funcname || hash || result7 || libp) ;
6645}
6646
6647static int G__BesVisLib_rootcint_243_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6648{
6649 G__letint(result7, 105, (long) ((BesMarker2D*) G__getstructoffset())->GetMarkerSizeMultiple());
6650 return(1 || funcname || hash || result7 || libp) ;
6651}
6652
6653static int G__BesVisLib_rootcint_243_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6654{
6655 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCX());
6656 return(1 || funcname || hash || result7 || libp) ;
6657}
6658
6659static int G__BesVisLib_rootcint_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6660{
6661 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCY());
6662 return(1 || funcname || hash || result7 || libp) ;
6663}
6664
6665static int G__BesVisLib_rootcint_243_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6666{
6667 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCZ());
6668 return(1 || funcname || hash || result7 || libp) ;
6669}
6670
6671static int G__BesVisLib_rootcint_243_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6672{
6673 ((BesMarker2D*) G__getstructoffset())->SetWCX((Float_t) G__double(libp->para[0]));
6674 G__setnull(result7);
6675 return(1 || funcname || hash || result7 || libp) ;
6676}
6677
6678static int G__BesVisLib_rootcint_243_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6679{
6680 ((BesMarker2D*) G__getstructoffset())->SetWCY((Float_t) G__double(libp->para[0]));
6681 G__setnull(result7);
6682 return(1 || funcname || hash || result7 || libp) ;
6683}
6684
6685static int G__BesVisLib_rootcint_243_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6686{
6687 ((BesMarker2D*) G__getstructoffset())->SetWCZ((Float_t) G__double(libp->para[0]));
6688 G__setnull(result7);
6689 return(1 || funcname || hash || result7 || libp) ;
6690}
6691
6692static int G__BesVisLib_rootcint_243_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6693{
6694 ((BesMarker2D*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
6695, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
6696, (Float_t) G__double(libp->para[4]));
6697 G__setnull(result7);
6698 return(1 || funcname || hash || result7 || libp) ;
6699}
6700
6701static int G__BesVisLib_rootcint_243_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6702{
6703 G__letint(result7, 85, (long) BesMarker2D::Class());
6704 return(1 || funcname || hash || result7 || libp) ;
6705}
6706
6707static int G__BesVisLib_rootcint_243_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6708{
6709 G__letint(result7, 67, (long) BesMarker2D::Class_Name());
6710 return(1 || funcname || hash || result7 || libp) ;
6711}
6712
6713static int G__BesVisLib_rootcint_243_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6714{
6715 G__letint(result7, 115, (long) BesMarker2D::Class_Version());
6716 return(1 || funcname || hash || result7 || libp) ;
6717}
6718
6719static int G__BesVisLib_rootcint_243_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6720{
6721 BesMarker2D::Dictionary();
6722 G__setnull(result7);
6723 return(1 || funcname || hash || result7 || libp) ;
6724}
6725
6726static int G__BesVisLib_rootcint_243_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6727{
6728 ((BesMarker2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
6729 G__setnull(result7);
6730 return(1 || funcname || hash || result7 || libp) ;
6731}
6732
6733static int G__BesVisLib_rootcint_243_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6734{
6735 G__letint(result7, 67, (long) BesMarker2D::DeclFileName());
6736 return(1 || funcname || hash || result7 || libp) ;
6737}
6738
6739static int G__BesVisLib_rootcint_243_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6740{
6741 G__letint(result7, 105, (long) BesMarker2D::ImplFileLine());
6742 return(1 || funcname || hash || result7 || libp) ;
6743}
6744
6745static int G__BesVisLib_rootcint_243_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6746{
6747 G__letint(result7, 67, (long) BesMarker2D::ImplFileName());
6748 return(1 || funcname || hash || result7 || libp) ;
6749}
6750
6751static int G__BesVisLib_rootcint_243_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6752{
6753 G__letint(result7, 105, (long) BesMarker2D::DeclFileLine());
6754 return(1 || funcname || hash || result7 || libp) ;
6755}
6756
6757// automatic copy constructor
6758static int G__BesVisLib_rootcint_243_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6759
6760{
6761 BesMarker2D* p;
6762 void* tmp = (void*) G__int(libp->para[0]);
6763 p = new BesMarker2D(*(BesMarker2D*) tmp);
6764 result7->obj.i = (long) p;
6765 result7->ref = (long) p;
6766 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
6767 return(1 || funcname || hash || result7 || libp) ;
6768}
6769
6770// automatic destructor
6771typedef BesMarker2D G__TBesMarker2D;
6772static int G__BesVisLib_rootcint_243_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6773{
6774 char* gvp = (char*) G__getgvp();
6775 long soff = G__getstructoffset();
6776 int n = G__getaryconstruct();
6777 //
6778 //has_a_delete: 1
6779 //has_own_delete1arg: 0
6780 //has_own_delete2arg: 0
6781 //
6782 if (!soff) {
6783 return(1);
6784 }
6785 if (n) {
6786 if (gvp == (char*)G__PVOID) {
6787 delete[] (BesMarker2D*) soff;
6788 } else {
6789 G__setgvp((long) G__PVOID);
6790 for (int i = n - 1; i >= 0; --i) {
6791 ((BesMarker2D*) (soff+(sizeof(BesMarker2D)*i)))->~G__TBesMarker2D();
6792 }
6793 G__setgvp((long)gvp);
6794 }
6795 } else {
6796 if (gvp == (char*)G__PVOID) {
6797 delete (BesMarker2D*) soff;
6798 } else {
6799 G__setgvp((long) G__PVOID);
6800 ((BesMarker2D*) (soff))->~G__TBesMarker2D();
6801 G__setgvp((long)gvp);
6802 }
6803 }
6804 G__setnull(result7);
6805 return(1 || funcname || hash || result7 || libp) ;
6806}
6807
6808// automatic assignment operator
6809static int G__BesVisLib_rootcint_243_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6810{
6811 BesMarker2D* dest = (BesMarker2D*) G__getstructoffset();
6812 *dest = *(BesMarker2D*) libp->para[0].ref;
6813 const BesMarker2D& obj = *dest;
6814 result7->ref = (long) (&obj);
6815 result7->obj.i = (long) (&obj);
6816 return(1 || funcname || hash || result7 || libp) ;
6817}
6818
6819
6820/* BesPaveText */
6821static int G__BesVisLib_rootcint_244_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6822{
6823 BesPaveText* p = NULL;
6824 char* gvp = (char*) G__getgvp();
6825 int n = G__getaryconstruct();
6826 if (n) {
6827 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6828 p = new BesPaveText[n];
6829 } else {
6830 p = new((void*) gvp) BesPaveText[n];
6831 }
6832 } else {
6833 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6834 p = new BesPaveText;
6835 } else {
6836 p = new((void*) gvp) BesPaveText;
6837 }
6838 }
6839 result7->obj.i = (long) p;
6840 result7->ref = (long) p;
6841 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
6842 return(1 || funcname || hash || result7 || libp) ;
6843}
6844
6845static int G__BesVisLib_rootcint_244_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6846{
6847 BesPaveText* p = NULL;
6848 char* gvp = (char*) G__getgvp();
6849 switch (libp->paran) {
6850 case 5:
6851 //m: 5
6852 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6853 p = new BesPaveText(
6854(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
6855, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
6856, (Option_t*) G__int(libp->para[4]));
6857 } else {
6858 p = new((void*) gvp) BesPaveText(
6859(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
6860, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
6861, (Option_t*) G__int(libp->para[4]));
6862 }
6863 break;
6864 case 4:
6865 //m: 4
6866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6867 p = new BesPaveText(
6868(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
6869, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
6870 } else {
6871 p = new((void*) gvp) BesPaveText(
6872(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
6873, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
6874 }
6875 break;
6876 }
6877 result7->obj.i = (long) p;
6878 result7->ref = (long) p;
6879 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
6880 return(1 || funcname || hash || result7 || libp) ;
6881}
6882
6883static int G__BesVisLib_rootcint_244_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6884{
6885 BesPaveText* p = NULL;
6886 char* gvp = (char*) G__getgvp();
6887 //m: 1
6888 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
6889 p = new BesPaveText(*(BesPaveText*) libp->para[0].ref);
6890 } else {
6891 p = new((void*) gvp) BesPaveText(*(BesPaveText*) libp->para[0].ref);
6892 }
6893 result7->obj.i = (long) p;
6894 result7->ref = (long) p;
6895 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
6896 return(1 || funcname || hash || result7 || libp) ;
6897}
6898
6899static int G__BesVisLib_rootcint_244_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6900{
6901 ((BesPaveText*) G__getstructoffset())->SetText(*((vector<TString>*) G__int(libp->para[0])));
6902 G__setnull(result7);
6903 return(1 || funcname || hash || result7 || libp) ;
6904}
6905
6906static int G__BesVisLib_rootcint_244_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6907{
6908 ((BesPaveText*) G__getstructoffset())->SetPos((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
6909 G__setnull(result7);
6910 return(1 || funcname || hash || result7 || libp) ;
6911}
6912
6913static int G__BesVisLib_rootcint_244_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6914{
6915 G__letint(result7, 85, (long) BesPaveText::Class());
6916 return(1 || funcname || hash || result7 || libp) ;
6917}
6918
6919static int G__BesVisLib_rootcint_244_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6920{
6921 G__letint(result7, 67, (long) BesPaveText::Class_Name());
6922 return(1 || funcname || hash || result7 || libp) ;
6923}
6924
6925static int G__BesVisLib_rootcint_244_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6926{
6927 G__letint(result7, 115, (long) BesPaveText::Class_Version());
6928 return(1 || funcname || hash || result7 || libp) ;
6929}
6930
6931static int G__BesVisLib_rootcint_244_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6932{
6933 BesPaveText::Dictionary();
6934 G__setnull(result7);
6935 return(1 || funcname || hash || result7 || libp) ;
6936}
6937
6938static int G__BesVisLib_rootcint_244_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6939{
6940 ((BesPaveText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
6941 G__setnull(result7);
6942 return(1 || funcname || hash || result7 || libp) ;
6943}
6944
6945static int G__BesVisLib_rootcint_244_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6946{
6947 G__letint(result7, 67, (long) BesPaveText::DeclFileName());
6948 return(1 || funcname || hash || result7 || libp) ;
6949}
6950
6951static int G__BesVisLib_rootcint_244_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6952{
6953 G__letint(result7, 105, (long) BesPaveText::ImplFileLine());
6954 return(1 || funcname || hash || result7 || libp) ;
6955}
6956
6957static int G__BesVisLib_rootcint_244_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6958{
6959 G__letint(result7, 67, (long) BesPaveText::ImplFileName());
6960 return(1 || funcname || hash || result7 || libp) ;
6961}
6962
6963static int G__BesVisLib_rootcint_244_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6964{
6965 G__letint(result7, 105, (long) BesPaveText::DeclFileLine());
6966 return(1 || funcname || hash || result7 || libp) ;
6967}
6968
6969// automatic destructor
6970typedef BesPaveText G__TBesPaveText;
6971static int G__BesVisLib_rootcint_244_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
6972{
6973 char* gvp = (char*) G__getgvp();
6974 long soff = G__getstructoffset();
6975 int n = G__getaryconstruct();
6976 //
6977 //has_a_delete: 1
6978 //has_own_delete1arg: 0
6979 //has_own_delete2arg: 0
6980 //
6981 if (!soff) {
6982 return(1);
6983 }
6984 if (n) {
6985 if (gvp == (char*)G__PVOID) {
6986 delete[] (BesPaveText*) soff;
6987 } else {
6988 G__setgvp((long) G__PVOID);
6989 for (int i = n - 1; i >= 0; --i) {
6990 ((BesPaveText*) (soff+(sizeof(BesPaveText)*i)))->~G__TBesPaveText();
6991 }
6992 G__setgvp((long)gvp);
6993 }
6994 } else {
6995 if (gvp == (char*)G__PVOID) {
6996 delete (BesPaveText*) soff;
6997 } else {
6998 G__setgvp((long) G__PVOID);
6999 ((BesPaveText*) (soff))->~G__TBesPaveText();
7000 G__setgvp((long)gvp);
7001 }
7002 }
7003 G__setnull(result7);
7004 return(1 || funcname || hash || result7 || libp) ;
7005}
7006
7007// automatic assignment operator
7008static int G__BesVisLib_rootcint_244_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7009{
7010 BesPaveText* dest = (BesPaveText*) G__getstructoffset();
7011 *dest = *(BesPaveText*) libp->para[0].ref;
7012 const BesPaveText& obj = *dest;
7013 result7->ref = (long) (&obj);
7014 result7->obj.i = (long) (&obj);
7015 return(1 || funcname || hash || result7 || libp) ;
7016}
7017
7018
7019/* BesGeoTrack */
7020static int G__BesVisLib_rootcint_249_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7021{
7022 BesGeoTrack* p = NULL;
7023 char* gvp = (char*) G__getgvp();
7024 int n = G__getaryconstruct();
7025 if (n) {
7026 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7027 p = new BesGeoTrack[n];
7028 } else {
7029 p = new((void*) gvp) BesGeoTrack[n];
7030 }
7031 } else {
7032 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7033 p = new BesGeoTrack;
7034 } else {
7035 p = new((void*) gvp) BesGeoTrack;
7036 }
7037 }
7038 result7->obj.i = (long) p;
7039 result7->ref = (long) p;
7040 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
7041 return(1 || funcname || hash || result7 || libp) ;
7042}
7043
7044static int G__BesVisLib_rootcint_249_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7045{
7046 BesGeoTrack* p = NULL;
7047 char* gvp = (char*) G__getgvp();
7048 switch (libp->paran) {
7049 case 4:
7050 //m: 4
7051 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7052 p = new BesGeoTrack(
7053(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
7054, (TVirtualGeoTrack*) G__int(libp->para[2]), (TObject*) G__int(libp->para[3]));
7055 } else {
7056 p = new((void*) gvp) BesGeoTrack(
7057(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
7058, (TVirtualGeoTrack*) G__int(libp->para[2]), (TObject*) G__int(libp->para[3]));
7059 }
7060 break;
7061 case 3:
7062 //m: 3
7063 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7064 p = new BesGeoTrack(
7065(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
7066, (TVirtualGeoTrack*) G__int(libp->para[2]));
7067 } else {
7068 p = new((void*) gvp) BesGeoTrack(
7069(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
7070, (TVirtualGeoTrack*) G__int(libp->para[2]));
7071 }
7072 break;
7073 case 2:
7074 //m: 2
7075 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7076 p = new BesGeoTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
7077 } else {
7078 p = new((void*) gvp) BesGeoTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
7079 }
7080 break;
7081 }
7082 result7->obj.i = (long) p;
7083 result7->ref = (long) p;
7084 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
7085 return(1 || funcname || hash || result7 || libp) ;
7086}
7087
7088static int G__BesVisLib_rootcint_249_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7089{
7090 ((BesGeoTrack*) G__getstructoffset())->Init();
7091 G__setnull(result7);
7092 return(1 || funcname || hash || result7 || libp) ;
7093}
7094
7095static int G__BesVisLib_rootcint_249_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7096{
7097 ((BesGeoTrack*) G__getstructoffset())->AddHit((TObject*) G__int(libp->para[0]));
7098 G__setnull(result7);
7099 return(1 || funcname || hash || result7 || libp) ;
7100}
7101
7102static int G__BesVisLib_rootcint_249_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7103{
7104 ((BesGeoTrack*) G__getstructoffset())->Add3DHit((TObject*) G__int(libp->para[0]));
7105 G__setnull(result7);
7106 return(1 || funcname || hash || result7 || libp) ;
7107}
7108
7109static int G__BesVisLib_rootcint_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7110{
7111 ((BesGeoTrack*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
7112 G__setnull(result7);
7113 return(1 || funcname || hash || result7 || libp) ;
7114}
7115
7116static int G__BesVisLib_rootcint_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7117{
7118 ((BesGeoTrack*) G__getstructoffset())->CloseInfo();
7119 G__setnull(result7);
7120 return(1 || funcname || hash || result7 || libp) ;
7121}
7122
7123static int G__BesVisLib_rootcint_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7124{
7125 ((BesGeoTrack*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
7126 G__setnull(result7);
7127 return(1 || funcname || hash || result7 || libp) ;
7128}
7129
7130static int G__BesVisLib_rootcint_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7131{
7132 ((BesGeoTrack*) G__getstructoffset())->SetTrackType((Int_t) G__int(libp->para[0]));
7133 G__setnull(result7);
7134 return(1 || funcname || hash || result7 || libp) ;
7135}
7136
7137static int G__BesVisLib_rootcint_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7138{
7139 ((BesGeoTrack*) G__getstructoffset())->SetMarker((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
7140, (Double_t) G__double(libp->para[2]));
7141 G__setnull(result7);
7142 return(1 || funcname || hash || result7 || libp) ;
7143}
7144
7145static int G__BesVisLib_rootcint_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7146{
7147 ((BesGeoTrack*) G__getstructoffset())->Construct3DLine();
7148 G__setnull(result7);
7149 return(1 || funcname || hash || result7 || libp) ;
7150}
7151
7152static int G__BesVisLib_rootcint_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7153{
7154 G__letint(result7, 85, (long) BesGeoTrack::Class());
7155 return(1 || funcname || hash || result7 || libp) ;
7156}
7157
7158static int G__BesVisLib_rootcint_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7159{
7160 G__letint(result7, 67, (long) BesGeoTrack::Class_Name());
7161 return(1 || funcname || hash || result7 || libp) ;
7162}
7163
7164static int G__BesVisLib_rootcint_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7165{
7166 G__letint(result7, 115, (long) BesGeoTrack::Class_Version());
7167 return(1 || funcname || hash || result7 || libp) ;
7168}
7169
7170static int G__BesVisLib_rootcint_249_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7171{
7172 BesGeoTrack::Dictionary();
7173 G__setnull(result7);
7174 return(1 || funcname || hash || result7 || libp) ;
7175}
7176
7177static int G__BesVisLib_rootcint_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7178{
7179 ((BesGeoTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
7180 G__setnull(result7);
7181 return(1 || funcname || hash || result7 || libp) ;
7182}
7183
7184static int G__BesVisLib_rootcint_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7185{
7186 G__letint(result7, 67, (long) BesGeoTrack::DeclFileName());
7187 return(1 || funcname || hash || result7 || libp) ;
7188}
7189
7190static int G__BesVisLib_rootcint_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7191{
7192 G__letint(result7, 105, (long) BesGeoTrack::ImplFileLine());
7193 return(1 || funcname || hash || result7 || libp) ;
7194}
7195
7196static int G__BesVisLib_rootcint_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7197{
7198 G__letint(result7, 67, (long) BesGeoTrack::ImplFileName());
7199 return(1 || funcname || hash || result7 || libp) ;
7200}
7201
7202static int G__BesVisLib_rootcint_249_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7203{
7204 G__letint(result7, 105, (long) BesGeoTrack::DeclFileLine());
7205 return(1 || funcname || hash || result7 || libp) ;
7206}
7207
7208// automatic destructor
7209typedef BesGeoTrack G__TBesGeoTrack;
7210static int G__BesVisLib_rootcint_249_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7211{
7212 char* gvp = (char*) G__getgvp();
7213 long soff = G__getstructoffset();
7214 int n = G__getaryconstruct();
7215 //
7216 //has_a_delete: 1
7217 //has_own_delete1arg: 0
7218 //has_own_delete2arg: 0
7219 //
7220 if (!soff) {
7221 return(1);
7222 }
7223 if (n) {
7224 if (gvp == (char*)G__PVOID) {
7225 delete[] (BesGeoTrack*) soff;
7226 } else {
7227 G__setgvp((long) G__PVOID);
7228 for (int i = n - 1; i >= 0; --i) {
7229 ((BesGeoTrack*) (soff+(sizeof(BesGeoTrack)*i)))->~G__TBesGeoTrack();
7230 }
7231 G__setgvp((long)gvp);
7232 }
7233 } else {
7234 if (gvp == (char*)G__PVOID) {
7235 delete (BesGeoTrack*) soff;
7236 } else {
7237 G__setgvp((long) G__PVOID);
7238 ((BesGeoTrack*) (soff))->~G__TBesGeoTrack();
7239 G__setgvp((long)gvp);
7240 }
7241 }
7242 G__setnull(result7);
7243 return(1 || funcname || hash || result7 || libp) ;
7244}
7245
7246
7247/* BesEvent */
7248static int G__BesVisLib_rootcint_529_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7249{
7250 BesEvent* p = NULL;
7251 char* gvp = (char*) G__getgvp();
7252 int n = G__getaryconstruct();
7253 if (n) {
7254 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7255 p = new BesEvent[n];
7256 } else {
7257 p = new((void*) gvp) BesEvent[n];
7258 }
7259 } else {
7260 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7261 p = new BesEvent;
7262 } else {
7263 p = new((void*) gvp) BesEvent;
7264 }
7265 }
7266 result7->obj.i = (long) p;
7267 result7->ref = (long) p;
7268 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
7269 return(1 || funcname || hash || result7 || libp) ;
7270}
7271
7272static int G__BesVisLib_rootcint_529_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7273{
7274 switch (libp->paran) {
7275 case 1:
7276 ((BesEvent*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
7277 G__setnull(result7);
7278 break;
7279 case 0:
7280 ((BesEvent*) G__getstructoffset())->Print();
7281 G__setnull(result7);
7282 break;
7283 }
7284 return(1 || funcname || hash || result7 || libp) ;
7285}
7286
7287static int G__BesVisLib_rootcint_529_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7288{
7289 ((BesEvent*) G__getstructoffset())->SetEvent((TDigiEvent*) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])
7290, (TEvtHeader*) G__int(libp->para[2]), (TRecEvTime*) G__int(libp->para[3])
7291, (Bool_t) G__int(libp->para[4]));
7292 G__setnull(result7);
7293 return(1 || funcname || hash || result7 || libp) ;
7294}
7295
7296static int G__BesVisLib_rootcint_529_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7297{
7298 ((BesEvent*) G__getstructoffset())->SetHits();
7299 G__setnull(result7);
7300 return(1 || funcname || hash || result7 || libp) ;
7301}
7302
7303static int G__BesVisLib_rootcint_529_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7304{
7305 ((BesEvent*) G__getstructoffset())->SetTracks((TDisTrack*) G__int(libp->para[0]));
7306 G__setnull(result7);
7307 return(1 || funcname || hash || result7 || libp) ;
7308}
7309
7310static int G__BesVisLib_rootcint_529_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7311{
7312 ((BesEvent*) G__getstructoffset())->SetMdcTracks((TDisTrack*) G__int(libp->para[0]));
7313 G__setnull(result7);
7314 return(1 || funcname || hash || result7 || libp) ;
7315}
7316
7317static int G__BesVisLib_rootcint_529_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7318{
7319 ((BesEvent*) G__getstructoffset())->SetTofTracks((TDisTrack*) G__int(libp->para[0]));
7320 G__setnull(result7);
7321 return(1 || funcname || hash || result7 || libp) ;
7322}
7323
7324static int G__BesVisLib_rootcint_529_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7325{
7326 ((BesEvent*) G__getstructoffset())->SetEmcShowers((TDisTrack*) G__int(libp->para[0]));
7327 G__setnull(result7);
7328 return(1 || funcname || hash || result7 || libp) ;
7329}
7330
7331static int G__BesVisLib_rootcint_529_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7332{
7333 ((BesEvent*) G__getstructoffset())->SetMucTracks((TDisTrack*) G__int(libp->para[0]));
7334 G__setnull(result7);
7335 return(1 || funcname || hash || result7 || libp) ;
7336}
7337
7338static int G__BesVisLib_rootcint_529_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7339{
7340 ((BesEvent*) G__getstructoffset())->SetExtTracks((TDisTrack*) G__int(libp->para[0]));
7341 G__setnull(result7);
7342 return(1 || funcname || hash || result7 || libp) ;
7343}
7344
7345static int G__BesVisLib_rootcint_529_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7346{
7347 ((BesEvent*) G__getstructoffset())->ConstructMdcTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecMdcTrack*) G__int(libp->para[1])
7348, (TDisTrack*) G__int(libp->para[2]));
7349 G__setnull(result7);
7350 return(1 || funcname || hash || result7 || libp) ;
7351}
7352
7353static int G__BesVisLib_rootcint_529_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7354{
7355 ((BesEvent*) G__getstructoffset())->ConstructMucTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecMucTrack*) G__int(libp->para[1]));
7356 G__setnull(result7);
7357 return(1 || funcname || hash || result7 || libp) ;
7358}
7359
7360static int G__BesVisLib_rootcint_529_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7361{
7362 ((BesEvent*) G__getstructoffset())->ConstructEmcTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecEmcShower*) G__int(libp->para[1]));
7363 G__setnull(result7);
7364 return(1 || funcname || hash || result7 || libp) ;
7365}
7366
7367static int G__BesVisLib_rootcint_529_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7368{
7369 ((BesEvent*) G__getstructoffset())->ConstructTofTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecTofTrack*) G__int(libp->para[1])
7370, (TDisTrack*) G__int(libp->para[2]));
7371 G__setnull(result7);
7372 return(1 || funcname || hash || result7 || libp) ;
7373}
7374
7375static int G__BesVisLib_rootcint_529_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7376{
7377 ((BesEvent*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
7378 G__setnull(result7);
7379 return(1 || funcname || hash || result7 || libp) ;
7380}
7381
7382static int G__BesVisLib_rootcint_529_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7383{
7384 ((BesEvent*) G__getstructoffset())->DrawTracks((Option_t*) G__int(libp->para[0]));
7385 G__setnull(result7);
7386 return(1 || funcname || hash || result7 || libp) ;
7387}
7388
7389static int G__BesVisLib_rootcint_529_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7390{
7391 ((BesEvent*) G__getstructoffset())->SetMagnetic((Double_t) G__double(libp->para[0]));
7392 G__setnull(result7);
7393 return(1 || funcname || hash || result7 || libp) ;
7394}
7395
7396static int G__BesVisLib_rootcint_529_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7397{
7398 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigiCol());
7399 return(1 || funcname || hash || result7 || libp) ;
7400}
7401
7402static int G__BesVisLib_rootcint_529_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7403{
7404 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigiCol());
7405 return(1 || funcname || hash || result7 || libp) ;
7406}
7407
7408static int G__BesVisLib_rootcint_529_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7409{
7410 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigiCol());
7411 return(1 || funcname || hash || result7 || libp) ;
7412}
7413
7414static int G__BesVisLib_rootcint_529_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7415{
7416 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigiCol());
7417 return(1 || funcname || hash || result7 || libp) ;
7418}
7419
7420static int G__BesVisLib_rootcint_529_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7421{
7422 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigiNum());
7423 return(1 || funcname || hash || result7 || libp) ;
7424}
7425
7426static int G__BesVisLib_rootcint_529_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7427{
7428 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigiNum());
7429 return(1 || funcname || hash || result7 || libp) ;
7430}
7431
7432static int G__BesVisLib_rootcint_529_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7433{
7434 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigiNum());
7435 return(1 || funcname || hash || result7 || libp) ;
7436}
7437
7438static int G__BesVisLib_rootcint_529_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7439{
7440 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigiNum());
7441 return(1 || funcname || hash || result7 || libp) ;
7442}
7443
7444static int G__BesVisLib_rootcint_529_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7445{
7446 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigi((Int_t) G__int(libp->para[0])));
7447 return(1 || funcname || hash || result7 || libp) ;
7448}
7449
7450static int G__BesVisLib_rootcint_529_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7451{
7452 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigi((Int_t) G__int(libp->para[0])));
7453 return(1 || funcname || hash || result7 || libp) ;
7454}
7455
7456static int G__BesVisLib_rootcint_529_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7457{
7458 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigi((Int_t) G__int(libp->para[0])));
7459 return(1 || funcname || hash || result7 || libp) ;
7460}
7461
7462static int G__BesVisLib_rootcint_529_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7463{
7464 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigi((Int_t) G__int(libp->para[0])));
7465 return(1 || funcname || hash || result7 || libp) ;
7466}
7467
7468static int G__BesVisLib_rootcint_529_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7469{
7470 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrackCol((TDisTrack*) G__int(libp->para[0])));
7471 return(1 || funcname || hash || result7 || libp) ;
7472}
7473
7474static int G__BesVisLib_rootcint_529_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7475{
7476 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrackCol((TDisTrack*) G__int(libp->para[0])));
7477 return(1 || funcname || hash || result7 || libp) ;
7478}
7479
7480static int G__BesVisLib_rootcint_529_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7481{
7482 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShowerCol((TDisTrack*) G__int(libp->para[0])));
7483 return(1 || funcname || hash || result7 || libp) ;
7484}
7485
7486static int G__BesVisLib_rootcint_529_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7487{
7488 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrackCol((TDisTrack*) G__int(libp->para[0])));
7489 return(1 || funcname || hash || result7 || libp) ;
7490}
7491
7492static int G__BesVisLib_rootcint_529_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7493{
7494 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetExtTrackCol());
7495 return(1 || funcname || hash || result7 || libp) ;
7496}
7497
7498static int G__BesVisLib_rootcint_529_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7499{
7500 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetDedxCol((TDisTrack*) G__int(libp->para[0])));
7501 return(1 || funcname || hash || result7 || libp) ;
7502}
7503
7504static int G__BesVisLib_rootcint_529_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7505{
7506 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrackNum((TDisTrack*) G__int(libp->para[0])));
7507 return(1 || funcname || hash || result7 || libp) ;
7508}
7509
7510static int G__BesVisLib_rootcint_529_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7511{
7512 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrackNum((TDisTrack*) G__int(libp->para[0])));
7513 return(1 || funcname || hash || result7 || libp) ;
7514}
7515
7516static int G__BesVisLib_rootcint_529_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7517{
7518 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShowerNum((TDisTrack*) G__int(libp->para[0])));
7519 return(1 || funcname || hash || result7 || libp) ;
7520}
7521
7522static int G__BesVisLib_rootcint_529_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7523{
7524 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrackNum((TDisTrack*) G__int(libp->para[0])));
7525 return(1 || funcname || hash || result7 || libp) ;
7526}
7527
7528static int G__BesVisLib_rootcint_529_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7529{
7530 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetExtTrackNum());
7531 return(1 || funcname || hash || result7 || libp) ;
7532}
7533
7534static int G__BesVisLib_rootcint_529_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7535{
7536 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetDedxNum((TDisTrack*) G__int(libp->para[0])));
7537 return(1 || funcname || hash || result7 || libp) ;
7538}
7539
7540static int G__BesVisLib_rootcint_529_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7541{
7542 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
7543 return(1 || funcname || hash || result7 || libp) ;
7544}
7545
7546static int G__BesVisLib_rootcint_529_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7547{
7548 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
7549 return(1 || funcname || hash || result7 || libp) ;
7550}
7551
7552static int G__BesVisLib_rootcint_529_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7553{
7554 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShower((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
7555 return(1 || funcname || hash || result7 || libp) ;
7556}
7557
7558static int G__BesVisLib_rootcint_529_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7559{
7560 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
7561 return(1 || funcname || hash || result7 || libp) ;
7562}
7563
7564static int G__BesVisLib_rootcint_529_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7565{
7566 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetDedx((Int_t) G__int(libp->para[0])));
7567 return(1 || funcname || hash || result7 || libp) ;
7568}
7569
7570static int G__BesVisLib_rootcint_529_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7571{
7572 G__letLonglong(result7, 110, (G__int64) ((BesEvent*) G__getstructoffset())->GetRun());
7573 return(1 || funcname || hash || result7 || libp) ;
7574}
7575
7576static int G__BesVisLib_rootcint_529_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7577{
7578 G__letLonglong(result7, 110, (G__int64) ((BesEvent*) G__getstructoffset())->GetEvent());
7579 return(1 || funcname || hash || result7 || libp) ;
7580}
7581
7582static int G__BesVisLib_rootcint_529_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7583{
7584 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetYear());
7585 return(1 || funcname || hash || result7 || libp) ;
7586}
7587
7588static int G__BesVisLib_rootcint_529_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7589{
7590 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMonth());
7591 return(1 || funcname || hash || result7 || libp) ;
7592}
7593
7594static int G__BesVisLib_rootcint_529_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7595{
7596 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetDay());
7597 return(1 || funcname || hash || result7 || libp) ;
7598}
7599
7600static int G__BesVisLib_rootcint_529_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7601{
7602 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetHour());
7603 return(1 || funcname || hash || result7 || libp) ;
7604}
7605
7606static int G__BesVisLib_rootcint_529_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7607{
7608 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMin());
7609 return(1 || funcname || hash || result7 || libp) ;
7610}
7611
7612static int G__BesVisLib_rootcint_529_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7613{
7614 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetSec());
7615 return(1 || funcname || hash || result7 || libp) ;
7616}
7617
7618static int G__BesVisLib_rootcint_529_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7619{
7620 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMC());
7621 return(1 || funcname || hash || result7 || libp) ;
7622}
7623
7624static int G__BesVisLib_rootcint_529_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7625{
7626 {
7627 BesEventHeader* pobj;
7628 BesEventHeader xobj = ((BesEvent*) G__getstructoffset())->GetHeader();
7629 pobj = new BesEventHeader(xobj);
7630 result7->obj.i = (long) ((void*) pobj);
7631 result7->ref = result7->obj.i;
7632 G__store_tempobject(*result7);
7633 }
7634 return(1 || funcname || hash || result7 || libp) ;
7635}
7636
7637static int G__BesVisLib_rootcint_529_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7638{
7639 G__letint(result7, 85, (long) BesEvent::Class());
7640 return(1 || funcname || hash || result7 || libp) ;
7641}
7642
7643static int G__BesVisLib_rootcint_529_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7644{
7645 G__letint(result7, 67, (long) BesEvent::Class_Name());
7646 return(1 || funcname || hash || result7 || libp) ;
7647}
7648
7649static int G__BesVisLib_rootcint_529_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7650{
7651 G__letint(result7, 115, (long) BesEvent::Class_Version());
7652 return(1 || funcname || hash || result7 || libp) ;
7653}
7654
7655static int G__BesVisLib_rootcint_529_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7656{
7657 BesEvent::Dictionary();
7658 G__setnull(result7);
7659 return(1 || funcname || hash || result7 || libp) ;
7660}
7661
7662static int G__BesVisLib_rootcint_529_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7663{
7664 ((BesEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
7665 G__setnull(result7);
7666 return(1 || funcname || hash || result7 || libp) ;
7667}
7668
7669static int G__BesVisLib_rootcint_529_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7670{
7671 G__letint(result7, 67, (long) BesEvent::DeclFileName());
7672 return(1 || funcname || hash || result7 || libp) ;
7673}
7674
7675static int G__BesVisLib_rootcint_529_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7676{
7677 G__letint(result7, 105, (long) BesEvent::ImplFileLine());
7678 return(1 || funcname || hash || result7 || libp) ;
7679}
7680
7681static int G__BesVisLib_rootcint_529_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7682{
7683 G__letint(result7, 67, (long) BesEvent::ImplFileName());
7684 return(1 || funcname || hash || result7 || libp) ;
7685}
7686
7687static int G__BesVisLib_rootcint_529_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7688{
7689 G__letint(result7, 105, (long) BesEvent::DeclFileLine());
7690 return(1 || funcname || hash || result7 || libp) ;
7691}
7692
7693// automatic copy constructor
7694static int G__BesVisLib_rootcint_529_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7695
7696{
7697 BesEvent* p;
7698 void* tmp = (void*) G__int(libp->para[0]);
7699 p = new BesEvent(*(BesEvent*) tmp);
7700 result7->obj.i = (long) p;
7701 result7->ref = (long) p;
7702 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
7703 return(1 || funcname || hash || result7 || libp) ;
7704}
7705
7706// automatic destructor
7707typedef BesEvent G__TBesEvent;
7708static int G__BesVisLib_rootcint_529_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7709{
7710 char* gvp = (char*) G__getgvp();
7711 long soff = G__getstructoffset();
7712 int n = G__getaryconstruct();
7713 //
7714 //has_a_delete: 1
7715 //has_own_delete1arg: 0
7716 //has_own_delete2arg: 0
7717 //
7718 if (!soff) {
7719 return(1);
7720 }
7721 if (n) {
7722 if (gvp == (char*)G__PVOID) {
7723 delete[] (BesEvent*) soff;
7724 } else {
7725 G__setgvp((long) G__PVOID);
7726 for (int i = n - 1; i >= 0; --i) {
7727 ((BesEvent*) (soff+(sizeof(BesEvent)*i)))->~G__TBesEvent();
7728 }
7729 G__setgvp((long)gvp);
7730 }
7731 } else {
7732 if (gvp == (char*)G__PVOID) {
7733 delete (BesEvent*) soff;
7734 } else {
7735 G__setgvp((long) G__PVOID);
7736 ((BesEvent*) (soff))->~G__TBesEvent();
7737 G__setgvp((long)gvp);
7738 }
7739 }
7740 G__setnull(result7);
7741 return(1 || funcname || hash || result7 || libp) ;
7742}
7743
7744// automatic assignment operator
7745static int G__BesVisLib_rootcint_529_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7746{
7747 BesEvent* dest = (BesEvent*) G__getstructoffset();
7748 *dest = *(BesEvent*) libp->para[0].ref;
7749 const BesEvent& obj = *dest;
7750 result7->ref = (long) (&obj);
7751 result7->obj.i = (long) (&obj);
7752 return(1 || funcname || hash || result7 || libp) ;
7753}
7754
7755
7756/* SubDetectorROOTGeo */
7757static int G__BesVisLib_rootcint_798_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7758{
7759 SubDetectorROOTGeo* p = NULL;
7760 char* gvp = (char*) G__getgvp();
7761 int n = G__getaryconstruct();
7762 if (n) {
7763 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7764 p = new SubDetectorROOTGeo[n];
7765 } else {
7766 p = new((void*) gvp) SubDetectorROOTGeo[n];
7767 }
7768 } else {
7769 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7770 p = new SubDetectorROOTGeo;
7771 } else {
7772 p = new((void*) gvp) SubDetectorROOTGeo;
7773 }
7774 }
7775 result7->obj.i = (long) p;
7776 result7->ref = (long) p;
7777 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
7778 return(1 || funcname || hash || result7 || libp) ;
7779}
7780
7781static int G__BesVisLib_rootcint_798_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7782{
7783 ((SubDetectorROOTGeo*) G__getstructoffset())->ReadGdml((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
7784 G__setnull(result7);
7785 return(1 || funcname || hash || result7 || libp) ;
7786}
7787
7788static int G__BesVisLib_rootcint_798_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7789{
7790 G__letint(result7, 105, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->IsInitialized());
7791 return(1 || funcname || hash || result7 || libp) ;
7792}
7793
7794static int G__BesVisLib_rootcint_798_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7795{
7796 ((SubDetectorROOTGeo*) G__getstructoffset())->SetChildNo((int) G__int(libp->para[0]));
7797 G__setnull(result7);
7798 return(1 || funcname || hash || result7 || libp) ;
7799}
7800
7801static int G__BesVisLib_rootcint_798_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7802{
7803 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetLogicalVolume(*(string*) libp->para[0].ref));
7804 return(1 || funcname || hash || result7 || libp) ;
7805}
7806
7807static int G__BesVisLib_rootcint_798_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7808{
7809 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetTopVolume());
7810 return(1 || funcname || hash || result7 || libp) ;
7811}
7812
7813static int G__BesVisLib_rootcint_798_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7814{
7815 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetAssemblyVolume(*(string*) libp->para[0].ref));
7816 return(1 || funcname || hash || result7 || libp) ;
7817}
7818
7819static int G__BesVisLib_rootcint_798_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7820{
7821 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetNode(*(string*) libp->para[0].ref));
7822 return(1 || funcname || hash || result7 || libp) ;
7823}
7824
7825static int G__BesVisLib_rootcint_798_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7826{
7827 G__letint(result7, 105, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetHitsNum());
7828 return(1 || funcname || hash || result7 || libp) ;
7829}
7830
7831static int G__BesVisLib_rootcint_798_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7832{
7833 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetHit((int) G__int(libp->para[0])));
7834 return(1 || funcname || hash || result7 || libp) ;
7835}
7836
7837static int G__BesVisLib_rootcint_798_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7838{
7839 ((SubDetectorROOTGeo*) G__getstructoffset())->SetDetectorOn();
7840 G__setnull(result7);
7841 return(1 || funcname || hash || result7 || libp) ;
7842}
7843
7844// automatic copy constructor
7845static int G__BesVisLib_rootcint_798_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7846
7847{
7848 SubDetectorROOTGeo* p;
7849 void* tmp = (void*) G__int(libp->para[0]);
7850 p = new SubDetectorROOTGeo(*(SubDetectorROOTGeo*) tmp);
7851 result7->obj.i = (long) p;
7852 result7->ref = (long) p;
7853 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
7854 return(1 || funcname || hash || result7 || libp) ;
7855}
7856
7857// automatic destructor
7858typedef SubDetectorROOTGeo G__TSubDetectorROOTGeo;
7859static int G__BesVisLib_rootcint_798_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7860{
7861 char* gvp = (char*) G__getgvp();
7862 long soff = G__getstructoffset();
7863 int n = G__getaryconstruct();
7864 //
7865 //has_a_delete: 0
7866 //has_own_delete1arg: 0
7867 //has_own_delete2arg: 0
7868 //
7869 if (!soff) {
7870 return(1);
7871 }
7872 if (n) {
7873 if (gvp == (char*)G__PVOID) {
7874 delete[] (SubDetectorROOTGeo*) soff;
7875 } else {
7876 G__setgvp((long) G__PVOID);
7877 for (int i = n - 1; i >= 0; --i) {
7878 ((SubDetectorROOTGeo*) (soff+(sizeof(SubDetectorROOTGeo)*i)))->~G__TSubDetectorROOTGeo();
7879 }
7880 G__setgvp((long)gvp);
7881 }
7882 } else {
7883 if (gvp == (char*)G__PVOID) {
7884 delete (SubDetectorROOTGeo*) soff;
7885 } else {
7886 G__setgvp((long) G__PVOID);
7887 ((SubDetectorROOTGeo*) (soff))->~G__TSubDetectorROOTGeo();
7888 G__setgvp((long)gvp);
7889 }
7890 }
7891 G__setnull(result7);
7892 return(1 || funcname || hash || result7 || libp) ;
7893}
7894
7895
7896/* BesPolygon2D */
7897static int G__BesVisLib_rootcint_836_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7898{
7899 BesPolygon2D* p = NULL;
7900 char* gvp = (char*) G__getgvp();
7901 int n = G__getaryconstruct();
7902 if (n) {
7903 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7904 p = new BesPolygon2D[n];
7905 } else {
7906 p = new((void*) gvp) BesPolygon2D[n];
7907 }
7908 } else {
7909 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7910 p = new BesPolygon2D;
7911 } else {
7912 p = new((void*) gvp) BesPolygon2D;
7913 }
7914 }
7915 result7->obj.i = (long) p;
7916 result7->ref = (long) p;
7917 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
7918 return(1 || funcname || hash || result7 || libp) ;
7919}
7920
7921static int G__BesVisLib_rootcint_836_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7922{
7923 BesPolygon2D* p = NULL;
7924 char* gvp = (char*) G__getgvp();
7925 //m: 4
7926 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7927 p = new BesPolygon2D(
7928(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
7929, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
7930 } else {
7931 p = new((void*) gvp) BesPolygon2D(
7932(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
7933, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
7934 }
7935 result7->obj.i = (long) p;
7936 result7->ref = (long) p;
7937 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
7938 return(1 || funcname || hash || result7 || libp) ;
7939}
7940
7941static int G__BesVisLib_rootcint_836_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7942{
7943 ((BesPolygon2D*) G__getstructoffset())->SetZRSign((Int_t) G__int(libp->para[0]));
7944 G__setnull(result7);
7945 return(1 || funcname || hash || result7 || libp) ;
7946}
7947
7948static int G__BesVisLib_rootcint_836_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7949{
7950 ((BesPolygon2D*) G__getstructoffset())->Resize((Double_t) G__double(libp->para[0]));
7951 G__setnull(result7);
7952 return(1 || funcname || hash || result7 || libp) ;
7953}
7954
7955static int G__BesVisLib_rootcint_836_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7956{
7957 ((BesPolygon2D*) G__getstructoffset())->SetInfoBox();
7958 G__setnull(result7);
7959 return(1 || funcname || hash || result7 || libp) ;
7960}
7961
7962static int G__BesVisLib_rootcint_836_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7963{
7964 ((const BesPolygon2D*) G__getstructoffset())->GetCenter((Double_t*) G__int(libp->para[0]));
7965 G__setnull(result7);
7966 return(1 || funcname || hash || result7 || libp) ;
7967}
7968
7969static int G__BesVisLib_rootcint_836_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7970{
7971 ((BesPolygon2D*) G__getstructoffset())->RotatePhi((Double_t) G__double(libp->para[0]));
7972 G__setnull(result7);
7973 return(1 || funcname || hash || result7 || libp) ;
7974}
7975
7976static int G__BesVisLib_rootcint_836_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7977{
7978 ((BesPolygon2D*) G__getstructoffset())->Restore();
7979 G__setnull(result7);
7980 return(1 || funcname || hash || result7 || libp) ;
7981}
7982
7983static int G__BesVisLib_rootcint_836_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7984{
7985 ((BesPolygon2D*) G__getstructoffset())->SetSize((Double_t) G__double(libp->para[0]));
7986 G__setnull(result7);
7987 return(1 || funcname || hash || result7 || libp) ;
7988}
7989
7990static int G__BesVisLib_rootcint_836_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7991{
7992 ((BesPolygon2D*) G__getstructoffset())->Stretch((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
7993, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
7994 G__setnull(result7);
7995 return(1 || funcname || hash || result7 || libp) ;
7996}
7997
7998static int G__BesVisLib_rootcint_836_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7999{
8000 G__letint(result7, 103, (long) ((BesPolygon2D*) G__getstructoffset())->IsRotatable());
8001 return(1 || funcname || hash || result7 || libp) ;
8002}
8003
8004static int G__BesVisLib_rootcint_836_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8005{
8006 ((BesPolygon2D*) G__getstructoffset())->SetRotatable((Bool_t) G__int(libp->para[0]));
8007 G__setnull(result7);
8008 return(1 || funcname || hash || result7 || libp) ;
8009}
8010
8011static int G__BesVisLib_rootcint_836_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8012{
8013 ((BesPolygon2D*) G__getstructoffset())->DrawClass();
8014 G__setnull(result7);
8015 return(1 || funcname || hash || result7 || libp) ;
8016}
8017
8018static int G__BesVisLib_rootcint_836_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8019{
8020 ((BesPolygon2D*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0]));
8021 G__setnull(result7);
8022 return(1 || funcname || hash || result7 || libp) ;
8023}
8024
8025static int G__BesVisLib_rootcint_836_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8026{
8027 ((BesPolygon2D*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
8028 G__setnull(result7);
8029 return(1 || funcname || hash || result7 || libp) ;
8030}
8031
8032static int G__BesVisLib_rootcint_836_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8033{
8034 G__letint(result7, 85, (long) BesPolygon2D::Class());
8035 return(1 || funcname || hash || result7 || libp) ;
8036}
8037
8038static int G__BesVisLib_rootcint_836_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8039{
8040 G__letint(result7, 67, (long) BesPolygon2D::Class_Name());
8041 return(1 || funcname || hash || result7 || libp) ;
8042}
8043
8044static int G__BesVisLib_rootcint_836_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8045{
8046 G__letint(result7, 115, (long) BesPolygon2D::Class_Version());
8047 return(1 || funcname || hash || result7 || libp) ;
8048}
8049
8050static int G__BesVisLib_rootcint_836_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8051{
8052 BesPolygon2D::Dictionary();
8053 G__setnull(result7);
8054 return(1 || funcname || hash || result7 || libp) ;
8055}
8056
8057static int G__BesVisLib_rootcint_836_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8058{
8059 ((BesPolygon2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8060 G__setnull(result7);
8061 return(1 || funcname || hash || result7 || libp) ;
8062}
8063
8064static int G__BesVisLib_rootcint_836_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8065{
8066 G__letint(result7, 67, (long) BesPolygon2D::DeclFileName());
8067 return(1 || funcname || hash || result7 || libp) ;
8068}
8069
8070static int G__BesVisLib_rootcint_836_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8071{
8072 G__letint(result7, 105, (long) BesPolygon2D::ImplFileLine());
8073 return(1 || funcname || hash || result7 || libp) ;
8074}
8075
8076static int G__BesVisLib_rootcint_836_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8077{
8078 G__letint(result7, 67, (long) BesPolygon2D::ImplFileName());
8079 return(1 || funcname || hash || result7 || libp) ;
8080}
8081
8082static int G__BesVisLib_rootcint_836_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8083{
8084 G__letint(result7, 105, (long) BesPolygon2D::DeclFileLine());
8085 return(1 || funcname || hash || result7 || libp) ;
8086}
8087
8088// automatic copy constructor
8089static int G__BesVisLib_rootcint_836_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8090
8091{
8092 BesPolygon2D* p;
8093 void* tmp = (void*) G__int(libp->para[0]);
8094 p = new BesPolygon2D(*(BesPolygon2D*) tmp);
8095 result7->obj.i = (long) p;
8096 result7->ref = (long) p;
8097 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
8098 return(1 || funcname || hash || result7 || libp) ;
8099}
8100
8101// automatic destructor
8102typedef BesPolygon2D G__TBesPolygon2D;
8103static int G__BesVisLib_rootcint_836_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8104{
8105 char* gvp = (char*) G__getgvp();
8106 long soff = G__getstructoffset();
8107 int n = G__getaryconstruct();
8108 //
8109 //has_a_delete: 1
8110 //has_own_delete1arg: 0
8111 //has_own_delete2arg: 0
8112 //
8113 if (!soff) {
8114 return(1);
8115 }
8116 if (n) {
8117 if (gvp == (char*)G__PVOID) {
8118 delete[] (BesPolygon2D*) soff;
8119 } else {
8120 G__setgvp((long) G__PVOID);
8121 for (int i = n - 1; i >= 0; --i) {
8122 ((BesPolygon2D*) (soff+(sizeof(BesPolygon2D)*i)))->~G__TBesPolygon2D();
8123 }
8124 G__setgvp((long)gvp);
8125 }
8126 } else {
8127 if (gvp == (char*)G__PVOID) {
8128 delete (BesPolygon2D*) soff;
8129 } else {
8130 G__setgvp((long) G__PVOID);
8131 ((BesPolygon2D*) (soff))->~G__TBesPolygon2D();
8132 G__setgvp((long)gvp);
8133 }
8134 }
8135 G__setnull(result7);
8136 return(1 || funcname || hash || result7 || libp) ;
8137}
8138
8139// automatic assignment operator
8140static int G__BesVisLib_rootcint_836_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8141{
8142 BesPolygon2D* dest = (BesPolygon2D*) G__getstructoffset();
8143 *dest = *(BesPolygon2D*) libp->para[0].ref;
8144 const BesPolygon2D& obj = *dest;
8145 result7->ref = (long) (&obj);
8146 result7->obj.i = (long) (&obj);
8147 return(1 || funcname || hash || result7 || libp) ;
8148}
8149
8150
8151/* Mdc2DWire */
8152static int G__BesVisLib_rootcint_837_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8153{
8154 Mdc2DWire* p = NULL;
8155 char* gvp = (char*) G__getgvp();
8156 int n = G__getaryconstruct();
8157 if (n) {
8158 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8159 p = new Mdc2DWire[n];
8160 } else {
8161 p = new((void*) gvp) Mdc2DWire[n];
8162 }
8163 } else {
8164 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8165 p = new Mdc2DWire;
8166 } else {
8167 p = new((void*) gvp) Mdc2DWire;
8168 }
8169 }
8170 result7->obj.i = (long) p;
8171 result7->ref = (long) p;
8172 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
8173 return(1 || funcname || hash || result7 || libp) ;
8174}
8175
8176static int G__BesVisLib_rootcint_837_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8177{
8178 Mdc2DWire* p = NULL;
8179 char* gvp = (char*) G__getgvp();
8180 //m: 7
8181 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8182 p = new Mdc2DWire(
8183(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8184, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
8185, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
8186, (Double_t*) G__int(libp->para[6]));
8187 } else {
8188 p = new((void*) gvp) Mdc2DWire(
8189(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8190, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
8191, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
8192, (Double_t*) G__int(libp->para[6]));
8193 }
8194 result7->obj.i = (long) p;
8195 result7->ref = (long) p;
8196 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
8197 return(1 || funcname || hash || result7 || libp) ;
8198}
8199
8200static int G__BesVisLib_rootcint_837_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8201{
8202 Mdc2DWire* p = NULL;
8203 char* gvp = (char*) G__getgvp();
8204 //m: 4
8205 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8206 p = new Mdc2DWire(
8207(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8208, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
8209 } else {
8210 p = new((void*) gvp) Mdc2DWire(
8211(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8212, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
8213 }
8214 result7->obj.i = (long) p;
8215 result7->ref = (long) p;
8216 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
8217 return(1 || funcname || hash || result7 || libp) ;
8218}
8219
8220static int G__BesVisLib_rootcint_837_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8221{
8222 ((Mdc2DWire*) G__getstructoffset())->Init();
8223 G__setnull(result7);
8224 return(1 || funcname || hash || result7 || libp) ;
8225}
8226
8227static int G__BesVisLib_rootcint_837_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8228{
8229 ((Mdc2DWire*) G__getstructoffset())->SetStyle();
8230 G__setnull(result7);
8231 return(1 || funcname || hash || result7 || libp) ;
8232}
8233
8234static int G__BesVisLib_rootcint_837_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8235{
8236 switch (libp->paran) {
8237 case 1:
8238 ((Mdc2DWire*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
8239 G__setnull(result7);
8240 break;
8241 case 0:
8242 ((Mdc2DWire*) G__getstructoffset())->SetHighlighted();
8243 G__setnull(result7);
8244 break;
8245 }
8246 return(1 || funcname || hash || result7 || libp) ;
8247}
8248
8249static int G__BesVisLib_rootcint_837_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8250{
8251 switch (libp->paran) {
8252 case 1:
8253 ((Mdc2DWire*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
8254 G__setnull(result7);
8255 break;
8256 case 0:
8257 ((Mdc2DWire*) G__getstructoffset())->SetFired();
8258 G__setnull(result7);
8259 break;
8260 }
8261 return(1 || funcname || hash || result7 || libp) ;
8262}
8263
8264static int G__BesVisLib_rootcint_837_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8265{
8266 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->IsHighlighted());
8267 return(1 || funcname || hash || result7 || libp) ;
8268}
8269
8270static int G__BesVisLib_rootcint_837_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8271{
8272 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->IsFired());
8273 return(1 || funcname || hash || result7 || libp) ;
8274}
8275
8276static int G__BesVisLib_rootcint_837_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8277{
8278 ((Mdc2DWire*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
8279 G__setnull(result7);
8280 return(1 || funcname || hash || result7 || libp) ;
8281}
8282
8283static int G__BesVisLib_rootcint_837_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8284{
8285 ((Mdc2DWire*) G__getstructoffset())->CloseInfo();
8286 G__setnull(result7);
8287 return(1 || funcname || hash || result7 || libp) ;
8288}
8289
8290static int G__BesVisLib_rootcint_837_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8291{
8292 ((Mdc2DWire*) G__getstructoffset())->ClearInfo();
8293 G__setnull(result7);
8294 return(1 || funcname || hash || result7 || libp) ;
8295}
8296
8297static int G__BesVisLib_rootcint_837_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8298{
8299 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->HasZRSection());
8300 return(1 || funcname || hash || result7 || libp) ;
8301}
8302
8303static int G__BesVisLib_rootcint_837_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8304{
8305 G__letdouble(result7, 100, (double) ((Mdc2DWire*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
8306 return(1 || funcname || hash || result7 || libp) ;
8307}
8308
8309static int G__BesVisLib_rootcint_837_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8310{
8311 ((Mdc2DWire*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
8312 G__setnull(result7);
8313 return(1 || funcname || hash || result7 || libp) ;
8314}
8315
8316static int G__BesVisLib_rootcint_837_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8317{
8318 ((Mdc2DWire*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
8319 G__setnull(result7);
8320 return(1 || funcname || hash || result7 || libp) ;
8321}
8322
8323static int G__BesVisLib_rootcint_837_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8324{
8325 ((Mdc2DWire*) G__getstructoffset())->SetColorfulWire((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
8326 G__setnull(result7);
8327 return(1 || funcname || hash || result7 || libp) ;
8328}
8329
8330static int G__BesVisLib_rootcint_837_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8331{
8332 ((Mdc2DWire*) G__getstructoffset())->SetQOverflow((Bool_t) G__int(libp->para[0]));
8333 G__setnull(result7);
8334 return(1 || funcname || hash || result7 || libp) ;
8335}
8336
8337static int G__BesVisLib_rootcint_837_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8338{
8339 ((Mdc2DWire*) G__getstructoffset())->SetEvTime((Double_t) G__double(libp->para[0]));
8340 G__setnull(result7);
8341 return(1 || funcname || hash || result7 || libp) ;
8342}
8343
8344static int G__BesVisLib_rootcint_837_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8345{
8346 ((Mdc2DWire*) G__getstructoffset())->SetTimeChannel((UInt_t) G__int(libp->para[0]));
8347 G__setnull(result7);
8348 return(1 || funcname || hash || result7 || libp) ;
8349}
8350
8351static int G__BesVisLib_rootcint_837_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8352{
8353 ((Mdc2DWire*) G__getstructoffset())->SetChargeChannel((UInt_t) G__int(libp->para[0]));
8354 G__setnull(result7);
8355 return(1 || funcname || hash || result7 || libp) ;
8356}
8357
8358static int G__BesVisLib_rootcint_837_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8359{
8360 G__letdouble(result7, 100, (double) ((const Mdc2DWire*) G__getstructoffset())->GetTime());
8361 return(1 || funcname || hash || result7 || libp) ;
8362}
8363
8364static int G__BesVisLib_rootcint_837_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8365{
8366 G__letdouble(result7, 100, (double) ((const Mdc2DWire*) G__getstructoffset())->GetCharge());
8367 return(1 || funcname || hash || result7 || libp) ;
8368}
8369
8370static int G__BesVisLib_rootcint_837_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8371{
8372 G__letdouble(result7, 100, (double) ((const Mdc2DWire*) G__getstructoffset())->GetEvTime());
8373 return(1 || funcname || hash || result7 || libp) ;
8374}
8375
8376static int G__BesVisLib_rootcint_837_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8377{
8378 G__letint(result7, 103, (long) ((const Mdc2DWire*) G__getstructoffset())->GetQOverflow());
8379 return(1 || funcname || hash || result7 || libp) ;
8380}
8381
8382static int G__BesVisLib_rootcint_837_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8383{
8384 G__letint(result7, 104, (long) ((const Mdc2DWire*) G__getstructoffset())->GetTimeChannel());
8385 return(1 || funcname || hash || result7 || libp) ;
8386}
8387
8388static int G__BesVisLib_rootcint_837_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8389{
8390 G__letint(result7, 104, (long) ((const Mdc2DWire*) G__getstructoffset())->GetChargeChannel());
8391 return(1 || funcname || hash || result7 || libp) ;
8392}
8393
8394static int G__BesVisLib_rootcint_837_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8395{
8396 G__letint(result7, 85, (long) Mdc2DWire::Class());
8397 return(1 || funcname || hash || result7 || libp) ;
8398}
8399
8400static int G__BesVisLib_rootcint_837_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8401{
8402 G__letint(result7, 67, (long) Mdc2DWire::Class_Name());
8403 return(1 || funcname || hash || result7 || libp) ;
8404}
8405
8406static int G__BesVisLib_rootcint_837_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8407{
8408 G__letint(result7, 115, (long) Mdc2DWire::Class_Version());
8409 return(1 || funcname || hash || result7 || libp) ;
8410}
8411
8412static int G__BesVisLib_rootcint_837_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8413{
8414 Mdc2DWire::Dictionary();
8415 G__setnull(result7);
8416 return(1 || funcname || hash || result7 || libp) ;
8417}
8418
8419static int G__BesVisLib_rootcint_837_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8420{
8421 ((Mdc2DWire*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8422 G__setnull(result7);
8423 return(1 || funcname || hash || result7 || libp) ;
8424}
8425
8426static int G__BesVisLib_rootcint_837_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8427{
8428 G__letint(result7, 67, (long) Mdc2DWire::DeclFileName());
8429 return(1 || funcname || hash || result7 || libp) ;
8430}
8431
8432static int G__BesVisLib_rootcint_837_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8433{
8434 G__letint(result7, 105, (long) Mdc2DWire::ImplFileLine());
8435 return(1 || funcname || hash || result7 || libp) ;
8436}
8437
8438static int G__BesVisLib_rootcint_837_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8439{
8440 G__letint(result7, 67, (long) Mdc2DWire::ImplFileName());
8441 return(1 || funcname || hash || result7 || libp) ;
8442}
8443
8444static int G__BesVisLib_rootcint_837_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8445{
8446 G__letint(result7, 105, (long) Mdc2DWire::DeclFileLine());
8447 return(1 || funcname || hash || result7 || libp) ;
8448}
8449
8450// automatic copy constructor
8451static int G__BesVisLib_rootcint_837_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8452
8453{
8454 Mdc2DWire* p;
8455 void* tmp = (void*) G__int(libp->para[0]);
8456 p = new Mdc2DWire(*(Mdc2DWire*) tmp);
8457 result7->obj.i = (long) p;
8458 result7->ref = (long) p;
8459 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
8460 return(1 || funcname || hash || result7 || libp) ;
8461}
8462
8463// automatic destructor
8464typedef Mdc2DWire G__TMdc2DWire;
8465static int G__BesVisLib_rootcint_837_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8466{
8467 char* gvp = (char*) G__getgvp();
8468 long soff = G__getstructoffset();
8469 int n = G__getaryconstruct();
8470 //
8471 //has_a_delete: 1
8472 //has_own_delete1arg: 0
8473 //has_own_delete2arg: 0
8474 //
8475 if (!soff) {
8476 return(1);
8477 }
8478 if (n) {
8479 if (gvp == (char*)G__PVOID) {
8480 delete[] (Mdc2DWire*) soff;
8481 } else {
8482 G__setgvp((long) G__PVOID);
8483 for (int i = n - 1; i >= 0; --i) {
8484 ((Mdc2DWire*) (soff+(sizeof(Mdc2DWire)*i)))->~G__TMdc2DWire();
8485 }
8486 G__setgvp((long)gvp);
8487 }
8488 } else {
8489 if (gvp == (char*)G__PVOID) {
8490 delete (Mdc2DWire*) soff;
8491 } else {
8492 G__setgvp((long) G__PVOID);
8493 ((Mdc2DWire*) (soff))->~G__TMdc2DWire();
8494 G__setgvp((long)gvp);
8495 }
8496 }
8497 G__setnull(result7);
8498 return(1 || funcname || hash || result7 || libp) ;
8499}
8500
8501// automatic assignment operator
8502static int G__BesVisLib_rootcint_837_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8503{
8504 Mdc2DWire* dest = (Mdc2DWire*) G__getstructoffset();
8505 *dest = *(Mdc2DWire*) libp->para[0].ref;
8506 const Mdc2DWire& obj = *dest;
8507 result7->ref = (long) (&obj);
8508 result7->obj.i = (long) (&obj);
8509 return(1 || funcname || hash || result7 || libp) ;
8510}
8511
8512
8513/* MdcROOTGeo */
8514static int G__BesVisLib_rootcint_838_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8515{
8516 MdcROOTGeo* p = NULL;
8517 char* gvp = (char*) G__getgvp();
8518 switch (libp->paran) {
8519 case 1:
8520 //m: 1
8521 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8522 p = new MdcROOTGeo((Bool_t) G__int(libp->para[0]));
8523 } else {
8524 p = new((void*) gvp) MdcROOTGeo((Bool_t) G__int(libp->para[0]));
8525 }
8526 break;
8527 case 0:
8528 int n = G__getaryconstruct();
8529 if (n) {
8530 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8531 p = new MdcROOTGeo[n];
8532 } else {
8533 p = new((void*) gvp) MdcROOTGeo[n];
8534 }
8535 } else {
8536 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8537 p = new MdcROOTGeo;
8538 } else {
8539 p = new((void*) gvp) MdcROOTGeo;
8540 }
8541 }
8542 break;
8543 }
8544 result7->obj.i = (long) p;
8545 result7->ref = (long) p;
8546 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
8547 return(1 || funcname || hash || result7 || libp) ;
8548}
8549
8550static int G__BesVisLib_rootcint_838_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8551{
8552 ((MdcROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
8553 G__setnull(result7);
8554 return(1 || funcname || hash || result7 || libp) ;
8555}
8556
8557static int G__BesVisLib_rootcint_838_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8558{
8559 ((MdcROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
8560 G__setnull(result7);
8561 return(1 || funcname || hash || result7 || libp) ;
8562}
8563
8564static int G__BesVisLib_rootcint_838_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8565{
8566 ((MdcROOTGeo*) G__getstructoffset())->Init2DGeometry();
8567 G__setnull(result7);
8568 return(1 || funcname || hash || result7 || libp) ;
8569}
8570
8571static int G__BesVisLib_rootcint_838_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8572{
8573 ((MdcROOTGeo*) G__getstructoffset())->SetNode();
8574 G__setnull(result7);
8575 return(1 || funcname || hash || result7 || libp) ;
8576}
8577
8578static int G__BesVisLib_rootcint_838_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8579{
8580 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->CorrectReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
8581 return(1 || funcname || hash || result7 || libp) ;
8582}
8583
8584static int G__BesVisLib_rootcint_838_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8585{
8586 ((MdcROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
8587 G__setnull(result7);
8588 return(1 || funcname || hash || result7 || libp) ;
8589}
8590
8591static int G__BesVisLib_rootcint_838_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8592{
8593 ((MdcROOTGeo*) G__getstructoffset())->SetAllVisible();
8594 G__setnull(result7);
8595 return(1 || funcname || hash || result7 || libp) ;
8596}
8597
8598static int G__BesVisLib_rootcint_838_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8599{
8600 ((MdcROOTGeo*) G__getstructoffset())->SetQuarterVisible();
8601 G__setnull(result7);
8602 return(1 || funcname || hash || result7 || libp) ;
8603}
8604
8605static int G__BesVisLib_rootcint_838_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8606{
8607 ((MdcROOTGeo*) G__getstructoffset())->SetHalfVisible();
8608 G__setnull(result7);
8609 return(1 || funcname || hash || result7 || libp) ;
8610}
8611
8612static int G__BesVisLib_rootcint_838_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8613{
8614 ((MdcROOTGeo*) G__getstructoffset())->SetPhysicalNode();
8615 G__setnull(result7);
8616 return(1 || funcname || hash || result7 || libp) ;
8617}
8618
8619static int G__BesVisLib_rootcint_838_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8620{
8621 ((MdcROOTGeo*) G__getstructoffset())->SetPhysicalDefaultVis();
8622 G__setnull(result7);
8623 return(1 || funcname || hash || result7 || libp) ;
8624}
8625
8626static int G__BesVisLib_rootcint_838_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8627{
8628 ((MdcROOTGeo*) G__getstructoffset())->SetDetector();
8629 G__setnull(result7);
8630 return(1 || funcname || hash || result7 || libp) ;
8631}
8632
8633static int G__BesVisLib_rootcint_838_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8634{
8635 ((MdcROOTGeo*) G__getstructoffset())->SetHits();
8636 G__setnull(result7);
8637 return(1 || funcname || hash || result7 || libp) ;
8638}
8639
8640static int G__BesVisLib_rootcint_838_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8641{
8642 ((MdcROOTGeo*) G__getstructoffset())->SetTFire((Bool_t) G__int(libp->para[0]));
8643 G__setnull(result7);
8644 return(1 || funcname || hash || result7 || libp) ;
8645}
8646
8647static int G__BesVisLib_rootcint_838_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8648{
8649 ((MdcROOTGeo*) G__getstructoffset())->SetQFire((Bool_t) G__int(libp->para[0]));
8650 G__setnull(result7);
8651 return(1 || funcname || hash || result7 || libp) ;
8652}
8653
8654static int G__BesVisLib_rootcint_838_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8655{
8656 ((MdcROOTGeo*) G__getstructoffset())->SetQNotOverflow((Bool_t) G__int(libp->para[0]));
8657 G__setnull(result7);
8658 return(1 || funcname || hash || result7 || libp) ;
8659}
8660
8661static int G__BesVisLib_rootcint_838_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8662{
8663 ((MdcROOTGeo*) G__getstructoffset())->SetColorfulWire((Bool_t) G__int(libp->para[0]));
8664 G__setnull(result7);
8665 return(1 || funcname || hash || result7 || libp) ;
8666}
8667
8668static int G__BesVisLib_rootcint_838_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8669{
8670 ((MdcROOTGeo*) G__getstructoffset())->SetMdcTimeSubEvTime((Bool_t) G__int(libp->para[0]));
8671 G__setnull(result7);
8672 return(1 || funcname || hash || result7 || libp) ;
8673}
8674
8675static int G__BesVisLib_rootcint_838_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8676{
8677 ((MdcROOTGeo*) G__getstructoffset())->SetVisMdcDetector();
8678 G__setnull(result7);
8679 return(1 || funcname || hash || result7 || libp) ;
8680}
8681
8682static int G__BesVisLib_rootcint_838_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8683{
8684 ((MdcROOTGeo*) G__getstructoffset())->SetVisMdcHits();
8685 G__setnull(result7);
8686 return(1 || funcname || hash || result7 || libp) ;
8687}
8688
8689static int G__BesVisLib_rootcint_838_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8690{
8691 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSegmentNb());
8692 return(1 || funcname || hash || result7 || libp) ;
8693}
8694
8695static int G__BesVisLib_rootcint_838_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8696{
8697 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetLayerNb());
8698 return(1 || funcname || hash || result7 || libp) ;
8699}
8700
8701static int G__BesVisLib_rootcint_838_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8702{
8703 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetReplicaNb((int) G__int(libp->para[0])));
8704 return(1 || funcname || hash || result7 || libp) ;
8705}
8706
8707static int G__BesVisLib_rootcint_838_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8708{
8709 ((MdcROOTGeo*) G__getstructoffset())->SetVolumeMdc((TGeoVolume*) G__int(libp->para[0]));
8710 G__setnull(result7);
8711 return(1 || funcname || hash || result7 || libp) ;
8712}
8713
8714static int G__BesVisLib_rootcint_838_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8715{
8716 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeMdc());
8717 return(1 || funcname || hash || result7 || libp) ;
8718}
8719
8720static int G__BesVisLib_rootcint_838_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8721{
8722 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeSegment((int) G__int(libp->para[0])));
8723 return(1 || funcname || hash || result7 || libp) ;
8724}
8725
8726static int G__BesVisLib_rootcint_838_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8727{
8728 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeLayer((int) G__int(libp->para[0])));
8729 return(1 || funcname || hash || result7 || libp) ;
8730}
8731
8732static int G__BesVisLib_rootcint_838_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8733{
8734 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeReplica((int) G__int(libp->para[0])));
8735 return(1 || funcname || hash || result7 || libp) ;
8736}
8737
8738static int G__BesVisLib_rootcint_838_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8739{
8740 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSegment((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
8741 return(1 || funcname || hash || result7 || libp) ;
8742}
8743
8744static int G__BesVisLib_rootcint_838_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8745{
8746 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetLayer((int) G__int(libp->para[0])));
8747 return(1 || funcname || hash || result7 || libp) ;
8748}
8749
8750static int G__BesVisLib_rootcint_838_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8751{
8752 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
8753 return(1 || funcname || hash || result7 || libp) ;
8754}
8755
8756static int G__BesVisLib_rootcint_838_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8757{
8758 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetPhysicalSegment((int) G__int(libp->para[0])));
8759 return(1 || funcname || hash || result7 || libp) ;
8760}
8761
8762static int G__BesVisLib_rootcint_838_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8763{
8764 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetPhysicalReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
8765 return(1 || funcname || hash || result7 || libp) ;
8766}
8767
8768static int G__BesVisLib_rootcint_838_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8769{
8770 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->Get2DWire((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
8771 return(1 || funcname || hash || result7 || libp) ;
8772}
8773
8774static int G__BesVisLib_rootcint_838_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8775{
8776 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSimuLayer((Int_t) G__int(libp->para[0])));
8777 return(1 || funcname || hash || result7 || libp) ;
8778}
8779
8780static int G__BesVisLib_rootcint_838_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8781{
8782 G__letint(result7, 103, (long) ((MdcROOTGeo*) G__getstructoffset())->IsHit((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
8783 return(1 || funcname || hash || result7 || libp) ;
8784}
8785
8786static int G__BesVisLib_rootcint_838_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8787{
8788 ((MdcROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
8789 G__setnull(result7);
8790 return(1 || funcname || hash || result7 || libp) ;
8791}
8792
8793static int G__BesVisLib_rootcint_838_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8794{
8795 ((MdcROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
8796 G__setnull(result7);
8797 return(1 || funcname || hash || result7 || libp) ;
8798}
8799
8800// automatic copy constructor
8801static int G__BesVisLib_rootcint_838_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8802
8803{
8804 MdcROOTGeo* p;
8805 void* tmp = (void*) G__int(libp->para[0]);
8806 p = new MdcROOTGeo(*(MdcROOTGeo*) tmp);
8807 result7->obj.i = (long) p;
8808 result7->ref = (long) p;
8809 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
8810 return(1 || funcname || hash || result7 || libp) ;
8811}
8812
8813// automatic destructor
8814typedef MdcROOTGeo G__TMdcROOTGeo;
8815static int G__BesVisLib_rootcint_838_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8816{
8817 char* gvp = (char*) G__getgvp();
8818 long soff = G__getstructoffset();
8819 int n = G__getaryconstruct();
8820 //
8821 //has_a_delete: 0
8822 //has_own_delete1arg: 0
8823 //has_own_delete2arg: 0
8824 //
8825 if (!soff) {
8826 return(1);
8827 }
8828 if (n) {
8829 if (gvp == (char*)G__PVOID) {
8830 delete[] (MdcROOTGeo*) soff;
8831 } else {
8832 G__setgvp((long) G__PVOID);
8833 for (int i = n - 1; i >= 0; --i) {
8834 ((MdcROOTGeo*) (soff+(sizeof(MdcROOTGeo)*i)))->~G__TMdcROOTGeo();
8835 }
8836 G__setgvp((long)gvp);
8837 }
8838 } else {
8839 if (gvp == (char*)G__PVOID) {
8840 delete (MdcROOTGeo*) soff;
8841 } else {
8842 G__setgvp((long) G__PVOID);
8843 ((MdcROOTGeo*) (soff))->~G__TMdcROOTGeo();
8844 G__setgvp((long)gvp);
8845 }
8846 }
8847 G__setnull(result7);
8848 return(1 || funcname || hash || result7 || libp) ;
8849}
8850
8851
8852/* Tof2DScin */
8853static int G__BesVisLib_rootcint_839_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8854{
8855 Tof2DScin* p = NULL;
8856 char* gvp = (char*) G__getgvp();
8857 int n = G__getaryconstruct();
8858 if (n) {
8859 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8860 p = new Tof2DScin[n];
8861 } else {
8862 p = new((void*) gvp) Tof2DScin[n];
8863 }
8864 } else {
8865 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8866 p = new Tof2DScin;
8867 } else {
8868 p = new((void*) gvp) Tof2DScin;
8869 }
8870 }
8871 result7->obj.i = (long) p;
8872 result7->ref = (long) p;
8873 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
8874 return(1 || funcname || hash || result7 || libp) ;
8875}
8876
8877static int G__BesVisLib_rootcint_839_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8878{
8879 Tof2DScin* p = NULL;
8880 char* gvp = (char*) G__getgvp();
8881 //m: 5
8882 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8883 p = new Tof2DScin(
8884(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8885, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
8886, (Int_t) G__int(libp->para[4]));
8887 } else {
8888 p = new((void*) gvp) Tof2DScin(
8889(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
8890, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
8891, (Int_t) G__int(libp->para[4]));
8892 }
8893 result7->obj.i = (long) p;
8894 result7->ref = (long) p;
8895 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
8896 return(1 || funcname || hash || result7 || libp) ;
8897}
8898
8899static int G__BesVisLib_rootcint_839_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8900{
8901 ((Tof2DScin*) G__getstructoffset())->SetStyle();
8902 G__setnull(result7);
8903 return(1 || funcname || hash || result7 || libp) ;
8904}
8905
8906static int G__BesVisLib_rootcint_839_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8907{
8908 switch (libp->paran) {
8909 case 1:
8910 ((Tof2DScin*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
8911 G__setnull(result7);
8912 break;
8913 case 0:
8914 ((Tof2DScin*) G__getstructoffset())->SetHighlighted();
8915 G__setnull(result7);
8916 break;
8917 }
8918 return(1 || funcname || hash || result7 || libp) ;
8919}
8920
8921static int G__BesVisLib_rootcint_839_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8922{
8923 switch (libp->paran) {
8924 case 1:
8925 ((Tof2DScin*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
8926 G__setnull(result7);
8927 break;
8928 case 0:
8929 ((Tof2DScin*) G__getstructoffset())->SetFired();
8930 G__setnull(result7);
8931 break;
8932 }
8933 return(1 || funcname || hash || result7 || libp) ;
8934}
8935
8936static int G__BesVisLib_rootcint_839_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8937{
8938 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->IsHighlighted());
8939 return(1 || funcname || hash || result7 || libp) ;
8940}
8941
8942static int G__BesVisLib_rootcint_839_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8943{
8944 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->IsFired());
8945 return(1 || funcname || hash || result7 || libp) ;
8946}
8947
8948static int G__BesVisLib_rootcint_839_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8949{
8950 ((Tof2DScin*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
8951 G__setnull(result7);
8952 return(1 || funcname || hash || result7 || libp) ;
8953}
8954
8955static int G__BesVisLib_rootcint_839_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8956{
8957 ((Tof2DScin*) G__getstructoffset())->CloseInfo();
8958 G__setnull(result7);
8959 return(1 || funcname || hash || result7 || libp) ;
8960}
8961
8962static int G__BesVisLib_rootcint_839_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8963{
8964 ((Tof2DScin*) G__getstructoffset())->ClearInfo();
8965 G__setnull(result7);
8966 return(1 || funcname || hash || result7 || libp) ;
8967}
8968
8969static int G__BesVisLib_rootcint_839_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8970{
8971 ((Tof2DScin*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
8972 G__setnull(result7);
8973 return(1 || funcname || hash || result7 || libp) ;
8974}
8975
8976static int G__BesVisLib_rootcint_839_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8977{
8978 ((Tof2DScin*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
8979 G__setnull(result7);
8980 return(1 || funcname || hash || result7 || libp) ;
8981}
8982
8983static int G__BesVisLib_rootcint_839_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8984{
8985 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetTime());
8986 return(1 || funcname || hash || result7 || libp) ;
8987}
8988
8989static int G__BesVisLib_rootcint_839_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8990{
8991 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetCharge());
8992 return(1 || funcname || hash || result7 || libp) ;
8993}
8994
8995static int G__BesVisLib_rootcint_839_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8996{
8997 ((Tof2DScin*) G__getstructoffset())->ResetTimeCharge();
8998 G__setnull(result7);
8999 return(1 || funcname || hash || result7 || libp) ;
9000}
9001
9002static int G__BesVisLib_rootcint_839_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9003{
9004 G__letint(result7, 105, (long) ((Tof2DScin*) G__getstructoffset())->GetPart());
9005 return(1 || funcname || hash || result7 || libp) ;
9006}
9007
9008static int G__BesVisLib_rootcint_839_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9009{
9010 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->HasZRSection());
9011 return(1 || funcname || hash || result7 || libp) ;
9012}
9013
9014static int G__BesVisLib_rootcint_839_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9015{
9016 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
9017 return(1 || funcname || hash || result7 || libp) ;
9018}
9019
9020static int G__BesVisLib_rootcint_839_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9021{
9022 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
9023 return(1 || funcname || hash || result7 || libp) ;
9024}
9025
9026static int G__BesVisLib_rootcint_839_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9027{
9028 ((Tof2DScin*) G__getstructoffset())->SetTimeChannel((UInt_t) G__int(libp->para[0]));
9029 G__setnull(result7);
9030 return(1 || funcname || hash || result7 || libp) ;
9031}
9032
9033static int G__BesVisLib_rootcint_839_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9034{
9035 ((Tof2DScin*) G__getstructoffset())->SetChargeChannel((UInt_t) G__int(libp->para[0]));
9036 G__setnull(result7);
9037 return(1 || funcname || hash || result7 || libp) ;
9038}
9039
9040static int G__BesVisLib_rootcint_839_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9041{
9042 G__letint(result7, 104, (long) ((const Tof2DScin*) G__getstructoffset())->GetTimeChannel());
9043 return(1 || funcname || hash || result7 || libp) ;
9044}
9045
9046static int G__BesVisLib_rootcint_839_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9047{
9048 G__letint(result7, 104, (long) ((const Tof2DScin*) G__getstructoffset())->GetChargeChannel());
9049 return(1 || funcname || hash || result7 || libp) ;
9050}
9051
9052static int G__BesVisLib_rootcint_839_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9053{
9054 G__letint(result7, 85, (long) Tof2DScin::Class());
9055 return(1 || funcname || hash || result7 || libp) ;
9056}
9057
9058static int G__BesVisLib_rootcint_839_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9059{
9060 G__letint(result7, 67, (long) Tof2DScin::Class_Name());
9061 return(1 || funcname || hash || result7 || libp) ;
9062}
9063
9064static int G__BesVisLib_rootcint_839_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9065{
9066 G__letint(result7, 115, (long) Tof2DScin::Class_Version());
9067 return(1 || funcname || hash || result7 || libp) ;
9068}
9069
9070static int G__BesVisLib_rootcint_839_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9071{
9072 Tof2DScin::Dictionary();
9073 G__setnull(result7);
9074 return(1 || funcname || hash || result7 || libp) ;
9075}
9076
9077static int G__BesVisLib_rootcint_839_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9078{
9079 ((Tof2DScin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9080 G__setnull(result7);
9081 return(1 || funcname || hash || result7 || libp) ;
9082}
9083
9084static int G__BesVisLib_rootcint_839_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9085{
9086 G__letint(result7, 67, (long) Tof2DScin::DeclFileName());
9087 return(1 || funcname || hash || result7 || libp) ;
9088}
9089
9090static int G__BesVisLib_rootcint_839_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9091{
9092 G__letint(result7, 105, (long) Tof2DScin::ImplFileLine());
9093 return(1 || funcname || hash || result7 || libp) ;
9094}
9095
9096static int G__BesVisLib_rootcint_839_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9097{
9098 G__letint(result7, 67, (long) Tof2DScin::ImplFileName());
9099 return(1 || funcname || hash || result7 || libp) ;
9100}
9101
9102static int G__BesVisLib_rootcint_839_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9103{
9104 G__letint(result7, 105, (long) Tof2DScin::DeclFileLine());
9105 return(1 || funcname || hash || result7 || libp) ;
9106}
9107
9108// automatic copy constructor
9109static int G__BesVisLib_rootcint_839_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9110
9111{
9112 Tof2DScin* p;
9113 void* tmp = (void*) G__int(libp->para[0]);
9114 p = new Tof2DScin(*(Tof2DScin*) tmp);
9115 result7->obj.i = (long) p;
9116 result7->ref = (long) p;
9117 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
9118 return(1 || funcname || hash || result7 || libp) ;
9119}
9120
9121// automatic destructor
9122typedef Tof2DScin G__TTof2DScin;
9123static int G__BesVisLib_rootcint_839_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9124{
9125 char* gvp = (char*) G__getgvp();
9126 long soff = G__getstructoffset();
9127 int n = G__getaryconstruct();
9128 //
9129 //has_a_delete: 1
9130 //has_own_delete1arg: 0
9131 //has_own_delete2arg: 0
9132 //
9133 if (!soff) {
9134 return(1);
9135 }
9136 if (n) {
9137 if (gvp == (char*)G__PVOID) {
9138 delete[] (Tof2DScin*) soff;
9139 } else {
9140 G__setgvp((long) G__PVOID);
9141 for (int i = n - 1; i >= 0; --i) {
9142 ((Tof2DScin*) (soff+(sizeof(Tof2DScin)*i)))->~G__TTof2DScin();
9143 }
9144 G__setgvp((long)gvp);
9145 }
9146 } else {
9147 if (gvp == (char*)G__PVOID) {
9148 delete (Tof2DScin*) soff;
9149 } else {
9150 G__setgvp((long) G__PVOID);
9151 ((Tof2DScin*) (soff))->~G__TTof2DScin();
9152 G__setgvp((long)gvp);
9153 }
9154 }
9155 G__setnull(result7);
9156 return(1 || funcname || hash || result7 || libp) ;
9157}
9158
9159// automatic assignment operator
9160static int G__BesVisLib_rootcint_839_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9161{
9162 Tof2DScin* dest = (Tof2DScin*) G__getstructoffset();
9163 *dest = *(Tof2DScin*) libp->para[0].ref;
9164 const Tof2DScin& obj = *dest;
9165 result7->ref = (long) (&obj);
9166 result7->obj.i = (long) (&obj);
9167 return(1 || funcname || hash || result7 || libp) ;
9168}
9169
9170
9171/* TofROOTGeo */
9172static int G__BesVisLib_rootcint_840_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9173{
9174 TofROOTGeo* p = NULL;
9175 char* gvp = (char*) G__getgvp();
9176 int n = G__getaryconstruct();
9177 if (n) {
9178 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9179 p = new TofROOTGeo[n];
9180 } else {
9181 p = new((void*) gvp) TofROOTGeo[n];
9182 }
9183 } else {
9184 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9185 p = new TofROOTGeo;
9186 } else {
9187 p = new((void*) gvp) TofROOTGeo;
9188 }
9189 }
9190 result7->obj.i = (long) p;
9191 result7->ref = (long) p;
9192 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
9193 return(1 || funcname || hash || result7 || libp) ;
9194}
9195
9196static int G__BesVisLib_rootcint_840_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9197{
9198 G__letint(result7, 103, (long) ((const TofROOTGeo*) G__getstructoffset())->GetMrpc());
9199 return(1 || funcname || hash || result7 || libp) ;
9200}
9201
9202static int G__BesVisLib_rootcint_840_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9203{
9204 ((TofROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
9205 G__setnull(result7);
9206 return(1 || funcname || hash || result7 || libp) ;
9207}
9208
9209static int G__BesVisLib_rootcint_840_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9210{
9211 ((TofROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
9212 G__setnull(result7);
9213 return(1 || funcname || hash || result7 || libp) ;
9214}
9215
9216static int G__BesVisLib_rootcint_840_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9217{
9218 ((TofROOTGeo*) G__getstructoffset())->Init2DGeometry();
9219 G__setnull(result7);
9220 return(1 || funcname || hash || result7 || libp) ;
9221}
9222
9223static int G__BesVisLib_rootcint_840_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9224{
9225 ((TofROOTGeo*) G__getstructoffset())->SetNode();
9226 G__setnull(result7);
9227 return(1 || funcname || hash || result7 || libp) ;
9228}
9229
9230static int G__BesVisLib_rootcint_840_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9231{
9232 ((TofROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
9233 G__setnull(result7);
9234 return(1 || funcname || hash || result7 || libp) ;
9235}
9236
9237static int G__BesVisLib_rootcint_840_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9238{
9239 ((TofROOTGeo*) G__getstructoffset())->SetPhysicalDefaultVis();
9240 G__setnull(result7);
9241 return(1 || funcname || hash || result7 || libp) ;
9242}
9243
9244static int G__BesVisLib_rootcint_840_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9245{
9246 ((TofROOTGeo*) G__getstructoffset())->SetAllVisible();
9247 G__setnull(result7);
9248 return(1 || funcname || hash || result7 || libp) ;
9249}
9250
9251static int G__BesVisLib_rootcint_840_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9252{
9253 ((TofROOTGeo*) G__getstructoffset())->SetTMatch((Bool_t) G__int(libp->para[0]));
9254 G__setnull(result7);
9255 return(1 || funcname || hash || result7 || libp) ;
9256}
9257
9258static int G__BesVisLib_rootcint_840_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9259{
9260 ((TofROOTGeo*) G__getstructoffset())->SetQMatch((Bool_t) G__int(libp->para[0]));
9261 G__setnull(result7);
9262 return(1 || funcname || hash || result7 || libp) ;
9263}
9264
9265static int G__BesVisLib_rootcint_840_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9266{
9267 ((TofROOTGeo*) G__getstructoffset())->SetQuarterVisible();
9268 G__setnull(result7);
9269 return(1 || funcname || hash || result7 || libp) ;
9270}
9271
9272static int G__BesVisLib_rootcint_840_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9273{
9274 ((TofROOTGeo*) G__getstructoffset())->SetHalfVisible();
9275 G__setnull(result7);
9276 return(1 || funcname || hash || result7 || libp) ;
9277}
9278
9279static int G__BesVisLib_rootcint_840_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9280{
9281 ((TofROOTGeo*) G__getstructoffset())->SetNoEndVisible();
9282 G__setnull(result7);
9283 return(1 || funcname || hash || result7 || libp) ;
9284}
9285
9286static int G__BesVisLib_rootcint_840_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9287{
9288 ((TofROOTGeo*) G__getstructoffset())->SetPhysicalNode();
9289 G__setnull(result7);
9290 return(1 || funcname || hash || result7 || libp) ;
9291}
9292
9293static int G__BesVisLib_rootcint_840_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9294{
9295 ((TofROOTGeo*) G__getstructoffset())->SetDetector();
9296 G__setnull(result7);
9297 return(1 || funcname || hash || result7 || libp) ;
9298}
9299
9300static int G__BesVisLib_rootcint_840_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9301{
9302 ((TofROOTGeo*) G__getstructoffset())->SetHits();
9303 G__setnull(result7);
9304 return(1 || funcname || hash || result7 || libp) ;
9305}
9306
9307static int G__BesVisLib_rootcint_840_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9308{
9309 ((TofROOTGeo*) G__getstructoffset())->SetVisTofDetector();
9310 G__setnull(result7);
9311 return(1 || funcname || hash || result7 || libp) ;
9312}
9313
9314static int G__BesVisLib_rootcint_840_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9315{
9316 ((TofROOTGeo*) G__getstructoffset())->SetVisTofHits();
9317 G__setnull(result7);
9318 return(1 || funcname || hash || result7 || libp) ;
9319}
9320
9321static int G__BesVisLib_rootcint_840_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9322{
9323 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetPartNb());
9324 return(1 || funcname || hash || result7 || libp) ;
9325}
9326
9327static int G__BesVisLib_rootcint_840_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9328{
9329 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetScinNb((int) G__int(libp->para[0])));
9330 return(1 || funcname || hash || result7 || libp) ;
9331}
9332
9333static int G__BesVisLib_rootcint_840_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9334{
9335 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetLayerNb((int) G__int(libp->para[0])));
9336 return(1 || funcname || hash || result7 || libp) ;
9337}
9338
9339static int G__BesVisLib_rootcint_840_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9340{
9341 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetModuleNb((int) G__int(libp->para[0])));
9342 return(1 || funcname || hash || result7 || libp) ;
9343}
9344
9345static int G__BesVisLib_rootcint_840_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9346{
9347 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetStripNb((int) G__int(libp->para[0])));
9348 return(1 || funcname || hash || result7 || libp) ;
9349}
9350
9351static int G__BesVisLib_rootcint_840_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9352{
9353 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetChamberNodeNb((int) G__int(libp->para[0])));
9354 return(1 || funcname || hash || result7 || libp) ;
9355}
9356
9357static int G__BesVisLib_rootcint_840_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9358{
9359 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetContainerNodeNb((int) G__int(libp->para[0])));
9360 return(1 || funcname || hash || result7 || libp) ;
9361}
9362
9363static int G__BesVisLib_rootcint_840_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9364{
9365 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetBoard1NodeNb((int) G__int(libp->para[0])));
9366 return(1 || funcname || hash || result7 || libp) ;
9367}
9368
9369static int G__BesVisLib_rootcint_840_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9370{
9371 ((TofROOTGeo*) G__getstructoffset())->SetVolumeTof((TGeoVolume*) G__int(libp->para[0]));
9372 G__setnull(result7);
9373 return(1 || funcname || hash || result7 || libp) ;
9374}
9375
9376static int G__BesVisLib_rootcint_840_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9377{
9378 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeTof());
9379 return(1 || funcname || hash || result7 || libp) ;
9380}
9381
9382static int G__BesVisLib_rootcint_840_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9383{
9384 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumePart((int) G__int(libp->para[0])));
9385 return(1 || funcname || hash || result7 || libp) ;
9386}
9387
9388static int G__BesVisLib_rootcint_840_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9389{
9390 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumePVF((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9391 return(1 || funcname || hash || result7 || libp) ;
9392}
9393
9394static int G__BesVisLib_rootcint_840_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9395{
9396 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeAl((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9397 return(1 || funcname || hash || result7 || libp) ;
9398}
9399
9400static int G__BesVisLib_rootcint_840_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9401{
9402 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9403 return(1 || funcname || hash || result7 || libp) ;
9404}
9405
9406static int G__BesVisLib_rootcint_840_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9407{
9408 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeBucket((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9409 return(1 || funcname || hash || result7 || libp) ;
9410}
9411
9412static int G__BesVisLib_rootcint_840_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9413{
9414 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetPVF((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
9415, (int) G__int(libp->para[2])));
9416 return(1 || funcname || hash || result7 || libp) ;
9417}
9418
9419static int G__BesVisLib_rootcint_840_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9420{
9421 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetAl((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9422 return(1 || funcname || hash || result7 || libp) ;
9423}
9424
9425static int G__BesVisLib_rootcint_840_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9426{
9427 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9428 return(1 || funcname || hash || result7 || libp) ;
9429}
9430
9431static int G__BesVisLib_rootcint_840_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9432{
9433 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetModule((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9434 return(1 || funcname || hash || result7 || libp) ;
9435}
9436
9437static int G__BesVisLib_rootcint_840_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9438{
9439 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
9440, (int) G__int(libp->para[2])));
9441 return(1 || funcname || hash || result7 || libp) ;
9442}
9443
9444static int G__BesVisLib_rootcint_840_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9445{
9446 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetgasContainer((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9447 return(1 || funcname || hash || result7 || libp) ;
9448}
9449
9450static int G__BesVisLib_rootcint_840_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9451{
9452 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetbareChamber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9453 return(1 || funcname || hash || result7 || libp) ;
9454}
9455
9456static int G__BesVisLib_rootcint_840_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9457{
9458 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetpcbBoard1((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
9459 return(1 || funcname || hash || result7 || libp) ;
9460}
9461
9462static int G__BesVisLib_rootcint_840_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9463{
9464 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetPhysicalScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
9465, (int) G__int(libp->para[2])));
9466 return(1 || funcname || hash || result7 || libp) ;
9467}
9468
9469static int G__BesVisLib_rootcint_840_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9470{
9471 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->Get2DScin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
9472, (Int_t) G__int(libp->para[2])));
9473 return(1 || funcname || hash || result7 || libp) ;
9474}
9475
9476static int G__BesVisLib_rootcint_840_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9477{
9478 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
9479 return(1 || funcname || hash || result7 || libp) ;
9480}
9481
9482static int G__BesVisLib_rootcint_840_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9483{
9484 ((TofROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
9485 G__setnull(result7);
9486 return(1 || funcname || hash || result7 || libp) ;
9487}
9488
9489static int G__BesVisLib_rootcint_840_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9490{
9491 ((TofROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
9492 G__setnull(result7);
9493 return(1 || funcname || hash || result7 || libp) ;
9494}
9495
9496// automatic copy constructor
9497static int G__BesVisLib_rootcint_840_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9498
9499{
9500 TofROOTGeo* p;
9501 void* tmp = (void*) G__int(libp->para[0]);
9502 p = new TofROOTGeo(*(TofROOTGeo*) tmp);
9503 result7->obj.i = (long) p;
9504 result7->ref = (long) p;
9505 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
9506 return(1 || funcname || hash || result7 || libp) ;
9507}
9508
9509// automatic destructor
9510typedef TofROOTGeo G__TTofROOTGeo;
9511static int G__BesVisLib_rootcint_840_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9512{
9513 char* gvp = (char*) G__getgvp();
9514 long soff = G__getstructoffset();
9515 int n = G__getaryconstruct();
9516 //
9517 //has_a_delete: 0
9518 //has_own_delete1arg: 0
9519 //has_own_delete2arg: 0
9520 //
9521 if (!soff) {
9522 return(1);
9523 }
9524 if (n) {
9525 if (gvp == (char*)G__PVOID) {
9526 delete[] (TofROOTGeo*) soff;
9527 } else {
9528 G__setgvp((long) G__PVOID);
9529 for (int i = n - 1; i >= 0; --i) {
9530 ((TofROOTGeo*) (soff+(sizeof(TofROOTGeo)*i)))->~G__TTofROOTGeo();
9531 }
9532 G__setgvp((long)gvp);
9533 }
9534 } else {
9535 if (gvp == (char*)G__PVOID) {
9536 delete (TofROOTGeo*) soff;
9537 } else {
9538 G__setgvp((long) G__PVOID);
9539 ((TofROOTGeo*) (soff))->~G__TTofROOTGeo();
9540 G__setgvp((long)gvp);
9541 }
9542 }
9543 G__setnull(result7);
9544 return(1 || funcname || hash || result7 || libp) ;
9545}
9546
9547
9548/* Emc2DCrystal */
9549static int G__BesVisLib_rootcint_841_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9550{
9551 Emc2DCrystal* p = NULL;
9552 char* gvp = (char*) G__getgvp();
9553 int n = G__getaryconstruct();
9554 if (n) {
9555 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9556 p = new Emc2DCrystal[n];
9557 } else {
9558 p = new((void*) gvp) Emc2DCrystal[n];
9559 }
9560 } else {
9561 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9562 p = new Emc2DCrystal;
9563 } else {
9564 p = new((void*) gvp) Emc2DCrystal;
9565 }
9566 }
9567 result7->obj.i = (long) p;
9568 result7->ref = (long) p;
9569 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
9570 return(1 || funcname || hash || result7 || libp) ;
9571}
9572
9573static int G__BesVisLib_rootcint_841_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9574{
9575 Emc2DCrystal* p = NULL;
9576 char* gvp = (char*) G__getgvp();
9577 //m: 6
9578 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9579 p = new Emc2DCrystal(
9580(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
9581, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
9582, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
9583 } else {
9584 p = new((void*) gvp) Emc2DCrystal(
9585(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
9586, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
9587, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
9588 }
9589 result7->obj.i = (long) p;
9590 result7->ref = (long) p;
9591 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
9592 return(1 || funcname || hash || result7 || libp) ;
9593}
9594
9595static int G__BesVisLib_rootcint_841_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9596{
9597 ((Emc2DCrystal*) G__getstructoffset())->SetStyle();
9598 G__setnull(result7);
9599 return(1 || funcname || hash || result7 || libp) ;
9600}
9601
9602static int G__BesVisLib_rootcint_841_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9603{
9604 switch (libp->paran) {
9605 case 1:
9606 ((Emc2DCrystal*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
9607 G__setnull(result7);
9608 break;
9609 case 0:
9610 ((Emc2DCrystal*) G__getstructoffset())->SetHighlighted();
9611 G__setnull(result7);
9612 break;
9613 }
9614 return(1 || funcname || hash || result7 || libp) ;
9615}
9616
9617static int G__BesVisLib_rootcint_841_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9618{
9619 switch (libp->paran) {
9620 case 1:
9621 ((Emc2DCrystal*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
9622 G__setnull(result7);
9623 break;
9624 case 0:
9625 ((Emc2DCrystal*) G__getstructoffset())->SetFired();
9626 G__setnull(result7);
9627 break;
9628 }
9629 return(1 || funcname || hash || result7 || libp) ;
9630}
9631
9632static int G__BesVisLib_rootcint_841_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9633{
9634 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsHighlighted());
9635 return(1 || funcname || hash || result7 || libp) ;
9636}
9637
9638static int G__BesVisLib_rootcint_841_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9639{
9640 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsFired());
9641 return(1 || funcname || hash || result7 || libp) ;
9642}
9643
9644static int G__BesVisLib_rootcint_841_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9645{
9646 ((Emc2DCrystal*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
9647 G__setnull(result7);
9648 return(1 || funcname || hash || result7 || libp) ;
9649}
9650
9651static int G__BesVisLib_rootcint_841_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9652{
9653 ((Emc2DCrystal*) G__getstructoffset())->CloseInfo();
9654 G__setnull(result7);
9655 return(1 || funcname || hash || result7 || libp) ;
9656}
9657
9658static int G__BesVisLib_rootcint_841_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9659{
9660 ((Emc2DCrystal*) G__getstructoffset())->ClearInfo();
9661 G__setnull(result7);
9662 return(1 || funcname || hash || result7 || libp) ;
9663}
9664
9665static int G__BesVisLib_rootcint_841_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9666{
9667 ((Emc2DCrystal*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
9668 G__setnull(result7);
9669 return(1 || funcname || hash || result7 || libp) ;
9670}
9671
9672static int G__BesVisLib_rootcint_841_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9673{
9674 ((Emc2DCrystal*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
9675 G__setnull(result7);
9676 return(1 || funcname || hash || result7 || libp) ;
9677}
9678
9679static int G__BesVisLib_rootcint_841_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9680{
9681 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetTime());
9682 return(1 || funcname || hash || result7 || libp) ;
9683}
9684
9685static int G__BesVisLib_rootcint_841_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9686{
9687 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetCharge());
9688 return(1 || funcname || hash || result7 || libp) ;
9689}
9690
9691static int G__BesVisLib_rootcint_841_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9692{
9693 ((Emc2DCrystal*) G__getstructoffset())->ResetTimeCharge();
9694 G__setnull(result7);
9695 return(1 || funcname || hash || result7 || libp) ;
9696}
9697
9698static int G__BesVisLib_rootcint_841_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9699{
9700 G__letint(result7, 105, (long) ((Emc2DCrystal*) G__getstructoffset())->GetPart());
9701 return(1 || funcname || hash || result7 || libp) ;
9702}
9703
9704static int G__BesVisLib_rootcint_841_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9705{
9706 G__letint(result7, 105, (long) ((Emc2DCrystal*) G__getstructoffset())->GetTheta());
9707 return(1 || funcname || hash || result7 || libp) ;
9708}
9709
9710static int G__BesVisLib_rootcint_841_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9711{
9712 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->HasZRSection());
9713 return(1 || funcname || hash || result7 || libp) ;
9714}
9715
9716static int G__BesVisLib_rootcint_841_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9717{
9718 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
9719 return(1 || funcname || hash || result7 || libp) ;
9720}
9721
9722static int G__BesVisLib_rootcint_841_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9723{
9724 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
9725 return(1 || funcname || hash || result7 || libp) ;
9726}
9727
9728static int G__BesVisLib_rootcint_841_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9729{
9730 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsXYVisible());
9731 return(1 || funcname || hash || result7 || libp) ;
9732}
9733
9734static int G__BesVisLib_rootcint_841_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9735{
9736 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsSideVisible());
9737 return(1 || funcname || hash || result7 || libp) ;
9738}
9739
9740static int G__BesVisLib_rootcint_841_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9741{
9742 ((Emc2DCrystal*) G__getstructoffset())->SetXYPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
9743, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
9744 G__setnull(result7);
9745 return(1 || funcname || hash || result7 || libp) ;
9746}
9747
9748static int G__BesVisLib_rootcint_841_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9749{
9750 ((Emc2DCrystal*) G__getstructoffset())->SetZRPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
9751, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
9752 G__setnull(result7);
9753 return(1 || funcname || hash || result7 || libp) ;
9754}
9755
9756static int G__BesVisLib_rootcint_841_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9757{
9758 ((Emc2DCrystal*) G__getstructoffset())->ProjectECToSide((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
9759 G__setnull(result7);
9760 return(1 || funcname || hash || result7 || libp) ;
9761}
9762
9763static int G__BesVisLib_rootcint_841_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9764{
9765 G__letint(result7, 85, (long) Emc2DCrystal::Class());
9766 return(1 || funcname || hash || result7 || libp) ;
9767}
9768
9769static int G__BesVisLib_rootcint_841_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9770{
9771 G__letint(result7, 67, (long) Emc2DCrystal::Class_Name());
9772 return(1 || funcname || hash || result7 || libp) ;
9773}
9774
9775static int G__BesVisLib_rootcint_841_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9776{
9777 G__letint(result7, 115, (long) Emc2DCrystal::Class_Version());
9778 return(1 || funcname || hash || result7 || libp) ;
9779}
9780
9781static int G__BesVisLib_rootcint_841_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9782{
9783 Emc2DCrystal::Dictionary();
9784 G__setnull(result7);
9785 return(1 || funcname || hash || result7 || libp) ;
9786}
9787
9788static int G__BesVisLib_rootcint_841_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9789{
9790 ((Emc2DCrystal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9791 G__setnull(result7);
9792 return(1 || funcname || hash || result7 || libp) ;
9793}
9794
9795static int G__BesVisLib_rootcint_841_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9796{
9797 G__letint(result7, 67, (long) Emc2DCrystal::DeclFileName());
9798 return(1 || funcname || hash || result7 || libp) ;
9799}
9800
9801static int G__BesVisLib_rootcint_841_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9802{
9803 G__letint(result7, 105, (long) Emc2DCrystal::ImplFileLine());
9804 return(1 || funcname || hash || result7 || libp) ;
9805}
9806
9807static int G__BesVisLib_rootcint_841_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9808{
9809 G__letint(result7, 67, (long) Emc2DCrystal::ImplFileName());
9810 return(1 || funcname || hash || result7 || libp) ;
9811}
9812
9813static int G__BesVisLib_rootcint_841_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9814{
9815 G__letint(result7, 105, (long) Emc2DCrystal::DeclFileLine());
9816 return(1 || funcname || hash || result7 || libp) ;
9817}
9818
9819// automatic copy constructor
9820static int G__BesVisLib_rootcint_841_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9821
9822{
9823 Emc2DCrystal* p;
9824 void* tmp = (void*) G__int(libp->para[0]);
9825 p = new Emc2DCrystal(*(Emc2DCrystal*) tmp);
9826 result7->obj.i = (long) p;
9827 result7->ref = (long) p;
9828 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
9829 return(1 || funcname || hash || result7 || libp) ;
9830}
9831
9832// automatic destructor
9833typedef Emc2DCrystal G__TEmc2DCrystal;
9834static int G__BesVisLib_rootcint_841_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9835{
9836 char* gvp = (char*) G__getgvp();
9837 long soff = G__getstructoffset();
9838 int n = G__getaryconstruct();
9839 //
9840 //has_a_delete: 1
9841 //has_own_delete1arg: 0
9842 //has_own_delete2arg: 0
9843 //
9844 if (!soff) {
9845 return(1);
9846 }
9847 if (n) {
9848 if (gvp == (char*)G__PVOID) {
9849 delete[] (Emc2DCrystal*) soff;
9850 } else {
9851 G__setgvp((long) G__PVOID);
9852 for (int i = n - 1; i >= 0; --i) {
9853 ((Emc2DCrystal*) (soff+(sizeof(Emc2DCrystal)*i)))->~G__TEmc2DCrystal();
9854 }
9855 G__setgvp((long)gvp);
9856 }
9857 } else {
9858 if (gvp == (char*)G__PVOID) {
9859 delete (Emc2DCrystal*) soff;
9860 } else {
9861 G__setgvp((long) G__PVOID);
9862 ((Emc2DCrystal*) (soff))->~G__TEmc2DCrystal();
9863 G__setgvp((long)gvp);
9864 }
9865 }
9866 G__setnull(result7);
9867 return(1 || funcname || hash || result7 || libp) ;
9868}
9869
9870// automatic assignment operator
9871static int G__BesVisLib_rootcint_841_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9872{
9873 Emc2DCrystal* dest = (Emc2DCrystal*) G__getstructoffset();
9874 *dest = *(Emc2DCrystal*) libp->para[0].ref;
9875 const Emc2DCrystal& obj = *dest;
9876 result7->ref = (long) (&obj);
9877 result7->obj.i = (long) (&obj);
9878 return(1 || funcname || hash || result7 || libp) ;
9879}
9880
9881
9882/* EmcROOTGeo */
9883static int G__BesVisLib_rootcint_842_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9884{
9885 EmcROOTGeo* p = NULL;
9886 char* gvp = (char*) G__getgvp();
9887 int n = G__getaryconstruct();
9888 if (n) {
9889 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9890 p = new EmcROOTGeo[n];
9891 } else {
9892 p = new((void*) gvp) EmcROOTGeo[n];
9893 }
9894 } else {
9895 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9896 p = new EmcROOTGeo;
9897 } else {
9898 p = new((void*) gvp) EmcROOTGeo;
9899 }
9900 }
9901 result7->obj.i = (long) p;
9902 result7->ref = (long) p;
9903 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
9904 return(1 || funcname || hash || result7 || libp) ;
9905}
9906
9907static int G__BesVisLib_rootcint_842_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9908{
9909 ((EmcROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
9910 G__setnull(result7);
9911 return(1 || funcname || hash || result7 || libp) ;
9912}
9913
9914static int G__BesVisLib_rootcint_842_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9915{
9916 ((EmcROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
9917 G__setnull(result7);
9918 return(1 || funcname || hash || result7 || libp) ;
9919}
9920
9921static int G__BesVisLib_rootcint_842_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9922{
9923 ((EmcROOTGeo*) G__getstructoffset())->Init2DGeometry();
9924 G__setnull(result7);
9925 return(1 || funcname || hash || result7 || libp) ;
9926}
9927
9928static int G__BesVisLib_rootcint_842_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9929{
9930 ((EmcROOTGeo*) G__getstructoffset())->SetNode();
9931 G__setnull(result7);
9932 return(1 || funcname || hash || result7 || libp) ;
9933}
9934
9935static int G__BesVisLib_rootcint_842_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9936{
9937 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeAppendInVis();
9938 G__setnull(result7);
9939 return(1 || funcname || hash || result7 || libp) ;
9940}
9941
9942static int G__BesVisLib_rootcint_842_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9943{
9944 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
9945 G__setnull(result7);
9946 return(1 || funcname || hash || result7 || libp) ;
9947}
9948
9949static int G__BesVisLib_rootcint_842_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9950{
9951 ((EmcROOTGeo*) G__getstructoffset())->SetAllVisible();
9952 G__setnull(result7);
9953 return(1 || funcname || hash || result7 || libp) ;
9954}
9955
9956static int G__BesVisLib_rootcint_842_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9957{
9958 ((EmcROOTGeo*) G__getstructoffset())->SetQuarterVisible();
9959 G__setnull(result7);
9960 return(1 || funcname || hash || result7 || libp) ;
9961}
9962
9963static int G__BesVisLib_rootcint_842_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9964{
9965 ((EmcROOTGeo*) G__getstructoffset())->SetHalfVisible();
9966 G__setnull(result7);
9967 return(1 || funcname || hash || result7 || libp) ;
9968}
9969
9970static int G__BesVisLib_rootcint_842_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9971{
9972 ((EmcROOTGeo*) G__getstructoffset())->SetNoEndVisible();
9973 G__setnull(result7);
9974 return(1 || funcname || hash || result7 || libp) ;
9975}
9976
9977static int G__BesVisLib_rootcint_842_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9978{
9979 ((EmcROOTGeo*) G__getstructoffset())->SetPhysicalNode();
9980 G__setnull(result7);
9981 return(1 || funcname || hash || result7 || libp) ;
9982}
9983
9984static int G__BesVisLib_rootcint_842_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9985{
9986 ((EmcROOTGeo*) G__getstructoffset())->SetPhysicalDefaultVis();
9987 G__setnull(result7);
9988 return(1 || funcname || hash || result7 || libp) ;
9989}
9990
9991static int G__BesVisLib_rootcint_842_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9992{
9993 ((EmcROOTGeo*) G__getstructoffset())->SetDetector();
9994 G__setnull(result7);
9995 return(1 || funcname || hash || result7 || libp) ;
9996}
9997
9998static int G__BesVisLib_rootcint_842_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9999{
10000 ((EmcROOTGeo*) G__getstructoffset())->SetHits();
10001 G__setnull(result7);
10002 return(1 || funcname || hash || result7 || libp) ;
10003}
10004
10005static int G__BesVisLib_rootcint_842_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10006{
10007 ((EmcROOTGeo*) G__getstructoffset())->SetVisEmcDetector();
10008 G__setnull(result7);
10009 return(1 || funcname || hash || result7 || libp) ;
10010}
10011
10012static int G__BesVisLib_rootcint_842_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10013{
10014 ((EmcROOTGeo*) G__getstructoffset())->SetVisEmcHits();
10015 G__setnull(result7);
10016 return(1 || funcname || hash || result7 || libp) ;
10017}
10018
10019static int G__BesVisLib_rootcint_842_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10020{
10021 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPartNb());
10022 return(1 || funcname || hash || result7 || libp) ;
10023}
10024
10025static int G__BesVisLib_rootcint_842_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10026{
10027 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetThetaNb((int) G__int(libp->para[0])));
10028 return(1 || funcname || hash || result7 || libp) ;
10029}
10030
10031static int G__BesVisLib_rootcint_842_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10032{
10033 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhiNb((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10034 return(1 || funcname || hash || result7 || libp) ;
10035}
10036
10037static int G__BesVisLib_rootcint_842_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10038{
10039 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeEmc((TGeoVolume*) G__int(libp->para[0]));
10040 G__setnull(result7);
10041 return(1 || funcname || hash || result7 || libp) ;
10042}
10043
10044static int G__BesVisLib_rootcint_842_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10045{
10046 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeEmc());
10047 return(1 || funcname || hash || result7 || libp) ;
10048}
10049
10050static int G__BesVisLib_rootcint_842_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10051{
10052 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumePart((int) G__int(libp->para[0])));
10053 return(1 || funcname || hash || result7 || libp) ;
10054}
10055
10056static int G__BesVisLib_rootcint_842_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10057{
10058 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumePhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10059 return(1 || funcname || hash || result7 || libp) ;
10060}
10061
10062static int G__BesVisLib_rootcint_842_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10063{
10064 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10065, (int) G__int(libp->para[2])));
10066 return(1 || funcname || hash || result7 || libp) ;
10067}
10068
10069static int G__BesVisLib_rootcint_842_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10070{
10071 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10072, (int) G__int(libp->para[2])));
10073 return(1 || funcname || hash || result7 || libp) ;
10074}
10075
10076static int G__BesVisLib_rootcint_842_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10077{
10078 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPart((int) G__int(libp->para[0])));
10079 return(1 || funcname || hash || result7 || libp) ;
10080}
10081
10082static int G__BesVisLib_rootcint_842_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10083{
10084 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10085 return(1 || funcname || hash || result7 || libp) ;
10086}
10087
10088static int G__BesVisLib_rootcint_842_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10089{
10090 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10091, (int) G__int(libp->para[2])));
10092 return(1 || funcname || hash || result7 || libp) ;
10093}
10094
10095static int G__BesVisLib_rootcint_842_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10096{
10097 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetTheta2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10098, (int) G__int(libp->para[2])));
10099 return(1 || funcname || hash || result7 || libp) ;
10100}
10101
10102static int G__BesVisLib_rootcint_842_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10103{
10104 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10105, (int) G__int(libp->para[2])));
10106 return(1 || funcname || hash || result7 || libp) ;
10107}
10108
10109static int G__BesVisLib_rootcint_842_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10110{
10111 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetCrystal2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10112, (int) G__int(libp->para[2])));
10113 return(1 || funcname || hash || result7 || libp) ;
10114}
10115
10116static int G__BesVisLib_rootcint_842_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10117{
10118 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhysicalCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10119, (int) G__int(libp->para[2])));
10120 return(1 || funcname || hash || result7 || libp) ;
10121}
10122
10123static int G__BesVisLib_rootcint_842_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10124{
10125 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhysicalCrystal2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10126, (int) G__int(libp->para[2])));
10127 return(1 || funcname || hash || result7 || libp) ;
10128}
10129
10130static int G__BesVisLib_rootcint_842_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10131{
10132 G__letint(result7, 103, (long) ((EmcROOTGeo*) G__getstructoffset())->HasTwoNodes((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10133, (int) G__int(libp->para[2])));
10134 return(1 || funcname || hash || result7 || libp) ;
10135}
10136
10137static int G__BesVisLib_rootcint_842_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10138{
10139 ((EmcROOTGeo*) G__getstructoffset())->ComputeThetaPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10140, (int) G__int(libp->para[2]), *(int*) G__Intref(&libp->para[3])
10141, *(int*) G__Intref(&libp->para[4]));
10142 G__setnull(result7);
10143 return(1 || funcname || hash || result7 || libp) ;
10144}
10145
10146static int G__BesVisLib_rootcint_842_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10147{
10148 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->ComputeEndCopyNb((int) G__int(libp->para[0])));
10149 return(1 || funcname || hash || result7 || libp) ;
10150}
10151
10152static int G__BesVisLib_rootcint_842_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10153{
10154 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->Get2DCrystal((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10155, (Int_t) G__int(libp->para[2])));
10156 return(1 || funcname || hash || result7 || libp) ;
10157}
10158
10159static int G__BesVisLib_rootcint_842_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10160{
10161 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
10162 return(1 || funcname || hash || result7 || libp) ;
10163}
10164
10165static int G__BesVisLib_rootcint_842_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10166{
10167 ((EmcROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
10168 G__setnull(result7);
10169 return(1 || funcname || hash || result7 || libp) ;
10170}
10171
10172static int G__BesVisLib_rootcint_842_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10173{
10174 ((EmcROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
10175 G__setnull(result7);
10176 return(1 || funcname || hash || result7 || libp) ;
10177}
10178
10179static int G__BesVisLib_rootcint_842_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10180{
10181 switch (libp->paran) {
10182 case 4:
10183 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
10184, (TGeoShape*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
10185 G__setnull(result7);
10186 break;
10187 case 3:
10188 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
10189, (TGeoShape*) G__int(libp->para[2]));
10190 G__setnull(result7);
10191 break;
10192 case 2:
10193 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1]));
10194 G__setnull(result7);
10195 break;
10196 case 1:
10197 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]));
10198 G__setnull(result7);
10199 break;
10200 }
10201 return(1 || funcname || hash || result7 || libp) ;
10202}
10203
10204static int G__BesVisLib_rootcint_842_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10205{
10206 ((EmcROOTGeo*) G__getstructoffset())->RestorePhyNode((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1]));
10207 G__setnull(result7);
10208 return(1 || funcname || hash || result7 || libp) ;
10209}
10210
10211// automatic copy constructor
10212static int G__BesVisLib_rootcint_842_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10213
10214{
10215 EmcROOTGeo* p;
10216 void* tmp = (void*) G__int(libp->para[0]);
10217 p = new EmcROOTGeo(*(EmcROOTGeo*) tmp);
10218 result7->obj.i = (long) p;
10219 result7->ref = (long) p;
10220 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
10221 return(1 || funcname || hash || result7 || libp) ;
10222}
10223
10224// automatic destructor
10225typedef EmcROOTGeo G__TEmcROOTGeo;
10226static int G__BesVisLib_rootcint_842_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10227{
10228 char* gvp = (char*) G__getgvp();
10229 long soff = G__getstructoffset();
10230 int n = G__getaryconstruct();
10231 //
10232 //has_a_delete: 0
10233 //has_own_delete1arg: 0
10234 //has_own_delete2arg: 0
10235 //
10236 if (!soff) {
10237 return(1);
10238 }
10239 if (n) {
10240 if (gvp == (char*)G__PVOID) {
10241 delete[] (EmcROOTGeo*) soff;
10242 } else {
10243 G__setgvp((long) G__PVOID);
10244 for (int i = n - 1; i >= 0; --i) {
10245 ((EmcROOTGeo*) (soff+(sizeof(EmcROOTGeo)*i)))->~G__TEmcROOTGeo();
10246 }
10247 G__setgvp((long)gvp);
10248 }
10249 } else {
10250 if (gvp == (char*)G__PVOID) {
10251 delete (EmcROOTGeo*) soff;
10252 } else {
10253 G__setgvp((long) G__PVOID);
10254 ((EmcROOTGeo*) (soff))->~G__TEmcROOTGeo();
10255 G__setgvp((long)gvp);
10256 }
10257 }
10258 G__setnull(result7);
10259 return(1 || funcname || hash || result7 || libp) ;
10260}
10261
10262
10263/* Muc2DStrip */
10264static int G__BesVisLib_rootcint_843_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10265{
10266 Muc2DStrip* p = NULL;
10267 char* gvp = (char*) G__getgvp();
10268 int n = G__getaryconstruct();
10269 if (n) {
10270 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10271 p = new Muc2DStrip[n];
10272 } else {
10273 p = new((void*) gvp) Muc2DStrip[n];
10274 }
10275 } else {
10276 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10277 p = new Muc2DStrip;
10278 } else {
10279 p = new((void*) gvp) Muc2DStrip;
10280 }
10281 }
10282 result7->obj.i = (long) p;
10283 result7->ref = (long) p;
10284 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
10285 return(1 || funcname || hash || result7 || libp) ;
10286}
10287
10288static int G__BesVisLib_rootcint_843_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10289{
10290 Muc2DStrip* p = NULL;
10291 char* gvp = (char*) G__getgvp();
10292 //m: 8
10293 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10294 p = new Muc2DStrip(
10295(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10296, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
10297, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
10298, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
10299 } else {
10300 p = new((void*) gvp) Muc2DStrip(
10301(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10302, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
10303, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
10304, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
10305 }
10306 result7->obj.i = (long) p;
10307 result7->ref = (long) p;
10308 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
10309 return(1 || funcname || hash || result7 || libp) ;
10310}
10311
10312static int G__BesVisLib_rootcint_843_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10313{
10314 ((Muc2DStrip*) G__getstructoffset())->SetStyle();
10315 G__setnull(result7);
10316 return(1 || funcname || hash || result7 || libp) ;
10317}
10318
10319static int G__BesVisLib_rootcint_843_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10320{
10321 switch (libp->paran) {
10322 case 1:
10323 ((Muc2DStrip*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
10324 G__setnull(result7);
10325 break;
10326 case 0:
10327 ((Muc2DStrip*) G__getstructoffset())->SetHighlighted();
10328 G__setnull(result7);
10329 break;
10330 }
10331 return(1 || funcname || hash || result7 || libp) ;
10332}
10333
10334static int G__BesVisLib_rootcint_843_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10335{
10336 switch (libp->paran) {
10337 case 1:
10338 ((Muc2DStrip*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
10339 G__setnull(result7);
10340 break;
10341 case 0:
10342 ((Muc2DStrip*) G__getstructoffset())->SetFired();
10343 G__setnull(result7);
10344 break;
10345 }
10346 return(1 || funcname || hash || result7 || libp) ;
10347}
10348
10349static int G__BesVisLib_rootcint_843_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10350{
10351 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsHighlighted());
10352 return(1 || funcname || hash || result7 || libp) ;
10353}
10354
10355static int G__BesVisLib_rootcint_843_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10356{
10357 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsFired());
10358 return(1 || funcname || hash || result7 || libp) ;
10359}
10360
10361static int G__BesVisLib_rootcint_843_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10362{
10363 ((Muc2DStrip*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
10364 G__setnull(result7);
10365 return(1 || funcname || hash || result7 || libp) ;
10366}
10367
10368static int G__BesVisLib_rootcint_843_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10369{
10370 ((Muc2DStrip*) G__getstructoffset())->CloseInfo();
10371 G__setnull(result7);
10372 return(1 || funcname || hash || result7 || libp) ;
10373}
10374
10375static int G__BesVisLib_rootcint_843_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10376{
10377 ((Muc2DStrip*) G__getstructoffset())->ClearInfo();
10378 G__setnull(result7);
10379 return(1 || funcname || hash || result7 || libp) ;
10380}
10381
10382static int G__BesVisLib_rootcint_843_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10383{
10384 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetPart());
10385 return(1 || funcname || hash || result7 || libp) ;
10386}
10387
10388static int G__BesVisLib_rootcint_843_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10389{
10390 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetSeg());
10391 return(1 || funcname || hash || result7 || libp) ;
10392}
10393
10394static int G__BesVisLib_rootcint_843_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10395{
10396 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetGap());
10397 return(1 || funcname || hash || result7 || libp) ;
10398}
10399
10400static int G__BesVisLib_rootcint_843_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10401{
10402 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetStrip());
10403 return(1 || funcname || hash || result7 || libp) ;
10404}
10405
10406static int G__BesVisLib_rootcint_843_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10407{
10408 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsZRVisible());
10409 return(1 || funcname || hash || result7 || libp) ;
10410}
10411
10412static int G__BesVisLib_rootcint_843_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10413{
10414 G__letdouble(result7, 100, (double) ((Muc2DStrip*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
10415 return(1 || funcname || hash || result7 || libp) ;
10416}
10417
10418static int G__BesVisLib_rootcint_843_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10419{
10420 G__letdouble(result7, 100, (double) ((Muc2DStrip*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
10421 return(1 || funcname || hash || result7 || libp) ;
10422}
10423
10424static int G__BesVisLib_rootcint_843_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10425{
10426 G__letint(result7, 85, (long) Muc2DStrip::Class());
10427 return(1 || funcname || hash || result7 || libp) ;
10428}
10429
10430static int G__BesVisLib_rootcint_843_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10431{
10432 G__letint(result7, 67, (long) Muc2DStrip::Class_Name());
10433 return(1 || funcname || hash || result7 || libp) ;
10434}
10435
10436static int G__BesVisLib_rootcint_843_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10437{
10438 G__letint(result7, 115, (long) Muc2DStrip::Class_Version());
10439 return(1 || funcname || hash || result7 || libp) ;
10440}
10441
10442static int G__BesVisLib_rootcint_843_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10443{
10444 Muc2DStrip::Dictionary();
10445 G__setnull(result7);
10446 return(1 || funcname || hash || result7 || libp) ;
10447}
10448
10449static int G__BesVisLib_rootcint_843_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10450{
10451 ((Muc2DStrip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10452 G__setnull(result7);
10453 return(1 || funcname || hash || result7 || libp) ;
10454}
10455
10456static int G__BesVisLib_rootcint_843_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10457{
10458 G__letint(result7, 67, (long) Muc2DStrip::DeclFileName());
10459 return(1 || funcname || hash || result7 || libp) ;
10460}
10461
10462static int G__BesVisLib_rootcint_843_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10463{
10464 G__letint(result7, 105, (long) Muc2DStrip::ImplFileLine());
10465 return(1 || funcname || hash || result7 || libp) ;
10466}
10467
10468static int G__BesVisLib_rootcint_843_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10469{
10470 G__letint(result7, 67, (long) Muc2DStrip::ImplFileName());
10471 return(1 || funcname || hash || result7 || libp) ;
10472}
10473
10474static int G__BesVisLib_rootcint_843_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10475{
10476 G__letint(result7, 105, (long) Muc2DStrip::DeclFileLine());
10477 return(1 || funcname || hash || result7 || libp) ;
10478}
10479
10480// automatic copy constructor
10481static int G__BesVisLib_rootcint_843_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10482
10483{
10484 Muc2DStrip* p;
10485 void* tmp = (void*) G__int(libp->para[0]);
10486 p = new Muc2DStrip(*(Muc2DStrip*) tmp);
10487 result7->obj.i = (long) p;
10488 result7->ref = (long) p;
10489 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
10490 return(1 || funcname || hash || result7 || libp) ;
10491}
10492
10493// automatic destructor
10494typedef Muc2DStrip G__TMuc2DStrip;
10495static int G__BesVisLib_rootcint_843_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10496{
10497 char* gvp = (char*) G__getgvp();
10498 long soff = G__getstructoffset();
10499 int n = G__getaryconstruct();
10500 //
10501 //has_a_delete: 1
10502 //has_own_delete1arg: 0
10503 //has_own_delete2arg: 0
10504 //
10505 if (!soff) {
10506 return(1);
10507 }
10508 if (n) {
10509 if (gvp == (char*)G__PVOID) {
10510 delete[] (Muc2DStrip*) soff;
10511 } else {
10512 G__setgvp((long) G__PVOID);
10513 for (int i = n - 1; i >= 0; --i) {
10514 ((Muc2DStrip*) (soff+(sizeof(Muc2DStrip)*i)))->~G__TMuc2DStrip();
10515 }
10516 G__setgvp((long)gvp);
10517 }
10518 } else {
10519 if (gvp == (char*)G__PVOID) {
10520 delete (Muc2DStrip*) soff;
10521 } else {
10522 G__setgvp((long) G__PVOID);
10523 ((Muc2DStrip*) (soff))->~G__TMuc2DStrip();
10524 G__setgvp((long)gvp);
10525 }
10526 }
10527 G__setnull(result7);
10528 return(1 || funcname || hash || result7 || libp) ;
10529}
10530
10531// automatic assignment operator
10532static int G__BesVisLib_rootcint_843_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10533{
10534 Muc2DStrip* dest = (Muc2DStrip*) G__getstructoffset();
10535 *dest = *(Muc2DStrip*) libp->para[0].ref;
10536 const Muc2DStrip& obj = *dest;
10537 result7->ref = (long) (&obj);
10538 result7->obj.i = (long) (&obj);
10539 return(1 || funcname || hash || result7 || libp) ;
10540}
10541
10542
10543/* MucROOTGeo */
10544static int G__BesVisLib_rootcint_844_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10545{
10546 MucROOTGeo* p = NULL;
10547 char* gvp = (char*) G__getgvp();
10548 int n = G__getaryconstruct();
10549 if (n) {
10550 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10551 p = new MucROOTGeo[n];
10552 } else {
10553 p = new((void*) gvp) MucROOTGeo[n];
10554 }
10555 } else {
10556 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10557 p = new MucROOTGeo;
10558 } else {
10559 p = new((void*) gvp) MucROOTGeo;
10560 }
10561 }
10562 result7->obj.i = (long) p;
10563 result7->ref = (long) p;
10564 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
10565 return(1 || funcname || hash || result7 || libp) ;
10566}
10567
10568static int G__BesVisLib_rootcint_844_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10569{
10570 ((MucROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10571 G__setnull(result7);
10572 return(1 || funcname || hash || result7 || libp) ;
10573}
10574
10575static int G__BesVisLib_rootcint_844_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10576{
10577 ((MucROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
10578 G__setnull(result7);
10579 return(1 || funcname || hash || result7 || libp) ;
10580}
10581
10582static int G__BesVisLib_rootcint_844_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10583{
10584 ((MucROOTGeo*) G__getstructoffset())->Init2DGeometry();
10585 G__setnull(result7);
10586 return(1 || funcname || hash || result7 || libp) ;
10587}
10588
10589static int G__BesVisLib_rootcint_844_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10590{
10591 ((MucROOTGeo*) G__getstructoffset())->SetNode();
10592 G__setnull(result7);
10593 return(1 || funcname || hash || result7 || libp) ;
10594}
10595
10596static int G__BesVisLib_rootcint_844_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10597{
10598 ((MucROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
10599 G__setnull(result7);
10600 return(1 || funcname || hash || result7 || libp) ;
10601}
10602
10603static int G__BesVisLib_rootcint_844_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10604{
10605 ((MucROOTGeo*) G__getstructoffset())->SetPhysicalDefaultVis();
10606 G__setnull(result7);
10607 return(1 || funcname || hash || result7 || libp) ;
10608}
10609
10610static int G__BesVisLib_rootcint_844_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10611{
10612 ((MucROOTGeo*) G__getstructoffset())->SetAllVisible();
10613 G__setnull(result7);
10614 return(1 || funcname || hash || result7 || libp) ;
10615}
10616
10617static int G__BesVisLib_rootcint_844_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10618{
10619 ((MucROOTGeo*) G__getstructoffset())->SetQuarterVisible();
10620 G__setnull(result7);
10621 return(1 || funcname || hash || result7 || libp) ;
10622}
10623
10624static int G__BesVisLib_rootcint_844_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10625{
10626 ((MucROOTGeo*) G__getstructoffset())->SetHalfVisible();
10627 G__setnull(result7);
10628 return(1 || funcname || hash || result7 || libp) ;
10629}
10630
10631static int G__BesVisLib_rootcint_844_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10632{
10633 ((MucROOTGeo*) G__getstructoffset())->SetNoEndVisible();
10634 G__setnull(result7);
10635 return(1 || funcname || hash || result7 || libp) ;
10636}
10637
10638static int G__BesVisLib_rootcint_844_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10639{
10640 ((MucROOTGeo*) G__getstructoffset())->SetPhysicalNode();
10641 G__setnull(result7);
10642 return(1 || funcname || hash || result7 || libp) ;
10643}
10644
10645static int G__BesVisLib_rootcint_844_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10646{
10647 ((MucROOTGeo*) G__getstructoffset())->SetDetector();
10648 G__setnull(result7);
10649 return(1 || funcname || hash || result7 || libp) ;
10650}
10651
10652static int G__BesVisLib_rootcint_844_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10653{
10654 ((MucROOTGeo*) G__getstructoffset())->SetHits();
10655 G__setnull(result7);
10656 return(1 || funcname || hash || result7 || libp) ;
10657}
10658
10659static int G__BesVisLib_rootcint_844_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10660{
10661 ((MucROOTGeo*) G__getstructoffset())->SetVisMucDetector();
10662 G__setnull(result7);
10663 return(1 || funcname || hash || result7 || libp) ;
10664}
10665
10666static int G__BesVisLib_rootcint_844_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10667{
10668 ((MucROOTGeo*) G__getstructoffset())->SetVisMucHits();
10669 G__setnull(result7);
10670 return(1 || funcname || hash || result7 || libp) ;
10671}
10672
10673static int G__BesVisLib_rootcint_844_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10674{
10675 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetPartNb());
10676 return(1 || funcname || hash || result7 || libp) ;
10677}
10678
10679static int G__BesVisLib_rootcint_844_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10680{
10681 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetSegNb((int) G__int(libp->para[0])));
10682 return(1 || funcname || hash || result7 || libp) ;
10683}
10684
10685static int G__BesVisLib_rootcint_844_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10686{
10687 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetGapNb((int) G__int(libp->para[0])));
10688 return(1 || funcname || hash || result7 || libp) ;
10689}
10690
10691static int G__BesVisLib_rootcint_844_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10692{
10693 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetStripNb((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10694, (int) G__int(libp->para[2])));
10695 return(1 || funcname || hash || result7 || libp) ;
10696}
10697
10698static int G__BesVisLib_rootcint_844_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10699{
10700 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorberNb((int) G__int(libp->para[0])));
10701 return(1 || funcname || hash || result7 || libp) ;
10702}
10703
10704static int G__BesVisLib_rootcint_844_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10705{
10706 ((MucROOTGeo*) G__getstructoffset())->SetVolumeMuc((TGeoVolume*) G__int(libp->para[0]));
10707 G__setnull(result7);
10708 return(1 || funcname || hash || result7 || libp) ;
10709}
10710
10711static int G__BesVisLib_rootcint_844_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10712{
10713 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeMuc());
10714 return(1 || funcname || hash || result7 || libp) ;
10715}
10716
10717static int G__BesVisLib_rootcint_844_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10718{
10719 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10720, (int) G__int(libp->para[2])));
10721 return(1 || funcname || hash || result7 || libp) ;
10722}
10723
10724static int G__BesVisLib_rootcint_844_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10725{
10726 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorberSmallBlock((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10727 return(1 || funcname || hash || result7 || libp) ;
10728}
10729
10730static int G__BesVisLib_rootcint_844_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10731{
10732 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10733, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10734 return(1 || funcname || hash || result7 || libp) ;
10735}
10736
10737static int G__BesVisLib_rootcint_844_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10738{
10739 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10740, (int) G__int(libp->para[2])));
10741 return(1 || funcname || hash || result7 || libp) ;
10742}
10743
10744static int G__BesVisLib_rootcint_844_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10745{
10746 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBox((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10747, (int) G__int(libp->para[2])));
10748 return(1 || funcname || hash || result7 || libp) ;
10749}
10750
10751static int G__BesVisLib_rootcint_844_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10752{
10753 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBoxSurface((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10754, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10755 return(1 || funcname || hash || result7 || libp) ;
10756}
10757
10758static int G__BesVisLib_rootcint_844_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10759{
10760 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10761, (int) G__int(libp->para[2])));
10762 return(1 || funcname || hash || result7 || libp) ;
10763}
10764
10765static int G__BesVisLib_rootcint_844_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10766{
10767 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10768, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10769 return(1 || funcname || hash || result7 || libp) ;
10770}
10771
10772static int G__BesVisLib_rootcint_844_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10773{
10774 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGasChamber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10775, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10776, (int) G__int(libp->para[4])));
10777 return(1 || funcname || hash || result7 || libp) ;
10778}
10779
10780static int G__BesVisLib_rootcint_844_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10781{
10782 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGasBorder((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10783, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10784, (int) G__int(libp->para[4])));
10785 return(1 || funcname || hash || result7 || libp) ;
10786}
10787
10788static int G__BesVisLib_rootcint_844_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10789{
10790 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBakelite((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10791, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10792, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
10793 return(1 || funcname || hash || result7 || libp) ;
10794}
10795
10796static int G__BesVisLib_rootcint_844_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10797{
10798 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10799, (int) G__int(libp->para[2])));
10800 return(1 || funcname || hash || result7 || libp) ;
10801}
10802
10803static int G__BesVisLib_rootcint_844_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10804{
10805 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10806, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10807 return(1 || funcname || hash || result7 || libp) ;
10808}
10809
10810static int G__BesVisLib_rootcint_844_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10811{
10812 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10813, (int) G__int(libp->para[2])));
10814 return(1 || funcname || hash || result7 || libp) ;
10815}
10816
10817static int G__BesVisLib_rootcint_844_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10818{
10819 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10820, (int) G__int(libp->para[2])));
10821 return(1 || funcname || hash || result7 || libp) ;
10822}
10823
10824static int G__BesVisLib_rootcint_844_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10825{
10826 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10827, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10828 return(1 || funcname || hash || result7 || libp) ;
10829}
10830
10831static int G__BesVisLib_rootcint_844_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10832{
10833 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10834, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10835 return(1 || funcname || hash || result7 || libp) ;
10836}
10837
10838static int G__BesVisLib_rootcint_844_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10839{
10840 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10841, (int) G__int(libp->para[2])));
10842 return(1 || funcname || hash || result7 || libp) ;
10843}
10844
10845static int G__BesVisLib_rootcint_844_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10846{
10847 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10848, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10849 return(1 || funcname || hash || result7 || libp) ;
10850}
10851
10852static int G__BesVisLib_rootcint_844_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10853{
10854 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->Get2DStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10855, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10856 return(1 || funcname || hash || result7 || libp) ;
10857}
10858
10859static int G__BesVisLib_rootcint_844_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10860{
10861 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
10862 return(1 || funcname || hash || result7 || libp) ;
10863}
10864
10865static int G__BesVisLib_rootcint_844_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10866{
10867 G__letint(result7, 103, (long) ((MucROOTGeo*) G__getstructoffset())->IsZRVisible((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10868 return(1 || funcname || hash || result7 || libp) ;
10869}
10870
10871static int G__BesVisLib_rootcint_844_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10872{
10873 G__letdouble(result7, 100, (double) ((MucROOTGeo*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
10874 return(1 || funcname || hash || result7 || libp) ;
10875}
10876
10877static int G__BesVisLib_rootcint_844_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10878{
10879 ((MucROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
10880 G__setnull(result7);
10881 return(1 || funcname || hash || result7 || libp) ;
10882}
10883
10884static int G__BesVisLib_rootcint_844_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10885{
10886 ((MucROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
10887 G__setnull(result7);
10888 return(1 || funcname || hash || result7 || libp) ;
10889}
10890
10891// automatic copy constructor
10892static int G__BesVisLib_rootcint_844_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10893
10894{
10895 MucROOTGeo* p;
10896 void* tmp = (void*) G__int(libp->para[0]);
10897 p = new MucROOTGeo(*(MucROOTGeo*) tmp);
10898 result7->obj.i = (long) p;
10899 result7->ref = (long) p;
10900 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
10901 return(1 || funcname || hash || result7 || libp) ;
10902}
10903
10904// automatic destructor
10905typedef MucROOTGeo G__TMucROOTGeo;
10906static int G__BesVisLib_rootcint_844_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10907{
10908 char* gvp = (char*) G__getgvp();
10909 long soff = G__getstructoffset();
10910 int n = G__getaryconstruct();
10911 //
10912 //has_a_delete: 0
10913 //has_own_delete1arg: 0
10914 //has_own_delete2arg: 0
10915 //
10916 if (!soff) {
10917 return(1);
10918 }
10919 if (n) {
10920 if (gvp == (char*)G__PVOID) {
10921 delete[] (MucROOTGeo*) soff;
10922 } else {
10923 G__setgvp((long) G__PVOID);
10924 for (int i = n - 1; i >= 0; --i) {
10925 ((MucROOTGeo*) (soff+(sizeof(MucROOTGeo)*i)))->~G__TMucROOTGeo();
10926 }
10927 G__setgvp((long)gvp);
10928 }
10929 } else {
10930 if (gvp == (char*)G__PVOID) {
10931 delete (MucROOTGeo*) soff;
10932 } else {
10933 G__setgvp((long) G__PVOID);
10934 ((MucROOTGeo*) (soff))->~G__TMucROOTGeo();
10935 G__setgvp((long)gvp);
10936 }
10937 }
10938 G__setnull(result7);
10939 return(1 || funcname || hash || result7 || libp) ;
10940}
10941
10942
10943/* BesGeometry */
10944static int G__BesVisLib_rootcint_845_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10945{
10946 BesGeometry* p = NULL;
10947 char* gvp = (char*) G__getgvp();
10948 int n = G__getaryconstruct();
10949 if (n) {
10950 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10951 p = new BesGeometry[n];
10952 } else {
10953 p = new((void*) gvp) BesGeometry[n];
10954 }
10955 } else {
10956 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10957 p = new BesGeometry;
10958 } else {
10959 p = new((void*) gvp) BesGeometry;
10960 }
10961 }
10962 result7->obj.i = (long) p;
10963 result7->ref = (long) p;
10964 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
10965 return(1 || funcname || hash || result7 || libp) ;
10966}
10967
10968static int G__BesVisLib_rootcint_845_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10969{
10970 switch (libp->paran) {
10971 case 3:
10972 ((BesGeometry*) G__getstructoffset())->InitFromGDML(*((const TString*) G__int(libp->para[0])), (bool) G__int(libp->para[1])
10973, (bool) G__int(libp->para[2]));
10974 G__setnull(result7);
10975 break;
10976 case 2:
10977 ((BesGeometry*) G__getstructoffset())->InitFromGDML(*((const TString*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
10978 G__setnull(result7);
10979 break;
10980 case 1:
10981 ((BesGeometry*) G__getstructoffset())->InitFromGDML(*((const TString*) G__int(libp->para[0])));
10982 G__setnull(result7);
10983 break;
10984 }
10985 return(1 || funcname || hash || result7 || libp) ;
10986}
10987
10988static int G__BesVisLib_rootcint_845_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10989{
10990 ((BesGeometry*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
10991 G__setnull(result7);
10992 return(1 || funcname || hash || result7 || libp) ;
10993}
10994
10995static int G__BesVisLib_rootcint_845_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10996{
10997 ((BesGeometry*) G__getstructoffset())->InitGeometry();
10998 G__setnull(result7);
10999 return(1 || funcname || hash || result7 || libp) ;
11000}
11001
11002static int G__BesVisLib_rootcint_845_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11003{
11004 G__letint(result7, 67, (long) ((BesGeometry*) G__getstructoffset())->GetFilename((const char*) G__int(libp->para[0])));
11005 return(1 || funcname || hash || result7 || libp) ;
11006}
11007
11008static int G__BesVisLib_rootcint_845_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11009{
11010 ((BesGeometry*) G__getstructoffset())->SetDefaultVis();
11011 G__setnull(result7);
11012 return(1 || funcname || hash || result7 || libp) ;
11013}
11014
11015static int G__BesVisLib_rootcint_845_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11016{
11017 ((BesGeometry*) G__getstructoffset())->SetPhysicalDefaultVis();
11018 G__setnull(result7);
11019 return(1 || funcname || hash || result7 || libp) ;
11020}
11021
11022static int G__BesVisLib_rootcint_845_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11023{
11024 ((BesGeometry*) G__getstructoffset())->Draw3D();
11025 G__setnull(result7);
11026 return(1 || funcname || hash || result7 || libp) ;
11027}
11028
11029static int G__BesVisLib_rootcint_845_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11030{
11031 ((BesGeometry*) G__getstructoffset())->Draw2DXY();
11032 G__setnull(result7);
11033 return(1 || funcname || hash || result7 || libp) ;
11034}
11035
11036static int G__BesVisLib_rootcint_845_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11037{
11038 ((BesGeometry*) G__getstructoffset())->Draw2DZR();
11039 G__setnull(result7);
11040 return(1 || funcname || hash || result7 || libp) ;
11041}
11042
11043static int G__BesVisLib_rootcint_845_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11044{
11045 G__letdouble(result7, 102, (double) ((BesGeometry*) G__getstructoffset())->GetBesR());
11046 return(1 || funcname || hash || result7 || libp) ;
11047}
11048
11049static int G__BesVisLib_rootcint_845_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11050{
11051 G__letdouble(result7, 102, (double) ((BesGeometry*) G__getstructoffset())->GetBesZ());
11052 return(1 || funcname || hash || result7 || libp) ;
11053}
11054
11055static int G__BesVisLib_rootcint_845_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11056{
11057 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolBes());
11058 return(1 || funcname || hash || result7 || libp) ;
11059}
11060
11061static int G__BesVisLib_rootcint_845_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11062{
11063 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeBeamPipe());
11064 return(1 || funcname || hash || result7 || libp) ;
11065}
11066
11067static int G__BesVisLib_rootcint_845_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11068{
11069 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetMdcROOTGeo());
11070 return(1 || funcname || hash || result7 || libp) ;
11071}
11072
11073static int G__BesVisLib_rootcint_845_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11074{
11075 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetTofROOTGeo());
11076 return(1 || funcname || hash || result7 || libp) ;
11077}
11078
11079static int G__BesVisLib_rootcint_845_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11080{
11081 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetEmcROOTGeo());
11082 return(1 || funcname || hash || result7 || libp) ;
11083}
11084
11085static int G__BesVisLib_rootcint_845_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11086{
11087 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetMucROOTGeo());
11088 return(1 || funcname || hash || result7 || libp) ;
11089}
11090
11091static int G__BesVisLib_rootcint_845_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11092{
11093 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdc());
11094 return(1 || funcname || hash || result7 || libp) ;
11095}
11096
11097static int G__BesVisLib_rootcint_845_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11098{
11099 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcSegment((int) G__int(libp->para[0])));
11100 return(1 || funcname || hash || result7 || libp) ;
11101}
11102
11103static int G__BesVisLib_rootcint_845_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11104{
11105 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcLayer((int) G__int(libp->para[0])));
11106 return(1 || funcname || hash || result7 || libp) ;
11107}
11108
11109static int G__BesVisLib_rootcint_845_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11110{
11111 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcReplica((int) G__int(libp->para[0])));
11112 return(1 || funcname || hash || result7 || libp) ;
11113}
11114
11115static int G__BesVisLib_rootcint_845_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11116{
11117 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMdcReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
11118 return(1 || funcname || hash || result7 || libp) ;
11119}
11120
11121static int G__BesVisLib_rootcint_845_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11122{
11123 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeTof());
11124 return(1 || funcname || hash || result7 || libp) ;
11125}
11126
11127static int G__BesVisLib_rootcint_845_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11128{
11129 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalTofScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11130, (int) G__int(libp->para[2])));
11131 return(1 || funcname || hash || result7 || libp) ;
11132}
11133
11134static int G__BesVisLib_rootcint_845_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11135{
11136 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmc());
11137 return(1 || funcname || hash || result7 || libp) ;
11138}
11139
11140static int G__BesVisLib_rootcint_845_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11141{
11142 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcPart((int) G__int(libp->para[0])));
11143 return(1 || funcname || hash || result7 || libp) ;
11144}
11145
11146static int G__BesVisLib_rootcint_845_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11147{
11148 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
11149 return(1 || funcname || hash || result7 || libp) ;
11150}
11151
11152static int G__BesVisLib_rootcint_845_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11153{
11154 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11155, (int) G__int(libp->para[2])));
11156 return(1 || funcname || hash || result7 || libp) ;
11157}
11158
11159static int G__BesVisLib_rootcint_845_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11160{
11161 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11162, (int) G__int(libp->para[2])));
11163 return(1 || funcname || hash || result7 || libp) ;
11164}
11165
11166static int G__BesVisLib_rootcint_845_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11167{
11168 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalEmcCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11169, (int) G__int(libp->para[2])));
11170 return(1 || funcname || hash || result7 || libp) ;
11171}
11172
11173static int G__BesVisLib_rootcint_845_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11174{
11175 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMuc());
11176 return(1 || funcname || hash || result7 || libp) ;
11177}
11178
11179static int G__BesVisLib_rootcint_845_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11180{
11181 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11182, (int) G__int(libp->para[2])));
11183 return(1 || funcname || hash || result7 || libp) ;
11184}
11185
11186static int G__BesVisLib_rootcint_845_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11187{
11188 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11189, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
11190 return(1 || funcname || hash || result7 || libp) ;
11191}
11192
11193static int G__BesVisLib_rootcint_845_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11194{
11195 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11196, (int) G__int(libp->para[2])));
11197 return(1 || funcname || hash || result7 || libp) ;
11198}
11199
11200static int G__BesVisLib_rootcint_845_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11201{
11202 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11203, (int) G__int(libp->para[2])));
11204 return(1 || funcname || hash || result7 || libp) ;
11205}
11206
11207static int G__BesVisLib_rootcint_845_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11208{
11209 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11210, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
11211 return(1 || funcname || hash || result7 || libp) ;
11212}
11213
11214static int G__BesVisLib_rootcint_845_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11215{
11216 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucGasChamber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11217, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
11218, (int) G__int(libp->para[4])));
11219 return(1 || funcname || hash || result7 || libp) ;
11220}
11221
11222static int G__BesVisLib_rootcint_845_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11223{
11224 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucBakelite((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11225, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
11226, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
11227 return(1 || funcname || hash || result7 || libp) ;
11228}
11229
11230static int G__BesVisLib_rootcint_845_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11231{
11232 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMucGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11233, (int) G__int(libp->para[2])));
11234 return(1 || funcname || hash || result7 || libp) ;
11235}
11236
11237static int G__BesVisLib_rootcint_845_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11238{
11239 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMucStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
11240, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
11241 return(1 || funcname || hash || result7 || libp) ;
11242}
11243
11244static int G__BesVisLib_rootcint_845_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11245{
11246 G__letint(result7, 85, (long) BesGeometry::Class());
11247 return(1 || funcname || hash || result7 || libp) ;
11248}
11249
11250static int G__BesVisLib_rootcint_845_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11251{
11252 G__letint(result7, 67, (long) BesGeometry::Class_Name());
11253 return(1 || funcname || hash || result7 || libp) ;
11254}
11255
11256static int G__BesVisLib_rootcint_845_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11257{
11258 G__letint(result7, 115, (long) BesGeometry::Class_Version());
11259 return(1 || funcname || hash || result7 || libp) ;
11260}
11261
11262static int G__BesVisLib_rootcint_845_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11263{
11264 BesGeometry::Dictionary();
11265 G__setnull(result7);
11266 return(1 || funcname || hash || result7 || libp) ;
11267}
11268
11269static int G__BesVisLib_rootcint_845_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11270{
11271 ((BesGeometry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11272 G__setnull(result7);
11273 return(1 || funcname || hash || result7 || libp) ;
11274}
11275
11276static int G__BesVisLib_rootcint_845_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11277{
11278 G__letint(result7, 67, (long) BesGeometry::DeclFileName());
11279 return(1 || funcname || hash || result7 || libp) ;
11280}
11281
11282static int G__BesVisLib_rootcint_845_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11283{
11284 G__letint(result7, 105, (long) BesGeometry::ImplFileLine());
11285 return(1 || funcname || hash || result7 || libp) ;
11286}
11287
11288static int G__BesVisLib_rootcint_845_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11289{
11290 G__letint(result7, 67, (long) BesGeometry::ImplFileName());
11291 return(1 || funcname || hash || result7 || libp) ;
11292}
11293
11294static int G__BesVisLib_rootcint_845_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11295{
11296 G__letint(result7, 105, (long) BesGeometry::DeclFileLine());
11297 return(1 || funcname || hash || result7 || libp) ;
11298}
11299
11300// automatic copy constructor
11301static int G__BesVisLib_rootcint_845_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11302
11303{
11304 BesGeometry* p;
11305 void* tmp = (void*) G__int(libp->para[0]);
11306 p = new BesGeometry(*(BesGeometry*) tmp);
11307 result7->obj.i = (long) p;
11308 result7->ref = (long) p;
11309 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
11310 return(1 || funcname || hash || result7 || libp) ;
11311}
11312
11313// automatic destructor
11314typedef BesGeometry G__TBesGeometry;
11315static int G__BesVisLib_rootcint_845_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11316{
11317 char* gvp = (char*) G__getgvp();
11318 long soff = G__getstructoffset();
11319 int n = G__getaryconstruct();
11320 //
11321 //has_a_delete: 1
11322 //has_own_delete1arg: 0
11323 //has_own_delete2arg: 0
11324 //
11325 if (!soff) {
11326 return(1);
11327 }
11328 if (n) {
11329 if (gvp == (char*)G__PVOID) {
11330 delete[] (BesGeometry*) soff;
11331 } else {
11332 G__setgvp((long) G__PVOID);
11333 for (int i = n - 1; i >= 0; --i) {
11334 ((BesGeometry*) (soff+(sizeof(BesGeometry)*i)))->~G__TBesGeometry();
11335 }
11336 G__setgvp((long)gvp);
11337 }
11338 } else {
11339 if (gvp == (char*)G__PVOID) {
11340 delete (BesGeometry*) soff;
11341 } else {
11342 G__setgvp((long) G__PVOID);
11343 ((BesGeometry*) (soff))->~G__TBesGeometry();
11344 G__setgvp((long)gvp);
11345 }
11346 }
11347 G__setnull(result7);
11348 return(1 || funcname || hash || result7 || libp) ;
11349}
11350
11351// automatic assignment operator
11352static int G__BesVisLib_rootcint_845_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11353{
11354 BesGeometry* dest = (BesGeometry*) G__getstructoffset();
11355 *dest = *(BesGeometry*) libp->para[0].ref;
11356 const BesGeometry& obj = *dest;
11357 result7->ref = (long) (&obj);
11358 result7->obj.i = (long) (&obj);
11359 return(1 || funcname || hash || result7 || libp) ;
11360}
11361
11362
11363/* BesGMenuTitle */
11364static int G__BesVisLib_rootcint_925_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11365{
11366 BesGMenuTitle* p = NULL;
11367 char* gvp = (char*) G__getgvp();
11368 switch (libp->paran) {
11369 case 6:
11370 //m: 6
11371 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11372 p = new BesGMenuTitle(
11373(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11374, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11375, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11376 } else {
11377 p = new((void*) gvp) BesGMenuTitle(
11378(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11379, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11380, (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11381 }
11382 break;
11383 case 5:
11384 //m: 5
11385 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11386 p = new BesGMenuTitle(
11387(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11388, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11389, (FontStruct_t) G__int(libp->para[4]));
11390 } else {
11391 p = new((void*) gvp) BesGMenuTitle(
11392(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11393, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11394, (FontStruct_t) G__int(libp->para[4]));
11395 }
11396 break;
11397 case 4:
11398 //m: 4
11399 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11400 p = new BesGMenuTitle(
11401(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11402, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11403 } else {
11404 p = new((void*) gvp) BesGMenuTitle(
11405(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11406, (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11407 }
11408 break;
11409 case 3:
11410 //m: 3
11411 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11412 p = new BesGMenuTitle(
11413(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11414, (TGPopupMenu*) G__int(libp->para[2]));
11415 } else {
11416 p = new((void*) gvp) BesGMenuTitle(
11417(TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11418, (TGPopupMenu*) G__int(libp->para[2]));
11419 }
11420 break;
11421 case 2:
11422 //m: 2
11423 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11424 p = new BesGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
11425 } else {
11426 p = new((void*) gvp) BesGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
11427 }
11428 break;
11429 case 1:
11430 //m: 1
11431 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11432 p = new BesGMenuTitle((TGWindow*) G__int(libp->para[0]));
11433 } else {
11434 p = new((void*) gvp) BesGMenuTitle((TGWindow*) G__int(libp->para[0]));
11435 }
11436 break;
11437 case 0:
11438 int n = G__getaryconstruct();
11439 if (n) {
11440 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11441 p = new BesGMenuTitle[n];
11442 } else {
11443 p = new((void*) gvp) BesGMenuTitle[n];
11444 }
11445 } else {
11446 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11447 p = new BesGMenuTitle;
11448 } else {
11449 p = new((void*) gvp) BesGMenuTitle;
11450 }
11451 }
11452 break;
11453 }
11454 result7->obj.i = (long) p;
11455 result7->ref = (long) p;
11456 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
11457 return(1 || funcname || hash || result7 || libp) ;
11458}
11459
11460static int G__BesVisLib_rootcint_925_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11461{
11462 ((BesGMenuTitle*) G__getstructoffset())->SetPicture((Pixmap_t) G__int(libp->para[0]));
11463 G__setnull(result7);
11464 return(1 || funcname || hash || result7 || libp) ;
11465}
11466
11467static int G__BesVisLib_rootcint_925_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11468{
11469 ((BesGMenuTitle*) G__getstructoffset())->SetPictureHL((Pixmap_t) G__int(libp->para[0]));
11470 G__setnull(result7);
11471 return(1 || funcname || hash || result7 || libp) ;
11472}
11473
11474static int G__BesVisLib_rootcint_925_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11475{
11476 G__letint(result7, 85, (long) BesGMenuTitle::Class());
11477 return(1 || funcname || hash || result7 || libp) ;
11478}
11479
11480static int G__BesVisLib_rootcint_925_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11481{
11482 G__letint(result7, 67, (long) BesGMenuTitle::Class_Name());
11483 return(1 || funcname || hash || result7 || libp) ;
11484}
11485
11486static int G__BesVisLib_rootcint_925_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11487{
11488 G__letint(result7, 115, (long) BesGMenuTitle::Class_Version());
11489 return(1 || funcname || hash || result7 || libp) ;
11490}
11491
11492static int G__BesVisLib_rootcint_925_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11493{
11494 BesGMenuTitle::Dictionary();
11495 G__setnull(result7);
11496 return(1 || funcname || hash || result7 || libp) ;
11497}
11498
11499static int G__BesVisLib_rootcint_925_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11500{
11501 ((BesGMenuTitle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11502 G__setnull(result7);
11503 return(1 || funcname || hash || result7 || libp) ;
11504}
11505
11506static int G__BesVisLib_rootcint_925_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11507{
11508 G__letint(result7, 67, (long) BesGMenuTitle::DeclFileName());
11509 return(1 || funcname || hash || result7 || libp) ;
11510}
11511
11512static int G__BesVisLib_rootcint_925_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11513{
11514 G__letint(result7, 105, (long) BesGMenuTitle::ImplFileLine());
11515 return(1 || funcname || hash || result7 || libp) ;
11516}
11517
11518static int G__BesVisLib_rootcint_925_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11519{
11520 G__letint(result7, 67, (long) BesGMenuTitle::ImplFileName());
11521 return(1 || funcname || hash || result7 || libp) ;
11522}
11523
11524static int G__BesVisLib_rootcint_925_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11525{
11526 G__letint(result7, 105, (long) BesGMenuTitle::DeclFileLine());
11527 return(1 || funcname || hash || result7 || libp) ;
11528}
11529
11530// automatic destructor
11531typedef BesGMenuTitle G__TBesGMenuTitle;
11532static int G__BesVisLib_rootcint_925_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11533{
11534 char* gvp = (char*) G__getgvp();
11535 long soff = G__getstructoffset();
11536 int n = G__getaryconstruct();
11537 //
11538 //has_a_delete: 1
11539 //has_own_delete1arg: 0
11540 //has_own_delete2arg: 0
11541 //
11542 if (!soff) {
11543 return(1);
11544 }
11545 if (n) {
11546 if (gvp == (char*)G__PVOID) {
11547 delete[] (BesGMenuTitle*) soff;
11548 } else {
11549 G__setgvp((long) G__PVOID);
11550 for (int i = n - 1; i >= 0; --i) {
11551 ((BesGMenuTitle*) (soff+(sizeof(BesGMenuTitle)*i)))->~G__TBesGMenuTitle();
11552 }
11553 G__setgvp((long)gvp);
11554 }
11555 } else {
11556 if (gvp == (char*)G__PVOID) {
11557 delete (BesGMenuTitle*) soff;
11558 } else {
11559 G__setgvp((long) G__PVOID);
11560 ((BesGMenuTitle*) (soff))->~G__TBesGMenuTitle();
11561 G__setgvp((long)gvp);
11562 }
11563 }
11564 G__setnull(result7);
11565 return(1 || funcname || hash || result7 || libp) ;
11566}
11567
11568
11569/* BesGMenuBar */
11570static int G__BesVisLib_rootcint_926_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11571{
11572 BesGMenuBar* p = NULL;
11573 char* gvp = (char*) G__getgvp();
11574 switch (libp->paran) {
11575 case 4:
11576 //m: 4
11577 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11578 p = new BesGMenuBar(
11579(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11580, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11581 } else {
11582 p = new((void*) gvp) BesGMenuBar(
11583(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11584, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11585 }
11586 break;
11587 case 3:
11588 //m: 3
11589 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11590 p = new BesGMenuBar(
11591(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11592, (UInt_t) G__int(libp->para[2]));
11593 } else {
11594 p = new((void*) gvp) BesGMenuBar(
11595(TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11596, (UInt_t) G__int(libp->para[2]));
11597 }
11598 break;
11599 case 2:
11600 //m: 2
11601 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11602 p = new BesGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
11603 } else {
11604 p = new((void*) gvp) BesGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
11605 }
11606 break;
11607 case 1:
11608 //m: 1
11609 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11610 p = new BesGMenuBar((TGWindow*) G__int(libp->para[0]));
11611 } else {
11612 p = new((void*) gvp) BesGMenuBar((TGWindow*) G__int(libp->para[0]));
11613 }
11614 break;
11615 case 0:
11616 int n = G__getaryconstruct();
11617 if (n) {
11618 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11619 p = new BesGMenuBar[n];
11620 } else {
11621 p = new((void*) gvp) BesGMenuBar[n];
11622 }
11623 } else {
11624 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11625 p = new BesGMenuBar;
11626 } else {
11627 p = new((void*) gvp) BesGMenuBar;
11628 }
11629 }
11630 break;
11631 }
11632 result7->obj.i = (long) p;
11633 result7->ref = (long) p;
11634 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
11635 return(1 || funcname || hash || result7 || libp) ;
11636}
11637
11638static int G__BesVisLib_rootcint_926_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11639{
11640 G__letint(result7, 85, (long) ((BesGMenuBar*) G__getstructoffset())->GetMenuTitle((Int_t) G__int(libp->para[0])));
11641 return(1 || funcname || hash || result7 || libp) ;
11642}
11643
11644static int G__BesVisLib_rootcint_926_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11645{
11646 G__letint(result7, 85, (long) BesGMenuBar::Class());
11647 return(1 || funcname || hash || result7 || libp) ;
11648}
11649
11650static int G__BesVisLib_rootcint_926_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11651{
11652 G__letint(result7, 67, (long) BesGMenuBar::Class_Name());
11653 return(1 || funcname || hash || result7 || libp) ;
11654}
11655
11656static int G__BesVisLib_rootcint_926_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11657{
11658 G__letint(result7, 115, (long) BesGMenuBar::Class_Version());
11659 return(1 || funcname || hash || result7 || libp) ;
11660}
11661
11662static int G__BesVisLib_rootcint_926_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11663{
11664 BesGMenuBar::Dictionary();
11665 G__setnull(result7);
11666 return(1 || funcname || hash || result7 || libp) ;
11667}
11668
11669static int G__BesVisLib_rootcint_926_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11670{
11671 ((BesGMenuBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11672 G__setnull(result7);
11673 return(1 || funcname || hash || result7 || libp) ;
11674}
11675
11676static int G__BesVisLib_rootcint_926_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11677{
11678 G__letint(result7, 67, (long) BesGMenuBar::DeclFileName());
11679 return(1 || funcname || hash || result7 || libp) ;
11680}
11681
11682static int G__BesVisLib_rootcint_926_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11683{
11684 G__letint(result7, 105, (long) BesGMenuBar::ImplFileLine());
11685 return(1 || funcname || hash || result7 || libp) ;
11686}
11687
11688static int G__BesVisLib_rootcint_926_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11689{
11690 G__letint(result7, 67, (long) BesGMenuBar::ImplFileName());
11691 return(1 || funcname || hash || result7 || libp) ;
11692}
11693
11694static int G__BesVisLib_rootcint_926_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11695{
11696 G__letint(result7, 105, (long) BesGMenuBar::DeclFileLine());
11697 return(1 || funcname || hash || result7 || libp) ;
11698}
11699
11700// automatic destructor
11701typedef BesGMenuBar G__TBesGMenuBar;
11702static int G__BesVisLib_rootcint_926_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11703{
11704 char* gvp = (char*) G__getgvp();
11705 long soff = G__getstructoffset();
11706 int n = G__getaryconstruct();
11707 //
11708 //has_a_delete: 1
11709 //has_own_delete1arg: 0
11710 //has_own_delete2arg: 0
11711 //
11712 if (!soff) {
11713 return(1);
11714 }
11715 if (n) {
11716 if (gvp == (char*)G__PVOID) {
11717 delete[] (BesGMenuBar*) soff;
11718 } else {
11719 G__setgvp((long) G__PVOID);
11720 for (int i = n - 1; i >= 0; --i) {
11721 ((BesGMenuBar*) (soff+(sizeof(BesGMenuBar)*i)))->~G__TBesGMenuBar();
11722 }
11723 G__setgvp((long)gvp);
11724 }
11725 } else {
11726 if (gvp == (char*)G__PVOID) {
11727 delete (BesGMenuBar*) soff;
11728 } else {
11729 G__setgvp((long) G__PVOID);
11730 ((BesGMenuBar*) (soff))->~G__TBesGMenuBar();
11731 G__setgvp((long)gvp);
11732 }
11733 }
11734 G__setnull(result7);
11735 return(1 || funcname || hash || result7 || libp) ;
11736}
11737
11738
11739/* BesGPictureButton */
11740static int G__BesVisLib_rootcint_934_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11741{
11742 BesGPictureButton* p = NULL;
11743 char* gvp = (char*) G__getgvp();
11744 switch (libp->paran) {
11745 case 5:
11746 //m: 5
11747 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11748 p = new BesGPictureButton(
11749(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11750, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11751, (UInt_t) G__int(libp->para[4]));
11752 } else {
11753 p = new((void*) gvp) BesGPictureButton(
11754(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11755, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11756, (UInt_t) G__int(libp->para[4]));
11757 }
11758 break;
11759 case 4:
11760 //m: 4
11761 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11762 p = new BesGPictureButton(
11763(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11764, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11765 } else {
11766 p = new((void*) gvp) BesGPictureButton(
11767(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11768, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11769 }
11770 break;
11771 case 3:
11772 //m: 3
11773 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11774 p = new BesGPictureButton(
11775(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11776, (Int_t) G__int(libp->para[2]));
11777 } else {
11778 p = new((void*) gvp) BesGPictureButton(
11779(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11780, (Int_t) G__int(libp->para[2]));
11781 }
11782 break;
11783 case 2:
11784 //m: 2
11785 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11786 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
11787 } else {
11788 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
11789 }
11790 break;
11791 }
11792 result7->obj.i = (long) p;
11793 result7->ref = (long) p;
11794 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11795 return(1 || funcname || hash || result7 || libp) ;
11796}
11797
11798static int G__BesVisLib_rootcint_934_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11799{
11800 BesGPictureButton* p = NULL;
11801 char* gvp = (char*) G__getgvp();
11802 switch (libp->paran) {
11803 case 6:
11804 //m: 6
11805 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11806 p = new BesGPictureButton(
11807(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11808, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11809, (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11810 } else {
11811 p = new((void*) gvp) BesGPictureButton(
11812(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11813, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11814, (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11815 }
11816 break;
11817 case 5:
11818 //m: 5
11819 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11820 p = new BesGPictureButton(
11821(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11822, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11823, (GContext_t) G__int(libp->para[4]));
11824 } else {
11825 p = new((void*) gvp) BesGPictureButton(
11826(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11827, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11828, (GContext_t) G__int(libp->para[4]));
11829 }
11830 break;
11831 case 4:
11832 //m: 4
11833 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11834 p = new BesGPictureButton(
11835(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11836, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
11837 } else {
11838 p = new((void*) gvp) BesGPictureButton(
11839(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11840, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
11841 }
11842 break;
11843 case 3:
11844 //m: 3
11845 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11846 p = new BesGPictureButton(
11847(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11848, (const char*) G__int(libp->para[2]));
11849 } else {
11850 p = new((void*) gvp) BesGPictureButton(
11851(TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11852, (const char*) G__int(libp->para[2]));
11853 }
11854 break;
11855 }
11856 result7->obj.i = (long) p;
11857 result7->ref = (long) p;
11858 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11859 return(1 || funcname || hash || result7 || libp) ;
11860}
11861
11862static int G__BesVisLib_rootcint_934_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11863{
11864 BesGPictureButton* p = NULL;
11865 char* gvp = (char*) G__getgvp();
11866 switch (libp->paran) {
11867 case 5:
11868 //m: 5
11869 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11870 p = new BesGPictureButton(
11871(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11872, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11873, (UInt_t) G__int(libp->para[4]));
11874 } else {
11875 p = new((void*) gvp) BesGPictureButton(
11876(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11877, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11878, (UInt_t) G__int(libp->para[4]));
11879 }
11880 break;
11881 case 4:
11882 //m: 4
11883 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11884 p = new BesGPictureButton(
11885(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11886, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11887 } else {
11888 p = new((void*) gvp) BesGPictureButton(
11889(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11890, (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11891 }
11892 break;
11893 case 3:
11894 //m: 3
11895 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11896 p = new BesGPictureButton(
11897(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11898, (Int_t) G__int(libp->para[2]));
11899 } else {
11900 p = new((void*) gvp) BesGPictureButton(
11901(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11902, (Int_t) G__int(libp->para[2]));
11903 }
11904 break;
11905 case 2:
11906 //m: 2
11907 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11908 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
11909 } else {
11910 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
11911 }
11912 break;
11913 case 1:
11914 //m: 1
11915 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11916 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]));
11917 } else {
11918 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]));
11919 }
11920 break;
11921 case 0:
11922 int n = G__getaryconstruct();
11923 if (n) {
11924 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11925 p = new BesGPictureButton[n];
11926 } else {
11927 p = new((void*) gvp) BesGPictureButton[n];
11928 }
11929 } else {
11930 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11931 p = new BesGPictureButton;
11932 } else {
11933 p = new((void*) gvp) BesGPictureButton;
11934 }
11935 }
11936 break;
11937 }
11938 result7->obj.i = (long) p;
11939 result7->ref = (long) p;
11940 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11941 return(1 || funcname || hash || result7 || libp) ;
11942}
11943
11944static int G__BesVisLib_rootcint_934_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11945{
11946 G__letint(result7, 103, (long) ((BesGPictureButton*) G__getstructoffset())->IsStateOn());
11947 return(1 || funcname || hash || result7 || libp) ;
11948}
11949
11950static int G__BesVisLib_rootcint_934_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11951{
11952 ((BesGPictureButton*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
11953 G__setnull(result7);
11954 return(1 || funcname || hash || result7 || libp) ;
11955}
11956
11957static int G__BesVisLib_rootcint_934_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11958{
11959 ((BesGPictureButton*) G__getstructoffset())->SetPictureHL((TGPicture*) G__int(libp->para[0]));
11960 G__setnull(result7);
11961 return(1 || funcname || hash || result7 || libp) ;
11962}
11963
11964static int G__BesVisLib_rootcint_934_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11965{
11966 G__letint(result7, 85, (long) BesGPictureButton::Class());
11967 return(1 || funcname || hash || result7 || libp) ;
11968}
11969
11970static int G__BesVisLib_rootcint_934_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11971{
11972 G__letint(result7, 67, (long) BesGPictureButton::Class_Name());
11973 return(1 || funcname || hash || result7 || libp) ;
11974}
11975
11976static int G__BesVisLib_rootcint_934_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11977{
11978 G__letint(result7, 115, (long) BesGPictureButton::Class_Version());
11979 return(1 || funcname || hash || result7 || libp) ;
11980}
11981
11982static int G__BesVisLib_rootcint_934_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11983{
11984 BesGPictureButton::Dictionary();
11985 G__setnull(result7);
11986 return(1 || funcname || hash || result7 || libp) ;
11987}
11988
11989static int G__BesVisLib_rootcint_934_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11990{
11991 ((BesGPictureButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11992 G__setnull(result7);
11993 return(1 || funcname || hash || result7 || libp) ;
11994}
11995
11996static int G__BesVisLib_rootcint_934_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11997{
11998 G__letint(result7, 67, (long) BesGPictureButton::DeclFileName());
11999 return(1 || funcname || hash || result7 || libp) ;
12000}
12001
12002static int G__BesVisLib_rootcint_934_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12003{
12004 G__letint(result7, 105, (long) BesGPictureButton::ImplFileLine());
12005 return(1 || funcname || hash || result7 || libp) ;
12006}
12007
12008static int G__BesVisLib_rootcint_934_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12009{
12010 G__letint(result7, 67, (long) BesGPictureButton::ImplFileName());
12011 return(1 || funcname || hash || result7 || libp) ;
12012}
12013
12014static int G__BesVisLib_rootcint_934_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12015{
12016 G__letint(result7, 105, (long) BesGPictureButton::DeclFileLine());
12017 return(1 || funcname || hash || result7 || libp) ;
12018}
12019
12020// automatic destructor
12021typedef BesGPictureButton G__TBesGPictureButton;
12022static int G__BesVisLib_rootcint_934_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12023{
12024 char* gvp = (char*) G__getgvp();
12025 long soff = G__getstructoffset();
12026 int n = G__getaryconstruct();
12027 //
12028 //has_a_delete: 1
12029 //has_own_delete1arg: 0
12030 //has_own_delete2arg: 0
12031 //
12032 if (!soff) {
12033 return(1);
12034 }
12035 if (n) {
12036 if (gvp == (char*)G__PVOID) {
12037 delete[] (BesGPictureButton*) soff;
12038 } else {
12039 G__setgvp((long) G__PVOID);
12040 for (int i = n - 1; i >= 0; --i) {
12041 ((BesGPictureButton*) (soff+(sizeof(BesGPictureButton)*i)))->~G__TBesGPictureButton();
12042 }
12043 G__setgvp((long)gvp);
12044 }
12045 } else {
12046 if (gvp == (char*)G__PVOID) {
12047 delete (BesGPictureButton*) soff;
12048 } else {
12049 G__setgvp((long) G__PVOID);
12050 ((BesGPictureButton*) (soff))->~G__TBesGPictureButton();
12051 G__setgvp((long)gvp);
12052 }
12053 }
12054 G__setnull(result7);
12055 return(1 || funcname || hash || result7 || libp) ;
12056}
12057
12058
12059/* BesHeader */
12060static int G__BesVisLib_rootcint_935_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12061{
12062 BesHeader* p = NULL;
12063 char* gvp = (char*) G__getgvp();
12064 int n = G__getaryconstruct();
12065 if (n) {
12066 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12067 p = new BesHeader[n];
12068 } else {
12069 p = new((void*) gvp) BesHeader[n];
12070 }
12071 } else {
12072 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12073 p = new BesHeader;
12074 } else {
12075 p = new((void*) gvp) BesHeader;
12076 }
12077 }
12078 result7->obj.i = (long) p;
12079 result7->ref = (long) p;
12080 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
12081 return(1 || funcname || hash || result7 || libp) ;
12082}
12083
12084static int G__BesVisLib_rootcint_935_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12085{
12086 BesHeader* p = NULL;
12087 char* gvp = (char*) G__getgvp();
12088 //m: 5
12089 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12090 p = new BesHeader(
12091(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12092, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12093, (Option_t*) G__int(libp->para[4]));
12094 } else {
12095 p = new((void*) gvp) BesHeader(
12096(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12097, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12098, (Option_t*) G__int(libp->para[4]));
12099 }
12100 result7->obj.i = (long) p;
12101 result7->ref = (long) p;
12102 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
12103 return(1 || funcname || hash || result7 || libp) ;
12104}
12105
12106static int G__BesVisLib_rootcint_935_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12107{
12108 ((BesHeader*) G__getstructoffset())->SetMdcOn((Bool_t) G__int(libp->para[0]));
12109 G__setnull(result7);
12110 return(1 || funcname || hash || result7 || libp) ;
12111}
12112
12113static int G__BesVisLib_rootcint_935_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12114{
12115 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetMdcOn());
12116 return(1 || funcname || hash || result7 || libp) ;
12117}
12118
12119static int G__BesVisLib_rootcint_935_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12120{
12121 ((BesHeader*) G__getstructoffset())->TransferMdcOn((Bool_t) G__int(libp->para[0]));
12122 G__setnull(result7);
12123 return(1 || funcname || hash || result7 || libp) ;
12124}
12125
12126static int G__BesVisLib_rootcint_935_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12127{
12128 ((BesHeader*) G__getstructoffset())->SetTofOn((Bool_t) G__int(libp->para[0]));
12129 G__setnull(result7);
12130 return(1 || funcname || hash || result7 || libp) ;
12131}
12132
12133static int G__BesVisLib_rootcint_935_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12134{
12135 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetTofOn());
12136 return(1 || funcname || hash || result7 || libp) ;
12137}
12138
12139static int G__BesVisLib_rootcint_935_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12140{
12141 ((BesHeader*) G__getstructoffset())->TransferTofOn((Bool_t) G__int(libp->para[0]));
12142 G__setnull(result7);
12143 return(1 || funcname || hash || result7 || libp) ;
12144}
12145
12146static int G__BesVisLib_rootcint_935_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12147{
12148 ((BesHeader*) G__getstructoffset())->SetEmcOn((Bool_t) G__int(libp->para[0]));
12149 G__setnull(result7);
12150 return(1 || funcname || hash || result7 || libp) ;
12151}
12152
12153static int G__BesVisLib_rootcint_935_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12154{
12155 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetEmcOn());
12156 return(1 || funcname || hash || result7 || libp) ;
12157}
12158
12159static int G__BesVisLib_rootcint_935_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12160{
12161 ((BesHeader*) G__getstructoffset())->TransferEmcOn((Bool_t) G__int(libp->para[0]));
12162 G__setnull(result7);
12163 return(1 || funcname || hash || result7 || libp) ;
12164}
12165
12166static int G__BesVisLib_rootcint_935_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12167{
12168 ((BesHeader*) G__getstructoffset())->DrawClass();
12169 G__setnull(result7);
12170 return(1 || funcname || hash || result7 || libp) ;
12171}
12172
12173static int G__BesVisLib_rootcint_935_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12174{
12175 switch (libp->paran) {
12176 case 1:
12177 G__letint(result7, 85, (long) ((BesHeader*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
12178 break;
12179 case 0:
12180 G__letint(result7, 85, (long) ((BesHeader*) G__getstructoffset())->DrawClone());
12181 break;
12182 }
12183 return(1 || funcname || hash || result7 || libp) ;
12184}
12185
12186static int G__BesVisLib_rootcint_935_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12187{
12188 ((BesHeader*) G__getstructoffset())->Dump();
12189 G__setnull(result7);
12190 return(1 || funcname || hash || result7 || libp) ;
12191}
12192
12193static int G__BesVisLib_rootcint_935_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12194{
12195 ((BesHeader*) G__getstructoffset())->Inspect();
12196 G__setnull(result7);
12197 return(1 || funcname || hash || result7 || libp) ;
12198}
12199
12200static int G__BesVisLib_rootcint_935_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12201{
12202 G__letint(result7, 85, (long) BesHeader::Class());
12203 return(1 || funcname || hash || result7 || libp) ;
12204}
12205
12206static int G__BesVisLib_rootcint_935_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12207{
12208 G__letint(result7, 67, (long) BesHeader::Class_Name());
12209 return(1 || funcname || hash || result7 || libp) ;
12210}
12211
12212static int G__BesVisLib_rootcint_935_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12213{
12214 G__letint(result7, 115, (long) BesHeader::Class_Version());
12215 return(1 || funcname || hash || result7 || libp) ;
12216}
12217
12218static int G__BesVisLib_rootcint_935_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12219{
12220 BesHeader::Dictionary();
12221 G__setnull(result7);
12222 return(1 || funcname || hash || result7 || libp) ;
12223}
12224
12225static int G__BesVisLib_rootcint_935_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12226{
12227 ((BesHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12228 G__setnull(result7);
12229 return(1 || funcname || hash || result7 || libp) ;
12230}
12231
12232static int G__BesVisLib_rootcint_935_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12233{
12234 G__letint(result7, 67, (long) BesHeader::DeclFileName());
12235 return(1 || funcname || hash || result7 || libp) ;
12236}
12237
12238static int G__BesVisLib_rootcint_935_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12239{
12240 G__letint(result7, 105, (long) BesHeader::ImplFileLine());
12241 return(1 || funcname || hash || result7 || libp) ;
12242}
12243
12244static int G__BesVisLib_rootcint_935_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12245{
12246 G__letint(result7, 67, (long) BesHeader::ImplFileName());
12247 return(1 || funcname || hash || result7 || libp) ;
12248}
12249
12250static int G__BesVisLib_rootcint_935_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12251{
12252 G__letint(result7, 105, (long) BesHeader::DeclFileLine());
12253 return(1 || funcname || hash || result7 || libp) ;
12254}
12255
12256// automatic destructor
12257typedef BesHeader G__TBesHeader;
12258static int G__BesVisLib_rootcint_935_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12259{
12260 char* gvp = (char*) G__getgvp();
12261 long soff = G__getstructoffset();
12262 int n = G__getaryconstruct();
12263 //
12264 //has_a_delete: 1
12265 //has_own_delete1arg: 0
12266 //has_own_delete2arg: 0
12267 //
12268 if (!soff) {
12269 return(1);
12270 }
12271 if (n) {
12272 if (gvp == (char*)G__PVOID) {
12273 delete[] (BesHeader*) soff;
12274 } else {
12275 G__setgvp((long) G__PVOID);
12276 for (int i = n - 1; i >= 0; --i) {
12277 ((BesHeader*) (soff+(sizeof(BesHeader)*i)))->~G__TBesHeader();
12278 }
12279 G__setgvp((long)gvp);
12280 }
12281 } else {
12282 if (gvp == (char*)G__PVOID) {
12283 delete (BesHeader*) soff;
12284 } else {
12285 G__setgvp((long) G__PVOID);
12286 ((BesHeader*) (soff))->~G__TBesHeader();
12287 G__setgvp((long)gvp);
12288 }
12289 }
12290 G__setnull(result7);
12291 return(1 || funcname || hash || result7 || libp) ;
12292}
12293
12294
12295/* BesVisDisplay */
12296static int G__BesVisLib_rootcint_957_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12297{
12298 BesVisDisplay* p = NULL;
12299 char* gvp = (char*) G__getgvp();
12300 int n = G__getaryconstruct();
12301 if (n) {
12302 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12303 p = new BesVisDisplay[n];
12304 } else {
12305 p = new((void*) gvp) BesVisDisplay[n];
12306 }
12307 } else {
12308 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12309 p = new BesVisDisplay;
12310 } else {
12311 p = new((void*) gvp) BesVisDisplay;
12312 }
12313 }
12314 result7->obj.i = (long) p;
12315 result7->ref = (long) p;
12316 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
12317 return(1 || funcname || hash || result7 || libp) ;
12318}
12319
12320static int G__BesVisLib_rootcint_957_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12321{
12322 BesVisDisplay* p = NULL;
12323 char* gvp = (char*) G__getgvp();
12324 //m: 1
12325 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12326 p = new BesVisDisplay((const char*) G__int(libp->para[0]));
12327 } else {
12328 p = new((void*) gvp) BesVisDisplay((const char*) G__int(libp->para[0]));
12329 }
12330 result7->obj.i = (long) p;
12331 result7->ref = (long) p;
12332 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
12333 return(1 || funcname || hash || result7 || libp) ;
12334}
12335
12336static int G__BesVisLib_rootcint_957_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12337{
12338 switch (libp->paran) {
12339 case 1:
12340 ((BesVisDisplay*) G__getstructoffset())->SetCanvas((TCanvas*) G__int(libp->para[0]));
12341 G__setnull(result7);
12342 break;
12343 case 0:
12344 ((BesVisDisplay*) G__getstructoffset())->SetCanvas();
12345 G__setnull(result7);
12346 break;
12347 }
12348 return(1 || funcname || hash || result7 || libp) ;
12349}
12350
12351static int G__BesVisLib_rootcint_957_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12352{
12353 ((BesVisDisplay*) G__getstructoffset())->SetDisplayMode((Int_t) G__int(libp->para[0]));
12354 G__setnull(result7);
12355 return(1 || funcname || hash || result7 || libp) ;
12356}
12357
12358static int G__BesVisLib_rootcint_957_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12359{
12360 G__letint(result7, 105, (long) ((BesVisDisplay*) G__getstructoffset())->GetDisplayMode());
12361 return(1 || funcname || hash || result7 || libp) ;
12362}
12363
12364static int G__BesVisLib_rootcint_957_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12365{
12366 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->IsVHeader());
12367 return(1 || funcname || hash || result7 || libp) ;
12368}
12369
12370static int G__BesVisLib_rootcint_957_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12371{
12372 ((BesVisDisplay*) G__getstructoffset())->SwitchDisplayMode((Int_t) G__int(libp->para[0]));
12373 G__setnull(result7);
12374 return(1 || funcname || hash || result7 || libp) ;
12375}
12376
12377static int G__BesVisLib_rootcint_957_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12378{
12379 ((BesVisDisplay*) G__getstructoffset())->ResizePad();
12380 G__setnull(result7);
12381 return(1 || funcname || hash || result7 || libp) ;
12382}
12383
12384static int G__BesVisLib_rootcint_957_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12385{
12386 ((BesVisDisplay*) G__getstructoffset())->SwitchPad();
12387 G__setnull(result7);
12388 return(1 || funcname || hash || result7 || libp) ;
12389}
12390
12391static int G__BesVisLib_rootcint_957_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12392{
12393 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPadXY());
12394 return(1 || funcname || hash || result7 || libp) ;
12395}
12396
12397static int G__BesVisLib_rootcint_957_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12398{
12399 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPadZR());
12400 return(1 || funcname || hash || result7 || libp) ;
12401}
12402
12403static int G__BesVisLib_rootcint_957_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12404{
12405 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPad3D());
12406 return(1 || funcname || hash || result7 || libp) ;
12407}
12408
12409static int G__BesVisLib_rootcint_957_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12410{
12411 ((BesVisDisplay*) G__getstructoffset())->DrawHeader();
12412 G__setnull(result7);
12413 return(1 || funcname || hash || result7 || libp) ;
12414}
12415
12416static int G__BesVisLib_rootcint_957_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12417{
12418 ((BesVisDisplay*) G__getstructoffset())->Reset();
12419 G__setnull(result7);
12420 return(1 || funcname || hash || result7 || libp) ;
12421}
12422
12423static int G__BesVisLib_rootcint_957_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12424{
12425 ((BesVisDisplay*) G__getstructoffset())->Refresh();
12426 G__setnull(result7);
12427 return(1 || funcname || hash || result7 || libp) ;
12428}
12429
12430static int G__BesVisLib_rootcint_957_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12431{
12432 switch (libp->paran) {
12433 case 3:
12434 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromGDML(*((const TString*) G__int(libp->para[0])), (bool) G__int(libp->para[1])
12435, (bool) G__int(libp->para[2]));
12436 G__setnull(result7);
12437 break;
12438 case 2:
12439 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromGDML(*((const TString*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
12440 G__setnull(result7);
12441 break;
12442 case 1:
12443 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromGDML(*((const TString*) G__int(libp->para[0])));
12444 G__setnull(result7);
12445 break;
12446 }
12447 return(1 || funcname || hash || result7 || libp) ;
12448}
12449
12450static int G__BesVisLib_rootcint_957_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12451{
12452 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromROOT((TGeoVolume*) G__int(libp->para[0]));
12453 G__setnull(result7);
12454 return(1 || funcname || hash || result7 || libp) ;
12455}
12456
12457static int G__BesVisLib_rootcint_957_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12458{
12459 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetBesGeometry());
12460 return(1 || funcname || hash || result7 || libp) ;
12461}
12462
12463static int G__BesVisLib_rootcint_957_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12464{
12465 ((BesVisDisplay*) G__getstructoffset())->SetMdcOn((Bool_t) G__int(libp->para[0]));
12466 G__setnull(result7);
12467 return(1 || funcname || hash || result7 || libp) ;
12468}
12469
12470static int G__BesVisLib_rootcint_957_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12471{
12472 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetMdcOn());
12473 return(1 || funcname || hash || result7 || libp) ;
12474}
12475
12476static int G__BesVisLib_rootcint_957_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12477{
12478 ((BesVisDisplay*) G__getstructoffset())->SetTofOn((Bool_t) G__int(libp->para[0]));
12479 G__setnull(result7);
12480 return(1 || funcname || hash || result7 || libp) ;
12481}
12482
12483static int G__BesVisLib_rootcint_957_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12484{
12485 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetTofOn());
12486 return(1 || funcname || hash || result7 || libp) ;
12487}
12488
12489static int G__BesVisLib_rootcint_957_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12490{
12491 ((BesVisDisplay*) G__getstructoffset())->SetEmcOn((Bool_t) G__int(libp->para[0]));
12492 G__setnull(result7);
12493 return(1 || funcname || hash || result7 || libp) ;
12494}
12495
12496static int G__BesVisLib_rootcint_957_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12497{
12498 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetEmcOn());
12499 return(1 || funcname || hash || result7 || libp) ;
12500}
12501
12502static int G__BesVisLib_rootcint_957_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12503{
12504 ((BesVisDisplay*) G__getstructoffset())->SetVisHeader((Bool_t) G__int(libp->para[0]));
12505 G__setnull(result7);
12506 return(1 || funcname || hash || result7 || libp) ;
12507}
12508
12509static int G__BesVisLib_rootcint_957_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12510{
12511 G__letint(result7, 103, (long) ((const BesVisDisplay*) G__getstructoffset())->GetVisHeader());
12512 return(1 || funcname || hash || result7 || libp) ;
12513}
12514
12515static int G__BesVisLib_rootcint_957_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12516{
12517 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->AllViews());
12518 return(1 || funcname || hash || result7 || libp) ;
12519}
12520
12521static int G__BesVisLib_rootcint_957_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12522{
12523 switch (libp->paran) {
12524 case 1:
12525 ((BesVisDisplay*) G__getstructoffset())->Clear((Option_t*) G__int(libp->para[0]));
12526 G__setnull(result7);
12527 break;
12528 case 0:
12529 ((BesVisDisplay*) G__getstructoffset())->Clear();
12530 G__setnull(result7);
12531 break;
12532 }
12533 return(1 || funcname || hash || result7 || libp) ;
12534}
12535
12536static int G__BesVisLib_rootcint_957_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12537{
12538 ((BesVisDisplay*) G__getstructoffset())->DisplayTrigger((Int_t) G__int(libp->para[0]));
12539 G__setnull(result7);
12540 return(1 || funcname || hash || result7 || libp) ;
12541}
12542
12543static int G__BesVisLib_rootcint_957_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12544{
12545 G__letint(result7, 105, (long) ((BesVisDisplay*) G__getstructoffset())->DistancetoPrimitive((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
12546 return(1 || funcname || hash || result7 || libp) ;
12547}
12548
12549static int G__BesVisLib_rootcint_957_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12550{
12551 switch (libp->paran) {
12552 case 1:
12553 ((BesVisDisplay*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
12554 G__setnull(result7);
12555 break;
12556 case 0:
12557 ((BesVisDisplay*) G__getstructoffset())->Draw();
12558 G__setnull(result7);
12559 break;
12560 }
12561 return(1 || funcname || hash || result7 || libp) ;
12562}
12563
12564static int G__BesVisLib_rootcint_957_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12565{
12566 switch (libp->paran) {
12567 case 1:
12568 ((BesVisDisplay*) G__getstructoffset())->Draw2D((Option_t*) G__int(libp->para[0]));
12569 G__setnull(result7);
12570 break;
12571 case 0:
12572 ((BesVisDisplay*) G__getstructoffset())->Draw2D();
12573 G__setnull(result7);
12574 break;
12575 }
12576 return(1 || funcname || hash || result7 || libp) ;
12577}
12578
12579static int G__BesVisLib_rootcint_957_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12580{
12581 switch (libp->paran) {
12582 case 1:
12583 ((BesVisDisplay*) G__getstructoffset())->Draw3D((Option_t*) G__int(libp->para[0]));
12584 G__setnull(result7);
12585 break;
12586 case 0:
12587 ((BesVisDisplay*) G__getstructoffset())->Draw3D();
12588 G__setnull(result7);
12589 break;
12590 }
12591 return(1 || funcname || hash || result7 || libp) ;
12592}
12593
12594static int G__BesVisLib_rootcint_957_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12595{
12596 switch (libp->paran) {
12597 case 1:
12598 ((BesVisDisplay*) G__getstructoffset())->Draw2DXY((Option_t*) G__int(libp->para[0]));
12599 G__setnull(result7);
12600 break;
12601 case 0:
12602 ((BesVisDisplay*) G__getstructoffset())->Draw2DXY();
12603 G__setnull(result7);
12604 break;
12605 }
12606 return(1 || funcname || hash || result7 || libp) ;
12607}
12608
12609static int G__BesVisLib_rootcint_957_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12610{
12611 switch (libp->paran) {
12612 case 1:
12613 ((BesVisDisplay*) G__getstructoffset())->Draw2DZR((Option_t*) G__int(libp->para[0]));
12614 G__setnull(result7);
12615 break;
12616 case 0:
12617 ((BesVisDisplay*) G__getstructoffset())->Draw2DZR();
12618 G__setnull(result7);
12619 break;
12620 }
12621 return(1 || funcname || hash || result7 || libp) ;
12622}
12623
12624static int G__BesVisLib_rootcint_957_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12625{
12626 ((BesVisDisplay*) G__getstructoffset())->DrawAllViews();
12627 G__setnull(result7);
12628 return(1 || funcname || hash || result7 || libp) ;
12629}
12630
12631static int G__BesVisLib_rootcint_957_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12632{
12633 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawClusters());
12634 return(1 || funcname || hash || result7 || libp) ;
12635}
12636
12637static int G__BesVisLib_rootcint_957_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12638{
12639 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawParticles());
12640 return(1 || funcname || hash || result7 || libp) ;
12641}
12642
12643static int G__BesVisLib_rootcint_957_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12644{
12645 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawParticles2());
12646 return(1 || funcname || hash || result7 || libp) ;
12647}
12648
12649static int G__BesVisLib_rootcint_957_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12650{
12651 switch (libp->paran) {
12652 case 1:
12653 ((BesVisDisplay*) G__getstructoffset())->DrawTitle((Option_t*) G__int(libp->para[0]));
12654 G__setnull(result7);
12655 break;
12656 case 0:
12657 ((BesVisDisplay*) G__getstructoffset())->DrawTitle();
12658 G__setnull(result7);
12659 break;
12660 }
12661 return(1 || funcname || hash || result7 || libp) ;
12662}
12663
12664static int G__BesVisLib_rootcint_957_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12665{
12666 ((BesVisDisplay*) G__getstructoffset())->DrawView((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
12667 G__setnull(result7);
12668 return(1 || funcname || hash || result7 || libp) ;
12669}
12670
12671static int G__BesVisLib_rootcint_957_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12672{
12673 ((BesVisDisplay*) G__getstructoffset())->DrawViewRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12674, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
12675 G__setnull(result7);
12676 return(1 || funcname || hash || result7 || libp) ;
12677}
12678
12679static int G__BesVisLib_rootcint_957_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12680{
12681 ((BesVisDisplay*) G__getstructoffset())->DrawViewGL();
12682 G__setnull(result7);
12683 return(1 || funcname || hash || result7 || libp) ;
12684}
12685
12686static int G__BesVisLib_rootcint_957_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12687{
12688 ((BesVisDisplay*) G__getstructoffset())->DrawViewX3D();
12689 G__setnull(result7);
12690 return(1 || funcname || hash || result7 || libp) ;
12691}
12692
12693static int G__BesVisLib_rootcint_957_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12694{
12695 ((BesVisDisplay*) G__getstructoffset())->DrawViewRaytracer((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
12696, (Float_t) G__double(libp->para[2]));
12697 G__setnull(result7);
12698 return(1 || funcname || hash || result7 || libp) ;
12699}
12700
12701static int G__BesVisLib_rootcint_957_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12702{
12703 ((BesVisDisplay*) G__getstructoffset())->DrawViewX3D((char) G__int(libp->para[0]));
12704 G__setnull(result7);
12705 return(1 || funcname || hash || result7 || libp) ;
12706}
12707
12708static int G__BesVisLib_rootcint_957_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12709{
12710 ((BesVisDisplay*) G__getstructoffset())->DrawImageSequence((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12711 G__setnull(result7);
12712 return(1 || funcname || hash || result7 || libp) ;
12713}
12714
12715static int G__BesVisLib_rootcint_957_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12716{
12717 ((BesVisDisplay*) G__getstructoffset())->ExecuteEvent((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12718, (Int_t) G__int(libp->para[2]));
12719 G__setnull(result7);
12720 return(1 || funcname || hash || result7 || libp) ;
12721}
12722
12723static int G__BesVisLib_rootcint_957_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12724{
12725 ((BesVisDisplay*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0]));
12726 G__setnull(result7);
12727 return(1 || funcname || hash || result7 || libp) ;
12728}
12729
12730static int G__BesVisLib_rootcint_957_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12731{
12732 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetVolBes());
12733 return(1 || funcname || hash || result7 || libp) ;
12734}
12735
12736static int G__BesVisLib_rootcint_957_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12737{
12738 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetMdcROOTGeo());
12739 return(1 || funcname || hash || result7 || libp) ;
12740}
12741
12742static int G__BesVisLib_rootcint_957_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12743{
12744 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetTofROOTGeo());
12745 return(1 || funcname || hash || result7 || libp) ;
12746}
12747
12748static int G__BesVisLib_rootcint_957_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12749{
12750 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetEmcROOTGeo());
12751 return(1 || funcname || hash || result7 || libp) ;
12752}
12753
12754static int G__BesVisLib_rootcint_957_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12755{
12756 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetMucROOTGeo());
12757 return(1 || funcname || hash || result7 || libp) ;
12758}
12759
12760static int G__BesVisLib_rootcint_957_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12761{
12762 ((BesVisDisplay*) G__getstructoffset())->Init();
12763 G__setnull(result7);
12764 return(1 || funcname || hash || result7 || libp) ;
12765}
12766
12767static int G__BesVisLib_rootcint_957_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12768{
12769 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->Pad());
12770 return(1 || funcname || hash || result7 || libp) ;
12771}
12772
12773static int G__BesVisLib_rootcint_957_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12774{
12775 switch (libp->paran) {
12776 case 1:
12777 ((BesVisDisplay*) G__getstructoffset())->Paint((Option_t*) G__int(libp->para[0]));
12778 G__setnull(result7);
12779 break;
12780 case 0:
12781 ((BesVisDisplay*) G__getstructoffset())->Paint();
12782 G__setnull(result7);
12783 break;
12784 }
12785 return(1 || funcname || hash || result7 || libp) ;
12786}
12787
12788static int G__BesVisLib_rootcint_957_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12789{
12790 switch (libp->paran) {
12791 case 6:
12792 ((BesVisDisplay*) G__getstructoffset())->PaintFruit((TObject*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
12793, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
12794, (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
12795 G__setnull(result7);
12796 break;
12797 case 5:
12798 ((BesVisDisplay*) G__getstructoffset())->PaintFruit((TObject*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
12799, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
12800, (Int_t) G__int(libp->para[4]));
12801 G__setnull(result7);
12802 break;
12803 }
12804 return(1 || funcname || hash || result7 || libp) ;
12805}
12806
12807static int G__BesVisLib_rootcint_957_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12808{
12809 switch (libp->paran) {
12810 case 1:
12811 ((BesVisDisplay*) G__getstructoffset())->PaintParticles((Option_t*) G__int(libp->para[0]));
12812 G__setnull(result7);
12813 break;
12814 case 0:
12815 ((BesVisDisplay*) G__getstructoffset())->PaintParticles();
12816 G__setnull(result7);
12817 break;
12818 }
12819 return(1 || funcname || hash || result7 || libp) ;
12820}
12821
12822static int G__BesVisLib_rootcint_957_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12823{
12824 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->PTcut());
12825 return(1 || funcname || hash || result7 || libp) ;
12826}
12827
12828static int G__BesVisLib_rootcint_957_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12829{
12830 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->PTcutEGMUNU());
12831 return(1 || funcname || hash || result7 || libp) ;
12832}
12833
12834static int G__BesVisLib_rootcint_957_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12835{
12836 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Rin());
12837 return(1 || funcname || hash || result7 || libp) ;
12838}
12839
12840static int G__BesVisLib_rootcint_957_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12841{
12842 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Rout());
12843 return(1 || funcname || hash || result7 || libp) ;
12844}
12845
12846static int G__BesVisLib_rootcint_957_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12847{
12848 switch (libp->paran) {
12849 case 1:
12850 ((BesVisDisplay*) G__getstructoffset())->SetDrawClusters((Bool_t) G__int(libp->para[0]));
12851 G__setnull(result7);
12852 break;
12853 case 0:
12854 ((BesVisDisplay*) G__getstructoffset())->SetDrawClusters();
12855 G__setnull(result7);
12856 break;
12857 }
12858 return(1 || funcname || hash || result7 || libp) ;
12859}
12860
12861static int G__BesVisLib_rootcint_957_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12862{
12863 switch (libp->paran) {
12864 case 1:
12865 ((BesVisDisplay*) G__getstructoffset())->SetDrawParticles((Bool_t) G__int(libp->para[0]));
12866 G__setnull(result7);
12867 break;
12868 case 0:
12869 ((BesVisDisplay*) G__getstructoffset())->SetDrawParticles();
12870 G__setnull(result7);
12871 break;
12872 }
12873 return(1 || funcname || hash || result7 || libp) ;
12874}
12875
12876static int G__BesVisLib_rootcint_957_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12877{
12878 switch (libp->paran) {
12879 case 1:
12880 ((BesVisDisplay*) G__getstructoffset())->SetPTcut((Float_t) G__double(libp->para[0]));
12881 G__setnull(result7);
12882 break;
12883 case 0:
12884 ((BesVisDisplay*) G__getstructoffset())->SetPTcut();
12885 G__setnull(result7);
12886 break;
12887 }
12888 return(1 || funcname || hash || result7 || libp) ;
12889}
12890
12891static int G__BesVisLib_rootcint_957_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12892{
12893 switch (libp->paran) {
12894 case 1:
12895 ((BesVisDisplay*) G__getstructoffset())->SetPTcutEGMUNU((Float_t) G__double(libp->para[0]));
12896 G__setnull(result7);
12897 break;
12898 case 0:
12899 ((BesVisDisplay*) G__getstructoffset())->SetPTcutEGMUNU();
12900 G__setnull(result7);
12901 break;
12902 }
12903 return(1 || funcname || hash || result7 || libp) ;
12904}
12905
12906static int G__BesVisLib_rootcint_957_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12907{
12908 ((BesVisDisplay*) G__getstructoffset())->SetView((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
12909 G__setnull(result7);
12910 return(1 || funcname || hash || result7 || libp) ;
12911}
12912
12913static int G__BesVisLib_rootcint_957_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12914{
12915 switch (libp->paran) {
12916 case 1:
12917 ((BesVisDisplay*) G__getstructoffset())->ShowNextEvent((Int_t) G__int(libp->para[0]));
12918 G__setnull(result7);
12919 break;
12920 case 0:
12921 ((BesVisDisplay*) G__getstructoffset())->ShowNextEvent();
12922 G__setnull(result7);
12923 break;
12924 }
12925 return(1 || funcname || hash || result7 || libp) ;
12926}
12927
12928static int G__BesVisLib_rootcint_957_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12929{
12930 ((BesVisDisplay*) G__getstructoffset())->SetMdcCon((Int_t) G__int(libp->para[0]));
12931 G__setnull(result7);
12932 return(1 || funcname || hash || result7 || libp) ;
12933}
12934
12935static int G__BesVisLib_rootcint_957_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12936{
12937 ((BesVisDisplay*) G__getstructoffset())->SetTofCon((Int_t) G__int(libp->para[0]));
12938 G__setnull(result7);
12939 return(1 || funcname || hash || result7 || libp) ;
12940}
12941
12942static int G__BesVisLib_rootcint_957_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12943{
12944 ((BesVisDisplay*) G__getstructoffset())->SetEmcCon((Int_t) G__int(libp->para[0]));
12945 G__setnull(result7);
12946 return(1 || funcname || hash || result7 || libp) ;
12947}
12948
12949static int G__BesVisLib_rootcint_957_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12950{
12951 ((BesVisDisplay*) G__getstructoffset())->SetMucCon((Int_t) G__int(libp->para[0]));
12952 G__setnull(result7);
12953 return(1 || funcname || hash || result7 || libp) ;
12954}
12955
12956static int G__BesVisLib_rootcint_957_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12957{
12958 ((BesVisDisplay*) G__getstructoffset())->SetAllVisible((Int_t) G__int(libp->para[0]));
12959 G__setnull(result7);
12960 return(1 || funcname || hash || result7 || libp) ;
12961}
12962
12963static int G__BesVisLib_rootcint_957_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12964{
12965 ((BesVisDisplay*) G__getstructoffset())->SetQuarterVisible((Int_t) G__int(libp->para[0]));
12966 G__setnull(result7);
12967 return(1 || funcname || hash || result7 || libp) ;
12968}
12969
12970static int G__BesVisLib_rootcint_957_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12971{
12972 ((BesVisDisplay*) G__getstructoffset())->SetHalfVisible((Int_t) G__int(libp->para[0]));
12973 G__setnull(result7);
12974 return(1 || funcname || hash || result7 || libp) ;
12975}
12976
12977static int G__BesVisLib_rootcint_957_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12978{
12979 ((BesVisDisplay*) G__getstructoffset())->SetNoEndVisible((Int_t) G__int(libp->para[0]));
12980 G__setnull(result7);
12981 return(1 || funcname || hash || result7 || libp) ;
12982}
12983
12984static int G__BesVisLib_rootcint_957_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12985{
12986 ((BesVisDisplay*) G__getstructoffset())->SetMdcFiredCell();
12987 G__setnull(result7);
12988 return(1 || funcname || hash || result7 || libp) ;
12989}
12990
12991static int G__BesVisLib_rootcint_957_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12992{
12993 ((BesVisDisplay*) G__getstructoffset())->SetTofFiredCell();
12994 G__setnull(result7);
12995 return(1 || funcname || hash || result7 || libp) ;
12996}
12997
12998static int G__BesVisLib_rootcint_957_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12999{
13000 ((BesVisDisplay*) G__getstructoffset())->SetEmcFiredCell();
13001 G__setnull(result7);
13002 return(1 || funcname || hash || result7 || libp) ;
13003}
13004
13005static int G__BesVisLib_rootcint_957_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13006{
13007 ((BesVisDisplay*) G__getstructoffset())->SetMucFiredCell();
13008 G__setnull(result7);
13009 return(1 || funcname || hash || result7 || libp) ;
13010}
13011
13012static int G__BesVisLib_rootcint_957_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13013{
13014 ((const BesVisDisplay*) G__getstructoffset())->SizeFruit();
13015 G__setnull(result7);
13016 return(1 || funcname || hash || result7 || libp) ;
13017}
13018
13019static int G__BesVisLib_rootcint_957_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13020{
13021 ((const BesVisDisplay*) G__getstructoffset())->SizeParticles();
13022 G__setnull(result7);
13023 return(1 || funcname || hash || result7 || libp) ;
13024}
13025
13026static int G__BesVisLib_rootcint_957_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13027{
13028 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Zin());
13029 return(1 || funcname || hash || result7 || libp) ;
13030}
13031
13032static int G__BesVisLib_rootcint_957_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13033{
13034 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Zout());
13035 return(1 || funcname || hash || result7 || libp) ;
13036}
13037
13038static int G__BesVisLib_rootcint_957_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13039{
13040 G__letint(result7, 85, (long) BesVisDisplay::Class());
13041 return(1 || funcname || hash || result7 || libp) ;
13042}
13043
13044static int G__BesVisLib_rootcint_957_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13045{
13046 G__letint(result7, 67, (long) BesVisDisplay::Class_Name());
13047 return(1 || funcname || hash || result7 || libp) ;
13048}
13049
13050static int G__BesVisLib_rootcint_957_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13051{
13052 G__letint(result7, 115, (long) BesVisDisplay::Class_Version());
13053 return(1 || funcname || hash || result7 || libp) ;
13054}
13055
13056static int G__BesVisLib_rootcint_957_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13057{
13058 BesVisDisplay::Dictionary();
13059 G__setnull(result7);
13060 return(1 || funcname || hash || result7 || libp) ;
13061}
13062
13063static int G__BesVisLib_rootcint_957_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13064{
13065 ((BesVisDisplay*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13066 G__setnull(result7);
13067 return(1 || funcname || hash || result7 || libp) ;
13068}
13069
13070static int G__BesVisLib_rootcint_957_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13071{
13072 G__letint(result7, 67, (long) BesVisDisplay::DeclFileName());
13073 return(1 || funcname || hash || result7 || libp) ;
13074}
13075
13076static int G__BesVisLib_rootcint_957_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13077{
13078 G__letint(result7, 105, (long) BesVisDisplay::ImplFileLine());
13079 return(1 || funcname || hash || result7 || libp) ;
13080}
13081
13082static int G__BesVisLib_rootcint_957_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13083{
13084 G__letint(result7, 67, (long) BesVisDisplay::ImplFileName());
13085 return(1 || funcname || hash || result7 || libp) ;
13086}
13087
13088static int G__BesVisLib_rootcint_957_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13089{
13090 G__letint(result7, 105, (long) BesVisDisplay::DeclFileLine());
13091 return(1 || funcname || hash || result7 || libp) ;
13092}
13093
13094// automatic destructor
13095typedef BesVisDisplay G__TBesVisDisplay;
13096static int G__BesVisLib_rootcint_957_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13097{
13098 char* gvp = (char*) G__getgvp();
13099 long soff = G__getstructoffset();
13100 int n = G__getaryconstruct();
13101 //
13102 //has_a_delete: 0
13103 //has_own_delete1arg: 0
13104 //has_own_delete2arg: 0
13105 //
13106 if (!soff) {
13107 return(1);
13108 }
13109 if (n) {
13110 if (gvp == (char*)G__PVOID) {
13111 delete[] (BesVisDisplay*) soff;
13112 } else {
13113 G__setgvp((long) G__PVOID);
13114 for (int i = n - 1; i >= 0; --i) {
13115 ((BesVisDisplay*) (soff+(sizeof(BesVisDisplay)*i)))->~G__TBesVisDisplay();
13116 }
13117 G__setgvp((long)gvp);
13118 }
13119 } else {
13120 if (gvp == (char*)G__PVOID) {
13121 delete (BesVisDisplay*) soff;
13122 } else {
13123 G__setgvp((long) G__PVOID);
13124 ((BesVisDisplay*) (soff))->~G__TBesVisDisplay();
13125 G__setgvp((long)gvp);
13126 }
13127 }
13128 G__setnull(result7);
13129 return(1 || funcname || hash || result7 || libp) ;
13130}
13131
13132
13133/* ZHelix */
13134static int G__BesVisLib_rootcint_960_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13135{
13136 ZHelix* p = NULL;
13137 char* gvp = (char*) G__getgvp();
13138 int n = G__getaryconstruct();
13139 if (n) {
13140 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13141 p = new ZHelix[n];
13142 } else {
13143 p = new((void*) gvp) ZHelix[n];
13144 }
13145 } else {
13146 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13147 p = new ZHelix;
13148 } else {
13149 p = new((void*) gvp) ZHelix;
13150 }
13151 }
13152 result7->obj.i = (long) p;
13153 result7->ref = (long) p;
13154 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
13155 return(1 || funcname || hash || result7 || libp) ;
13156}
13157
13158static int G__BesVisLib_rootcint_960_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13159{
13160 ZHelix* p = NULL;
13161 char* gvp = (char*) G__getgvp();
13162 switch (libp->paran) {
13163 case 14:
13164 //m: 14
13165 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13166 p = new ZHelix(
13167(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13168, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13169, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13170, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13171, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13172, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
13173, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13]));
13174 } else {
13175 p = new((void*) gvp) ZHelix(
13176(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13177, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13178, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13179, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13180, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13181, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
13182, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13]));
13183 }
13184 break;
13185 case 13:
13186 //m: 13
13187 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13188 p = new ZHelix(
13189(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13190, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13191, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13192, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13193, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13194, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
13195, (Double_t) G__double(libp->para[12]));
13196 } else {
13197 p = new((void*) gvp) ZHelix(
13198(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13199, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13200, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13201, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13202, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13203, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
13204, (Double_t) G__double(libp->para[12]));
13205 }
13206 break;
13207 case 12:
13208 //m: 12
13209 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13210 p = new ZHelix(
13211(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13212, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13213, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13214, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13215, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13216, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11]));
13217 } else {
13218 p = new((void*) gvp) ZHelix(
13219(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13220, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13221, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13222, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13223, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13224, (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11]));
13225 }
13226 break;
13227 case 11:
13228 //m: 11
13229 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13230 p = new ZHelix(
13231(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13232, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13233, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13234, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13235, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13236, (Int_t) G__int(libp->para[10]));
13237 } else {
13238 p = new((void*) gvp) ZHelix(
13239(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
13240, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
13241, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
13242, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
13243, (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
13244, (Int_t) G__int(libp->para[10]));
13245 }
13246 break;
13247 }
13248 result7->obj.i = (long) p;
13249 result7->ref = (long) p;
13250 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
13251 return(1 || funcname || hash || result7 || libp) ;
13252}
13253
13254static int G__BesVisLib_rootcint_960_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13255{
13256 ((ZHelix*) G__getstructoffset())->Phi2XYZ((Double_t) G__double(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
13257, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
13258 G__setnull(result7);
13259 return(1 || funcname || hash || result7 || libp) ;
13260}
13261
13262static int G__BesVisLib_rootcint_960_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13263{
13264 ((ZHelix*) G__getstructoffset())->Phi2ZR((Double_t) G__double(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
13265, *(Double_t*) G__Doubleref(&libp->para[2]));
13266 G__setnull(result7);
13267 return(1 || funcname || hash || result7 || libp) ;
13268}
13269
13270static int G__BesVisLib_rootcint_960_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13271{
13272 ((ZHelix*) G__getstructoffset())->SetRange((EZHelixRangeType) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
13273, (Double_t) G__double(libp->para[2]));
13274 G__setnull(result7);
13275 return(1 || funcname || hash || result7 || libp) ;
13276}
13277
13278static int G__BesVisLib_rootcint_960_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13279{
13280 ((ZHelix*) G__getstructoffset())->SetTrackType((TrackType) G__int(libp->para[0]));
13281 G__setnull(result7);
13282 return(1 || funcname || hash || result7 || libp) ;
13283}
13284
13285static int G__BesVisLib_rootcint_960_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13286{
13287 switch (libp->paran) {
13288 case 1:
13289 ((ZHelix*) G__getstructoffset())->SetPoints((Option_t*) G__int(libp->para[0]));
13290 G__setnull(result7);
13291 break;
13292 case 0:
13293 ((ZHelix*) G__getstructoffset())->SetPoints();
13294 G__setnull(result7);
13295 break;
13296 }
13297 return(1 || funcname || hash || result7 || libp) ;
13298}
13299
13300static int G__BesVisLib_rootcint_960_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13301{
13302 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->X2Phi((Double_t) G__double(libp->para[0])));
13303 return(1 || funcname || hash || result7 || libp) ;
13304}
13305
13306static int G__BesVisLib_rootcint_960_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13307{
13308 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Y2Phi((Double_t) G__double(libp->para[0])));
13309 return(1 || funcname || hash || result7 || libp) ;
13310}
13311
13312static int G__BesVisLib_rootcint_960_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13313{
13314 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Z2Phi((Double_t) G__double(libp->para[0])));
13315 return(1 || funcname || hash || result7 || libp) ;
13316}
13317
13318static int G__BesVisLib_rootcint_960_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13319{
13320 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->R2Phi((Double_t) G__double(libp->para[0])));
13321 return(1 || funcname || hash || result7 || libp) ;
13322}
13323
13324static int G__BesVisLib_rootcint_960_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13325{
13326 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Phi2S((Double_t) G__double(libp->para[0])));
13327 return(1 || funcname || hash || result7 || libp) ;
13328}
13329
13330static int G__BesVisLib_rootcint_960_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13331{
13332 ((ZHelix*) G__getstructoffset())->DrawClass();
13333 G__setnull(result7);
13334 return(1 || funcname || hash || result7 || libp) ;
13335}
13336
13337static int G__BesVisLib_rootcint_960_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13338{
13339 ((ZHelix*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0]));
13340 G__setnull(result7);
13341 return(1 || funcname || hash || result7 || libp) ;
13342}
13343
13344static int G__BesVisLib_rootcint_960_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13345{
13346 G__letint(result7, 85, (long) ZHelix::Class());
13347 return(1 || funcname || hash || result7 || libp) ;
13348}
13349
13350static int G__BesVisLib_rootcint_960_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13351{
13352 G__letint(result7, 67, (long) ZHelix::Class_Name());
13353 return(1 || funcname || hash || result7 || libp) ;
13354}
13355
13356static int G__BesVisLib_rootcint_960_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13357{
13358 G__letint(result7, 115, (long) ZHelix::Class_Version());
13359 return(1 || funcname || hash || result7 || libp) ;
13360}
13361
13362static int G__BesVisLib_rootcint_960_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13363{
13364 ZHelix::Dictionary();
13365 G__setnull(result7);
13366 return(1 || funcname || hash || result7 || libp) ;
13367}
13368
13369static int G__BesVisLib_rootcint_960_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13370{
13371 ((ZHelix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13372 G__setnull(result7);
13373 return(1 || funcname || hash || result7 || libp) ;
13374}
13375
13376static int G__BesVisLib_rootcint_960_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13377{
13378 G__letint(result7, 67, (long) ZHelix::DeclFileName());
13379 return(1 || funcname || hash || result7 || libp) ;
13380}
13381
13382static int G__BesVisLib_rootcint_960_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13383{
13384 G__letint(result7, 105, (long) ZHelix::ImplFileLine());
13385 return(1 || funcname || hash || result7 || libp) ;
13386}
13387
13388static int G__BesVisLib_rootcint_960_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13389{
13390 G__letint(result7, 67, (long) ZHelix::ImplFileName());
13391 return(1 || funcname || hash || result7 || libp) ;
13392}
13393
13394static int G__BesVisLib_rootcint_960_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13395{
13396 G__letint(result7, 105, (long) ZHelix::DeclFileLine());
13397 return(1 || funcname || hash || result7 || libp) ;
13398}
13399
13400// automatic copy constructor
13401static int G__BesVisLib_rootcint_960_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13402
13403{
13404 ZHelix* p;
13405 void* tmp = (void*) G__int(libp->para[0]);
13406 p = new ZHelix(*(ZHelix*) tmp);
13407 result7->obj.i = (long) p;
13408 result7->ref = (long) p;
13409 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
13410 return(1 || funcname || hash || result7 || libp) ;
13411}
13412
13413// automatic destructor
13414typedef ZHelix G__TZHelix;
13415static int G__BesVisLib_rootcint_960_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13416{
13417 char* gvp = (char*) G__getgvp();
13418 long soff = G__getstructoffset();
13419 int n = G__getaryconstruct();
13420 //
13421 //has_a_delete: 1
13422 //has_own_delete1arg: 0
13423 //has_own_delete2arg: 0
13424 //
13425 if (!soff) {
13426 return(1);
13427 }
13428 if (n) {
13429 if (gvp == (char*)G__PVOID) {
13430 delete[] (ZHelix*) soff;
13431 } else {
13432 G__setgvp((long) G__PVOID);
13433 for (int i = n - 1; i >= 0; --i) {
13434 ((ZHelix*) (soff+(sizeof(ZHelix)*i)))->~G__TZHelix();
13435 }
13436 G__setgvp((long)gvp);
13437 }
13438 } else {
13439 if (gvp == (char*)G__PVOID) {
13440 delete (ZHelix*) soff;
13441 } else {
13442 G__setgvp((long) G__PVOID);
13443 ((ZHelix*) (soff))->~G__TZHelix();
13444 G__setgvp((long)gvp);
13445 }
13446 }
13447 G__setnull(result7);
13448 return(1 || funcname || hash || result7 || libp) ;
13449}
13450
13451// automatic assignment operator
13452static int G__BesVisLib_rootcint_960_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13453{
13454 ZHelix* dest = (ZHelix*) G__getstructoffset();
13455 *dest = *(ZHelix*) libp->para[0].ref;
13456 const ZHelix& obj = *dest;
13457 result7->ref = (long) (&obj);
13458 result7->obj.i = (long) (&obj);
13459 return(1 || funcname || hash || result7 || libp) ;
13460}
13461
13462
13463/* vector3 */
13464// automatic default constructor
13465static int G__BesVisLib_rootcint_961_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13466{
13467 vector3 *p;
13468 char* gvp = (char*) G__getgvp();
13469 int n = G__getaryconstruct();
13470 if (n) {
13471 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13472 p = new vector3[n];
13473 } else {
13474 p = new((void*) gvp) vector3[n];
13475 }
13476 } else {
13477 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13478 p = new vector3;
13479 } else {
13480 p = new((void*) gvp) vector3;
13481 }
13482 }
13483 result7->obj.i = (long) p;
13484 result7->ref = (long) p;
13485 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
13486 return(1 || funcname || hash || result7 || libp) ;
13487}
13488
13489// automatic copy constructor
13490static int G__BesVisLib_rootcint_961_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13491
13492{
13493 vector3* p;
13494 void* tmp = (void*) G__int(libp->para[0]);
13495 p = new vector3(*(vector3*) tmp);
13496 result7->obj.i = (long) p;
13497 result7->ref = (long) p;
13498 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
13499 return(1 || funcname || hash || result7 || libp) ;
13500}
13501
13502// automatic destructor
13503typedef vector3 G__Tvector3;
13504static int G__BesVisLib_rootcint_961_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13505{
13506 char* gvp = (char*) G__getgvp();
13507 long soff = G__getstructoffset();
13508 int n = G__getaryconstruct();
13509 //
13510 //has_a_delete: 0
13511 //has_own_delete1arg: 0
13512 //has_own_delete2arg: 0
13513 //
13514 if (!soff) {
13515 return(1);
13516 }
13517 if (n) {
13518 if (gvp == (char*)G__PVOID) {
13519 delete[] (vector3*) soff;
13520 } else {
13521 G__setgvp((long) G__PVOID);
13522 for (int i = n - 1; i >= 0; --i) {
13523 ((vector3*) (soff+(sizeof(vector3)*i)))->~G__Tvector3();
13524 }
13525 G__setgvp((long)gvp);
13526 }
13527 } else {
13528 if (gvp == (char*)G__PVOID) {
13529 delete (vector3*) soff;
13530 } else {
13531 G__setgvp((long) G__PVOID);
13532 ((vector3*) (soff))->~G__Tvector3();
13533 G__setgvp((long)gvp);
13534 }
13535 }
13536 G__setnull(result7);
13537 return(1 || funcname || hash || result7 || libp) ;
13538}
13539
13540// automatic assignment operator
13541static int G__BesVisLib_rootcint_961_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13542{
13543 vector3* dest = (vector3*) G__getstructoffset();
13544 *dest = *(vector3*) libp->para[0].ref;
13545 const vector3& obj = *dest;
13546 result7->ref = (long) (&obj);
13547 result7->obj.i = (long) (&obj);
13548 return(1 || funcname || hash || result7 || libp) ;
13549}
13550
13551
13552/* Setting up global function */
13553
13554/*********************************************************
13555* Member function Stub
13556*********************************************************/
13557
13558/* BesStatus */
13559
13560/* BesTView */
13561
13562/* Bes2DView */
13563
13564/* BesCircle2D */
13565
13566/* BesCursor */
13567
13568/* BesEventHeader */
13569
13570/* BesView */
13571
13572/* BesMarker2D */
13573
13574/* BesPaveText */
13575
13576/* BesGeoTrack */
13577
13578/* BesEvent */
13579
13580/* SubDetectorROOTGeo */
13581
13582/* BesPolygon2D */
13583
13584/* Mdc2DWire */
13585
13586/* MdcROOTGeo */
13587
13588/* Tof2DScin */
13589
13590/* TofROOTGeo */
13591
13592/* Emc2DCrystal */
13593
13594/* EmcROOTGeo */
13595
13596/* Muc2DStrip */
13597
13598/* MucROOTGeo */
13599
13600/* BesGeometry */
13601
13602/* BesGMenuTitle */
13603
13604/* BesGMenuBar */
13605
13606/* BesGPictureButton */
13607
13608/* BesHeader */
13609
13610/* BesVisDisplay */
13611
13612/* ZHelix */
13613
13614/* vector3 */
13615
13616/*********************************************************
13617* Global function Stub
13618*********************************************************/
13619
13620/*********************************************************
13621* Get size of pointer to member function
13622*********************************************************/
13623class G__Sizep2memfuncBesVisLib_rootcint {
13624 public:
13625 G__Sizep2memfuncBesVisLib_rootcint(): p(&G__Sizep2memfuncBesVisLib_rootcint::sizep2memfunc) {}
13626 size_t sizep2memfunc() { return(sizeof(p)); }
13627 private:
13628 size_t (G__Sizep2memfuncBesVisLib_rootcint::*p)();
13629};
13630
13631size_t G__get_sizep2memfuncBesVisLib_rootcint()
13632{
13633 G__Sizep2memfuncBesVisLib_rootcint a;
13634 G__setsizep2memfunc((int)a.sizep2memfunc());
13635 return((size_t)a.sizep2memfunc());
13636}
13637
13638
13639/*********************************************************
13640* virtual base class offset calculation interface
13641*********************************************************/
13642
13643 /* Setting up class inheritance */
13644
13645/*********************************************************
13646* Inheritance information setup/
13647*********************************************************/
13648extern "C" void G__cpp_setup_inheritanceBesVisLib_rootcint() {
13649
13650 /* Setting up class inheritance */
13651 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus))) {
13652 BesStatus *G__Lderived;
13653 G__Lderived=(BesStatus*)0x1000;
13654 {
13655 TObject *G__Lpbase=(TObject*)G__Lderived;
13656 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13657 }
13658 }
13659 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView))) {
13660 BesTView *G__Lderived;
13661 G__Lderived=(BesTView*)0x1000;
13662 {
13663 TView *G__Lpbase=(TView*)G__Lderived;
13664 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,1);
13665 }
13666 {
13667 TObject *G__Lpbase=(TObject*)G__Lderived;
13668 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13669 }
13670 {
13671 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13672 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13673 }
13674 }
13675 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView))) {
13676 Bes2DView *G__Lderived;
13677 G__Lderived=(Bes2DView*)0x1000;
13678 {
13679 BesTView *G__Lpbase=(BesTView*)G__Lderived;
13680 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),(long)G__Lpbase-(long)G__Lderived,1,1);
13681 }
13682 {
13683 TView *G__Lpbase=(TView*)G__Lderived;
13684 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,0);
13685 }
13686 {
13687 TObject *G__Lpbase=(TObject*)G__Lderived;
13688 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13689 }
13690 {
13691 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13692 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13693 }
13694 }
13695 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D))) {
13696 BesCircle2D *G__Lderived;
13697 G__Lderived=(BesCircle2D*)0x1000;
13698 {
13699 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13700 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13701 }
13702 {
13703 TObject *G__Lpbase=(TObject*)G__Lderived;
13704 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13705 }
13706 {
13707 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13708 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13709 }
13710 {
13711 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13712 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13713 }
13714 }
13715 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor))) {
13716 BesCursor *G__Lderived;
13717 G__Lderived=(BesCursor*)0x1000;
13718 {
13719 TObject *G__Lpbase=(TObject*)G__Lderived;
13720 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13721 }
13722 }
13723 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader))) {
13724 BesEventHeader *G__Lderived;
13725 G__Lderived=(BesEventHeader*)0x1000;
13726 {
13727 TObject *G__Lpbase=(TObject*)G__Lderived;
13728 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13729 }
13730 }
13731 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView))) {
13732 BesView *G__Lderived;
13733 G__Lderived=(BesView*)0x1000;
13734 {
13735 BesTView *G__Lpbase=(BesTView*)G__Lderived;
13736 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),(long)G__Lpbase-(long)G__Lderived,1,1);
13737 }
13738 {
13739 TView *G__Lpbase=(TView*)G__Lderived;
13740 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,0);
13741 }
13742 {
13743 TObject *G__Lpbase=(TObject*)G__Lderived;
13744 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13745 }
13746 {
13747 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13748 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13749 }
13750 }
13751 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D))) {
13752 BesMarker2D *G__Lderived;
13753 G__Lderived=(BesMarker2D*)0x1000;
13754 {
13755 TMarker *G__Lpbase=(TMarker*)G__Lderived;
13756 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
13757 }
13758 {
13759 TObject *G__Lpbase=(TObject*)G__Lderived;
13760 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13761 }
13762 {
13763 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
13764 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
13765 }
13766 }
13767 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText))) {
13768 BesPaveText *G__Lderived;
13769 G__Lderived=(BesPaveText*)0x1000;
13770 {
13771 TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
13772 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
13773 }
13774 {
13775 TPave *G__Lpbase=(TPave*)G__Lderived;
13776 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
13777 }
13778 {
13779 TBox *G__Lpbase=(TBox*)G__Lderived;
13780 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
13781 }
13782 {
13783 TObject *G__Lpbase=(TObject*)G__Lderived;
13784 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13785 }
13786 {
13787 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13788 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13789 }
13790 {
13791 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13792 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
13793 }
13794 {
13795 TAttText *G__Lpbase=(TAttText*)G__Lderived;
13796 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
13797 }
13798 }
13799 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack))) {
13800 BesGeoTrack *G__Lderived;
13801 G__Lderived=(BesGeoTrack*)0x1000;
13802 {
13803 TGeoTrack *G__Lpbase=(TGeoTrack*)G__Lderived;
13804 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoTrack),(long)G__Lpbase-(long)G__Lderived,1,1);
13805 }
13806 {
13807 TVirtualGeoTrack *G__Lpbase=(TVirtualGeoTrack*)G__Lderived;
13808 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVirtualGeoTrack),(long)G__Lpbase-(long)G__Lderived,1,0);
13809 }
13810 {
13811 TObject *G__Lpbase=(TObject*)G__Lderived;
13812 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13813 }
13814 {
13815 TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
13816 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
13817 }
13818 {
13819 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13820 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13821 }
13822 {
13823 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
13824 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
13825 }
13826 }
13827 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent))) {
13828 BesEvent *G__Lderived;
13829 G__Lderived=(BesEvent*)0x1000;
13830 {
13831 TObject *G__Lpbase=(TObject*)G__Lderived;
13832 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13833 }
13834 }
13835 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D))) {
13836 BesPolygon2D *G__Lderived;
13837 G__Lderived=(BesPolygon2D*)0x1000;
13838 {
13839 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13840 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13841 }
13842 {
13843 TObject *G__Lpbase=(TObject*)G__Lderived;
13844 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13845 }
13846 {
13847 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13848 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13849 }
13850 {
13851 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13852 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13853 }
13854 }
13855 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire))) {
13856 Mdc2DWire *G__Lderived;
13857 G__Lderived=(Mdc2DWire*)0x1000;
13858 {
13859 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13860 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13861 }
13862 {
13863 TObject *G__Lpbase=(TObject*)G__Lderived;
13864 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13865 }
13866 {
13867 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13868 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13869 }
13870 {
13871 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13872 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13873 }
13874 }
13875 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo))) {
13876 MdcROOTGeo *G__Lderived;
13877 G__Lderived=(MdcROOTGeo*)0x1000;
13878 {
13879 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13880 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13881 }
13882 }
13883 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin))) {
13884 Tof2DScin *G__Lderived;
13885 G__Lderived=(Tof2DScin*)0x1000;
13886 {
13887 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13888 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13889 }
13890 {
13891 TObject *G__Lpbase=(TObject*)G__Lderived;
13892 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13893 }
13894 {
13895 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13896 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13897 }
13898 {
13899 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13900 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13901 }
13902 }
13903 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo))) {
13904 TofROOTGeo *G__Lderived;
13905 G__Lderived=(TofROOTGeo*)0x1000;
13906 {
13907 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13908 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13909 }
13910 }
13911 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal))) {
13912 Emc2DCrystal *G__Lderived;
13913 G__Lderived=(Emc2DCrystal*)0x1000;
13914 {
13915 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13916 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13917 }
13918 {
13919 TObject *G__Lpbase=(TObject*)G__Lderived;
13920 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13921 }
13922 {
13923 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13924 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13925 }
13926 {
13927 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13928 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13929 }
13930 }
13931 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo))) {
13932 EmcROOTGeo *G__Lderived;
13933 G__Lderived=(EmcROOTGeo*)0x1000;
13934 {
13935 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13936 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13937 }
13938 }
13939 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip))) {
13940 Muc2DStrip *G__Lderived;
13941 G__Lderived=(Muc2DStrip*)0x1000;
13942 {
13943 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13944 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13945 }
13946 {
13947 TObject *G__Lpbase=(TObject*)G__Lderived;
13948 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13949 }
13950 {
13951 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13952 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13953 }
13954 {
13955 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13956 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13957 }
13958 }
13959 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo))) {
13960 MucROOTGeo *G__Lderived;
13961 G__Lderived=(MucROOTGeo*)0x1000;
13962 {
13963 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13964 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13965 }
13966 }
13967 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry))) {
13968 BesGeometry *G__Lderived;
13969 G__Lderived=(BesGeometry*)0x1000;
13970 {
13971 TObject *G__Lpbase=(TObject*)G__Lderived;
13972 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13973 }
13974 }
13975 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle))) {
13976 BesGMenuTitle *G__Lderived;
13977 G__Lderived=(BesGMenuTitle*)0x1000;
13978 {
13979 TGMenuTitle *G__Lpbase=(TGMenuTitle*)G__Lderived;
13980 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGMenuTitle),(long)G__Lpbase-(long)G__Lderived,1,1);
13981 }
13982 {
13983 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13984 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13985 }
13986 {
13987 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13988 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13989 }
13990 {
13991 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13992 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13993 }
13994 {
13995 TObject *G__Lpbase=(TObject*)G__Lderived;
13996 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13997 }
13998 {
13999 TQObject *G__Lpbase=(TQObject*)G__Lderived;
14000 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14001 }
14002 }
14003 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar))) {
14004 BesGMenuBar *G__Lderived;
14005 G__Lderived=(BesGMenuBar*)0x1000;
14006 {
14007 TGMenuBar *G__Lpbase=(TGMenuBar*)G__Lderived;
14008 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGMenuBar),(long)G__Lpbase-(long)G__Lderived,1,1);
14009 }
14010 {
14011 TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived;
14012 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
14013 }
14014 {
14015 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
14016 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
14017 }
14018 {
14019 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
14020 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
14021 }
14022 {
14023 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
14024 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
14025 }
14026 {
14027 TGObject *G__Lpbase=(TGObject*)G__Lderived;
14028 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14029 }
14030 {
14031 TObject *G__Lpbase=(TObject*)G__Lderived;
14032 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14033 }
14034 {
14035 TQObject *G__Lpbase=(TQObject*)G__Lderived;
14036 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14037 }
14038 }
14039 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton))) {
14040 BesGPictureButton *G__Lderived;
14041 G__Lderived=(BesGPictureButton*)0x1000;
14042 {
14043 TGPictureButton *G__Lpbase=(TGPictureButton*)G__Lderived;
14044 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGPictureButton),(long)G__Lpbase-(long)G__Lderived,1,1);
14045 }
14046 {
14047 TGButton *G__Lpbase=(TGButton*)G__Lderived;
14048 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
14049 }
14050 {
14051 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
14052 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
14053 }
14054 {
14055 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
14056 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
14057 }
14058 {
14059 TGObject *G__Lpbase=(TGObject*)G__Lderived;
14060 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14061 }
14062 {
14063 TObject *G__Lpbase=(TObject*)G__Lderived;
14064 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14065 }
14066 {
14067 TQObject *G__Lpbase=(TQObject*)G__Lderived;
14068 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14069 }
14070 {
14071 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
14072 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
14073 }
14074 }
14075 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader))) {
14076 BesHeader *G__Lderived;
14077 G__Lderived=(BesHeader*)0x1000;
14078 {
14079 TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
14080 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
14081 }
14082 {
14083 TPave *G__Lpbase=(TPave*)G__Lderived;
14084 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
14085 }
14086 {
14087 TBox *G__Lpbase=(TBox*)G__Lderived;
14088 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
14089 }
14090 {
14091 TObject *G__Lpbase=(TObject*)G__Lderived;
14092 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14093 }
14094 {
14095 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
14096 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
14097 }
14098 {
14099 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
14100 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
14101 }
14102 {
14103 TAttText *G__Lpbase=(TAttText*)G__Lderived;
14104 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
14105 }
14106 {
14107 TQObject *G__Lpbase=(TQObject*)G__Lderived;
14108 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
14109 }
14110 }
14111 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay))) {
14112 BesVisDisplay *G__Lderived;
14113 G__Lderived=(BesVisDisplay*)0x1000;
14114 {
14115 TQObject *G__Lpbase=(TQObject*)G__Lderived;
14116 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
14117 }
14118 }
14119 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix))) {
14120 ZHelix *G__Lderived;
14121 G__Lderived=(ZHelix*)0x1000;
14122 {
14123 TPolyLine3D *G__Lpbase=(TPolyLine3D*)G__Lderived;
14124 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPolyLine3D),(long)G__Lpbase-(long)G__Lderived,1,1);
14125 }
14126 {
14127 TObject *G__Lpbase=(TObject*)G__Lderived;
14128 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
14129 }
14130 {
14131 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
14132 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
14133 }
14134 {
14135 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
14136 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
14137 }
14138 }
14139}
14140
14141/*********************************************************
14142* typedef information setup/
14143*********************************************************/
14144extern "C" void G__cpp_setup_typetableBesVisLib_rootcint() {
14145
14146 /* Setting up typedef entry */
14147 G__search_typename2("Int_t",105,-1,0,-1);
14148 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
14149 G__search_typename2("UInt_t",104,-1,0,-1);
14150 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
14151 G__search_typename2("Float_t",102,-1,0,-1);
14152 G__setnewtype(-1,"Float 4 bytes (float)",0);
14153 G__search_typename2("Double_t",100,-1,0,-1);
14154 G__setnewtype(-1,"Double 8 bytes",0);
14155 G__search_typename2("Bool_t",103,-1,0,-1);
14156 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
14157 G__search_typename2("Version_t",115,-1,0,-1);
14158 G__setnewtype(-1,"Class version identifier (short)",0);
14159 G__search_typename2("Option_t",99,-1,256,-1);
14160 G__setnewtype(-1,"Option string (const char)",0);
14161 G__search_typename2("Long64_t",110,-1,0,-1);
14162 G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
14163 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
14164 G__setnewtype(-1,NULL,0);
14165 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
14166 G__setnewtype(-1,NULL,0);
14167 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
14168 G__setnewtype(-1,NULL,0);
14169 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
14170 G__setnewtype(-1,NULL,0);
14171 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14172 G__setnewtype(-1,NULL,0);
14173 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14174 G__setnewtype(-1,NULL,0);
14175 G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
14176 G__setnewtype(-1,NULL,0);
14177 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
14178 G__setnewtype(-1,NULL,0);
14179 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
14180 G__setnewtype(-1,NULL,0);
14181 G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
14182 G__setnewtype(-1,NULL,0);
14183 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14184 G__setnewtype(-1,NULL,0);
14185 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14186 G__setnewtype(-1,NULL,0);
14187 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14188 G__setnewtype(-1,NULL,0);
14189 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14190 G__setnewtype(-1,NULL,0);
14191 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14192 G__setnewtype(-1,NULL,0);
14193 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
14194 G__setnewtype(-1,NULL,0);
14195 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
14196 G__setnewtype(-1,NULL,0);
14197 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
14198 G__setnewtype(-1,NULL,0);
14199 G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
14200 G__setnewtype(-1,NULL,0);
14201 G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
14202 G__setnewtype(-1,NULL,0);
14203 G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
14204 G__setnewtype(-1,NULL,0);
14205 G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
14206 G__setnewtype(-1,NULL,0);
14207 G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
14208 G__setnewtype(-1,NULL,0);
14209 G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
14210 G__setnewtype(-1,NULL,0);
14211 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
14212 G__setnewtype(-1,NULL,0);
14213 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
14214 G__setnewtype(-1,NULL,0);
14215 G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
14216 G__setnewtype(-1,NULL,0);
14217 G__search_typename2("pair<Int_t,Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_pairlEintcOfloatgR),0,-1);
14218 G__setnewtype(-1,NULL,0);
14219 G__search_typename2("vector<std::pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
14220 G__setnewtype(-1,NULL,0);
14221 G__search_typename2("vector<pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
14222 G__setnewtype(-1,NULL,0);
14223 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
14224 G__setnewtype(-1,NULL,0);
14225 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
14226 G__setnewtype(-1,NULL,0);
14227 G__search_typename2("vector<pair<int,float> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
14228 G__setnewtype(-1,NULL,0);
14229 G__search_typename2("Pixmap_t",107,-1,0,-1);
14230 G__setnewtype(-1,"Pixmap handle",0);
14231 G__search_typename2("GContext_t",107,-1,0,-1);
14232 G__setnewtype(-1,"Graphics context handle",0);
14233 G__search_typename2("FontStruct_t",107,-1,0,-1);
14234 G__setnewtype(-1,"Pointer to font structure",0);
14235 G__search_typename2("pair<UInt_t,Int_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR),0,-1);
14236 G__setnewtype(-1,NULL,0);
14237 G__search_typename2("vector<std::pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
14238 G__setnewtype(-1,NULL,0);
14239 G__search_typename2("vector<pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
14240 G__setnewtype(-1,NULL,0);
14241 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
14242 G__setnewtype(-1,NULL,0);
14243 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
14244 G__setnewtype(-1,NULL,0);
14245 G__search_typename2("vector<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
14246 G__setnewtype(-1,NULL,0);
14247 G__search_typename2("map<Int_t,TGeoElementRN*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
14248 G__setnewtype(-1,NULL,0);
14249 G__search_typename2("map<int,TGeoElementRN*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
14250 G__setnewtype(-1,NULL,0);
14251 G__search_typename2("map<int,TGeoElementRN*,less<int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
14252 G__setnewtype(-1,NULL,0);
14253 G__search_typename2("vector<ThreadData_t*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
14254 G__setnewtype(-1,NULL,0);
14255 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
14256 G__setnewtype(-1,NULL,0);
14257 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
14258 G__setnewtype(-1,NULL,0);
14259 G__search_typename2("vector<TGeoVolumeAssembly::ThreadData_t*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
14260 G__setnewtype(-1,NULL,0);
14261 G__search_typename2("vector<ContentItem>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR),0,-1);
14262 G__setnewtype(-1,NULL,0);
14263 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR));
14264 G__setnewtype(-1,NULL,0);
14265 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR));
14266 G__setnewtype(-1,NULL,0);
14267 G__search_typename2("vector<ContentGroup::ContentItem>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR),0,-1);
14268 G__setnewtype(-1,NULL,0);
14269 G__search_typename2("vector<ContentChoice*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR),0,-1);
14270 G__setnewtype(-1,NULL,0);
14271 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR));
14272 G__setnewtype(-1,NULL,0);
14273 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR));
14274 G__setnewtype(-1,NULL,0);
14275 G__search_typename2("map<std::string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
14276 G__setnewtype(-1,NULL,0);
14277 G__search_typename2("map<string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
14278 G__setnewtype(-1,NULL,0);
14279 G__search_typename2("map<string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
14280 G__setnewtype(-1,NULL,0);
14281 G__search_typename2("map<string,define::constant,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
14282 G__setnewtype(-1,NULL,0);
14283 G__search_typename2("map<std::string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
14284 G__setnewtype(-1,NULL,0);
14285 G__search_typename2("map<string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
14286 G__setnewtype(-1,NULL,0);
14287 G__search_typename2("map<string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
14288 G__setnewtype(-1,NULL,0);
14289 G__search_typename2("map<string,define::quantity,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
14290 G__setnewtype(-1,NULL,0);
14291 G__search_typename2("map<std::string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
14292 G__setnewtype(-1,NULL,0);
14293 G__search_typename2("map<string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
14294 G__setnewtype(-1,NULL,0);
14295 G__search_typename2("map<string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
14296 G__setnewtype(-1,NULL,0);
14297 G__search_typename2("map<string,define::expression,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
14298 G__setnewtype(-1,NULL,0);
14299 G__search_typename2("map<std::string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
14300 G__setnewtype(-1,NULL,0);
14301 G__search_typename2("map<string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
14302 G__setnewtype(-1,NULL,0);
14303 G__search_typename2("map<string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
14304 G__setnewtype(-1,NULL,0);
14305 G__search_typename2("map<string,define::position,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
14306 G__setnewtype(-1,NULL,0);
14307 G__search_typename2("map<std::string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
14308 G__setnewtype(-1,NULL,0);
14309 G__search_typename2("map<string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
14310 G__setnewtype(-1,NULL,0);
14311 G__search_typename2("map<string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
14312 G__setnewtype(-1,NULL,0);
14313 G__search_typename2("map<string,define::rotation,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
14314 G__setnewtype(-1,NULL,0);
14315 G__search_typename2("map<std::string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
14316 G__setnewtype(-1,NULL,0);
14317 G__search_typename2("map<string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
14318 G__setnewtype(-1,NULL,0);
14319 G__search_typename2("map<string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
14320 G__setnewtype(-1,NULL,0);
14321 G__search_typename2("map<string,TGeoTranslation*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
14322 G__setnewtype(-1,NULL,0);
14323 G__search_typename2("map<std::string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
14324 G__setnewtype(-1,NULL,0);
14325 G__search_typename2("map<string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
14326 G__setnewtype(-1,NULL,0);
14327 G__search_typename2("map<string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
14328 G__setnewtype(-1,NULL,0);
14329 G__search_typename2("map<string,TGeoRotation*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
14330 G__setnewtype(-1,NULL,0);
14331 G__search_typename2("map<std::string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
14332 G__setnewtype(-1,NULL,0);
14333 G__search_typename2("map<string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
14334 G__setnewtype(-1,NULL,0);
14335 G__search_typename2("map<string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
14336 G__setnewtype(-1,NULL,0);
14337 G__search_typename2("map<string,TGeoShape*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
14338 G__setnewtype(-1,NULL,0);
14339 G__search_typename2("map<std::string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
14340 G__setnewtype(-1,NULL,0);
14341 G__search_typename2("map<string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
14342 G__setnewtype(-1,NULL,0);
14343 G__search_typename2("map<string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
14344 G__setnewtype(-1,NULL,0);
14345 G__search_typename2("map<string,TGeoVolume*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
14346 G__setnewtype(-1,NULL,0);
14347 G__search_typename2("map<std::string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
14348 G__setnewtype(-1,NULL,0);
14349 G__search_typename2("map<string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
14350 G__setnewtype(-1,NULL,0);
14351 G__search_typename2("map<string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
14352 G__setnewtype(-1,NULL,0);
14353 G__search_typename2("map<string,TGeoVolumeAssembly*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
14354 G__setnewtype(-1,NULL,0);
14355 G__search_typename2("map<std::string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
14356 G__setnewtype(-1,NULL,0);
14357 G__search_typename2("map<string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
14358 G__setnewtype(-1,NULL,0);
14359 G__search_typename2("map<string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
14360 G__setnewtype(-1,NULL,0);
14361 G__search_typename2("map<string,TGeoNode*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
14362 G__setnewtype(-1,NULL,0);
14363 G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR),0,-1);
14364 G__setnewtype(-1,NULL,0);
14365 G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR),0,-1);
14366 G__setnewtype(-1,NULL,0);
14367 G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVectorTlEfloatgR),0,-1);
14368 G__setnewtype(-1,NULL,0);
14369 G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVectorTlEdoublegR),0,-1);
14370 G__setnewtype(-1,NULL,0);
14371 G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTlEfloatgR),0,-1);
14372 G__setnewtype(-1,NULL,0);
14373 G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR),0,-1);
14374 G__setnewtype(-1,NULL,0);
14375 G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR),0,-1);
14376 G__setnewtype(-1,NULL,0);
14377 G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR),0,-1);
14378 G__setnewtype(-1,NULL,0);
14379 G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR),0,-1);
14380 G__setnewtype(-1,NULL,0);
14381 G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR),0,-1);
14382 G__setnewtype(-1,NULL,0);
14383 G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
14384 G__setnewtype(-1,NULL,0);
14385 G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
14386 G__setnewtype(-1,NULL,0);
14387 G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR),0,-1);
14388 G__setnewtype(-1,NULL,0);
14389 G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR),0,-1);
14390 G__setnewtype(-1,NULL,0);
14391 G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR),0,-1);
14392 G__setnewtype(-1,NULL,0);
14393 G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR),0,-1);
14394 G__setnewtype(-1,NULL,0);
14395 G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR),0,-1);
14396 G__setnewtype(-1,NULL,0);
14397 G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR),0,-1);
14398 G__setnewtype(-1,NULL,0);
14399 G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
14400 G__setnewtype(-1,NULL,0);
14401 G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TElementActionTlEfloatgR),0,-1);
14402 G__setnewtype(-1,NULL,0);
14403 G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR),0,-1);
14404 G__setnewtype(-1,NULL,0);
14405 G__search_typename2("intMap",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
14406 G__setnewtype(-1,NULL,0);
14407}
14408
14409/*********************************************************
14410* Data Member information setup/
14411*********************************************************/
14412
14413 /* Setting up class,struct,union tag member variable */
14414
14415 /* BesStatus */
14416static void G__setup_memvarBesStatus(void) {
14417 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
14418 { BesStatus *p; p=(BesStatus*)0x1000; if (p) { }
14419 G__memvar_setup((void*)((long)(&p->fCgemGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemGlobal=",0,"visibility for global CGEM");
14420 G__memvar_setup((void*)((long)(&p->fCgemLayers)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemLayers=",0,"visibility for CGEM layers");
14421 G__memvar_setup((void*)((long)(&p->fCgemXStrips)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemXStrips=",0,"visibility for CGEM X-strips");
14422 G__memvar_setup((void*)((long)(&p->fCgemVStrips)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemVStrips=",0,"visibility for CGEM V-strips");
14423 G__memvar_setup((void*)((long)(&p->fMdcGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcGlobal=",0,"! visibility flag for global Mdc");
14424 G__memvar_setup((void*)((long)(&p->fMdcTubes)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcTubes=",0,"! visibility flag for Mdc main tubes");
14425 G__memvar_setup((void*)((long)(&p->fMdcWires)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcWires=",0,"! visibility flag for Mdc wires");
14426 G__memvar_setup((void*)((long)(&p->fTofGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofGlobal=",0,"!visibility flag for global Tof");
14427 G__memvar_setup((void*)((long)(&p->fTofEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofEast=",0,"!visibility flag for Tof east EC");
14428 G__memvar_setup((void*)((long)(&p->fTofBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofBarrel=",0,"!visibility flag for Tof barrel");
14429 G__memvar_setup((void*)((long)(&p->fTofWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofWest=",0,"!visibility flag for Tof west EC");
14430 G__memvar_setup((void*)((long)(&p->fEmcGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcGlobal=",0,"! visivility flag for global Emc");
14431 G__memvar_setup((void*)((long)(&p->fEmcEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcEast=",0,"! visivility flag for Emc east EC");
14432 G__memvar_setup((void*)((long)(&p->fEmcBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcBarrel=",0,"! visivility flag for Emc barrel");
14433 G__memvar_setup((void*)((long)(&p->fEmcWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcWest=",0,"! visivility flag for Emc west EC");
14434 G__memvar_setup((void*)((long)(&p->fEmcSide)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcSide=",0,"! visivility flag for Emc side");
14435 G__memvar_setup((void*)((long)(&p->fMucGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucGlobal=",0,"! visivility flag for global Muc");
14436 G__memvar_setup((void*)((long)(&p->fMucEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucEast=",0,"! visivility flag for Muc east EC");
14437 G__memvar_setup((void*)((long)(&p->fMucBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucBarrel=",0,"! visivility flag for Muc barrel");
14438 G__memvar_setup((void*)((long)(&p->fMucWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucWest=",0,"! visivility flag for Muc west EC");
14439 G__memvar_setup((void*)((long)(&p->fMucStrips)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucStrips=",0,"! visivility flag for Muc strips");
14440 G__memvar_setup((void*)((long)(&p->fFull3DCgem)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DCgem=",0,"Long Peixun's update: Add Cgem option");
14441 G__memvar_setup((void*)((long)(&p->fFull3DMdc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DMdc=",0,"! visivility flag for full 3D Mdc");
14442 G__memvar_setup((void*)((long)(&p->fFull3DTof)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DTof=",0,"! visivility flag for full 3D Tof");
14443 G__memvar_setup((void*)((long)(&p->fFull3DEmc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DEmc=",0,"! visivility flag for full 3D Emc");
14444 G__memvar_setup((void*)((long)(&p->fFull3DMuc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DMuc=",0,"! visivility flag for full 3D Muc");
14445 G__memvar_setup((void*)((long)(&p->fBeamPipe)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fBeamPipe=",0,"! visibility flag for beam pipe");
14446 G__memvar_setup((void*)((long)(&p->fZRPlaneOnXY)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fZRPlaneOnXY=",0,"! visibility flag for ZRPlaneOnXY");
14447 G__memvar_setup((void*)((long)(&p->fAxis)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fAxis=",0,"! visibility flag for axis");
14448 G__memvar_setup((void*)((long)(&p->fCgemHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemHitsGlobal=",0,"visibility flag for global CGEM hits");
14449 G__memvar_setup((void*)((long)(&p->fCgemHitsXStrip)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemHitsXStrip=",0,"visibility flag for CGEM hits X-strip");
14450 G__memvar_setup((void*)((long)(&p->fCgemHitsVStrip)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemHitsVStrip=",0,"visibility flag for CGEM hits V-strip");
14451 G__memvar_setup((void*)((long)(&p->fCgemHitsClusters)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemHitsClusters=",0,"visibility flag for CGEM clusters");
14452 G__memvar_setup((void*)((long)(&p->fCgemHitsFiredHL)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fCgemHitsFiredHL=",0,"visibility flag for CGEM highlight fired stirps");
14453 G__memvar_setup((void*)((long)(&p->fMdcHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcHitsGlobal=",0,"! visibility flag for global Mdc Hits");
14454 G__memvar_setup((void*)((long)(&p->fMdcHits)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcHits=",0,"! visibility flag for Mdc Hits");
14455 G__memvar_setup((void*)((long)(&p->fTofHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsGlobal=",0,"! visibility flag for global Tof Hits");
14456 G__memvar_setup((void*)((long)(&p->fTofHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsEast=",0,"! visibility flag for Tof Hits East");
14457 G__memvar_setup((void*)((long)(&p->fTofHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsBarrel=",0,"! visibility flag for Tof Hits Barrel");
14458 G__memvar_setup((void*)((long)(&p->fTofHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsWest=",0,"! visibility flag for Tof Hits West");
14459 G__memvar_setup((void*)((long)(&p->fEmcHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsGlobal=",0,"! visibility flag for global Emc Hits");
14460 G__memvar_setup((void*)((long)(&p->fEmcHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsEast=",0,"! visibility flag for Emc Hits East");
14461 G__memvar_setup((void*)((long)(&p->fEmcHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsBarrel=",0,"! visibility flag for Emc Hits Barrel");
14462 G__memvar_setup((void*)((long)(&p->fEmcHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsWest=",0,"! visibility flag for Emc Hits West");
14463 G__memvar_setup((void*)((long)(&p->fEmcHitsSide)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsSide=",0,"! visibility flag for Emc Hits Side");
14464 G__memvar_setup((void*)((long)(&p->fMucHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsGlobal=",0,"! visibility flag for global Muc Hits");
14465 G__memvar_setup((void*)((long)(&p->fMucHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsEast=",0,"! visibility flag for Muc Hits East");
14466 G__memvar_setup((void*)((long)(&p->fMucHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsBarrel=",0,"! visibility flag for Muc Hits Barrel");
14467 G__memvar_setup((void*)((long)(&p->fMucHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsWest=",0,"! visibility flag for Muc Hits West");
14468 G__memvar_setup((void*)((long)(&p->fTracksGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksGlobal=",0,"! visibility flag for global Tracks");
14469 G__memvar_setup((void*)((long)(&p->fTracksMdc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksMdc=",0,"! visibility flag for Mdc Tracks");
14470 G__memvar_setup((void*)((long)(&p->fTracksTof)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksTof=",0,"! visibility flag for Tof Tracks");
14471 G__memvar_setup((void*)((long)(&p->fTracksEmc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksEmc=",0,"! visibility flag for Emc Tracks");
14472 G__memvar_setup((void*)((long)(&p->fTracksMuc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksMuc=",0,"! visibility flag for Muc Tracks");
14473 G__memvar_setup((void*)((long)(&p->fTracksExt)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksExt=",0,"! visibility flag for Ext Tracks");
14474 G__memvar_setup((void*)((long)(&p->fFishEye)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFishEye=",0,"! flags for fish eye view");
14475 G__memvar_setup((void*)((long)(&p->fPhiRangeMin)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14476 G__memvar_setup((void*)((long)(&p->fPhiRangeMax)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14477 G__memvar_setup((void*)((long)(&p->fZoom)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fZoom=",0,(char*)NULL);
14478 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14479 }
14480 G__tag_memvar_reset();
14481}
14482
14483
14484 /* BesTView */
14485static void G__setup_memvarBesTView(void) {
14486 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
14487 { BesTView *p; p=(BesTView*)0x1000; if (p) { }
14488 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLatitude=",0,"View angle latitude");
14489 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLongitude=",0,"View angle longitude");
14490 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsi=",0,"View angle psi");
14491 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDview=",0,"Distance from COP to COV");
14492 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDproj=",0,"Distance from COP to projection plane");
14493 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUpix=",0,"pad X size in pixels");
14494 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVpix=",0,"pad Y size in pixels");
14495 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTN[16]=",0,(char*)NULL);
14496 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTB[16]=",0,(char*)NULL);
14497 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax[3]=",0,"Upper limits of object");
14498 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin[3]=",0,"Lower limits of object");
14499 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUVcoord[4]=",0,"Viewing window limits");
14500 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTnorm[16]=",0,"Transformation matrix");
14501 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTback[16]=",0,"Back transformation matrix");
14502 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1[3]=",0,"First coordinate of X axis");
14503 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2[3]=",0,"Second coordinate of X axis");
14504 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1[3]=",0,"First coordinate of Y axis");
14505 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2[3]=",0,"Second coordinate of Y axis");
14506 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ1[3]=",0,"First coordinate of Z axis");
14507 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ2[3]=",0,"Second coordinate of Z axis");
14508 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSystem=",0,"Coordinate system");
14509 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TSeqCollection),-1,-1,2,"fOutline=",0,"Collection of outline's objects");
14510 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDefaultOutline=",0,"Set to TRUE if outline is default cube");
14511 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoRange=",0,"Set to TRUE if range computed automatically");
14512 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"! Set to TRUE after ExecuteRotateView");
14513 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTViewcLcLdA),-1,-2,1,G__FastAllocString(4096).Format("kPerspective=%lldLL",(long long)BesTView::kPerspective).data(),0,(char*)NULL);
14514 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14515 }
14516 G__tag_memvar_reset();
14517}
14518
14519
14520 /* Bes2DView */
14521static void G__setup_memvarBes2DView(void) {
14522 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
14523 { Bes2DView *p; p=(Bes2DView*)0x1000; if (p) { }
14524 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFishEye=",0,"variable needed for toggle in menu");
14525 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"f2DViewType=",0,"View type");
14526 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14527 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14528 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveLabel),-1,-1,4,"fLabel=",0,"Label");
14529 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMarkerSize=",0,"size for marker");
14530 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatus3D=",0,"3D view status flags");
14531 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusXY=",0,"XY view status flags");
14532 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusZR=",0,"ZR view status flags");
14533 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusCurrent=",0,"current view status flags");
14534 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomFactor=",0,"zoom factor");
14535 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14536 }
14537 G__tag_memvar_reset();
14538}
14539
14540
14541 /* BesCircle2D */
14542static void G__setup_memvarBesCircle2D(void) {
14543 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
14544 { BesCircle2D *p; p=(BesCircle2D*)0x1000; if (p) { }
14545 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_innerCircleX=",0,(char*)NULL);
14546 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_innerCircleY=",0,(char*)NULL);
14547 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_outerCircleX=",0,(char*)NULL);
14548 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_outerCircleY=",0,(char*)NULL);
14549 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_areaX=",0,(char*)NULL);
14550 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_areaY=",0,(char*)NULL);
14551 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInnerRadius=",0,"inner Radius of circle");
14552 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOuterRadius=",0,"outer Radius of circle");
14553 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCenter=",0,"[3] center of circle");
14554 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNSegment=",0,(char*)NULL);
14555 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14556 }
14557 G__tag_memvar_reset();
14558}
14559
14560
14561 /* BesCursor */
14562static void G__setup_memvarBesCursor(void) {
14563 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
14564 { BesCursor *p; p=(BesCursor*)0x1000; if (p) { }
14565 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESCursorType),-1,-1,4,"fCursorType=",0,(char*)NULL);
14566 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShowInfo=",0,(char*)NULL);
14567 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14568 }
14569 G__tag_memvar_reset();
14570}
14571
14572
14573 /* BesEventHeader */
14574static void G__setup_memvarBesEventHeader(void) {
14575 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
14576 { BesEventHeader *p; p=(BesEventHeader*)0x1000; if (p) { }
14577 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fRun=",0,"Run number");
14578 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fEvent=",0,"Event number");
14579 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMC=",0,"MC event ");
14580 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDay=",0,"Day of Event");
14581 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMonth=",0,"Month of Event");
14582 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fYear=",0,"Year of Event");
14583 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHour=",0,"Hour of Event");
14584 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMin=",0,"Minute of Event");
14585 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSec=",0,"Second of Event");
14586 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRec=",0,"Long Peixun's update: Reconstruction Event");
14587 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvTime=",0,"event start time ");
14588 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEvTimeStatus=",0,"event start time status");
14589 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvTimeQuality=",0,"event start time quality");
14590 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fP=",0,"Total momentum of all Mdc Tracks (in GeV/c)");
14591 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPt=",0,"Transverse momentum");
14592 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPx=",0,(char*)NULL);
14593 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPy=",0,(char*)NULL);
14594 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPz=",0,(char*)NULL);
14595 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fT=",0,(char*)NULL);
14596 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fE=",0,(char*)NULL);
14597 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTimeType=",0,(char*)NULL);
14598 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fTrigChannelVector=",0,(char*)NULL);
14599 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fTrigConditionVector=",0,(char*)NULL);
14600 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14601 }
14602 G__tag_memvar_reset();
14603}
14604
14605
14606 /* BesView */
14607static void G__setup_memvarBesView(void) {
14608 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
14609 { BesView *p; p=(BesView*)0x1000; if (p) { }
14610 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFishEye=",0,"variable needed for toggle in menu");
14611 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESViewType),-1,-1,4,"fViewType=",0,"View type");
14612 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14613 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14614 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveLabel),-1,-1,4,"fLabel=",0,"Label");
14615 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMarkerSize=",0,"size for marker");
14616 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatus3D=",0,"3D view status flags");
14617 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusXY=",0,"XY view status flags");
14618 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusZR=",0,"ZR view status flags");
14619 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusCurrent=",0,"current view status flags");
14620 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomFactor=",0,"zoom factor");
14621 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fExtentDefault=",0,(char*)NULL);
14622 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"m_BesR=",0,(char*)NULL);
14623 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"m_BesZ=",0,(char*)NULL);
14624 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"ViewCenter[2]=",0,"Long Peixun's update: Coordinate of the center of View");
14625 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14626 }
14627 G__tag_memvar_reset();
14628}
14629
14630
14631 /* BesMarker2D */
14632static void G__setup_memvarBesMarker2D(void) {
14633 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
14634 { BesMarker2D *p; p=(BesMarker2D*)0x1000; if (p) { }
14635 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TString),-1,-1,4,"fName=",0,"name of line");
14636 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TString),-1,-1,4,"fTitle=",0,"title of line");
14637 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCX=",0,"marker x pos in world coordinaten");
14638 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCY=",0,"marker y pos in world coordinaten");
14639 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCZ=",0,"marker z pos in world coordinaten");
14640 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSizeMultiple=",0,"marker size mulitple * TView->GetMarkerSize ");
14641 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14642 }
14643 G__tag_memvar_reset();
14644}
14645
14646
14647 /* BesPaveText */
14648static void G__setup_memvarBesPaveText(void) {
14649 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
14650 { BesPaveText *p; p=(BesPaveText*)0x1000; if (p) { }
14651 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTextSize=",0,(char*)NULL);
14652 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fdxNDC=",0,(char*)NULL);
14653 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fdyNDC=",0,(char*)NULL);
14654 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14655 }
14656 G__tag_memvar_reset();
14657}
14658
14659
14660 /* BesGeoTrack */
14661static void G__setup_memvarBesGeoTrack(void) {
14662 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
14663 { BesGeoTrack *p; p=(BesGeoTrack*)0x1000; if (p) { }
14664 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fHits=",0,(char*)NULL);
14665 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"f3DHits=",0,"Long Peixun's update: for 3D track display");
14666 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14667 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCharge=",0,(char*)NULL);
14668 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fType=",0,"1: Mdc, 2: Tof, 3: Emc, 4: Muc, 5: Ext");
14669 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14670 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPolyLine3D),-1,-1,4,"fPolyLine3D=",0,(char*)NULL);
14671 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),-1,-1,4,"fMarker=",0,(char*)NULL);
14672 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14673 }
14674 G__tag_memvar_reset();
14675}
14676
14677
14678 /* BesEvent */
14679static void G__setup_memvarBesEvent(void) {
14680 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
14681 { BesEvent *p; p=(BesEvent*)0x1000; if (p) { }
14682 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_Magnetic=",0,(char*)NULL);
14683 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader),-1,-1,4,"fEventHeader=",0,"Event header");
14684 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TDigiEvent),-1,-1,4,"fDigiEvent=",0,(char*)NULL);
14685 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TEvtHeader),-1,-1,4,"fEvtHeader=",0,(char*)NULL);
14686 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TTrigEvent),-1,-1,4,"fTrigEvent=",0,(char*)NULL);
14687 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecEvTime),-1,-1,4,"fRecEvTime=",0,(char*)NULL);
14688 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fMdcTrackCol=",0,(char*)NULL);
14689 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fTofTrackCol=",0,(char*)NULL);
14690 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fEmcTrackCol=",0,(char*)NULL);
14691 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fMucTrackCol=",0,(char*)NULL);
14692 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fExtTrackCol=",0,(char*)NULL);
14693 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14694 }
14695 G__tag_memvar_reset();
14696}
14697
14698
14699 /* SubDetectorROOTGeo */
14700static void G__setup_memvarSubDetectorROOTGeo(void) {
14701 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
14702 { SubDetectorROOTGeo *p; p=(SubDetectorROOTGeo*)0x1000; if (p) { }
14703 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14704 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SAXProcessor),-1,-1,4,"m_sxp=",0,(char*)NULL);
14705 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ProcessingConfigurator),-1,-1,4,"m_config=",0,(char*)NULL);
14706 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_ROOTGeoInit=",0,(char*)NULL);
14707 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_childNo=",0,"child no of this subdetector in bes. ");
14708 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_2DGeoInit=",0,(char*)NULL);
14709 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,2,"m_TopVolume=",0,(char*)NULL);
14710 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_DetectorsArray=",0,(char*)NULL);
14711 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_HitsArray=",0,(char*)NULL);
14712 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_2DHitsArray=",0,(char*)NULL);
14713 }
14714 G__tag_memvar_reset();
14715}
14716
14717
14718 /* BesPolygon2D */
14719static void G__setup_memvarBesPolygon2D(void) {
14720 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
14721 { BesPolygon2D *p; p=(BesPolygon2D*)0x1000; if (p) { }
14722 G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"num=",0,(char*)NULL);
14723 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"f_xx=",0,(char*)NULL);
14724 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"f_yy=",0,(char*)NULL);
14725 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"No. of points");
14726 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fP=",0,"[3*fN] Points in world coordinates");
14727 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPBackUp=",0,"[3*fN] for fP BackUp when rotate;");
14728 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCenter[3]=",0,(char*)NULL);
14729 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRotatable=",0,(char*)NULL);
14730 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),-1,-1,2,"fInfoBox=",0,"! info box");
14731 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14732 }
14733 G__tag_memvar_reset();
14734}
14735
14736
14737 /* Mdc2DWire */
14738static void G__setup_memvarMdc2DWire(void) {
14739 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
14740 { Mdc2DWire *p; p=(Mdc2DWire*)0x1000; if (p) { }
14741 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWireType=",0,"1: Axial wire 2: Stereo wire");
14742 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fTube=",0,(char*)NULL);
14743 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"fWireCircle=",0,(char*)NULL);
14744 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fWireCone=",0,(char*)NULL);
14745 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),-1,-1,4,"fZRPosMarker2D=",0,(char*)NULL);
14746 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWestHole[3]=",0,(char*)NULL);
14747 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEastHole[3]=",0,(char*)NULL);
14748 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWestPhi=",0,(char*)NULL);
14749 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEastPhi=",0,(char*)NULL);
14750 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionPos[3]=",0,(char*)NULL);
14751 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fZRSectionFlag=",0,(char*)NULL);
14752 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14753 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14754 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHighlighted=",0,(char*)NULL);
14755 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFired=",0,(char*)NULL);
14756 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fColorfulWire=",0,(char*)NULL);
14757 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"qOverflow=",0,(char*)NULL);
14758 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcTube=",0,(char*)NULL);
14759 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwTube=",0,(char*)NULL);
14760 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcTube=",0,(char*)NULL);
14761 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsTube=",0,(char*)NULL);
14762 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWire=",0,(char*)NULL);
14763 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircle=",0,(char*)NULL);
14764 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCone=",0,(char*)NULL);
14765 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircle=",0,(char*)NULL);
14766 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCone=",0,(char*)NULL);
14767 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircle=",0,(char*)NULL);
14768 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCone=",0,(char*)NULL);
14769 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWireFired=",0,(char*)NULL);
14770 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircleFired=",0,(char*)NULL);
14771 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwConeFired=",0,(char*)NULL);
14772 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircleFired=",0,(char*)NULL);
14773 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcConeFired=",0,(char*)NULL);
14774 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircleFired=",0,(char*)NULL);
14775 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsConeFired=",0,(char*)NULL);
14776 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWireHL=",0,(char*)NULL);
14777 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircleHL=",0,(char*)NULL);
14778 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwConeHL=",0,(char*)NULL);
14779 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircleHL=",0,(char*)NULL);
14780 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcConeHL=",0,(char*)NULL);
14781 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircleHL=",0,(char*)NULL);
14782 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsConeHL=",0,(char*)NULL);
14783 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sizeMarker=",0,(char*)NULL);
14784 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarker=",0,(char*)NULL);
14785 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarkerFired=",0,(char*)NULL);
14786 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarkerHL=",0,(char*)NULL);
14787 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarker=",0,(char*)NULL);
14788 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarkerFired=",0,(char*)NULL);
14789 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarkerHL=",0,(char*)NULL);
14790 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"mdcTime=",0,(char*)NULL);
14791 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"mdcCharge=",0,(char*)NULL);
14792 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"evTime=",0,(char*)NULL);
14793 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"timeChannel=",0,(char*)NULL);
14794 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"chargeChannel=",0,(char*)NULL);
14795 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14796 }
14797 G__tag_memvar_reset();
14798}
14799
14800
14801 /* MdcROOTGeo */
14802static void G__setup_memvarMdcROOTGeo(void) {
14803 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
14804 { MdcROOTGeo *p; p=(MdcROOTGeo*)0x1000; if (p) { }
14805 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegment=66LL",0,(char*)NULL);
14806 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStereoLayerIn=8LL",0,(char*)NULL);
14807 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAxialLayerIn=12LL",0,(char*)NULL);
14808 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStereoLayerOut=16LL",0,(char*)NULL);
14809 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAxialLayerOut=7LL",0,(char*)NULL);
14810 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayer=50LL",0,(char*)NULL);
14811 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kTrueLayer=43LL",0,"m_kLayer-m_kAxialLayerOut");
14812 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kReplicaMax=288LL",0,(char*)NULL);
14813 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kReplica[50]=",0,(char*)NULL);
14814 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kStereoDir[43]=",0,(char*)NULL);
14815 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kCorrectLayer=10LL",0,(char*)NULL);
14816 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kiCorrectLayer[10]=",0,(char*)NULL);
14817 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kiCorrectReplica[10]=",0,(char*)NULL);
14818 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegmentNodeOffset=891LL",0,(char*)NULL);
14819 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegmentBr=2LL",0,"Segment 1 or 2 is special");
14820 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_TFire=",0,(char*)NULL);
14821 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QFire=",0,(char*)NULL);
14822 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QNotOverflow=",0,(char*)NULL);
14823 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_ColorfulWire=",0,(char*)NULL);
14824 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_MdcTimeSubEvTime=",0,(char*)NULL);
14825 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_StartLayer=",0,"0 - No CGEM; 8 - Contains CGEM");
14826 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"MDC_TIME_FACTOR=100000LL",0,(char*)NULL);
14827 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"MDC_CHARGE_FACTOR=1000000LL",0,(char*)NULL);
14828 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_MdcColor=",0,(char*)NULL);
14829 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_segmentColor=",0,(char*)NULL);
14830 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_hypeColor=",0,(char*)NULL);
14831 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_tubeColor=",0,(char*)NULL);
14832 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_twistedTubsColor=",0,(char*)NULL);
14833 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_replicaColor=",0,(char*)NULL);
14834 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("map<int,int>"),-1,4,"m_CorrectMap=",0,(char*)NULL);
14835 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Mdc=",0,(char*)NULL);
14836 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeLayer[50]=",0,(char*)NULL);
14837 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeReplica[50][288]=",0,(char*)NULL);
14838 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalSegment[132]=",0,(char*)NULL);
14839 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalReplica[50][288]=",0,(char*)NULL);
14840 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_MdcDigiCol=",0,(char*)NULL);
14841 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_MdcXY=",0,(char*)NULL);
14842 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_MdcXYSuper[4]=",0,(char*)NULL);
14843 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),-1,-1,4,"m_Mdc2DWire[43][288]=",0,(char*)NULL);
14844 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MdcZR[2]=",0,(char*)NULL);
14845 }
14846 G__tag_memvar_reset();
14847}
14848
14849
14850 /* Tof2DScin */
14851static void G__setup_memvarTof2DScin(void) {
14852 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
14853 { Tof2DScin *p; p=(Tof2DScin*)0x1000; if (p) { }
14854 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
14855 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinXY=",0,(char*)NULL);
14856 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinZR=",0,(char*)NULL);
14857 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinXYFired=",0,(char*)NULL);
14858 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinZRFired=",0,(char*)NULL);
14859 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fChargeMax=50LL",0,(char*)NULL);
14860 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTime=",0,(char*)NULL);
14861 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCharge=",0,(char*)NULL);
14862 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionTolerance[3]=",0,"to avoid on zrSection nothing drawn sometimes");
14863 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMin=",0,(char*)NULL);
14864 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMax=",0,(char*)NULL);
14865 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14866 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14867 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
14868 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
14869 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScin=",0,(char*)NULL);
14870 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScin=",0,(char*)NULL);
14871 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScin=",0,(char*)NULL);
14872 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScin=",0,(char*)NULL);
14873 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinFired=",0,(char*)NULL);
14874 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinFired=",0,(char*)NULL);
14875 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinFired=",0,(char*)NULL);
14876 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinFired=",0,(char*)NULL);
14877 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinHL=",0,(char*)NULL);
14878 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinHL=",0,(char*)NULL);
14879 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinHL=",0,(char*)NULL);
14880 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinHL=",0,(char*)NULL);
14881 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinFiredHL=",0,(char*)NULL);
14882 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinFiredHL=",0,(char*)NULL);
14883 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinFiredHL=",0,(char*)NULL);
14884 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinFiredHL=",0,(char*)NULL);
14885 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"timeChannel=",0,(char*)NULL);
14886 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"chargeChannel=",0,(char*)NULL);
14887 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14888 }
14889 G__tag_memvar_reset();
14890}
14891
14892
14893 /* TofROOTGeo */
14894static void G__setup_memvarTofROOTGeo(void) {
14895 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
14896 { TofROOTGeo *p; p=(TofROOTGeo*)0x1000; if (p) { }
14897 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
14898 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayerBr=2LL",0,(char*)NULL);
14899 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayerEc=1LL",0,(char*)NULL);
14900 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kScinBr=88LL",0,(char*)NULL);
14901 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kScinEc=48LL",0,(char*)NULL);
14902 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBucketEc=1LL",0,(char*)NULL);
14903 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBucketBr=2LL",0,(char*)NULL);
14904 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kModuleEc=36LL",0,"Huang Shuhui's update: For Mrpc");
14905 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStripEc=12LL",0,"Huang Shuhui's update: For Mrpc");
14906 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kChamberNodeNb=6LL",0,"Huang Shuhui's update: For Mrpc Geometry Initialization");
14907 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kContainerNodeNb=0LL",0,"Huang Shuhui's update: For Mrpc Geometry Initialization");
14908 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBoard1NodeNb=30LL",0,"Huang Shuhui's update: For Mrpc Geometry Initialization");
14909 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"TOF_TIME_FACTOR=1000000LL",0,(char*)NULL);
14910 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"TOF_CHARGE_FACTOR=1000000LL",0,(char*)NULL);
14911 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_TMatch=",0,(char*)NULL);
14912 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QMatch=",0,(char*)NULL);
14913 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_TofColor=",0,(char*)NULL);
14914 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_BucketColor=",0,(char*)NULL);
14915 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_ScinColor=",0,(char*)NULL);
14916 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Tof=",0,(char*)NULL);
14917 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePVF[3][2][88]=",0,(char*)NULL);
14918 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAl[3][2]=",0,(char*)NULL);
14919 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeScin[3][2]=",0,(char*)NULL);
14920 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalScin[3][36][88]=",0,"Huang Shuhui's update: m_kLayerBr -> m_kModuleEc");
14921 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeModule[3][36]=",0,(char*)NULL);
14922 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodegasContainer[3][36]=",0,(char*)NULL);
14923 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodebareChamber[3][36]=",0,(char*)NULL);
14924 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodepcbBoard1[3][36]=",0,(char*)NULL);
14925 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeStrip[3][36][12]=",0,(char*)NULL);
14926 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_TofDigiCol=",0,(char*)NULL);
14927 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTofMrpc=",0,(char*)NULL);
14928 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),-1,-1,4,"m_Tof2DScin[3][36][88]=",0,"Huang Shuhui's update: m_kLayerBr -> m_kModuleEc");
14929 }
14930 G__tag_memvar_reset();
14931}
14932
14933
14934 /* Emc2DCrystal */
14935static void G__setup_memvarEmc2DCrystal(void) {
14936 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
14937 { Emc2DCrystal *p; p=(Emc2DCrystal*)0x1000; if (p) { }
14938 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
14939 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTheta=",0,(char*)NULL);
14940 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalXY=",0,(char*)NULL);
14941 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalZR=",0,(char*)NULL);
14942 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalSide=",0,(char*)NULL);
14943 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalXYFired=",0,(char*)NULL);
14944 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalZRFired=",0,(char*)NULL);
14945 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalSideFired=",0,(char*)NULL);
14946 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fChargeMax=300LL",0,(char*)NULL);
14947 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTime=",0,(char*)NULL);
14948 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCharge=",0,(char*)NULL);
14949 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionTolerance[3]=",0,"to avoid on zrSection nothing drawn sometimes");
14950 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMin=",0,(char*)NULL);
14951 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMax=",0,(char*)NULL);
14952 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"ecXYPointZ=1420LL",0,"theta0:1407.71, theta5:1416.8");
14953 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"brZRPointR=990LL",0,"these two doule define the tube of emc, R=brZRPointR, Z=+-ecXYPointZ;");
14954 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"sideDeltaPhi=21LL",0,"deg, side emc viewPhi +- sideDeltaPhi range ");
14955 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14956 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14957 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
14958 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
14959 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystal=",0,"line color");
14960 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystal=",0,"line width");
14961 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystal=",0,"fill color");
14962 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystal=",0,"fill style");
14963 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalTrans=",0,(char*)NULL);
14964 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalFired=",0,(char*)NULL);
14965 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalFired=",0,(char*)NULL);
14966 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalFired=",0,(char*)NULL);
14967 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalFired=",0,(char*)NULL);
14968 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalHL=",0,(char*)NULL);
14969 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalHL=",0,(char*)NULL);
14970 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalHL=",0,(char*)NULL);
14971 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalHL=",0,(char*)NULL);
14972 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalFiredHL=",0,(char*)NULL);
14973 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalFiredHL=",0,(char*)NULL);
14974 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalFiredHL=",0,(char*)NULL);
14975 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalFiredHL=",0,(char*)NULL);
14976 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14977 }
14978 G__tag_memvar_reset();
14979}
14980
14981
14982 /* EmcROOTGeo */
14983static void G__setup_memvarEmcROOTGeo(void) {
14984 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
14985 { EmcROOTGeo *p; p=(EmcROOTGeo*)0x1000; if (p) { }
14986 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
14987 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPhiBr=120LL",0,(char*)NULL);
14988 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kThetaBr=44LL",0,(char*)NULL);
14989 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kPhiEc=",0,(char*)NULL);
14990 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kThetaEc=",0,(char*)NULL);
14991 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kSectorEc=",0,(char*)NULL);
14992 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kNbEc=",0,(char*)NULL);
14993 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kRealNbEc=",0,(char*)NULL);
14994 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_EmcColor=",0,(char*)NULL);
14995 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_partColor=",0,(char*)NULL);
14996 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_phiColor=",0,(char*)NULL);
14997 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_thetaColor=",0,(char*)NULL);
14998 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_brCrystalColor=",0,(char*)NULL);
14999 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_ecCrystalColor=",0,(char*)NULL);
15000 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"EMC_TIME_FACTOR=1LL",0,(char*)NULL);
15001 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"EMC_CHARGE_FACTOR=1000LL",0,(char*)NULL);
15002 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Emc=",0,(char*)NULL);
15003 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePart[3]=",0,(char*)NULL);
15004 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePhi[3][120]=",0,(char*)NULL);
15005 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeTheta[3][120][44]=",0,"m_kPhiBr > m_kPhiEc, m_kThetaBr > m_kThetaEc");
15006 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeTheta2[3][120][44]=",0,"contains theta phi has tow nodes ");
15007 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalCrystal[3][120][44]=",0,(char*)NULL);
15008 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalCrystal2[3][120][44]=",0,(char*)NULL);
15009 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_PhyNodeOrgArray=",0,(char*)NULL);
15010 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_EmcDigiCol=",0,(char*)NULL);
15011 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),-1,-1,4,"m_Emc2DCrystal[3][120][44]=",0,(char*)NULL);
15012 }
15013 G__tag_memvar_reset();
15014}
15015
15016
15017 /* Muc2DStrip */
15018static void G__setup_memvarMuc2DStrip(void) {
15019 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
15020 { Muc2DStrip *p; p=(Muc2DStrip*)0x1000; if (p) { }
15021 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
15022 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSeg=",0,(char*)NULL);
15023 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGap=",0,(char*)NULL);
15024 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrip=",0,(char*)NULL);
15025 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fStripXY=",0,(char*)NULL);
15026 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fStripZR=",0,(char*)NULL);
15027 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
15028 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
15029 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
15030 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
15031 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStrip=",0,"line color");
15032 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStrip=",0,"line width");
15033 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStrip=",0,"line width");
15034 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStrip=",0,"fill color");
15035 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStrip=",0,"fill style");
15036 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStripFired=",0,(char*)NULL);
15037 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStripFired=",0,(char*)NULL);
15038 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStripFired=",0,(char*)NULL);
15039 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStripFired=",0,(char*)NULL);
15040 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStripFired=",0,(char*)NULL);
15041 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStripHL=",0,(char*)NULL);
15042 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStripHL=",0,(char*)NULL);
15043 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStripHL=",0,(char*)NULL);
15044 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStripHL=",0,(char*)NULL);
15045 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStripHL=",0,(char*)NULL);
15046 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"m_kDrawLineRange=2000LL",0,"if view x range > 2000, a barrel strip is very small, so dont draw edge lines ");
15047 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15048 }
15049 G__tag_memvar_reset();
15050}
15051
15052
15053 /* MucROOTGeo */
15054static void G__setup_memvarMucROOTGeo(void) {
15055 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
15056 { MucROOTGeo *p; p=(MucROOTGeo*)0x1000; if (p) { }
15057 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
15058 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegMax=8LL",0,(char*)NULL);
15059 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAbsorberMax=9LL",0,(char*)NULL);
15060 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kGapMax=9LL",0,(char*)NULL);
15061 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPanelMax=4LL",0,(char*)NULL);
15062 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStripMax=112LL",0,(char*)NULL);
15063 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBakelite=2LL",0,(char*)NULL);
15064 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kGasChamber=1LL",0,(char*)NULL);
15065 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSmallBlockMax=2LL",0,(char*)NULL);
15066 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kUpDown=2LL",0,(char*)NULL);
15067 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kSeg[3]=",0,(char*)NULL);
15068 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kAbsorber[3]=",0,(char*)NULL);
15069 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kGap[3]=",0,(char*)NULL);
15070 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kPanel[3]=",0,(char*)NULL);
15071 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kBakelitePanel[3][2]=",0,(char*)NULL);
15072 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_StripNum[3][8][9]=",0,(char*)NULL);
15073 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_MucColor=",0,(char*)NULL);
15074 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_absorberColor=",0,(char*)NULL);
15075 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_gapColor=",0,(char*)NULL);
15076 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_gasChamberColor=",0,(char*)NULL);
15077 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_bakeliteColor=",0,(char*)NULL);
15078 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_stripColor=",0,(char*)NULL);
15079 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"m_kStripZMuliple=12LL",0,"as dz is very thin, multiply so that it can be seen.");
15080 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Muc=",0,(char*)NULL);
15081 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAbsorber[3][8][9]=",0,(char*)NULL);
15082 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAbsorberPanel[3][8][9][4]=",0,(char*)NULL);
15083 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeGap[3][8][9]=",0,(char*)NULL);
15084 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeStripPlane[3][8][9]=",0,(char*)NULL);
15085 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeStrip[3][8][9][112]=",0,(char*)NULL);
15086 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalAbsorber[3][8][9][4]=",0,(char*)NULL);
15087 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalGap[3][8][9]=",0,(char*)NULL);
15088 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalStrip[3][8][9][112]=",0,(char*)NULL);
15089 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_MucDigiCol=",0,(char*)NULL);
15090 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucXY[3][8]=",0,(char*)NULL);
15091 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucZR[3][8]=",0,(char*)NULL);
15092 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucXYGap[3][8][9]=",0,(char*)NULL);
15093 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucZRGap[3][8][9]=",0,(char*)NULL);
15094 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),-1,-1,4,"m_Muc2DStrip[3][8][9][112]=",0,(char*)NULL);
15095 }
15096 G__tag_memvar_reset();
15097}
15098
15099
15100 /* BesGeometry */
15101static void G__setup_memvarBesGeometry(void) {
15102 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
15103 { BesGeometry *p; p=(BesGeometry*)0x1000; if (p) { }
15104 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BesR=",0,(char*)NULL);
15105 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BesZ=",0,(char*)NULL);
15106 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeRMin=",0,(char*)NULL);
15107 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeRMax=",0,(char*)NULL);
15108 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeZ=",0,(char*)NULL);
15109 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Bes=",0,"Bes world volume");
15110 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_BeamPipe=",0,"Beam Pipe volume");
15111 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Mdc=",0,(char*)NULL);
15112 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Tof=",0,(char*)NULL);
15113 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Emc=",0,(char*)NULL);
15114 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Muc=",0,(char*)NULL);
15115 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_phyBeamPipe=",0,"Long Peixun's update: for BeamPipe full 3D view");
15116 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),-1,-1,4,"m_MdcROOTGeo=",0,"MdcROOTGeo");
15117 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),-1,-1,4,"m_TofROOTGeo=",0,"TofROOTGeo");
15118 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),-1,-1,4,"m_EmcROOTGeo=",0,"EmcROOTGeo");
15119 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),-1,-1,4,"m_MucROOTGeo=",0,"MucROOTGeo");
15120 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_BeamPipeXY=",0,(char*)NULL);
15121 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_BeamPipeZR=",0,(char*)NULL);
15122 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_ZRPlaneOnXY=",0,(char*)NULL);
15123 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_BeamPipeColor=",0,"Long Peixun's update: color of beampipe");
15124 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15125 }
15126 G__tag_memvar_reset();
15127}
15128
15129
15130 /* BesGMenuTitle */
15131static void G__setup_memvarBesGMenuTitle(void) {
15132 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
15133 { BesGMenuTitle *p; p=(BesGMenuTitle*)0x1000; if (p) { }
15134 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPic=",0,"picture shown");
15135 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPicHL=",0,"picture when selected");
15136 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15137 }
15138 G__tag_memvar_reset();
15139}
15140
15141
15142 /* BesGMenuBar */
15143static void G__setup_memvarBesGMenuBar(void) {
15144 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
15145 { BesGMenuBar *p; p=(BesGMenuBar*)0x1000; if (p) { }
15146 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15147 }
15148 G__tag_memvar_reset();
15149}
15150
15151
15152 /* BesGPictureButton */
15153static void G__setup_memvarBesGPictureButton(void) {
15154 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
15155 { BesGPictureButton *p; p=(BesGPictureButton*)0x1000; if (p) { }
15156 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGPicture),-1,-1,2,"fPicHL=",0,"picture shown when button selected");
15157 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fState=",0,(char*)NULL);
15158 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15159 }
15160 G__tag_memvar_reset();
15161}
15162
15163
15164 /* BesHeader */
15165static void G__setup_memvarBesHeader(void) {
15166 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
15167 { BesHeader *p; p=(BesHeader*)0x1000; if (p) { }
15168 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMdcOn=",0,"show Mdc information on ?");
15169 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTofOn=",0,"show Tof information on ?");
15170 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEmcOn=",0,"show Emc information on ?");
15171 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15172 }
15173 G__tag_memvar_reset();
15174}
15175
15176
15177 /* BesVisDisplay */
15178static void G__setup_memvarBesVisDisplay(void) {
15179 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
15180 { BesVisDisplay *p; p=(BesVisDisplay*)0x1000; if (p) { }
15181 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDisplayMode=",0,"Flag for display mode, 0: 2D XY+ZR, 1: 2D XY, 2: 2D ZR, 3: 3D, 4: 2D+3D");
15182 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadHeader=",0,(char*)NULL);
15183 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadXY=",0,(char*)NULL);
15184 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadZR=",0,(char*)NULL);
15185 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPad3D=",0,(char*)NULL);
15186 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),-1,-1,4,"fBesHeader=",0,(char*)NULL);
15187 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderImage=",0,(char*)NULL);
15188 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderHImage=",0,(char*)NULL);
15189 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderVImage=",0,(char*)NULL);
15190 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLatticeWidth=",0,"Lattice Width");
15191 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeTitle=",0,"Text Size: Title");
15192 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeTime=",0,"Text Size: Time");
15193 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeData=",0,"Text Size: Data");
15194 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeFlt=",0,"Text Size: FLT");
15195 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoordx=",0,"x coordinate of text");
15196 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoordy=",0,"y coordinate of text");
15197 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistanceOfRows=",0,"Distance between rows");
15198 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMdcOn=",0,(char*)NULL);
15199 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTofOn=",0,(char*)NULL);
15200 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEmcOn=",0,(char*)NULL);
15201 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry),-1,-1,4,"fBesGeometry=",0,(char*)NULL);
15202 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawAllViews=",0,"Flag True if AllViews selected");
15203 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawParticles=",0,"Flag True if particles to be drawn");
15204 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawParticles2=",0,(char*)NULL);
15205 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVisHeader=",0,"Long Peixun's update: visibility flag");
15206 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawClusters=",0,"Flag True if clusters to be drawn");
15207 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPTcut=",0,"PT cut to display objects");
15208 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPTcutEGMUNU=",0,"PT cut for Electrons, Gammas, MUons, Neutrinos");
15209 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRin=",0,"Inner ATLAS radius");
15210 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRout=",0,"Outer ATLAS radius");
15211 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZin=",0,"Inner ATLAS length along Z");
15212 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZout=",0,"Outer ATLAS length along Z");
15213 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTheta=",0,"Viewing angle theta");
15214 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhi=",0,"Viewing angle phi");
15215 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBesR=",0,"BesR");
15216 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBesZ=",0,"BesZ");
15217 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TCanvas),-1,-1,4,"fCanvas=",0,"Pointer to the display canvas");
15218 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fTrigPad=",0,"Pointer to the trigger pad ");
15219 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fButtons=",0,"Pointer to the buttons pad");
15220 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPad=",0,"Pointer to the event display main pad");
15221 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEM1=",0,"Pointer to arc showing ON/OFF trigger EM1");
15222 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fPH1=",0,"Pointer to arc showing ON/OFF trigger PH1");
15223 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEM2=",0,"Pointer to arc showing ON/OFF trigger EM2");
15224 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fMU1=",0,"Pointer to arc showing ON/OFF trigger MU1");
15225 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fMU2=",0,"Pointer to arc showing ON/OFF trigger MU2");
15226 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEMU=",0,"Pointer to arc showing ON/OFF trigger EMU");
15227 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT1=",0,"Pointer to arc showing ON/OFF trigger JT1");
15228 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT3=",0,"Pointer to arc showing ON/OFF trigger JT3");
15229 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT4=",0,"Pointer to arc showing ON/OFF trigger JT4");
15230 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fALL=",0,"Pointer to arc showing ON/OFF trigger ALL");
15231 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"fBes=",0,"Bes world volume");
15232 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRayPicCount=",0,"Counter of picture");
15233 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),-1,-1,4,"fMdcROOTGeo=",0,"MdcROOTGeo");
15234 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),-1,-1,4,"fTofROOTGeo=",0,"TofROOTGeo");
15235 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),-1,-1,4,"fEmcROOTGeo=",0,"EmcROOTGeo");
15236 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),-1,-1,4,"fMucROOTGeo=",0,"MucROOTGeo");
15237 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMdcCon=",0,"Mdc Construction flag");
15238 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTofCon=",0,"Tof Construction flag");
15239 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEmcCon=",0,"Emc Construction flag");
15240 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMucCon=",0,"Muc Construction flag");
15241 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAllVis=",0,"All node visible flag");
15242 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fQuarterVis=",0,"Quarter visible flag");
15243 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHalfVis=",0,"Half visible flag");
15244 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNoEndVis=",0,"NoEnd visible flag");
15245 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"fxyView=",0,"XY View pointer;");
15246 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"fzrView=",0,"ZR View pointer;");
15247 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"f3DView=",0,"3D View pointer;");
15248 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15249 }
15250 G__tag_memvar_reset();
15251}
15252
15253
15254 /* ZHelix */
15255static void G__setup_memvarZHelix(void) {
15256 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
15257 { ZHelix *p; p=(ZHelix*)0x1000; if (p) { }
15258 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TrackType),-1,-1,2,"fTrackType=",0,"Type of track");
15259 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAzim=",0,"Azimuth");
15260 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fQovR=",0,"Q/R");
15261 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fQxDh=",0,"Q*D_h");
15262 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTDip=",0,"tan(Dip)");
15263 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefX=",0,"Helix reference point x coordinate");
15264 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefY=",0,"Helix reference point y coordinate");
15265 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefZ=",0,"Helix reference point z coordinate");
15266 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRange[2]=",0,"Range of helix (in phi)");
15267 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EZHelixRangeType),-1,-1,2,"fRType=",0,"Helix range type");
15268 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fChi2=",0,"Chi2 of the fit");
15269 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDoF=",0,"Degrees of freedom");
15270 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinAzim=",0,"Sin(Azimuth)");
15271 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosAzim=",0,"Cos(Azimuth)");
15272 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRSign=",0,"! sign of radius");
15273 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiI=",0,"phi inner");
15274 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiO=",0,"phi outer");
15275 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnable=",0,"enable of drawing of helix, could be set false for bad tracks");
15276 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
15277 }
15278 G__tag_memvar_reset();
15279}
15280
15281
15282 /* vector3 */
15283static void G__setup_memvarvector3(void) {
15284 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
15285 { vector3 *p; p=(vector3*)0x1000; if (p) { }
15286 G__memvar_setup((void*)((long)(&p->x)-(long)(p)),102,0,0,-1,-1,-1,1,"x=",0,(char*)NULL);
15287 G__memvar_setup((void*)((long)(&p->y)-(long)(p)),102,0,0,-1,-1,-1,1,"y=",0,(char*)NULL);
15288 G__memvar_setup((void*)((long)(&p->z)-(long)(p)),102,0,0,-1,-1,-1,1,"z=",0,(char*)NULL);
15289 }
15290 G__tag_memvar_reset();
15291}
15292
15293extern "C" void G__cpp_setup_memvarBesVisLib_rootcint() {
15294}
15295/***********************************************************
15296************************************************************
15297************************************************************
15298************************************************************
15299************************************************************
15300************************************************************
15301************************************************************
15302***********************************************************/
15303
15304/*********************************************************
15305* Member function information setup for each class
15306*********************************************************/
15307static void G__setup_memfuncBesStatus(void) {
15308 /* BesStatus */
15309 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
15310 G__memfunc_setup("BesStatus",926,G__BesVisLib_rootcint_169_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15311 G__memfunc_setup("Transfer",837,G__BesVisLib_rootcint_169_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15312"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15313 G__memfunc_setup("TransferGeometryCgem",2061,G__BesVisLib_rootcint_169_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
15314"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", "Long Peixun's update: for CGEM", (void*) NULL, 0);
15315 G__memfunc_setup("TransferGeometryMdc",1957,G__BesVisLib_rootcint_169_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
15316"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15317 G__memfunc_setup("TransferGeometryTof",1978,G__BesVisLib_rootcint_169_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
15318"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15319 G__memfunc_setup("TransferGeometryEmc",1958,G__BesVisLib_rootcint_169_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
15320"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15321 G__memfunc_setup("TransferGeometryMuc",1974,G__BesVisLib_rootcint_169_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
15322"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15323 G__memfunc_setup("TransferGeometryFull3D",2203,G__BesVisLib_rootcint_169_0_8, 121, -1, -1, 0, 2, 1, 1, 0,
15324"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15325 G__memfunc_setup("TransferGeometryOtherParts",2717,G__BesVisLib_rootcint_169_0_9, 121, -1, -1, 0, 2, 1, 1, 0,
15326"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15327 G__memfunc_setup("TransferHitsCgem",1625,G__BesVisLib_rootcint_169_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
15328"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", "Long Peixun's update: for CGEM", (void*) NULL, 0);
15329 G__memfunc_setup("TransferHitsMdc",1521,G__BesVisLib_rootcint_169_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
15330"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15331 G__memfunc_setup("TransferHitsTof",1542,G__BesVisLib_rootcint_169_0_12, 121, -1, -1, 0, 2, 1, 1, 0,
15332"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15333 G__memfunc_setup("TransferHitsEmc",1522,G__BesVisLib_rootcint_169_0_13, 121, -1, -1, 0, 2, 1, 1, 0,
15334"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15335 G__memfunc_setup("TransferHitsMuc",1538,G__BesVisLib_rootcint_169_0_14, 121, -1, -1, 0, 2, 1, 1, 0,
15336"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15337 G__memfunc_setup("TransferTracks",1453,G__BesVisLib_rootcint_169_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
15338"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15339 G__memfunc_setup("TransferFishEye",1522,G__BesVisLib_rootcint_169_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
15340"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15341 G__memfunc_setup("TransferPhiRange",1619,G__BesVisLib_rootcint_169_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
15342"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15343 G__memfunc_setup("TransferZoom",1258,G__BesVisLib_rootcint_169_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
15344"U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
15345 G__memfunc_setup("Default",709,G__BesVisLib_rootcint_169_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EBESViewType' - 0 - type", (char*)NULL, (void*) NULL, 0);
15346 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_169_0_20, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesStatus::Class) ), 0);
15347 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_169_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::Class_Name) ), 0);
15348 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_169_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesStatus::Class_Version) ), 0);
15349 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_169_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesStatus::Dictionary) ), 0);
15350 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15351 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15352 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15353 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_169_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15354 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_169_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::DeclFileName) ), 0);
15355 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_169_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesStatus::ImplFileLine) ), 0);
15356 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_169_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::ImplFileName) ), 0);
15357 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_169_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesStatus::DeclFileLine) ), 0);
15358 // automatic copy constructor
15359 G__memfunc_setup("BesStatus", 926, G__BesVisLib_rootcint_169_0_32, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 1, 1, 1, 0, "u 'BesStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
15360 // automatic destructor
15361 G__memfunc_setup("~BesStatus", 1052, G__BesVisLib_rootcint_169_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15362 // automatic assignment operator
15363 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_169_0_34, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 1, 1, 1, 1, 0, "u 'BesStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
15364 G__tag_memfunc_reset();
15365}
15366
15367static void G__setup_memfuncBesTView(void) {
15368 /* BesTView */
15369 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
15370 G__memfunc_setup("BesTView",777,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 1, 1, 2, 0, "u 'BesTView' - 11 - -", "Not implemented", (void*) NULL, 0);
15371 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 1, 1, 1, 2, 0, "u 'BesTView' - 11 - -", "Not implemented", (void*) NULL, 0);
15372 G__memfunc_setup("ResetView",926,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0,
15373"d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
15374"d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 0);
15375 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_4, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15376 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_5, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - system", (char*)NULL, (void*) NULL, 0);
15377 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_6, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 3, 1, 1, 0,
15378"F - 'Float_t' 10 - rmin F - 'Float_t' 10 - rmax "
15379"i - 'Int_t' 0 '1' system", (char*)NULL, (void*) NULL, 0);
15380 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_7, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 3, 1, 1, 0,
15381"D - 'Double_t' 10 - rmin D - 'Double_t' 10 - rmax "
15382"i - 'Int_t' 0 '1' system", (char*)NULL, (void*) NULL, 0);
15383 G__memfunc_setup("AxisVertex",1043,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
15384"d - 'Double_t' 0 - ang D - 'Double_t' 0 - av "
15385"i - 'Int_t' 1 - ix1 i - 'Int_t' 1 - ix2 "
15386"i - 'Int_t' 1 - iy1 i - 'Int_t' 1 - iy2 "
15387"i - 'Int_t' 1 - iz1 i - 'Int_t' 1 - iz2", (char*)NULL, (void*) NULL, 1);
15388 G__memfunc_setup("DefinePerspectiveView",2160,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15389 G__memfunc_setup("DefineViewDirection",1927,(G__InterfaceMethod) NULL,121, -1, -1, 0, 10, 1, 1, 0,
15390"D - 'Double_t' 10 - s D - 'Double_t' 10 - c "
15391"d - 'Double_t' 0 - cosphi d - 'Double_t' 0 - sinphi "
15392"d - 'Double_t' 0 - costhe d - 'Double_t' 0 - sinthe "
15393"d - 'Double_t' 0 - cospsi d - 'Double_t' 0 - sinpsi "
15394"D - 'Double_t' 0 - tnorm D - 'Double_t' 0 - tback", (char*)NULL, (void*) NULL, 1);
15395 G__memfunc_setup("DrawOutlineCube",1517,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15396"U 'TList' - 0 - outline D - 'Double_t' 0 - rmin "
15397"D - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 1);
15398 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15399"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15400"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15401 G__memfunc_setup("ExecuteRotateView",1757,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15402"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15403"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15404 G__memfunc_setup("FindScope",891,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15405"D - 'Double_t' 0 - scale D - 'Double_t' 0 - center "
15406"i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
15407 G__memfunc_setup("GetDistancetoAxis",1731,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0,
15408"i - 'Int_t' 0 - axis i - 'Int_t' 0 - px "
15409"i - 'Int_t' 0 - py d - 'Double_t' 1 - ratio", (char*)NULL, (void*) NULL, 1);
15410 G__memfunc_setup("GetDview",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15411 G__memfunc_setup("GetDproj",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15412 G__memfunc_setup("GetExtent",920,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15413 G__memfunc_setup("GetAutoRange",1190,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15414 G__memfunc_setup("GetLatitude",1116,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15415 G__memfunc_setup("GetLongitude",1227,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15416 G__memfunc_setup("GetPsi",588,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15417 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15418"F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
15419 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15420"D - 'Double_t' 0 - min D - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 1);
15421 G__memfunc_setup("GetRmax",696,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15422 G__memfunc_setup("GetRmin",694,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15423 G__memfunc_setup("GetOutline",1024,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TSeqCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15424 G__memfunc_setup("GetTback",773,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15425 G__memfunc_setup("GetTN",450,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15426 G__memfunc_setup("GetTnorm",816,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15427 G__memfunc_setup("GetSystem",933,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15428 G__memfunc_setup("GetWindow",920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8,
15429"d - 'Double_t' 1 - u0 d - 'Double_t' 1 - v0 "
15430"d - 'Double_t' 1 - du d - 'Double_t' 1 - dv", (char*)NULL, (void*) NULL, 1);
15431 G__memfunc_setup("GetWindowWidth",1432,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15432 G__memfunc_setup("GetWindowHeight",1521,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15433 G__memfunc_setup("FindNormal",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15434"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15435"d - 'Double_t' 0 - z d - 'Double_t' 1 - zn", (char*)NULL, (void*) NULL, 1);
15436 G__memfunc_setup("FindPhiSectors",1413,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
15437"i - 'Int_t' 0 - iopt i - 'Int_t' 1 - kphi "
15438"D - 'Double_t' 0 - aphi i - 'Int_t' 1 - iphi1 "
15439"i - 'Int_t' 1 - iphi2", (char*)NULL, (void*) NULL, 1);
15440 G__memfunc_setup("FindThetaSectors",1626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
15441"i - 'Int_t' 0 - iopt d - 'Double_t' 0 - phi "
15442"i - 'Int_t' 1 - kth D - 'Double_t' 0 - ath "
15443"i - 'Int_t' 1 - ith1 i - 'Int_t' 1 - ith2", (char*)NULL, (void*) NULL, 1);
15444 G__memfunc_setup("IsClippedNDC",1106,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 1);
15445 G__memfunc_setup("IsPerspective",1350,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15446 G__memfunc_setup("IsViewChanged",1281,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15447 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15448"F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15449 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15450"D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15451 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15452"F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15453 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15454"D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15455 G__memfunc_setup("PadRange",770,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rback", (char*)NULL, (void*) NULL, 1);
15456 G__memfunc_setup("ResizePad",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15457 G__memfunc_setup("SetAutoRange",1202,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autorange", (char*)NULL, (void*) NULL, 1);
15458 G__memfunc_setup("SetAxisNDC",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
15459"D - 'Double_t' 10 - x1 D - 'Double_t' 10 - x2 "
15460"D - 'Double_t' 10 - y1 D - 'Double_t' 10 - y2 "
15461"D - 'Double_t' 10 - z1 D - 'Double_t' 10 - z2", (char*)NULL, (void*) NULL, 1);
15462 G__memfunc_setup("SetDefaultWindow",1641,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15463 G__memfunc_setup("SetDview",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dview", (char*)NULL, (void*) NULL, 1);
15464 G__memfunc_setup("SetDproj",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dproj", (char*)NULL, (void*) NULL, 1);
15465 G__memfunc_setup("SetLatitude",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - latitude", (char*)NULL, (void*) NULL, 1);
15466 G__memfunc_setup("SetLongitude",1239,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - longitude", (char*)NULL, (void*) NULL, 1);
15467 G__memfunc_setup("SetPsi",600,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 1);
15468 G__memfunc_setup("SetOutlineToCube",1614,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15469 G__memfunc_setup("SetParallel",1113,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15470 G__memfunc_setup("SetPerspective",1462,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15471 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15472"D - 'Double_t' 10 - min D - 'Double_t' 10 - max", (char*)NULL, (void*) NULL, 1);
15473 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0,
15474"d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
15475"d - 'Double_t' 0 - z0 d - 'Double_t' 0 - x1 "
15476"d - 'Double_t' 0 - y1 d - 'Double_t' 0 - z1 "
15477"i - 'Int_t' 0 '0' flag", (char*)NULL, (void*) NULL, 1);
15478 G__memfunc_setup("SetSystem",945,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - system", (char*)NULL, (void*) NULL, 1);
15479 G__memfunc_setup("SetView",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15480"d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
15481"d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
15482 G__memfunc_setup("SetViewChanged",1393,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
15483 G__memfunc_setup("SetWindow",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15484"d - 'Double_t' 0 - u0 d - 'Double_t' 0 - v0 "
15485"d - 'Double_t' 0 - du d - 'Double_t' 0 - dv", (char*)NULL, (void*) NULL, 1);
15486 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15487"F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15488 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15489"D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15490 G__memfunc_setup("MoveFocus",919,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
15491"D - 'Double_t' 0 - center d - 'Double_t' 0 - dx "
15492"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
15493"i - 'Int_t' 0 '10' nsteps d - 'Double_t' 0 '0' dlong "
15494"d - 'Double_t' 0 '0' dlat d - 'Double_t' 0 '0' dpsi", (char*)NULL, (void*) NULL, 1);
15495 G__memfunc_setup("MoveViewCommand",1521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15496"c - 'Char_t' 0 - chCode i - 'Int_t' 0 '1' count", (char*)NULL, (void*) NULL, 1);
15497 G__memfunc_setup("MoveWindow",1039,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - option", (char*)NULL, (void*) NULL, 1);
15498 G__memfunc_setup("AdjustPad",896,G__BesVisLib_rootcint_175_0_69, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualPad*))(&BesTView::AdjustPad) ), 0);
15499 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", "*MENU*", (void*) NULL, 1);
15500 G__memfunc_setup("Centered3DImages",1527,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15501 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15502 G__memfunc_setup("FrontView",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15503 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15504 G__memfunc_setup("ZoomIn",604,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15505 G__memfunc_setup("ZoomOut",733,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15506 G__memfunc_setup("ZoomView",832,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15507"U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' zoomFactor", (char*)NULL, (void*) NULL, 1);
15508 G__memfunc_setup("UnzoomView",1059,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15509"U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' unZoomFactor", (char*)NULL, (void*) NULL, 1);
15510 G__memfunc_setup("RotateView",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15511"d - 'Double_t' 0 - phi d - 'Double_t' 0 - theta "
15512"U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15513 G__memfunc_setup("SideView",800,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15514 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15515 G__memfunc_setup("TopView",718,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15516 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15517 G__memfunc_setup("ToggleRulers",1247,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15518 G__memfunc_setup("ShowAxis",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15519 G__memfunc_setup("ToggleZoom",1031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15520 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15521 G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15522 G__memfunc_setup("UnZoom",616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15523 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_175_0_90, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesTView::Class) ), 0);
15524 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_175_0_91, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::Class_Name) ), 0);
15525 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_175_0_92, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesTView::Class_Version) ), 0);
15526 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_175_0_93, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesTView::Dictionary) ), 0);
15527 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15528 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15529 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15530 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_175_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15531 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_175_0_98, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::DeclFileName) ), 0);
15532 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_175_0_99, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesTView::ImplFileLine) ), 0);
15533 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_175_0_100, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::ImplFileName) ), 0);
15534 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_175_0_101, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesTView::DeclFileLine) ), 0);
15535 // automatic destructor
15536 G__memfunc_setup("~BesTView", 903, G__BesVisLib_rootcint_175_0_102, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15537 G__tag_memfunc_reset();
15538}
15539
15540static void G__setup_memfuncBes2DView(void) {
15541 /* Bes2DView */
15542 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
15543 G__memfunc_setup("Bes2DView",811,G__BesVisLib_rootcint_182_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15544 G__memfunc_setup("ClearPad",764,G__BesVisLib_rootcint_182_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15545 G__memfunc_setup("DrawLabel",878,G__BesVisLib_rootcint_182_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15546 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15547"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15548"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15549 G__memfunc_setup("GetRSign",771,G__BesVisLib_rootcint_182_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 0 - Phi", (char*)NULL, (void*) NULL, 1);
15550 G__memfunc_setup("UpdateView",1022,G__BesVisLib_rootcint_182_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15551 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15552"F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15553 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15554"D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15555 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15556"F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15557 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15558"D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15559 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15560"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15561 G__memfunc_setup("Set2DViewType",1247,G__BesVisLib_rootcint_182_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - viewType", (char*)NULL, (void*) NULL, 0);
15562 G__memfunc_setup("Get2DViewType",1235,G__BesVisLib_rootcint_182_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15563 G__memfunc_setup("GetMarkerSize",1309,G__BesVisLib_rootcint_182_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15564 G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15565 G__memfunc_setup("UnZoom",616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15566 G__memfunc_setup("Center",609,G__BesVisLib_rootcint_182_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15567 G__memfunc_setup("Move",407,G__BesVisLib_rootcint_182_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
15568"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
15569 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_182_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15570 G__memfunc_setup("SetMarkerSize",1321,G__BesVisLib_rootcint_182_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - size", (char*)NULL, (void*) NULL, 0);
15571 G__memfunc_setup("GetFishEyeStatus",1617,G__BesVisLib_rootcint_182_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15572 G__memfunc_setup("GetFishEye",973,G__BesVisLib_rootcint_182_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15573 G__memfunc_setup("SetFishEye",985,G__BesVisLib_rootcint_182_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '0' input", "*TOGGLE*", (void*) NULL, 0);
15574 G__memfunc_setup("PrintCurrent",1264,G__BesVisLib_rootcint_182_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15575 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15576 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15577 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15578 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15579 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15580 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15581 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15582 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_182_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15583 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_182_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15584 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_182_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15585 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_182_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15586 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15587 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15588 G__memfunc_setup("SetZoomFactor",1328,G__BesVisLib_rootcint_182_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
15589 G__memfunc_setup("GetZoomFactor",1316,G__BesVisLib_rootcint_182_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15590 G__memfunc_setup("GetStatusCurrent",1671,G__BesVisLib_rootcint_182_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15591 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_182_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Bes2DView::Class) ), 0);
15592 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_182_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::Class_Name) ), 0);
15593 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_182_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Bes2DView::Class_Version) ), 0);
15594 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_182_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Bes2DView::Dictionary) ), 0);
15595 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15596 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15597 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15598 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_182_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15599 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_182_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::DeclFileName) ), 0);
15600 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_182_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Bes2DView::ImplFileLine) ), 0);
15601 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_182_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::ImplFileName) ), 0);
15602 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_182_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Bes2DView::DeclFileLine) ), 0);
15603 // automatic copy constructor
15604 G__memfunc_setup("Bes2DView", 811, G__BesVisLib_rootcint_182_0_53, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView), -1, 0, 1, 1, 1, 0, "u 'Bes2DView' - 11 - -", (char*) NULL, (void*) NULL, 0);
15605 // automatic destructor
15606 G__memfunc_setup("~Bes2DView", 937, G__BesVisLib_rootcint_182_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15607 G__tag_memfunc_reset();
15608}
15609
15610static void G__setup_memfuncBesCircle2D(void) {
15611 /* BesCircle2D */
15612 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
15613 G__memfunc_setup("BesCircle2D",994,G__BesVisLib_rootcint_199_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15614 G__memfunc_setup("BesCircle2D",994,G__BesVisLib_rootcint_199_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 5, 1, 1, 0,
15615"C - - 10 - name C - - 10 - title "
15616"d - 'Double_t' 0 - innerRadius d - 'Double_t' 0 - outerRadius "
15617"D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 0);
15618 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15619"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15620 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15621"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15622"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15623 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15624 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15625 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15626"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15627 G__memfunc_setup("SetCenter",909,G__BesVisLib_rootcint_199_0_8, 121, -1, -1, 0, 3, 1, 1, 0,
15628"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15629"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
15630 G__memfunc_setup("GetCenter",897,G__BesVisLib_rootcint_199_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 1);
15631 G__memfunc_setup("SetNSegment",1101,G__BesVisLib_rootcint_199_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - np", (char*)NULL, (void*) NULL, 1);
15632 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_199_0_11, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesCircle2D::Class) ), 0);
15633 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_199_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::Class_Name) ), 0);
15634 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_199_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesCircle2D::Class_Version) ), 0);
15635 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_199_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesCircle2D::Dictionary) ), 0);
15636 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15637 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15638 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15639 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_199_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15640 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_199_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::DeclFileName) ), 0);
15641 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_199_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCircle2D::ImplFileLine) ), 0);
15642 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_199_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::ImplFileName) ), 0);
15643 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_199_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCircle2D::DeclFileLine) ), 0);
15644 // automatic copy constructor
15645 G__memfunc_setup("BesCircle2D", 994, G__BesVisLib_rootcint_199_0_23, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 1, 1, 1, 0, "u 'BesCircle2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15646 // automatic destructor
15647 G__memfunc_setup("~BesCircle2D", 1120, G__BesVisLib_rootcint_199_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15648 // automatic assignment operator
15649 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_199_0_25, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 1, 1, 1, 1, 0, "u 'BesCircle2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15650 G__tag_memfunc_reset();
15651}
15652
15653static void G__setup_memfuncBesCursor(void) {
15654 /* BesCursor */
15655 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
15656 G__memfunc_setup("BesCursor",920,G__BesVisLib_rootcint_201_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15657 G__memfunc_setup("SetType",718,G__BesVisLib_rootcint_201_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EBESCursorType' - 0 - cursorType", (char*)NULL, (void*) NULL, 0);
15658 G__memfunc_setup("GetType",706,G__BesVisLib_rootcint_201_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESCursorType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15659 G__memfunc_setup("SetShowInfo",1113,G__BesVisLib_rootcint_201_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 0);
15660 G__memfunc_setup("GetShowInfo",1101,G__BesVisLib_rootcint_201_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15661 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_201_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesCursor::Class) ), 0);
15662 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_201_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::Class_Name) ), 0);
15663 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_201_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesCursor::Class_Version) ), 0);
15664 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_201_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesCursor::Dictionary) ), 0);
15665 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15666 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15667 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15668 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_201_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15669 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::DeclFileName) ), 0);
15670 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCursor::ImplFileLine) ), 0);
15671 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_201_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::ImplFileName) ), 0);
15672 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_201_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCursor::DeclFileLine) ), 0);
15673 // automatic copy constructor
15674 G__memfunc_setup("BesCursor", 920, G__BesVisLib_rootcint_201_0_18, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 0, 1, 1, 1, 0, "u 'BesCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
15675 // automatic destructor
15676 G__memfunc_setup("~BesCursor", 1046, G__BesVisLib_rootcint_201_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15677 // automatic assignment operator
15678 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_201_0_20, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 1, 1, 1, 1, 0, "u 'BesCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
15679 G__tag_memfunc_reset();
15680}
15681
15682static void G__setup_memfuncBesEventHeader(void) {
15683 /* BesEventHeader */
15684 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
15685 G__memfunc_setup("BesEventHeader",1381,G__BesVisLib_rootcint_202_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15686 G__memfunc_setup("SetEventHeaderGeneral",2101,G__BesVisLib_rootcint_202_0_2, 121, -1, -1, 0, 4, 1, 1, 0,
15687"n - 'Long64_t' 0 - run n - 'Long64_t' 0 - event "
15688"i - 'Int_t' 0 - time1 i - 'Int_t' 0 - time2", (char*)NULL, (void*) NULL, 1);
15689 G__memfunc_setup("SetEventTrig",1220,G__BesVisLib_rootcint_202_0_3, 121, -1, -1, 0, 3, 1, 1, 0,
15690"i - 'Int_t' 0 - timeType u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - trigConditionVector "
15691"u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - trigChannelVector", (char*)NULL, (void*) NULL, 1);
15692 G__memfunc_setup("SetEventMC",958,G__BesVisLib_rootcint_202_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mc", (char*)NULL, (void*) NULL, 1);
15693 G__memfunc_setup("SetEventRec",1096,G__BesVisLib_rootcint_202_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - rec", "Long Peixun's update: Rec flag", (void*) NULL, 1);
15694 G__memfunc_setup("SetEventEvTime",1400,G__BesVisLib_rootcint_202_0_6, 121, -1, -1, 0, 3, 1, 1, 0,
15695"d - 'Double_t' 0 - time i - 'Int_t' 0 - status "
15696"d - 'Double_t' 0 - quality", (char*)NULL, (void*) NULL, 1);
15697 G__memfunc_setup("SetEventMdc",1090,G__BesVisLib_rootcint_202_0_7, 121, -1, -1, 0, 5, 1, 1, 0,
15698"d - 'Double_t' 0 - p d - 'Double_t' 0 - pt "
15699"d - 'Double_t' 0 - px d - 'Double_t' 0 - py "
15700"d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 1);
15701 G__memfunc_setup("SetEventTof",1111,G__BesVisLib_rootcint_202_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 1);
15702 G__memfunc_setup("SetEventEmc",1091,G__BesVisLib_rootcint_202_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - e", (char*)NULL, (void*) NULL, 1);
15703 G__memfunc_setup("PrintWord",937,G__BesVisLib_rootcint_202_0_10, 121, -1, -1, 0, 4, 1, 1, 8,
15704"u 'TString' - 1 - word i - 'Int_t' 0 - nbits "
15705"i - 'Int_t' 0 - trigger i - 'Int_t' 0 '0' trigger2", (char*)NULL, (void*) NULL, 0);
15706 G__memfunc_setup("GetRunNumber",1214,G__BesVisLib_rootcint_202_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15707 G__memfunc_setup("GetEventNumber",1419,G__BesVisLib_rootcint_202_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15708 G__memfunc_setup("GetEventMC",946,G__BesVisLib_rootcint_202_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15709 G__memfunc_setup("GetTimeType",1105,G__BesVisLib_rootcint_202_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15710 G__memfunc_setup("GetTrigChannelVector",2018,G__BesVisLib_rootcint_202_0_15, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15711 G__memfunc_setup("GetTrigConditionVector",2256,G__BesVisLib_rootcint_202_0_16, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15712 G__memfunc_setup("GetEventYear",1203,G__BesVisLib_rootcint_202_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15713 G__memfunc_setup("GetEventMonth",1320,G__BesVisLib_rootcint_202_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15714 G__memfunc_setup("GetEventDay",1088,G__BesVisLib_rootcint_202_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15715 G__memfunc_setup("GetEventHour",1216,G__BesVisLib_rootcint_202_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15716 G__memfunc_setup("GetEventMin",1094,G__BesVisLib_rootcint_202_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15717 G__memfunc_setup("GetEventSec",1085,G__BesVisLib_rootcint_202_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15718 G__memfunc_setup("GetEventRec",1084,G__BesVisLib_rootcint_202_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", "Long Peixun's update: Rec flag", (void*) NULL, 0);
15719 G__memfunc_setup("GetEvTime",874,G__BesVisLib_rootcint_202_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15720 G__memfunc_setup("GetEvTimeStatus",1518,G__BesVisLib_rootcint_202_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15721 G__memfunc_setup("GetEvTimeQuality",1619,G__BesVisLib_rootcint_202_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15722 G__memfunc_setup("GetP",368,G__BesVisLib_rootcint_202_0_27, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15723 G__memfunc_setup("GetPt",484,G__BesVisLib_rootcint_202_0_28, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15724 G__memfunc_setup("GetPx",488,G__BesVisLib_rootcint_202_0_29, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15725 G__memfunc_setup("GetPy",489,G__BesVisLib_rootcint_202_0_30, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15726 G__memfunc_setup("GetPz",490,G__BesVisLib_rootcint_202_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15727 G__memfunc_setup("GetT",372,G__BesVisLib_rootcint_202_0_32, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15728 G__memfunc_setup("GetE",357,G__BesVisLib_rootcint_202_0_33, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15729 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_202_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesEventHeader::Class) ), 0);
15730 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_202_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::Class_Name) ), 0);
15731 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_202_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesEventHeader::Class_Version) ), 0);
15732 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_202_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesEventHeader::Dictionary) ), 0);
15733 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15734 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15735 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15736 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_202_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15737 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_202_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::DeclFileName) ), 0);
15738 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_202_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEventHeader::ImplFileLine) ), 0);
15739 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_202_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::ImplFileName) ), 0);
15740 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_202_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEventHeader::DeclFileLine) ), 0);
15741 // automatic copy constructor
15742 G__memfunc_setup("BesEventHeader", 1381, G__BesVisLib_rootcint_202_0_46, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 1, 1, 1, 0, "u 'BesEventHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
15743 // automatic destructor
15744 G__memfunc_setup("~BesEventHeader", 1507, G__BesVisLib_rootcint_202_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15745 // automatic assignment operator
15746 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_202_0_48, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 1, 1, 1, 1, 0, "u 'BesEventHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
15747 G__tag_memfunc_reset();
15748}
15749
15750static void G__setup_memfuncBesView(void) {
15751 /* BesView */
15752 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
15753 G__memfunc_setup("BesView",693,G__BesVisLib_rootcint_242_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15754 G__memfunc_setup("SetViewType",1129,G__BesVisLib_rootcint_242_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15755"i 'EBESViewType' - 0 - ViewType g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15756 G__memfunc_setup("SetViewTypeBare",1507,G__BesVisLib_rootcint_242_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
15757"i 'EBESViewType' - 0 - ViewType g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15758 G__memfunc_setup("DefaultRange",1202,G__BesVisLib_rootcint_242_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15759 G__memfunc_setup("ClearPad",764,G__BesVisLib_rootcint_242_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15760 G__memfunc_setup("DrawLabel",878,G__BesVisLib_rootcint_242_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15761 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15762"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15763"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15764 G__memfunc_setup("GetRSign",771,G__BesVisLib_rootcint_242_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 0 - Phi", (char*)NULL, (void*) NULL, 1);
15765 G__memfunc_setup("UpdateView",1022,G__BesVisLib_rootcint_242_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15766 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15767"F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15768 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15769"D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15770 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15771"F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15772 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15773"D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15774 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15775"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15776 G__memfunc_setup("SetZoomRatio",1232,G__BesVisLib_rootcint_242_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ratio", (char*)NULL, (void*) NULL, 0);
15777 G__memfunc_setup("GetZoomRatio",1220,G__BesVisLib_rootcint_242_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15778 G__memfunc_setup("GetViewType",1117,G__BesVisLib_rootcint_242_0_17, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESViewType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15779 G__memfunc_setup("GetMarkerSize",1309,G__BesVisLib_rootcint_242_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15780 G__memfunc_setup("View3D",530,G__BesVisLib_rootcint_242_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15781 G__memfunc_setup("ViewXY",588,G__BesVisLib_rootcint_242_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15782 G__memfunc_setup("ViewZR",583,G__BesVisLib_rootcint_242_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15783 G__memfunc_setup("ZoomIn",604,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15784 G__memfunc_setup("ZoomOut",733,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15785 G__memfunc_setup("Center",609,G__BesVisLib_rootcint_242_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15786 G__memfunc_setup("Move",407,G__BesVisLib_rootcint_242_0_25, 121, -1, -1, 0, 2, 1, 1, 0,
15787"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
15788 G__memfunc_setup("Front3D",640,G__BesVisLib_rootcint_242_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15789 G__memfunc_setup("Side3D",508,G__BesVisLib_rootcint_242_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15790 G__memfunc_setup("Top3D",426,G__BesVisLib_rootcint_242_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15791 G__memfunc_setup("SetPhiRange",1082,G__BesVisLib_rootcint_242_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
15792"f - 'Float_t' 0 '0' PhiMin f - 'Float_t' 0 '180' PhiMax", (char*)NULL, (void*) NULL, 0);
15793 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_242_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15794 G__memfunc_setup("Refresh",719,G__BesVisLib_rootcint_242_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun's update: Refresh", (void*) NULL, 0);
15795 G__memfunc_setup("SetMarkerSize",1321,G__BesVisLib_rootcint_242_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - size", (char*)NULL, (void*) NULL, 0);
15796 G__memfunc_setup("GetVisCgemGlobal",1567,G__BesVisLib_rootcint_242_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15797 G__memfunc_setup("GetVisCgemLayers",1598,G__BesVisLib_rootcint_242_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15798 G__memfunc_setup("GetVisCgemXStrips",1707,G__BesVisLib_rootcint_242_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15799 G__memfunc_setup("GetVisCgemVStrips",1705,G__BesVisLib_rootcint_242_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15800 G__memfunc_setup("SetVisCgemGlobal",1579,G__BesVisLib_rootcint_242_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15801 G__memfunc_setup("SetVisCgemLayers",1610,G__BesVisLib_rootcint_242_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15802 G__memfunc_setup("SetVisCgemXStrips",1719,G__BesVisLib_rootcint_242_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15803 G__memfunc_setup("SetVisCgemVStrips",1717,G__BesVisLib_rootcint_242_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15804 G__memfunc_setup("GetVisMdcGlobal",1463,G__BesVisLib_rootcint_242_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15805 G__memfunc_setup("GetVisMdcTubes",1385,G__BesVisLib_rootcint_242_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15806 G__memfunc_setup("GetVisMdcWires",1392,G__BesVisLib_rootcint_242_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15807 G__memfunc_setup("SetVisMdcGlobal",1475,G__BesVisLib_rootcint_242_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15808 G__memfunc_setup("SetVisMdcTubes",1397,G__BesVisLib_rootcint_242_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15809 G__memfunc_setup("SetVisMdcWires",1404,G__BesVisLib_rootcint_242_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15810 G__memfunc_setup("GetVisTofGlobal",1484,G__BesVisLib_rootcint_242_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15811 G__memfunc_setup("GetVisTofEast",1288,G__BesVisLib_rootcint_242_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15812 G__memfunc_setup("GetVisTofBarrel",1491,G__BesVisLib_rootcint_242_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15813 G__memfunc_setup("GetVisTofWest",1310,G__BesVisLib_rootcint_242_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15814 G__memfunc_setup("GetVisZoom",1015,G__BesVisLib_rootcint_242_0_51, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15815 G__memfunc_setup("SetVisTofGlobal",1496,G__BesVisLib_rootcint_242_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15816 G__memfunc_setup("SetVisTofEast",1300,G__BesVisLib_rootcint_242_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15817 G__memfunc_setup("SetVisTofBarrel",1503,G__BesVisLib_rootcint_242_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15818 G__memfunc_setup("SetVisTofWest",1322,G__BesVisLib_rootcint_242_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15819 G__memfunc_setup("SetVisZoom",1027,G__BesVisLib_rootcint_242_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15820 G__memfunc_setup("GetVisEmcGlobal",1464,G__BesVisLib_rootcint_242_0_57, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15821 G__memfunc_setup("GetVisEmcEast",1268,G__BesVisLib_rootcint_242_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15822 G__memfunc_setup("GetVisEmcBarrel",1471,G__BesVisLib_rootcint_242_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15823 G__memfunc_setup("GetVisEmcWest",1290,G__BesVisLib_rootcint_242_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15824 G__memfunc_setup("GetVisEmcSide",1260,G__BesVisLib_rootcint_242_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15825 G__memfunc_setup("SetVisEmcGlobal",1476,G__BesVisLib_rootcint_242_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15826 G__memfunc_setup("SetVisEmcEast",1280,G__BesVisLib_rootcint_242_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15827 G__memfunc_setup("SetVisEmcBarrel",1483,G__BesVisLib_rootcint_242_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15828 G__memfunc_setup("SetVisEmcWest",1302,G__BesVisLib_rootcint_242_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15829 G__memfunc_setup("SetVisEmcSide",1272,G__BesVisLib_rootcint_242_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15830 G__memfunc_setup("GetVisMucGlobal",1480,G__BesVisLib_rootcint_242_0_67, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15831 G__memfunc_setup("GetVisMucEast",1284,G__BesVisLib_rootcint_242_0_68, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15832 G__memfunc_setup("GetVisMucBarrel",1487,G__BesVisLib_rootcint_242_0_69, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15833 G__memfunc_setup("GetVisMucWest",1306,G__BesVisLib_rootcint_242_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15834 G__memfunc_setup("GetVisMucStrips",1532,G__BesVisLib_rootcint_242_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15835 G__memfunc_setup("SetVisMucGlobal",1492,G__BesVisLib_rootcint_242_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15836 G__memfunc_setup("SetVisMucEast",1296,G__BesVisLib_rootcint_242_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15837 G__memfunc_setup("SetVisMucBarrel",1499,G__BesVisLib_rootcint_242_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15838 G__memfunc_setup("SetVisMucWest",1318,G__BesVisLib_rootcint_242_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15839 G__memfunc_setup("SetVisMucStrips",1544,G__BesVisLib_rootcint_242_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15840 G__memfunc_setup("GetVisFull3DCgem",1496,G__BesVisLib_rootcint_242_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15841 G__memfunc_setup("GetVisFull3DMdc",1392,G__BesVisLib_rootcint_242_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15842 G__memfunc_setup("GetVisFull3DTof",1413,G__BesVisLib_rootcint_242_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15843 G__memfunc_setup("GetVisFull3DEmc",1393,G__BesVisLib_rootcint_242_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15844 G__memfunc_setup("GetVisFull3DMuc",1409,G__BesVisLib_rootcint_242_0_81, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15845 G__memfunc_setup("SetVisFull3DCgem",1508,G__BesVisLib_rootcint_242_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15846 G__memfunc_setup("SetVisFull3DMdc",1404,G__BesVisLib_rootcint_242_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15847 G__memfunc_setup("SetVisFull3DTof",1425,G__BesVisLib_rootcint_242_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15848 G__memfunc_setup("SetVisFull3DEmc",1405,G__BesVisLib_rootcint_242_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15849 G__memfunc_setup("SetVisFull3DMuc",1421,G__BesVisLib_rootcint_242_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15850 G__memfunc_setup("GetVisBeamPipe",1365,G__BesVisLib_rootcint_242_0_87, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15851 G__memfunc_setup("GetVisZRPlaneOnXY",1628,G__BesVisLib_rootcint_242_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15852 G__memfunc_setup("GetVisAxis",999,G__BesVisLib_rootcint_242_0_89, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15853 G__memfunc_setup("SetVisBeamPipe",1377,G__BesVisLib_rootcint_242_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15854 G__memfunc_setup("SetVisZRPlaneOnXY",1640,G__BesVisLib_rootcint_242_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15855 G__memfunc_setup("SetVisAxis",1011,G__BesVisLib_rootcint_242_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15856 G__memfunc_setup("GetVisCgemHitsGlobal",1975,G__BesVisLib_rootcint_242_0_93, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15857 G__memfunc_setup("GetVisCgemHitsXStrip",2000,G__BesVisLib_rootcint_242_0_94, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15858 G__memfunc_setup("GetVisCgemHitsVStrip",1998,G__BesVisLib_rootcint_242_0_95, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15859 G__memfunc_setup("GetVisCgemHitsClusters",2235,G__BesVisLib_rootcint_242_0_96, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15860 G__memfunc_setup("SetVisCgemHitsGlobal",1987,G__BesVisLib_rootcint_242_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15861 G__memfunc_setup("SetVisCgemHitsXStrip",2012,G__BesVisLib_rootcint_242_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15862 G__memfunc_setup("SetVisCgemHitsVStrip",2010,G__BesVisLib_rootcint_242_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15863 G__memfunc_setup("SetVisCgemHitsClusters",2247,G__BesVisLib_rootcint_242_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15864 G__memfunc_setup("GetVisMdcHitsGlobal",1871,G__BesVisLib_rootcint_242_0_101, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15865 G__memfunc_setup("GetVisMdcHits",1278,G__BesVisLib_rootcint_242_0_102, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15866 G__memfunc_setup("SetVisMdcHitsGlobal",1883,G__BesVisLib_rootcint_242_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15867 G__memfunc_setup("SetVisMdcHits",1290,G__BesVisLib_rootcint_242_0_104, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15868 G__memfunc_setup("GetVisTofHitsGlobal",1892,G__BesVisLib_rootcint_242_0_105, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15869 G__memfunc_setup("GetVisTofHitsEast",1696,G__BesVisLib_rootcint_242_0_106, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15870 G__memfunc_setup("GetVisTofHitsBarrel",1899,G__BesVisLib_rootcint_242_0_107, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15871 G__memfunc_setup("GetVisTofHitsWest",1718,G__BesVisLib_rootcint_242_0_108, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15872 G__memfunc_setup("SetVisTofHitsGlobal",1904,G__BesVisLib_rootcint_242_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15873 G__memfunc_setup("SetVisTofHitsEast",1708,G__BesVisLib_rootcint_242_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15874 G__memfunc_setup("SetVisTofHitsBarrel",1911,G__BesVisLib_rootcint_242_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15875 G__memfunc_setup("SetVisTofHitsWest",1730,G__BesVisLib_rootcint_242_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15876 G__memfunc_setup("GetVisEmcHitsGlobal",1872,G__BesVisLib_rootcint_242_0_113, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15877 G__memfunc_setup("GetVisEmcHitsEast",1676,G__BesVisLib_rootcint_242_0_114, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15878 G__memfunc_setup("GetVisEmcHitsBarrel",1879,G__BesVisLib_rootcint_242_0_115, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15879 G__memfunc_setup("GetVisEmcHitsWest",1698,G__BesVisLib_rootcint_242_0_116, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15880 G__memfunc_setup("GetVisEmcHitsSide",1668,G__BesVisLib_rootcint_242_0_117, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15881 G__memfunc_setup("SetVisEmcHitsGlobal",1884,G__BesVisLib_rootcint_242_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15882 G__memfunc_setup("SetVisEmcHitsEast",1688,G__BesVisLib_rootcint_242_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15883 G__memfunc_setup("SetVisEmcHitsBarrel",1891,G__BesVisLib_rootcint_242_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15884 G__memfunc_setup("SetVisEmcHitsWest",1710,G__BesVisLib_rootcint_242_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15885 G__memfunc_setup("SetVisEmcHitsSide",1680,G__BesVisLib_rootcint_242_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15886 G__memfunc_setup("GetVisMucHitsGlobal",1888,G__BesVisLib_rootcint_242_0_123, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15887 G__memfunc_setup("GetVisMucHitsEast",1692,G__BesVisLib_rootcint_242_0_124, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15888 G__memfunc_setup("GetVisMucHitsBarrel",1895,G__BesVisLib_rootcint_242_0_125, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15889 G__memfunc_setup("GetVisMucHitsWest",1714,G__BesVisLib_rootcint_242_0_126, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15890 G__memfunc_setup("SetVisMucHitsGlobal",1900,G__BesVisLib_rootcint_242_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15891 G__memfunc_setup("SetVisMucHitsEast",1704,G__BesVisLib_rootcint_242_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15892 G__memfunc_setup("SetVisMucHitsBarrel",1907,G__BesVisLib_rootcint_242_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15893 G__memfunc_setup("SetVisMucHitsWest",1726,G__BesVisLib_rootcint_242_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15894 G__memfunc_setup("GetVisTracksGlobal",1803,G__BesVisLib_rootcint_242_0_131, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15895 G__memfunc_setup("GetVisTracksMdc",1486,G__BesVisLib_rootcint_242_0_132, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15896 G__memfunc_setup("GetVisTracksTof",1507,G__BesVisLib_rootcint_242_0_133, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15897 G__memfunc_setup("GetVisTracksEmc",1487,G__BesVisLib_rootcint_242_0_134, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15898 G__memfunc_setup("GetVisTracksMuc",1503,G__BesVisLib_rootcint_242_0_135, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15899 G__memfunc_setup("GetVisTracksExt",1515,G__BesVisLib_rootcint_242_0_136, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15900 G__memfunc_setup("SetVisTracksGlobal",1815,G__BesVisLib_rootcint_242_0_137, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15901 G__memfunc_setup("SetVisTracksMdc",1498,G__BesVisLib_rootcint_242_0_138, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15902 G__memfunc_setup("SetVisTracksTof",1519,G__BesVisLib_rootcint_242_0_139, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15903 G__memfunc_setup("SetVisTracksEmc",1499,G__BesVisLib_rootcint_242_0_140, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15904 G__memfunc_setup("SetVisTracksMuc",1515,G__BesVisLib_rootcint_242_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15905 G__memfunc_setup("SetVisTracksExt",1527,G__BesVisLib_rootcint_242_0_142, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15906 G__memfunc_setup("GetFishEyeStatus",1617,G__BesVisLib_rootcint_242_0_143, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15907 G__memfunc_setup("GetFishEye",973,G__BesVisLib_rootcint_242_0_144, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15908 G__memfunc_setup("SetFishEye",985,G__BesVisLib_rootcint_242_0_145, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '0' input", "*TOGGLE*", (void*) NULL, 0);
15909 G__memfunc_setup("PrintCurrent",1264,G__BesVisLib_rootcint_242_0_146, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15910 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15911 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15912 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15913 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15914 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15915 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15916 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15917 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_242_0_154, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15918 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_242_0_155, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15919 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_242_0_156, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15920 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_242_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15921 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15922 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15923 G__memfunc_setup("SetZoomFactor",1328,G__BesVisLib_rootcint_242_0_160, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
15924 G__memfunc_setup("GetZoomFactor",1316,G__BesVisLib_rootcint_242_0_161, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15925 G__memfunc_setup("GetStatusCurrent",1671,G__BesVisLib_rootcint_242_0_162, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15926 G__memfunc_setup("GetStatus3D",1051,G__BesVisLib_rootcint_242_0_163, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15927 G__memfunc_setup("GetStatusXY",1109,G__BesVisLib_rootcint_242_0_164, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15928 G__memfunc_setup("GetStatusZR",1104,G__BesVisLib_rootcint_242_0_165, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15929 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_242_0_166, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesView::Class) ), 0);
15930 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_242_0_167, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::Class_Name) ), 0);
15931 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_242_0_168, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesView::Class_Version) ), 0);
15932 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_242_0_169, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesView::Dictionary) ), 0);
15933 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15934 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15935 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15936 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_242_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15937 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_242_0_174, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::DeclFileName) ), 0);
15938 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_242_0_175, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesView::ImplFileLine) ), 0);
15939 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_242_0_176, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::ImplFileName) ), 0);
15940 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_242_0_177, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesView::DeclFileLine) ), 0);
15941 // automatic copy constructor
15942 G__memfunc_setup("BesView", 693, G__BesVisLib_rootcint_242_0_178, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView), -1, 0, 1, 1, 1, 0, "u 'BesView' - 11 - -", (char*) NULL, (void*) NULL, 0);
15943 // automatic destructor
15944 G__memfunc_setup("~BesView", 819, G__BesVisLib_rootcint_242_0_179, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15945 G__tag_memfunc_reset();
15946}
15947
15948static void G__setup_memfuncBesMarker2D(void) {
15949 /* BesMarker2D */
15950 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
15951 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15952 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 5, 1, 1, 0,
15953"C - - 10 - name C - - 10 - title "
15954"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
15955"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
15956 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 5, 1, 1, 0,
15957"C - - 10 - name C - - 10 - title "
15958"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15959"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
15960 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15961 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15962 G__memfunc_setup("GetCenterPixel",1411,G__BesVisLib_rootcint_243_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
15963"i - 'Int_t' 1 - px i - 'Int_t' 1 - py", (char*)NULL, (void*) NULL, 1);
15964 G__memfunc_setup("SetMarkerSizeMultiple",2165,G__BesVisLib_rootcint_243_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15965 G__memfunc_setup("GetMarkerSizeMultiple",2153,G__BesVisLib_rootcint_243_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15966 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15967 G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15968 G__memfunc_setup("GetWCX",530,G__BesVisLib_rootcint_243_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15969 G__memfunc_setup("GetWCY",531,G__BesVisLib_rootcint_243_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15970 G__memfunc_setup("GetWCZ",532,G__BesVisLib_rootcint_243_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15971 G__memfunc_setup("SetWCX",542,G__BesVisLib_rootcint_243_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15972 G__memfunc_setup("SetWCY",543,G__BesVisLib_rootcint_243_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15973 G__memfunc_setup("SetWCZ",544,G__BesVisLib_rootcint_243_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15974 G__memfunc_setup("SetParameter",1229,G__BesVisLib_rootcint_243_0_17, 121, -1, -1, 0, 5, 1, 1, 0,
15975"C - - 10 - name C - - 10 - title "
15976"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
15977"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
15978 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15979"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15980 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_243_0_19, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesMarker2D::Class) ), 0);
15981 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_243_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::Class_Name) ), 0);
15982 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_243_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesMarker2D::Class_Version) ), 0);
15983 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_243_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesMarker2D::Dictionary) ), 0);
15984 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15985 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15986 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15987 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_243_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15988 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_243_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::DeclFileName) ), 0);
15989 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_243_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesMarker2D::ImplFileLine) ), 0);
15990 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_243_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::ImplFileName) ), 0);
15991 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_243_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesMarker2D::DeclFileLine) ), 0);
15992 // automatic copy constructor
15993 G__memfunc_setup("BesMarker2D", 1010, G__BesVisLib_rootcint_243_0_31, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 1, 1, 1, 0, "u 'BesMarker2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15994 // automatic destructor
15995 G__memfunc_setup("~BesMarker2D", 1136, G__BesVisLib_rootcint_243_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15996 // automatic assignment operator
15997 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_243_0_33, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 1, 1, 1, 1, 0, "u 'BesMarker2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15998 G__tag_memfunc_reset();
15999}
16000
16001static void G__setup_memfuncBesPaveText(void) {
16002 /* BesPaveText */
16003 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
16004 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16005 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 5, 1, 1, 0,
16006"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
16007"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
16008"C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
16009 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 1, 1, 1, 0, "u 'BesPaveText' - 11 - pavetext", (char*)NULL, (void*) NULL, 0);
16010 G__memfunc_setup("SetText",721,G__BesVisLib_rootcint_244_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >' 'vector<TString>' 0 - infoCon", (char*)NULL, (void*) NULL, 1);
16011 G__memfunc_setup("SetPos",606,G__BesVisLib_rootcint_244_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
16012"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16013 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_244_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesPaveText::Class) ), 0);
16014 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_244_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::Class_Name) ), 0);
16015 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_244_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesPaveText::Class_Version) ), 0);
16016 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_244_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesPaveText::Dictionary) ), 0);
16017 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16018 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16019 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16020 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_244_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16021 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_244_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::DeclFileName) ), 0);
16022 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_244_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPaveText::ImplFileLine) ), 0);
16023 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_244_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::ImplFileName) ), 0);
16024 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_244_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPaveText::DeclFileLine) ), 0);
16025 // automatic destructor
16026 G__memfunc_setup("~BesPaveText", 1225, G__BesVisLib_rootcint_244_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16027 // automatic assignment operator
16028 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_244_0_19, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 1, 1, 1, 1, 0, "u 'BesPaveText' - 11 - -", (char*) NULL, (void*) NULL, 0);
16029 G__tag_memfunc_reset();
16030}
16031
16032static void G__setup_memfuncBesGeoTrack(void) {
16033 /* BesGeoTrack */
16034 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
16035 G__memfunc_setup("BesGeoTrack",1066,G__BesVisLib_rootcint_249_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16036 G__memfunc_setup("BesGeoTrack",1066,G__BesVisLib_rootcint_249_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack), -1, 0, 4, 1, 1, 0,
16037"i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
16038"U 'TVirtualGeoTrack' - 0 '0' parent U 'TObject' - 0 '0' particle", (char*)NULL, (void*) NULL, 0);
16039 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_249_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16040 G__memfunc_setup("AddHit",558,G__BesVisLib_rootcint_249_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16041 G__memfunc_setup("Add3DHit",677,G__BesVisLib_rootcint_249_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", "Long Peixun's update: for 3D track display", (void*) NULL, 1);
16042 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_249_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16043 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_249_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16044 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_249_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
16045 G__memfunc_setup("SetTrackType",1219,G__BesVisLib_rootcint_249_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
16046 G__memfunc_setup("AddPoint",787,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16047"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
16048"d - 'Double_t' 0 - z d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 1);
16049 G__memfunc_setup("SetMarker",910,G__BesVisLib_rootcint_249_0_11, 121, -1, -1, 0, 3, 1, 1, 0,
16050"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
16051"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
16052 G__memfunc_setup("Construct3DLine",1476,G__BesVisLib_rootcint_249_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun's update: construct but not draw", (void*) NULL, 1);
16053 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16054"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16055 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16056"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16057"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16058 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16059 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16060 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16061"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16062 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_249_0_18, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGeoTrack::Class) ), 0);
16063 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_249_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::Class_Name) ), 0);
16064 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_249_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGeoTrack::Class_Version) ), 0);
16065 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_249_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGeoTrack::Dictionary) ), 0);
16066 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16067 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16068 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16069 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_249_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16070 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_249_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::DeclFileName) ), 0);
16071 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_249_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeoTrack::ImplFileLine) ), 0);
16072 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_249_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::ImplFileName) ), 0);
16073 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_249_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeoTrack::DeclFileLine) ), 0);
16074 // automatic destructor
16075 G__memfunc_setup("~BesGeoTrack", 1192, G__BesVisLib_rootcint_249_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16076 G__tag_memfunc_reset();
16077}
16078
16079static void G__setup_memfuncBesEvent(void) {
16080 /* BesEvent */
16081 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
16082 G__memfunc_setup("Is_tofBarrel",1212,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 4, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
16083 G__memfunc_setup("Is_tofCounter",1348,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 4, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
16084 G__memfunc_setup("BesEvent",796,G__BesVisLib_rootcint_529_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16085 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16086 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16087 G__memfunc_setup("Print",525,G__BesVisLib_rootcint_529_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16088 G__memfunc_setup("SetEvent",814,G__BesVisLib_rootcint_529_0_7, 121, -1, -1, 0, 5, 1, 1, 0,
16089"U 'TDigiEvent' - 0 - digiEvent U 'TDisTrack' - 0 - recEvent "
16090"U 'TEvtHeader' - 0 - evtHeader U 'TRecEvTime' - 0 - recEvTime "
16091"g - 'Bool_t' 0 - isRec", ", TTrigEvent *trigEvent);", (void*) NULL, 1);
16092 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_529_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16093 G__memfunc_setup("SetTracks",916,G__BesVisLib_rootcint_529_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16094 G__memfunc_setup("SetMdcTracks",1192,G__BesVisLib_rootcint_529_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16095 G__memfunc_setup("SetTofTracks",1213,G__BesVisLib_rootcint_529_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16096 G__memfunc_setup("SetEmcShowers",1324,G__BesVisLib_rootcint_529_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16097 G__memfunc_setup("SetMucTracks",1209,G__BesVisLib_rootcint_529_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16098 G__memfunc_setup("SetExtTracks",1221,G__BesVisLib_rootcint_529_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16099 G__memfunc_setup("ConstructMdcTrackFromRec",2428,G__BesVisLib_rootcint_529_0_15, 121, -1, -1, 0, 3, 1, 1, 0,
16100"U 'BesGeoTrack' - 0 - mdcTrack U 'TRecMdcTrack' - 10 - recTrack "
16101"U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16102 G__memfunc_setup("ConstructMucTrackFromRec",2445,G__BesVisLib_rootcint_529_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
16103"U 'BesGeoTrack' - 0 - mucTrack U 'TRecMucTrack' - 10 - recTrack", (char*)NULL, (void*) NULL, 1);
16104 G__memfunc_setup("ConstructEmcTrackFromRec",2429,G__BesVisLib_rootcint_529_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
16105"U 'BesGeoTrack' - 0 - emcTrack U 'TRecEmcShower' - 10 - recTrack", (char*)NULL, (void*) NULL, 1);
16106 G__memfunc_setup("ConstructTofTrackFromRec",2449,G__BesVisLib_rootcint_529_0_18, 121, -1, -1, 0, 3, 1, 1, 0,
16107"U 'BesGeoTrack' - 0 - tofTrack U 'TRecTofTrack' - 10 - recTrack "
16108"U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
16109 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_529_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16110 G__memfunc_setup("DrawTracks",1014,G__BesVisLib_rootcint_529_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16111 G__memfunc_setup("SetMagnetic",1108,G__BesVisLib_rootcint_529_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16112 G__memfunc_setup("GetMdcDigiCol",1231,G__BesVisLib_rootcint_529_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16113 G__memfunc_setup("GetTofDigiCol",1252,G__BesVisLib_rootcint_529_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16114 G__memfunc_setup("GetEmcDigiCol",1232,G__BesVisLib_rootcint_529_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16115 G__memfunc_setup("GetMucDigiCol",1248,G__BesVisLib_rootcint_529_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16116 G__memfunc_setup("GetMdcDigiNum",1249,G__BesVisLib_rootcint_529_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16117 G__memfunc_setup("GetTofDigiNum",1270,G__BesVisLib_rootcint_529_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16118 G__memfunc_setup("GetEmcDigiNum",1250,G__BesVisLib_rootcint_529_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16119 G__memfunc_setup("GetMucDigiNum",1266,G__BesVisLib_rootcint_529_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16120 G__memfunc_setup("GetMdcDigi",945,G__BesVisLib_rootcint_529_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", "Long Peixun's update: Remove semicolon", (void*) NULL, 0);
16121 G__memfunc_setup("GetTofDigi",966,G__BesVisLib_rootcint_529_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16122 G__memfunc_setup("GetEmcDigi",946,G__BesVisLib_rootcint_529_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16123 G__memfunc_setup("GetMucDigi",962,G__BesVisLib_rootcint_529_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16124 G__memfunc_setup("GetMdcTrackCol",1351,G__BesVisLib_rootcint_529_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16125 G__memfunc_setup("GetTofTrackCol",1372,G__BesVisLib_rootcint_529_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16126 G__memfunc_setup("GetEmcShowerCol",1483,G__BesVisLib_rootcint_529_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16127 G__memfunc_setup("GetMucTrackCol",1368,G__BesVisLib_rootcint_529_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16128 G__memfunc_setup("GetExtTrackCol",1380,G__BesVisLib_rootcint_529_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16129 G__memfunc_setup("GetDedxCol",963,G__BesVisLib_rootcint_529_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16130 G__memfunc_setup("GetMdcTrackNum",1369,G__BesVisLib_rootcint_529_0_40, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16131 G__memfunc_setup("GetTofTrackNum",1390,G__BesVisLib_rootcint_529_0_41, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16132 G__memfunc_setup("GetEmcShowerNum",1501,G__BesVisLib_rootcint_529_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16133 G__memfunc_setup("GetMucTrackNum",1386,G__BesVisLib_rootcint_529_0_43, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16134 G__memfunc_setup("GetExtTrackNum",1398,G__BesVisLib_rootcint_529_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16135 G__memfunc_setup("GetDedxNum",981,G__BesVisLib_rootcint_529_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16136 G__memfunc_setup("GetMdcTrack",1065,G__BesVisLib_rootcint_529_0_46, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMdcTrack), -1, 0, 2, 1, 1, 9,
16137"i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16138 G__memfunc_setup("GetTofTrack",1086,G__BesVisLib_rootcint_529_0_47, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecTofTrack), -1, 0, 2, 1, 1, 9,
16139"i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16140 G__memfunc_setup("GetEmcShower",1197,G__BesVisLib_rootcint_529_0_48, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecEmcShower), -1, 0, 2, 1, 1, 9,
16141"i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16142 G__memfunc_setup("GetMucTrack",1082,G__BesVisLib_rootcint_529_0_49, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMucTrack), -1, 0, 2, 1, 1, 9,
16143"i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
16144 G__memfunc_setup("GetDedx",677,G__BesVisLib_rootcint_529_0_50, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16145 G__memfunc_setup("GetRun",597,G__BesVisLib_rootcint_529_0_51, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16146 G__memfunc_setup("GetEvent",802,G__BesVisLib_rootcint_529_0_52, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16147 G__memfunc_setup("GetYear",689,G__BesVisLib_rootcint_529_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16148 G__memfunc_setup("GetMonth",806,G__BesVisLib_rootcint_529_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16149 G__memfunc_setup("GetDay",574,G__BesVisLib_rootcint_529_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16150 G__memfunc_setup("GetHour",702,G__BesVisLib_rootcint_529_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16151 G__memfunc_setup("GetMin",580,G__BesVisLib_rootcint_529_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16152 G__memfunc_setup("GetSec",571,G__BesVisLib_rootcint_529_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16153 G__memfunc_setup("GetMC",432,G__BesVisLib_rootcint_529_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16154 G__memfunc_setup("GetHeader",873,G__BesVisLib_rootcint_529_0_60, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16155 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_529_0_61, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesEvent::Class) ), 0);
16156 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_529_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::Class_Name) ), 0);
16157 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_529_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesEvent::Class_Version) ), 0);
16158 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_529_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesEvent::Dictionary) ), 0);
16159 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16160 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16161 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16162 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_529_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16163 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_529_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::DeclFileName) ), 0);
16164 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_529_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEvent::ImplFileLine) ), 0);
16165 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_529_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::ImplFileName) ), 0);
16166 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_529_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEvent::DeclFileLine) ), 0);
16167 // automatic copy constructor
16168 G__memfunc_setup("BesEvent", 796, G__BesVisLib_rootcint_529_0_73, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 0, 1, 1, 1, 0, "u 'BesEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
16169 // automatic destructor
16170 G__memfunc_setup("~BesEvent", 922, G__BesVisLib_rootcint_529_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16171 // automatic assignment operator
16172 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_529_0_75, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 1, 1, 1, 1, 0, "u 'BesEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
16173 G__tag_memfunc_reset();
16174}
16175
16176static void G__setup_memfuncSubDetectorROOTGeo(void) {
16177 /* SubDetectorROOTGeo */
16178 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
16179 G__memfunc_setup("SubDetectorROOTGeo",1731,G__BesVisLib_rootcint_798_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16180 G__memfunc_setup("ReadGdml",768,G__BesVisLib_rootcint_798_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16181"C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 1);
16182 G__memfunc_setup("IsInitialized",1330,G__BesVisLib_rootcint_798_0_3, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16183 G__memfunc_setup("SetChildNo",973,G__BesVisLib_rootcint_798_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - childNo", (char*)NULL, (void*) NULL, 1);
16184 G__memfunc_setup("GetLogicalVolume",1619,G__BesVisLib_rootcint_798_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - vn", (char*)NULL, (void*) NULL, 1);
16185 G__memfunc_setup("GetTopVolume",1227,G__BesVisLib_rootcint_798_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16186 G__memfunc_setup("GetAssemblyVolume",1752,G__BesVisLib_rootcint_798_0_7, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - an", (char*)NULL, (void*) NULL, 1);
16187 G__memfunc_setup("GetNode",678,G__BesVisLib_rootcint_798_0_8, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - nn", (char*)NULL, (void*) NULL, 1);
16188 G__memfunc_setup("GetHitsNum",1000,G__BesVisLib_rootcint_798_0_9, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16189 G__memfunc_setup("GetHit",581,G__BesVisLib_rootcint_798_0_10, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 1);
16190 G__memfunc_setup("SetDetectorOn",1315,G__BesVisLib_rootcint_798_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16191 // automatic copy constructor
16192 G__memfunc_setup("SubDetectorROOTGeo", 1731, G__BesVisLib_rootcint_798_0_12, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo), -1, 0, 1, 1, 1, 0, "u 'SubDetectorROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16193 // automatic destructor
16194 G__memfunc_setup("~SubDetectorROOTGeo", 1857, G__BesVisLib_rootcint_798_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16195 G__tag_memfunc_reset();
16196}
16197
16198static void G__setup_memfuncBesPolygon2D(void) {
16199 /* BesPolygon2D */
16200 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
16201 G__memfunc_setup("BesPolygon2D",1144,G__BesVisLib_rootcint_836_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16202 G__memfunc_setup("BesPolygon2D",1144,G__BesVisLib_rootcint_836_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 4, 1, 1, 0,
16203"C - - 10 - name C - - 10 - title "
16204"i - 'Int_t' 0 - N D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
16205 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16206 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16207 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16208"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16209 G__memfunc_setup("SetZRSign",873,G__BesVisLib_rootcint_836_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sign", (char*)NULL, (void*) NULL, 1);
16210 G__memfunc_setup("Resize",626,G__BesVisLib_rootcint_836_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ScaleFactor", (char*)NULL, (void*) NULL, 1);
16211 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16212"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16213 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16214"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16215"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16216 G__memfunc_setup("SetInfoBox",993,G__BesVisLib_rootcint_836_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
16217 G__memfunc_setup("GetCenter",897,G__BesVisLib_rootcint_836_0_11, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - Center", (char*)NULL, (void*) NULL, 1);
16218 G__memfunc_setup("RotatePhi",912,G__BesVisLib_rootcint_836_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
16219 G__memfunc_setup("Restore",740,G__BesVisLib_rootcint_836_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16220 G__memfunc_setup("SetSize",711,G__BesVisLib_rootcint_836_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
16221 G__memfunc_setup("Stretch",733,G__BesVisLib_rootcint_836_0_15, 121, -1, -1, 0, 4, 1, 1, 0,
16222"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
16223"d - 'Double_t' 0 - sz d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
16224 G__memfunc_setup("IsRotatable",1114,G__BesVisLib_rootcint_836_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16225 G__memfunc_setup("SetRotatable",1226,G__BesVisLib_rootcint_836_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16226 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
16227 G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
16228 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16229 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_836_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16230 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_836_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16231 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16232 G__memfunc_setup("SetPoints",937,G__BesVisLib_rootcint_836_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
16233 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_836_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesPolygon2D::Class) ), 0);
16234 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_836_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::Class_Name) ), 0);
16235 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_836_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesPolygon2D::Class_Version) ), 0);
16236 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_836_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesPolygon2D::Dictionary) ), 0);
16237 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16238 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16239 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16240 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_836_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16241 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_836_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::DeclFileName) ), 0);
16242 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_836_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPolygon2D::ImplFileLine) ), 0);
16243 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_836_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::ImplFileName) ), 0);
16244 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_836_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPolygon2D::DeclFileLine) ), 0);
16245 // automatic copy constructor
16246 G__memfunc_setup("BesPolygon2D", 1144, G__BesVisLib_rootcint_836_0_37, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 1, 1, 1, 0, "u 'BesPolygon2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
16247 // automatic destructor
16248 G__memfunc_setup("~BesPolygon2D", 1270, G__BesVisLib_rootcint_836_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16249 // automatic assignment operator
16250 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_836_0_39, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 1, 1, 1, 1, 0, "u 'BesPolygon2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
16251 G__tag_memfunc_reset();
16252}
16253
16254static void G__setup_memfuncMdc2DWire(void) {
16255 /* Mdc2DWire */
16256 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
16257 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16258 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 7, 1, 1, 0,
16259"C - - 10 - name C - - 10 - title "
16260"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
16261"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi "
16262"D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 0);
16263 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 4, 1, 1, 0,
16264"C - - 10 - name C - - 10 - title "
16265"i - 'Int_t' 0 - N D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
16266 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_837_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16267 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_837_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16268 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16269"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16270 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16271"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16272"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16273 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_837_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16274 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_837_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16275 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_837_0_10, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16276 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_837_0_11, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16277 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_837_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16278 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_837_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16279 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_837_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16280 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16281 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16282 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16283"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16284 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_837_0_18, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16285 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_837_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16286 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_837_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
16287 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_837_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
16288 G__memfunc_setup("SetColorfulWire",1545,G__BesVisLib_rootcint_837_0_22, 121, -1, -1, 0, 2, 1, 1, 0,
16289"g - 'Bool_t' 0 - colorfulWire g - 'Bool_t' 0 - subEvTime", (char*)NULL, (void*) NULL, 0);
16290 G__memfunc_setup("SetQOverflow",1233,G__BesVisLib_rootcint_837_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - qOvfl", (char*)NULL, (void*) NULL, 0);
16291 G__memfunc_setup("SetEvTime",886,G__BesVisLib_rootcint_837_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
16292 G__memfunc_setup("SetTimeChannel",1396,G__BesVisLib_rootcint_837_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - tc", (char*)NULL, (void*) NULL, 0);
16293 G__memfunc_setup("SetChargeChannel",1583,G__BesVisLib_rootcint_837_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - cc", (char*)NULL, (void*) NULL, 0);
16294 G__memfunc_setup("GetTime",687,G__BesVisLib_rootcint_837_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16295 G__memfunc_setup("GetCharge",874,G__BesVisLib_rootcint_837_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16296 G__memfunc_setup("GetEvTime",874,G__BesVisLib_rootcint_837_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16297 G__memfunc_setup("GetQOverflow",1221,G__BesVisLib_rootcint_837_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16298 G__memfunc_setup("GetTimeChannel",1384,G__BesVisLib_rootcint_837_0_31, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16299 G__memfunc_setup("GetChargeChannel",1571,G__BesVisLib_rootcint_837_0_32, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16300 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_837_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Mdc2DWire::Class) ), 0);
16301 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_837_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::Class_Name) ), 0);
16302 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_837_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Mdc2DWire::Class_Version) ), 0);
16303 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_837_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Mdc2DWire::Dictionary) ), 0);
16304 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16305 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16306 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16307 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_837_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16308 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_837_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::DeclFileName) ), 0);
16309 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_837_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Mdc2DWire::ImplFileLine) ), 0);
16310 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_837_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::ImplFileName) ), 0);
16311 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_837_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Mdc2DWire::DeclFileLine) ), 0);
16312 // automatic copy constructor
16313 G__memfunc_setup("Mdc2DWire", 801, G__BesVisLib_rootcint_837_0_45, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 1, 1, 1, 0, "u 'Mdc2DWire' - 11 - -", (char*) NULL, (void*) NULL, 0);
16314 // automatic destructor
16315 G__memfunc_setup("~Mdc2DWire", 927, G__BesVisLib_rootcint_837_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16316 // automatic assignment operator
16317 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_837_0_47, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 1, 1, 1, 1, 0, "u 'Mdc2DWire' - 11 - -", (char*) NULL, (void*) NULL, 0);
16318 G__tag_memfunc_reset();
16319}
16320
16321static void G__setup_memfuncMdcROOTGeo(void) {
16322 /* MdcROOTGeo */
16323 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
16324 G__memfunc_setup("MdcROOTGeo",883,G__BesVisLib_rootcint_838_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '0' cgem_flag", (char*)NULL, (void*) NULL, 0);
16325 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_838_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16326"C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16327 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_838_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16328 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_838_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16329 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_838_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16330 G__memfunc_setup("CorrectReplica",1426,G__BesVisLib_rootcint_838_0_6, 105, -1, -1, 0, 2, 1, 1, 0,
16331"i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
16332 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_838_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16333 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_838_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16334 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_838_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16335 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_838_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16336 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_838_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16337 G__memfunc_setup("SetPhysicalDefaultVis",2144,G__BesVisLib_rootcint_838_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun' update: Remove annotation", (void*) NULL, 0);
16338 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_838_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16339 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_838_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16340 G__memfunc_setup("SetTFire",774,G__BesVisLib_rootcint_838_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16341 G__memfunc_setup("SetQFire",771,G__BesVisLib_rootcint_838_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16342 G__memfunc_setup("SetQNotOverflow",1538,G__BesVisLib_rootcint_838_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16343 G__memfunc_setup("SetColorfulWire",1545,G__BesVisLib_rootcint_838_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16344 G__memfunc_setup("SetMdcTimeSubEvTime",1859,G__BesVisLib_rootcint_838_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16345 G__memfunc_setup("SetVisMdcDetector",1708,G__BesVisLib_rootcint_838_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16346 G__memfunc_setup("SetVisMdcHits",1290,G__BesVisLib_rootcint_838_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16347 G__memfunc_setup("GetSegmentNb",1187,G__BesVisLib_rootcint_838_0_22, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16348 G__memfunc_setup("GetLayerNb",973,G__BesVisLib_rootcint_838_0_23, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16349 G__memfunc_setup("GetReplicaNb",1168,G__BesVisLib_rootcint_838_0_24, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16350 G__memfunc_setup("SetVolumeMdc",1208,G__BesVisLib_rootcint_838_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16351 G__memfunc_setup("GetVolumeMdc",1196,G__BesVisLib_rootcint_838_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16352 G__memfunc_setup("GetVolumeSegment",1643,G__BesVisLib_rootcint_838_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
16353 G__memfunc_setup("GetVolumeLayer",1429,G__BesVisLib_rootcint_838_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16354 G__memfunc_setup("GetVolumeReplica",1624,G__BesVisLib_rootcint_838_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16355 G__memfunc_setup("GetSegment",1011,G__BesVisLib_rootcint_838_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16356"i - - 0 - segment i - - 0 - no", (char*)NULL, (void*) NULL, 0);
16357 G__memfunc_setup("GetLayer",797,G__BesVisLib_rootcint_838_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16358 G__memfunc_setup("GetReplica",992,G__BesVisLib_rootcint_838_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16359"i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
16360 G__memfunc_setup("GetPhysicalSegment",1840,G__BesVisLib_rootcint_838_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
16361 G__memfunc_setup("GetPhysicalReplica",1821,G__BesVisLib_rootcint_838_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 2, 1, 1, 0,
16362"i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
16363 G__memfunc_setup("Get2DWire",813,G__BesVisLib_rootcint_838_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 2, 1, 1, 0,
16364"i - 'Int_t' 0 - layer i - 'Int_t' 0 - replica", (char*)NULL, (void*) NULL, 0);
16365 G__memfunc_setup("GetSimuLayer",1211,G__BesVisLib_rootcint_838_0_36, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trueLayer", (char*)NULL, (void*) NULL, 0);
16366 G__memfunc_setup("IsHit",481,G__BesVisLib_rootcint_838_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
16367"i - 'Int_t' 0 - layer i - 'Int_t' 0 - wire", (char*)NULL, (void*) NULL, 0);
16368 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_838_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16369 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_838_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16370 // automatic copy constructor
16371 G__memfunc_setup("MdcROOTGeo", 883, G__BesVisLib_rootcint_838_0_40, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 1, 1, 1, 0, "u 'MdcROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16372 // automatic destructor
16373 G__memfunc_setup("~MdcROOTGeo", 1009, G__BesVisLib_rootcint_838_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16374 G__tag_memfunc_reset();
16375}
16376
16377static void G__setup_memfuncTof2DScin(void) {
16378 /* Tof2DScin */
16379 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
16380 G__memfunc_setup("Tof2DScin",812,G__BesVisLib_rootcint_839_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16381 G__memfunc_setup("Tof2DScin",812,G__BesVisLib_rootcint_839_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 5, 1, 1, 0,
16382"C - - 10 - name C - - 10 - title "
16383"i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
16384"i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
16385 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_839_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16386 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16387"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16388 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16389"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16390"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16391 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_839_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16392 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_839_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16393 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_839_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16394 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_839_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16395 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_839_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16396 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_839_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16397 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_839_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16398 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_839_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 1);
16399 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_839_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
16400 G__memfunc_setup("GetTime",687,G__BesVisLib_rootcint_839_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16401 G__memfunc_setup("GetCharge",874,G__BesVisLib_rootcint_839_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16402 G__memfunc_setup("ResetTimeCharge",1500,G__BesVisLib_rootcint_839_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16403 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16404 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16405 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16406"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16407 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_839_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16408 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_839_0_22, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16409 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_839_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
16410"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
16411 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_839_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16412 G__memfunc_setup("SetTimeChannel",1396,G__BesVisLib_rootcint_839_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - tc", (char*)NULL, (void*) NULL, 0);
16413 G__memfunc_setup("SetChargeChannel",1583,G__BesVisLib_rootcint_839_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - cc", (char*)NULL, (void*) NULL, 0);
16414 G__memfunc_setup("GetTimeChannel",1384,G__BesVisLib_rootcint_839_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16415 G__memfunc_setup("GetChargeChannel",1571,G__BesVisLib_rootcint_839_0_28, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16416 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_839_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Tof2DScin::Class) ), 0);
16417 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_839_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::Class_Name) ), 0);
16418 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_839_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Tof2DScin::Class_Version) ), 0);
16419 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_839_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Tof2DScin::Dictionary) ), 0);
16420 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16421 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16422 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16423 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_839_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16424 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_839_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::DeclFileName) ), 0);
16425 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_839_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Tof2DScin::ImplFileLine) ), 0);
16426 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_839_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::ImplFileName) ), 0);
16427 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_839_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Tof2DScin::DeclFileLine) ), 0);
16428 // automatic copy constructor
16429 G__memfunc_setup("Tof2DScin", 812, G__BesVisLib_rootcint_839_0_41, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 1, 1, 1, 0, "u 'Tof2DScin' - 11 - -", (char*) NULL, (void*) NULL, 0);
16430 // automatic destructor
16431 G__memfunc_setup("~Tof2DScin", 938, G__BesVisLib_rootcint_839_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16432 // automatic assignment operator
16433 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_839_0_43, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 1, 1, 1, 1, 0, "u 'Tof2DScin' - 11 - -", (char*) NULL, (void*) NULL, 0);
16434 G__tag_memfunc_reset();
16435}
16436
16437static void G__setup_memfuncTofROOTGeo(void) {
16438 /* TofROOTGeo */
16439 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
16440 G__memfunc_setup("TofROOTGeo",904,G__BesVisLib_rootcint_840_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16441 G__memfunc_setup("GetMrpc",690,G__BesVisLib_rootcint_840_0_2, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16442 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_840_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
16443"C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16444 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_840_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16445 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_840_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16446 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_840_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16447 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_840_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16448 G__memfunc_setup("SetPhysicalDefaultVis",2144,G__BesVisLib_rootcint_840_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16449 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_840_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16450 G__memfunc_setup("SetTMatch",877,G__BesVisLib_rootcint_840_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16451 G__memfunc_setup("SetQMatch",874,G__BesVisLib_rootcint_840_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16452 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_840_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16453 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_840_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16454 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_840_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16455 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_840_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16456 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_840_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16457 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_840_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16458 G__memfunc_setup("SetVisTofDetector",1729,G__BesVisLib_rootcint_840_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16459 G__memfunc_setup("SetVisTofHits",1311,G__BesVisLib_rootcint_840_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16460 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_840_0_20, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16461 G__memfunc_setup("GetScinNb",861,G__BesVisLib_rootcint_840_0_21, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16462 G__memfunc_setup("GetLayerNb",973,G__BesVisLib_rootcint_840_0_22, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16463 G__memfunc_setup("GetModuleNb",1078,G__BesVisLib_rootcint_840_0_23, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16464 G__memfunc_setup("GetStripNb",994,G__BesVisLib_rootcint_840_0_24, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16465 G__memfunc_setup("GetChamberNodeNb",1544,G__BesVisLib_rootcint_840_0_25, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16466 G__memfunc_setup("GetContainerNodeNb",1785,G__BesVisLib_rootcint_840_0_26, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16467 G__memfunc_setup("GetBoard1NodeNb",1391,G__BesVisLib_rootcint_840_0_27, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16468 G__memfunc_setup("SetVolumeTof",1229,G__BesVisLib_rootcint_840_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16469 G__memfunc_setup("GetVolumeTof",1217,G__BesVisLib_rootcint_840_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16470 G__memfunc_setup("GetVolumePart",1327,G__BesVisLib_rootcint_840_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16471 G__memfunc_setup("GetVolumePVF",1156,G__BesVisLib_rootcint_840_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16472"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16473 G__memfunc_setup("GetVolumeAl",1093,G__BesVisLib_rootcint_840_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16474"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16475 G__memfunc_setup("GetVolumeScin",1317,G__BesVisLib_rootcint_840_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16476"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16477 G__memfunc_setup("GetVolumeBucket",1526,G__BesVisLib_rootcint_840_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16478"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16479 G__memfunc_setup("GetPVF",524,G__BesVisLib_rootcint_840_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16480"i - - 0 - part i - - 0 - layer "
16481"i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
16482 G__memfunc_setup("GetAl",461,G__BesVisLib_rootcint_840_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16483"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16484 G__memfunc_setup("GetScin",685,G__BesVisLib_rootcint_840_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16485"i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16486 G__memfunc_setup("GetModule",902,G__BesVisLib_rootcint_840_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16487"i - - 0 - part i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16488 G__memfunc_setup("GetStrip",818,G__BesVisLib_rootcint_840_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16489"i - - 0 - part i - - 0 - module "
16490"i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16491 G__memfunc_setup("GetgasContainer",1534,G__BesVisLib_rootcint_840_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16492"i - - 0 - part i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16493 G__memfunc_setup("GetbareChamber",1388,G__BesVisLib_rootcint_840_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16494"i - - 0 - part i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16495 G__memfunc_setup("GetpcbBoard1",1134,G__BesVisLib_rootcint_840_0_42, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16496"i - - 0 - part i - - 0 - module", (char*)NULL, (void*) NULL, 0);
16497 G__memfunc_setup("GetPhysicalScin",1514,G__BesVisLib_rootcint_840_0_43, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16498"i - - 0 - part i - - 0 - layer "
16499"i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
16500 G__memfunc_setup("Get2DScin",803,G__BesVisLib_rootcint_840_0_44, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 3, 1, 1, 0,
16501"i - 'Int_t' 0 - part i - 'Int_t' 0 - layer "
16502"i - 'Int_t' 0 - scin", (char*)NULL, (void*) NULL, 0);
16503 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_840_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
16504 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_840_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16505 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_840_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16506 // automatic copy constructor
16507 G__memfunc_setup("TofROOTGeo", 904, G__BesVisLib_rootcint_840_0_48, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 1, 1, 1, 0, "u 'TofROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16508 // automatic destructor
16509 G__memfunc_setup("~TofROOTGeo", 1030, G__BesVisLib_rootcint_840_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16510 G__tag_memfunc_reset();
16511}
16512
16513static void G__setup_memfuncEmc2DCrystal(void) {
16514 /* Emc2DCrystal */
16515 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
16516 G__memfunc_setup("Emc2DCrystal",1133,G__BesVisLib_rootcint_841_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16517 G__memfunc_setup("Emc2DCrystal",1133,G__BesVisLib_rootcint_841_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 6, 1, 1, 0,
16518"C - - 10 - name C - - 10 - title "
16519"i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
16520"i - 'Int_t' 0 - part i - 'Int_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
16521 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_841_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16522 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16523"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16524 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16525"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16526"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16527 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_841_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16528 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_841_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16529 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_841_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16530 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_841_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16531 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_841_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16532 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_841_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16533 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_841_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16534 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_841_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 1);
16535 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_841_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
16536 G__memfunc_setup("GetTime",687,G__BesVisLib_rootcint_841_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16537 G__memfunc_setup("GetCharge",874,G__BesVisLib_rootcint_841_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16538 G__memfunc_setup("ResetTimeCharge",1500,G__BesVisLib_rootcint_841_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16539 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16540 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16541 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16542"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16543 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_841_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16544 G__memfunc_setup("GetTheta",790,G__BesVisLib_rootcint_841_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16545 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_841_0_23, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16546 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_841_0_24, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
16547"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
16548 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_841_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16549 G__memfunc_setup("IsXYVisible",1083,G__BesVisLib_rootcint_841_0_26, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16550 G__memfunc_setup("IsSideVisible",1295,G__BesVisLib_rootcint_841_0_27, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16551 G__memfunc_setup("SetXYPoint",999,G__BesVisLib_rootcint_841_0_28, 121, -1, -1, 0, 4, 1, 1, 0,
16552"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2 "
16553"D - 'Double_t' 0 - newP d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
16554 G__memfunc_setup("SetZRPoint",994,G__BesVisLib_rootcint_841_0_29, 121, -1, -1, 0, 4, 1, 1, 0,
16555"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2 "
16556"D - 'Double_t' 0 - newP d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 1);
16557 G__memfunc_setup("ProjectECToSide",1447,G__BesVisLib_rootcint_841_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
16558"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - newP", (char*)NULL, (void*) NULL, 1);
16559 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_841_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Emc2DCrystal::Class) ), 0);
16560 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_841_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::Class_Name) ), 0);
16561 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_841_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Emc2DCrystal::Class_Version) ), 0);
16562 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_841_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Emc2DCrystal::Dictionary) ), 0);
16563 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16564 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16565 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16566 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_841_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16567 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_841_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::DeclFileName) ), 0);
16568 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_841_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Emc2DCrystal::ImplFileLine) ), 0);
16569 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_841_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::ImplFileName) ), 0);
16570 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_841_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Emc2DCrystal::DeclFileLine) ), 0);
16571 // automatic copy constructor
16572 G__memfunc_setup("Emc2DCrystal", 1133, G__BesVisLib_rootcint_841_0_43, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 1, 1, 1, 0, "u 'Emc2DCrystal' - 11 - -", (char*) NULL, (void*) NULL, 0);
16573 // automatic destructor
16574 G__memfunc_setup("~Emc2DCrystal", 1259, G__BesVisLib_rootcint_841_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16575 // automatic assignment operator
16576 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_841_0_45, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 1, 1, 1, 1, 0, "u 'Emc2DCrystal' - 11 - -", (char*) NULL, (void*) NULL, 0);
16577 G__tag_memfunc_reset();
16578}
16579
16580static void G__setup_memfuncEmcROOTGeo(void) {
16581 /* EmcROOTGeo */
16582 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
16583 G__memfunc_setup("EmcROOTGeo",884,G__BesVisLib_rootcint_842_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16584 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_842_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16585"C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16586 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_842_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16587 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_842_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16588 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_842_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16589 G__memfunc_setup("SetVolumeAppendInVis",2021,G__BesVisLib_rootcint_842_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16590 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_842_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16591 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_842_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16592 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_842_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16593 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_842_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16594 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_842_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16595 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_842_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16596 G__memfunc_setup("SetPhysicalDefaultVis",2144,G__BesVisLib_rootcint_842_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun's update: Remove annotation", (void*) NULL, 0);
16597 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_842_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16598 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_842_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16599 G__memfunc_setup("SetVisEmcDetector",1709,G__BesVisLib_rootcint_842_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16600 G__memfunc_setup("SetVisEmcHits",1291,G__BesVisLib_rootcint_842_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16601 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_842_0_18, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16602 G__memfunc_setup("GetThetaNb",966,G__BesVisLib_rootcint_842_0_19, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16603 G__memfunc_setup("GetPhiNb",753,G__BesVisLib_rootcint_842_0_20, 105, -1, -1, 0, 2, 1, 1, 0,
16604"i - - 0 - part i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16605 G__memfunc_setup("SetVolumeEmc",1209,G__BesVisLib_rootcint_842_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16606 G__memfunc_setup("GetVolumeEmc",1197,G__BesVisLib_rootcint_842_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16607 G__memfunc_setup("GetVolumePart",1327,G__BesVisLib_rootcint_842_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16608 G__memfunc_setup("GetVolumePhi",1209,G__BesVisLib_rootcint_842_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16609"i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16610 G__memfunc_setup("GetVolumeTheta",1422,G__BesVisLib_rootcint_842_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16611"i - - 0 - part i - - 0 - phi "
16612"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16613 G__memfunc_setup("GetVolumeCrystal",1658,G__BesVisLib_rootcint_842_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16614"i - - 0 - part i - - 0 - phi "
16615"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16616 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_842_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16617 G__memfunc_setup("GetPhi",577,G__BesVisLib_rootcint_842_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16618"i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16619 G__memfunc_setup("GetTheta",790,G__BesVisLib_rootcint_842_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16620"i - - 0 - part i - - 0 - phi "
16621"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16622 G__memfunc_setup("GetTheta2",840,G__BesVisLib_rootcint_842_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16623"i - - 0 - part i - - 0 - phi "
16624"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16625 G__memfunc_setup("GetCrystal",1026,G__BesVisLib_rootcint_842_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16626"i - - 0 - part i - - 0 - phi "
16627"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16628 G__memfunc_setup("GetCrystal2",1076,G__BesVisLib_rootcint_842_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16629"i - - 0 - part i - - 0 - phi "
16630"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16631 G__memfunc_setup("GetPhysicalCrystal",1855,G__BesVisLib_rootcint_842_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16632"i - - 0 - part i - - 0 - phi "
16633"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16634 G__memfunc_setup("GetPhysicalCrystal2",1905,G__BesVisLib_rootcint_842_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16635"i - - 0 - part i - - 0 - phi "
16636"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16637 G__memfunc_setup("HasTwoNodes",1103,G__BesVisLib_rootcint_842_0_35, 103, -1, -1, 0, 3, 1, 1, 0,
16638"i - - 0 - part i - - 0 - phi "
16639"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16640 G__memfunc_setup("ComputeThetaPhi",1524,G__BesVisLib_rootcint_842_0_36, 121, -1, -1, 0, 5, 1, 1, 0,
16641"i - - 0 - id i - - 0 - sector "
16642"i - - 0 - nb i - - 1 - CryNumberTheta "
16643"i - - 1 - CryNumberPhi", (char*)NULL, (void*) NULL, 0);
16644 G__memfunc_setup("ComputeEndCopyNb",1599,G__BesVisLib_rootcint_842_0_37, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - num", (char*)NULL, (void*) NULL, 0);
16645 G__memfunc_setup("Get2DCrystal",1144,G__BesVisLib_rootcint_842_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 3, 1, 1, 0,
16646"i - 'Int_t' 0 - part i - 'Int_t' 0 - phi "
16647"i - 'Int_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
16648 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_842_0_39, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
16649 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_842_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16650 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_842_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16651 G__memfunc_setup("Align",491,G__BesVisLib_rootcint_842_0_42, 121, -1, -1, 0, 4, 1, 1, 0,
16652"U 'TGeoPhysicalNode' - 0 - phyNode U 'TGeoMatrix' - 0 '0' newmat "
16653"U 'TGeoShape' - 0 '0' newshape g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
16654 G__memfunc_setup("RestorePhyNode",1435,G__BesVisLib_rootcint_842_0_43, 121, -1, -1, 0, 2, 1, 1, 0,
16655"U 'TGeoPhysicalNode' - 0 - phyNode U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
16656 // automatic copy constructor
16657 G__memfunc_setup("EmcROOTGeo", 884, G__BesVisLib_rootcint_842_0_44, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 1, 1, 1, 0, "u 'EmcROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16658 // automatic destructor
16659 G__memfunc_setup("~EmcROOTGeo", 1010, G__BesVisLib_rootcint_842_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16660 G__tag_memfunc_reset();
16661}
16662
16663static void G__setup_memfuncMuc2DStrip(void) {
16664 /* Muc2DStrip */
16665 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
16666 G__memfunc_setup("Muc2DStrip",941,G__BesVisLib_rootcint_843_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16667 G__memfunc_setup("Muc2DStrip",941,G__BesVisLib_rootcint_843_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 8, 1, 1, 0,
16668"C - - 10 - name C - - 10 - title "
16669"i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
16670"i - 'Int_t' 0 - part i - 'Int_t' 0 - seg "
16671"i - 'Int_t' 0 - gap i - 'Int_t' 0 - strip", (char*)NULL, (void*) NULL, 0);
16672 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_843_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16673 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16674"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16675 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16676"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16677"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16678 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_843_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16679 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_843_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16680 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_843_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16681 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_843_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16682 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_843_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16683 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_843_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16684 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_843_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16685 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16686 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16687 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16688"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16689 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_843_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16690 G__memfunc_setup("GetSeg",575,G__BesVisLib_rootcint_843_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16691 G__memfunc_setup("GetGap",568,G__BesVisLib_rootcint_843_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16692 G__memfunc_setup("GetStrip",818,G__BesVisLib_rootcint_843_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16693 G__memfunc_setup("IsZRVisible",1078,G__BesVisLib_rootcint_843_0_20, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16694 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_843_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
16695"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
16696 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_843_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16697 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_843_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Muc2DStrip::Class) ), 0);
16698 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_843_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::Class_Name) ), 0);
16699 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_843_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Muc2DStrip::Class_Version) ), 0);
16700 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_843_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Muc2DStrip::Dictionary) ), 0);
16701 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16702 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16703 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16704 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_843_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16705 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_843_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::DeclFileName) ), 0);
16706 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_843_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Muc2DStrip::ImplFileLine) ), 0);
16707 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_843_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::ImplFileName) ), 0);
16708 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_843_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Muc2DStrip::DeclFileLine) ), 0);
16709 // automatic copy constructor
16710 G__memfunc_setup("Muc2DStrip", 941, G__BesVisLib_rootcint_843_0_35, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 1, 1, 1, 0, "u 'Muc2DStrip' - 11 - -", (char*) NULL, (void*) NULL, 0);
16711 // automatic destructor
16712 G__memfunc_setup("~Muc2DStrip", 1067, G__BesVisLib_rootcint_843_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16713 // automatic assignment operator
16714 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_843_0_37, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 1, 1, 1, 1, 0, "u 'Muc2DStrip' - 11 - -", (char*) NULL, (void*) NULL, 0);
16715 G__tag_memfunc_reset();
16716}
16717
16718static void G__setup_memfuncMucROOTGeo(void) {
16719 /* MucROOTGeo */
16720 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
16721 G__memfunc_setup("MucROOTGeo",900,G__BesVisLib_rootcint_844_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16722 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_844_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16723"C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16724 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_844_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16725 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_844_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16726 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_844_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16727 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_844_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16728 G__memfunc_setup("SetPhysicalDefaultVis",2144,G__BesVisLib_rootcint_844_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16729 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_844_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16730 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_844_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16731 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_844_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16732 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_844_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16733 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_844_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16734 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_844_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16735 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_844_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16736 G__memfunc_setup("SetVisMucDetector",1725,G__BesVisLib_rootcint_844_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16737 G__memfunc_setup("SetVisMucHits",1307,G__BesVisLib_rootcint_844_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16738 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_844_0_17, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16739 G__memfunc_setup("GetSegNb",751,G__BesVisLib_rootcint_844_0_18, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16740 G__memfunc_setup("GetGapNb",744,G__BesVisLib_rootcint_844_0_19, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16741 G__memfunc_setup("GetStripNb",994,G__BesVisLib_rootcint_844_0_20, 105, -1, -1, 0, 3, 1, 1, 0,
16742"i - - 0 - part i - - 0 - seg "
16743"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16744 G__memfunc_setup("GetAbsorberNb",1280,G__BesVisLib_rootcint_844_0_21, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16745 G__memfunc_setup("SetVolumeMuc",1225,G__BesVisLib_rootcint_844_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16746 G__memfunc_setup("GetVolumeMuc",1213,G__BesVisLib_rootcint_844_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16747 G__memfunc_setup("GetVolumeAbsorber",1736,G__BesVisLib_rootcint_844_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16748"i - - 0 - part i - - 0 - seg "
16749"i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16750 G__memfunc_setup("GetVolumeAbsorberSmallBlock",2732,G__BesVisLib_rootcint_844_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16751"i - - 0 - gap i - - 0 - sb", (char*)NULL, (void*) NULL, 0);
16752 G__memfunc_setup("GetVolumeAbsorberPanel",2232,G__BesVisLib_rootcint_844_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16753"i - - 0 - part i - - 0 - seg "
16754"i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16755 G__memfunc_setup("GetVolumeGap",1200,G__BesVisLib_rootcint_844_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16756"i - - 0 - part i - - 0 - seg "
16757"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16758 G__memfunc_setup("GetVolumeBox",1217,G__BesVisLib_rootcint_844_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16759"i - - 0 - part i - - 0 - seg "
16760"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16761 G__memfunc_setup("GetVolumeBoxSurface",1930,G__BesVisLib_rootcint_844_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16762"i - - 0 - part i - - 0 - seg "
16763"i - - 0 - gap i - - 0 - up", (char*)NULL, (void*) NULL, 0);
16764 G__memfunc_setup("GetVolumeStripPlane",1946,G__BesVisLib_rootcint_844_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16765"i - - 0 - part i - - 0 - seg "
16766"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16767 G__memfunc_setup("GetVolumeStrip",1450,G__BesVisLib_rootcint_844_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16768"i - - 0 - part i - - 0 - seg "
16769"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16770 G__memfunc_setup("GetVolumeGasChamber",1893,G__BesVisLib_rootcint_844_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16771"i - - 0 - part i - - 0 - seg "
16772"i - - 0 - gap i - - 0 - panel "
16773"i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16774 G__memfunc_setup("GetVolumeGasBorder",1809,G__BesVisLib_rootcint_844_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16775"i - - 0 - part i - - 0 - seg "
16776"i - - 0 - gap i - - 0 - panel "
16777"i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16778 G__memfunc_setup("GetVolumeBakelite",1721,G__BesVisLib_rootcint_844_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 6, 1, 1, 0,
16779"i - - 0 - part i - - 0 - seg "
16780"i - - 0 - gap i - - 0 - RpcUpDown "
16781"i - - 0 - panel i - - 0 - bakelite", (char*)NULL, (void*) NULL, 0);
16782 G__memfunc_setup("GetAbsorber",1104,G__BesVisLib_rootcint_844_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16783"i - - 0 - part i - - 0 - seg "
16784"i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16785 G__memfunc_setup("GetAbsorberPanel",1600,G__BesVisLib_rootcint_844_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 4, 1, 1, 0,
16786"i - - 0 - part i - - 0 - seg "
16787"i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16788 G__memfunc_setup("GetGap",568,G__BesVisLib_rootcint_844_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16789"i - - 0 - part i - - 0 - seg "
16790"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16791 G__memfunc_setup("GetStripPlane",1314,G__BesVisLib_rootcint_844_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16792"i - - 0 - part i - - 0 - seg "
16793"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16794 G__memfunc_setup("GetStrip",818,G__BesVisLib_rootcint_844_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 4, 1, 1, 0,
16795"i - - 0 - part i - - 0 - seg "
16796"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16797 G__memfunc_setup("GetPhysicalAbsorber",1933,G__BesVisLib_rootcint_844_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16798"i - - 0 - part i - - 0 - seg "
16799"i - - 0 - gap i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16800 G__memfunc_setup("GetPhysicalGap",1397,G__BesVisLib_rootcint_844_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16801"i - - 0 - part i - - 0 - seg "
16802"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16803 G__memfunc_setup("GetPhysicalStrip",1647,G__BesVisLib_rootcint_844_0_42, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16804"i - - 0 - part i - - 0 - seg "
16805"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16806 G__memfunc_setup("Get2DStrip",936,G__BesVisLib_rootcint_844_0_43, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 4, 1, 1, 0,
16807"i - - 0 - part i - - 0 - seg "
16808"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16809 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_844_0_44, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
16810 G__memfunc_setup("IsZRVisible",1078,G__BesVisLib_rootcint_844_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
16811"i - - 0 - part i - - 0 - seg", (char*)NULL, (void*) NULL, 0);
16812 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_844_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16813 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_844_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16814 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_844_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16815 // automatic copy constructor
16816 G__memfunc_setup("MucROOTGeo", 900, G__BesVisLib_rootcint_844_0_49, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 1, 1, 1, 0, "u 'MucROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16817 // automatic destructor
16818 G__memfunc_setup("~MucROOTGeo", 1026, G__BesVisLib_rootcint_844_0_50, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16819 G__tag_memfunc_reset();
16820}
16821
16822static void G__setup_memfuncBesGeometry(void) {
16823 /* BesGeometry */
16824 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
16825 G__memfunc_setup("BesGeometry",1126,G__BesVisLib_rootcint_845_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16826 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_845_0_2, 121, -1, -1, 0, 3, 1, 1, 0,
16827"u 'TString' - 10 - fPath g - - 0 'false' mrpc "
16828"g - - 0 'false' cgem", (char*)NULL, (void*) NULL, 1);
16829 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_845_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volBes", (char*)NULL, (void*) NULL, 1);
16830 G__memfunc_setup("InitGeometry",1248,G__BesVisLib_rootcint_845_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16831 G__memfunc_setup("GetFilename",1089,G__BesVisLib_rootcint_845_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - RunPeriod", (char*)NULL, (void*) NULL, 0);
16832 G__memfunc_setup("SetDefaultVis",1315,G__BesVisLib_rootcint_845_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16833 G__memfunc_setup("SetPhysicalDefaultVis",2144,G__BesVisLib_rootcint_845_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun's update: Reset 3D color", (void*) NULL, 1);
16834 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
16835 G__memfunc_setup("Draw3D",517,G__BesVisLib_rootcint_845_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16836 G__memfunc_setup("Draw2DXY",693,G__BesVisLib_rootcint_845_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16837 G__memfunc_setup("Draw2DZR",688,G__BesVisLib_rootcint_845_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16838 G__memfunc_setup("GetBesR",652,G__BesVisLib_rootcint_845_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16839 G__memfunc_setup("GetBesZ",660,G__BesVisLib_rootcint_845_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16840 G__memfunc_setup("GetVolBes",875,G__BesVisLib_rootcint_845_0_14, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16841 G__memfunc_setup("GetVolumeBeamPipe",1691,G__BesVisLib_rootcint_845_0_15, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16842 G__memfunc_setup("GetMdcROOTGeo",1171,G__BesVisLib_rootcint_845_0_16, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16843 G__memfunc_setup("GetTofROOTGeo",1192,G__BesVisLib_rootcint_845_0_17, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16844 G__memfunc_setup("GetEmcROOTGeo",1172,G__BesVisLib_rootcint_845_0_18, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16845 G__memfunc_setup("GetMucROOTGeo",1188,G__BesVisLib_rootcint_845_0_19, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16846 G__memfunc_setup("GetVolumeMdc",1196,G__BesVisLib_rootcint_845_0_20, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16847 G__memfunc_setup("GetVolumeMdcSegment",1919,G__BesVisLib_rootcint_845_0_21, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
16848 G__memfunc_setup("GetVolumeMdcLayer",1705,G__BesVisLib_rootcint_845_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16849 G__memfunc_setup("GetVolumeMdcReplica",1900,G__BesVisLib_rootcint_845_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16850 G__memfunc_setup("GetPhysicalMdcReplica",2097,G__BesVisLib_rootcint_845_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 2, 1, 1, 0,
16851"i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
16852 G__memfunc_setup("GetVolumeTof",1217,G__BesVisLib_rootcint_845_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16853 G__memfunc_setup("GetPhysicalTofScin",1811,G__BesVisLib_rootcint_845_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16854"i - - 0 - part i - - 0 - layer "
16855"i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
16856 G__memfunc_setup("GetVolumeEmc",1197,G__BesVisLib_rootcint_845_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16857 G__memfunc_setup("GetVolumeEmcPart",1604,G__BesVisLib_rootcint_845_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16858 G__memfunc_setup("GetVolumeEmcPhi",1486,G__BesVisLib_rootcint_845_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16859"i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16860 G__memfunc_setup("GetVolumeEmcTheta",1699,G__BesVisLib_rootcint_845_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16861"i - - 0 - part i - - 0 - phi "
16862"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16863 G__memfunc_setup("GetVolumeEmcCrystal",1935,G__BesVisLib_rootcint_845_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16864"i - - 0 - part i - - 0 - phi "
16865"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16866 G__memfunc_setup("GetPhysicalEmcCrystal",2132,G__BesVisLib_rootcint_845_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16867"i - - 0 - part i - - 0 - phi "
16868"i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16869 G__memfunc_setup("GetVolumeMuc",1213,G__BesVisLib_rootcint_845_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16870 G__memfunc_setup("GetVolumeMucAbsorber",2029,G__BesVisLib_rootcint_845_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16871"i - - 0 - part i - - 0 - seg "
16872"i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16873 G__memfunc_setup("GetVolumeMucAbsorberPanel",2525,G__BesVisLib_rootcint_845_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16874"i - - 0 - part i - - 0 - seg "
16875"i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16876 G__memfunc_setup("GetVolumeMucGap",1493,G__BesVisLib_rootcint_845_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16877"i - - 0 - part i - - 0 - seg "
16878"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16879 G__memfunc_setup("GetVolumeMucStripPlane",2239,G__BesVisLib_rootcint_845_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16880"i - - 0 - part i - - 0 - seg "
16881"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16882 G__memfunc_setup("GetVolumeMucStrip",1743,G__BesVisLib_rootcint_845_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16883"i - - 0 - part i - - 0 - seg "
16884"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16885 G__memfunc_setup("GetVolumeMucGasChamber",2186,G__BesVisLib_rootcint_845_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16886"i - - 0 - part i - - 0 - seg "
16887"i - - 0 - gap i - - 0 - panel "
16888"i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16889 G__memfunc_setup("GetVolumeMucBakelite",2014,G__BesVisLib_rootcint_845_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 6, 1, 1, 0,
16890"i - - 0 - part i - - 0 - seg "
16891"i - - 0 - gap i - - 0 - RpcUpDown "
16892"i - - 0 - panel i - - 0 - bakelite", (char*)NULL, (void*) NULL, 0);
16893 G__memfunc_setup("GetPhysicalMucGap",1690,G__BesVisLib_rootcint_845_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16894"i - - 0 - part i - - 0 - seg "
16895"i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16896 G__memfunc_setup("GetPhysicalMucStrip",1940,G__BesVisLib_rootcint_845_0_42, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16897"i - - 0 - part i - - 0 - seg "
16898"i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16899 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_845_0_43, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGeometry::Class) ), 0);
16900 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_845_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::Class_Name) ), 0);
16901 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_845_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGeometry::Class_Version) ), 0);
16902 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_845_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGeometry::Dictionary) ), 0);
16903 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16904 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16905 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16906 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_845_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16907 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_845_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::DeclFileName) ), 0);
16908 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_845_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeometry::ImplFileLine) ), 0);
16909 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_845_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::ImplFileName) ), 0);
16910 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_845_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeometry::DeclFileLine) ), 0);
16911 // automatic copy constructor
16912 G__memfunc_setup("BesGeometry", 1126, G__BesVisLib_rootcint_845_0_55, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 1, 1, 1, 0, "u 'BesGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
16913 // automatic destructor
16914 G__memfunc_setup("~BesGeometry", 1252, G__BesVisLib_rootcint_845_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16915 // automatic assignment operator
16916 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_845_0_57, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 1, 1, 1, 1, 0, "u 'BesGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
16917 G__tag_memfunc_reset();
16918}
16919
16920static void G__setup_memfuncBesGMenuTitle(void) {
16921 /* BesGMenuTitle */
16922 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
16923 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
16924 G__memfunc_setup("BesGMenuTitle",1272,G__BesVisLib_rootcint_925_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle), -1, 0, 6, 1, 1, 0,
16925"U 'TGWindow' - 10 '0' p U 'TGHotString' - 0 '0' s "
16926"U 'TGPopupMenu' - 0 '0' menu k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16927"k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
16928 G__memfunc_setup("SetPicture",1032,G__BesVisLib_rootcint_925_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pic", (char*)NULL, (void*) NULL, 1);
16929 G__memfunc_setup("SetPictureHL",1180,G__BesVisLib_rootcint_925_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pic", (char*)NULL, (void*) NULL, 1);
16930 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_925_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGMenuTitle::Class) ), 0);
16931 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_925_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::Class_Name) ), 0);
16932 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_925_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGMenuTitle::Class_Version) ), 0);
16933 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_925_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGMenuTitle::Dictionary) ), 0);
16934 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16935 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16936 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16937 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_925_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16938 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_925_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::DeclFileName) ), 0);
16939 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_925_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuTitle::ImplFileLine) ), 0);
16940 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_925_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::ImplFileName) ), 0);
16941 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_925_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuTitle::DeclFileLine) ), 0);
16942 // automatic destructor
16943 G__memfunc_setup("~BesGMenuTitle", 1398, G__BesVisLib_rootcint_925_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16944 G__tag_memfunc_reset();
16945}
16946
16947static void G__setup_memfuncBesGMenuBar(void) {
16948 /* BesGMenuBar */
16949 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
16950 G__memfunc_setup("AddFrameBefore",1351,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
16951"U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l "
16952"U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16953 G__memfunc_setup("BesGMenuBar",1035,G__BesVisLib_rootcint_926_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar), -1, 0, 4, 1, 1, 0,
16954"U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '60' w "
16955"h - 'UInt_t' 0 '20' h h - 'UInt_t' 0 'kHorizontalFrame|kRaisedFrame' options", (char*)NULL, (void*) NULL, 0);
16956 G__memfunc_setup("AddPopup",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16957"U 'TGHotString' - 0 - s U 'TGPopupMenu' - 0 - menu "
16958"U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16959 G__memfunc_setup("AddPopup",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16960"C - - 10 - s U 'TGPopupMenu' - 0 - menu "
16961"U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16962 G__memfunc_setup("GetMenuTitle",1207,G__BesVisLib_rootcint_926_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16963 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_926_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGMenuBar::Class) ), 0);
16964 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_926_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::Class_Name) ), 0);
16965 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_926_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGMenuBar::Class_Version) ), 0);
16966 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_926_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGMenuBar::Dictionary) ), 0);
16967 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16968 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16969 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16970 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_926_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16971 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_926_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::DeclFileName) ), 0);
16972 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_926_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuBar::ImplFileLine) ), 0);
16973 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_926_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::ImplFileName) ), 0);
16974 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_926_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuBar::DeclFileLine) ), 0);
16975 // automatic destructor
16976 G__memfunc_setup("~BesGMenuBar", 1161, G__BesVisLib_rootcint_926_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16977 G__tag_memfunc_reset();
16978}
16979
16980static void G__setup_memfuncBesGPictureButton(void) {
16981 /* BesGPictureButton */
16982 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
16983 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 5, 1, 1, 0,
16984"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
16985"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16986"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16987 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 6, 1, 1, 0,
16988"U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
16989"C - - 10 - cmd i - 'Int_t' 0 '-1' id "
16990"k - 'GContext_t' 0 'GetDefaultGC()()' norm h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16991 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 5, 1, 1, 0,
16992"U 'TGWindow' - 10 '0' p C - - 10 '0' pic "
16993"i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16994"h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16995 G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
16996 G__memfunc_setup("IsStateOn",890,G__BesVisLib_rootcint_934_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16997 G__memfunc_setup("SetState",813,G__BesVisLib_rootcint_934_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
16998 G__memfunc_setup("SetPicture",1032,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - new_pic", (char*)NULL, (void*) NULL, 1);
16999 G__memfunc_setup("SetPictureHL",1180,G__BesVisLib_rootcint_934_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - hl_pic", (char*)NULL, (void*) NULL, 1);
17000 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_934_0_9, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGPictureButton::Class) ), 0);
17001 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_934_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::Class_Name) ), 0);
17002 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_934_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGPictureButton::Class_Version) ), 0);
17003 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_934_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGPictureButton::Dictionary) ), 0);
17004 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17005 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
17006 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
17007 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_934_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
17008 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_934_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::DeclFileName) ), 0);
17009 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_934_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGPictureButton::ImplFileLine) ), 0);
17010 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_934_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::ImplFileName) ), 0);
17011 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_934_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGPictureButton::DeclFileLine) ), 0);
17012 // automatic destructor
17013 G__memfunc_setup("~BesGPictureButton", 1847, G__BesVisLib_rootcint_934_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
17014 G__tag_memfunc_reset();
17015}
17016
17017static void G__setup_memfuncBesHeader(void) {
17018 /* BesHeader */
17019 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
17020 G__memfunc_setup("BesHeader",867,G__BesVisLib_rootcint_935_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17021 G__memfunc_setup("BesHeader",867,G__BesVisLib_rootcint_935_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader), -1, 0, 5, 1, 1, 0,
17022"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
17023"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
17024"C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
17025 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
17026"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
17027 G__memfunc_setup("SetMdcOn",765,G__BesVisLib_rootcint_935_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mdcOn", "*TOGGLE*", (void*) NULL, 0);
17028 G__memfunc_setup("GetMdcOn",753,G__BesVisLib_rootcint_935_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17029 G__memfunc_setup("TransferMdcOn",1302,G__BesVisLib_rootcint_935_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
17030 G__memfunc_setup("SetTofOn",786,G__BesVisLib_rootcint_935_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - tofOn", "*TOGGLE*", (void*) NULL, 0);
17031 G__memfunc_setup("GetTofOn",774,G__BesVisLib_rootcint_935_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17032 G__memfunc_setup("TransferTofOn",1323,G__BesVisLib_rootcint_935_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
17033 G__memfunc_setup("SetEmcOn",766,G__BesVisLib_rootcint_935_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - emcOn", "*TOGGLE*", (void*) NULL, 0);
17034 G__memfunc_setup("GetEmcOn",754,G__BesVisLib_rootcint_935_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17035 G__memfunc_setup("TransferEmcOn",1303,G__BesVisLib_rootcint_935_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
17036 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17037 G__memfunc_setup("DeleteText",1016,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17038 G__memfunc_setup("EditText",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17039 G__memfunc_setup("InsertLine",1021,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17040 G__memfunc_setup("InsertText",1050,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
17041 G__memfunc_setup("ReadFile",764,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
17042"C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
17043"i - 'Int_t' 0 '50' nlines i - 'Int_t' 0 '0' fromline", (char*)NULL, (void*) NULL, 1);
17044 G__memfunc_setup("SetAllWith",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
17045"C - - 10 - text C - 'Option_t' 10 - option "
17046"d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
17047 G__memfunc_setup("SetLabel",780,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
17048 G__memfunc_setup("SetMargin",906,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.05' margin", (char*)NULL, (void*) NULL, 1);
17049 G__memfunc_setup("SetBorderSize",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '4' bordersize", (char*)NULL, (void*) NULL, 1);
17050 G__memfunc_setup("SetCornerRadius",1533,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.2' rad", (char*)NULL, (void*) NULL, 1);
17051 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
17052 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17053 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_935_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17054 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_935_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17055 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_935_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17056 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_935_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17057 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17058 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17059 G__memfunc_setup("SetFillAttributes",1754,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17060 G__memfunc_setup("SetTextAttributes",1784,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17061 G__memfunc_setup("SetTextAngle",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' tangle", (char*)NULL, (void*) NULL, 1);
17062 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_935_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesHeader::Class) ), 0);
17063 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_935_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::Class_Name) ), 0);
17064 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_935_0_37, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesHeader::Class_Version) ), 0);
17065 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_935_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesHeader::Dictionary) ), 0);
17066 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17067 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
17068 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
17069 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_935_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
17070 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_935_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::DeclFileName) ), 0);
17071 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_935_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesHeader::ImplFileLine) ), 0);
17072 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_935_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::ImplFileName) ), 0);
17073 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_935_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesHeader::DeclFileLine) ), 0);
17074 // automatic destructor
17075 G__memfunc_setup("~BesHeader", 993, G__BesVisLib_rootcint_935_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17076 G__tag_memfunc_reset();
17077}
17078
17079static void G__setup_memfuncBesVisDisplay(void) {
17080 /* BesVisDisplay */
17081 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
17082 G__memfunc_setup("BesVisDisplay",1314,G__BesVisLib_rootcint_957_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17083 G__memfunc_setup("BesVisDisplay",1314,G__BesVisLib_rootcint_957_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay), -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 0);
17084 G__memfunc_setup("SetCanvas",904,G__BesVisLib_rootcint_957_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 '0' c", (char*)NULL, (void*) NULL, 1);
17085 G__memfunc_setup("SetDisplayMode",1415,G__BesVisLib_rootcint_957_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
17086 G__memfunc_setup("GetDisplayMode",1403,G__BesVisLib_rootcint_957_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17087 G__memfunc_setup("IsVHeader",859,G__BesVisLib_rootcint_957_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17088 G__memfunc_setup("SwitchDisplayMode",1741,G__BesVisLib_rootcint_957_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
17089 G__memfunc_setup("ResizePad",903,G__BesVisLib_rootcint_957_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17090 G__memfunc_setup("SwitchPad",903,G__BesVisLib_rootcint_957_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17091 G__memfunc_setup("GetPadXY",742,G__BesVisLib_rootcint_957_0_10, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17092 G__memfunc_setup("GetPadZR",737,G__BesVisLib_rootcint_957_0_11, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17093 G__memfunc_setup("GetPad3D",684,G__BesVisLib_rootcint_957_0_12, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17094 G__memfunc_setup("DrawHeader",983,G__BesVisLib_rootcint_957_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17095 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_957_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17096 G__memfunc_setup("Refresh",719,G__BesVisLib_rootcint_957_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", "Long Peixun's update: Refresh views", (void*) NULL, 1);
17097 G__memfunc_setup("InitGeometryFromGDML",1944,G__BesVisLib_rootcint_957_0_16, 121, -1, -1, 0, 3, 1, 1, 0,
17098"u 'TString' - 10 - fPath g - - 0 'false' mrpc "
17099"g - - 0 'false' cgem", (char*)NULL, (void*) NULL, 1);
17100 G__memfunc_setup("InitGeometryFromROOT",1976,G__BesVisLib_rootcint_957_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - bes", (char*)NULL, (void*) NULL, 1);
17101 G__memfunc_setup("GetBesGeometry",1414,G__BesVisLib_rootcint_957_0_18, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17102 G__memfunc_setup("SetMdcOn",765,G__BesVisLib_rootcint_957_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - MdcOn", "*TOGGLE*", (void*) NULL, 1);
17103 G__memfunc_setup("GetMdcOn",753,G__BesVisLib_rootcint_957_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17104 G__memfunc_setup("SetTofOn",786,G__BesVisLib_rootcint_957_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - TofOn", "*TOGGLE*", (void*) NULL, 1);
17105 G__memfunc_setup("GetTofOn",774,G__BesVisLib_rootcint_957_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17106 G__memfunc_setup("SetEmcOn",766,G__BesVisLib_rootcint_957_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - EmcOn", "*TOGGLE*", (void*) NULL, 1);
17107 G__memfunc_setup("GetEmcOn",754,G__BesVisLib_rootcint_957_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17108 G__memfunc_setup("SetVisHeader",1191,G__BesVisLib_rootcint_957_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - val", (char*)NULL, (void*) NULL, 1);
17109 G__memfunc_setup("GetVisHeader",1179,G__BesVisLib_rootcint_957_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17110 G__memfunc_setup("AllViews",807,G__BesVisLib_rootcint_957_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17111 G__memfunc_setup("Clear",487,G__BesVisLib_rootcint_957_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17112 G__memfunc_setup("DisplayTrigger",1450,G__BesVisLib_rootcint_957_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trig", (char*)NULL, (void*) NULL, 1);
17113 G__memfunc_setup("DistancetoPrimitive",1991,G__BesVisLib_rootcint_957_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
17114"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
17115 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_957_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17116 G__memfunc_setup("Draw2D",516,G__BesVisLib_rootcint_957_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17117 G__memfunc_setup("Draw3D",517,G__BesVisLib_rootcint_957_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17118 G__memfunc_setup("Draw2DXY",693,G__BesVisLib_rootcint_957_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17119 G__memfunc_setup("Draw2DZR",688,G__BesVisLib_rootcint_957_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17120 G__memfunc_setup("DrawAllViews",1205,G__BesVisLib_rootcint_957_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17121 G__memfunc_setup("DrawClusters",1251,G__BesVisLib_rootcint_957_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17122 G__memfunc_setup("DrawParticles",1333,G__BesVisLib_rootcint_957_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17123 G__memfunc_setup("DrawParticles2",1383,G__BesVisLib_rootcint_957_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17124 G__memfunc_setup("DrawTitle",912,G__BesVisLib_rootcint_957_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17125 G__memfunc_setup("DrawView",809,G__BesVisLib_rootcint_957_0_41, 121, -1, -1, 0, 2, 1, 1, 0,
17126"f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
17127 G__memfunc_setup("DrawViewRange",1302,G__BesVisLib_rootcint_957_0_42, 121, -1, -1, 0, 4, 1, 1, 0,
17128"d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
17129"d - 'Double_t' 0 - z0 d - 'Double_t' 0 - zoomSize", (char*)NULL, (void*) NULL, 0);
17130 G__memfunc_setup("DrawViewGL",956,G__BesVisLib_rootcint_957_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17131 G__memfunc_setup("DrawViewX3D",1016,G__BesVisLib_rootcint_957_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17132 G__memfunc_setup("DrawViewRaytracer",1750,G__BesVisLib_rootcint_957_0_45, 121, -1, -1, 0, 3, 1, 1, 0,
17133"f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi "
17134"f - 'Float_t' 0 - psi", (char*)NULL, (void*) NULL, 1);
17135 G__memfunc_setup("DrawViewX3D",1016,G__BesVisLib_rootcint_957_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "c - - 0 - option", (char*)NULL, (void*) NULL, 1);
17136 G__memfunc_setup("DrawImageSequence",1706,G__BesVisLib_rootcint_957_0_47, 121, -1, -1, 0, 2, 1, 1, 0,
17137"i - 'Int_t' 0 - thetaStart i - 'Int_t' 0 - thetaStep", (char*)NULL, (void*) NULL, 0);
17138 G__memfunc_setup("ExecuteEvent",1237,G__BesVisLib_rootcint_957_0_48, 121, -1, -1, 0, 3, 1, 1, 0,
17139"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
17140"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
17141 G__memfunc_setup("GetEvent",802,G__BesVisLib_rootcint_957_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - event", "*MENU*", (void*) NULL, 1);
17142 G__memfunc_setup("GetVolBes",875,G__BesVisLib_rootcint_957_0_50, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17143 G__memfunc_setup("GetMdcROOTGeo",1171,G__BesVisLib_rootcint_957_0_51, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17144 G__memfunc_setup("GetTofROOTGeo",1192,G__BesVisLib_rootcint_957_0_52, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17145 G__memfunc_setup("GetEmcROOTGeo",1172,G__BesVisLib_rootcint_957_0_53, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17146 G__memfunc_setup("GetMucROOTGeo",1188,G__BesVisLib_rootcint_957_0_54, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17147 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_957_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17148 G__memfunc_setup("Pad",277,G__BesVisLib_rootcint_957_0_56, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17149 G__memfunc_setup("Paint",508,G__BesVisLib_rootcint_957_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17150 G__memfunc_setup("PaintFruit",1030,G__BesVisLib_rootcint_957_0_58, 121, -1, -1, 0, 6, 1, 1, 0,
17151"U 'TObject' - 0 - obj f - 'Float_t' 0 - eta "
17152"f - 'Float_t' 0 - phi f - 'Float_t' 0 - pt "
17153"i - 'Int_t' 0 - type C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17154 G__memfunc_setup("PaintParticles",1443,G__BesVisLib_rootcint_957_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17155 G__memfunc_setup("PTcut",496,G__BesVisLib_rootcint_957_0_60, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17156 G__memfunc_setup("PTcutEGMUNU",961,G__BesVisLib_rootcint_957_0_61, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17157 G__memfunc_setup("Rin",297,G__BesVisLib_rootcint_957_0_62, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17158 G__memfunc_setup("Rout",426,G__BesVisLib_rootcint_957_0_63, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17159 G__memfunc_setup("SetDrawClusters",1551,G__BesVisLib_rootcint_957_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' draw", "*MENU*", (void*) NULL, 1);
17160 G__memfunc_setup("SetDrawParticles",1633,G__BesVisLib_rootcint_957_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' draw", "*MENU*", (void*) NULL, 1);
17161 G__memfunc_setup("SetPTcut",796,G__BesVisLib_rootcint_957_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.4' ptcut", "*MENU*", (void*) NULL, 1);
17162 G__memfunc_setup("SetPTcutEGMUNU",1261,G__BesVisLib_rootcint_957_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '5' ptcut", "*MENU*", (void*) NULL, 1);
17163 G__memfunc_setup("SetView",711,G__BesVisLib_rootcint_957_0_68, 121, -1, -1, 0, 2, 1, 1, 0,
17164"f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
17165 G__memfunc_setup("ShowNextEvent",1346,G__BesVisLib_rootcint_957_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' delta", (char*)NULL, (void*) NULL, 1);
17166 G__memfunc_setup("SetMdcCon",864,G__BesVisLib_rootcint_957_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mdcCon", (char*)NULL, (void*) NULL, 0);
17167 G__memfunc_setup("SetTofCon",885,G__BesVisLib_rootcint_957_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofCon", (char*)NULL, (void*) NULL, 0);
17168 G__memfunc_setup("SetEmcCon",865,G__BesVisLib_rootcint_957_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - emcCon", (char*)NULL, (void*) NULL, 0);
17169 G__memfunc_setup("SetMucCon",881,G__BesVisLib_rootcint_957_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mucCon", (char*)NULL, (void*) NULL, 0);
17170 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_957_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
17171 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_957_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
17172 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_957_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
17173 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_957_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
17174 G__memfunc_setup("SetMdcFiredCell",1450,G__BesVisLib_rootcint_957_0_78, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17175 G__memfunc_setup("SetTofFiredCell",1471,G__BesVisLib_rootcint_957_0_79, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17176 G__memfunc_setup("SetEmcFiredCell",1451,G__BesVisLib_rootcint_957_0_80, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17177 G__memfunc_setup("SetMucFiredCell",1467,G__BesVisLib_rootcint_957_0_81, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17178 G__memfunc_setup("SizeFruit",933,G__BesVisLib_rootcint_957_0_82, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17179 G__memfunc_setup("SizeParticles",1346,G__BesVisLib_rootcint_957_0_83, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17180 G__memfunc_setup("Zin",305,G__BesVisLib_rootcint_957_0_84, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17181 G__memfunc_setup("Zout",434,G__BesVisLib_rootcint_957_0_85, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17182 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_957_0_86, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesVisDisplay::Class) ), 0);
17183 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_957_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::Class_Name) ), 0);
17184 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_957_0_88, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesVisDisplay::Class_Version) ), 0);
17185 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_957_0_89, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesVisDisplay::Dictionary) ), 0);
17186 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17187 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
17188 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
17189 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_957_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
17190 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_957_0_94, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::DeclFileName) ), 0);
17191 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_957_0_95, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesVisDisplay::ImplFileLine) ), 0);
17192 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_957_0_96, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::ImplFileName) ), 0);
17193 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_957_0_97, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesVisDisplay::DeclFileLine) ), 0);
17194 // automatic destructor
17195 G__memfunc_setup("~BesVisDisplay", 1440, G__BesVisLib_rootcint_957_0_98, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17196 G__tag_memfunc_reset();
17197}
17198
17199static void G__setup_memfuncZHelix(void) {
17200 /* ZHelix */
17201 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
17202 G__memfunc_setup("ZHelix",596,G__BesVisLib_rootcint_960_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17203 G__memfunc_setup("ZHelix",596,G__BesVisLib_rootcint_960_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 14, 1, 1, 0,
17204"d - 'Double_t' 0 - Azim d - 'Double_t' 0 - QovR "
17205"d - 'Double_t' 0 - QxDh d - 'Double_t' 0 - refx "
17206"d - 'Double_t' 0 - refy d - 'Double_t' 0 - refz "
17207"d - 'Double_t' 0 - TDip d - 'Double_t' 0 - phii "
17208"d - 'Double_t' 0 - phio f - 'Float_t' 0 - Chi2 "
17209"i - 'Int_t' 0 - NDoF i 'EZHelixRangeType' - 0 'kHelixPhi' RangeType "
17210"d - 'Double_t' 0 '0' RangeMin d - 'Double_t' 0 '2*TMath::Pi()' RangeMax", (char*)NULL, (void*) NULL, 0);
17211 G__memfunc_setup("Phi2XYZ",606,G__BesVisLib_rootcint_960_0_3, 121, -1, -1, 0, 4, 1, 1, 0,
17212"d - 'Double_t' 0 - phi d - 'Double_t' 1 - x "
17213"d - 'Double_t' 1 - y d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 0);
17214 G__memfunc_setup("Phi2ZR",511,G__BesVisLib_rootcint_960_0_4, 121, -1, -1, 0, 3, 1, 1, 0,
17215"d - 'Double_t' 0 - phi d - 'Double_t' 1 - z "
17216"d - 'Double_t' 1 - r", (char*)NULL, (void*) NULL, 0);
17217 G__memfunc_setup("SetRange",793,G__BesVisLib_rootcint_960_0_5, 121, -1, -1, 0, 3, 1, 1, 0,
17218"i 'EZHelixRangeType' - 0 - RangeType d - 'Double_t' 0 - RangeMin "
17219"d - 'Double_t' 0 - RangeMax", (char*)NULL, (void*) NULL, 0);
17220 G__memfunc_setup("SetTrackType",1219,G__BesVisLib_rootcint_960_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TrackType' - 0 - tt", (char*)NULL, (void*) NULL, 0);
17221 G__memfunc_setup("SetPoints",937,G__BesVisLib_rootcint_960_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
17222 G__memfunc_setup("X2Phi",427,G__BesVisLib_rootcint_960_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
17223 G__memfunc_setup("Y2Phi",428,G__BesVisLib_rootcint_960_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
17224 G__memfunc_setup("Z2Phi",429,G__BesVisLib_rootcint_960_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
17225 G__memfunc_setup("R2Phi",421,G__BesVisLib_rootcint_960_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
17226 G__memfunc_setup("Phi2S",422,G__BesVisLib_rootcint_960_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
17227 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
17228 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
17229 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
17230 G__memfunc_setup("SetNextPoint",1237,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
17231"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
17232"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
17233 G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
17234"i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
17235"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
17236 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
17237 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_960_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17238 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_960_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
17239 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
17240 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
17241"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
17242"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
17243 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_960_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ZHelix::Class) ), 0);
17244 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_960_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::Class_Name) ), 0);
17245 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_960_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ZHelix::Class_Version) ), 0);
17246 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_960_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ZHelix::Dictionary) ), 0);
17247 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17248 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
17249 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
17250 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_960_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
17251 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_960_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::DeclFileName) ), 0);
17252 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_960_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ZHelix::ImplFileLine) ), 0);
17253 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_960_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::ImplFileName) ), 0);
17254 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_960_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ZHelix::DeclFileLine) ), 0);
17255 // automatic copy constructor
17256 G__memfunc_setup("ZHelix", 596, G__BesVisLib_rootcint_960_0_35, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 1, 1, 1, 0, "u 'ZHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
17257 // automatic destructor
17258 G__memfunc_setup("~ZHelix", 722, G__BesVisLib_rootcint_960_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17259 // automatic assignment operator
17260 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_960_0_37, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 1, 1, 1, 1, 0, "u 'ZHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
17261 G__tag_memfunc_reset();
17262}
17263
17264static void G__setup_memfuncvector3(void) {
17265 /* vector3 */
17266 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
17267 // automatic default constructor
17268 G__memfunc_setup("vector3", 710, G__BesVisLib_rootcint_961_0_1, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
17269 // automatic copy constructor
17270 G__memfunc_setup("vector3", 710, G__BesVisLib_rootcint_961_0_2, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 0, 1, 1, 1, 0, "u 'vector3' - 11 - -", (char*) NULL, (void*) NULL, 0);
17271 // automatic destructor
17272 G__memfunc_setup("~vector3", 836, G__BesVisLib_rootcint_961_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
17273 // automatic assignment operator
17274 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_961_0_4, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 1, 1, 1, 1, 0, "u 'vector3' - 11 - -", (char*) NULL, (void*) NULL, 0);
17275 G__tag_memfunc_reset();
17276}
17277
17278
17279/*********************************************************
17280* Member function information setup
17281*********************************************************/
17282extern "C" void G__cpp_setup_memfuncBesVisLib_rootcint() {
17283}
17284
17285/*********************************************************
17286* Global variable information setup for each class
17287*********************************************************/
17288static void G__cpp_setup_global0() {
17289
17290 /* Setting up global variables */
17291 G__resetplocal();
17292
17293}
17294
17295static void G__cpp_setup_global1() {
17296}
17297
17298static void G__cpp_setup_global2() {
17299}
17300
17301static void G__cpp_setup_global3() {
17302}
17303
17304static void G__cpp_setup_global4() {
17305}
17306
17307static void G__cpp_setup_global5() {
17308}
17309
17310static void G__cpp_setup_global6() {
17311}
17312
17313static void G__cpp_setup_global7() {
17314}
17315
17316static void G__cpp_setup_global8() {
17317
17318 G__resetglobalenv();
17319}
17320extern "C" void G__cpp_setup_globalBesVisLib_rootcint() {
17321 G__cpp_setup_global0();
17322 G__cpp_setup_global1();
17323 G__cpp_setup_global2();
17324 G__cpp_setup_global3();
17325 G__cpp_setup_global4();
17326 G__cpp_setup_global5();
17327 G__cpp_setup_global6();
17328 G__cpp_setup_global7();
17329 G__cpp_setup_global8();
17330}
17331
17332/*********************************************************
17333* Global function information setup for each class
17334*********************************************************/
17335static void G__cpp_setup_func0() {
17336 G__lastifuncposition();
17337
17338}
17339
17340static void G__cpp_setup_func1() {
17341}
17342
17343static void G__cpp_setup_func2() {
17344}
17345
17346static void G__cpp_setup_func3() {
17347}
17348
17349static void G__cpp_setup_func4() {
17350}
17351
17352static void G__cpp_setup_func5() {
17353}
17354
17355static void G__cpp_setup_func6() {
17356}
17357
17358static void G__cpp_setup_func7() {
17359}
17360
17361static void G__cpp_setup_func8() {
17362}
17363
17364static void G__cpp_setup_func9() {
17365}
17366
17367static void G__cpp_setup_func10() {
17368}
17369
17370static void G__cpp_setup_func11() {
17371}
17372
17373static void G__cpp_setup_func12() {
17374}
17375
17376static void G__cpp_setup_func13() {
17377}
17378
17379static void G__cpp_setup_func14() {
17380}
17381
17382static void G__cpp_setup_func15() {
17383}
17384
17385static void G__cpp_setup_func16() {
17386}
17387
17388static void G__cpp_setup_func17() {
17389}
17390
17391static void G__cpp_setup_func18() {
17392}
17393
17394static void G__cpp_setup_func19() {
17395}
17396
17397static void G__cpp_setup_func20() {
17398}
17399
17400static void G__cpp_setup_func21() {
17401}
17402
17403static void G__cpp_setup_func22() {
17404}
17405
17406static void G__cpp_setup_func23() {
17407}
17408
17409static void G__cpp_setup_func24() {
17410
17411 G__resetifuncposition();
17412}
17413
17414extern "C" void G__cpp_setup_funcBesVisLib_rootcint() {
17415 G__cpp_setup_func0();
17416 G__cpp_setup_func1();
17417 G__cpp_setup_func2();
17418 G__cpp_setup_func3();
17419 G__cpp_setup_func4();
17420 G__cpp_setup_func5();
17421 G__cpp_setup_func6();
17422 G__cpp_setup_func7();
17423 G__cpp_setup_func8();
17424 G__cpp_setup_func9();
17425 G__cpp_setup_func10();
17426 G__cpp_setup_func11();
17427 G__cpp_setup_func12();
17428 G__cpp_setup_func13();
17429 G__cpp_setup_func14();
17430 G__cpp_setup_func15();
17431 G__cpp_setup_func16();
17432 G__cpp_setup_func17();
17433 G__cpp_setup_func18();
17434 G__cpp_setup_func19();
17435 G__cpp_setup_func20();
17436 G__cpp_setup_func21();
17437 G__cpp_setup_func22();
17438 G__cpp_setup_func23();
17439 G__cpp_setup_func24();
17440}
17441
17442/*********************************************************
17443* Class,struct,union,enum tag information setup
17444*********************************************************/
17445/* Setup class/struct taginfo */
17446G__linked_taginfo G__BesVisLib_rootcintLN_TClass = { "TClass" , 99 , -1 };
17447G__linked_taginfo G__BesVisLib_rootcintLN_TBuffer = { "TBuffer" , 99 , -1 };
17448G__linked_taginfo G__BesVisLib_rootcintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
17449G__linked_taginfo G__BesVisLib_rootcintLN_TObject = { "TObject" , 99 , -1 };
17450G__linked_taginfo G__BesVisLib_rootcintLN_TNamed = { "TNamed" , 99 , -1 };
17451G__linked_taginfo G__BesVisLib_rootcintLN_TString = { "TString" , 99 , -1 };
17452G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
17453G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
17454G__linked_taginfo G__BesVisLib_rootcintLN_string = { "string" , 99 , -1 };
17455G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
17456G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
17457G__linked_taginfo G__BesVisLib_rootcintLN_TList = { "TList" , 99 , -1 };
17458G__linked_taginfo G__BesVisLib_rootcintLN_TObjArray = { "TObjArray" , 99 , -1 };
17459G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
17460G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
17461G__linked_taginfo G__BesVisLib_rootcintLN_EBESViewType = { "EBESViewType" , 101 , -1 };
17462G__linked_taginfo G__BesVisLib_rootcintLN_BesStatus = { "BesStatus" , 99 , -1 };
17463G__linked_taginfo G__BesVisLib_rootcintLN_TAttLine = { "TAttLine" , 99 , -1 };
17464G__linked_taginfo G__BesVisLib_rootcintLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
17465G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
17466G__linked_taginfo G__BesVisLib_rootcintLN_TView = { "TView" , 99 , -1 };
17467G__linked_taginfo G__BesVisLib_rootcintLN_BesTView = { "BesTView" , 99 , -1 };
17468G__linked_taginfo G__BesVisLib_rootcintLN_BesTViewcLcLdA = { "BesTView::$" , 101 , -1 };
17469G__linked_taginfo G__BesVisLib_rootcintLN_TPaveLabel = { "TPaveLabel" , 99 , -1 };
17470G__linked_taginfo G__BesVisLib_rootcintLN_TPad = { "TPad" , 99 , -1 };
17471G__linked_taginfo G__BesVisLib_rootcintLN_TCanvas = { "TCanvas" , 99 , -1 };
17472G__linked_taginfo G__BesVisLib_rootcintLN_Bes2DView = { "Bes2DView" , 99 , -1 };
17473G__linked_taginfo G__BesVisLib_rootcintLN_TAttFill = { "TAttFill" , 99 , -1 };
17474G__linked_taginfo G__BesVisLib_rootcintLN_BesCircle2D = { "BesCircle2D" , 99 , -1 };
17475G__linked_taginfo G__BesVisLib_rootcintLN_EBESCursorType = { "EBESCursorType" , 101 , -1 };
17476G__linked_taginfo G__BesVisLib_rootcintLN_BesCursor = { "BesCursor" , 99 , -1 };
17477G__linked_taginfo G__BesVisLib_rootcintLN_BesEventHeader = { "BesEventHeader" , 99 , -1 };
17478G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
17479G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
17480G__linked_taginfo G__BesVisLib_rootcintLN_TBox = { "TBox" , 99 , -1 };
17481G__linked_taginfo G__BesVisLib_rootcintLN_TPave = { "TPave" , 99 , -1 };
17482G__linked_taginfo G__BesVisLib_rootcintLN_TAttText = { "TAttText" , 99 , -1 };
17483G__linked_taginfo G__BesVisLib_rootcintLN_TPaveText = { "TPaveText" , 99 , -1 };
17484G__linked_taginfo G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
17485G__linked_taginfo G__BesVisLib_rootcintLN_TGeoAtt = { "TGeoAtt" , 99 , -1 };
17486G__linked_taginfo G__BesVisLib_rootcintLN_TAttMarker = { "TAttMarker" , 99 , -1 };
17487G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualGeoTrack = { "TVirtualGeoTrack" , 99 , -1 };
17488G__linked_taginfo G__BesVisLib_rootcintLN_TAtt3D = { "TAtt3D" , 99 , -1 };
17489G__linked_taginfo G__BesVisLib_rootcintLN_TPolyLine3D = { "TPolyLine3D" , 99 , -1 };
17490G__linked_taginfo G__BesVisLib_rootcintLN_TGeoTrack = { "TGeoTrack" , 99 , -1 };
17491G__linked_taginfo G__BesVisLib_rootcintLN_TMarker = { "TMarker" , 99 , -1 };
17492G__linked_taginfo G__BesVisLib_rootcintLN_BesView = { "BesView" , 99 , -1 };
17493G__linked_taginfo G__BesVisLib_rootcintLN_BesMarker2D = { "BesMarker2D" , 99 , -1 };
17494G__linked_taginfo G__BesVisLib_rootcintLN_BesPaveText = { "BesPaveText" , 99 , -1 };
17495G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
17496G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
17497G__linked_taginfo G__BesVisLib_rootcintLN_BesGeoTrack = { "BesGeoTrack" , 99 , -1 };
17498G__linked_taginfo G__BesVisLib_rootcintLN_TMdcDigi = { "TMdcDigi" , 99 , -1 };
17499G__linked_taginfo G__BesVisLib_rootcintLN_TEmcDigi = { "TEmcDigi" , 99 , -1 };
17500G__linked_taginfo G__BesVisLib_rootcintLN_TTofDigi = { "TTofDigi" , 99 , -1 };
17501G__linked_taginfo G__BesVisLib_rootcintLN_TMucDigi = { "TMucDigi" , 99 , -1 };
17502G__linked_taginfo G__BesVisLib_rootcintLN_TDigiEvent = { "TDigiEvent" , 99 , -1 };
17503G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcTrack = { "TRecMdcTrack" , 99 , -1 };
17504G__linked_taginfo G__BesVisLib_rootcintLN_TRecTofTrack = { "TRecTofTrack" , 99 , -1 };
17505G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "map<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
17506G__linked_taginfo G__BesVisLib_rootcintLN_TRecEmcShower = { "TRecEmcShower" , 99 , -1 };
17507G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
17508G__linked_taginfo G__BesVisLib_rootcintLN_TRecMucTrack = { "TRecMucTrack" , 99 , -1 };
17509G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcDedx = { "TRecMdcDedx" , 99 , -1 };
17510G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
17511G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
17512G__linked_taginfo G__BesVisLib_rootcintLN_TRecEvTime = { "TRecEvTime" , 99 , -1 };
17513G__linked_taginfo G__BesVisLib_rootcintLN_pairlEintcOfloatgR = { "pair<int,float>" , 115 , -1 };
17514G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR = { "vector<pair<int,float>,allocator<pair<int,float> > >" , 99 , -1 };
17515G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,float>,allocator<pair<int,float> > >::iterator>" , 99 , -1 };
17516G__linked_taginfo G__BesVisLib_rootcintLN_TEvtHeader = { "TEvtHeader" , 99 , -1 };
17517G__linked_taginfo G__BesVisLib_rootcintLN_TDisTrack = { "TDisTrack" , 99 , -1 };
17518G__linked_taginfo G__BesVisLib_rootcintLN_TTrigEvent = { "TTrigEvent" , 99 , -1 };
17519G__linked_taginfo G__BesVisLib_rootcintLN_BesEvent = { "BesEvent" , 99 , -1 };
17520G__linked_taginfo G__BesVisLib_rootcintLN_Event_t = { "Event_t" , 115 , -1 };
17521G__linked_taginfo G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
17522G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
17523G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator>" , 99 , -1 };
17524G__linked_taginfo G__BesVisLib_rootcintLN_TQObject = { "TQObject" , 99 , -1 };
17525G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >" , 99 , -1 };
17526G__linked_taginfo G__BesVisLib_rootcintLN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
17527G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
17528G__linked_taginfo G__BesVisLib_rootcintLN_TGeoShape = { "TGeoShape" , 99 , -1 };
17529G__linked_taginfo G__BesVisLib_rootcintLN_TGeoNode = { "TGeoNode" , 99 , -1 };
17530G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolumeAssembly = { "TGeoVolumeAssembly" , 99 , -1 };
17531G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR = { "vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >" , 99 , -1 };
17532G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >::iterator>" , 99 , -1 };
17533G__linked_taginfo G__BesVisLib_rootcintLN_TGeoPhysicalNode = { "TGeoPhysicalNode" , 99 , -1 };
17534G__linked_taginfo G__BesVisLib_rootcintLN_ProcessingConfigurator = { "ProcessingConfigurator" , 99 , -1 };
17535G__linked_taginfo G__BesVisLib_rootcintLN_SAXProcessor = { "SAXProcessor" , 99 , -1 };
17536G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR = { "vector<ContentGroup::ContentItem,allocator<ContentGroup::ContentItem> >" , 99 , -1 };
17537G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ContentGroup::ContentItem,allocator<ContentGroup::ContentItem> >::iterator>" , 99 , -1 };
17538G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR = { "vector<ContentChoice*,allocator<ContentChoice*> >" , 99 , -1 };
17539G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ContentChoice*,allocator<ContentChoice*> >::iterator>" , 99 , -1 };
17540G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR = { "map<string,define::constant,less<string>,allocator<pair<const string,define::constant> > >" , 99 , -1 };
17541G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR = { "map<string,define::quantity,less<string>,allocator<pair<const string,define::quantity> > >" , 99 , -1 };
17542G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR = { "map<string,define::expression,less<string>,allocator<pair<const string,define::expression> > >" , 99 , -1 };
17543G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR = { "map<string,define::position,less<string>,allocator<pair<const string,define::position> > >" , 99 , -1 };
17544G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR = { "map<string,define::rotation,less<string>,allocator<pair<const string,define::rotation> > >" , 99 , -1 };
17545G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR = { "map<string,TGeoTranslation*,less<string>,allocator<pair<const string,TGeoTranslation*> > >" , 99 , -1 };
17546G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR = { "map<string,TGeoRotation*,less<string>,allocator<pair<const string,TGeoRotation*> > >" , 99 , -1 };
17547G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR = { "map<string,TGeoShape*,less<string>,allocator<pair<const string,TGeoShape*> > >" , 99 , -1 };
17548G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR = { "map<string,TGeoVolume*,less<string>,allocator<pair<const string,TGeoVolume*> > >" , 99 , -1 };
17549G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR = { "map<string,TGeoVolumeAssembly*,less<string>,allocator<pair<const string,TGeoVolumeAssembly*> > >" , 99 , -1 };
17550G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR = { "map<string,TGeoNode*,less<string>,allocator<pair<const string,TGeoNode*> > >" , 99 , -1 };
17551G__linked_taginfo G__BesVisLib_rootcintLN_SubDetectorROOTGeo = { "SubDetectorROOTGeo" , 99 , -1 };
17552G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
17553G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
17554G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
17555G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
17556G__linked_taginfo G__BesVisLib_rootcintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
17557G__linked_taginfo G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
17558G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
17559G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
17560G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
17561G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
17562G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
17563G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
17564G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
17565G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
17566G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
17567G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
17568G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
17569G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
17570G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
17571G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
17572G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
17573G__linked_taginfo G__BesVisLib_rootcintLN_BesPolygon2D = { "BesPolygon2D" , 99 , -1 };
17574G__linked_taginfo G__BesVisLib_rootcintLN_Mdc2DWire = { "Mdc2DWire" , 99 , -1 };
17575G__linked_taginfo G__BesVisLib_rootcintLN_MdcROOTGeo = { "MdcROOTGeo" , 99 , -1 };
17576G__linked_taginfo G__BesVisLib_rootcintLN_Tof2DScin = { "Tof2DScin" , 99 , -1 };
17577G__linked_taginfo G__BesVisLib_rootcintLN_TofROOTGeo = { "TofROOTGeo" , 99 , -1 };
17578G__linked_taginfo G__BesVisLib_rootcintLN_Emc2DCrystal = { "Emc2DCrystal" , 99 , -1 };
17579G__linked_taginfo G__BesVisLib_rootcintLN_EmcROOTGeo = { "EmcROOTGeo" , 99 , -1 };
17580G__linked_taginfo G__BesVisLib_rootcintLN_Muc2DStrip = { "Muc2DStrip" , 99 , -1 };
17581G__linked_taginfo G__BesVisLib_rootcintLN_MucROOTGeo = { "MucROOTGeo" , 99 , -1 };
17582G__linked_taginfo G__BesVisLib_rootcintLN_BesGeometry = { "BesGeometry" , 99 , -1 };
17583G__linked_taginfo G__BesVisLib_rootcintLN_TGObject = { "TGObject" , 99 , -1 };
17584G__linked_taginfo G__BesVisLib_rootcintLN_TGWindow = { "TGWindow" , 99 , -1 };
17585G__linked_taginfo G__BesVisLib_rootcintLN_TGPicture = { "TGPicture" , 99 , -1 };
17586G__linked_taginfo G__BesVisLib_rootcintLN_TGFrame = { "TGFrame" , 99 , -1 };
17587G__linked_taginfo G__BesVisLib_rootcintLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
17588G__linked_taginfo G__BesVisLib_rootcintLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
17589G__linked_taginfo G__BesVisLib_rootcintLN_TGHotString = { "TGHotString" , 99 , -1 };
17590G__linked_taginfo G__BesVisLib_rootcintLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
17591G__linked_taginfo G__BesVisLib_rootcintLN_TGWidget = { "TGWidget" , 99 , -1 };
17592G__linked_taginfo G__BesVisLib_rootcintLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
17593G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
17594G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuTitle = { "TGMenuTitle" , 99 , -1 };
17595G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuTitle = { "BesGMenuTitle" , 99 , -1 };
17596G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuBar = { "BesGMenuBar" , 99 , -1 };
17597G__linked_taginfo G__BesVisLib_rootcintLN_TGButton = { "TGButton" , 99 , -1 };
17598G__linked_taginfo G__BesVisLib_rootcintLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
17599G__linked_taginfo G__BesVisLib_rootcintLN_BesGPictureButton = { "BesGPictureButton" , 99 , -1 };
17600G__linked_taginfo G__BesVisLib_rootcintLN_BesHeader = { "BesHeader" , 99 , -1 };
17601G__linked_taginfo G__BesVisLib_rootcintLN_TArc = { "TArc" , 99 , -1 };
17602G__linked_taginfo G__BesVisLib_rootcintLN_TImage = { "TImage" , 99 , -1 };
17603G__linked_taginfo G__BesVisLib_rootcintLN_BesVisDisplay = { "BesVisDisplay" , 99 , -1 };
17604G__linked_taginfo G__BesVisLib_rootcintLN_EZHelixRangeType = { "EZHelixRangeType" , 101 , -1 };
17605G__linked_taginfo G__BesVisLib_rootcintLN_TrackType = { "TrackType" , 101 , -1 };
17606G__linked_taginfo G__BesVisLib_rootcintLN_ZHelix = { "ZHelix" , 99 , -1 };
17607G__linked_taginfo G__BesVisLib_rootcintLN_vector3 = { "vector3" , 115 , -1 };
17608
17609/* Reset class/struct taginfo */
17610extern "C" void G__cpp_reset_tagtableBesVisLib_rootcint() {
17611 G__BesVisLib_rootcintLN_TClass.tagnum = -1 ;
17612 G__BesVisLib_rootcintLN_TBuffer.tagnum = -1 ;
17613 G__BesVisLib_rootcintLN_TMemberInspector.tagnum = -1 ;
17614 G__BesVisLib_rootcintLN_TObject.tagnum = -1 ;
17615 G__BesVisLib_rootcintLN_TNamed.tagnum = -1 ;
17616 G__BesVisLib_rootcintLN_TString.tagnum = -1 ;
17617 G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
17618 G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
17619 G__BesVisLib_rootcintLN_string.tagnum = -1 ;
17620 G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
17621 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
17622 G__BesVisLib_rootcintLN_TList.tagnum = -1 ;
17623 G__BesVisLib_rootcintLN_TObjArray.tagnum = -1 ;
17624 G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
17625 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17626 G__BesVisLib_rootcintLN_EBESViewType.tagnum = -1 ;
17627 G__BesVisLib_rootcintLN_BesStatus.tagnum = -1 ;
17628 G__BesVisLib_rootcintLN_TAttLine.tagnum = -1 ;
17629 G__BesVisLib_rootcintLN_TSeqCollection.tagnum = -1 ;
17630 G__BesVisLib_rootcintLN_TVirtualPad.tagnum = -1 ;
17631 G__BesVisLib_rootcintLN_TView.tagnum = -1 ;
17632 G__BesVisLib_rootcintLN_BesTView.tagnum = -1 ;
17633 G__BesVisLib_rootcintLN_BesTViewcLcLdA.tagnum = -1 ;
17634 G__BesVisLib_rootcintLN_TPaveLabel.tagnum = -1 ;
17635 G__BesVisLib_rootcintLN_TPad.tagnum = -1 ;
17636 G__BesVisLib_rootcintLN_TCanvas.tagnum = -1 ;
17637 G__BesVisLib_rootcintLN_Bes2DView.tagnum = -1 ;
17638 G__BesVisLib_rootcintLN_TAttFill.tagnum = -1 ;
17639 G__BesVisLib_rootcintLN_BesCircle2D.tagnum = -1 ;
17640 G__BesVisLib_rootcintLN_EBESCursorType.tagnum = -1 ;
17641 G__BesVisLib_rootcintLN_BesCursor.tagnum = -1 ;
17642 G__BesVisLib_rootcintLN_BesEventHeader.tagnum = -1 ;
17643 G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
17644 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
17645 G__BesVisLib_rootcintLN_TBox.tagnum = -1 ;
17646 G__BesVisLib_rootcintLN_TPave.tagnum = -1 ;
17647 G__BesVisLib_rootcintLN_TAttText.tagnum = -1 ;
17648 G__BesVisLib_rootcintLN_TPaveText.tagnum = -1 ;
17649 G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
17650 G__BesVisLib_rootcintLN_TGeoAtt.tagnum = -1 ;
17651 G__BesVisLib_rootcintLN_TAttMarker.tagnum = -1 ;
17652 G__BesVisLib_rootcintLN_TVirtualGeoTrack.tagnum = -1 ;
17653 G__BesVisLib_rootcintLN_TAtt3D.tagnum = -1 ;
17654 G__BesVisLib_rootcintLN_TPolyLine3D.tagnum = -1 ;
17655 G__BesVisLib_rootcintLN_TGeoTrack.tagnum = -1 ;
17656 G__BesVisLib_rootcintLN_TMarker.tagnum = -1 ;
17657 G__BesVisLib_rootcintLN_BesView.tagnum = -1 ;
17658 G__BesVisLib_rootcintLN_BesMarker2D.tagnum = -1 ;
17659 G__BesVisLib_rootcintLN_BesPaveText.tagnum = -1 ;
17660 G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
17661 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
17662 G__BesVisLib_rootcintLN_BesGeoTrack.tagnum = -1 ;
17663 G__BesVisLib_rootcintLN_TMdcDigi.tagnum = -1 ;
17664 G__BesVisLib_rootcintLN_TEmcDigi.tagnum = -1 ;
17665 G__BesVisLib_rootcintLN_TTofDigi.tagnum = -1 ;
17666 G__BesVisLib_rootcintLN_TMucDigi.tagnum = -1 ;
17667 G__BesVisLib_rootcintLN_TDigiEvent.tagnum = -1 ;
17668 G__BesVisLib_rootcintLN_TRecMdcTrack.tagnum = -1 ;
17669 G__BesVisLib_rootcintLN_TRecTofTrack.tagnum = -1 ;
17670 G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
17671 G__BesVisLib_rootcintLN_TRecEmcShower.tagnum = -1 ;
17672 G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
17673 G__BesVisLib_rootcintLN_TRecMucTrack.tagnum = -1 ;
17674 G__BesVisLib_rootcintLN_TRecMdcDedx.tagnum = -1 ;
17675 G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
17676 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17677 G__BesVisLib_rootcintLN_TRecEvTime.tagnum = -1 ;
17678 G__BesVisLib_rootcintLN_pairlEintcOfloatgR.tagnum = -1 ;
17679 G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR.tagnum = -1 ;
17680 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17681 G__BesVisLib_rootcintLN_TEvtHeader.tagnum = -1 ;
17682 G__BesVisLib_rootcintLN_TDisTrack.tagnum = -1 ;
17683 G__BesVisLib_rootcintLN_TTrigEvent.tagnum = -1 ;
17684 G__BesVisLib_rootcintLN_BesEvent.tagnum = -1 ;
17685 G__BesVisLib_rootcintLN_Event_t.tagnum = -1 ;
17686 G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
17687 G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
17688 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17689 G__BesVisLib_rootcintLN_TQObject.tagnum = -1 ;
17690 G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR.tagnum = -1 ;
17691 G__BesVisLib_rootcintLN_TGeoMatrix.tagnum = -1 ;
17692 G__BesVisLib_rootcintLN_TGeoVolume.tagnum = -1 ;
17693 G__BesVisLib_rootcintLN_TGeoShape.tagnum = -1 ;
17694 G__BesVisLib_rootcintLN_TGeoNode.tagnum = -1 ;
17695 G__BesVisLib_rootcintLN_TGeoVolumeAssembly.tagnum = -1 ;
17696 G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR.tagnum = -1 ;
17697 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17698 G__BesVisLib_rootcintLN_TGeoPhysicalNode.tagnum = -1 ;
17699 G__BesVisLib_rootcintLN_ProcessingConfigurator.tagnum = -1 ;
17700 G__BesVisLib_rootcintLN_SAXProcessor.tagnum = -1 ;
17701 G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR.tagnum = -1 ;
17702 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR.tagnum = -1 ;
17703 G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR.tagnum = -1 ;
17704 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17705 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR.tagnum = -1 ;
17706 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR.tagnum = -1 ;
17707 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR.tagnum = -1 ;
17708 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR.tagnum = -1 ;
17709 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR.tagnum = -1 ;
17710 G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR.tagnum = -1 ;
17711 G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR.tagnum = -1 ;
17712 G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR.tagnum = -1 ;
17713 G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR.tagnum = -1 ;
17714 G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR.tagnum = -1 ;
17715 G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR.tagnum = -1 ;
17716 G__BesVisLib_rootcintLN_SubDetectorROOTGeo.tagnum = -1 ;
17717 G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
17718 G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
17719 G__BesVisLib_rootcintLN_TVectorTlEfloatgR.tagnum = -1 ;
17720 G__BesVisLib_rootcintLN_TVectorTlEdoublegR.tagnum = -1 ;
17721 G__BesVisLib_rootcintLN_TElementActionTlEfloatgR.tagnum = -1 ;
17722 G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
17723 G__BesVisLib_rootcintLN_TMatrixTlEfloatgR.tagnum = -1 ;
17724 G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
17725 G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
17726 G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
17727 G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
17728 G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
17729 G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
17730 G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
17731 G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
17732 G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
17733 G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
17734 G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
17735 G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
17736 G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
17737 G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
17738 G__BesVisLib_rootcintLN_BesPolygon2D.tagnum = -1 ;
17739 G__BesVisLib_rootcintLN_Mdc2DWire.tagnum = -1 ;
17740 G__BesVisLib_rootcintLN_MdcROOTGeo.tagnum = -1 ;
17741 G__BesVisLib_rootcintLN_Tof2DScin.tagnum = -1 ;
17742 G__BesVisLib_rootcintLN_TofROOTGeo.tagnum = -1 ;
17743 G__BesVisLib_rootcintLN_Emc2DCrystal.tagnum = -1 ;
17744 G__BesVisLib_rootcintLN_EmcROOTGeo.tagnum = -1 ;
17745 G__BesVisLib_rootcintLN_Muc2DStrip.tagnum = -1 ;
17746 G__BesVisLib_rootcintLN_MucROOTGeo.tagnum = -1 ;
17747 G__BesVisLib_rootcintLN_BesGeometry.tagnum = -1 ;
17748 G__BesVisLib_rootcintLN_TGObject.tagnum = -1 ;
17749 G__BesVisLib_rootcintLN_TGWindow.tagnum = -1 ;
17750 G__BesVisLib_rootcintLN_TGPicture.tagnum = -1 ;
17751 G__BesVisLib_rootcintLN_TGFrame.tagnum = -1 ;
17752 G__BesVisLib_rootcintLN_TGCompositeFrame.tagnum = -1 ;
17753 G__BesVisLib_rootcintLN_TGLayoutHints.tagnum = -1 ;
17754 G__BesVisLib_rootcintLN_TGHotString.tagnum = -1 ;
17755 G__BesVisLib_rootcintLN_TGHorizontalFrame.tagnum = -1 ;
17756 G__BesVisLib_rootcintLN_TGWidget.tagnum = -1 ;
17757 G__BesVisLib_rootcintLN_TGPopupMenu.tagnum = -1 ;
17758 G__BesVisLib_rootcintLN_TGMenuBar.tagnum = -1 ;
17759 G__BesVisLib_rootcintLN_TGMenuTitle.tagnum = -1 ;
17760 G__BesVisLib_rootcintLN_BesGMenuTitle.tagnum = -1 ;
17761 G__BesVisLib_rootcintLN_BesGMenuBar.tagnum = -1 ;
17762 G__BesVisLib_rootcintLN_TGButton.tagnum = -1 ;
17763 G__BesVisLib_rootcintLN_TGPictureButton.tagnum = -1 ;
17764 G__BesVisLib_rootcintLN_BesGPictureButton.tagnum = -1 ;
17765 G__BesVisLib_rootcintLN_BesHeader.tagnum = -1 ;
17766 G__BesVisLib_rootcintLN_TArc.tagnum = -1 ;
17767 G__BesVisLib_rootcintLN_TImage.tagnum = -1 ;
17768 G__BesVisLib_rootcintLN_BesVisDisplay.tagnum = -1 ;
17769 G__BesVisLib_rootcintLN_EZHelixRangeType.tagnum = -1 ;
17770 G__BesVisLib_rootcintLN_TrackType.tagnum = -1 ;
17771 G__BesVisLib_rootcintLN_ZHelix.tagnum = -1 ;
17772 G__BesVisLib_rootcintLN_vector3.tagnum = -1 ;
17773}
17774
17775
17776extern "C" void G__cpp_setup_tagtableBesVisLib_rootcint() {
17777
17778 /* Setting up class,struct,union tag entry */
17779 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TClass);
17780 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TBuffer);
17781 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMemberInspector);
17782 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TObject);
17783 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TNamed);
17784 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TString);
17785 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
17786 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
17787 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_string);
17788 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
17789 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
17790 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TList);
17791 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TObjArray);
17792 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
17793 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
17794 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EBESViewType);
17795 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesStatus),sizeof(BesStatus),-1,292096,"Bes View Status",G__setup_memvarBesStatus,G__setup_memfuncBesStatus);
17796 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttLine);
17797 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TSeqCollection);
17798 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVirtualPad);
17799 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TView);
17800 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesTView),sizeof(BesTView),-1,130816,"3-D View",G__setup_memvarBesTView,G__setup_memfuncBesTView);
17801 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesTViewcLcLdA);
17802 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPaveLabel);
17803 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPad);
17804 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TCanvas);
17805 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Bes2DView),sizeof(Bes2DView),-1,324864,"Bes View",G__setup_memvarBes2DView,G__setup_memfuncBes2DView);
17806 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttFill);
17807 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesCircle2D),sizeof(BesCircle2D),-1,324864,"Circle in 2D",G__setup_memvarBesCircle2D,G__setup_memfuncBesCircle2D);
17808 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EBESCursorType);
17809 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesCursor),sizeof(BesCursor),-1,292096,"BesCursor",G__setup_memvarBesCursor,G__setup_memfuncBesCursor);
17810 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesEventHeader),sizeof(BesEventHeader),-1,292096,"Bes Event Header",G__setup_memvarBesEventHeader,G__setup_memfuncBesEventHeader);
17811 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR);
17812 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
17813 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TBox);
17814 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPave);
17815 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttText);
17816 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPaveText);
17817 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
17818 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoAtt);
17819 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttMarker);
17820 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVirtualGeoTrack);
17821 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAtt3D);
17822 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPolyLine3D);
17823 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoTrack);
17824 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMarker);
17825 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesView),sizeof(BesView),-1,324864,"BesVis View",G__setup_memvarBesView,G__setup_memfuncBesView);
17826 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesMarker2D),sizeof(BesMarker2D),-1,324864,"Bes 2D marker",G__setup_memvarBesMarker2D,G__setup_memfuncBesMarker2D);
17827 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesPaveText),sizeof(BesPaveText),-1,324352,"BesPaveText",G__setup_memvarBesPaveText,G__setup_memfuncBesPaveText);
17828 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR);
17829 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
17830 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGeoTrack),sizeof(BesGeoTrack),-1,324864,"BesGeoTrack",G__setup_memvarBesGeoTrack,G__setup_memfuncBesGeoTrack);
17831 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMdcDigi);
17832 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TEmcDigi);
17833 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TTofDigi);
17834 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMucDigi);
17835 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TDigiEvent);
17836 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMdcTrack);
17837 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecTofTrack);
17838 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
17839 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecEmcShower);
17840 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
17841 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMucTrack);
17842 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMdcDedx);
17843 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
17844 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
17845 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecEvTime);
17846 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_pairlEintcOfloatgR);
17847 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR);
17848 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR);
17849 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TEvtHeader);
17850 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TDisTrack);
17851 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TTrigEvent);
17852 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesEvent),sizeof(BesEvent),-1,292096,"BesVis Event",G__setup_memvarBesEvent,G__setup_memfuncBesEvent);
17853 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Event_t);
17854 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR);
17855 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
17856 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR);
17857 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TQObject);
17858 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR);
17859 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoMatrix);
17860 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoVolume);
17861 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoShape);
17862 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoNode);
17863 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoVolumeAssembly);
17864 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR);
17865 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR);
17866 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoPhysicalNode);
17867 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_ProcessingConfigurator);
17868 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_SAXProcessor);
17869 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR);
17870 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR);
17871 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR);
17872 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR);
17873 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR);
17874 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR);
17875 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR);
17876 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR);
17877 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR);
17878 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR);
17879 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR);
17880 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR);
17881 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR);
17882 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR);
17883 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR);
17884 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),sizeof(SubDetectorROOTGeo),-1,263424,(char*)NULL,G__setup_memvarSubDetectorROOTGeo,G__setup_memfuncSubDetectorROOTGeo);
17885 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR);
17886 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR);
17887 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVectorTlEfloatgR);
17888 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVectorTlEdoublegR);
17889 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TElementActionTlEfloatgR);
17890 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR);
17891 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTlEfloatgR);
17892 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR);
17893 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR);
17894 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR);
17895 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR);
17896 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR);
17897 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR);
17898 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR);
17899 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR);
17900 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR);
17901 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR);
17902 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR);
17903 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR);
17904 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR);
17905 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR);
17906 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesPolygon2D),sizeof(BesPolygon2D),-1,324864,"Polygon in 2D",G__setup_memvarBesPolygon2D,G__setup_memfuncBesPolygon2D);
17907 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Mdc2DWire),sizeof(Mdc2DWire),-1,324864,"Mdc 2D Wire",G__setup_memvarMdc2DWire,G__setup_memfuncMdc2DWire);
17908 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_MdcROOTGeo),sizeof(MdcROOTGeo),-1,263424,(char*)NULL,G__setup_memvarMdcROOTGeo,G__setup_memfuncMdcROOTGeo);
17909 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Tof2DScin),sizeof(Tof2DScin),-1,324864,"Tof 2D Scin",G__setup_memvarTof2DScin,G__setup_memfuncTof2DScin);
17910 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TofROOTGeo),sizeof(TofROOTGeo),-1,263424,(char*)NULL,G__setup_memvarTofROOTGeo,G__setup_memfuncTofROOTGeo);
17911 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Emc2DCrystal),sizeof(Emc2DCrystal),-1,324864,"Emc 2D Crystal",G__setup_memvarEmc2DCrystal,G__setup_memfuncEmc2DCrystal);
17912 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EmcROOTGeo),sizeof(EmcROOTGeo),-1,263424,(char*)NULL,G__setup_memvarEmcROOTGeo,G__setup_memfuncEmcROOTGeo);
17913 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Muc2DStrip),sizeof(Muc2DStrip),-1,324864,"Muc 2D Strip",G__setup_memvarMuc2DStrip,G__setup_memfuncMuc2DStrip);
17914 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_MucROOTGeo),sizeof(MucROOTGeo),-1,263424,(char*)NULL,G__setup_memvarMucROOTGeo,G__setup_memfuncMucROOTGeo);
17915 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGeometry),sizeof(BesGeometry),-1,292096,"Bes Geometry",G__setup_memvarBesGeometry,G__setup_memfuncBesGeometry);
17916 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGObject);
17917 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGWindow);
17918 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPicture);
17919 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGFrame);
17920 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGCompositeFrame);
17921 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGLayoutHints);
17922 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGHotString);
17923 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGHorizontalFrame);
17924 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGWidget);
17925 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPopupMenu);
17926 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGMenuBar);
17927 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGMenuTitle);
17928 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGMenuTitle),sizeof(BesGMenuTitle),-1,323840,"Menu title class",G__setup_memvarBesGMenuTitle,G__setup_memfuncBesGMenuTitle);
17929 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGMenuBar),sizeof(BesGMenuBar),-1,323840,"Menu bar class",G__setup_memvarBesGMenuBar,G__setup_memfuncBesGMenuBar);
17930 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGButton);
17931 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPictureButton);
17932 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGPictureButton),sizeof(BesGPictureButton),-1,323840,"BesGPictureButton",G__setup_memvarBesGPictureButton,G__setup_memfuncBesGPictureButton);
17933 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesHeader),sizeof(BesHeader),-1,324864,"BesVis Header",G__setup_memvarBesHeader,G__setup_memfuncBesHeader);
17934 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TArc);
17935 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TImage);
17936 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesVisDisplay),sizeof(BesVisDisplay),-1,296192,"Utility class to display ATLAS outline, tracks, clusters, jets,..",G__setup_memvarBesVisDisplay,G__setup_memfuncBesVisDisplay);
17937 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EZHelixRangeType);
17938 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TrackType);
17939 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_ZHelix),sizeof(ZHelix),-1,324864,"ZeVis Helix",G__setup_memvarZHelix,G__setup_memfuncZHelix);
17940 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vector3),sizeof(vector3),-1,262144,(char*)NULL,G__setup_memvarvector3,G__setup_memfuncvector3);
17941}
17942extern "C" void G__cpp_setupBesVisLib_rootcint(void) {
17943 G__check_setup_version(30051515,"G__cpp_setupBesVisLib_rootcint()");
17944 G__set_cpp_environmentBesVisLib_rootcint();
17945 G__cpp_setup_tagtableBesVisLib_rootcint();
17946
17947 G__cpp_setup_inheritanceBesVisLib_rootcint();
17948
17949 G__cpp_setup_typetableBesVisLib_rootcint();
17950
17951 G__cpp_setup_memvarBesVisLib_rootcint();
17952
17953 G__cpp_setup_memfuncBesVisLib_rootcint();
17954 G__cpp_setup_globalBesVisLib_rootcint();
17955 G__cpp_setup_funcBesVisLib_rootcint();
17956
17957 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncBesVisLib_rootcint();
17958 return;
17959}
17960class G__cpp_setup_initBesVisLib_rootcint {
17961 public:
17962 G__cpp_setup_initBesVisLib_rootcint() { G__add_setup_func("BesVisLib_rootcint",(G__incsetup)(&G__cpp_setupBesVisLib_rootcint)); G__call_setup_funcs(); }
17963 ~G__cpp_setup_initBesVisLib_rootcint() { G__remove_setup_func("BesVisLib_rootcint"); }
17964};
17965G__cpp_setup_initBesVisLib_rootcint G__cpp_setup_initializerBesVisLib_rootcint;
17966
n
const Int_t n
Definition: DataBase/tau_mode.c:65
data
TTree * data
Definition: DataBase/tau_mode.c:5
x
Double_t x[10]
Definition: DataBase/tau_mode.c:57
G__BesVisLib_rootcintLN_BesTView
G__linked_taginfo G__BesVisLib_rootcintLN_BesTView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17467
G__BesVisLib_rootcintLN_BesGeoTrack
G__linked_taginfo G__BesVisLib_rootcintLN_BesGeoTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17497
G__BesVisLib_rootcintLN_TofROOTGeo
G__linked_taginfo G__BesVisLib_rootcintLN_TofROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17577
G__TBesGeoTrack
BesGeoTrack G__TBesGeoTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:7209
G__BesVisLib_rootcintLN_TMatrixTlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17558
G__BesVisLib_rootcintLN_TImage
G__linked_taginfo G__BesVisLib_rootcintLN_TImage
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17602
G__TBesGMenuBar
BesGMenuBar G__TBesGMenuBar
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:11701
G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17572
G__TBesVisDisplay
BesVisDisplay G__TBesVisDisplay
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13095
G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17569
G__BesVisLib_rootcintLN_Tof2DScin
G__linked_taginfo G__BesVisLib_rootcintLN_Tof2DScin
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17576
G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17538
G__BesVisLib_rootcintLN_Muc2DStrip
G__linked_taginfo G__BesVisLib_rootcintLN_Muc2DStrip
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17580
G__cpp_reset_tagtableBesVisLib_rootcint
void G__cpp_reset_tagtableBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17610
G__BesVisLib_rootcintLN_TDigiEvent
G__linked_taginfo G__BesVisLib_rootcintLN_TDigiEvent
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17502
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17496
G__BesVisLib_rootcintLN_BesGPictureButton
G__linked_taginfo G__BesVisLib_rootcintLN_BesGPictureButton
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17599
G__TBes2DView
Bes2DView G__TBes2DView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:4661
G__cpp_setupBesVisLib_rootcint
void G__cpp_setupBesVisLib_rootcint(void)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17942
G__BesVisLib_rootcintLN_TGHotString
G__linked_taginfo G__BesVisLib_rootcintLN_TGHotString
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17589
G__BesVisLib_rootcintLN_TDisTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TDisTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17517
G__BesVisLib_rootcintLN_Event_t
G__linked_taginfo G__BesVisLib_rootcintLN_Event_t
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17520
G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17548
G__TBesMarker2D
BesMarker2D G__TBesMarker2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:6771
G__TBesPaveText
BesPaveText G__TBesPaveText
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:6970
G__BesVisLib_rootcintLN_TVectorTlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17554
G__BesVisLib_rootcintLN_TRecMdcTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17503
G__BesVisLib_rootcintLN_TRecMucTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TRecMucTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17508
G__TBesGPictureButton
BesGPictureButton G__TBesGPictureButton
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:12021
G__BesVisLib_rootcintLN_TRecTofTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TRecTofTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17504
G__TTof2DScin
Tof2DScin G__TTof2DScin
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:9122
G__TBesCircle2D
BesCircle2D G__TBesCircle2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:4838
G__TEmc2DCrystal
Emc2DCrystal G__TEmc2DCrystal
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:9833
G__BesVisLib_rootcintLN_TSeqCollection
G__linked_taginfo G__BesVisLib_rootcintLN_TSeqCollection
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17464
G__cpp_setup_globalBesVisLib_rootcint
void G__cpp_setup_globalBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17320
G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17514
G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17531
G__BesVisLib_rootcintLN_TPaveText
G__linked_taginfo G__BesVisLib_rootcintLN_TPaveText
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17483
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17456
G__BesVisLib_rootcintLN_ZHelix
G__linked_taginfo G__BesVisLib_rootcintLN_ZHelix
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17606
G__BesVisLib_rootcintLN_pairlEintcOfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_pairlEintcOfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17513
G__TTofROOTGeo
TofROOTGeo G__TTofROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:9510
G__BesVisLib_rootcintLN_TAttFill
G__linked_taginfo G__BesVisLib_rootcintLN_TAttFill
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17473
G__cpp_dllrevBesVisLib_rootcint
int G__cpp_dllrevBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3913
G__BesVisLib_rootcintLN_TGMenuBar
G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuBar
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17593
G__BesVisLib_rootcintLN_TGFrame
G__linked_taginfo G__BesVisLib_rootcintLN_TGFrame
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17586
G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17560
G__BesVisLib_rootcintLN_TAttText
G__linked_taginfo G__BesVisLib_rootcintLN_TAttText
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17482
G__BesVisLib_rootcintLN_TRecEmcShower
G__linked_taginfo G__BesVisLib_rootcintLN_TRecEmcShower
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17506
G__BesVisLib_rootcintLN_TGeoVolume
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolume
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17527
G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR
G__linked_taginfo G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17521
G__cpp_setup_inheritanceBesVisLib_rootcint
void G__cpp_setup_inheritanceBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13648
G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17567
G__BesVisLib_rootcintLN_TAttMarker
G__linked_taginfo G__BesVisLib_rootcintLN_TAttMarker
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17486
G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17510
G__BesVisLib_rootcintLN_TVirtualGeoTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualGeoTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17487
G__BesVisLib_rootcintLN_BesGMenuBar
G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuBar
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17596
G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17568
G__BesVisLib_rootcintLN_BesEvent
G__linked_taginfo G__BesVisLib_rootcintLN_BesEvent
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17519
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17532
G__BesVisLib_rootcintLN_TCanvas
G__linked_taginfo G__BesVisLib_rootcintLN_TCanvas
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17471
G__BesVisLib_rootcintLN_TGPopupMenu
G__linked_taginfo G__BesVisLib_rootcintLN_TGPopupMenu
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17592
G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17453
G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17561
G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17545
G__BesVisLib_rootcintLN_TGHorizontalFrame
G__linked_taginfo G__BesVisLib_rootcintLN_TGHorizontalFrame
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17590
G__cpp_setup_memvarBesVisLib_rootcint
void G__cpp_setup_memvarBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:15293
G__BesVisLib_rootcintLN_TGWindow
G__linked_taginfo G__BesVisLib_rootcintLN_TGWindow
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17584
G__BesVisLib_rootcintLN_BesPaveText
G__linked_taginfo G__BesVisLib_rootcintLN_BesPaveText
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17494
G__BesVisLib_rootcintLN_BesGMenuTitle
G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuTitle
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17595
G__BesVisLib_rootcintLN_TBuffer
G__linked_taginfo G__BesVisLib_rootcintLN_TBuffer
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17447
G__BesVisLib_rootcintLN_TPaveLabel
G__linked_taginfo G__BesVisLib_rootcintLN_TPaveLabel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17469
G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17544
G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17540
G__cpp_setup_initializerBesVisLib_rootcint
G__cpp_setup_initBesVisLib_rootcint G__cpp_setup_initializerBesVisLib_rootcint
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17965
G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17562
G__BesVisLib_rootcintLN_TPad
G__linked_taginfo G__BesVisLib_rootcintLN_TPad
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17470
G__BesVisLib_rootcintLN_TGeoShape
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoShape
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17528
G__BesVisLib_rootcintLN_TEvtHeader
G__linked_taginfo G__BesVisLib_rootcintLN_TEvtHeader
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17516
G__BesVisLib_rootcintLN_EZHelixRangeType
G__linked_taginfo G__BesVisLib_rootcintLN_EZHelixRangeType
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17604
G__BesVisLib_rootcintLN_TEmcDigi
G__linked_taginfo G__BesVisLib_rootcintLN_TEmcDigi
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17499
G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17495
G__BesVisLib_rootcintLN_TMucDigi
G__linked_taginfo G__BesVisLib_rootcintLN_TMucDigi
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17501
G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17553
G__BesVisLib_rootcintLN_TElementActionTlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TElementActionTlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17556
G__BesVisLib_rootcintLN_TPolyLine3D
G__linked_taginfo G__BesVisLib_rootcintLN_TPolyLine3D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17489
G__BesVisLib_rootcintLN_Bes2DView
G__linked_taginfo G__BesVisLib_rootcintLN_Bes2DView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17472
G__BesVisLib_rootcintLN_Mdc2DWire
G__linked_taginfo G__BesVisLib_rootcintLN_Mdc2DWire
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17574
G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17565
G__BesVisLib_rootcintLN_EmcROOTGeo
G__linked_taginfo G__BesVisLib_rootcintLN_EmcROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17579
G__TBesPolygon2D
BesPolygon2D G__TBesPolygon2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:8102
G__TBesGeometry
BesGeometry G__TBesGeometry
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:11314
G__cpp_setup_funcBesVisLib_rootcint
void G__cpp_setup_funcBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17414
G__BesVisLib_rootcintLN_TGButton
G__linked_taginfo G__BesVisLib_rootcintLN_TGButton
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17597
G__BesVisLib_rootcintLN_EBESViewType
G__linked_taginfo G__BesVisLib_rootcintLN_EBESViewType
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17461
G__TZHelix
ZHelix G__TZHelix
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13414
G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17507
G__BesVisLib_rootcintLN_TGeoMatrix
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoMatrix
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17526
G__cpp_setup_memfuncBesVisLib_rootcint
void G__cpp_setup_memfuncBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17282
G__BesVisLib_rootcintLN_string
G__linked_taginfo G__BesVisLib_rootcintLN_string
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17454
G__TBesGMenuTitle
BesGMenuTitle G__TBesGMenuTitle
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:11531
G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17546
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17523
G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17536
G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
G__linked_taginfo G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17484
G__BesVisLib_rootcintLN_TVirtualPad
G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualPad
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17465
G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17557
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17479
G__TEmcROOTGeo
EmcROOTGeo G__TEmcROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:10225
G__TBesEvent
BesEvent G__TBesEvent
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:7707
G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17550
G__BesVisLib_rootcintLN_TGLayoutHints
G__linked_taginfo G__BesVisLib_rootcintLN_TGLayoutHints
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17588
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17511
G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17541
G__BesVisLib_rootcintLN_TGeoVolumeAssembly
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolumeAssembly
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17530
G__BesVisLib_rootcintLN_TTofDigi
G__linked_taginfo G__BesVisLib_rootcintLN_TTofDigi
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17500
G__BesVisLib_rootcintLN_BesEventHeader
G__linked_taginfo G__BesVisLib_rootcintLN_BesEventHeader
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17477
G__cpp_setup_tagtableBesVisLib_rootcint
void G__cpp_setup_tagtableBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17776
G__BesVisLib_rootcintLN_Emc2DCrystal
G__linked_taginfo G__BesVisLib_rootcintLN_Emc2DCrystal
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17578
G__TMucROOTGeo
MucROOTGeo G__TMucROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:10905
G__TBesStatus
BesStatus G__TBesStatus
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:4140
G__BesVisLib_rootcintLN_TList
G__linked_taginfo G__BesVisLib_rootcintLN_TList
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17457
G__BesVisLib_rootcintLN_BesTViewcLcLdA
G__linked_taginfo G__BesVisLib_rootcintLN_BesTViewcLcLdA
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17468
G__BesVisLib_rootcintLN_TrackType
G__linked_taginfo G__BesVisLib_rootcintLN_TrackType
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17605
G__TBesHeader
BesHeader G__TBesHeader
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:12257
G__BesVisLib_rootcintLN_ProcessingConfigurator
G__linked_taginfo G__BesVisLib_rootcintLN_ProcessingConfigurator
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17534
G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17542
G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17452
G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17566
G__BesVisLib_rootcintLN_TAtt3D
G__linked_taginfo G__BesVisLib_rootcintLN_TAtt3D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17488
G__BesVisLib_rootcintLN_TGObject
G__linked_taginfo G__BesVisLib_rootcintLN_TGObject
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17583
G__BesVisLib_rootcintLN_TGeoPhysicalNode
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoPhysicalNode
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17533
G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17547
G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17525
G__get_sizep2memfuncBesVisLib_rootcint
size_t G__get_sizep2memfuncBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13631
G__TMdc2DWire
Mdc2DWire G__TMdc2DWire
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:8464
G__BesVisLib_rootcintLN_TObject
G__linked_taginfo G__BesVisLib_rootcintLN_TObject
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17449
G__BesVisLib_rootcintLN_TString
G__linked_taginfo G__BesVisLib_rootcintLN_TString
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17451
G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17552
G__TBesView
BesView G__TBesView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:6526
G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17459
G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17543
G__TMdcROOTGeo
MdcROOTGeo G__TMdcROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:8814
G__BesVisLib_rootcintLN_TClass
G__linked_taginfo G__BesVisLib_rootcintLN_TClass
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17446
G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17455
G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17549
G__BesVisLib_rootcintLN_TArc
G__linked_taginfo G__BesVisLib_rootcintLN_TArc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17601
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17537
G__BesVisLib_rootcintLN_BesStatus
G__linked_taginfo G__BesVisLib_rootcintLN_BesStatus
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17462
G__TBesTView
BesTView G__TBesTView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:4366
G__TSubDetectorROOTGeo
SubDetectorROOTGeo G__TSubDetectorROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:7858
G__TBesCursor
BesCursor G__TBesCursor
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:5008
G__BesVisLib_rootcintLN_TVectorTlEdoublegR
G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEdoublegR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17555
G__BesVisLib_rootcintLN_TMemberInspector
G__linked_taginfo G__BesVisLib_rootcintLN_TMemberInspector
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17448
G__BesVisLib_rootcintLN_TQObject
G__linked_taginfo G__BesVisLib_rootcintLN_TQObject
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17524
G__BesVisLib_rootcintLN_BesGeometry
G__linked_taginfo G__BesVisLib_rootcintLN_BesGeometry
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17582
G__BesVisLib_rootcintLN_TObjArray
G__linked_taginfo G__BesVisLib_rootcintLN_TObjArray
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17458
G__BesVisLib_rootcintLN_TTrigEvent
G__linked_taginfo G__BesVisLib_rootcintLN_TTrigEvent
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17518
G__TMuc2DStrip
Muc2DStrip G__TMuc2DStrip
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:10494
G__TBesEventHeader
BesEventHeader G__TBesEventHeader
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:5376
G__cpp_setup_typetableBesVisLib_rootcint
void G__cpp_setup_typetableBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:14144
G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17505
G__BesVisLib_rootcintLN_EBESCursorType
G__linked_taginfo G__BesVisLib_rootcintLN_EBESCursorType
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17475
G__BesVisLib_rootcintLN_BesCircle2D
G__linked_taginfo G__BesVisLib_rootcintLN_BesCircle2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17474
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17515
G__BesVisLib_rootcintLN_BesVisDisplay
G__linked_taginfo G__BesVisLib_rootcintLN_BesVisDisplay
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17603
G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17571
G__BesVisLib_rootcintLN_MucROOTGeo
G__linked_taginfo G__BesVisLib_rootcintLN_MucROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17581
G__BesVisLib_rootcintLN_TGeoTrack
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoTrack
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17490
G__BesVisLib_rootcintLN_BesHeader
G__linked_taginfo G__BesVisLib_rootcintLN_BesHeader
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17600
G__set_cpp_environmentBesVisLib_rootcint
void G__set_cpp_environmentBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3877
G__BesVisLib_rootcintLN_vector3
G__linked_taginfo G__BesVisLib_rootcintLN_vector3
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17607
G__BesVisLib_rootcintLN_SAXProcessor
G__linked_taginfo G__BesVisLib_rootcintLN_SAXProcessor
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17535
G__BesVisLib_rootcintLN_BesView
G__linked_taginfo G__BesVisLib_rootcintLN_BesView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17492
G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17559
G__BesVisLib_rootcintLN_TGeoNode
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoNode
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17529
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17539
G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17478
G__BesVisLib_rootcintLN_BesPolygon2D
G__linked_taginfo G__BesVisLib_rootcintLN_BesPolygon2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17573
G__BesVisLib_rootcintLN_TRecEvTime
G__linked_taginfo G__BesVisLib_rootcintLN_TRecEvTime
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17512
G__BesVisLib_rootcintLN_BesMarker2D
G__linked_taginfo G__BesVisLib_rootcintLN_BesMarker2D
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17493
G__BesVisLib_rootcintLN_TGWidget
G__linked_taginfo G__BesVisLib_rootcintLN_TGWidget
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17591
G__BesVisLib_rootcintLN_MdcROOTGeo
G__linked_taginfo G__BesVisLib_rootcintLN_MdcROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17575
G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17570
G__BesVisLib_rootcintLN_TMarker
G__linked_taginfo G__BesVisLib_rootcintLN_TMarker
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17491
G__BesVisLib_rootcintLN_TPave
G__linked_taginfo G__BesVisLib_rootcintLN_TPave
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17481
G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17564
G__BesVisLib_rootcintLN_TGCompositeFrame
G__linked_taginfo G__BesVisLib_rootcintLN_TGCompositeFrame
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17587
G__BesVisLib_rootcintLN_TBox
G__linked_taginfo G__BesVisLib_rootcintLN_TBox
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17480
G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17460
G__BesVisLib_rootcintLN_TAttLine
G__linked_taginfo G__BesVisLib_rootcintLN_TAttLine
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17463
G__BesVisLib_rootcintLN_TGMenuTitle
G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuTitle
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17594
G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR
G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17563
G__BesVisLib_rootcintLN_TGPictureButton
G__linked_taginfo G__BesVisLib_rootcintLN_TGPictureButton
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17598
G__BesVisLib_rootcintLN_TGeoAtt
G__linked_taginfo G__BesVisLib_rootcintLN_TGeoAtt
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17485
G__BesVisLib_rootcintLN_TNamed
G__linked_taginfo G__BesVisLib_rootcintLN_TNamed
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17450
G__Tvector3
vector3 G__Tvector3
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13503
G__BesVisLib_rootcintLN_SubDetectorROOTGeo
G__linked_taginfo G__BesVisLib_rootcintLN_SubDetectorROOTGeo
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17551
G__BesVisLib_rootcintLN_TRecMdcDedx
G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcDedx
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17509
G__BesVisLib_rootcintLN_TMdcDigi
G__linked_taginfo G__BesVisLib_rootcintLN_TMdcDigi
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17498
G__BesVisLib_rootcintLN_BesCursor
G__linked_taginfo G__BesVisLib_rootcintLN_BesCursor
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17476
G__BesVisLib_rootcintLN_TGPicture
G__linked_taginfo G__BesVisLib_rootcintLN_TGPicture
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17585
G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR
G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17522
G__BesVisLib_rootcintLN_TView
G__linked_taginfo G__BesVisLib_rootcintLN_TView
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17466
G__cpp_setupBesVisLib_rootcint
void G__cpp_setupBesVisLib_rootcint(void)
Definition: InstallArea/include/BesVisLib/BesVisLib/BesVisLib_rootcint.cxx:17942
BesVisLib_rootcint.h
BesStatus::fTracksEmc
Bool_t fTracksEmc
visibility flag for Tof Tracks
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:121
BesStatus::fMucHitsEast
Bool_t fMucHitsEast
visibility flag for global Muc Hits
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:112
BesStatus::fTofHitsEast
Bool_t fTofHitsEast
visibility flag for global Tof Hits
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:97
BesStatus::fMucBarrel
Bool_t fMucBarrel
visivility flag for Muc east EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:65
BesStatus::fFull3DCgem
Bool_t fFull3DCgem
visivility flag for Muc strips
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:71
BesStatus::fTracksMdc
Bool_t fTracksMdc
visibility flag for global Tracks
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:119
BesStatus::fTofBarrel
Bool_t fTofBarrel
visibility flag for Tof east EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:50
BesStatus::fTracksExt
Bool_t fTracksExt
visibility flag for Muc Tracks
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:123
BesStatus::fMucStrips
Bool_t fMucStrips
visivility flag for Muc west EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:67
BesStatus::fAxis
Bool_t fAxis
visibility flag for ZRPlaneOnXY
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:81
BesStatus::fEmcHitsGlobal
Bool_t fEmcHitsGlobal
visibility flag for Tof Hits West
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:103
BesStatus::fMucHitsWest
Bool_t fMucHitsWest
visibility flag for Muc Hits Barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:114
BesStatus::fZRPlaneOnXY
Bool_t fZRPlaneOnXY
visibility flag for beam pipe
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:80
BesStatus::fMucWest
Bool_t fMucWest
visivility flag for Muc barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:66
BesStatus::fMucEast
Bool_t fMucEast
visivility flag for global Muc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:64
BesStatus::fMdcWires
Bool_t fMdcWires
visibility flag for Mdc main tubes
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:44
BesStatus::fFull3DMuc
Bool_t fFull3DMuc
visivility flag for full 3D Emc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:75
BesStatus::fEmcGlobal
Bool_t fEmcGlobal
visibility flag for Tof west EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:55
BesStatus::fTofHitsWest
Bool_t fTofHitsWest
visibility flag for Tof Hits Barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:99
BesStatus::fFull3DEmc
Bool_t fFull3DEmc
visivility flag for full 3D Tof
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:74
BesStatus::fTofHitsBarrel
Bool_t fTofHitsBarrel
visibility flag for Tof Hits East
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:98
BesStatus::fEmcWest
Bool_t fEmcWest
visivility flag for Emc barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:58
BesStatus::fTofWest
Bool_t fTofWest
visibility flag for Tof barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:51
BesStatus::fTofEast
Bool_t fTofEast
visibility flag for global Tof
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:49
BesStatus::fTofHitsGlobal
Bool_t fTofHitsGlobal
visibility flag for Mdc Hits
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:96
BesStatus::fEmcHitsBarrel
Bool_t fEmcHitsBarrel
visibility flag for Emc Hits East
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:105
BesStatus::fEmcEast
Bool_t fEmcEast
visivility flag for global Emc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:56
BesStatus::fMdcHits
Bool_t fMdcHits
visibility flag for global Mdc Hits
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:92
BesStatus::fMdcTubes
Bool_t fMdcTubes
visibility flag for global Mdc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:43
BesStatus::fEmcHitsSide
Bool_t fEmcHitsSide
visibility flag for Emc Hits West
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:107
BesStatus::fEmcHitsWest
Bool_t fEmcHitsWest
visibility flag for Emc Hits Barrel
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:106
BesStatus::fEmcSide
Bool_t fEmcSide
visivility flag for Emc west EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:59
BesStatus::fFull3DTof
Bool_t fFull3DTof
visivility flag for full 3D Mdc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:73
BesStatus::fTracksMuc
Bool_t fTracksMuc
visibility flag for Emc Tracks
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:122
BesStatus::fTofGlobal
Bool_t fTofGlobal
visibility flag for Mdc wires
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:48
BesStatus::fBeamPipe
Bool_t fBeamPipe
visivility flag for full 3D Muc
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:79
BesStatus::fMucHitsBarrel
Bool_t fMucHitsBarrel
visibility flag for Muc Hits East
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:113
BesStatus::fEmcHitsEast
Bool_t fEmcHitsEast
visibility flag for global Emc Hits
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:104
BesStatus::fTracksTof
Bool_t fTracksTof
visibility flag for Mdc Tracks
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:120
BesStatus::fEmcBarrel
Bool_t fEmcBarrel
visivility flag for Emc east EC
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:57
BesStatus::fMucHitsGlobal
Bool_t fMucHitsGlobal
visibility flag for Emc Hits Side
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:111
BesStatus::fTracksGlobal
Bool_t fTracksGlobal
visibility flag for Muc Hits West
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesStatus.h:118
BesTView::AdjustPad
static void AdjustPad(TVirtualPad *pad=0)
Definition: BesTView.cxx:1668
G__Sizep2memfuncBesVisLib_rootcint
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13623
G__Sizep2memfuncBesVisLib_rootcint::sizep2memfunc
size_t sizep2memfunc()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13626
G__Sizep2memfuncBesVisLib_rootcint::G__Sizep2memfuncBesVisLib_rootcint
G__Sizep2memfuncBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:13625
G__cpp_setup_initBesVisLib_rootcint
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17960
G__cpp_setup_initBesVisLib_rootcint::G__cpp_setup_initBesVisLib_rootcint
G__cpp_setup_initBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17962
G__cpp_setup_initBesVisLib_rootcint::~G__cpp_setup_initBesVisLib_rootcint
~G__cpp_setup_initBesVisLib_rootcint()
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:17963
Draw
legend Draw()
ROOT::BesPaveText_ShowMembers
void BesPaveText_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::Tof2DScin_ShowMembers
void Tof2DScin_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesGPictureButton_ShowMembers
void BesGPictureButton_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesGMenuTitle_ShowMembers
void BesGMenuTitle_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::Emc2DCrystal_ShowMembers
void Emc2DCrystal_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::MucROOTGeo_ShowMembers
void MucROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3404
ROOT::BesStatus_ShowMembers
void BesStatus_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesEventHeader_ShowMembers
void BesEventHeader_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TofROOTGeo_ShowMembers
void TofROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3587
ROOT::BesCursor_ShowMembers
void BesCursor_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::SubDetectorROOTGeo_ShowMembers
void SubDetectorROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3463
ROOT::vectorlETStringgR_ShowMembers
void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesTView_ShowMembers
void BesTView_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::Bes2DView_ShowMembers
void Bes2DView_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::EmcROOTGeo_ShowMembers
void EmcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3116
ROOT::BesHeader_ShowMembers
void BesHeader_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::MdcROOTGeo_ShowMembers
void MdcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3273
ROOT::BesVisDisplay_ShowMembers
void BesVisDisplay_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesPolygon2D_ShowMembers
void BesPolygon2D_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesGMenuBar_ShowMembers
void BesGMenuBar_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesGeoTrack_ShowMembers
void BesGeoTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vector3_ShowMembers
void vector3_ShowMembers(void *obj, TMemberInspector &R__insp)
Definition: EventDisplay/BesVisLib/BesVisLib-00-05-04/BesVisLib/BesVisLib_rootcint.cxx:3642
ROOT::BesGeometry_ShowMembers
void BesGeometry_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::Mdc2DWire_ShowMembers
void Mdc2DWire_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::ZHelix_ShowMembers
void ZHelix_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::maplEintcOintgR_ShowMembers
void maplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::Muc2DStrip_ShowMembers
void Muc2DStrip_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_(Init))
ROOT::BesMarker2D_ShowMembers
void BesMarker2D_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesCircle2D_ShowMembers
void BesCircle2D_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesEvent_ShowMembers
void BesEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::BesView_ShowMembers
void BesView_ShowMembers(void *obj, TMemberInspector &R__insp)